sys/fs/fuse/fuse_internal.c

   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
 103 SDT_PROVIDER_DECLARE(fusefs);
 104 /*
 105  * Fuse trace probe:
 106  * arg0: verbosity.  Higher numbers give more verbose messages
 107  * arg1: Textual message
 108  */
 109 SDT_PROBE_DEFINE2(fusefs, , internal, trace, "int", "char*");
 110
 111 #ifdef ZERO_PAD_INCOMPLETE_BUFS
 112 static int isbzero(void *buf, size_t len);
 113
 114 #endif
 115
 116 counter_u64_t fuse_lookup_cache_hits;
 117 counter_u64_t fuse_lookup_cache_misses;
 118
 119 SYSCTL_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
 122 SYSCTL_COUNTER_U64(_vfs_fusefs_stats, OID_AUTO, lookup_cache_misses, CTLFLAG_RD,
 123     &fuse_lookup_cache_misses, "number of cache misses in lookup");
 124
 125 int
 126 fuse_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
 161 SDT_PROBE_DEFINE0(fusefs, , internal, access_vadmin);
 162 /* Synchronously send a FUSE_ACCESS operation */
 163 int
 164 fuse_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  */
 256 void
 257 fuse_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
 317 int
 318 fuse_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
 326 int
 327 fuse_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 */
 388 SDT_PROBE_DEFINE3(fusefs, , internal, invalidate_entry,
 389         "struct vnode*", "struct fuse_notify_inval_entry_out*", "char*");
 390 int
 391 fuse_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
 447 SDT_PROBE_DEFINE2(fusefs, , internal, invalidate_inode,
 448         "struct vnode*", "struct fuse_notify_inval_inode_out *");
 449 int
 450 fuse_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 */
 486 int
 487 fuse_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
 510 int
 511 fuse_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  */
 574 int
 575 fuse_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
 675 int
 676 fuse_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
 727 int
 728 fuse_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
 759 void
 760 fuse_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
 776 int
 777 fuse_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
 814 int
 815 fuse_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
 838 int
 839 fuse_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
 847 void
 848 fuse_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
 873 SDT_PROBE_DEFINE2(fusefs, , internal, getattr_cache_incoherent,
 874         "struct vnode*", "struct fuse_attr_out*");
 875
 876 /* Fetch the vnode's attributes from the daemon*/
 877 int
 878 fuse_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
 943 out:
 944         fdisp_destroy(&fdi);
 945         return err;
 946 }
 947
 948 /* Read a vnode's attributes from cache or fetch them from the fuse daemon */
 949 int
 950 fuse_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
 963 void
 964 fuse_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
 975 SDT_PROBE_DEFINE2(fusefs, , internal, init_done,
 976         "struct fuse_data*", "struct fuse_init_out*");
 977 int
 978 fuse_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
1061 out:
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
1074 void
1075 fuse_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  */
1124 int 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
1236 out:
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  */
1244 void
1245 fuse_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
1281 static int
1282 isbzero(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
1296 void
1297 fuse_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
1303 void
1304 fuse_internal_destroy(void)
1305 {
1306         counter_u64_free(fuse_lookup_cache_hits);
1307         counter_u64_free(fuse_lookup_cache_misses);
1308 }