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/systm.h> 68#include <sys/counter.h> 69#include <sys/module.h> 70#include <sys/errno.h> 71#include <sys/kernel.h> 72#include <sys/conf.h> 73#include <sys/uio.h> 74#include <sys/malloc.h> 75#include <sys/queue.h> 76#include <sys/lock.h> 77#include <sys/mutex.h> 78#include <sys/sdt.h> 79#include <sys/sx.h> 80#include <sys/proc.h> 81#include <sys/mount.h> 82#include <sys/vnode.h> 83#include <sys/namei.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/priv.h> 94 95#include "fuse.h" 96#include "fuse_file.h" 97#include "fuse_internal.h" 98#include "fuse_io.h" 99#include "fuse_ipc.h" 100#include "fuse_node.h" 101#include "fuse_file.h" 102 103SDT_PROVIDER_DECLARE(fusefs); 104/* 105 * Fuse trace probe: 106 * arg0: verbosity. Higher numbers give more verbose messages 107 * arg1: Textual message 108 */ 109SDT_PROBE_DEFINE2(fusefs, , internal, trace, "int", "char*"); 110 111#ifdef ZERO_PAD_INCOMPLETE_BUFS 112static int isbzero(void *buf, size_t len); 113 114#endif 115 116counter_u64_t fuse_lookup_cache_hits; 117counter_u64_t fuse_lookup_cache_misses; 118 119SYSCTL_COUNTER_U64(_vfs_fusefs_stats, OID_AUTO, lookup_cache_hits, CTLFLAG_RD, 120 &fuse_lookup_cache_hits, "number of positive cache hits in lookup"); 121 122SYSCTL_COUNTER_U64(_vfs_fusefs_stats, OID_AUTO, lookup_cache_misses, CTLFLAG_RD, 123 &fuse_lookup_cache_misses, "number of cache misses in lookup"); 124 125int 126fuse_internal_get_cached_vnode(struct mount* mp, ino_t ino, int flags, 127 struct vnode **vpp) 128{ 129 struct bintime now; 130 struct thread *td = curthread; 131 uint64_t nodeid = ino; 132 int error; 133 134 *vpp = NULL; 135 136 error = vfs_hash_get(mp, fuse_vnode_hash(nodeid), flags, td, vpp, 137 fuse_vnode_cmp, &nodeid); 138 if (error) 139 return error; 140 /* 141 * Check the entry cache timeout. We have to do this within fusefs 142 * instead of by using cache_enter_time/cache_lookup because those 143 * routines are only intended to work with pathnames, not inodes 144 */ 145 if (*vpp != NULL) { 146 getbinuptime(&now); 147 if (bintime_cmp(&(VTOFUD(*vpp)->entry_cache_timeout), &now, >)){ 148 counter_u64_add(fuse_lookup_cache_hits, 1); 149 return 0; 150 } else { 151 /* Entry cache timeout */ 152 counter_u64_add(fuse_lookup_cache_misses, 1); 153 cache_purge(*vpp); 154 vput(*vpp); 155 *vpp = NULL; 156 } 157 } 158 return 0; 159} 160 161SDT_PROBE_DEFINE0(fusefs, , internal, access_vadmin); 162/* Synchronously send a FUSE_ACCESS operation */ 163int 164fuse_internal_access(struct vnode *vp, 165 accmode_t mode, 166 struct thread *td, 167 struct ucred *cred) 168{ 169 int err = 0; 170 uint32_t mask = F_OK; 171 int dataflags; 172 int vtype; 173 struct mount *mp; 174 struct fuse_dispatcher fdi; 175 struct fuse_access_in *fai; 176 struct fuse_data *data; 177 178 mp = vnode_mount(vp); 179 vtype = vnode_vtype(vp); 180 181 data = fuse_get_mpdata(mp); 182 dataflags = data->dataflags; 183 184 if (mode == 0) 185 return 0; 186 187 if (mode & VMODIFY_PERMS && vfs_isrdonly(mp)) { 188 switch (vp->v_type) { 189 case VDIR: 190 /* FALLTHROUGH */ 191 case VLNK: 192 /* FALLTHROUGH */ 193 case VREG: 194 return EROFS; 195 default: 196 break; 197 } 198 } 199 200 /* Unless explicitly permitted, deny everyone except the fs owner. */ 201 if (!(dataflags & FSESS_DAEMON_CAN_SPY)) { 202 if (fuse_match_cred(data->daemoncred, cred)) 203 return EPERM; 204 } 205 206 if (dataflags & FSESS_DEFAULT_PERMISSIONS) { 207 struct vattr va; 208 209 fuse_internal_getattr(vp, &va, cred, td); 210 return vaccess(vp->v_type, va.va_mode, va.va_uid, 211 va.va_gid, mode, cred); 212 } 213 214 if (mode & VADMIN) { 215 /* 216 * The FUSE protocol doesn't have an equivalent of VADMIN, so 217 * it's a bug if we ever reach this point with that bit set. 218 */ 219 SDT_PROBE0(fusefs, , internal, access_vadmin); 220 } 221 222 if (fsess_not_impl(mp, FUSE_ACCESS)) 223 return 0; 224 225 if ((mode & (VWRITE | VAPPEND)) != 0) 226 mask |= W_OK; 227 if ((mode & VREAD) != 0) 228 mask |= R_OK; 229 if ((mode & VEXEC) != 0) 230 mask |= X_OK; 231 232 fdisp_init(&fdi, sizeof(*fai)); 233 fdisp_make_vp(&fdi, FUSE_ACCESS, vp, td, cred); 234 235 fai = fdi.indata; 236 fai->mask = mask; 237 238 err = fdisp_wait_answ(&fdi); 239 fdisp_destroy(&fdi); 240 241 if (err == ENOSYS) { 242 fsess_set_notimpl(mp, FUSE_ACCESS); 243 err = 0; 244 } 245 return err; 246} 247 248/* 249 * Cache FUSE attributes from attr, in attribute cache associated with vnode 250 * 'vp'. Optionally, if argument 'vap' is not NULL, store a copy of the 251 * converted attributes there as well. 252 * 253 * If the nominal attribute cache TTL is zero, do not cache on the 'vp' (but do 254 * return the result to the caller). 255 */ 256void 257fuse_internal_cache_attrs(struct vnode *vp, struct fuse_attr *attr, 258 uint64_t attr_valid, uint32_t attr_valid_nsec, struct vattr *vap) 259{ 260 struct mount *mp; 261 struct fuse_vnode_data *fvdat; 262 struct fuse_data *data; 263 struct vattr *vp_cache_at; 264 265 mp = vnode_mount(vp); 266 fvdat = VTOFUD(vp); 267 data = fuse_get_mpdata(mp); 268 269 ASSERT_VOP_ELOCKED(vp, "fuse_internal_cache_attrs"); 270 271 fuse_validity_2_bintime(attr_valid, attr_valid_nsec, 272 &fvdat->attr_cache_timeout); 273 274 /* Fix our buffers if the filesize changed without us knowing */ 275 if (vnode_isreg(vp) && attr->size != fvdat->cached_attrs.va_size) { 276 (void)fuse_vnode_setsize(vp, attr->size); 277 fvdat->cached_attrs.va_size = attr->size; 278 } 279 280 if (attr_valid > 0 || attr_valid_nsec > 0) 281 vp_cache_at = &(fvdat->cached_attrs); 282 else if (vap != NULL) 283 vp_cache_at = vap; 284 else 285 return; 286 287 vattr_null(vp_cache_at); 288 vp_cache_at->va_fsid = mp->mnt_stat.f_fsid.val[0]; 289 vp_cache_at->va_fileid = attr->ino; 290 vp_cache_at->va_mode = attr->mode & ~S_IFMT; 291 vp_cache_at->va_nlink = attr->nlink; 292 vp_cache_at->va_uid = attr->uid; 293 vp_cache_at->va_gid = attr->gid; 294 vp_cache_at->va_rdev = attr->rdev; 295 vp_cache_at->va_size = attr->size; 296 /* XXX on i386, seconds are truncated to 32 bits */ 297 vp_cache_at->va_atime.tv_sec = attr->atime; 298 vp_cache_at->va_atime.tv_nsec = attr->atimensec; 299 vp_cache_at->va_mtime.tv_sec = attr->mtime; 300 vp_cache_at->va_mtime.tv_nsec = attr->mtimensec; 301 vp_cache_at->va_ctime.tv_sec = attr->ctime; 302 vp_cache_at->va_ctime.tv_nsec = attr->ctimensec; 303 if (fuse_libabi_geq(data, 7, 9) && attr->blksize > 0) 304 vp_cache_at->va_blocksize = attr->blksize; 305 else 306 vp_cache_at->va_blocksize = PAGE_SIZE; 307 vp_cache_at->va_type = IFTOVT(attr->mode); 308 vp_cache_at->va_bytes = attr->blocks * S_BLKSIZE; 309 vp_cache_at->va_flags = 0; 310 311 if (vap != vp_cache_at && vap != NULL) 312 memcpy(vap, vp_cache_at, sizeof(*vap)); 313} 314 315/* fsync */ 316 317int 318fuse_internal_fsync_callback(struct fuse_ticket *tick, struct uio *uio) 319{ 320 if (tick->tk_aw_ohead.error == ENOSYS) { 321 fsess_set_notimpl(tick->tk_data->mp, fticket_opcode(tick)); 322 } 323 return 0; 324} 325 326int 327fuse_internal_fsync(struct vnode *vp, 328 struct thread *td, 329 int waitfor, 330 bool datasync) 331{ 332 struct fuse_fsync_in *ffsi = NULL; 333 struct fuse_dispatcher fdi; 334 struct fuse_filehandle *fufh; 335 struct fuse_vnode_data *fvdat = VTOFUD(vp); 336 struct mount *mp = vnode_mount(vp); 337 int op = FUSE_FSYNC; 338 int err = 0; 339 340 if (fsess_not_impl(vnode_mount(vp), 341 (vnode_vtype(vp) == VDIR ? FUSE_FSYNCDIR : FUSE_FSYNC))) { 342 return 0; 343 } 344 if (vnode_isdir(vp)) 345 op = FUSE_FSYNCDIR; 346 347 if (fsess_not_impl(mp, op)) 348 return 0; 349 350 fdisp_init(&fdi, sizeof(*ffsi)); 351 /* 352 * fsync every open file handle for this file, because we can't be sure 353 * which file handle the caller is really referring to. 354 */ 355 LIST_FOREACH(fufh, &fvdat->handles, next) { 356 fdi.iosize = sizeof(*ffsi); 357 if (ffsi == NULL) 358 fdisp_make_vp(&fdi, op, vp, td, NULL); 359 else 360 fdisp_refresh_vp(&fdi, op, vp, td, NULL); 361 ffsi = fdi.indata; 362 ffsi->fh = fufh->fh_id; 363 ffsi->fsync_flags = 0; 364 365 if (datasync) 366 ffsi->fsync_flags = 1; 367 368 if (waitfor == MNT_WAIT) { 369 err = fdisp_wait_answ(&fdi); 370 } else { 371 fuse_insert_callback(fdi.tick, 372 fuse_internal_fsync_callback); 373 fuse_insert_message(fdi.tick, false); 374 } 375 if (err == ENOSYS) { 376 /* ENOSYS means "success, and don't call again" */ 377 fsess_set_notimpl(mp, op); 378 err = 0; 379 break; 380 } 381 } 382 fdisp_destroy(&fdi); 383 384 return err; 385} 386 387/* Asynchronous invalidation */ 388SDT_PROBE_DEFINE3(fusefs, , internal, invalidate_entry, 389 "struct vnode*", "struct fuse_notify_inval_entry_out*", "char*"); 390int 391fuse_internal_invalidate_entry(struct mount *mp, struct uio *uio) 392{ 393 struct fuse_notify_inval_entry_out fnieo; 394 struct componentname cn; 395 struct vnode *dvp, *vp; 396 char name[PATH_MAX]; 397 int err; 398 399 if ((err = uiomove(&fnieo, sizeof(fnieo), uio)) != 0) 400 return (err); 401 402 if (fnieo.namelen >= sizeof(name)) 403 return (EINVAL); 404 405 if ((err = uiomove(name, fnieo.namelen, uio)) != 0) 406 return (err); 407 name[fnieo.namelen] = '\0'; 408 /* fusefs does not cache "." or ".." entries */ 409 if (strncmp(name, ".", sizeof(".")) == 0 || 410 strncmp(name, "..", sizeof("..")) == 0) 411 return (0); 412 413 if (fnieo.parent == FUSE_ROOT_ID) 414 err = VFS_ROOT(mp, LK_SHARED, &dvp); 415 else 416 err = fuse_internal_get_cached_vnode( mp, fnieo.parent, 417 LK_SHARED, &dvp); 418 SDT_PROBE3(fusefs, , internal, invalidate_entry, dvp, &fnieo, name); 419 /* 420 * If dvp is not in the cache, then it must've been reclaimed. And 421 * since fuse_vnop_reclaim does a cache_purge, name's entry must've 422 * been invalidated already. So we can safely return if dvp == NULL 423 */ 424 if (err != 0 || dvp == NULL) 425 return (err); 426 /* 427 * XXX we can't check dvp's generation because the FUSE invalidate 428 * entry message doesn't include it. Worse case is that we invalidate 429 * an entry that didn't need to be invalidated. 430 */ 431 432 cn.cn_nameiop = LOOKUP; 433 cn.cn_flags = 0; /* !MAKEENTRY means free cached entry */ 434 cn.cn_thread = curthread; 435 cn.cn_cred = curthread->td_ucred; 436 cn.cn_lkflags = LK_SHARED; 437 cn.cn_pnbuf = NULL; 438 cn.cn_nameptr = name; 439 cn.cn_namelen = fnieo.namelen; 440 err = cache_lookup(dvp, &vp, &cn, NULL, NULL); 441 MPASS(err == 0); 442 fuse_vnode_clear_attr_cache(dvp); 443 vput(dvp); 444 return (0); 445} 446 447SDT_PROBE_DEFINE2(fusefs, , internal, invalidate_inode, 448 "struct vnode*", "struct fuse_notify_inval_inode_out *"); 449int 450fuse_internal_invalidate_inode(struct mount *mp, struct uio *uio) 451{ 452 struct fuse_notify_inval_inode_out fniio; 453 struct vnode *vp; 454 int err; 455 456 if ((err = uiomove(&fniio, sizeof(fniio), uio)) != 0) 457 return (err); 458 459 if (fniio.ino == FUSE_ROOT_ID) 460 err = VFS_ROOT(mp, LK_EXCLUSIVE, &vp); 461 else 462 err = fuse_internal_get_cached_vnode(mp, fniio.ino, LK_SHARED, 463 &vp); 464 SDT_PROBE2(fusefs, , internal, invalidate_inode, vp, &fniio); 465 if (err != 0 || vp == NULL) 466 return (err); 467 /* 468 * XXX we can't check vp's generation because the FUSE invalidate 469 * entry message doesn't include it. Worse case is that we invalidate 470 * an inode that didn't need to be invalidated. 471 */ 472 473 /* 474 * Flush and invalidate buffers if off >= 0. Technically we only need 475 * to flush and invalidate the range of offsets [off, off + len), but 476 * for simplicity's sake we do everything. 477 */ 478 if (fniio.off >= 0) 479 fuse_io_invalbuf(vp, curthread); 480 fuse_vnode_clear_attr_cache(vp); 481 vput(vp); 482 return (0); 483} 484 485/* mknod */ 486int 487fuse_internal_mknod(struct vnode *dvp, struct vnode **vpp, 488 struct componentname *cnp, struct vattr *vap) 489{ 490 struct fuse_data *data; 491 struct fuse_mknod_in fmni; 492 size_t insize; 493 494 data = fuse_get_mpdata(dvp->v_mount); 495 496 fmni.mode = MAKEIMODE(vap->va_type, vap->va_mode); 497 fmni.rdev = vap->va_rdev; 498 if (fuse_libabi_geq(data, 7, 12)) { 499 insize = sizeof(fmni); 500 fmni.umask = curthread->td_proc->p_pd->pd_cmask; 501 } else { 502 insize = FUSE_COMPAT_MKNOD_IN_SIZE; 503 } 504 return (fuse_internal_newentry(dvp, vpp, cnp, FUSE_MKNOD, &fmni, 505 insize, vap->va_type)); 506} 507 508/* readdir */ 509 510int 511fuse_internal_readdir(struct vnode *vp, 512 struct uio *uio, 513 off_t startoff, 514 struct fuse_filehandle *fufh, 515 struct fuse_iov *cookediov, 516 int *ncookies, 517 u_long *cookies) 518{ 519 int err = 0; 520 struct fuse_dispatcher fdi; 521 struct fuse_read_in *fri = NULL; 522 int fnd_start; 523 524 if (uio_resid(uio) == 0) 525 return 0; 526 fdisp_init(&fdi, 0); 527 528 /* 529 * Note that we DO NOT have a UIO_SYSSPACE here (so no need for p2p 530 * I/O). 531 */ 532 533 /* 534 * fnd_start is set non-zero once the offset in the directory gets 535 * to the startoff. This is done because directories must be read 536 * from the beginning (offset == 0) when fuse_vnop_readdir() needs 537 * to do an open of the directory. 538 * If it is not set non-zero here, it will be set non-zero in 539 * fuse_internal_readdir_processdata() when uio_offset == startoff. 540 */ 541 fnd_start = 0; 542 if (uio->uio_offset == startoff) 543 fnd_start = 1; 544 while (uio_resid(uio) > 0) { 545 fdi.iosize = sizeof(*fri); 546 if (fri == NULL) 547 fdisp_make_vp(&fdi, FUSE_READDIR, vp, NULL, NULL); 548 else 549 fdisp_refresh_vp(&fdi, FUSE_READDIR, vp, NULL, NULL); 550 551 fri = fdi.indata; 552 fri->fh = fufh->fh_id; 553 fri->offset = uio_offset(uio); 554 fri->size = MIN(uio->uio_resid, 555 fuse_get_mpdata(vp->v_mount)->max_read); 556 557 if ((err = fdisp_wait_answ(&fdi))) 558 break; 559 if ((err = fuse_internal_readdir_processdata(uio, startoff, 560 &fnd_start, fri->size, fdi.answ, fdi.iosize, cookediov, 561 ncookies, &cookies))) 562 break; 563 } 564 565 fdisp_destroy(&fdi); 566 return ((err == -1) ? 0 : err); 567} 568 569/* 570 * Return -1 to indicate that this readdir is finished, 0 if it copied 571 * all the directory data read in and it may be possible to read more 572 * and greater than 0 for a failure. 573 */ 574int 575fuse_internal_readdir_processdata(struct uio *uio, 576 off_t startoff, 577 int *fnd_start, 578 size_t reqsize, 579 void *buf, 580 size_t bufsize, 581 struct fuse_iov *cookediov, 582 int *ncookies, 583 u_long **cookiesp) 584{ 585 int err = 0; 586 int oreclen; 587 size_t freclen; 588 589 struct dirent *de; 590 struct fuse_dirent *fudge; 591 u_long *cookies; 592 593 cookies = *cookiesp; 594 if (bufsize < FUSE_NAME_OFFSET) 595 return -1; 596 for (;;) { 597 if (bufsize < FUSE_NAME_OFFSET) { 598 err = -1; 599 break; 600 } 601 fudge = (struct fuse_dirent *)buf; 602 freclen = FUSE_DIRENT_SIZE(fudge); 603 604 if (bufsize < freclen) { 605 /* 606 * This indicates a partial directory entry at the 607 * end of the directory data. 608 */ 609 err = -1; 610 break; 611 } 612#ifdef ZERO_PAD_INCOMPLETE_BUFS 613 if (isbzero(buf, FUSE_NAME_OFFSET)) { 614 err = -1; 615 break; 616 } 617#endif 618 619 if (!fudge->namelen || fudge->namelen > MAXNAMLEN) { 620 err = EINVAL; 621 break; 622 } 623 oreclen = GENERIC_DIRSIZ((struct pseudo_dirent *) 624 &fudge->namelen); 625 626 if (oreclen > uio_resid(uio)) { 627 /* Out of space for the dir so we are done. */ 628 err = -1; 629 break; 630 } 631 /* 632 * Don't start to copy the directory entries out until 633 * the requested offset in the directory is found. 634 */ 635 if (*fnd_start != 0) { 636 fiov_adjust(cookediov, oreclen); 637 bzero(cookediov->base, oreclen); 638 639 de = (struct dirent *)cookediov->base; 640 de->d_fileno = fudge->ino; 641 de->d_off = fudge->off; 642 de->d_reclen = oreclen; 643 de->d_type = fudge->type; 644 de->d_namlen = fudge->namelen; 645 memcpy((char *)cookediov->base + sizeof(struct dirent) - 646 MAXNAMLEN - 1, 647 (char *)buf + FUSE_NAME_OFFSET, fudge->namelen); 648 dirent_terminate(de); 649 650 err = uiomove(cookediov->base, cookediov->len, uio); 651 if (err) 652 break; 653 if (cookies != NULL) { 654 if (*ncookies == 0) { 655 err = -1; 656 break; 657 } 658 *cookies = fudge->off; 659 cookies++; 660 (*ncookies)--; 661 } 662 } else if (startoff == fudge->off) 663 *fnd_start = 1; 664 buf = (char *)buf + freclen; 665 bufsize -= freclen; 666 uio_setoffset(uio, fudge->off); 667 } 668 *cookiesp = cookies; 669 670 return err; 671} 672 673/* remove */ 674 675int 676fuse_internal_remove(struct vnode *dvp, 677 struct vnode *vp, 678 struct componentname *cnp, 679 enum fuse_opcode op) 680{ 681 struct fuse_dispatcher fdi; 682 nlink_t nlink; 683 int err = 0; 684 685 fdisp_init(&fdi, cnp->cn_namelen + 1); 686 fdisp_make_vp(&fdi, op, dvp, cnp->cn_thread, cnp->cn_cred); 687 688 memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen); 689 ((char *)fdi.indata)[cnp->cn_namelen] = '\0'; 690 691 err = fdisp_wait_answ(&fdi); 692 fdisp_destroy(&fdi); 693 694 if (err) 695 return (err); 696 697 /* 698 * Access the cached nlink even if the attr cached has expired. If 699 * it's inaccurate, the worst that will happen is: 700 * 1) We'll recycle the vnode even though the file has another link we 701 * don't know about, costing a bit of cpu time, or 702 * 2) We won't recycle the vnode even though all of its links are gone. 703 * It will linger around until vnlru reclaims it, costing a bit of 704 * temporary memory. 705 */ 706 nlink = VTOFUD(vp)->cached_attrs.va_nlink--; 707 708 /* 709 * Purge the parent's attribute cache because the daemon 710 * should've updated its mtime and ctime. 711 */ 712 fuse_vnode_clear_attr_cache(dvp); 713 714 /* NB: nlink could be zero if it was never cached */ 715 if (nlink <= 1 || vnode_vtype(vp) == VDIR) { 716 fuse_internal_vnode_disappear(vp); 717 } else { 718 cache_purge(vp); 719 fuse_vnode_update(vp, FN_CTIMECHANGE); 720 } 721 722 return err; 723} 724 725/* rename */ 726 727int 728fuse_internal_rename(struct vnode *fdvp, 729 struct componentname *fcnp, 730 struct vnode *tdvp, 731 struct componentname *tcnp) 732{ 733 struct fuse_dispatcher fdi; 734 struct fuse_rename_in *fri; 735 int err = 0; 736 737 fdisp_init(&fdi, sizeof(*fri) + fcnp->cn_namelen + tcnp->cn_namelen + 2); 738 fdisp_make_vp(&fdi, FUSE_RENAME, fdvp, tcnp->cn_thread, tcnp->cn_cred); 739 740 fri = fdi.indata; 741 fri->newdir = VTOI(tdvp); 742 memcpy((char *)fdi.indata + sizeof(*fri), fcnp->cn_nameptr, 743 fcnp->cn_namelen); 744 ((char *)fdi.indata)[sizeof(*fri) + fcnp->cn_namelen] = '\0'; 745 memcpy((char *)fdi.indata + sizeof(*fri) + fcnp->cn_namelen + 1, 746 tcnp->cn_nameptr, tcnp->cn_namelen); 747 ((char *)fdi.indata)[sizeof(*fri) + fcnp->cn_namelen + 748 tcnp->cn_namelen + 1] = '\0'; 749 750 err = fdisp_wait_answ(&fdi); 751 fdisp_destroy(&fdi); 752 return err; 753} 754 755/* strategy */ 756 757/* entity creation */ 758 759void 760fuse_internal_newentry_makerequest(struct mount *mp, 761 uint64_t dnid, 762 struct componentname *cnp, 763 enum fuse_opcode op, 764 void *buf, 765 size_t bufsize, 766 struct fuse_dispatcher *fdip) 767{ 768 fdip->iosize = bufsize + cnp->cn_namelen + 1; 769 770 fdisp_make(fdip, op, mp, dnid, cnp->cn_thread, cnp->cn_cred); 771 memcpy(fdip->indata, buf, bufsize); 772 memcpy((char *)fdip->indata + bufsize, cnp->cn_nameptr, cnp->cn_namelen); 773 ((char *)fdip->indata)[bufsize + cnp->cn_namelen] = '\0'; 774} 775 776int 777fuse_internal_newentry_core(struct vnode *dvp, 778 struct vnode **vpp, 779 struct componentname *cnp, 780 enum vtype vtyp, 781 struct fuse_dispatcher *fdip) 782{ 783 int err = 0; 784 struct fuse_entry_out *feo; 785 struct mount *mp = vnode_mount(dvp); 786 787 if ((err = fdisp_wait_answ(fdip))) { 788 return err; 789 } 790 feo = fdip->answ; 791 792 if ((err = fuse_internal_checkentry(feo, vtyp))) { 793 return err; 794 } 795 err = fuse_vnode_get(mp, feo, feo->nodeid, dvp, vpp, cnp, vtyp); 796 if (err) { 797 fuse_internal_forget_send(mp, cnp->cn_thread, cnp->cn_cred, 798 feo->nodeid, 1); 799 return err; 800 } 801 802 /* 803 * Purge the parent's attribute cache because the daemon should've 804 * updated its mtime and ctime 805 */ 806 fuse_vnode_clear_attr_cache(dvp); 807 808 fuse_internal_cache_attrs(*vpp, &feo->attr, feo->attr_valid, 809 feo->attr_valid_nsec, NULL); 810 811 return err; 812} 813 814int 815fuse_internal_newentry(struct vnode *dvp, 816 struct vnode **vpp, 817 struct componentname *cnp, 818 enum fuse_opcode op, 819 void *buf, 820 size_t bufsize, 821 enum vtype vtype) 822{ 823 int err; 824 struct fuse_dispatcher fdi; 825 struct mount *mp = vnode_mount(dvp); 826 827 fdisp_init(&fdi, 0); 828 fuse_internal_newentry_makerequest(mp, VTOI(dvp), cnp, op, buf, 829 bufsize, &fdi); 830 err = fuse_internal_newentry_core(dvp, vpp, cnp, vtype, &fdi); 831 fdisp_destroy(&fdi); 832 833 return err; 834} 835 836/* entity destruction */ 837 838int 839fuse_internal_forget_callback(struct fuse_ticket *ftick, struct uio *uio) 840{ 841 fuse_internal_forget_send(ftick->tk_data->mp, curthread, NULL, 842 ((struct fuse_in_header *)ftick->tk_ms_fiov.base)->nodeid, 1); 843 844 return 0; 845} 846 847void 848fuse_internal_forget_send(struct mount *mp, 849 struct thread *td, 850 struct ucred *cred, 851 uint64_t nodeid, 852 uint64_t nlookup) 853{ 854 855 struct fuse_dispatcher fdi; 856 struct fuse_forget_in *ffi; 857 858 /* 859 * KASSERT(nlookup > 0, ("zero-times forget for vp #%llu", 860 * (long long unsigned) nodeid)); 861 */ 862 863 fdisp_init(&fdi, sizeof(*ffi)); 864 fdisp_make(&fdi, FUSE_FORGET, mp, nodeid, td, cred); 865 866 ffi = fdi.indata; 867 ffi->nlookup = nlookup; 868 869 fuse_insert_message(fdi.tick, false); 870 fdisp_destroy(&fdi); 871} 872 873SDT_PROBE_DEFINE2(fusefs, , internal, getattr_cache_incoherent, 874 "struct vnode*", "struct fuse_attr_out*"); 875 876/* Fetch the vnode's attributes from the daemon*/ 877int 878fuse_internal_do_getattr(struct vnode *vp, struct vattr *vap, 879 struct ucred *cred, struct thread *td) 880{ 881 struct fuse_dispatcher fdi; 882 struct fuse_vnode_data *fvdat = VTOFUD(vp); 883 struct fuse_getattr_in *fgai; 884 struct fuse_attr_out *fao; 885 off_t old_filesize = fvdat->cached_attrs.va_size; 886 struct timespec old_ctime = fvdat->cached_attrs.va_ctime; 887 struct timespec old_mtime = fvdat->cached_attrs.va_mtime; 888 enum vtype vtyp; 889 int err; 890 891 fdisp_init(&fdi, sizeof(*fgai)); 892 fdisp_make_vp(&fdi, FUSE_GETATTR, vp, td, cred); 893 fgai = fdi.indata; 894 /* 895 * We could look up a file handle and set it in fgai->fh, but that 896 * involves extra runtime work and I'm unaware of any file systems that 897 * care. 898 */ 899 fgai->getattr_flags = 0; 900 if ((err = fdisp_wait_answ(&fdi))) { 901 if (err == ENOENT) 902 fuse_internal_vnode_disappear(vp); 903 goto out; 904 } 905 906 fao = (struct fuse_attr_out *)fdi.answ; 907 vtyp = IFTOVT(fao->attr.mode); 908 if (fvdat->flag & FN_SIZECHANGE) 909 fao->attr.size = old_filesize; 910 if (fvdat->flag & FN_CTIMECHANGE) { 911 fao->attr.ctime = old_ctime.tv_sec; 912 fao->attr.ctimensec = old_ctime.tv_nsec; 913 } 914 if (fvdat->flag & FN_MTIMECHANGE) { 915 fao->attr.mtime = old_mtime.tv_sec; 916 fao->attr.mtimensec = old_mtime.tv_nsec; 917 } 918 if (vnode_isreg(vp) && 919 fvdat->cached_attrs.va_size != VNOVAL && 920 fao->attr.size != fvdat->cached_attrs.va_size) { 921 /* 922 * The server changed the file's size even though we had it 923 * cached! That's a server bug. 924 */ 925 SDT_PROBE2(fusefs, , internal, getattr_cache_incoherent, vp, 926 fao); 927 printf("%s: cache incoherent on %s! " 928 "Buggy FUSE server detected. To prevent data corruption, " 929 "disable the data cache by mounting with -o direct_io, or " 930 "as directed otherwise by your FUSE server's " 931 "documentation\n", __func__, 932 vnode_mount(vp)->mnt_stat.f_mntonname); 933 int iosize = fuse_iosize(vp); 934 v_inval_buf_range(vp, 0, INT64_MAX, iosize); 935 } 936 fuse_internal_cache_attrs(vp, &fao->attr, fao->attr_valid, 937 fao->attr_valid_nsec, vap); 938 if (vtyp != vnode_vtype(vp)) { 939 fuse_internal_vnode_disappear(vp); 940 err = ENOENT; 941 } 942 943out: 944 fdisp_destroy(&fdi); 945 return err; 946} 947 948/* Read a vnode's attributes from cache or fetch them from the fuse daemon */ 949int 950fuse_internal_getattr(struct vnode *vp, struct vattr *vap, struct ucred *cred, 951 struct thread *td) 952{ 953 struct vattr *attrs; 954 955 if ((attrs = VTOVA(vp)) != NULL) { 956 *vap = *attrs; /* struct copy */ 957 return 0; 958 } 959 960 return fuse_internal_do_getattr(vp, vap, cred, td); 961} 962 963void 964fuse_internal_vnode_disappear(struct vnode *vp) 965{ 966 struct fuse_vnode_data *fvdat = VTOFUD(vp); 967 968 ASSERT_VOP_ELOCKED(vp, "fuse_internal_vnode_disappear"); 969 fvdat->flag |= FN_REVOKED; 970 cache_purge(vp); 971} 972 973/* fuse start/stop */ 974 975SDT_PROBE_DEFINE2(fusefs, , internal, init_done, 976 "struct fuse_data*", "struct fuse_init_out*"); 977int 978fuse_internal_init_callback(struct fuse_ticket *tick, struct uio *uio) 979{ 980 int err = 0; 981 struct fuse_data *data = tick->tk_data; 982 struct fuse_init_out *fiio; 983 984 if ((err = tick->tk_aw_ohead.error)) { 985 goto out; 986 } 987 if ((err = fticket_pull(tick, uio))) { 988 goto out; 989 } 990 fiio = fticket_resp(tick)->base; 991 992 data->fuse_libabi_major = fiio->major; 993 data->fuse_libabi_minor = fiio->minor; 994 if (!fuse_libabi_geq(data, 7, 4)) { 995 /* 996 * With a little work we could support servers as old as 7.1. 997 * But there would be little payoff. 998 */ 999 SDT_PROBE2(fusefs, , internal, trace, 1, 1000 "userpace version too low"); 1001 err = EPROTONOSUPPORT; 1002 goto out; 1003 } 1004 1005 if (fuse_libabi_geq(data, 7, 5)) { 1006 if (fticket_resp(tick)->len == sizeof(struct fuse_init_out) || 1007 fticket_resp(tick)->len == FUSE_COMPAT_22_INIT_OUT_SIZE) { 1008 data->max_write = fiio->max_write; 1009 if (fiio->flags & FUSE_ASYNC_READ) 1010 data->dataflags |= FSESS_ASYNC_READ; 1011 if (fiio->flags & FUSE_POSIX_LOCKS) 1012 data->dataflags |= FSESS_POSIX_LOCKS; 1013 if (fiio->flags & FUSE_EXPORT_SUPPORT) 1014 data->dataflags |= FSESS_EXPORT_SUPPORT; 1015 /* 1016 * Don't bother to check FUSE_BIG_WRITES, because it's 1017 * redundant with max_write 1018 */ 1019 /* 1020 * max_background and congestion_threshold are not 1021 * implemented 1022 */ 1023 } else { 1024 err = EINVAL; 1025 } 1026 } else { 1027 /* Old fixed values */ 1028 data->max_write = 4096; 1029 } 1030 1031 if (fuse_libabi_geq(data, 7, 6)) 1032 data->max_readahead_blocks = fiio->max_readahead / maxbcachebuf; 1033 1034 if (!fuse_libabi_geq(data, 7, 7)) 1035 fsess_set_notimpl(data->mp, FUSE_INTERRUPT); 1036 1037 if (!fuse_libabi_geq(data, 7, 8)) { 1038 fsess_set_notimpl(data->mp, FUSE_BMAP); 1039 fsess_set_notimpl(data->mp, FUSE_DESTROY); 1040 } 1041 1042 if (fuse_libabi_geq(data, 7, 23) && fiio->time_gran >= 1 && 1043 fiio->time_gran <= 1000000000) 1044 data->time_gran = fiio->time_gran; 1045 else 1046 data->time_gran = 1; 1047 1048 if (!fuse_libabi_geq(data, 7, 23)) 1049 data->cache_mode = fuse_data_cache_mode; 1050 else if (fiio->flags & FUSE_WRITEBACK_CACHE) 1051 data->cache_mode = FUSE_CACHE_WB; 1052 else 1053 data->cache_mode = FUSE_CACHE_WT; 1054 1055 if (!fuse_libabi_geq(data, 7, 24)) 1056 fsess_set_notimpl(data->mp, FUSE_LSEEK); 1057 1058 if (!fuse_libabi_geq(data, 7, 28)) 1059 fsess_set_notimpl(data->mp, FUSE_COPY_FILE_RANGE); 1060 1061out: 1062 if (err) { 1063 fdata_set_dead(data); 1064 } 1065 FUSE_LOCK(); 1066 data->dataflags |= FSESS_INITED; 1067 SDT_PROBE2(fusefs, , internal, init_done, data, fiio); 1068 wakeup(&data->ticketer); 1069 FUSE_UNLOCK(); 1070 1071 return 0; 1072} 1073 1074void 1075fuse_internal_send_init(struct fuse_data *data, struct thread *td) 1076{ 1077 struct fuse_init_in *fiii; 1078 struct fuse_dispatcher fdi; 1079 1080 fdisp_init(&fdi, sizeof(*fiii)); 1081 fdisp_make(&fdi, FUSE_INIT, data->mp, 0, td, NULL); 1082 fiii = fdi.indata; 1083 fiii->major = FUSE_KERNEL_VERSION; 1084 fiii->minor = FUSE_KERNEL_MINOR_VERSION; 1085 /* 1086 * fusefs currently reads ahead no more than one cache block at a time. 1087 * See fuse_read_biobackend 1088 */ 1089 fiii->max_readahead = maxbcachebuf; 1090 /* 1091 * Unsupported features: 1092 * FUSE_FILE_OPS: No known FUSE server or client supports it 1093 * FUSE_ATOMIC_O_TRUNC: our VFS cannot support it 1094 * FUSE_DONT_MASK: unlike Linux, FreeBSD always applies the umask, even 1095 * when default ACLs are in use. 1096 * FUSE_SPLICE_WRITE, FUSE_SPLICE_MOVE, FUSE_SPLICE_READ: FreeBSD 1097 * doesn't have splice(2). 1098 * FUSE_FLOCK_LOCKS: not yet implemented 1099 * FUSE_HAS_IOCTL_DIR: not yet implemented 1100 * FUSE_AUTO_INVAL_DATA: not yet implemented 1101 * FUSE_DO_READDIRPLUS: not yet implemented 1102 * FUSE_READDIRPLUS_AUTO: not yet implemented 1103 * FUSE_ASYNC_DIO: not yet implemented 1104 * FUSE_NO_OPEN_SUPPORT: not yet implemented 1105 * FUSE_PARALLEL_DIROPS: not yet implemented 1106 * FUSE_HANDLE_KILLPRIV: not yet implemented 1107 * FUSE_POSIX_ACL: not yet implemented 1108 * FUSE_ABORT_ERROR: not yet implemented 1109 * FUSE_CACHE_SYMLINKS: not yet implemented 1110 * FUSE_MAX_PAGES: not yet implemented 1111 */ 1112 fiii->flags = FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_EXPORT_SUPPORT 1113 | FUSE_BIG_WRITES | FUSE_WRITEBACK_CACHE; 1114 1115 fuse_insert_callback(fdi.tick, fuse_internal_init_callback); 1116 fuse_insert_message(fdi.tick, false); 1117 fdisp_destroy(&fdi); 1118} 1119 1120/* 1121 * Send a FUSE_SETATTR operation with no permissions checks. If cred is NULL, 1122 * send the request with root credentials 1123 */ 1124int fuse_internal_setattr(struct vnode *vp, struct vattr *vap, 1125 struct thread *td, struct ucred *cred) 1126{ 1127 struct fuse_vnode_data *fvdat; 1128 struct fuse_dispatcher fdi; 1129 struct fuse_setattr_in *fsai; 1130 struct mount *mp; 1131 pid_t pid = td->td_proc->p_pid; 1132 struct fuse_data *data; 1133 int dataflags; 1134 int err = 0; 1135 enum vtype vtyp; 1136 int sizechanged = -1; 1137 uint64_t newsize = 0; 1138 1139 mp = vnode_mount(vp); 1140 fvdat = VTOFUD(vp); 1141 data = fuse_get_mpdata(mp); 1142 dataflags = data->dataflags; 1143 1144 fdisp_init(&fdi, sizeof(*fsai)); 1145 fdisp_make_vp(&fdi, FUSE_SETATTR, vp, td, cred); 1146 if (!cred) { 1147 fdi.finh->uid = 0; 1148 fdi.finh->gid = 0; 1149 } 1150 fsai = fdi.indata; 1151 fsai->valid = 0; 1152 1153 if (vap->va_uid != (uid_t)VNOVAL) { 1154 fsai->uid = vap->va_uid; 1155 fsai->valid |= FATTR_UID; 1156 } 1157 if (vap->va_gid != (gid_t)VNOVAL) { 1158 fsai->gid = vap->va_gid; 1159 fsai->valid |= FATTR_GID; 1160 } 1161 if (vap->va_size != VNOVAL) { 1162 struct fuse_filehandle *fufh = NULL; 1163 1164 /*Truncate to a new value. */ 1165 fsai->size = vap->va_size; 1166 sizechanged = 1; 1167 newsize = vap->va_size; 1168 fsai->valid |= FATTR_SIZE; 1169 1170 fuse_filehandle_getrw(vp, FWRITE, &fufh, cred, pid); 1171 if (fufh) { 1172 fsai->fh = fufh->fh_id; 1173 fsai->valid |= FATTR_FH; 1174 } 1175 VTOFUD(vp)->flag &= ~FN_SIZECHANGE; 1176 } 1177 if (vap->va_atime.tv_sec != VNOVAL) { 1178 fsai->atime = vap->va_atime.tv_sec; 1179 fsai->atimensec = vap->va_atime.tv_nsec; 1180 fsai->valid |= FATTR_ATIME; 1181 if (vap->va_vaflags & VA_UTIMES_NULL) 1182 fsai->valid |= FATTR_ATIME_NOW; 1183 } 1184 if (vap->va_mtime.tv_sec != VNOVAL) { 1185 fsai->mtime = vap->va_mtime.tv_sec; 1186 fsai->mtimensec = vap->va_mtime.tv_nsec; 1187 fsai->valid |= FATTR_MTIME; 1188 if (vap->va_vaflags & VA_UTIMES_NULL) 1189 fsai->valid |= FATTR_MTIME_NOW; 1190 } else if (fvdat->flag & FN_MTIMECHANGE) { 1191 fsai->mtime = fvdat->cached_attrs.va_mtime.tv_sec; 1192 fsai->mtimensec = fvdat->cached_attrs.va_mtime.tv_nsec; 1193 fsai->valid |= FATTR_MTIME; 1194 } 1195 if (fuse_libabi_geq(data, 7, 23) && fvdat->flag & FN_CTIMECHANGE) { 1196 fsai->ctime = fvdat->cached_attrs.va_ctime.tv_sec; 1197 fsai->ctimensec = fvdat->cached_attrs.va_ctime.tv_nsec; 1198 fsai->valid |= FATTR_CTIME; 1199 } 1200 if (vap->va_mode != (mode_t)VNOVAL) { 1201 fsai->mode = vap->va_mode & ALLPERMS; 1202 fsai->valid |= FATTR_MODE; 1203 } 1204 if (!fsai->valid) { 1205 goto out; 1206 } 1207 1208 if ((err = fdisp_wait_answ(&fdi))) 1209 goto out; 1210 vtyp = IFTOVT(((struct fuse_attr_out *)fdi.answ)->attr.mode); 1211 1212 if (vnode_vtype(vp) != vtyp) { 1213 if (vnode_vtype(vp) == VNON && vtyp != VNON) { 1214 SDT_PROBE2(fusefs, , internal, trace, 1, "FUSE: Dang! " 1215 "vnode_vtype is VNON and vtype isn't."); 1216 } else { 1217 /* 1218 * STALE vnode, ditch 1219 * 1220 * The vnode has changed its type "behind our back". 1221 * There's nothing really we can do, so let us just 1222 * force an internal revocation and tell the caller to 1223 * try again, if interested. 1224 */ 1225 fuse_internal_vnode_disappear(vp); 1226 err = EAGAIN; 1227 } 1228 } 1229 if (err == 0) { 1230 struct fuse_attr_out *fao = (struct fuse_attr_out*)fdi.answ; 1231 fuse_vnode_undirty_cached_timestamps(vp); 1232 fuse_internal_cache_attrs(vp, &fao->attr, fao->attr_valid, 1233 fao->attr_valid_nsec, NULL); 1234 } 1235 1236out: 1237 fdisp_destroy(&fdi); 1238 return err; 1239} 1240 1241/* 1242 * FreeBSD clears the SUID and SGID bits on any write by a non-root user. 1243 */ 1244void 1245fuse_internal_clear_suid_on_write(struct vnode *vp, struct ucred *cred, 1246 struct thread *td) 1247{ 1248 struct fuse_data *data; 1249 struct mount *mp; 1250 struct vattr va; 1251 int dataflags; 1252 1253 mp = vnode_mount(vp); 1254 data = fuse_get_mpdata(mp); 1255 dataflags = data->dataflags; 1256 1257 ASSERT_VOP_LOCKED(vp, __func__); 1258 1259 if (dataflags & FSESS_DEFAULT_PERMISSIONS) { 1260 if (priv_check_cred(cred, PRIV_VFS_RETAINSUGID)) { 1261 fuse_internal_getattr(vp, &va, cred, td); 1262 if (va.va_mode & (S_ISUID | S_ISGID)) { 1263 mode_t mode = va.va_mode & ~(S_ISUID | S_ISGID); 1264 /* Clear all vattr fields except mode */ 1265 vattr_null(&va); 1266 va.va_mode = mode; 1267 1268 /* 1269 * Ignore fuse_internal_setattr's return value, 1270 * because at this point the write operation has 1271 * already succeeded and we don't want to return 1272 * failing status for that. 1273 */ 1274 (void)fuse_internal_setattr(vp, &va, td, NULL); 1275 } 1276 } 1277 } 1278} 1279 1280#ifdef ZERO_PAD_INCOMPLETE_BUFS 1281static int 1282isbzero(void *buf, size_t len) 1283{ 1284 int i; 1285 1286 for (i = 0; i < len; i++) { 1287 if (((char *)buf)[i]) 1288 return (0); 1289 } 1290 1291 return (1); 1292} 1293 1294#endif 1295 1296void 1297fuse_internal_init(void) 1298{ 1299 fuse_lookup_cache_misses = counter_u64_alloc(M_WAITOK); 1300 fuse_lookup_cache_hits = counter_u64_alloc(M_WAITOK); 1301} 1302 1303void 1304fuse_internal_destroy(void) 1305{ 1306 counter_u64_free(fuse_lookup_cache_hits); 1307 counter_u64_free(fuse_lookup_cache_misses); 1308} 1309