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