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