1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 2007-2009 Google Inc. and Amit Singh 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions are 9 * met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above 14 * copyright notice, this list of conditions and the following disclaimer 15 * in the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Google Inc. nor the names of its 18 * contributors may be used to endorse or promote products derived from 19 * this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 * 33 * Copyright (C) 2005 Csaba Henk. 34 * All rights reserved. 35 * 36 * Redistribution and use in source and binary forms, with or without 37 * modification, are permitted provided that the following conditions 38 * are met: 39 * 1. Redistributions of source code must retain the above copyright 40 * notice, this list of conditions and the following disclaimer. 41 * 2. Redistributions in binary form must reproduce the above copyright 42 * notice, this list of conditions and the following disclaimer in the 43 * documentation and/or other materials provided with the distribution. 44 * 45 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND 46 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 47 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 48 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 49 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 50 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 51 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 52 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 53 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 54 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 55 * SUCH DAMAGE. 56 */ 57 58 #include <sys/cdefs.h> 59 __FBSDID("$FreeBSD$"); 60 61 #include <sys/types.h> 62 #include <sys/module.h> 63 #include <sys/systm.h> 64 #include <sys/errno.h> 65 #include <sys/param.h> 66 #include <sys/kernel.h> 67 #include <sys/conf.h> 68 #include <sys/uio.h> 69 #include <sys/malloc.h> 70 #include <sys/queue.h> 71 #include <sys/lock.h> 72 #include <sys/rwlock.h> 73 #include <sys/sx.h> 74 #include <sys/proc.h> 75 #include <sys/mount.h> 76 #include <sys/vnode.h> 77 #include <sys/namei.h> 78 #include <sys/extattr.h> 79 #include <sys/stat.h> 80 #include <sys/unistd.h> 81 #include <sys/filedesc.h> 82 #include <sys/file.h> 83 #include <sys/fcntl.h> 84 #include <sys/dirent.h> 85 #include <sys/bio.h> 86 #include <sys/buf.h> 87 #include <sys/sysctl.h> 88 #include <sys/vmmeter.h> 89 90 #include <vm/vm.h> 91 #include <vm/vm_extern.h> 92 #include <vm/pmap.h> 93 #include <vm/vm_map.h> 94 #include <vm/vm_page.h> 95 #include <vm/vm_param.h> 96 #include <vm/vm_object.h> 97 #include <vm/vm_pager.h> 98 #include <vm/vnode_pager.h> 99 #include <vm/vm_object.h> 100 101 #include "fuse.h" 102 #include "fuse_file.h" 103 #include "fuse_internal.h" 104 #include "fuse_ipc.h" 105 #include "fuse_node.h" 106 #include "fuse_param.h" 107 #include "fuse_io.h" 108 109 #include <sys/priv.h> 110 111 #define FUSE_DEBUG_MODULE VNOPS 112 #include "fuse_debug.h" 113 114 /* vnode ops */ 115 static vop_access_t fuse_vnop_access; 116 static vop_close_t fuse_vnop_close; 117 static vop_create_t fuse_vnop_create; 118 static vop_deleteextattr_t fuse_vnop_deleteextattr; 119 static vop_fsync_t fuse_vnop_fsync; 120 static vop_getattr_t fuse_vnop_getattr; 121 static vop_getextattr_t fuse_vnop_getextattr; 122 static vop_inactive_t fuse_vnop_inactive; 123 static vop_link_t fuse_vnop_link; 124 static vop_listextattr_t fuse_vnop_listextattr; 125 static vop_lookup_t fuse_vnop_lookup; 126 static vop_mkdir_t fuse_vnop_mkdir; 127 static vop_mknod_t fuse_vnop_mknod; 128 static vop_open_t fuse_vnop_open; 129 static vop_pathconf_t fuse_vnop_pathconf; 130 static vop_read_t fuse_vnop_read; 131 static vop_readdir_t fuse_vnop_readdir; 132 static vop_readlink_t fuse_vnop_readlink; 133 static vop_reclaim_t fuse_vnop_reclaim; 134 static vop_remove_t fuse_vnop_remove; 135 static vop_rename_t fuse_vnop_rename; 136 static vop_rmdir_t fuse_vnop_rmdir; 137 static vop_setattr_t fuse_vnop_setattr; 138 static vop_setextattr_t fuse_vnop_setextattr; 139 static vop_strategy_t fuse_vnop_strategy; 140 static vop_symlink_t fuse_vnop_symlink; 141 static vop_write_t fuse_vnop_write; 142 static vop_getpages_t fuse_vnop_getpages; 143 static vop_putpages_t fuse_vnop_putpages; 144 static vop_print_t fuse_vnop_print; 145 146 struct vop_vector fuse_vnops = { 147 .vop_default = &default_vnodeops, 148 .vop_access = fuse_vnop_access, 149 .vop_close = fuse_vnop_close, 150 .vop_create = fuse_vnop_create, 151 .vop_deleteextattr = fuse_vnop_deleteextattr, 152 .vop_fsync = fuse_vnop_fsync, 153 .vop_getattr = fuse_vnop_getattr, 154 .vop_getextattr = fuse_vnop_getextattr, 155 .vop_inactive = fuse_vnop_inactive, 156 .vop_link = fuse_vnop_link, 157 .vop_listextattr = fuse_vnop_listextattr, 158 .vop_lookup = fuse_vnop_lookup, 159 .vop_mkdir = fuse_vnop_mkdir, 160 .vop_mknod = fuse_vnop_mknod, 161 .vop_open = fuse_vnop_open, 162 .vop_pathconf = fuse_vnop_pathconf, 163 .vop_read = fuse_vnop_read, 164 .vop_readdir = fuse_vnop_readdir, 165 .vop_readlink = fuse_vnop_readlink, 166 .vop_reclaim = fuse_vnop_reclaim, 167 .vop_remove = fuse_vnop_remove, 168 .vop_rename = fuse_vnop_rename, 169 .vop_rmdir = fuse_vnop_rmdir, 170 .vop_setattr = fuse_vnop_setattr, 171 .vop_setextattr = fuse_vnop_setextattr, 172 .vop_strategy = fuse_vnop_strategy, 173 .vop_symlink = fuse_vnop_symlink, 174 .vop_write = fuse_vnop_write, 175 .vop_getpages = fuse_vnop_getpages, 176 .vop_putpages = fuse_vnop_putpages, 177 .vop_print = fuse_vnop_print, 178 }; 179 180 static u_long fuse_lookup_cache_hits = 0; 181 182 SYSCTL_ULONG(_vfs_fuse, OID_AUTO, lookup_cache_hits, CTLFLAG_RD, 183 &fuse_lookup_cache_hits, 0, ""); 184 185 static u_long fuse_lookup_cache_misses = 0; 186 187 SYSCTL_ULONG(_vfs_fuse, OID_AUTO, lookup_cache_misses, CTLFLAG_RD, 188 &fuse_lookup_cache_misses, 0, ""); 189 190 int fuse_lookup_cache_enable = 1; 191 192 SYSCTL_INT(_vfs_fuse, OID_AUTO, lookup_cache_enable, CTLFLAG_RW, 193 &fuse_lookup_cache_enable, 0, ""); 194 195 /* 196 * XXX: This feature is highly experimental and can bring to instabilities, 197 * needs revisiting before to be enabled by default. 198 */ 199 static int fuse_reclaim_revoked = 0; 200 201 SYSCTL_INT(_vfs_fuse, OID_AUTO, reclaim_revoked, CTLFLAG_RW, 202 &fuse_reclaim_revoked, 0, ""); 203 204 int fuse_pbuf_freecnt = -1; 205 206 #define fuse_vm_page_lock(m) vm_page_lock((m)); 207 #define fuse_vm_page_unlock(m) vm_page_unlock((m)); 208 #define fuse_vm_page_lock_queues() ((void)0) 209 #define fuse_vm_page_unlock_queues() ((void)0) 210 211 /* 212 struct vnop_access_args { 213 struct vnode *a_vp; 214 #if VOP_ACCESS_TAKES_ACCMODE_T 215 accmode_t a_accmode; 216 #else 217 int a_mode; 218 #endif 219 struct ucred *a_cred; 220 struct thread *a_td; 221 }; 222 */ 223 static int 224 fuse_vnop_access(struct vop_access_args *ap) 225 { 226 struct vnode *vp = ap->a_vp; 227 int accmode = ap->a_accmode; 228 struct ucred *cred = ap->a_cred; 229 230 struct fuse_access_param facp; 231 struct fuse_data *data = fuse_get_mpdata(vnode_mount(vp)); 232 233 int err; 234 235 FS_DEBUG2G("inode=%ju\n", (uintmax_t)VTOI(vp)); 236 237 if (fuse_isdeadfs(vp)) { 238 if (vnode_isvroot(vp)) { 239 return 0; 240 } 241 return ENXIO; 242 } 243 if (!(data->dataflags & FSESS_INITED)) { 244 if (vnode_isvroot(vp)) { 245 if (priv_check_cred(cred, PRIV_VFS_ADMIN, 0) || 246 (fuse_match_cred(data->daemoncred, cred) == 0)) { 247 return 0; 248 } 249 } 250 return EBADF; 251 } 252 if (vnode_islnk(vp)) { 253 return 0; 254 } 255 bzero(&facp, sizeof(facp)); 256 257 err = fuse_internal_access(vp, accmode, &facp, ap->a_td, ap->a_cred); 258 FS_DEBUG2G("err=%d accmode=0x%x\n", err, accmode); 259 return err; 260 } 261 262 /* 263 struct vnop_close_args { 264 struct vnode *a_vp; 265 int a_fflag; 266 struct ucred *a_cred; 267 struct thread *a_td; 268 }; 269 */ 270 static int 271 fuse_vnop_close(struct vop_close_args *ap) 272 { 273 struct vnode *vp = ap->a_vp; 274 struct ucred *cred = ap->a_cred; 275 int fflag = ap->a_fflag; 276 fufh_type_t fufh_type; 277 278 fuse_trace_printf_vnop(); 279 280 if (fuse_isdeadfs(vp)) { 281 return 0; 282 } 283 if (vnode_isdir(vp)) { 284 if (fuse_filehandle_valid(vp, FUFH_RDONLY)) { 285 fuse_filehandle_close(vp, FUFH_RDONLY, NULL, cred); 286 } 287 return 0; 288 } 289 if (fflag & IO_NDELAY) { 290 return 0; 291 } 292 fufh_type = fuse_filehandle_xlate_from_fflags(fflag); 293 294 if (!fuse_filehandle_valid(vp, fufh_type)) { 295 int i; 296 297 for (i = 0; i < FUFH_MAXTYPE; i++) 298 if (fuse_filehandle_valid(vp, i)) 299 break; 300 if (i == FUFH_MAXTYPE) 301 panic("FUSE: fufh type %d found to be invalid in close" 302 " (fflag=0x%x)\n", 303 fufh_type, fflag); 304 } 305 if ((VTOFUD(vp)->flag & FN_SIZECHANGE) != 0) { 306 fuse_vnode_savesize(vp, cred); 307 } 308 return 0; 309 } 310 311 /* 312 struct vnop_create_args { 313 struct vnode *a_dvp; 314 struct vnode **a_vpp; 315 struct componentname *a_cnp; 316 struct vattr *a_vap; 317 }; 318 */ 319 static int 320 fuse_vnop_create(struct vop_create_args *ap) 321 { 322 struct vnode *dvp = ap->a_dvp; 323 struct vnode **vpp = ap->a_vpp; 324 struct componentname *cnp = ap->a_cnp; 325 struct vattr *vap = ap->a_vap; 326 struct thread *td = cnp->cn_thread; 327 struct ucred *cred = cnp->cn_cred; 328 329 struct fuse_open_in *foi; 330 struct fuse_entry_out *feo; 331 struct fuse_dispatcher fdi; 332 struct fuse_dispatcher *fdip = &fdi; 333 334 int err; 335 336 struct mount *mp = vnode_mount(dvp); 337 uint64_t parentnid = VTOFUD(dvp)->nid; 338 mode_t mode = MAKEIMODE(vap->va_type, vap->va_mode); 339 uint64_t x_fh_id; 340 uint32_t x_open_flags; 341 342 fuse_trace_printf_vnop(); 343 344 if (fuse_isdeadfs(dvp)) { 345 return ENXIO; 346 } 347 bzero(&fdi, sizeof(fdi)); 348 349 /* XXX: Will we ever want devices ? */ 350 if ((vap->va_type != VREG)) { 351 printf("fuse_vnop_create: unsupported va_type %d\n", 352 vap->va_type); 353 return (EINVAL); 354 } 355 debug_printf("parent nid = %ju, mode = %x\n", (uintmax_t)parentnid, 356 mode); 357 358 fdisp_init(fdip, sizeof(*foi) + cnp->cn_namelen + 1); 359 if (!fsess_isimpl(mp, FUSE_CREATE)) { 360 debug_printf("eh, daemon doesn't implement create?\n"); 361 return (EINVAL); 362 } 363 fdisp_make(fdip, FUSE_CREATE, vnode_mount(dvp), parentnid, td, cred); 364 365 foi = fdip->indata; 366 foi->mode = mode; 367 foi->flags = O_CREAT | O_RDWR; 368 369 memcpy((char *)fdip->indata + sizeof(*foi), cnp->cn_nameptr, 370 cnp->cn_namelen); 371 ((char *)fdip->indata)[sizeof(*foi) + cnp->cn_namelen] = '\0'; 372 373 err = fdisp_wait_answ(fdip); 374 375 if (err) { 376 if (err == ENOSYS) 377 fsess_set_notimpl(mp, FUSE_CREATE); 378 debug_printf("create: got err=%d from daemon\n", err); 379 goto out; 380 } 381 382 feo = fdip->answ; 383 384 if ((err = fuse_internal_checkentry(feo, VREG))) { 385 goto out; 386 } 387 err = fuse_vnode_get(mp, feo->nodeid, dvp, vpp, cnp, VREG); 388 if (err) { 389 struct fuse_release_in *fri; 390 uint64_t nodeid = feo->nodeid; 391 uint64_t fh_id = ((struct fuse_open_out *)(feo + 1))->fh; 392 393 fdisp_init(fdip, sizeof(*fri)); 394 fdisp_make(fdip, FUSE_RELEASE, mp, nodeid, td, cred); 395 fri = fdip->indata; 396 fri->fh = fh_id; 397 fri->flags = OFLAGS(mode); 398 fuse_insert_callback(fdip->tick, fuse_internal_forget_callback); 399 fuse_insert_message(fdip->tick); 400 return err; 401 } 402 ASSERT_VOP_ELOCKED(*vpp, "fuse_vnop_create"); 403 404 fdip->answ = feo + 1; 405 406 x_fh_id = ((struct fuse_open_out *)(feo + 1))->fh; 407 x_open_flags = ((struct fuse_open_out *)(feo + 1))->open_flags; 408 fuse_filehandle_init(*vpp, FUFH_RDWR, NULL, x_fh_id); 409 fuse_vnode_open(*vpp, x_open_flags, td); 410 cache_purge_negative(dvp); 411 412 out: 413 fdisp_destroy(fdip); 414 return err; 415 } 416 417 /* 418 * Our vnop_fsync roughly corresponds to the FUSE_FSYNC method. The Linux 419 * version of FUSE also has a FUSE_FLUSH method. 420 * 421 * On Linux, fsync() synchronizes a file's complete in-core state with that 422 * on disk. The call is not supposed to return until the system has completed 423 * that action or until an error is detected. 424 * 425 * Linux also has an fdatasync() call that is similar to fsync() but is not 426 * required to update the metadata such as access time and modification time. 427 */ 428 429 /* 430 struct vnop_fsync_args { 431 struct vnodeop_desc *a_desc; 432 struct vnode * a_vp; 433 struct ucred * a_cred; 434 int a_waitfor; 435 struct thread * a_td; 436 }; 437 */ 438 static int 439 fuse_vnop_fsync(struct vop_fsync_args *ap) 440 { 441 struct vnode *vp = ap->a_vp; 442 struct thread *td = ap->a_td; 443 444 struct fuse_filehandle *fufh; 445 struct fuse_vnode_data *fvdat = VTOFUD(vp); 446 447 int type, err = 0; 448 449 fuse_trace_printf_vnop(); 450 451 if (fuse_isdeadfs(vp)) { 452 return 0; 453 } 454 if ((err = vop_stdfsync(ap))) 455 return err; 456 457 if (!fsess_isimpl(vnode_mount(vp), 458 (vnode_vtype(vp) == VDIR ? FUSE_FSYNCDIR : FUSE_FSYNC))) { 459 goto out; 460 } 461 for (type = 0; type < FUFH_MAXTYPE; type++) { 462 fufh = &(fvdat->fufh[type]); 463 if (FUFH_IS_VALID(fufh)) { 464 fuse_internal_fsync(vp, td, NULL, fufh); 465 } 466 } 467 468 out: 469 return 0; 470 } 471 472 /* 473 struct vnop_getattr_args { 474 struct vnode *a_vp; 475 struct vattr *a_vap; 476 struct ucred *a_cred; 477 struct thread *a_td; 478 }; 479 */ 480 static int 481 fuse_vnop_getattr(struct vop_getattr_args *ap) 482 { 483 struct vnode *vp = ap->a_vp; 484 struct vattr *vap = ap->a_vap; 485 struct ucred *cred = ap->a_cred; 486 struct thread *td = curthread; 487 struct fuse_vnode_data *fvdat = VTOFUD(vp); 488 489 int err = 0; 490 int dataflags; 491 struct fuse_dispatcher fdi; 492 493 FS_DEBUG2G("inode=%ju\n", (uintmax_t)VTOI(vp)); 494 495 dataflags = fuse_get_mpdata(vnode_mount(vp))->dataflags; 496 497 /* Note that we are not bailing out on a dead file system just yet. */ 498 499 if (!(dataflags & FSESS_INITED)) { 500 if (!vnode_isvroot(vp)) { 501 fdata_set_dead(fuse_get_mpdata(vnode_mount(vp))); 502 err = ENOTCONN; 503 debug_printf("fuse_getattr b: returning ENOTCONN\n"); 504 return err; 505 } else { 506 goto fake; 507 } 508 } 509 fdisp_init(&fdi, 0); 510 if ((err = fdisp_simple_putget_vp(&fdi, FUSE_GETATTR, vp, td, cred))) { 511 if ((err == ENOTCONN) && vnode_isvroot(vp)) { 512 /* see comment at similar place in fuse_statfs() */ 513 fdisp_destroy(&fdi); 514 goto fake; 515 } 516 if (err == ENOENT) { 517 fuse_internal_vnode_disappear(vp); 518 } 519 goto out; 520 } 521 cache_attrs(vp, (struct fuse_attr_out *)fdi.answ); 522 if (vap != VTOVA(vp)) { 523 memcpy(vap, VTOVA(vp), sizeof(*vap)); 524 } 525 if (vap->va_type != vnode_vtype(vp)) { 526 fuse_internal_vnode_disappear(vp); 527 err = ENOENT; 528 goto out; 529 } 530 if ((fvdat->flag & FN_SIZECHANGE) != 0) 531 vap->va_size = fvdat->filesize; 532 533 if (vnode_isreg(vp) && (fvdat->flag & FN_SIZECHANGE) == 0) { 534 /* 535 * This is for those cases when the file size changed without us 536 * knowing, and we want to catch up. 537 */ 538 off_t new_filesize = ((struct fuse_attr_out *) 539 fdi.answ)->attr.size; 540 541 if (fvdat->filesize != new_filesize) { 542 fuse_vnode_setsize(vp, cred, new_filesize); 543 } 544 } 545 debug_printf("fuse_getattr e: returning 0\n"); 546 547 out: 548 fdisp_destroy(&fdi); 549 return err; 550 551 fake: 552 bzero(vap, sizeof(*vap)); 553 vap->va_type = vnode_vtype(vp); 554 555 return 0; 556 } 557 558 /* 559 struct vnop_inactive_args { 560 struct vnode *a_vp; 561 struct thread *a_td; 562 }; 563 */ 564 static int 565 fuse_vnop_inactive(struct vop_inactive_args *ap) 566 { 567 struct vnode *vp = ap->a_vp; 568 struct thread *td = ap->a_td; 569 570 struct fuse_vnode_data *fvdat = VTOFUD(vp); 571 struct fuse_filehandle *fufh = NULL; 572 573 int type, need_flush = 1; 574 575 FS_DEBUG("inode=%ju\n", (uintmax_t)VTOI(vp)); 576 577 for (type = 0; type < FUFH_MAXTYPE; type++) { 578 fufh = &(fvdat->fufh[type]); 579 if (FUFH_IS_VALID(fufh)) { 580 if (need_flush && vp->v_type == VREG) { 581 if ((VTOFUD(vp)->flag & FN_SIZECHANGE) != 0) { 582 fuse_vnode_savesize(vp, NULL); 583 } 584 if (fuse_data_cache_invalidate || 585 (fvdat->flag & FN_REVOKED) != 0) 586 fuse_io_invalbuf(vp, td); 587 else 588 fuse_io_flushbuf(vp, MNT_WAIT, td); 589 need_flush = 0; 590 } 591 fuse_filehandle_close(vp, type, td, NULL); 592 } 593 } 594 595 if ((fvdat->flag & FN_REVOKED) != 0 && fuse_reclaim_revoked) { 596 vrecycle(vp); 597 } 598 return 0; 599 } 600 601 /* 602 struct vnop_link_args { 603 struct vnode *a_tdvp; 604 struct vnode *a_vp; 605 struct componentname *a_cnp; 606 }; 607 */ 608 static int 609 fuse_vnop_link(struct vop_link_args *ap) 610 { 611 struct vnode *vp = ap->a_vp; 612 struct vnode *tdvp = ap->a_tdvp; 613 struct componentname *cnp = ap->a_cnp; 614 615 struct vattr *vap = VTOVA(vp); 616 617 struct fuse_dispatcher fdi; 618 struct fuse_entry_out *feo; 619 struct fuse_link_in fli; 620 621 int err; 622 623 fuse_trace_printf_vnop(); 624 625 if (fuse_isdeadfs(vp)) { 626 return ENXIO; 627 } 628 if (vnode_mount(tdvp) != vnode_mount(vp)) { 629 return EXDEV; 630 } 631 if (vap->va_nlink >= FUSE_LINK_MAX) { 632 return EMLINK; 633 } 634 fli.oldnodeid = VTOI(vp); 635 636 fdisp_init(&fdi, 0); 637 fuse_internal_newentry_makerequest(vnode_mount(tdvp), VTOI(tdvp), cnp, 638 FUSE_LINK, &fli, sizeof(fli), &fdi); 639 if ((err = fdisp_wait_answ(&fdi))) { 640 goto out; 641 } 642 feo = fdi.answ; 643 644 err = fuse_internal_checkentry(feo, vnode_vtype(vp)); 645 out: 646 fdisp_destroy(&fdi); 647 return err; 648 } 649 650 /* 651 struct vnop_lookup_args { 652 struct vnodeop_desc *a_desc; 653 struct vnode *a_dvp; 654 struct vnode **a_vpp; 655 struct componentname *a_cnp; 656 }; 657 */ 658 int 659 fuse_vnop_lookup(struct vop_lookup_args *ap) 660 { 661 struct vnode *dvp = ap->a_dvp; 662 struct vnode **vpp = ap->a_vpp; 663 struct componentname *cnp = ap->a_cnp; 664 struct thread *td = cnp->cn_thread; 665 struct ucred *cred = cnp->cn_cred; 666 667 int nameiop = cnp->cn_nameiop; 668 int flags = cnp->cn_flags; 669 int wantparent = flags & (LOCKPARENT | WANTPARENT); 670 int islastcn = flags & ISLASTCN; 671 struct mount *mp = vnode_mount(dvp); 672 673 int err = 0; 674 int lookup_err = 0; 675 struct vnode *vp = NULL; 676 677 struct fuse_dispatcher fdi; 678 enum fuse_opcode op; 679 680 uint64_t nid; 681 struct fuse_access_param facp; 682 683 FS_DEBUG2G("parent_inode=%ju - %*s\n", 684 (uintmax_t)VTOI(dvp), (int)cnp->cn_namelen, cnp->cn_nameptr); 685 686 if (fuse_isdeadfs(dvp)) { 687 *vpp = NULL; 688 return ENXIO; 689 } 690 if (!vnode_isdir(dvp)) { 691 return ENOTDIR; 692 } 693 if (islastcn && vfs_isrdonly(mp) && (nameiop != LOOKUP)) { 694 return EROFS; 695 } 696 /* 697 * We do access check prior to doing anything else only in the case 698 * when we are at fs root (we'd like to say, "we are at the first 699 * component", but that's not exactly the same... nevermind). 700 * See further comments at further access checks. 701 */ 702 703 bzero(&facp, sizeof(facp)); 704 if (vnode_isvroot(dvp)) { /* early permission check hack */ 705 if ((err = fuse_internal_access(dvp, VEXEC, &facp, td, cred))) { 706 return err; 707 } 708 } 709 if (flags & ISDOTDOT) { 710 nid = VTOFUD(dvp)->parent_nid; 711 if (nid == 0) { 712 return ENOENT; 713 } 714 fdisp_init(&fdi, 0); 715 op = FUSE_GETATTR; 716 goto calldaemon; 717 } else if (cnp->cn_namelen == 1 && *(cnp->cn_nameptr) == '.') { 718 nid = VTOI(dvp); 719 fdisp_init(&fdi, 0); 720 op = FUSE_GETATTR; 721 goto calldaemon; 722 } else if (fuse_lookup_cache_enable) { 723 err = cache_lookup(dvp, vpp, cnp, NULL, NULL); 724 switch (err) { 725 726 case -1: /* positive match */ 727 atomic_add_acq_long(&fuse_lookup_cache_hits, 1); 728 return 0; 729 730 case 0: /* no match in cache */ 731 atomic_add_acq_long(&fuse_lookup_cache_misses, 1); 732 break; 733 734 case ENOENT: /* negative match */ 735 /* fall through */ 736 default: 737 return err; 738 } 739 } 740 nid = VTOI(dvp); 741 fdisp_init(&fdi, cnp->cn_namelen + 1); 742 op = FUSE_LOOKUP; 743 744 calldaemon: 745 fdisp_make(&fdi, op, mp, nid, td, cred); 746 747 if (op == FUSE_LOOKUP) { 748 memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen); 749 ((char *)fdi.indata)[cnp->cn_namelen] = '\0'; 750 } 751 lookup_err = fdisp_wait_answ(&fdi); 752 753 if ((op == FUSE_LOOKUP) && !lookup_err) { /* lookup call succeeded */ 754 nid = ((struct fuse_entry_out *)fdi.answ)->nodeid; 755 if (!nid) { 756 /* 757 * zero nodeid is the same as "not found", 758 * but it's also cacheable (which we keep 759 * keep on doing not as of writing this) 760 */ 761 lookup_err = ENOENT; 762 } else if (nid == FUSE_ROOT_ID) { 763 lookup_err = EINVAL; 764 } 765 } 766 if (lookup_err && 767 (!fdi.answ_stat || lookup_err != ENOENT || op != FUSE_LOOKUP)) { 768 fdisp_destroy(&fdi); 769 return lookup_err; 770 } 771 /* lookup_err, if non-zero, must be ENOENT at this point */ 772 773 if (lookup_err) { 774 775 if ((nameiop == CREATE || nameiop == RENAME) && islastcn 776 /* && directory dvp has not been removed */ ) { 777 778 if (vfs_isrdonly(mp)) { 779 err = EROFS; 780 goto out; 781 } 782 #if 0 /* THINK_ABOUT_THIS */ 783 if ((err = fuse_internal_access(dvp, VWRITE, cred, td, &facp))) { 784 goto out; 785 } 786 #endif 787 788 /* 789 * Possibly record the position of a slot in the 790 * directory large enough for the new component name. 791 * This can be recorded in the vnode private data for 792 * dvp. Set the SAVENAME flag to hold onto the 793 * pathname for use later in VOP_CREATE or VOP_RENAME. 794 */ 795 cnp->cn_flags |= SAVENAME; 796 797 err = EJUSTRETURN; 798 goto out; 799 } 800 /* Consider inserting name into cache. */ 801 802 /* 803 * No we can't use negative caching, as the fs 804 * changes are out of our control. 805 * False positives' falseness turns out just as things 806 * go by, but false negatives' falseness doesn't. 807 * (and aiding the caching mechanism with extra control 808 * mechanisms comes quite close to beating the whole purpose 809 * caching...) 810 */ 811 #if 0 812 if ((cnp->cn_flags & MAKEENTRY) != 0) { 813 FS_DEBUG("inserting NULL into cache\n"); 814 cache_enter(dvp, NULL, cnp); 815 } 816 #endif 817 err = ENOENT; 818 goto out; 819 820 } else { 821 822 /* !lookup_err */ 823 824 struct fuse_entry_out *feo = NULL; 825 struct fuse_attr *fattr = NULL; 826 827 if (op == FUSE_GETATTR) { 828 fattr = &((struct fuse_attr_out *)fdi.answ)->attr; 829 } else { 830 feo = (struct fuse_entry_out *)fdi.answ; 831 fattr = &(feo->attr); 832 } 833 834 /* 835 * If deleting, and at end of pathname, return parameters 836 * which can be used to remove file. If the wantparent flag 837 * isn't set, we return only the directory, otherwise we go on 838 * and lock the inode, being careful with ".". 839 */ 840 if (nameiop == DELETE && islastcn) { 841 /* 842 * Check for write access on directory. 843 */ 844 facp.xuid = fattr->uid; 845 facp.facc_flags |= FACCESS_STICKY; 846 err = fuse_internal_access(dvp, VWRITE, &facp, td, cred); 847 facp.facc_flags &= ~FACCESS_XQUERIES; 848 849 if (err) { 850 goto out; 851 } 852 if (nid == VTOI(dvp)) { 853 vref(dvp); 854 *vpp = dvp; 855 } else { 856 err = fuse_vnode_get(dvp->v_mount, nid, dvp, 857 &vp, cnp, IFTOVT(fattr->mode)); 858 if (err) 859 goto out; 860 *vpp = vp; 861 } 862 863 /* 864 * Save the name for use in VOP_RMDIR and VOP_REMOVE 865 * later. 866 */ 867 cnp->cn_flags |= SAVENAME; 868 goto out; 869 870 } 871 /* 872 * If rewriting (RENAME), return the inode and the 873 * information required to rewrite the present directory 874 * Must get inode of directory entry to verify it's a 875 * regular file, or empty directory. 876 */ 877 if (nameiop == RENAME && wantparent && islastcn) { 878 879 #if 0 /* THINK_ABOUT_THIS */ 880 if ((err = fuse_internal_access(dvp, VWRITE, cred, td, &facp))) { 881 goto out; 882 } 883 #endif 884 885 /* 886 * Check for "." 887 */ 888 if (nid == VTOI(dvp)) { 889 err = EISDIR; 890 goto out; 891 } 892 err = fuse_vnode_get(vnode_mount(dvp), 893 nid, 894 dvp, 895 &vp, 896 cnp, 897 IFTOVT(fattr->mode)); 898 if (err) { 899 goto out; 900 } 901 *vpp = vp; 902 /* 903 * Save the name for use in VOP_RENAME later. 904 */ 905 cnp->cn_flags |= SAVENAME; 906 907 goto out; 908 } 909 if (flags & ISDOTDOT) { 910 struct mount *mp; 911 int ltype; 912 913 /* 914 * Expanded copy of vn_vget_ino() so that 915 * fuse_vnode_get() can be used. 916 */ 917 mp = dvp->v_mount; 918 ltype = VOP_ISLOCKED(dvp); 919 err = vfs_busy(mp, MBF_NOWAIT); 920 if (err != 0) { 921 vfs_ref(mp); 922 VOP_UNLOCK(dvp, 0); 923 err = vfs_busy(mp, 0); 924 vn_lock(dvp, ltype | LK_RETRY); 925 vfs_rel(mp); 926 if (err) 927 goto out; 928 if ((dvp->v_iflag & VI_DOOMED) != 0) { 929 err = ENOENT; 930 vfs_unbusy(mp); 931 goto out; 932 } 933 } 934 VOP_UNLOCK(dvp, 0); 935 err = fuse_vnode_get(vnode_mount(dvp), 936 nid, 937 NULL, 938 &vp, 939 cnp, 940 IFTOVT(fattr->mode)); 941 vfs_unbusy(mp); 942 vn_lock(dvp, ltype | LK_RETRY); 943 if ((dvp->v_iflag & VI_DOOMED) != 0) { 944 if (err == 0) 945 vput(vp); 946 err = ENOENT; 947 } 948 if (err) 949 goto out; 950 *vpp = vp; 951 } else if (nid == VTOI(dvp)) { 952 vref(dvp); 953 *vpp = dvp; 954 } else { 955 err = fuse_vnode_get(vnode_mount(dvp), 956 nid, 957 dvp, 958 &vp, 959 cnp, 960 IFTOVT(fattr->mode)); 961 if (err) { 962 goto out; 963 } 964 fuse_vnode_setparent(vp, dvp); 965 *vpp = vp; 966 } 967 968 if (op == FUSE_GETATTR) { 969 cache_attrs(*vpp, (struct fuse_attr_out *)fdi.answ); 970 } else { 971 cache_attrs(*vpp, (struct fuse_entry_out *)fdi.answ); 972 } 973 974 /* Insert name into cache if appropriate. */ 975 976 /* 977 * Nooo, caching is evil. With caching, we can't avoid stale 978 * information taking over the playground (cached info is not 979 * just positive/negative, it does have qualitative aspects, 980 * too). And a (VOP/FUSE)_GETATTR is always thrown anyway, when 981 * walking down along cached path components, and that's not 982 * any cheaper than FUSE_LOOKUP. This might change with 983 * implementing kernel side attr caching, but... In Linux, 984 * lookup results are not cached, and the daemon is bombarded 985 * with FUSE_LOOKUPS on and on. This shows that by design, the 986 * daemon is expected to handle frequent lookup queries 987 * efficiently, do its caching in userspace, and so on. 988 * 989 * So just leave the name cache alone. 990 */ 991 992 /* 993 * Well, now I know, Linux caches lookups, but with a 994 * timeout... So it's the same thing as attribute caching: 995 * we can deal with it when implement timeouts. 996 */ 997 #if 0 998 if (cnp->cn_flags & MAKEENTRY) { 999 cache_enter(dvp, *vpp, cnp); 1000 } 1001 #endif 1002 } 1003 out: 1004 if (!lookup_err) { 1005 1006 /* No lookup error; need to clean up. */ 1007 1008 if (err) { /* Found inode; exit with no vnode. */ 1009 if (op == FUSE_LOOKUP) { 1010 fuse_internal_forget_send(vnode_mount(dvp), td, cred, 1011 nid, 1); 1012 } 1013 fdisp_destroy(&fdi); 1014 return err; 1015 } else { 1016 #ifndef NO_EARLY_PERM_CHECK_HACK 1017 if (!islastcn) { 1018 /* 1019 * We have the attributes of the next item 1020 * *now*, and it's a fact, and we do not 1021 * have to do extra work for it (ie, beg the 1022 * daemon), and it neither depends on such 1023 * accidental things like attr caching. So 1024 * the big idea: check credentials *now*, 1025 * not at the beginning of the next call to 1026 * lookup. 1027 * 1028 * The first item of the lookup chain (fs root) 1029 * won't be checked then here, of course, as 1030 * its never "the next". But go and see that 1031 * the root is taken care about at the very 1032 * beginning of this function. 1033 * 1034 * Now, given we want to do the access check 1035 * this way, one might ask: so then why not 1036 * do the access check just after fetching 1037 * the inode and its attributes from the 1038 * daemon? Why bother with producing the 1039 * corresponding vnode at all if something 1040 * is not OK? We know what's the deal as 1041 * soon as we get those attrs... There is 1042 * one bit of info though not given us by 1043 * the daemon: whether his response is 1044 * authoritative or not... His response should 1045 * be ignored if something is mounted over 1046 * the dir in question. But that can be 1047 * known only by having the vnode... 1048 */ 1049 int tmpvtype = vnode_vtype(*vpp); 1050 1051 bzero(&facp, sizeof(facp)); 1052 /*the early perm check hack */ 1053 facp.facc_flags |= FACCESS_VA_VALID; 1054 1055 if ((tmpvtype != VDIR) && (tmpvtype != VLNK)) { 1056 err = ENOTDIR; 1057 } 1058 if (!err && !vnode_mountedhere(*vpp)) { 1059 err = fuse_internal_access(*vpp, VEXEC, &facp, td, cred); 1060 } 1061 if (err) { 1062 if (tmpvtype == VLNK) 1063 FS_DEBUG("weird, permission error with a symlink?\n"); 1064 vput(*vpp); 1065 *vpp = NULL; 1066 } 1067 } 1068 #endif 1069 } 1070 } 1071 fdisp_destroy(&fdi); 1072 1073 return err; 1074 } 1075 1076 /* 1077 struct vnop_mkdir_args { 1078 struct vnode *a_dvp; 1079 struct vnode **a_vpp; 1080 struct componentname *a_cnp; 1081 struct vattr *a_vap; 1082 }; 1083 */ 1084 static int 1085 fuse_vnop_mkdir(struct vop_mkdir_args *ap) 1086 { 1087 struct vnode *dvp = ap->a_dvp; 1088 struct vnode **vpp = ap->a_vpp; 1089 struct componentname *cnp = ap->a_cnp; 1090 struct vattr *vap = ap->a_vap; 1091 1092 struct fuse_mkdir_in fmdi; 1093 1094 fuse_trace_printf_vnop(); 1095 1096 if (fuse_isdeadfs(dvp)) { 1097 return ENXIO; 1098 } 1099 fmdi.mode = MAKEIMODE(vap->va_type, vap->va_mode); 1100 1101 return (fuse_internal_newentry(dvp, vpp, cnp, FUSE_MKDIR, &fmdi, 1102 sizeof(fmdi), VDIR)); 1103 } 1104 1105 /* 1106 struct vnop_mknod_args { 1107 struct vnode *a_dvp; 1108 struct vnode **a_vpp; 1109 struct componentname *a_cnp; 1110 struct vattr *a_vap; 1111 }; 1112 */ 1113 static int 1114 fuse_vnop_mknod(struct vop_mknod_args *ap) 1115 { 1116 1117 return (EINVAL); 1118 } 1119 1120 1121 /* 1122 struct vnop_open_args { 1123 struct vnode *a_vp; 1124 int a_mode; 1125 struct ucred *a_cred; 1126 struct thread *a_td; 1127 int a_fdidx; / struct file *a_fp; 1128 }; 1129 */ 1130 static int 1131 fuse_vnop_open(struct vop_open_args *ap) 1132 { 1133 struct vnode *vp = ap->a_vp; 1134 int mode = ap->a_mode; 1135 struct thread *td = ap->a_td; 1136 struct ucred *cred = ap->a_cred; 1137 1138 fufh_type_t fufh_type; 1139 struct fuse_vnode_data *fvdat; 1140 1141 int error, isdir = 0; 1142 int32_t fuse_open_flags; 1143 1144 FS_DEBUG2G("inode=%ju mode=0x%x\n", (uintmax_t)VTOI(vp), mode); 1145 1146 if (fuse_isdeadfs(vp)) { 1147 return ENXIO; 1148 } 1149 fvdat = VTOFUD(vp); 1150 1151 if (vnode_isdir(vp)) { 1152 isdir = 1; 1153 } 1154 fuse_open_flags = 0; 1155 if (isdir) { 1156 fufh_type = FUFH_RDONLY; 1157 } else { 1158 fufh_type = fuse_filehandle_xlate_from_fflags(mode); 1159 /* 1160 * For WRONLY opens, force DIRECT_IO. This is necessary 1161 * since writing a partial block through the buffer cache 1162 * will result in a read of the block and that read won't 1163 * be allowed by the WRONLY open. 1164 */ 1165 if (fufh_type == FUFH_WRONLY || 1166 (fvdat->flag & FN_DIRECTIO) != 0) 1167 fuse_open_flags = FOPEN_DIRECT_IO; 1168 } 1169 1170 if (fuse_filehandle_validrw(vp, fufh_type) != FUFH_INVALID) { 1171 fuse_vnode_open(vp, fuse_open_flags, td); 1172 return 0; 1173 } 1174 error = fuse_filehandle_open(vp, fufh_type, NULL, td, cred); 1175 1176 return error; 1177 } 1178 1179 static int 1180 fuse_vnop_pathconf(struct vop_pathconf_args *ap) 1181 { 1182 1183 switch (ap->a_name) { 1184 case _PC_FILESIZEBITS: 1185 *ap->a_retval = 64; 1186 return (0); 1187 case _PC_NAME_MAX: 1188 *ap->a_retval = NAME_MAX; 1189 return (0); 1190 case _PC_LINK_MAX: 1191 *ap->a_retval = MIN(LONG_MAX, FUSE_LINK_MAX); 1192 return (0); 1193 case _PC_SYMLINK_MAX: 1194 *ap->a_retval = MAXPATHLEN; 1195 return (0); 1196 case _PC_NO_TRUNC: 1197 *ap->a_retval = 1; 1198 return (0); 1199 default: 1200 return (vop_stdpathconf(ap)); 1201 } 1202 } 1203 1204 /* 1205 struct vnop_read_args { 1206 struct vnode *a_vp; 1207 struct uio *a_uio; 1208 int a_ioflag; 1209 struct ucred *a_cred; 1210 }; 1211 */ 1212 static int 1213 fuse_vnop_read(struct vop_read_args *ap) 1214 { 1215 struct vnode *vp = ap->a_vp; 1216 struct uio *uio = ap->a_uio; 1217 int ioflag = ap->a_ioflag; 1218 struct ucred *cred = ap->a_cred; 1219 1220 FS_DEBUG2G("inode=%ju offset=%jd resid=%zd\n", 1221 (uintmax_t)VTOI(vp), uio->uio_offset, uio->uio_resid); 1222 1223 if (fuse_isdeadfs(vp)) { 1224 return ENXIO; 1225 } 1226 1227 if (VTOFUD(vp)->flag & FN_DIRECTIO) { 1228 ioflag |= IO_DIRECT; 1229 } 1230 1231 return fuse_io_dispatch(vp, uio, ioflag, cred); 1232 } 1233 1234 /* 1235 struct vnop_readdir_args { 1236 struct vnode *a_vp; 1237 struct uio *a_uio; 1238 struct ucred *a_cred; 1239 int *a_eofflag; 1240 int *ncookies; 1241 u_long **a_cookies; 1242 }; 1243 */ 1244 static int 1245 fuse_vnop_readdir(struct vop_readdir_args *ap) 1246 { 1247 struct vnode *vp = ap->a_vp; 1248 struct uio *uio = ap->a_uio; 1249 struct ucred *cred = ap->a_cred; 1250 1251 struct fuse_filehandle *fufh = NULL; 1252 struct fuse_iov cookediov; 1253 1254 int err = 0; 1255 int freefufh = 0; 1256 1257 FS_DEBUG2G("inode=%ju\n", (uintmax_t)VTOI(vp)); 1258 1259 if (fuse_isdeadfs(vp)) { 1260 return ENXIO; 1261 } 1262 if ( /* XXXIP ((uio_iovcnt(uio) > 1)) || */ 1263 (uio_resid(uio) < sizeof(struct dirent))) { 1264 return EINVAL; 1265 } 1266 1267 if (!fuse_filehandle_valid(vp, FUFH_RDONLY)) { 1268 FS_DEBUG("calling readdir() before open()"); 1269 err = fuse_filehandle_open(vp, FUFH_RDONLY, &fufh, NULL, cred); 1270 freefufh = 1; 1271 } else { 1272 err = fuse_filehandle_get(vp, FUFH_RDONLY, &fufh); 1273 } 1274 if (err) { 1275 return (err); 1276 } 1277 #define DIRCOOKEDSIZE FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + MAXNAMLEN + 1) 1278 fiov_init(&cookediov, DIRCOOKEDSIZE); 1279 1280 err = fuse_internal_readdir(vp, uio, fufh, &cookediov); 1281 1282 fiov_teardown(&cookediov); 1283 if (freefufh) { 1284 fuse_filehandle_close(vp, FUFH_RDONLY, NULL, cred); 1285 } 1286 return err; 1287 } 1288 1289 /* 1290 struct vnop_readlink_args { 1291 struct vnode *a_vp; 1292 struct uio *a_uio; 1293 struct ucred *a_cred; 1294 }; 1295 */ 1296 static int 1297 fuse_vnop_readlink(struct vop_readlink_args *ap) 1298 { 1299 struct vnode *vp = ap->a_vp; 1300 struct uio *uio = ap->a_uio; 1301 struct ucred *cred = ap->a_cred; 1302 1303 struct fuse_dispatcher fdi; 1304 int err; 1305 1306 FS_DEBUG2G("inode=%ju\n", (uintmax_t)VTOI(vp)); 1307 1308 if (fuse_isdeadfs(vp)) { 1309 return ENXIO; 1310 } 1311 if (!vnode_islnk(vp)) { 1312 return EINVAL; 1313 } 1314 fdisp_init(&fdi, 0); 1315 err = fdisp_simple_putget_vp(&fdi, FUSE_READLINK, vp, curthread, cred); 1316 if (err) { 1317 goto out; 1318 } 1319 if (((char *)fdi.answ)[0] == '/' && 1320 fuse_get_mpdata(vnode_mount(vp))->dataflags & FSESS_PUSH_SYMLINKS_IN) { 1321 char *mpth = vnode_mount(vp)->mnt_stat.f_mntonname; 1322 1323 err = uiomove(mpth, strlen(mpth), uio); 1324 } 1325 if (!err) { 1326 err = uiomove(fdi.answ, fdi.iosize, uio); 1327 } 1328 out: 1329 fdisp_destroy(&fdi); 1330 return err; 1331 } 1332 1333 /* 1334 struct vnop_reclaim_args { 1335 struct vnode *a_vp; 1336 struct thread *a_td; 1337 }; 1338 */ 1339 static int 1340 fuse_vnop_reclaim(struct vop_reclaim_args *ap) 1341 { 1342 struct vnode *vp = ap->a_vp; 1343 struct thread *td = ap->a_td; 1344 1345 struct fuse_vnode_data *fvdat = VTOFUD(vp); 1346 struct fuse_filehandle *fufh = NULL; 1347 1348 int type; 1349 1350 if (!fvdat) { 1351 panic("FUSE: no vnode data during recycling"); 1352 } 1353 FS_DEBUG("inode=%ju\n", (uintmax_t)VTOI(vp)); 1354 1355 for (type = 0; type < FUFH_MAXTYPE; type++) { 1356 fufh = &(fvdat->fufh[type]); 1357 if (FUFH_IS_VALID(fufh)) { 1358 printf("FUSE: vnode being reclaimed but fufh (type=%d) is valid", 1359 type); 1360 fuse_filehandle_close(vp, type, td, NULL); 1361 } 1362 } 1363 1364 if ((!fuse_isdeadfs(vp)) && (fvdat->nlookup)) { 1365 fuse_internal_forget_send(vnode_mount(vp), td, NULL, VTOI(vp), 1366 fvdat->nlookup); 1367 } 1368 fuse_vnode_setparent(vp, NULL); 1369 cache_purge(vp); 1370 vfs_hash_remove(vp); 1371 vnode_destroy_vobject(vp); 1372 fuse_vnode_destroy(vp); 1373 1374 return 0; 1375 } 1376 1377 /* 1378 struct vnop_remove_args { 1379 struct vnode *a_dvp; 1380 struct vnode *a_vp; 1381 struct componentname *a_cnp; 1382 }; 1383 */ 1384 static int 1385 fuse_vnop_remove(struct vop_remove_args *ap) 1386 { 1387 struct vnode *dvp = ap->a_dvp; 1388 struct vnode *vp = ap->a_vp; 1389 struct componentname *cnp = ap->a_cnp; 1390 1391 int err; 1392 1393 FS_DEBUG2G("inode=%ju name=%*s\n", 1394 (uintmax_t)VTOI(vp), (int)cnp->cn_namelen, cnp->cn_nameptr); 1395 1396 if (fuse_isdeadfs(vp)) { 1397 return ENXIO; 1398 } 1399 if (vnode_isdir(vp)) { 1400 return EPERM; 1401 } 1402 cache_purge(vp); 1403 1404 err = fuse_internal_remove(dvp, vp, cnp, FUSE_UNLINK); 1405 1406 if (err == 0) 1407 fuse_internal_vnode_disappear(vp); 1408 return err; 1409 } 1410 1411 /* 1412 struct vnop_rename_args { 1413 struct vnode *a_fdvp; 1414 struct vnode *a_fvp; 1415 struct componentname *a_fcnp; 1416 struct vnode *a_tdvp; 1417 struct vnode *a_tvp; 1418 struct componentname *a_tcnp; 1419 }; 1420 */ 1421 static int 1422 fuse_vnop_rename(struct vop_rename_args *ap) 1423 { 1424 struct vnode *fdvp = ap->a_fdvp; 1425 struct vnode *fvp = ap->a_fvp; 1426 struct componentname *fcnp = ap->a_fcnp; 1427 struct vnode *tdvp = ap->a_tdvp; 1428 struct vnode *tvp = ap->a_tvp; 1429 struct componentname *tcnp = ap->a_tcnp; 1430 struct fuse_data *data; 1431 1432 int err = 0; 1433 1434 FS_DEBUG2G("from: inode=%ju name=%*s -> to: inode=%ju name=%*s\n", 1435 (uintmax_t)VTOI(fvp), (int)fcnp->cn_namelen, fcnp->cn_nameptr, 1436 (uintmax_t)(tvp == NULL ? -1 : VTOI(tvp)), 1437 (int)tcnp->cn_namelen, tcnp->cn_nameptr); 1438 1439 if (fuse_isdeadfs(fdvp)) { 1440 return ENXIO; 1441 } 1442 if (fvp->v_mount != tdvp->v_mount || 1443 (tvp && fvp->v_mount != tvp->v_mount)) { 1444 FS_DEBUG("cross-device rename: %s -> %s\n", 1445 fcnp->cn_nameptr, (tcnp != NULL ? tcnp->cn_nameptr : "(NULL)")); 1446 err = EXDEV; 1447 goto out; 1448 } 1449 cache_purge(fvp); 1450 1451 /* 1452 * FUSE library is expected to check if target directory is not 1453 * under the source directory in the file system tree. 1454 * Linux performs this check at VFS level. 1455 */ 1456 data = fuse_get_mpdata(vnode_mount(tdvp)); 1457 sx_xlock(&data->rename_lock); 1458 err = fuse_internal_rename(fdvp, fcnp, tdvp, tcnp); 1459 if (err == 0) { 1460 if (tdvp != fdvp) 1461 fuse_vnode_setparent(fvp, tdvp); 1462 if (tvp != NULL) 1463 fuse_vnode_setparent(tvp, NULL); 1464 } 1465 sx_unlock(&data->rename_lock); 1466 1467 if (tvp != NULL && tvp != fvp) { 1468 cache_purge(tvp); 1469 } 1470 if (vnode_isdir(fvp)) { 1471 if ((tvp != NULL) && vnode_isdir(tvp)) { 1472 cache_purge(tdvp); 1473 } 1474 cache_purge(fdvp); 1475 } 1476 out: 1477 if (tdvp == tvp) { 1478 vrele(tdvp); 1479 } else { 1480 vput(tdvp); 1481 } 1482 if (tvp != NULL) { 1483 vput(tvp); 1484 } 1485 vrele(fdvp); 1486 vrele(fvp); 1487 1488 return err; 1489 } 1490 1491 /* 1492 struct vnop_rmdir_args { 1493 struct vnode *a_dvp; 1494 struct vnode *a_vp; 1495 struct componentname *a_cnp; 1496 } *ap; 1497 */ 1498 static int 1499 fuse_vnop_rmdir(struct vop_rmdir_args *ap) 1500 { 1501 struct vnode *dvp = ap->a_dvp; 1502 struct vnode *vp = ap->a_vp; 1503 1504 int err; 1505 1506 FS_DEBUG2G("inode=%ju\n", (uintmax_t)VTOI(vp)); 1507 1508 if (fuse_isdeadfs(vp)) { 1509 return ENXIO; 1510 } 1511 if (VTOFUD(vp) == VTOFUD(dvp)) { 1512 return EINVAL; 1513 } 1514 err = fuse_internal_remove(dvp, vp, ap->a_cnp, FUSE_RMDIR); 1515 1516 if (err == 0) 1517 fuse_internal_vnode_disappear(vp); 1518 return err; 1519 } 1520 1521 /* 1522 struct vnop_setattr_args { 1523 struct vnode *a_vp; 1524 struct vattr *a_vap; 1525 struct ucred *a_cred; 1526 struct thread *a_td; 1527 }; 1528 */ 1529 static int 1530 fuse_vnop_setattr(struct vop_setattr_args *ap) 1531 { 1532 struct vnode *vp = ap->a_vp; 1533 struct vattr *vap = ap->a_vap; 1534 struct ucred *cred = ap->a_cred; 1535 struct thread *td = curthread; 1536 1537 struct fuse_dispatcher fdi; 1538 struct fuse_setattr_in *fsai; 1539 struct fuse_access_param facp; 1540 1541 int err = 0; 1542 enum vtype vtyp; 1543 int sizechanged = 0; 1544 uint64_t newsize = 0; 1545 1546 FS_DEBUG2G("inode=%ju\n", (uintmax_t)VTOI(vp)); 1547 1548 if (fuse_isdeadfs(vp)) { 1549 return ENXIO; 1550 } 1551 fdisp_init(&fdi, sizeof(*fsai)); 1552 fdisp_make_vp(&fdi, FUSE_SETATTR, vp, td, cred); 1553 fsai = fdi.indata; 1554 fsai->valid = 0; 1555 1556 bzero(&facp, sizeof(facp)); 1557 1558 facp.xuid = vap->va_uid; 1559 facp.xgid = vap->va_gid; 1560 1561 if (vap->va_uid != (uid_t)VNOVAL) { 1562 facp.facc_flags |= FACCESS_CHOWN; 1563 fsai->uid = vap->va_uid; 1564 fsai->valid |= FATTR_UID; 1565 } 1566 if (vap->va_gid != (gid_t)VNOVAL) { 1567 facp.facc_flags |= FACCESS_CHOWN; 1568 fsai->gid = vap->va_gid; 1569 fsai->valid |= FATTR_GID; 1570 } 1571 if (vap->va_size != VNOVAL) { 1572 1573 struct fuse_filehandle *fufh = NULL; 1574 1575 /*Truncate to a new value. */ 1576 fsai->size = vap->va_size; 1577 sizechanged = 1; 1578 newsize = vap->va_size; 1579 fsai->valid |= FATTR_SIZE; 1580 1581 fuse_filehandle_getrw(vp, FUFH_WRONLY, &fufh); 1582 if (fufh) { 1583 fsai->fh = fufh->fh_id; 1584 fsai->valid |= FATTR_FH; 1585 } 1586 } 1587 if (vap->va_atime.tv_sec != VNOVAL) { 1588 fsai->atime = vap->va_atime.tv_sec; 1589 fsai->atimensec = vap->va_atime.tv_nsec; 1590 fsai->valid |= FATTR_ATIME; 1591 } 1592 if (vap->va_mtime.tv_sec != VNOVAL) { 1593 fsai->mtime = vap->va_mtime.tv_sec; 1594 fsai->mtimensec = vap->va_mtime.tv_nsec; 1595 fsai->valid |= FATTR_MTIME; 1596 } 1597 if (vap->va_mode != (mode_t)VNOVAL) { 1598 fsai->mode = vap->va_mode & ALLPERMS; 1599 fsai->valid |= FATTR_MODE; 1600 } 1601 if (!fsai->valid) { 1602 goto out; 1603 } 1604 vtyp = vnode_vtype(vp); 1605 1606 if (fsai->valid & FATTR_SIZE && vtyp == VDIR) { 1607 err = EISDIR; 1608 goto out; 1609 } 1610 if (vfs_isrdonly(vnode_mount(vp)) && (fsai->valid & ~FATTR_SIZE || vtyp == VREG)) { 1611 err = EROFS; 1612 goto out; 1613 } 1614 if (fsai->valid & ~FATTR_SIZE) { 1615 /*err = fuse_internal_access(vp, VADMIN, context, &facp); */ 1616 /*XXX */ 1617 err = 0; 1618 } 1619 facp.facc_flags &= ~FACCESS_XQUERIES; 1620 1621 if (err && !(fsai->valid & ~(FATTR_ATIME | FATTR_MTIME)) && 1622 vap->va_vaflags & VA_UTIMES_NULL) { 1623 err = fuse_internal_access(vp, VWRITE, &facp, td, cred); 1624 } 1625 if (err) 1626 goto out; 1627 if ((err = fdisp_wait_answ(&fdi))) 1628 goto out; 1629 vtyp = IFTOVT(((struct fuse_attr_out *)fdi.answ)->attr.mode); 1630 1631 if (vnode_vtype(vp) != vtyp) { 1632 if (vnode_vtype(vp) == VNON && vtyp != VNON) { 1633 debug_printf("FUSE: Dang! vnode_vtype is VNON and vtype isn't.\n"); 1634 } else { 1635 /* 1636 * STALE vnode, ditch 1637 * 1638 * The vnode has changed its type "behind our back". There's 1639 * nothing really we can do, so let us just force an internal 1640 * revocation and tell the caller to try again, if interested. 1641 */ 1642 fuse_internal_vnode_disappear(vp); 1643 err = EAGAIN; 1644 } 1645 } 1646 if (!err && !sizechanged) { 1647 cache_attrs(vp, (struct fuse_attr_out *)fdi.answ); 1648 } 1649 out: 1650 fdisp_destroy(&fdi); 1651 if (!err && sizechanged) { 1652 fuse_vnode_setsize(vp, cred, newsize); 1653 VTOFUD(vp)->flag &= ~FN_SIZECHANGE; 1654 } 1655 return err; 1656 } 1657 1658 /* 1659 struct vnop_strategy_args { 1660 struct vnode *a_vp; 1661 struct buf *a_bp; 1662 }; 1663 */ 1664 static int 1665 fuse_vnop_strategy(struct vop_strategy_args *ap) 1666 { 1667 struct vnode *vp = ap->a_vp; 1668 struct buf *bp = ap->a_bp; 1669 1670 fuse_trace_printf_vnop(); 1671 1672 if (!vp || fuse_isdeadfs(vp)) { 1673 bp->b_ioflags |= BIO_ERROR; 1674 bp->b_error = ENXIO; 1675 bufdone(bp); 1676 return ENXIO; 1677 } 1678 if (bp->b_iocmd == BIO_WRITE) 1679 fuse_vnode_refreshsize(vp, NOCRED); 1680 1681 (void)fuse_io_strategy(vp, bp); 1682 1683 /* 1684 * This is a dangerous function. If returns error, that might mean a 1685 * panic. We prefer pretty much anything over being forced to panic 1686 * by a malicious daemon (a demon?). So we just return 0 anyway. You 1687 * should never mind this: this function has its own error 1688 * propagation mechanism via the argument buffer, so 1689 * not-that-melodramatic residents of the call chain still will be 1690 * able to know what to do. 1691 */ 1692 return 0; 1693 } 1694 1695 1696 /* 1697 struct vnop_symlink_args { 1698 struct vnode *a_dvp; 1699 struct vnode **a_vpp; 1700 struct componentname *a_cnp; 1701 struct vattr *a_vap; 1702 char *a_target; 1703 }; 1704 */ 1705 static int 1706 fuse_vnop_symlink(struct vop_symlink_args *ap) 1707 { 1708 struct vnode *dvp = ap->a_dvp; 1709 struct vnode **vpp = ap->a_vpp; 1710 struct componentname *cnp = ap->a_cnp; 1711 char *target = ap->a_target; 1712 1713 struct fuse_dispatcher fdi; 1714 1715 int err; 1716 size_t len; 1717 1718 FS_DEBUG2G("inode=%ju name=%*s\n", 1719 (uintmax_t)VTOI(dvp), (int)cnp->cn_namelen, cnp->cn_nameptr); 1720 1721 if (fuse_isdeadfs(dvp)) { 1722 return ENXIO; 1723 } 1724 /* 1725 * Unlike the other creator type calls, here we have to create a message 1726 * where the name of the new entry comes first, and the data describing 1727 * the entry comes second. 1728 * Hence we can't rely on our handy fuse_internal_newentry() routine, 1729 * but put together the message manually and just call the core part. 1730 */ 1731 1732 len = strlen(target) + 1; 1733 fdisp_init(&fdi, len + cnp->cn_namelen + 1); 1734 fdisp_make_vp(&fdi, FUSE_SYMLINK, dvp, curthread, NULL); 1735 1736 memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen); 1737 ((char *)fdi.indata)[cnp->cn_namelen] = '\0'; 1738 memcpy((char *)fdi.indata + cnp->cn_namelen + 1, target, len); 1739 1740 err = fuse_internal_newentry_core(dvp, vpp, cnp, VLNK, &fdi); 1741 fdisp_destroy(&fdi); 1742 return err; 1743 } 1744 1745 /* 1746 struct vnop_write_args { 1747 struct vnode *a_vp; 1748 struct uio *a_uio; 1749 int a_ioflag; 1750 struct ucred *a_cred; 1751 }; 1752 */ 1753 static int 1754 fuse_vnop_write(struct vop_write_args *ap) 1755 { 1756 struct vnode *vp = ap->a_vp; 1757 struct uio *uio = ap->a_uio; 1758 int ioflag = ap->a_ioflag; 1759 struct ucred *cred = ap->a_cred; 1760 1761 fuse_trace_printf_vnop(); 1762 1763 if (fuse_isdeadfs(vp)) { 1764 return ENXIO; 1765 } 1766 fuse_vnode_refreshsize(vp, cred); 1767 1768 if (VTOFUD(vp)->flag & FN_DIRECTIO) { 1769 ioflag |= IO_DIRECT; 1770 } 1771 1772 return fuse_io_dispatch(vp, uio, ioflag, cred); 1773 } 1774 1775 /* 1776 struct vnop_getpages_args { 1777 struct vnode *a_vp; 1778 vm_page_t *a_m; 1779 int a_count; 1780 int a_reqpage; 1781 }; 1782 */ 1783 static int 1784 fuse_vnop_getpages(struct vop_getpages_args *ap) 1785 { 1786 int i, error, nextoff, size, toff, count, npages; 1787 struct uio uio; 1788 struct iovec iov; 1789 vm_offset_t kva; 1790 struct buf *bp; 1791 struct vnode *vp; 1792 struct thread *td; 1793 struct ucred *cred; 1794 vm_page_t *pages; 1795 1796 FS_DEBUG2G("heh\n"); 1797 1798 vp = ap->a_vp; 1799 KASSERT(vp->v_object, ("objectless vp passed to getpages")); 1800 td = curthread; /* XXX */ 1801 cred = curthread->td_ucred; /* XXX */ 1802 pages = ap->a_m; 1803 npages = ap->a_count; 1804 1805 if (!fsess_opt_mmap(vnode_mount(vp))) { 1806 FS_DEBUG("called on non-cacheable vnode??\n"); 1807 return (VM_PAGER_ERROR); 1808 } 1809 1810 /* 1811 * If the last page is partially valid, just return it and allow 1812 * the pager to zero-out the blanks. Partially valid pages can 1813 * only occur at the file EOF. 1814 * 1815 * XXXGL: is that true for FUSE, which is a local filesystem, 1816 * but still somewhat disconnected from the kernel? 1817 */ 1818 VM_OBJECT_WLOCK(vp->v_object); 1819 if (pages[npages - 1]->valid != 0 && --npages == 0) 1820 goto out; 1821 VM_OBJECT_WUNLOCK(vp->v_object); 1822 1823 /* 1824 * We use only the kva address for the buffer, but this is extremely 1825 * convenient and fast. 1826 */ 1827 bp = getpbuf(&fuse_pbuf_freecnt); 1828 1829 kva = (vm_offset_t)bp->b_data; 1830 pmap_qenter(kva, pages, npages); 1831 VM_CNT_INC(v_vnodein); 1832 VM_CNT_ADD(v_vnodepgsin, npages); 1833 1834 count = npages << PAGE_SHIFT; 1835 iov.iov_base = (caddr_t)kva; 1836 iov.iov_len = count; 1837 uio.uio_iov = &iov; 1838 uio.uio_iovcnt = 1; 1839 uio.uio_offset = IDX_TO_OFF(pages[0]->pindex); 1840 uio.uio_resid = count; 1841 uio.uio_segflg = UIO_SYSSPACE; 1842 uio.uio_rw = UIO_READ; 1843 uio.uio_td = td; 1844 1845 error = fuse_io_dispatch(vp, &uio, IO_DIRECT, cred); 1846 pmap_qremove(kva, npages); 1847 1848 relpbuf(bp, &fuse_pbuf_freecnt); 1849 1850 if (error && (uio.uio_resid == count)) { 1851 FS_DEBUG("error %d\n", error); 1852 return VM_PAGER_ERROR; 1853 } 1854 /* 1855 * Calculate the number of bytes read and validate only that number 1856 * of bytes. Note that due to pending writes, size may be 0. This 1857 * does not mean that the remaining data is invalid! 1858 */ 1859 1860 size = count - uio.uio_resid; 1861 VM_OBJECT_WLOCK(vp->v_object); 1862 fuse_vm_page_lock_queues(); 1863 for (i = 0, toff = 0; i < npages; i++, toff = nextoff) { 1864 vm_page_t m; 1865 1866 nextoff = toff + PAGE_SIZE; 1867 m = pages[i]; 1868 1869 if (nextoff <= size) { 1870 /* 1871 * Read operation filled an entire page 1872 */ 1873 m->valid = VM_PAGE_BITS_ALL; 1874 KASSERT(m->dirty == 0, 1875 ("fuse_getpages: page %p is dirty", m)); 1876 } else if (size > toff) { 1877 /* 1878 * Read operation filled a partial page. 1879 */ 1880 m->valid = 0; 1881 vm_page_set_valid_range(m, 0, size - toff); 1882 KASSERT(m->dirty == 0, 1883 ("fuse_getpages: page %p is dirty", m)); 1884 } else { 1885 /* 1886 * Read operation was short. If no error occurred 1887 * we may have hit a zero-fill section. We simply 1888 * leave valid set to 0. 1889 */ 1890 ; 1891 } 1892 } 1893 fuse_vm_page_unlock_queues(); 1894 out: 1895 VM_OBJECT_WUNLOCK(vp->v_object); 1896 if (ap->a_rbehind) 1897 *ap->a_rbehind = 0; 1898 if (ap->a_rahead) 1899 *ap->a_rahead = 0; 1900 return (VM_PAGER_OK); 1901 } 1902 1903 /* 1904 struct vnop_putpages_args { 1905 struct vnode *a_vp; 1906 vm_page_t *a_m; 1907 int a_count; 1908 int a_sync; 1909 int *a_rtvals; 1910 vm_ooffset_t a_offset; 1911 }; 1912 */ 1913 static int 1914 fuse_vnop_putpages(struct vop_putpages_args *ap) 1915 { 1916 struct uio uio; 1917 struct iovec iov; 1918 vm_offset_t kva; 1919 struct buf *bp; 1920 int i, error, npages, count; 1921 off_t offset; 1922 int *rtvals; 1923 struct vnode *vp; 1924 struct thread *td; 1925 struct ucred *cred; 1926 vm_page_t *pages; 1927 vm_ooffset_t fsize; 1928 1929 FS_DEBUG2G("heh\n"); 1930 1931 vp = ap->a_vp; 1932 KASSERT(vp->v_object, ("objectless vp passed to putpages")); 1933 fsize = vp->v_object->un_pager.vnp.vnp_size; 1934 td = curthread; /* XXX */ 1935 cred = curthread->td_ucred; /* XXX */ 1936 pages = ap->a_m; 1937 count = ap->a_count; 1938 rtvals = ap->a_rtvals; 1939 npages = btoc(count); 1940 offset = IDX_TO_OFF(pages[0]->pindex); 1941 1942 if (!fsess_opt_mmap(vnode_mount(vp))) { 1943 FS_DEBUG("called on non-cacheable vnode??\n"); 1944 } 1945 for (i = 0; i < npages; i++) 1946 rtvals[i] = VM_PAGER_AGAIN; 1947 1948 /* 1949 * When putting pages, do not extend file past EOF. 1950 */ 1951 1952 if (offset + count > fsize) { 1953 count = fsize - offset; 1954 if (count < 0) 1955 count = 0; 1956 } 1957 /* 1958 * We use only the kva address for the buffer, but this is extremely 1959 * convenient and fast. 1960 */ 1961 bp = getpbuf(&fuse_pbuf_freecnt); 1962 1963 kva = (vm_offset_t)bp->b_data; 1964 pmap_qenter(kva, pages, npages); 1965 VM_CNT_INC(v_vnodeout); 1966 VM_CNT_ADD(v_vnodepgsout, count); 1967 1968 iov.iov_base = (caddr_t)kva; 1969 iov.iov_len = count; 1970 uio.uio_iov = &iov; 1971 uio.uio_iovcnt = 1; 1972 uio.uio_offset = offset; 1973 uio.uio_resid = count; 1974 uio.uio_segflg = UIO_SYSSPACE; 1975 uio.uio_rw = UIO_WRITE; 1976 uio.uio_td = td; 1977 1978 error = fuse_io_dispatch(vp, &uio, IO_DIRECT, cred); 1979 1980 pmap_qremove(kva, npages); 1981 relpbuf(bp, &fuse_pbuf_freecnt); 1982 1983 if (!error) { 1984 int nwritten = round_page(count - uio.uio_resid) / PAGE_SIZE; 1985 1986 for (i = 0; i < nwritten; i++) { 1987 rtvals[i] = VM_PAGER_OK; 1988 VM_OBJECT_WLOCK(pages[i]->object); 1989 vm_page_undirty(pages[i]); 1990 VM_OBJECT_WUNLOCK(pages[i]->object); 1991 } 1992 } 1993 return rtvals[0]; 1994 } 1995 1996 static const char extattr_namespace_separator = '.'; 1997 1998 /* 1999 struct vop_getextattr_args { 2000 struct vop_generic_args a_gen; 2001 struct vnode *a_vp; 2002 int a_attrnamespace; 2003 const char *a_name; 2004 struct uio *a_uio; 2005 size_t *a_size; 2006 struct ucred *a_cred; 2007 struct thread *a_td; 2008 }; 2009 */ 2010 static int 2011 fuse_vnop_getextattr(struct vop_getextattr_args *ap) 2012 { 2013 struct vnode *vp = ap->a_vp; 2014 struct uio *uio = ap->a_uio; 2015 struct fuse_dispatcher fdi; 2016 struct fuse_getxattr_in *get_xattr_in; 2017 struct fuse_getxattr_out *get_xattr_out; 2018 struct mount *mp = vnode_mount(vp); 2019 struct thread *td = ap->a_td; 2020 struct ucred *cred = ap->a_cred; 2021 char *prefix; 2022 char *attr_str; 2023 size_t len; 2024 int err; 2025 2026 fuse_trace_printf_vnop(); 2027 2028 if (fuse_isdeadfs(vp)) 2029 return (ENXIO); 2030 2031 /* Default to looking for user attributes. */ 2032 if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 2033 prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 2034 else 2035 prefix = EXTATTR_NAMESPACE_USER_STRING; 2036 2037 len = strlen(prefix) + sizeof(extattr_namespace_separator) + 2038 strlen(ap->a_name) + 1; 2039 2040 fdisp_init(&fdi, len + sizeof(*get_xattr_in)); 2041 fdisp_make_vp(&fdi, FUSE_GETXATTR, vp, td, cred); 2042 2043 get_xattr_in = fdi.indata; 2044 /* 2045 * Check to see whether we're querying the available size or 2046 * issuing the actual request. If we pass in 0, we get back struct 2047 * fuse_getxattr_out. If we pass in a non-zero size, we get back 2048 * that much data, without the struct fuse_getxattr_out header. 2049 */ 2050 if (uio == NULL) 2051 get_xattr_in->size = 0; 2052 else 2053 get_xattr_in->size = uio->uio_resid; 2054 2055 attr_str = (char *)fdi.indata + sizeof(*get_xattr_in); 2056 snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator, 2057 ap->a_name); 2058 2059 err = fdisp_wait_answ(&fdi); 2060 if (err != 0) { 2061 if (err == ENOSYS) 2062 fsess_set_notimpl(mp, FUSE_GETXATTR); 2063 debug_printf("getxattr: got err=%d from daemon\n", err); 2064 goto out; 2065 } 2066 2067 get_xattr_out = fdi.answ; 2068 2069 if (ap->a_size != NULL) 2070 *ap->a_size = get_xattr_out->size; 2071 2072 if (uio != NULL) 2073 err = uiomove(fdi.answ, fdi.iosize, uio); 2074 2075 out: 2076 fdisp_destroy(&fdi); 2077 return (err); 2078 } 2079 2080 /* 2081 struct vop_setextattr_args { 2082 struct vop_generic_args a_gen; 2083 struct vnode *a_vp; 2084 int a_attrnamespace; 2085 const char *a_name; 2086 struct uio *a_uio; 2087 struct ucred *a_cred; 2088 struct thread *a_td; 2089 }; 2090 */ 2091 static int 2092 fuse_vnop_setextattr(struct vop_setextattr_args *ap) 2093 { 2094 struct vnode *vp = ap->a_vp; 2095 struct uio *uio = ap->a_uio; 2096 struct fuse_dispatcher fdi; 2097 struct fuse_setxattr_in *set_xattr_in; 2098 struct mount *mp = vnode_mount(vp); 2099 struct thread *td = ap->a_td; 2100 struct ucred *cred = ap->a_cred; 2101 char *prefix; 2102 size_t len; 2103 char *attr_str; 2104 int err; 2105 2106 fuse_trace_printf_vnop(); 2107 2108 if (fuse_isdeadfs(vp)) 2109 return (ENXIO); 2110 2111 /* Default to looking for user attributes. */ 2112 if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 2113 prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 2114 else 2115 prefix = EXTATTR_NAMESPACE_USER_STRING; 2116 2117 len = strlen(prefix) + sizeof(extattr_namespace_separator) + 2118 strlen(ap->a_name) + 1; 2119 2120 fdisp_init(&fdi, len + sizeof(*set_xattr_in) + uio->uio_resid); 2121 fdisp_make_vp(&fdi, FUSE_SETXATTR, vp, td, cred); 2122 2123 set_xattr_in = fdi.indata; 2124 set_xattr_in->size = uio->uio_resid; 2125 2126 attr_str = (char *)fdi.indata + sizeof(*set_xattr_in); 2127 snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator, 2128 ap->a_name); 2129 2130 err = uiomove((char *)fdi.indata + sizeof(*set_xattr_in) + len, 2131 uio->uio_resid, uio); 2132 if (err != 0) { 2133 debug_printf("setxattr: got error %d from uiomove\n", err); 2134 goto out; 2135 } 2136 2137 err = fdisp_wait_answ(&fdi); 2138 2139 if (err != 0) { 2140 if (err == ENOSYS) 2141 fsess_set_notimpl(mp, FUSE_SETXATTR); 2142 debug_printf("setxattr: got err=%d from daemon\n", err); 2143 goto out; 2144 } 2145 2146 out: 2147 fdisp_destroy(&fdi); 2148 return (err); 2149 } 2150 2151 /* 2152 * The Linux / FUSE extended attribute list is simply a collection of 2153 * NUL-terminated strings. The FreeBSD extended attribute list is a single 2154 * byte length followed by a non-NUL terminated string. So, this allows 2155 * conversion of the Linux / FUSE format to the FreeBSD format in place. 2156 * Linux attribute names are reported with the namespace as a prefix (e.g. 2157 * "user.attribute_name"), but in FreeBSD they are reported without the 2158 * namespace prefix (e.g. "attribute_name"). So, we're going from: 2159 * 2160 * user.attr_name1\0user.attr_name2\0 2161 * 2162 * to: 2163 * 2164 * <num>attr_name1<num>attr_name2 2165 * 2166 * Where "<num>" is a single byte number of characters in the attribute name. 2167 * 2168 * Args: 2169 * prefix - exattr namespace prefix string 2170 * list, list_len - input list with namespace prefixes 2171 * bsd_list, bsd_list_len - output list compatible with bsd vfs 2172 */ 2173 static int 2174 fuse_xattrlist_convert(char *prefix, const char *list, int list_len, 2175 char *bsd_list, int *bsd_list_len) 2176 { 2177 int len, pos, dist_to_next, prefix_len; 2178 2179 pos = 0; 2180 *bsd_list_len = 0; 2181 prefix_len = strlen(prefix); 2182 2183 while (pos < list_len && list[pos] != '\0') { 2184 dist_to_next = strlen(&list[pos]) + 1; 2185 if (bcmp(&list[pos], prefix, prefix_len) == 0 && 2186 list[pos + prefix_len] == extattr_namespace_separator) { 2187 len = dist_to_next - 2188 (prefix_len + sizeof(extattr_namespace_separator)) - 1; 2189 if (len >= EXTATTR_MAXNAMELEN) 2190 return (ENAMETOOLONG); 2191 2192 bsd_list[*bsd_list_len] = len; 2193 memcpy(&bsd_list[*bsd_list_len + 1], 2194 &list[pos + prefix_len + 2195 sizeof(extattr_namespace_separator)], len); 2196 2197 *bsd_list_len += len + 1; 2198 } 2199 2200 pos += dist_to_next; 2201 } 2202 2203 return (0); 2204 } 2205 2206 /* 2207 struct vop_listextattr_args { 2208 struct vop_generic_args a_gen; 2209 struct vnode *a_vp; 2210 int a_attrnamespace; 2211 struct uio *a_uio; 2212 size_t *a_size; 2213 struct ucred *a_cred; 2214 struct thread *a_td; 2215 }; 2216 */ 2217 static int 2218 fuse_vnop_listextattr(struct vop_listextattr_args *ap) 2219 { 2220 struct vnode *vp = ap->a_vp; 2221 struct uio *uio = ap->a_uio; 2222 struct fuse_dispatcher fdi; 2223 struct fuse_listxattr_in *list_xattr_in; 2224 struct fuse_listxattr_out *list_xattr_out; 2225 struct mount *mp = vnode_mount(vp); 2226 struct thread *td = ap->a_td; 2227 struct ucred *cred = ap->a_cred; 2228 size_t len; 2229 char *prefix; 2230 char *attr_str; 2231 char *bsd_list = NULL; 2232 char *linux_list; 2233 int bsd_list_len; 2234 int linux_list_len; 2235 int err; 2236 2237 fuse_trace_printf_vnop(); 2238 2239 if (fuse_isdeadfs(vp)) 2240 return (ENXIO); 2241 2242 /* 2243 * Add space for a NUL and the period separator if enabled. 2244 * Default to looking for user attributes. 2245 */ 2246 if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 2247 prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 2248 else 2249 prefix = EXTATTR_NAMESPACE_USER_STRING; 2250 2251 len = strlen(prefix) + sizeof(extattr_namespace_separator) + 1; 2252 2253 fdisp_init(&fdi, sizeof(*list_xattr_in) + len); 2254 fdisp_make_vp(&fdi, FUSE_LISTXATTR, vp, td, cred); 2255 2256 /* 2257 * Retrieve Linux / FUSE compatible list size. 2258 */ 2259 list_xattr_in = fdi.indata; 2260 list_xattr_in->size = 0; 2261 attr_str = (char *)fdi.indata + sizeof(*list_xattr_in); 2262 snprintf(attr_str, len, "%s%c", prefix, extattr_namespace_separator); 2263 2264 err = fdisp_wait_answ(&fdi); 2265 if (err != 0) { 2266 if (err == ENOSYS) 2267 fsess_set_notimpl(mp, FUSE_LISTXATTR); 2268 debug_printf("listextattr: got err=%d from daemon\n", err); 2269 goto out; 2270 } 2271 2272 list_xattr_out = fdi.answ; 2273 linux_list_len = list_xattr_out->size; 2274 if (linux_list_len == 0) { 2275 if (ap->a_size != NULL) 2276 *ap->a_size = linux_list_len; 2277 goto out; 2278 } 2279 2280 /* 2281 * Retrieve Linux / FUSE compatible list values. 2282 */ 2283 fdisp_make_vp(&fdi, FUSE_LISTXATTR, vp, td, cred); 2284 list_xattr_in = fdi.indata; 2285 list_xattr_in->size = linux_list_len + sizeof(*list_xattr_out); 2286 attr_str = (char *)fdi.indata + sizeof(*list_xattr_in); 2287 snprintf(attr_str, len, "%s%c", prefix, extattr_namespace_separator); 2288 2289 err = fdisp_wait_answ(&fdi); 2290 if (err != 0) 2291 goto out; 2292 2293 linux_list = fdi.answ; 2294 linux_list_len = fdi.iosize; 2295 2296 /* 2297 * Retrieve the BSD compatible list values. 2298 * The Linux / FUSE attribute list format isn't the same 2299 * as FreeBSD's format. So we need to transform it into 2300 * FreeBSD's format before giving it to the user. 2301 */ 2302 bsd_list = malloc(linux_list_len, M_TEMP, M_WAITOK); 2303 err = fuse_xattrlist_convert(prefix, linux_list, linux_list_len, 2304 bsd_list, &bsd_list_len); 2305 if (err != 0) 2306 goto out; 2307 2308 if (ap->a_size != NULL) 2309 *ap->a_size = bsd_list_len; 2310 2311 if (uio != NULL) 2312 err = uiomove(bsd_list, bsd_list_len, uio); 2313 2314 out: 2315 free(bsd_list, M_TEMP); 2316 fdisp_destroy(&fdi); 2317 return (err); 2318 } 2319 2320 /* 2321 struct vop_deleteextattr_args { 2322 struct vop_generic_args a_gen; 2323 struct vnode *a_vp; 2324 int a_attrnamespace; 2325 const char *a_name; 2326 struct ucred *a_cred; 2327 struct thread *a_td; 2328 }; 2329 */ 2330 static int 2331 fuse_vnop_deleteextattr(struct vop_deleteextattr_args *ap) 2332 { 2333 struct vnode *vp = ap->a_vp; 2334 struct fuse_dispatcher fdi; 2335 struct mount *mp = vnode_mount(vp); 2336 struct thread *td = ap->a_td; 2337 struct ucred *cred = ap->a_cred; 2338 char *prefix; 2339 size_t len; 2340 char *attr_str; 2341 int err; 2342 2343 fuse_trace_printf_vnop(); 2344 2345 if (fuse_isdeadfs(vp)) 2346 return (ENXIO); 2347 2348 /* Default to looking for user attributes. */ 2349 if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 2350 prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 2351 else 2352 prefix = EXTATTR_NAMESPACE_USER_STRING; 2353 2354 len = strlen(prefix) + sizeof(extattr_namespace_separator) + 2355 strlen(ap->a_name) + 1; 2356 2357 fdisp_init(&fdi, len); 2358 fdisp_make_vp(&fdi, FUSE_REMOVEXATTR, vp, td, cred); 2359 2360 attr_str = fdi.indata; 2361 snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator, 2362 ap->a_name); 2363 2364 err = fdisp_wait_answ(&fdi); 2365 if (err != 0) { 2366 if (err == ENOSYS) 2367 fsess_set_notimpl(mp, FUSE_REMOVEXATTR); 2368 debug_printf("removexattr: got err=%d from daemon\n", err); 2369 } 2370 2371 fdisp_destroy(&fdi); 2372 return (err); 2373 } 2374 2375 /* 2376 struct vnop_print_args { 2377 struct vnode *a_vp; 2378 }; 2379 */ 2380 static int 2381 fuse_vnop_print(struct vop_print_args *ap) 2382 { 2383 struct fuse_vnode_data *fvdat = VTOFUD(ap->a_vp); 2384 2385 printf("nodeid: %ju, parent nodeid: %ju, nlookup: %ju, flag: %#x\n", 2386 (uintmax_t)VTOILLU(ap->a_vp), (uintmax_t)fvdat->parent_nid, 2387 (uintmax_t)fvdat->nlookup, 2388 fvdat->flag); 2389 2390 return 0; 2391 } 2392