xref: /freebsd/sys/fs/fuse/fuse_vnops.c (revision a521f2116473fbd8c09db395518f060a27d02334)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 2007-2009 Google Inc. and Amit Singh
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions are
9  * met:
10  *
11  * * Redistributions of source code must retain the above copyright
12  *   notice, this list of conditions and the following disclaimer.
13  * * Redistributions in binary form must reproduce the above
14  *   copyright notice, this list of conditions and the following disclaimer
15  *   in the documentation and/or other materials provided with the
16  *   distribution.
17  * * Neither the name of Google Inc. nor the names of its
18  *   contributors may be used to endorse or promote products derived from
19  *   this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  *
33  * Copyright (C) 2005 Csaba Henk.
34  * All rights reserved.
35  *
36  * Copyright (c) 2019 The FreeBSD Foundation
37  *
38  * Portions of this software were developed by BFF Storage Systems, LLC under
39  * sponsorship from the FreeBSD Foundation.
40  *
41  * Redistribution and use in source and binary forms, with or without
42  * modification, are permitted provided that the following conditions
43  * are met:
44  * 1. Redistributions of source code must retain the above copyright
45  *    notice, this list of conditions and the following disclaimer.
46  * 2. Redistributions in binary form must reproduce the above copyright
47  *    notice, this list of conditions and the following disclaimer in the
48  *    documentation and/or other materials provided with the distribution.
49  *
50  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
51  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
52  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
53  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
54  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
58  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
59  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
60  * SUCH DAMAGE.
61  */
62 
63 #include <sys/cdefs.h>
64 __FBSDID("$FreeBSD$");
65 
66 #include <sys/param.h>
67 #include <sys/module.h>
68 #include <sys/systm.h>
69 #include <sys/errno.h>
70 #include <sys/kernel.h>
71 #include <sys/conf.h>
72 #include <sys/uio.h>
73 #include <sys/malloc.h>
74 #include <sys/queue.h>
75 #include <sys/limits.h>
76 #include <sys/lock.h>
77 #include <sys/rwlock.h>
78 #include <sys/sx.h>
79 #include <sys/proc.h>
80 #include <sys/mount.h>
81 #include <sys/vnode.h>
82 #include <sys/namei.h>
83 #include <sys/extattr.h>
84 #include <sys/stat.h>
85 #include <sys/unistd.h>
86 #include <sys/filedesc.h>
87 #include <sys/file.h>
88 #include <sys/fcntl.h>
89 #include <sys/dirent.h>
90 #include <sys/bio.h>
91 #include <sys/buf.h>
92 #include <sys/sysctl.h>
93 #include <sys/vmmeter.h>
94 
95 #include <vm/vm.h>
96 #include <vm/vm_extern.h>
97 #include <vm/pmap.h>
98 #include <vm/vm_map.h>
99 #include <vm/vm_page.h>
100 #include <vm/vm_param.h>
101 #include <vm/vm_object.h>
102 #include <vm/vm_pager.h>
103 #include <vm/vnode_pager.h>
104 #include <vm/vm_object.h>
105 
106 #include "fuse.h"
107 #include "fuse_file.h"
108 #include "fuse_internal.h"
109 #include "fuse_ipc.h"
110 #include "fuse_node.h"
111 #include "fuse_io.h"
112 
113 #include <sys/priv.h>
114 
115 /* Maximum number of hardlinks to a single FUSE file */
116 #define FUSE_LINK_MAX                      UINT32_MAX
117 
118 SDT_PROVIDER_DECLARE(fusefs);
119 /*
120  * Fuse trace probe:
121  * arg0: verbosity.  Higher numbers give more verbose messages
122  * arg1: Textual message
123  */
124 SDT_PROBE_DEFINE2(fusefs, , vnops, trace, "int", "char*");
125 
126 /* vnode ops */
127 static vop_access_t fuse_vnop_access;
128 static vop_advlock_t fuse_vnop_advlock;
129 static vop_bmap_t fuse_vnop_bmap;
130 static vop_close_t fuse_fifo_close;
131 static vop_close_t fuse_vnop_close;
132 static vop_create_t fuse_vnop_create;
133 static vop_deleteextattr_t fuse_vnop_deleteextattr;
134 static vop_fdatasync_t fuse_vnop_fdatasync;
135 static vop_fsync_t fuse_vnop_fsync;
136 static vop_getattr_t fuse_vnop_getattr;
137 static vop_getextattr_t fuse_vnop_getextattr;
138 static vop_inactive_t fuse_vnop_inactive;
139 static vop_link_t fuse_vnop_link;
140 static vop_listextattr_t fuse_vnop_listextattr;
141 static vop_lookup_t fuse_vnop_lookup;
142 static vop_mkdir_t fuse_vnop_mkdir;
143 static vop_mknod_t fuse_vnop_mknod;
144 static vop_open_t fuse_vnop_open;
145 static vop_pathconf_t fuse_vnop_pathconf;
146 static vop_read_t fuse_vnop_read;
147 static vop_readdir_t fuse_vnop_readdir;
148 static vop_readlink_t fuse_vnop_readlink;
149 static vop_reclaim_t fuse_vnop_reclaim;
150 static vop_remove_t fuse_vnop_remove;
151 static vop_rename_t fuse_vnop_rename;
152 static vop_rmdir_t fuse_vnop_rmdir;
153 static vop_setattr_t fuse_vnop_setattr;
154 static vop_setextattr_t fuse_vnop_setextattr;
155 static vop_strategy_t fuse_vnop_strategy;
156 static vop_symlink_t fuse_vnop_symlink;
157 static vop_write_t fuse_vnop_write;
158 static vop_getpages_t fuse_vnop_getpages;
159 static vop_print_t fuse_vnop_print;
160 static vop_vptofh_t fuse_vnop_vptofh;
161 
162 struct vop_vector fuse_fifoops = {
163 	.vop_default =		&fifo_specops,
164 	.vop_access =		fuse_vnop_access,
165 	.vop_close =		fuse_fifo_close,
166 	.vop_fsync =		fuse_vnop_fsync,
167 	.vop_getattr =		fuse_vnop_getattr,
168 	.vop_inactive =		fuse_vnop_inactive,
169 	.vop_pathconf =		fuse_vnop_pathconf,
170 	.vop_print =		fuse_vnop_print,
171 	.vop_read =		VOP_PANIC,
172 	.vop_reclaim =		fuse_vnop_reclaim,
173 	.vop_setattr =		fuse_vnop_setattr,
174 	.vop_write =		VOP_PANIC,
175 	.vop_vptofh =		fuse_vnop_vptofh,
176 };
177 VFS_VOP_VECTOR_REGISTER(fuse_fifoops);
178 
179 struct vop_vector fuse_vnops = {
180 	.vop_allocate =	VOP_EINVAL,
181 	.vop_default = &default_vnodeops,
182 	.vop_access = fuse_vnop_access,
183 	.vop_advlock = fuse_vnop_advlock,
184 	.vop_bmap = fuse_vnop_bmap,
185 	.vop_close = fuse_vnop_close,
186 	.vop_create = fuse_vnop_create,
187 	.vop_deleteextattr = fuse_vnop_deleteextattr,
188 	.vop_fsync = fuse_vnop_fsync,
189 	.vop_fdatasync = fuse_vnop_fdatasync,
190 	.vop_getattr = fuse_vnop_getattr,
191 	.vop_getextattr = fuse_vnop_getextattr,
192 	.vop_inactive = fuse_vnop_inactive,
193 	/*
194 	 * TODO: implement vop_ioctl after upgrading to protocol 7.16.
195 	 * FUSE_IOCTL was added in 7.11, but 32-bit compat is broken until
196 	 * 7.16.
197 	 */
198 	.vop_link = fuse_vnop_link,
199 	.vop_listextattr = fuse_vnop_listextattr,
200 	.vop_lookup = fuse_vnop_lookup,
201 	.vop_mkdir = fuse_vnop_mkdir,
202 	.vop_mknod = fuse_vnop_mknod,
203 	.vop_open = fuse_vnop_open,
204 	.vop_pathconf = fuse_vnop_pathconf,
205 	/*
206 	 * TODO: implement vop_poll after upgrading to protocol 7.21.
207 	 * FUSE_POLL was added in protocol 7.11, but it's kind of broken until
208 	 * 7.21, which adds the ability for the client to choose which poll
209 	 * events it wants, and for a client to deregister a file handle
210 	 */
211 	.vop_read = fuse_vnop_read,
212 	.vop_readdir = fuse_vnop_readdir,
213 	.vop_readlink = fuse_vnop_readlink,
214 	.vop_reclaim = fuse_vnop_reclaim,
215 	.vop_remove = fuse_vnop_remove,
216 	.vop_rename = fuse_vnop_rename,
217 	.vop_rmdir = fuse_vnop_rmdir,
218 	.vop_setattr = fuse_vnop_setattr,
219 	.vop_setextattr = fuse_vnop_setextattr,
220 	.vop_strategy = fuse_vnop_strategy,
221 	.vop_symlink = fuse_vnop_symlink,
222 	.vop_write = fuse_vnop_write,
223 	.vop_getpages = fuse_vnop_getpages,
224 	.vop_print = fuse_vnop_print,
225 	.vop_vptofh = fuse_vnop_vptofh,
226 };
227 VFS_VOP_VECTOR_REGISTER(fuse_vnops);
228 
229 uma_zone_t fuse_pbuf_zone;
230 
231 /* Check permission for extattr operations, much like extattr_check_cred */
232 static int
233 fuse_extattr_check_cred(struct vnode *vp, int ns, struct ucred *cred,
234 	struct thread *td, accmode_t accmode)
235 {
236 	struct mount *mp = vnode_mount(vp);
237 	struct fuse_data *data = fuse_get_mpdata(mp);
238 	int default_permissions = data->dataflags & FSESS_DEFAULT_PERMISSIONS;
239 
240 	/*
241 	 * Kernel-invoked always succeeds.
242 	 */
243 	if (cred == NOCRED)
244 		return (0);
245 
246 	/*
247 	 * Do not allow privileged processes in jail to directly manipulate
248 	 * system attributes.
249 	 */
250 	switch (ns) {
251 	case EXTATTR_NAMESPACE_SYSTEM:
252 		if (default_permissions) {
253 			return (priv_check_cred(cred, PRIV_VFS_EXTATTR_SYSTEM));
254 		}
255 		return (0);
256 	case EXTATTR_NAMESPACE_USER:
257 		if (default_permissions) {
258 			return (fuse_internal_access(vp, accmode, td, cred));
259 		}
260 		return (0);
261 	default:
262 		return (EPERM);
263 	}
264 }
265 
266 /* Get a filehandle for a directory */
267 static int
268 fuse_filehandle_get_dir(struct vnode *vp, struct fuse_filehandle **fufhp,
269 	struct ucred *cred, pid_t pid)
270 {
271 	if (fuse_filehandle_get(vp, FREAD, fufhp, cred, pid) == 0)
272 		return 0;
273 	return fuse_filehandle_get(vp, FEXEC, fufhp, cred, pid);
274 }
275 
276 /* Send FUSE_FLUSH for this vnode */
277 static int
278 fuse_flush(struct vnode *vp, struct ucred *cred, pid_t pid, int fflag)
279 {
280 	struct fuse_flush_in *ffi;
281 	struct fuse_filehandle *fufh;
282 	struct fuse_dispatcher fdi;
283 	struct thread *td = curthread;
284 	struct mount *mp = vnode_mount(vp);
285 	int err;
286 
287 	if (!fsess_isimpl(vnode_mount(vp), FUSE_FLUSH))
288 		return 0;
289 
290 	err = fuse_filehandle_getrw(vp, fflag, &fufh, cred, pid);
291 	if (err)
292 		return err;
293 
294 	fdisp_init(&fdi, sizeof(*ffi));
295 	fdisp_make_vp(&fdi, FUSE_FLUSH, vp, td, cred);
296 	ffi = fdi.indata;
297 	ffi->fh = fufh->fh_id;
298 	/*
299 	 * If the file has a POSIX lock then we're supposed to set lock_owner.
300 	 * If not, then lock_owner is undefined.  So we may as well always set
301 	 * it.
302 	 */
303 	ffi->lock_owner = td->td_proc->p_pid;
304 
305 	err = fdisp_wait_answ(&fdi);
306 	if (err == ENOSYS) {
307 		fsess_set_notimpl(mp, FUSE_FLUSH);
308 		err = 0;
309 	}
310 	fdisp_destroy(&fdi);
311 	return err;
312 }
313 
314 /* Close wrapper for fifos.  */
315 static int
316 fuse_fifo_close(struct vop_close_args *ap)
317 {
318 	return (fifo_specops.vop_close(ap));
319 }
320 
321 /*
322     struct vnop_access_args {
323 	struct vnode *a_vp;
324 #if VOP_ACCESS_TAKES_ACCMODE_T
325 	accmode_t a_accmode;
326 #else
327 	int a_mode;
328 #endif
329 	struct ucred *a_cred;
330 	struct thread *a_td;
331     };
332 */
333 static int
334 fuse_vnop_access(struct vop_access_args *ap)
335 {
336 	struct vnode *vp = ap->a_vp;
337 	int accmode = ap->a_accmode;
338 	struct ucred *cred = ap->a_cred;
339 
340 	struct fuse_data *data = fuse_get_mpdata(vnode_mount(vp));
341 
342 	int err;
343 
344 	if (fuse_isdeadfs(vp)) {
345 		if (vnode_isvroot(vp)) {
346 			return 0;
347 		}
348 		return ENXIO;
349 	}
350 	if (!(data->dataflags & FSESS_INITED)) {
351 		if (vnode_isvroot(vp)) {
352 			if (priv_check_cred(cred, PRIV_VFS_ADMIN) ||
353 			    (fuse_match_cred(data->daemoncred, cred) == 0)) {
354 				return 0;
355 			}
356 		}
357 		return EBADF;
358 	}
359 	if (vnode_islnk(vp)) {
360 		return 0;
361 	}
362 
363 	err = fuse_internal_access(vp, accmode, ap->a_td, ap->a_cred);
364 	return err;
365 }
366 
367 /*
368  * struct vop_advlock_args {
369  *	struct vop_generic_args a_gen;
370  *	struct vnode *a_vp;
371  *	void *a_id;
372  *	int a_op;
373  *	struct flock *a_fl;
374  *	int a_flags;
375  * }
376  */
377 static int
378 fuse_vnop_advlock(struct vop_advlock_args *ap)
379 {
380 	struct vnode *vp = ap->a_vp;
381 	struct flock *fl = ap->a_fl;
382 	struct thread *td = curthread;
383 	struct ucred *cred = td->td_ucred;
384 	pid_t pid = td->td_proc->p_pid;
385 	struct fuse_filehandle *fufh;
386 	struct fuse_dispatcher fdi;
387 	struct fuse_lk_in *fli;
388 	struct fuse_lk_out *flo;
389 	enum fuse_opcode op;
390 	int dataflags, err;
391 	int flags = ap->a_flags;
392 
393 	dataflags = fuse_get_mpdata(vnode_mount(vp))->dataflags;
394 
395 	if (fuse_isdeadfs(vp)) {
396 		return ENXIO;
397 	}
398 
399 	if (!(dataflags & FSESS_POSIX_LOCKS))
400 		return vop_stdadvlock(ap);
401 	/* FUSE doesn't properly support flock until protocol 7.17 */
402 	if (flags & F_FLOCK)
403 		return vop_stdadvlock(ap);
404 
405 	err = fuse_filehandle_get_anyflags(vp, &fufh, cred, pid);
406 	if (err)
407 		return err;
408 
409 	fdisp_init(&fdi, sizeof(*fli));
410 
411 	switch(ap->a_op) {
412 	case F_GETLK:
413 		op = FUSE_GETLK;
414 		break;
415 	case F_SETLK:
416 		op = FUSE_SETLK;
417 		break;
418 	case F_SETLKW:
419 		op = FUSE_SETLKW;
420 		break;
421 	default:
422 		return EINVAL;
423 	}
424 
425 	fdisp_make_vp(&fdi, op, vp, td, cred);
426 	fli = fdi.indata;
427 	fli->fh = fufh->fh_id;
428 	fli->owner = fl->l_pid;
429 	fli->lk.start = fl->l_start;
430 	if (fl->l_len != 0)
431 		fli->lk.end = fl->l_start + fl->l_len - 1;
432 	else
433 		fli->lk.end = INT64_MAX;
434 	fli->lk.type = fl->l_type;
435 	fli->lk.pid = fl->l_pid;
436 
437 	err = fdisp_wait_answ(&fdi);
438 	fdisp_destroy(&fdi);
439 
440 	if (err == 0 && op == FUSE_GETLK) {
441 		flo = fdi.answ;
442 		fl->l_type = flo->lk.type;
443 		fl->l_pid = flo->lk.pid;
444 		if (flo->lk.type != F_UNLCK) {
445 			fl->l_start = flo->lk.start;
446 			if (flo->lk.end == INT64_MAX)
447 				fl->l_len = 0;
448 			else
449 				fl->l_len = flo->lk.end - flo->lk.start + 1;
450 			fl->l_start = flo->lk.start;
451 		}
452 	}
453 
454 	return err;
455 }
456 
457 /* {
458 	struct vnode *a_vp;
459 	daddr_t a_bn;
460 	struct bufobj **a_bop;
461 	daddr_t *a_bnp;
462 	int *a_runp;
463 	int *a_runb;
464 } */
465 static int
466 fuse_vnop_bmap(struct vop_bmap_args *ap)
467 {
468 	struct vnode *vp = ap->a_vp;
469 	struct bufobj **bo = ap->a_bop;
470 	struct thread *td = curthread;
471 	struct mount *mp;
472 	struct fuse_dispatcher fdi;
473 	struct fuse_bmap_in *fbi;
474 	struct fuse_bmap_out *fbo;
475 	struct fuse_data *data;
476 	uint64_t biosize;
477 	off_t filesize;
478 	daddr_t lbn = ap->a_bn;
479 	daddr_t *pbn = ap->a_bnp;
480 	int *runp = ap->a_runp;
481 	int *runb = ap->a_runb;
482 	int error = 0;
483 	int maxrun;
484 
485 	if (fuse_isdeadfs(vp)) {
486 		return ENXIO;
487 	}
488 
489 	mp = vnode_mount(vp);
490 	data = fuse_get_mpdata(mp);
491 	biosize = fuse_iosize(vp);
492 	maxrun = MIN(vp->v_mount->mnt_iosize_max / biosize - 1,
493 		data->max_readahead_blocks);
494 
495 	if (bo != NULL)
496 		*bo = &vp->v_bufobj;
497 
498 	/*
499 	 * The FUSE_BMAP operation does not include the runp and runb
500 	 * variables, so we must guess.  Report nonzero contiguous runs so
501 	 * cluster_read will combine adjacent reads.  It's worthwhile to reduce
502 	 * upcalls even if we don't know the true physical layout of the file.
503 	 *
504 	 * FUSE file systems may opt out of read clustering in two ways:
505 	 * * mounting with -onoclusterr
506 	 * * Setting max_readahead <= maxbcachebuf during FUSE_INIT
507 	 */
508 	if (runb != NULL)
509 		*runb = MIN(lbn, maxrun);
510 	if (runp != NULL) {
511 		error = fuse_vnode_size(vp, &filesize, td->td_ucred, td);
512 		if (error == 0)
513 			*runp = MIN(MAX(0, filesize / (off_t)biosize - lbn - 1),
514 				    maxrun);
515 		else
516 			*runp = 0;
517 	}
518 
519 	if (fsess_isimpl(mp, FUSE_BMAP)) {
520 		fdisp_init(&fdi, sizeof(*fbi));
521 		fdisp_make_vp(&fdi, FUSE_BMAP, vp, td, td->td_ucred);
522 		fbi = fdi.indata;
523 		fbi->block = lbn;
524 		fbi->blocksize = biosize;
525 		error = fdisp_wait_answ(&fdi);
526 		if (error == ENOSYS) {
527 			fdisp_destroy(&fdi);
528 			fsess_set_notimpl(mp, FUSE_BMAP);
529 			error = 0;
530 		} else {
531 			fbo = fdi.answ;
532 			if (error == 0 && pbn != NULL)
533 				*pbn = fbo->block;
534 			fdisp_destroy(&fdi);
535 			return error;
536 		}
537 	}
538 
539 	/* If the daemon doesn't support BMAP, make up a sensible default */
540 	if (pbn != NULL)
541 		*pbn = lbn * btodb(biosize);
542 	return (error);
543 }
544 
545 /*
546     struct vop_close_args {
547 	struct vnode *a_vp;
548 	int  a_fflag;
549 	struct ucred *a_cred;
550 	struct thread *a_td;
551     };
552 */
553 static int
554 fuse_vnop_close(struct vop_close_args *ap)
555 {
556 	struct vnode *vp = ap->a_vp;
557 	struct ucred *cred = ap->a_cred;
558 	int fflag = ap->a_fflag;
559 	struct thread *td = ap->a_td;
560 	pid_t pid = td->td_proc->p_pid;
561 	int err = 0;
562 
563 	if (fuse_isdeadfs(vp))
564 		return 0;
565 	if (vnode_isdir(vp))
566 		return 0;
567 	if (fflag & IO_NDELAY)
568 		return 0;
569 
570 	err = fuse_flush(vp, cred, pid, fflag);
571 	/* TODO: close the file handle, if we're sure it's no longer used */
572 	if ((VTOFUD(vp)->flag & FN_SIZECHANGE) != 0) {
573 		fuse_vnode_savesize(vp, cred, td->td_proc->p_pid);
574 	}
575 	return err;
576 }
577 
578 static void
579 fdisp_make_mknod_for_fallback(
580 	struct fuse_dispatcher *fdip,
581 	struct componentname *cnp,
582 	struct vnode *dvp,
583 	uint64_t parentnid,
584 	struct thread *td,
585 	struct ucred *cred,
586 	mode_t mode,
587 	enum fuse_opcode *op)
588 {
589 	struct fuse_mknod_in *fmni;
590 
591 	fdisp_init(fdip, sizeof(*fmni) + cnp->cn_namelen + 1);
592 	*op = FUSE_MKNOD;
593 	fdisp_make(fdip, *op, vnode_mount(dvp), parentnid, td, cred);
594 	fmni = fdip->indata;
595 	fmni->mode = mode;
596 	fmni->rdev = 0;
597 	memcpy((char *)fdip->indata + sizeof(*fmni), cnp->cn_nameptr,
598 	    cnp->cn_namelen);
599 	((char *)fdip->indata)[sizeof(*fmni) + cnp->cn_namelen] = '\0';
600 }
601 /*
602     struct vnop_create_args {
603 	struct vnode *a_dvp;
604 	struct vnode **a_vpp;
605 	struct componentname *a_cnp;
606 	struct vattr *a_vap;
607     };
608 */
609 static int
610 fuse_vnop_create(struct vop_create_args *ap)
611 {
612 	struct vnode *dvp = ap->a_dvp;
613 	struct vnode **vpp = ap->a_vpp;
614 	struct componentname *cnp = ap->a_cnp;
615 	struct vattr *vap = ap->a_vap;
616 	struct thread *td = cnp->cn_thread;
617 	struct ucred *cred = cnp->cn_cred;
618 
619 	struct fuse_data *data;
620 	struct fuse_create_in *fci;
621 	struct fuse_entry_out *feo;
622 	struct fuse_open_out *foo;
623 	struct fuse_dispatcher fdi, fdi2;
624 	struct fuse_dispatcher *fdip = &fdi;
625 	struct fuse_dispatcher *fdip2 = NULL;
626 
627 	int err;
628 
629 	struct mount *mp = vnode_mount(dvp);
630 	data = fuse_get_mpdata(mp);
631 	uint64_t parentnid = VTOFUD(dvp)->nid;
632 	mode_t mode = MAKEIMODE(vap->va_type, vap->va_mode);
633 	enum fuse_opcode op;
634 	int flags;
635 
636 	if (fuse_isdeadfs(dvp))
637 		return ENXIO;
638 
639 	/* FUSE expects sockets to be created with FUSE_MKNOD */
640 	if (vap->va_type == VSOCK)
641 		return fuse_internal_mknod(dvp, vpp, cnp, vap);
642 
643 	/*
644 	 * VOP_CREATE doesn't tell us the open(2) flags, so we guess.  Only a
645 	 * writable mode makes sense, and we might as well include readability
646 	 * too.
647 	 */
648 	flags = O_RDWR;
649 
650 	bzero(&fdi, sizeof(fdi));
651 
652 	if (vap->va_type != VREG)
653 		return (EINVAL);
654 
655 	if (!fsess_isimpl(mp, FUSE_CREATE) || vap->va_type == VSOCK) {
656 		/* Fallback to FUSE_MKNOD/FUSE_OPEN */
657 		fdisp_make_mknod_for_fallback(fdip, cnp, dvp, parentnid, td,
658 			cred, mode, &op);
659 	} else {
660 		/* Use FUSE_CREATE */
661 		size_t insize;
662 
663 		op = FUSE_CREATE;
664 		fdisp_init(fdip, sizeof(*fci) + cnp->cn_namelen + 1);
665 		fdisp_make(fdip, op, vnode_mount(dvp), parentnid, td, cred);
666 		fci = fdip->indata;
667 		fci->mode = mode;
668 		fci->flags = O_CREAT | flags;
669 		if (fuse_libabi_geq(data, 7, 12)) {
670 			insize = sizeof(*fci);
671 			fci->umask = td->td_proc->p_fd->fd_cmask;
672 		} else {
673 			insize = sizeof(struct fuse_open_in);
674 		}
675 
676 		memcpy((char *)fdip->indata + insize, cnp->cn_nameptr,
677 		    cnp->cn_namelen);
678 		((char *)fdip->indata)[insize + cnp->cn_namelen] = '\0';
679 	}
680 
681 	err = fdisp_wait_answ(fdip);
682 
683 	if (err) {
684 		if (err == ENOSYS && op == FUSE_CREATE) {
685 			fsess_set_notimpl(mp, FUSE_CREATE);
686 			fdisp_destroy(fdip);
687 			fdisp_make_mknod_for_fallback(fdip, cnp, dvp,
688 				parentnid, td, cred, mode, &op);
689 			err = fdisp_wait_answ(fdip);
690 		}
691 		if (err)
692 			goto out;
693 	}
694 
695 	feo = fdip->answ;
696 
697 	if ((err = fuse_internal_checkentry(feo, vap->va_type))) {
698 		goto out;
699 	}
700 
701 	if (op == FUSE_CREATE) {
702 		foo = (struct fuse_open_out*)(feo + 1);
703 	} else {
704 		/* Issue a separate FUSE_OPEN */
705 		struct fuse_open_in *foi;
706 
707 		fdip2 = &fdi2;
708 		fdisp_init(fdip2, sizeof(*foi));
709 		fdisp_make(fdip2, FUSE_OPEN, vnode_mount(dvp), feo->nodeid, td,
710 			cred);
711 		foi = fdip2->indata;
712 		foi->flags = flags;
713 		err = fdisp_wait_answ(fdip2);
714 		if (err)
715 			goto out;
716 		foo = fdip2->answ;
717 	}
718 	err = fuse_vnode_get(mp, feo, feo->nodeid, dvp, vpp, cnp, vap->va_type);
719 	if (err) {
720 		struct fuse_release_in *fri;
721 		uint64_t nodeid = feo->nodeid;
722 		uint64_t fh_id = foo->fh;
723 
724 		fdisp_init(fdip, sizeof(*fri));
725 		fdisp_make(fdip, FUSE_RELEASE, mp, nodeid, td, cred);
726 		fri = fdip->indata;
727 		fri->fh = fh_id;
728 		fri->flags = flags;
729 		fuse_insert_callback(fdip->tick, fuse_internal_forget_callback);
730 		fuse_insert_message(fdip->tick, false);
731 		goto out;
732 	}
733 	ASSERT_VOP_ELOCKED(*vpp, "fuse_vnop_create");
734 	fuse_internal_cache_attrs(*vpp, &feo->attr, feo->attr_valid,
735 		feo->attr_valid_nsec, NULL);
736 
737 	fuse_filehandle_init(*vpp, FUFH_RDWR, NULL, td, cred, foo);
738 	fuse_vnode_open(*vpp, foo->open_flags, td);
739 	/*
740 	 * Purge the parent's attribute cache because the daemon should've
741 	 * updated its mtime and ctime
742 	 */
743 	fuse_vnode_clear_attr_cache(dvp);
744 	cache_purge_negative(dvp);
745 
746 out:
747 	if (fdip2)
748 		fdisp_destroy(fdip2);
749 	fdisp_destroy(fdip);
750 	return err;
751 }
752 
753 /*
754     struct vnop_fdatasync_args {
755 	struct vop_generic_args a_gen;
756 	struct vnode * a_vp;
757 	struct thread * a_td;
758     };
759 */
760 static int
761 fuse_vnop_fdatasync(struct vop_fdatasync_args *ap)
762 {
763 	struct vnode *vp = ap->a_vp;
764 	struct thread *td = ap->a_td;
765 	int waitfor = MNT_WAIT;
766 
767 	int err = 0;
768 
769 	if (fuse_isdeadfs(vp)) {
770 		return 0;
771 	}
772 	if ((err = vop_stdfdatasync_buf(ap)))
773 		return err;
774 
775 	return fuse_internal_fsync(vp, td, waitfor, true);
776 }
777 
778 /*
779     struct vnop_fsync_args {
780 	struct vop_generic_args a_gen;
781 	struct vnode * a_vp;
782 	int  a_waitfor;
783 	struct thread * a_td;
784     };
785 */
786 static int
787 fuse_vnop_fsync(struct vop_fsync_args *ap)
788 {
789 	struct vnode *vp = ap->a_vp;
790 	struct thread *td = ap->a_td;
791 	int waitfor = ap->a_waitfor;
792 	int err = 0;
793 
794 	if (fuse_isdeadfs(vp)) {
795 		return 0;
796 	}
797 	if ((err = vop_stdfsync(ap)))
798 		return err;
799 
800 	return fuse_internal_fsync(vp, td, waitfor, false);
801 }
802 
803 /*
804     struct vnop_getattr_args {
805 	struct vnode *a_vp;
806 	struct vattr *a_vap;
807 	struct ucred *a_cred;
808 	struct thread *a_td;
809     };
810 */
811 static int
812 fuse_vnop_getattr(struct vop_getattr_args *ap)
813 {
814 	struct vnode *vp = ap->a_vp;
815 	struct vattr *vap = ap->a_vap;
816 	struct ucred *cred = ap->a_cred;
817 	struct thread *td = curthread;
818 
819 	int err = 0;
820 	int dataflags;
821 
822 	dataflags = fuse_get_mpdata(vnode_mount(vp))->dataflags;
823 
824 	/* Note that we are not bailing out on a dead file system just yet. */
825 
826 	if (!(dataflags & FSESS_INITED)) {
827 		if (!vnode_isvroot(vp)) {
828 			fdata_set_dead(fuse_get_mpdata(vnode_mount(vp)));
829 			err = ENOTCONN;
830 			return err;
831 		} else {
832 			goto fake;
833 		}
834 	}
835 	err = fuse_internal_getattr(vp, vap, cred, td);
836 	if (err == ENOTCONN && vnode_isvroot(vp)) {
837 		/* see comment in fuse_vfsop_statfs() */
838 		goto fake;
839 	} else {
840 		return err;
841 	}
842 
843 fake:
844 	bzero(vap, sizeof(*vap));
845 	vap->va_type = vnode_vtype(vp);
846 
847 	return 0;
848 }
849 
850 /*
851     struct vnop_inactive_args {
852 	struct vnode *a_vp;
853     };
854 */
855 static int
856 fuse_vnop_inactive(struct vop_inactive_args *ap)
857 {
858 	struct vnode *vp = ap->a_vp;
859 	struct thread *td = curthread;
860 
861 	struct fuse_vnode_data *fvdat = VTOFUD(vp);
862 	struct fuse_filehandle *fufh, *fufh_tmp;
863 
864 	int need_flush = 1;
865 
866 	LIST_FOREACH_SAFE(fufh, &fvdat->handles, next, fufh_tmp) {
867 		if (need_flush && vp->v_type == VREG) {
868 			if ((VTOFUD(vp)->flag & FN_SIZECHANGE) != 0) {
869 				fuse_vnode_savesize(vp, NULL, 0);
870 			}
871 			if ((fvdat->flag & FN_REVOKED) != 0)
872 				fuse_io_invalbuf(vp, td);
873 			else
874 				fuse_io_flushbuf(vp, MNT_WAIT, td);
875 			need_flush = 0;
876 		}
877 		fuse_filehandle_close(vp, fufh, td, NULL);
878 	}
879 
880 	if ((fvdat->flag & FN_REVOKED) != 0)
881 		vrecycle(vp);
882 
883 	return 0;
884 }
885 
886 /*
887     struct vnop_link_args {
888 	struct vnode *a_tdvp;
889 	struct vnode *a_vp;
890 	struct componentname *a_cnp;
891     };
892 */
893 static int
894 fuse_vnop_link(struct vop_link_args *ap)
895 {
896 	struct vnode *vp = ap->a_vp;
897 	struct vnode *tdvp = ap->a_tdvp;
898 	struct componentname *cnp = ap->a_cnp;
899 
900 	struct vattr *vap = VTOVA(vp);
901 
902 	struct fuse_dispatcher fdi;
903 	struct fuse_entry_out *feo;
904 	struct fuse_link_in fli;
905 
906 	int err;
907 
908 	if (fuse_isdeadfs(vp)) {
909 		return ENXIO;
910 	}
911 	if (vnode_mount(tdvp) != vnode_mount(vp)) {
912 		return EXDEV;
913 	}
914 
915 	/*
916 	 * This is a seatbelt check to protect naive userspace filesystems from
917 	 * themselves and the limitations of the FUSE IPC protocol.  If a
918 	 * filesystem does not allow attribute caching, assume it is capable of
919 	 * validating that nlink does not overflow.
920 	 */
921 	if (vap != NULL && vap->va_nlink >= FUSE_LINK_MAX)
922 		return EMLINK;
923 	fli.oldnodeid = VTOI(vp);
924 
925 	fdisp_init(&fdi, 0);
926 	fuse_internal_newentry_makerequest(vnode_mount(tdvp), VTOI(tdvp), cnp,
927 	    FUSE_LINK, &fli, sizeof(fli), &fdi);
928 	if ((err = fdisp_wait_answ(&fdi))) {
929 		goto out;
930 	}
931 	feo = fdi.answ;
932 
933 	err = fuse_internal_checkentry(feo, vnode_vtype(vp));
934 	if (!err) {
935 		/*
936 		 * Purge the parent's attribute cache because the daemon
937 		 * should've updated its mtime and ctime
938 		 */
939 		fuse_vnode_clear_attr_cache(tdvp);
940 		fuse_internal_cache_attrs(vp, &feo->attr, feo->attr_valid,
941 			feo->attr_valid_nsec, NULL);
942 	}
943 out:
944 	fdisp_destroy(&fdi);
945 	return err;
946 }
947 
948 struct fuse_lookup_alloc_arg {
949 	struct fuse_entry_out *feo;
950 	struct componentname *cnp;
951 	uint64_t nid;
952 	enum vtype vtyp;
953 };
954 
955 /* Callback for vn_get_ino */
956 static int
957 fuse_lookup_alloc(struct mount *mp, void *arg, int lkflags, struct vnode **vpp)
958 {
959 	struct fuse_lookup_alloc_arg *flaa = arg;
960 
961 	return fuse_vnode_get(mp, flaa->feo, flaa->nid, NULL, vpp, flaa->cnp,
962 		flaa->vtyp);
963 }
964 
965 SDT_PROBE_DEFINE3(fusefs, , vnops, cache_lookup,
966 	"int", "struct timespec*", "struct timespec*");
967 SDT_PROBE_DEFINE2(fusefs, , vnops, lookup_cache_incoherent,
968 	"struct vnode*", "struct fuse_entry_out*");
969 /*
970     struct vnop_lookup_args {
971 	struct vnodeop_desc *a_desc;
972 	struct vnode *a_dvp;
973 	struct vnode **a_vpp;
974 	struct componentname *a_cnp;
975     };
976 */
977 int
978 fuse_vnop_lookup(struct vop_lookup_args *ap)
979 {
980 	struct vnode *dvp = ap->a_dvp;
981 	struct vnode **vpp = ap->a_vpp;
982 	struct componentname *cnp = ap->a_cnp;
983 	struct thread *td = cnp->cn_thread;
984 	struct ucred *cred = cnp->cn_cred;
985 
986 	int nameiop = cnp->cn_nameiop;
987 	int flags = cnp->cn_flags;
988 	int wantparent = flags & (LOCKPARENT | WANTPARENT);
989 	int islastcn = flags & ISLASTCN;
990 	struct mount *mp = vnode_mount(dvp);
991 	struct fuse_data *data = fuse_get_mpdata(mp);
992 	int default_permissions = data->dataflags & FSESS_DEFAULT_PERMISSIONS;
993 
994 	int err = 0;
995 	int lookup_err = 0;
996 	struct vnode *vp = NULL;
997 
998 	struct fuse_dispatcher fdi;
999 	bool did_lookup = false;
1000 	struct fuse_entry_out *feo = NULL;
1001 	enum vtype vtyp;	/* vnode type of target */
1002 	off_t filesize;		/* filesize of target */
1003 
1004 	uint64_t nid;
1005 
1006 	if (fuse_isdeadfs(dvp)) {
1007 		*vpp = NULL;
1008 		return ENXIO;
1009 	}
1010 	if (!vnode_isdir(dvp))
1011 		return ENOTDIR;
1012 
1013 	if (islastcn && vfs_isrdonly(mp) && (nameiop != LOOKUP))
1014 		return EROFS;
1015 
1016 	if ((cnp->cn_flags & NOEXECCHECK) != 0)
1017 		cnp->cn_flags &= ~NOEXECCHECK;
1018 	else if ((err = fuse_internal_access(dvp, VEXEC, td, cred)))
1019 		return err;
1020 
1021 	if (flags & ISDOTDOT) {
1022 		KASSERT(VTOFUD(dvp)->flag & FN_PARENT_NID,
1023 			("Looking up .. is TODO"));
1024 		nid = VTOFUD(dvp)->parent_nid;
1025 		if (nid == 0)
1026 			return ENOENT;
1027 		/* .. is obviously a directory */
1028 		vtyp = VDIR;
1029 		filesize = 0;
1030 	} else if (cnp->cn_namelen == 1 && *(cnp->cn_nameptr) == '.') {
1031 		nid = VTOI(dvp);
1032 		/* . is obviously a directory */
1033 		vtyp = VDIR;
1034 		filesize = 0;
1035 	} else {
1036 		struct timespec now, timeout;
1037 		int ncpticks; /* here to accomodate for API contract */
1038 
1039 		err = cache_lookup(dvp, vpp, cnp, &timeout, &ncpticks);
1040 		getnanouptime(&now);
1041 		SDT_PROBE3(fusefs, , vnops, cache_lookup, err, &timeout, &now);
1042 		switch (err) {
1043 		case -1:		/* positive match */
1044 			if (timespeccmp(&timeout, &now, >)) {
1045 				counter_u64_add(fuse_lookup_cache_hits, 1);
1046 			} else {
1047 				/* Cache timeout */
1048 				counter_u64_add(fuse_lookup_cache_misses, 1);
1049 				bintime_clear(
1050 					&VTOFUD(*vpp)->entry_cache_timeout);
1051 				cache_purge(*vpp);
1052 				if (dvp != *vpp)
1053 					vput(*vpp);
1054 				else
1055 					vrele(*vpp);
1056 				*vpp = NULL;
1057 				break;
1058 			}
1059 			return 0;
1060 
1061 		case 0:		/* no match in cache */
1062 			counter_u64_add(fuse_lookup_cache_misses, 1);
1063 			break;
1064 
1065 		case ENOENT:		/* negative match */
1066 			getnanouptime(&now);
1067 			if (timespeccmp(&timeout, &now, <=)) {
1068 				/* Cache timeout */
1069 				cache_purge_negative(dvp);
1070 				break;
1071 			}
1072 			/* fall through */
1073 		default:
1074 			return err;
1075 		}
1076 
1077 		nid = VTOI(dvp);
1078 		fdisp_init(&fdi, cnp->cn_namelen + 1);
1079 		fdisp_make(&fdi, FUSE_LOOKUP, mp, nid, td, cred);
1080 
1081 		memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen);
1082 		((char *)fdi.indata)[cnp->cn_namelen] = '\0';
1083 		lookup_err = fdisp_wait_answ(&fdi);
1084 		did_lookup = true;
1085 
1086 		if (!lookup_err) {
1087 			/* lookup call succeeded */
1088 			feo = (struct fuse_entry_out *)fdi.answ;
1089 			nid = feo->nodeid;
1090 			if (nid == 0) {
1091 				/* zero nodeid means ENOENT and cache it */
1092 				struct timespec timeout;
1093 
1094 				fdi.answ_stat = ENOENT;
1095 				lookup_err = ENOENT;
1096 				if (cnp->cn_flags & MAKEENTRY) {
1097 					fuse_validity_2_timespec(feo, &timeout);
1098 					cache_enter_time(dvp, *vpp, cnp,
1099 						&timeout, NULL);
1100 				}
1101 			} else if (nid == FUSE_ROOT_ID) {
1102 				lookup_err = EINVAL;
1103 			}
1104 			vtyp = IFTOVT(feo->attr.mode);
1105 			filesize = feo->attr.size;
1106 		}
1107 		if (lookup_err && (!fdi.answ_stat || lookup_err != ENOENT)) {
1108 			fdisp_destroy(&fdi);
1109 			return lookup_err;
1110 		}
1111 	}
1112 	/* lookup_err, if non-zero, must be ENOENT at this point */
1113 
1114 	if (lookup_err) {
1115 		/* Entry not found */
1116 		if ((nameiop == CREATE || nameiop == RENAME) && islastcn) {
1117 			if (default_permissions)
1118 				err = fuse_internal_access(dvp, VWRITE, td,
1119 				    cred);
1120 			else
1121 				err = 0;
1122 			if (!err) {
1123 				/*
1124 				 * Set the SAVENAME flag to hold onto the
1125 				 * pathname for use later in VOP_CREATE or
1126 				 * VOP_RENAME.
1127 				 */
1128 				cnp->cn_flags |= SAVENAME;
1129 
1130 				err = EJUSTRETURN;
1131 			}
1132 		} else {
1133 			err = ENOENT;
1134 		}
1135 	} else {
1136 		/* Entry was found */
1137 		if (flags & ISDOTDOT) {
1138 			struct fuse_lookup_alloc_arg flaa;
1139 
1140 			flaa.nid = nid;
1141 			flaa.feo = feo;
1142 			flaa.cnp = cnp;
1143 			flaa.vtyp = vtyp;
1144 			err = vn_vget_ino_gen(dvp, fuse_lookup_alloc, &flaa, 0,
1145 				&vp);
1146 			*vpp = vp;
1147 		} else if (nid == VTOI(dvp)) {
1148 			vref(dvp);
1149 			*vpp = dvp;
1150 		} else {
1151 			struct fuse_vnode_data *fvdat;
1152 			struct vattr *vap;
1153 
1154 			err = fuse_vnode_get(vnode_mount(dvp), feo, nid, dvp,
1155 			    &vp, cnp, vtyp);
1156 			if (err)
1157 				goto out;
1158 			*vpp = vp;
1159 
1160 			/*
1161 			 * In the case where we are looking up a FUSE node
1162 			 * represented by an existing cached vnode, and the
1163 			 * true size reported by FUSE_LOOKUP doesn't match
1164 			 * the vnode's cached size, then any cached writes
1165 			 * beyond the file's current size are lost.
1166 			 *
1167 			 * We can get here:
1168 			 * * following attribute cache expiration, or
1169 			 * * due a bug in the daemon, or
1170 			 */
1171 			fvdat = VTOFUD(vp);
1172 			if (vnode_isreg(vp) &&
1173 			    ((filesize != fvdat->cached_attrs.va_size &&
1174 			      fvdat->flag & FN_SIZECHANGE) ||
1175 			     ((vap = VTOVA(vp)) &&
1176 			      filesize != vap->va_size)))
1177 			{
1178 				SDT_PROBE2(fusefs, , vnops, lookup_cache_incoherent, vp, feo);
1179 				fvdat->flag &= ~FN_SIZECHANGE;
1180 				/*
1181 				 * The server changed the file's size even
1182 				 * though we had it cached, or had dirty writes
1183 				 * in the WB cache!
1184 				 */
1185 				printf("%s: cache incoherent on %s!  "
1186 		    		    "Buggy FUSE server detected.  To prevent "
1187 				    "data corruption, disable the data cache "
1188 				    "by mounting with -o direct_io, or as "
1189 				    "directed otherwise by your FUSE server's "
1190 		    		    "documentation\n", __func__,
1191 				    vnode_mount(vp)->mnt_stat.f_mntonname);
1192 				int iosize = fuse_iosize(vp);
1193 				v_inval_buf_range(vp, 0, INT64_MAX, iosize);
1194 			}
1195 
1196 			MPASS(feo != NULL);
1197 			fuse_internal_cache_attrs(*vpp, &feo->attr,
1198 				feo->attr_valid, feo->attr_valid_nsec, NULL);
1199 			fuse_validity_2_bintime(feo->entry_valid,
1200 				feo->entry_valid_nsec,
1201 				&fvdat->entry_cache_timeout);
1202 
1203 			if ((nameiop == DELETE || nameiop == RENAME) &&
1204 				islastcn && default_permissions)
1205 			{
1206 				struct vattr dvattr;
1207 
1208 				err = fuse_internal_access(dvp, VWRITE, td,
1209 					cred);
1210 				if (err != 0)
1211 					goto out;
1212 				/*
1213 				 * if the parent's sticky bit is set, check
1214 				 * whether we're allowed to remove the file.
1215 				 * Need to figure out the vnode locking to make
1216 				 * this work.
1217 				 */
1218 				fuse_internal_getattr(dvp, &dvattr, cred, td);
1219 				if ((dvattr.va_mode & S_ISTXT) &&
1220 					fuse_internal_access(dvp, VADMIN, td,
1221 						cred) &&
1222 					fuse_internal_access(*vpp, VADMIN, td,
1223 						cred)) {
1224 					err = EPERM;
1225 					goto out;
1226 				}
1227 			}
1228 
1229 			if (islastcn && (
1230 				(nameiop == DELETE) ||
1231 				(nameiop == RENAME && wantparent))) {
1232 				cnp->cn_flags |= SAVENAME;
1233 			}
1234 		}
1235 	}
1236 out:
1237 	if (err) {
1238 		if (vp != NULL && dvp != vp)
1239 			vput(vp);
1240 		else if (vp != NULL)
1241 			vrele(vp);
1242 		*vpp = NULL;
1243 	}
1244 	if (did_lookup)
1245 		fdisp_destroy(&fdi);
1246 
1247 	return err;
1248 }
1249 
1250 /*
1251     struct vnop_mkdir_args {
1252 	struct vnode *a_dvp;
1253 	struct vnode **a_vpp;
1254 	struct componentname *a_cnp;
1255 	struct vattr *a_vap;
1256     };
1257 */
1258 static int
1259 fuse_vnop_mkdir(struct vop_mkdir_args *ap)
1260 {
1261 	struct vnode *dvp = ap->a_dvp;
1262 	struct vnode **vpp = ap->a_vpp;
1263 	struct componentname *cnp = ap->a_cnp;
1264 	struct vattr *vap = ap->a_vap;
1265 
1266 	struct fuse_mkdir_in fmdi;
1267 
1268 	if (fuse_isdeadfs(dvp)) {
1269 		return ENXIO;
1270 	}
1271 	fmdi.mode = MAKEIMODE(vap->va_type, vap->va_mode);
1272 	fmdi.umask = curthread->td_proc->p_fd->fd_cmask;
1273 
1274 	return (fuse_internal_newentry(dvp, vpp, cnp, FUSE_MKDIR, &fmdi,
1275 	    sizeof(fmdi), VDIR));
1276 }
1277 
1278 /*
1279     struct vnop_mknod_args {
1280 	struct vnode *a_dvp;
1281 	struct vnode **a_vpp;
1282 	struct componentname *a_cnp;
1283 	struct vattr *a_vap;
1284     };
1285 */
1286 static int
1287 fuse_vnop_mknod(struct vop_mknod_args *ap)
1288 {
1289 
1290 	struct vnode *dvp = ap->a_dvp;
1291 	struct vnode **vpp = ap->a_vpp;
1292 	struct componentname *cnp = ap->a_cnp;
1293 	struct vattr *vap = ap->a_vap;
1294 
1295 	if (fuse_isdeadfs(dvp))
1296 		return ENXIO;
1297 
1298 	return fuse_internal_mknod(dvp, vpp, cnp, vap);
1299 }
1300 
1301 /*
1302     struct vop_open_args {
1303 	struct vnode *a_vp;
1304 	int  a_mode;
1305 	struct ucred *a_cred;
1306 	struct thread *a_td;
1307 	int a_fdidx; / struct file *a_fp;
1308     };
1309 */
1310 static int
1311 fuse_vnop_open(struct vop_open_args *ap)
1312 {
1313 	struct vnode *vp = ap->a_vp;
1314 	int a_mode = ap->a_mode;
1315 	struct thread *td = ap->a_td;
1316 	struct ucred *cred = ap->a_cred;
1317 	pid_t pid = td->td_proc->p_pid;
1318 	struct fuse_vnode_data *fvdat;
1319 
1320 	if (fuse_isdeadfs(vp))
1321 		return ENXIO;
1322 	if (vp->v_type == VCHR || vp->v_type == VBLK || vp->v_type == VFIFO)
1323 		return (EOPNOTSUPP);
1324 	if ((a_mode & (FREAD | FWRITE | FEXEC)) == 0)
1325 		return EINVAL;
1326 
1327 	fvdat = VTOFUD(vp);
1328 
1329 	if (fuse_filehandle_validrw(vp, a_mode, cred, pid)) {
1330 		fuse_vnode_open(vp, 0, td);
1331 		return 0;
1332 	}
1333 
1334 	return fuse_filehandle_open(vp, a_mode, NULL, td, cred);
1335 }
1336 
1337 static int
1338 fuse_vnop_pathconf(struct vop_pathconf_args *ap)
1339 {
1340 
1341 	switch (ap->a_name) {
1342 	case _PC_FILESIZEBITS:
1343 		*ap->a_retval = 64;
1344 		return (0);
1345 	case _PC_NAME_MAX:
1346 		*ap->a_retval = NAME_MAX;
1347 		return (0);
1348 	case _PC_LINK_MAX:
1349 		*ap->a_retval = MIN(LONG_MAX, FUSE_LINK_MAX);
1350 		return (0);
1351 	case _PC_SYMLINK_MAX:
1352 		*ap->a_retval = MAXPATHLEN;
1353 		return (0);
1354 	case _PC_NO_TRUNC:
1355 		*ap->a_retval = 1;
1356 		return (0);
1357 	default:
1358 		return (vop_stdpathconf(ap));
1359 	}
1360 }
1361 
1362 /*
1363     struct vnop_read_args {
1364 	struct vnode *a_vp;
1365 	struct uio *a_uio;
1366 	int  a_ioflag;
1367 	struct ucred *a_cred;
1368     };
1369 */
1370 static int
1371 fuse_vnop_read(struct vop_read_args *ap)
1372 {
1373 	struct vnode *vp = ap->a_vp;
1374 	struct uio *uio = ap->a_uio;
1375 	int ioflag = ap->a_ioflag;
1376 	struct ucred *cred = ap->a_cred;
1377 	pid_t pid = curthread->td_proc->p_pid;
1378 
1379 	if (fuse_isdeadfs(vp)) {
1380 		return ENXIO;
1381 	}
1382 
1383 	if (VTOFUD(vp)->flag & FN_DIRECTIO) {
1384 		ioflag |= IO_DIRECT;
1385 	}
1386 
1387 	return fuse_io_dispatch(vp, uio, ioflag, cred, pid);
1388 }
1389 
1390 /*
1391     struct vnop_readdir_args {
1392 	struct vnode *a_vp;
1393 	struct uio *a_uio;
1394 	struct ucred *a_cred;
1395 	int *a_eofflag;
1396 	int *a_ncookies;
1397 	u_long **a_cookies;
1398     };
1399 */
1400 static int
1401 fuse_vnop_readdir(struct vop_readdir_args *ap)
1402 {
1403 	struct vnode *vp = ap->a_vp;
1404 	struct uio *uio = ap->a_uio;
1405 	struct ucred *cred = ap->a_cred;
1406 	struct fuse_filehandle *fufh = NULL;
1407 	struct fuse_iov cookediov;
1408 	int err = 0;
1409 	u_long *cookies;
1410 	off_t startoff;
1411 	ssize_t tresid;
1412 	int ncookies;
1413 	bool closefufh = false;
1414 	pid_t pid = curthread->td_proc->p_pid;
1415 
1416 	if (ap->a_eofflag)
1417 		*ap->a_eofflag = 0;
1418 	if (fuse_isdeadfs(vp)) {
1419 		return ENXIO;
1420 	}
1421 	if (				/* XXXIP ((uio_iovcnt(uio) > 1)) || */
1422 	    (uio_resid(uio) < sizeof(struct dirent))) {
1423 		return EINVAL;
1424 	}
1425 
1426 	tresid = uio->uio_resid;
1427 	startoff = uio->uio_offset;
1428 	err = fuse_filehandle_get_dir(vp, &fufh, cred, pid);
1429 	if (err == EBADF && vnode_mount(vp)->mnt_flag & MNT_EXPORTED) {
1430 		/*
1431 		 * nfsd will do VOP_READDIR without first doing VOP_OPEN.  We
1432 		 * must implicitly open the directory here
1433 		 */
1434 		err = fuse_filehandle_open(vp, FREAD, &fufh, curthread, cred);
1435 		if (err == 0) {
1436 			/*
1437 			 * When a directory is opened, it must be read from
1438 			 * the beginning.  Hopefully, the "startoff" still
1439 			 * exists as an offset cookie for the directory.
1440 			 * If not, it will read the entire directory without
1441 			 * returning any entries and just return eof.
1442 			 */
1443 			uio->uio_offset = 0;
1444 		}
1445 		closefufh = true;
1446 	}
1447 	if (err)
1448 		return (err);
1449 	if (ap->a_ncookies != NULL) {
1450 		ncookies = uio->uio_resid /
1451 			(offsetof(struct dirent, d_name) + 4) + 1;
1452 		cookies = malloc(ncookies * sizeof(*cookies), M_TEMP, M_WAITOK);
1453 		*ap->a_ncookies = ncookies;
1454 		*ap->a_cookies = cookies;
1455 	} else {
1456 		ncookies = 0;
1457 		cookies = NULL;
1458 	}
1459 #define DIRCOOKEDSIZE FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + MAXNAMLEN + 1)
1460 	fiov_init(&cookediov, DIRCOOKEDSIZE);
1461 
1462 	err = fuse_internal_readdir(vp, uio, startoff, fufh, &cookediov,
1463 		&ncookies, cookies);
1464 
1465 	fiov_teardown(&cookediov);
1466 	if (closefufh)
1467 		fuse_filehandle_close(vp, fufh, curthread, cred);
1468 
1469 	if (ap->a_ncookies != NULL) {
1470 		if (err == 0) {
1471 			*ap->a_ncookies -= ncookies;
1472 		} else {
1473 			free(*ap->a_cookies, M_TEMP);
1474 			*ap->a_ncookies = 0;
1475 			*ap->a_cookies = NULL;
1476 		}
1477 	}
1478 	if (err == 0 && tresid == uio->uio_resid)
1479 		*ap->a_eofflag = 1;
1480 
1481 	return err;
1482 }
1483 
1484 /*
1485     struct vnop_readlink_args {
1486 	struct vnode *a_vp;
1487 	struct uio *a_uio;
1488 	struct ucred *a_cred;
1489     };
1490 */
1491 static int
1492 fuse_vnop_readlink(struct vop_readlink_args *ap)
1493 {
1494 	struct vnode *vp = ap->a_vp;
1495 	struct uio *uio = ap->a_uio;
1496 	struct ucred *cred = ap->a_cred;
1497 
1498 	struct fuse_dispatcher fdi;
1499 	int err;
1500 
1501 	if (fuse_isdeadfs(vp)) {
1502 		return ENXIO;
1503 	}
1504 	if (!vnode_islnk(vp)) {
1505 		return EINVAL;
1506 	}
1507 	fdisp_init(&fdi, 0);
1508 	err = fdisp_simple_putget_vp(&fdi, FUSE_READLINK, vp, curthread, cred);
1509 	if (err) {
1510 		goto out;
1511 	}
1512 	if (((char *)fdi.answ)[0] == '/' &&
1513 	    fuse_get_mpdata(vnode_mount(vp))->dataflags & FSESS_PUSH_SYMLINKS_IN) {
1514 		char *mpth = vnode_mount(vp)->mnt_stat.f_mntonname;
1515 
1516 		err = uiomove(mpth, strlen(mpth), uio);
1517 	}
1518 	if (!err) {
1519 		err = uiomove(fdi.answ, fdi.iosize, uio);
1520 	}
1521 out:
1522 	fdisp_destroy(&fdi);
1523 	return err;
1524 }
1525 
1526 /*
1527     struct vnop_reclaim_args {
1528 	struct vnode *a_vp;
1529     };
1530 */
1531 static int
1532 fuse_vnop_reclaim(struct vop_reclaim_args *ap)
1533 {
1534 	struct vnode *vp = ap->a_vp;
1535 	struct thread *td = curthread;
1536 	struct fuse_vnode_data *fvdat = VTOFUD(vp);
1537 	struct fuse_filehandle *fufh, *fufh_tmp;
1538 
1539 	if (!fvdat) {
1540 		panic("FUSE: no vnode data during recycling");
1541 	}
1542 	LIST_FOREACH_SAFE(fufh, &fvdat->handles, next, fufh_tmp) {
1543 		printf("FUSE: vnode being reclaimed with open fufh "
1544 			"(type=%#x)", fufh->fufh_type);
1545 		fuse_filehandle_close(vp, fufh, td, NULL);
1546 	}
1547 
1548 	if (!fuse_isdeadfs(vp) && fvdat->nlookup > 0) {
1549 		fuse_internal_forget_send(vnode_mount(vp), td, NULL, VTOI(vp),
1550 		    fvdat->nlookup);
1551 	}
1552 	cache_purge(vp);
1553 	vfs_hash_remove(vp);
1554 	fuse_vnode_destroy(vp);
1555 
1556 	return 0;
1557 }
1558 
1559 /*
1560     struct vnop_remove_args {
1561 	struct vnode *a_dvp;
1562 	struct vnode *a_vp;
1563 	struct componentname *a_cnp;
1564     };
1565 */
1566 static int
1567 fuse_vnop_remove(struct vop_remove_args *ap)
1568 {
1569 	struct vnode *dvp = ap->a_dvp;
1570 	struct vnode *vp = ap->a_vp;
1571 	struct componentname *cnp = ap->a_cnp;
1572 
1573 	int err;
1574 
1575 	if (fuse_isdeadfs(vp)) {
1576 		return ENXIO;
1577 	}
1578 	if (vnode_isdir(vp)) {
1579 		return EPERM;
1580 	}
1581 
1582 	err = fuse_internal_remove(dvp, vp, cnp, FUSE_UNLINK);
1583 
1584 	return err;
1585 }
1586 
1587 /*
1588     struct vnop_rename_args {
1589 	struct vnode *a_fdvp;
1590 	struct vnode *a_fvp;
1591 	struct componentname *a_fcnp;
1592 	struct vnode *a_tdvp;
1593 	struct vnode *a_tvp;
1594 	struct componentname *a_tcnp;
1595     };
1596 */
1597 static int
1598 fuse_vnop_rename(struct vop_rename_args *ap)
1599 {
1600 	struct vnode *fdvp = ap->a_fdvp;
1601 	struct vnode *fvp = ap->a_fvp;
1602 	struct componentname *fcnp = ap->a_fcnp;
1603 	struct vnode *tdvp = ap->a_tdvp;
1604 	struct vnode *tvp = ap->a_tvp;
1605 	struct componentname *tcnp = ap->a_tcnp;
1606 	struct fuse_data *data;
1607 	bool newparent = fdvp != tdvp;
1608 	bool isdir = fvp->v_type == VDIR;
1609 	int err = 0;
1610 
1611 	if (fuse_isdeadfs(fdvp)) {
1612 		return ENXIO;
1613 	}
1614 	if (fvp->v_mount != tdvp->v_mount ||
1615 	    (tvp && fvp->v_mount != tvp->v_mount)) {
1616 		SDT_PROBE2(fusefs, , vnops, trace, 1, "cross-device rename");
1617 		err = EXDEV;
1618 		goto out;
1619 	}
1620 	cache_purge(fvp);
1621 
1622 	/*
1623 	 * FUSE library is expected to check if target directory is not
1624 	 * under the source directory in the file system tree.
1625 	 * Linux performs this check at VFS level.
1626 	 */
1627 	/*
1628 	 * If source is a directory, and it will get a new parent, user must
1629 	 * have write permission to it, so ".." can be modified.
1630 	 */
1631 	data = fuse_get_mpdata(vnode_mount(tdvp));
1632 	if (data->dataflags & FSESS_DEFAULT_PERMISSIONS && isdir && newparent) {
1633 		err = fuse_internal_access(fvp, VWRITE,
1634 			tcnp->cn_thread, tcnp->cn_cred);
1635 		if (err)
1636 			goto out;
1637 	}
1638 	sx_xlock(&data->rename_lock);
1639 	err = fuse_internal_rename(fdvp, fcnp, tdvp, tcnp);
1640 	if (err == 0) {
1641 		if (tdvp != fdvp)
1642 			fuse_vnode_setparent(fvp, tdvp);
1643 		if (tvp != NULL)
1644 			fuse_vnode_setparent(tvp, NULL);
1645 	}
1646 	sx_unlock(&data->rename_lock);
1647 
1648 	if (tvp != NULL && tvp != fvp) {
1649 		cache_purge(tvp);
1650 	}
1651 	if (vnode_isdir(fvp)) {
1652 		if ((tvp != NULL) && vnode_isdir(tvp)) {
1653 			cache_purge(tdvp);
1654 		}
1655 		cache_purge(fdvp);
1656 	}
1657 out:
1658 	if (tdvp == tvp) {
1659 		vrele(tdvp);
1660 	} else {
1661 		vput(tdvp);
1662 	}
1663 	if (tvp != NULL) {
1664 		vput(tvp);
1665 	}
1666 	vrele(fdvp);
1667 	vrele(fvp);
1668 
1669 	return err;
1670 }
1671 
1672 /*
1673     struct vnop_rmdir_args {
1674 	    struct vnode *a_dvp;
1675 	    struct vnode *a_vp;
1676 	    struct componentname *a_cnp;
1677     } *ap;
1678 */
1679 static int
1680 fuse_vnop_rmdir(struct vop_rmdir_args *ap)
1681 {
1682 	struct vnode *dvp = ap->a_dvp;
1683 	struct vnode *vp = ap->a_vp;
1684 
1685 	int err;
1686 
1687 	if (fuse_isdeadfs(vp)) {
1688 		return ENXIO;
1689 	}
1690 	if (VTOFUD(vp) == VTOFUD(dvp)) {
1691 		return EINVAL;
1692 	}
1693 	err = fuse_internal_remove(dvp, vp, ap->a_cnp, FUSE_RMDIR);
1694 
1695 	return err;
1696 }
1697 
1698 /*
1699     struct vnop_setattr_args {
1700 	struct vnode *a_vp;
1701 	struct vattr *a_vap;
1702 	struct ucred *a_cred;
1703 	struct thread *a_td;
1704     };
1705 */
1706 static int
1707 fuse_vnop_setattr(struct vop_setattr_args *ap)
1708 {
1709 	struct vnode *vp = ap->a_vp;
1710 	struct vattr *vap = ap->a_vap;
1711 	struct ucred *cred = ap->a_cred;
1712 	struct thread *td = curthread;
1713 	struct mount *mp;
1714 	struct fuse_data *data;
1715 	struct vattr old_va;
1716 	int dataflags;
1717 	int err = 0, err2;
1718 	accmode_t accmode = 0;
1719 	bool checkperm;
1720 	bool drop_suid = false;
1721 	gid_t cr_gid;
1722 
1723 	mp = vnode_mount(vp);
1724 	data = fuse_get_mpdata(mp);
1725 	dataflags = data->dataflags;
1726 	checkperm = dataflags & FSESS_DEFAULT_PERMISSIONS;
1727 	if (cred->cr_ngroups > 0)
1728 		cr_gid = cred->cr_groups[0];
1729 	else
1730 		cr_gid = 0;
1731 
1732 	if (fuse_isdeadfs(vp)) {
1733 		return ENXIO;
1734 	}
1735 
1736 	if (vap->va_uid != (uid_t)VNOVAL) {
1737 		if (checkperm) {
1738 			/* Only root may change a file's owner */
1739 			err = priv_check_cred(cred, PRIV_VFS_CHOWN);
1740 			if (err) {
1741 				/* As a special case, allow the null chown */
1742 				err2 = fuse_internal_getattr(vp, &old_va, cred,
1743 					td);
1744 				if (err2)
1745 					return (err2);
1746 				if (vap->va_uid != old_va.va_uid)
1747 					return err;
1748 				else
1749 					accmode |= VADMIN;
1750 				drop_suid = true;
1751 			} else
1752 				accmode |= VADMIN;
1753 		} else
1754 			accmode |= VADMIN;
1755 	}
1756 	if (vap->va_gid != (gid_t)VNOVAL) {
1757 		if (checkperm && priv_check_cred(cred, PRIV_VFS_CHOWN))
1758 			drop_suid = true;
1759 		if (checkperm && !groupmember(vap->va_gid, cred))
1760 		{
1761 			/*
1762 			 * Non-root users may only chgrp to one of their own
1763 			 * groups
1764 			 */
1765 			err = priv_check_cred(cred, PRIV_VFS_CHOWN);
1766 			if (err) {
1767 				/* As a special case, allow the null chgrp */
1768 				err2 = fuse_internal_getattr(vp, &old_va, cred,
1769 					td);
1770 				if (err2)
1771 					return (err2);
1772 				if (vap->va_gid != old_va.va_gid)
1773 					return err;
1774 				accmode |= VADMIN;
1775 			} else
1776 				accmode |= VADMIN;
1777 		} else
1778 			accmode |= VADMIN;
1779 	}
1780 	if (vap->va_size != VNOVAL) {
1781 		switch (vp->v_type) {
1782 		case VDIR:
1783 			return (EISDIR);
1784 		case VLNK:
1785 		case VREG:
1786 			if (vfs_isrdonly(mp))
1787 				return (EROFS);
1788 			break;
1789 		default:
1790 			/*
1791 			 * According to POSIX, the result is unspecified
1792 			 * for file types other than regular files,
1793 			 * directories and shared memory objects.  We
1794 			 * don't support shared memory objects in the file
1795 			 * system, and have dubious support for truncating
1796 			 * symlinks.  Just ignore the request in other cases.
1797 			 */
1798 			return (0);
1799 		}
1800 		/* Don't set accmode.  Permission to trunc is checked upstack */
1801 	}
1802 	if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
1803 		if (vap->va_vaflags & VA_UTIMES_NULL)
1804 			accmode |= VWRITE;
1805 		else
1806 			accmode |= VADMIN;
1807 	}
1808 	if (drop_suid) {
1809 		if (vap->va_mode != (mode_t)VNOVAL)
1810 			vap->va_mode &= ~(S_ISUID | S_ISGID);
1811 		else {
1812 			err = fuse_internal_getattr(vp, &old_va, cred, td);
1813 			if (err)
1814 				return (err);
1815 			vap->va_mode = old_va.va_mode & ~(S_ISUID | S_ISGID);
1816 		}
1817 	}
1818 	if (vap->va_mode != (mode_t)VNOVAL) {
1819 		/* Only root may set the sticky bit on non-directories */
1820 		if (checkperm && vp->v_type != VDIR && (vap->va_mode & S_ISTXT)
1821 		    && priv_check_cred(cred, PRIV_VFS_STICKYFILE))
1822 			return EFTYPE;
1823 		if (checkperm && (vap->va_mode & S_ISGID)) {
1824 			err = fuse_internal_getattr(vp, &old_va, cred, td);
1825 			if (err)
1826 				return (err);
1827 			if (!groupmember(old_va.va_gid, cred)) {
1828 				err = priv_check_cred(cred, PRIV_VFS_SETGID);
1829 				if (err)
1830 					return (err);
1831 			}
1832 		}
1833 		accmode |= VADMIN;
1834 	}
1835 
1836 	if (vfs_isrdonly(mp))
1837 		return EROFS;
1838 
1839 	if (checkperm) {
1840 		err = fuse_internal_access(vp, accmode, td, cred);
1841 	} else {
1842 		err = 0;
1843 	}
1844 	if (err)
1845 		return err;
1846 	else
1847 		return fuse_internal_setattr(vp, vap, td, cred);
1848 }
1849 
1850 /*
1851     struct vnop_strategy_args {
1852 	struct vnode *a_vp;
1853 	struct buf *a_bp;
1854     };
1855 */
1856 static int
1857 fuse_vnop_strategy(struct vop_strategy_args *ap)
1858 {
1859 	struct vnode *vp = ap->a_vp;
1860 	struct buf *bp = ap->a_bp;
1861 
1862 	if (!vp || fuse_isdeadfs(vp)) {
1863 		bp->b_ioflags |= BIO_ERROR;
1864 		bp->b_error = ENXIO;
1865 		bufdone(bp);
1866 		return 0;
1867 	}
1868 
1869 	/*
1870 	 * VOP_STRATEGY always returns zero and signals error via bp->b_ioflags.
1871 	 * fuse_io_strategy sets bp's error fields
1872 	 */
1873 	(void)fuse_io_strategy(vp, bp);
1874 
1875 	return 0;
1876 }
1877 
1878 /*
1879     struct vnop_symlink_args {
1880 	struct vnode *a_dvp;
1881 	struct vnode **a_vpp;
1882 	struct componentname *a_cnp;
1883 	struct vattr *a_vap;
1884 	char *a_target;
1885     };
1886 */
1887 static int
1888 fuse_vnop_symlink(struct vop_symlink_args *ap)
1889 {
1890 	struct vnode *dvp = ap->a_dvp;
1891 	struct vnode **vpp = ap->a_vpp;
1892 	struct componentname *cnp = ap->a_cnp;
1893 	const char *target = ap->a_target;
1894 
1895 	struct fuse_dispatcher fdi;
1896 
1897 	int err;
1898 	size_t len;
1899 
1900 	if (fuse_isdeadfs(dvp)) {
1901 		return ENXIO;
1902 	}
1903 	/*
1904 	 * Unlike the other creator type calls, here we have to create a message
1905 	 * where the name of the new entry comes first, and the data describing
1906 	 * the entry comes second.
1907 	 * Hence we can't rely on our handy fuse_internal_newentry() routine,
1908 	 * but put together the message manually and just call the core part.
1909 	 */
1910 
1911 	len = strlen(target) + 1;
1912 	fdisp_init(&fdi, len + cnp->cn_namelen + 1);
1913 	fdisp_make_vp(&fdi, FUSE_SYMLINK, dvp, curthread, NULL);
1914 
1915 	memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen);
1916 	((char *)fdi.indata)[cnp->cn_namelen] = '\0';
1917 	memcpy((char *)fdi.indata + cnp->cn_namelen + 1, target, len);
1918 
1919 	err = fuse_internal_newentry_core(dvp, vpp, cnp, VLNK, &fdi);
1920 	fdisp_destroy(&fdi);
1921 	return err;
1922 }
1923 
1924 /*
1925     struct vnop_write_args {
1926 	struct vnode *a_vp;
1927 	struct uio *a_uio;
1928 	int  a_ioflag;
1929 	struct ucred *a_cred;
1930     };
1931 */
1932 static int
1933 fuse_vnop_write(struct vop_write_args *ap)
1934 {
1935 	struct vnode *vp = ap->a_vp;
1936 	struct uio *uio = ap->a_uio;
1937 	int ioflag = ap->a_ioflag;
1938 	struct ucred *cred = ap->a_cred;
1939 	pid_t pid = curthread->td_proc->p_pid;
1940 
1941 	if (fuse_isdeadfs(vp)) {
1942 		return ENXIO;
1943 	}
1944 
1945 	if (VTOFUD(vp)->flag & FN_DIRECTIO) {
1946 		ioflag |= IO_DIRECT;
1947 	}
1948 
1949 	return fuse_io_dispatch(vp, uio, ioflag, cred, pid);
1950 }
1951 
1952 static daddr_t
1953 fuse_gbp_getblkno(struct vnode *vp, vm_ooffset_t off)
1954 {
1955 	const int biosize = fuse_iosize(vp);
1956 
1957 	return (off / biosize);
1958 }
1959 
1960 static int
1961 fuse_gbp_getblksz(struct vnode *vp, daddr_t lbn)
1962 {
1963 	off_t filesize;
1964 	int blksz, err;
1965 	const int biosize = fuse_iosize(vp);
1966 
1967 	err = fuse_vnode_size(vp, &filesize, NULL, NULL);
1968 	KASSERT(err == 0, ("vfs_bio_getpages can't handle errors here"));
1969 	if (err)
1970 		return biosize;
1971 
1972 	if ((off_t)lbn * biosize >= filesize) {
1973 		blksz = 0;
1974 	} else if ((off_t)(lbn + 1) * biosize > filesize) {
1975 		blksz = filesize - (off_t)lbn *biosize;
1976 	} else {
1977 		blksz = biosize;
1978 	}
1979 	return (blksz);
1980 }
1981 
1982 /*
1983     struct vnop_getpages_args {
1984 	struct vnode *a_vp;
1985 	vm_page_t *a_m;
1986 	int a_count;
1987 	int a_reqpage;
1988     };
1989 */
1990 static int
1991 fuse_vnop_getpages(struct vop_getpages_args *ap)
1992 {
1993 	struct vnode *vp = ap->a_vp;
1994 
1995 	if (!fsess_opt_mmap(vnode_mount(vp))) {
1996 		SDT_PROBE2(fusefs, , vnops, trace, 1,
1997 			"called on non-cacheable vnode??\n");
1998 		return (VM_PAGER_ERROR);
1999 	}
2000 
2001 	return (vfs_bio_getpages(vp, ap->a_m, ap->a_count, ap->a_rbehind,
2002 	    ap->a_rahead, fuse_gbp_getblkno, fuse_gbp_getblksz));
2003 }
2004 
2005 static const char extattr_namespace_separator = '.';
2006 
2007 /*
2008     struct vop_getextattr_args {
2009 	struct vop_generic_args a_gen;
2010 	struct vnode *a_vp;
2011 	int a_attrnamespace;
2012 	const char *a_name;
2013 	struct uio *a_uio;
2014 	size_t *a_size;
2015 	struct ucred *a_cred;
2016 	struct thread *a_td;
2017     };
2018 */
2019 static int
2020 fuse_vnop_getextattr(struct vop_getextattr_args *ap)
2021 {
2022 	struct vnode *vp = ap->a_vp;
2023 	struct uio *uio = ap->a_uio;
2024 	struct fuse_dispatcher fdi;
2025 	struct fuse_getxattr_in *get_xattr_in;
2026 	struct fuse_getxattr_out *get_xattr_out;
2027 	struct mount *mp = vnode_mount(vp);
2028 	struct thread *td = ap->a_td;
2029 	struct ucred *cred = ap->a_cred;
2030 	char *prefix;
2031 	char *attr_str;
2032 	size_t len;
2033 	int err;
2034 
2035 	if (fuse_isdeadfs(vp))
2036 		return (ENXIO);
2037 
2038 	if (!fsess_isimpl(mp, FUSE_GETXATTR))
2039 		return EOPNOTSUPP;
2040 
2041 	err = fuse_extattr_check_cred(vp, ap->a_attrnamespace, cred, td, VREAD);
2042 	if (err)
2043 		return err;
2044 
2045 	/* Default to looking for user attributes. */
2046 	if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM)
2047 		prefix = EXTATTR_NAMESPACE_SYSTEM_STRING;
2048 	else
2049 		prefix = EXTATTR_NAMESPACE_USER_STRING;
2050 
2051 	len = strlen(prefix) + sizeof(extattr_namespace_separator) +
2052 	    strlen(ap->a_name) + 1;
2053 
2054 	fdisp_init(&fdi, len + sizeof(*get_xattr_in));
2055 	fdisp_make_vp(&fdi, FUSE_GETXATTR, vp, td, cred);
2056 
2057 	get_xattr_in = fdi.indata;
2058 	/*
2059 	 * Check to see whether we're querying the available size or
2060 	 * issuing the actual request.  If we pass in 0, we get back struct
2061 	 * fuse_getxattr_out.  If we pass in a non-zero size, we get back
2062 	 * that much data, without the struct fuse_getxattr_out header.
2063 	 */
2064 	if (uio == NULL)
2065 		get_xattr_in->size = 0;
2066 	else
2067 		get_xattr_in->size = uio->uio_resid;
2068 
2069 	attr_str = (char *)fdi.indata + sizeof(*get_xattr_in);
2070 	snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator,
2071 	    ap->a_name);
2072 
2073 	err = fdisp_wait_answ(&fdi);
2074 	if (err != 0) {
2075 		if (err == ENOSYS) {
2076 			fsess_set_notimpl(mp, FUSE_GETXATTR);
2077 			err = EOPNOTSUPP;
2078 		}
2079 		goto out;
2080 	}
2081 
2082 	get_xattr_out = fdi.answ;
2083 
2084 	if (ap->a_size != NULL)
2085 		*ap->a_size = get_xattr_out->size;
2086 
2087 	if (uio != NULL)
2088 		err = uiomove(fdi.answ, fdi.iosize, uio);
2089 
2090 out:
2091 	fdisp_destroy(&fdi);
2092 	return (err);
2093 }
2094 
2095 /*
2096     struct vop_setextattr_args {
2097 	struct vop_generic_args a_gen;
2098 	struct vnode *a_vp;
2099 	int a_attrnamespace;
2100 	const char *a_name;
2101 	struct uio *a_uio;
2102 	struct ucred *a_cred;
2103 	struct thread *a_td;
2104     };
2105 */
2106 static int
2107 fuse_vnop_setextattr(struct vop_setextattr_args *ap)
2108 {
2109 	struct vnode *vp = ap->a_vp;
2110 	struct uio *uio = ap->a_uio;
2111 	struct fuse_dispatcher fdi;
2112 	struct fuse_setxattr_in *set_xattr_in;
2113 	struct mount *mp = vnode_mount(vp);
2114 	struct thread *td = ap->a_td;
2115 	struct ucred *cred = ap->a_cred;
2116 	char *prefix;
2117 	size_t len;
2118 	char *attr_str;
2119 	int err;
2120 
2121 	if (fuse_isdeadfs(vp))
2122 		return (ENXIO);
2123 
2124 	if (!fsess_isimpl(mp, FUSE_SETXATTR))
2125 		return EOPNOTSUPP;
2126 
2127 	if (vfs_isrdonly(mp))
2128 		return EROFS;
2129 
2130 	/* Deleting xattrs must use VOP_DELETEEXTATTR instead */
2131 	if (ap->a_uio == NULL) {
2132 		/*
2133 		 * If we got here as fallback from VOP_DELETEEXTATTR, then
2134 		 * return EOPNOTSUPP.
2135 		 */
2136 		if (!fsess_isimpl(mp, FUSE_REMOVEXATTR))
2137 			return (EOPNOTSUPP);
2138 		else
2139 			return (EINVAL);
2140 	}
2141 
2142 	err = fuse_extattr_check_cred(vp, ap->a_attrnamespace, cred, td,
2143 		VWRITE);
2144 	if (err)
2145 		return err;
2146 
2147 	/* Default to looking for user attributes. */
2148 	if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM)
2149 		prefix = EXTATTR_NAMESPACE_SYSTEM_STRING;
2150 	else
2151 		prefix = EXTATTR_NAMESPACE_USER_STRING;
2152 
2153 	len = strlen(prefix) + sizeof(extattr_namespace_separator) +
2154 	    strlen(ap->a_name) + 1;
2155 
2156 	fdisp_init(&fdi, len + sizeof(*set_xattr_in) + uio->uio_resid);
2157 	fdisp_make_vp(&fdi, FUSE_SETXATTR, vp, td, cred);
2158 
2159 	set_xattr_in = fdi.indata;
2160 	set_xattr_in->size = uio->uio_resid;
2161 
2162 	attr_str = (char *)fdi.indata + sizeof(*set_xattr_in);
2163 	snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator,
2164 	    ap->a_name);
2165 
2166 	err = uiomove((char *)fdi.indata + sizeof(*set_xattr_in) + len,
2167 	    uio->uio_resid, uio);
2168 	if (err != 0) {
2169 		goto out;
2170 	}
2171 
2172 	err = fdisp_wait_answ(&fdi);
2173 
2174 	if (err == ENOSYS) {
2175 		fsess_set_notimpl(mp, FUSE_SETXATTR);
2176 		err = EOPNOTSUPP;
2177 	}
2178 	if (err == ERESTART) {
2179 		/* Can't restart after calling uiomove */
2180 		err = EINTR;
2181 	}
2182 
2183 out:
2184 	fdisp_destroy(&fdi);
2185 	return (err);
2186 }
2187 
2188 /*
2189  * The Linux / FUSE extended attribute list is simply a collection of
2190  * NUL-terminated strings.  The FreeBSD extended attribute list is a single
2191  * byte length followed by a non-NUL terminated string.  So, this allows
2192  * conversion of the Linux / FUSE format to the FreeBSD format in place.
2193  * Linux attribute names are reported with the namespace as a prefix (e.g.
2194  * "user.attribute_name"), but in FreeBSD they are reported without the
2195  * namespace prefix (e.g. "attribute_name").  So, we're going from:
2196  *
2197  * user.attr_name1\0user.attr_name2\0
2198  *
2199  * to:
2200  *
2201  * <num>attr_name1<num>attr_name2
2202  *
2203  * Where "<num>" is a single byte number of characters in the attribute name.
2204  *
2205  * Args:
2206  * prefix - exattr namespace prefix string
2207  * list, list_len - input list with namespace prefixes
2208  * bsd_list, bsd_list_len - output list compatible with bsd vfs
2209  */
2210 static int
2211 fuse_xattrlist_convert(char *prefix, const char *list, int list_len,
2212     char *bsd_list, int *bsd_list_len)
2213 {
2214 	int len, pos, dist_to_next, prefix_len;
2215 
2216 	pos = 0;
2217 	*bsd_list_len = 0;
2218 	prefix_len = strlen(prefix);
2219 
2220 	while (pos < list_len && list[pos] != '\0') {
2221 		dist_to_next = strlen(&list[pos]) + 1;
2222 		if (bcmp(&list[pos], prefix, prefix_len) == 0 &&
2223 		    list[pos + prefix_len] == extattr_namespace_separator) {
2224 			len = dist_to_next -
2225 			    (prefix_len + sizeof(extattr_namespace_separator)) - 1;
2226 			if (len >= EXTATTR_MAXNAMELEN)
2227 				return (ENAMETOOLONG);
2228 
2229 			bsd_list[*bsd_list_len] = len;
2230 			memcpy(&bsd_list[*bsd_list_len + 1],
2231 			    &list[pos + prefix_len +
2232 			    sizeof(extattr_namespace_separator)], len);
2233 
2234 			*bsd_list_len += len + 1;
2235 		}
2236 
2237 		pos += dist_to_next;
2238 	}
2239 
2240 	return (0);
2241 }
2242 
2243 /*
2244  * List extended attributes
2245  *
2246  * The FUSE_LISTXATTR operation is based on Linux's listxattr(2) syscall, which
2247  * has a number of differences compared to its FreeBSD equivalent,
2248  * extattr_list_file:
2249  *
2250  * - FUSE_LISTXATTR returns all extended attributes across all namespaces,
2251  *   whereas listxattr(2) only returns attributes for a single namespace
2252  * - FUSE_LISTXATTR prepends each attribute name with "namespace."
2253  * - If the provided buffer is not large enough to hold the result,
2254  *   FUSE_LISTXATTR should return ERANGE, whereas listxattr is expected to
2255  *   return as many results as will fit.
2256  */
2257 /*
2258     struct vop_listextattr_args {
2259 	struct vop_generic_args a_gen;
2260 	struct vnode *a_vp;
2261 	int a_attrnamespace;
2262 	struct uio *a_uio;
2263 	size_t *a_size;
2264 	struct ucred *a_cred;
2265 	struct thread *a_td;
2266     };
2267 */
2268 static int
2269 fuse_vnop_listextattr(struct vop_listextattr_args *ap)
2270 {
2271 	struct vnode *vp = ap->a_vp;
2272 	struct uio *uio = ap->a_uio;
2273 	struct fuse_dispatcher fdi;
2274 	struct fuse_listxattr_in *list_xattr_in;
2275 	struct fuse_listxattr_out *list_xattr_out;
2276 	struct mount *mp = vnode_mount(vp);
2277 	struct thread *td = ap->a_td;
2278 	struct ucred *cred = ap->a_cred;
2279 	char *prefix;
2280 	char *bsd_list = NULL;
2281 	char *linux_list;
2282 	int bsd_list_len;
2283 	int linux_list_len;
2284 	int err;
2285 
2286 	if (fuse_isdeadfs(vp))
2287 		return (ENXIO);
2288 
2289 	if (!fsess_isimpl(mp, FUSE_LISTXATTR))
2290 		return EOPNOTSUPP;
2291 
2292 	err = fuse_extattr_check_cred(vp, ap->a_attrnamespace, cred, td, VREAD);
2293 	if (err)
2294 		return err;
2295 
2296 	/*
2297 	 * Add space for a NUL and the period separator if enabled.
2298 	 * Default to looking for user attributes.
2299 	 */
2300 	if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM)
2301 		prefix = EXTATTR_NAMESPACE_SYSTEM_STRING;
2302 	else
2303 		prefix = EXTATTR_NAMESPACE_USER_STRING;
2304 
2305 	fdisp_init(&fdi, sizeof(*list_xattr_in));
2306 	fdisp_make_vp(&fdi, FUSE_LISTXATTR, vp, td, cred);
2307 
2308 	/*
2309 	 * Retrieve Linux / FUSE compatible list size.
2310 	 */
2311 	list_xattr_in = fdi.indata;
2312 	list_xattr_in->size = 0;
2313 
2314 	err = fdisp_wait_answ(&fdi);
2315 	if (err != 0) {
2316 		if (err == ENOSYS) {
2317 			fsess_set_notimpl(mp, FUSE_LISTXATTR);
2318 			err = EOPNOTSUPP;
2319 		}
2320 		goto out;
2321 	}
2322 
2323 	list_xattr_out = fdi.answ;
2324 	linux_list_len = list_xattr_out->size;
2325 	if (linux_list_len == 0) {
2326 		if (ap->a_size != NULL)
2327 			*ap->a_size = linux_list_len;
2328 		goto out;
2329 	}
2330 
2331 	/*
2332 	 * Retrieve Linux / FUSE compatible list values.
2333 	 */
2334 	fdisp_refresh_vp(&fdi, FUSE_LISTXATTR, vp, td, cred);
2335 	list_xattr_in = fdi.indata;
2336 	list_xattr_in->size = linux_list_len;
2337 
2338 	err = fdisp_wait_answ(&fdi);
2339 	if (err == ERANGE) {
2340 		/*
2341 		 * Race detected.  The attribute list must've grown since the
2342 		 * first FUSE_LISTXATTR call.  Start over.  Go all the way back
2343 		 * to userland so we can process signals, if necessary, before
2344 		 * restarting.
2345 		 */
2346 		err = ERESTART;
2347 		goto out;
2348 	} else if (err != 0)
2349 		goto out;
2350 
2351 	linux_list = fdi.answ;
2352 	/* FUSE doesn't allow the server to return more data than requested */
2353 	if (fdi.iosize > linux_list_len) {
2354 		printf("WARNING: FUSE protocol violation.  Server returned "
2355 			"more extended attribute data than requested; "
2356 			"should've returned ERANGE instead");
2357 	} else {
2358 		/* But returning less data is fine */
2359 		linux_list_len = fdi.iosize;
2360 	}
2361 
2362 	/*
2363 	 * Retrieve the BSD compatible list values.
2364 	 * The Linux / FUSE attribute list format isn't the same
2365 	 * as FreeBSD's format. So we need to transform it into
2366 	 * FreeBSD's format before giving it to the user.
2367 	 */
2368 	bsd_list = malloc(linux_list_len, M_TEMP, M_WAITOK);
2369 	err = fuse_xattrlist_convert(prefix, linux_list, linux_list_len,
2370 	    bsd_list, &bsd_list_len);
2371 	if (err != 0)
2372 		goto out;
2373 
2374 	if (ap->a_size != NULL)
2375 		*ap->a_size = bsd_list_len;
2376 
2377 	if (uio != NULL)
2378 		err = uiomove(bsd_list, bsd_list_len, uio);
2379 
2380 out:
2381 	free(bsd_list, M_TEMP);
2382 	fdisp_destroy(&fdi);
2383 	return (err);
2384 }
2385 
2386 /*
2387     struct vop_deleteextattr_args {
2388 	struct vop_generic_args a_gen;
2389 	struct vnode *a_vp;
2390 	int a_attrnamespace;
2391 	const char *a_name;
2392 	struct ucred *a_cred;
2393 	struct thread *a_td;
2394     };
2395 */
2396 static int
2397 fuse_vnop_deleteextattr(struct vop_deleteextattr_args *ap)
2398 {
2399 	struct vnode *vp = ap->a_vp;
2400 	struct fuse_dispatcher fdi;
2401 	struct mount *mp = vnode_mount(vp);
2402 	struct thread *td = ap->a_td;
2403 	struct ucred *cred = ap->a_cred;
2404 	char *prefix;
2405 	size_t len;
2406 	char *attr_str;
2407 	int err;
2408 
2409 	if (fuse_isdeadfs(vp))
2410 		return (ENXIO);
2411 
2412 	if (!fsess_isimpl(mp, FUSE_REMOVEXATTR))
2413 		return EOPNOTSUPP;
2414 
2415 	if (vfs_isrdonly(mp))
2416 		return EROFS;
2417 
2418 	err = fuse_extattr_check_cred(vp, ap->a_attrnamespace, cred, td,
2419 		VWRITE);
2420 	if (err)
2421 		return err;
2422 
2423 	/* Default to looking for user attributes. */
2424 	if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM)
2425 		prefix = EXTATTR_NAMESPACE_SYSTEM_STRING;
2426 	else
2427 		prefix = EXTATTR_NAMESPACE_USER_STRING;
2428 
2429 	len = strlen(prefix) + sizeof(extattr_namespace_separator) +
2430 	    strlen(ap->a_name) + 1;
2431 
2432 	fdisp_init(&fdi, len);
2433 	fdisp_make_vp(&fdi, FUSE_REMOVEXATTR, vp, td, cred);
2434 
2435 	attr_str = fdi.indata;
2436 	snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator,
2437 	    ap->a_name);
2438 
2439 	err = fdisp_wait_answ(&fdi);
2440 	if (err == ENOSYS) {
2441 		fsess_set_notimpl(mp, FUSE_REMOVEXATTR);
2442 		err = EOPNOTSUPP;
2443 	}
2444 
2445 	fdisp_destroy(&fdi);
2446 	return (err);
2447 }
2448 
2449 /*
2450     struct vnop_print_args {
2451 	struct vnode *a_vp;
2452     };
2453 */
2454 static int
2455 fuse_vnop_print(struct vop_print_args *ap)
2456 {
2457 	struct fuse_vnode_data *fvdat = VTOFUD(ap->a_vp);
2458 
2459 	printf("nodeid: %ju, parent nodeid: %ju, nlookup: %ju, flag: %#x\n",
2460 	    (uintmax_t)VTOILLU(ap->a_vp), (uintmax_t)fvdat->parent_nid,
2461 	    (uintmax_t)fvdat->nlookup,
2462 	    fvdat->flag);
2463 
2464 	return 0;
2465 }
2466 
2467 /*
2468  * Get an NFS filehandle for a FUSE file.
2469  *
2470  * This will only work for FUSE file systems that guarantee the uniqueness of
2471  * nodeid:generation, which most don't.
2472  */
2473 /*
2474 vop_vptofh {
2475 	IN struct vnode *a_vp;
2476 	IN struct fid *a_fhp;
2477 };
2478 */
2479 static int
2480 fuse_vnop_vptofh(struct vop_vptofh_args *ap)
2481 {
2482 	struct vnode *vp = ap->a_vp;
2483 	struct fuse_vnode_data *fvdat = VTOFUD(vp);
2484 	struct fuse_fid *fhp = (struct fuse_fid *)(ap->a_fhp);
2485 	_Static_assert(sizeof(struct fuse_fid) <= sizeof(struct fid),
2486 		"FUSE fid type is too big");
2487 	struct mount *mp = vnode_mount(vp);
2488 	struct fuse_data *data = fuse_get_mpdata(mp);
2489 	struct vattr va;
2490 	int err;
2491 
2492 	if (!(data->dataflags & FSESS_EXPORT_SUPPORT))
2493 		return EOPNOTSUPP;
2494 
2495 	err = fuse_internal_getattr(vp, &va, curthread->td_ucred, curthread);
2496 	if (err)
2497 		return err;
2498 
2499 	/*ip = VTOI(ap->a_vp);*/
2500 	/*ufhp = (struct ufid *)ap->a_fhp;*/
2501 	fhp->len = sizeof(struct fuse_fid);
2502 	fhp->nid = fvdat->nid;
2503 	if (fvdat->generation <= UINT32_MAX)
2504 		fhp->gen = fvdat->generation;
2505 	else
2506 		return EOVERFLOW;
2507 	return (0);
2508 }
2509