151369649SPedro F. Giffuni /*- 251369649SPedro F. Giffuni * SPDX-License-Identifier: BSD-3-Clause 351369649SPedro F. Giffuni * 45fe58019SAttilio Rao * Copyright (c) 2007-2009 Google Inc. and Amit Singh 55fe58019SAttilio Rao * All rights reserved. 65fe58019SAttilio Rao * 75fe58019SAttilio Rao * Redistribution and use in source and binary forms, with or without 85fe58019SAttilio Rao * modification, are permitted provided that the following conditions are 95fe58019SAttilio Rao * met: 105fe58019SAttilio Rao * 115fe58019SAttilio Rao * * Redistributions of source code must retain the above copyright 125fe58019SAttilio Rao * notice, this list of conditions and the following disclaimer. 135fe58019SAttilio Rao * * Redistributions in binary form must reproduce the above 145fe58019SAttilio Rao * copyright notice, this list of conditions and the following disclaimer 155fe58019SAttilio Rao * in the documentation and/or other materials provided with the 165fe58019SAttilio Rao * distribution. 175fe58019SAttilio Rao * * Neither the name of Google Inc. nor the names of its 185fe58019SAttilio Rao * contributors may be used to endorse or promote products derived from 195fe58019SAttilio Rao * this software without specific prior written permission. 205fe58019SAttilio Rao * 215fe58019SAttilio Rao * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 225fe58019SAttilio Rao * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 235fe58019SAttilio Rao * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 245fe58019SAttilio Rao * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 255fe58019SAttilio Rao * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 265fe58019SAttilio Rao * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 275fe58019SAttilio Rao * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 285fe58019SAttilio Rao * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 295fe58019SAttilio Rao * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 305fe58019SAttilio Rao * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 315fe58019SAttilio Rao * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 325fe58019SAttilio Rao * 335fe58019SAttilio Rao * Copyright (C) 2005 Csaba Henk. 345fe58019SAttilio Rao * All rights reserved. 355fe58019SAttilio Rao * 368aafc8c3SAlan Somers * Copyright (c) 2019 The FreeBSD Foundation 378aafc8c3SAlan Somers * 388aafc8c3SAlan Somers * Portions of this software were developed by BFF Storage Systems, LLC under 398aafc8c3SAlan Somers * sponsorship from the FreeBSD Foundation. 408aafc8c3SAlan Somers * 415fe58019SAttilio Rao * Redistribution and use in source and binary forms, with or without 425fe58019SAttilio Rao * modification, are permitted provided that the following conditions 435fe58019SAttilio Rao * are met: 445fe58019SAttilio Rao * 1. Redistributions of source code must retain the above copyright 455fe58019SAttilio Rao * notice, this list of conditions and the following disclaimer. 465fe58019SAttilio Rao * 2. Redistributions in binary form must reproduce the above copyright 475fe58019SAttilio Rao * notice, this list of conditions and the following disclaimer in the 485fe58019SAttilio Rao * documentation and/or other materials provided with the distribution. 495fe58019SAttilio Rao * 505fe58019SAttilio Rao * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND 515fe58019SAttilio Rao * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 525fe58019SAttilio Rao * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 535fe58019SAttilio Rao * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 545fe58019SAttilio Rao * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 555fe58019SAttilio Rao * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 565fe58019SAttilio Rao * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 575fe58019SAttilio Rao * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 585fe58019SAttilio Rao * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 595fe58019SAttilio Rao * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 605fe58019SAttilio Rao * SUCH DAMAGE. 615fe58019SAttilio Rao */ 625fe58019SAttilio Rao 635fe58019SAttilio Rao #include <sys/cdefs.h> 645fe58019SAttilio Rao __FBSDID("$FreeBSD$"); 655fe58019SAttilio Rao 66cf169498SAlan Somers #include <sys/param.h> 675fe58019SAttilio Rao #include <sys/module.h> 685fe58019SAttilio Rao #include <sys/systm.h> 695fe58019SAttilio Rao #include <sys/errno.h> 705fe58019SAttilio Rao #include <sys/kernel.h> 715fe58019SAttilio Rao #include <sys/conf.h> 725fe58019SAttilio Rao #include <sys/uio.h> 735fe58019SAttilio Rao #include <sys/malloc.h> 745fe58019SAttilio Rao #include <sys/queue.h> 7591898857SMark Johnston #include <sys/limits.h> 765fe58019SAttilio Rao #include <sys/lock.h> 7789f6b863SAttilio Rao #include <sys/rwlock.h> 785fe58019SAttilio Rao #include <sys/sx.h> 795fe58019SAttilio Rao #include <sys/proc.h> 805fe58019SAttilio Rao #include <sys/mount.h> 815fe58019SAttilio Rao #include <sys/vnode.h> 825fe58019SAttilio Rao #include <sys/namei.h> 8304660064SFedor Uporov #include <sys/extattr.h> 845fe58019SAttilio Rao #include <sys/stat.h> 855fe58019SAttilio Rao #include <sys/unistd.h> 865fe58019SAttilio Rao #include <sys/filedesc.h> 875fe58019SAttilio Rao #include <sys/file.h> 885fe58019SAttilio Rao #include <sys/fcntl.h> 895fe58019SAttilio Rao #include <sys/dirent.h> 905fe58019SAttilio Rao #include <sys/bio.h> 915fe58019SAttilio Rao #include <sys/buf.h> 925fe58019SAttilio Rao #include <sys/sysctl.h> 93ca148cdaSGleb Smirnoff #include <sys/vmmeter.h> 945fe58019SAttilio Rao 955fe58019SAttilio Rao #include <vm/vm.h> 965fe58019SAttilio Rao #include <vm/vm_extern.h> 975fe58019SAttilio Rao #include <vm/pmap.h> 985fe58019SAttilio Rao #include <vm/vm_map.h> 995fe58019SAttilio Rao #include <vm/vm_page.h> 1005fe58019SAttilio Rao #include <vm/vm_param.h> 1015fe58019SAttilio Rao #include <vm/vm_object.h> 1025fe58019SAttilio Rao #include <vm/vm_pager.h> 1035fe58019SAttilio Rao #include <vm/vnode_pager.h> 1045fe58019SAttilio Rao #include <vm/vm_object.h> 1055fe58019SAttilio Rao 1065fe58019SAttilio Rao #include "fuse.h" 1075fe58019SAttilio Rao #include "fuse_file.h" 1085fe58019SAttilio Rao #include "fuse_internal.h" 1095fe58019SAttilio Rao #include "fuse_ipc.h" 1105fe58019SAttilio Rao #include "fuse_node.h" 1115fe58019SAttilio Rao #include "fuse_io.h" 1125fe58019SAttilio Rao 1135fe58019SAttilio Rao #include <sys/priv.h> 1145fe58019SAttilio Rao 115fd2749f2SAlan Somers /* Maximum number of hardlinks to a single FUSE file */ 116fd2749f2SAlan Somers #define FUSE_LINK_MAX UINT32_MAX 117fd2749f2SAlan Somers 118419e7ff6SAlan Somers SDT_PROVIDER_DECLARE(fusefs); 119cf169498SAlan Somers /* 120cf169498SAlan Somers * Fuse trace probe: 121cf169498SAlan Somers * arg0: verbosity. Higher numbers give more verbose messages 122cf169498SAlan Somers * arg1: Textual message 123cf169498SAlan Somers */ 124419e7ff6SAlan Somers SDT_PROBE_DEFINE2(fusefs, , vnops, trace, "int", "char*"); 1255fe58019SAttilio Rao 1265fe58019SAttilio Rao /* vnode ops */ 1275fe58019SAttilio Rao static vop_access_t fuse_vnop_access; 128f067b609SAlan Somers static vop_advlock_t fuse_vnop_advlock; 129a1c9f4adSAlan Somers static vop_bmap_t fuse_vnop_bmap; 130f9b0e30bSAlan Somers static vop_close_t fuse_fifo_close; 1315fe58019SAttilio Rao static vop_close_t fuse_vnop_close; 1325fe58019SAttilio Rao static vop_create_t fuse_vnop_create; 13304660064SFedor Uporov static vop_deleteextattr_t fuse_vnop_deleteextattr; 134915012e0SAlan Somers static vop_fdatasync_t fuse_vnop_fdatasync; 1355fe58019SAttilio Rao static vop_fsync_t fuse_vnop_fsync; 1365fe58019SAttilio Rao static vop_getattr_t fuse_vnop_getattr; 13704660064SFedor Uporov static vop_getextattr_t fuse_vnop_getextattr; 1385fe58019SAttilio Rao static vop_inactive_t fuse_vnop_inactive; 1395fe58019SAttilio Rao static vop_link_t fuse_vnop_link; 14004660064SFedor Uporov static vop_listextattr_t fuse_vnop_listextattr; 1415fe58019SAttilio Rao static vop_lookup_t fuse_vnop_lookup; 1425fe58019SAttilio Rao static vop_mkdir_t fuse_vnop_mkdir; 1435fe58019SAttilio Rao static vop_mknod_t fuse_vnop_mknod; 1445fe58019SAttilio Rao static vop_open_t fuse_vnop_open; 145746c92e0SJohn Baldwin static vop_pathconf_t fuse_vnop_pathconf; 1465fe58019SAttilio Rao static vop_read_t fuse_vnop_read; 1475fe58019SAttilio Rao static vop_readdir_t fuse_vnop_readdir; 1485fe58019SAttilio Rao static vop_readlink_t fuse_vnop_readlink; 1495fe58019SAttilio Rao static vop_reclaim_t fuse_vnop_reclaim; 1505fe58019SAttilio Rao static vop_remove_t fuse_vnop_remove; 1515fe58019SAttilio Rao static vop_rename_t fuse_vnop_rename; 1525fe58019SAttilio Rao static vop_rmdir_t fuse_vnop_rmdir; 1535fe58019SAttilio Rao static vop_setattr_t fuse_vnop_setattr; 15404660064SFedor Uporov static vop_setextattr_t fuse_vnop_setextattr; 1555fe58019SAttilio Rao static vop_strategy_t fuse_vnop_strategy; 1565fe58019SAttilio Rao static vop_symlink_t fuse_vnop_symlink; 1575fe58019SAttilio Rao static vop_write_t fuse_vnop_write; 1585fe58019SAttilio Rao static vop_getpages_t fuse_vnop_getpages; 1595fe58019SAttilio Rao static vop_print_t fuse_vnop_print; 160e5b50fe7SAlan Somers static vop_vptofh_t fuse_vnop_vptofh; 1615fe58019SAttilio Rao 162f9b0e30bSAlan Somers struct vop_vector fuse_fifoops = { 163f9b0e30bSAlan Somers .vop_default = &fifo_specops, 164f9b0e30bSAlan Somers .vop_access = fuse_vnop_access, 165f9b0e30bSAlan Somers .vop_close = fuse_fifo_close, 166f9b0e30bSAlan Somers .vop_fsync = fuse_vnop_fsync, 167f9b0e30bSAlan Somers .vop_getattr = fuse_vnop_getattr, 168f9b0e30bSAlan Somers .vop_inactive = fuse_vnop_inactive, 169f9b0e30bSAlan Somers .vop_pathconf = fuse_vnop_pathconf, 170f9b0e30bSAlan Somers .vop_print = fuse_vnop_print, 171f9b0e30bSAlan Somers .vop_read = VOP_PANIC, 172f9b0e30bSAlan Somers .vop_reclaim = fuse_vnop_reclaim, 173f9b0e30bSAlan Somers .vop_setattr = fuse_vnop_setattr, 174f9b0e30bSAlan Somers .vop_write = VOP_PANIC, 175e5b50fe7SAlan Somers .vop_vptofh = fuse_vnop_vptofh, 176f9b0e30bSAlan Somers }; 1776fa079fcSMateusz Guzik VFS_VOP_VECTOR_REGISTER(fuse_fifoops); 178f9b0e30bSAlan Somers 1795fe58019SAttilio Rao struct vop_vector fuse_vnops = { 1801c8a5f5eSAlan Somers .vop_allocate = VOP_EINVAL, 1815fe58019SAttilio Rao .vop_default = &default_vnodeops, 1825fe58019SAttilio Rao .vop_access = fuse_vnop_access, 183f067b609SAlan Somers .vop_advlock = fuse_vnop_advlock, 184a1c9f4adSAlan Somers .vop_bmap = fuse_vnop_bmap, 1855fe58019SAttilio Rao .vop_close = fuse_vnop_close, 1865fe58019SAttilio Rao .vop_create = fuse_vnop_create, 18704660064SFedor Uporov .vop_deleteextattr = fuse_vnop_deleteextattr, 1885fe58019SAttilio Rao .vop_fsync = fuse_vnop_fsync, 189915012e0SAlan Somers .vop_fdatasync = fuse_vnop_fdatasync, 1905fe58019SAttilio Rao .vop_getattr = fuse_vnop_getattr, 19104660064SFedor Uporov .vop_getextattr = fuse_vnop_getextattr, 1925fe58019SAttilio Rao .vop_inactive = fuse_vnop_inactive, 193e039bafaSAlan Somers /* 194e039bafaSAlan Somers * TODO: implement vop_ioctl after upgrading to protocol 7.16. 195e039bafaSAlan Somers * FUSE_IOCTL was added in 7.11, but 32-bit compat is broken until 196e039bafaSAlan Somers * 7.16. 197e039bafaSAlan Somers */ 1985fe58019SAttilio Rao .vop_link = fuse_vnop_link, 19904660064SFedor Uporov .vop_listextattr = fuse_vnop_listextattr, 2005fe58019SAttilio Rao .vop_lookup = fuse_vnop_lookup, 2015fe58019SAttilio Rao .vop_mkdir = fuse_vnop_mkdir, 2025fe58019SAttilio Rao .vop_mknod = fuse_vnop_mknod, 2035fe58019SAttilio Rao .vop_open = fuse_vnop_open, 204746c92e0SJohn Baldwin .vop_pathconf = fuse_vnop_pathconf, 205e039bafaSAlan Somers /* 206e039bafaSAlan Somers * TODO: implement vop_poll after upgrading to protocol 7.21. 207e039bafaSAlan Somers * FUSE_POLL was added in protocol 7.11, but it's kind of broken until 208e039bafaSAlan Somers * 7.21, which adds the ability for the client to choose which poll 209e039bafaSAlan Somers * events it wants, and for a client to deregister a file handle 210e039bafaSAlan Somers */ 2115fe58019SAttilio Rao .vop_read = fuse_vnop_read, 2125fe58019SAttilio Rao .vop_readdir = fuse_vnop_readdir, 2135fe58019SAttilio Rao .vop_readlink = fuse_vnop_readlink, 2145fe58019SAttilio Rao .vop_reclaim = fuse_vnop_reclaim, 2155fe58019SAttilio Rao .vop_remove = fuse_vnop_remove, 2165fe58019SAttilio Rao .vop_rename = fuse_vnop_rename, 2175fe58019SAttilio Rao .vop_rmdir = fuse_vnop_rmdir, 2185fe58019SAttilio Rao .vop_setattr = fuse_vnop_setattr, 21904660064SFedor Uporov .vop_setextattr = fuse_vnop_setextattr, 2205fe58019SAttilio Rao .vop_strategy = fuse_vnop_strategy, 2215fe58019SAttilio Rao .vop_symlink = fuse_vnop_symlink, 2225fe58019SAttilio Rao .vop_write = fuse_vnop_write, 2235fe58019SAttilio Rao .vop_getpages = fuse_vnop_getpages, 2245fe58019SAttilio Rao .vop_print = fuse_vnop_print, 225e5b50fe7SAlan Somers .vop_vptofh = fuse_vnop_vptofh, 2265fe58019SAttilio Rao }; 2276fa079fcSMateusz Guzik VFS_VOP_VECTOR_REGISTER(fuse_vnops); 2285fe58019SAttilio Rao 229756a5412SGleb Smirnoff uma_zone_t fuse_pbuf_zone; 2305fe58019SAttilio Rao 231666f8543SAlan Somers /* Check permission for extattr operations, much like extattr_check_cred */ 232666f8543SAlan Somers static int 233666f8543SAlan Somers fuse_extattr_check_cred(struct vnode *vp, int ns, struct ucred *cred, 234666f8543SAlan Somers struct thread *td, accmode_t accmode) 235666f8543SAlan Somers { 236666f8543SAlan Somers struct mount *mp = vnode_mount(vp); 237666f8543SAlan Somers struct fuse_data *data = fuse_get_mpdata(mp); 238666f8543SAlan Somers 239666f8543SAlan Somers /* 240666f8543SAlan Somers * Kernel-invoked always succeeds. 241666f8543SAlan Somers */ 242666f8543SAlan Somers if (cred == NOCRED) 243666f8543SAlan Somers return (0); 244666f8543SAlan Somers 245666f8543SAlan Somers /* 246666f8543SAlan Somers * Do not allow privileged processes in jail to directly manipulate 247666f8543SAlan Somers * system attributes. 248666f8543SAlan Somers */ 249666f8543SAlan Somers switch (ns) { 250666f8543SAlan Somers case EXTATTR_NAMESPACE_SYSTEM: 251666f8543SAlan Somers if (data->dataflags & FSESS_DEFAULT_PERMISSIONS) { 252666f8543SAlan Somers return (priv_check_cred(cred, PRIV_VFS_EXTATTR_SYSTEM)); 253666f8543SAlan Somers } 254666f8543SAlan Somers /* FALLTHROUGH */ 255666f8543SAlan Somers case EXTATTR_NAMESPACE_USER: 256666f8543SAlan Somers return (fuse_internal_access(vp, accmode, td, cred)); 257666f8543SAlan Somers default: 258666f8543SAlan Somers return (EPERM); 259666f8543SAlan Somers } 260666f8543SAlan Somers } 261666f8543SAlan Somers 262f8d4af10SAlan Somers /* Get a filehandle for a directory */ 263f8d4af10SAlan Somers static int 264f8d4af10SAlan Somers fuse_filehandle_get_dir(struct vnode *vp, struct fuse_filehandle **fufhp, 265f8d4af10SAlan Somers struct ucred *cred, pid_t pid) 266f8d4af10SAlan Somers { 2679f10f423SAlan Somers if (fuse_filehandle_get(vp, FREAD, fufhp, cred, pid) == 0) 268f8d4af10SAlan Somers return 0; 2699f10f423SAlan Somers return fuse_filehandle_get(vp, FEXEC, fufhp, cred, pid); 2709f10f423SAlan Somers } 2719f10f423SAlan Somers 2729f10f423SAlan Somers /* Send FUSE_FLUSH for this vnode */ 2739f10f423SAlan Somers static int 2749f10f423SAlan Somers fuse_flush(struct vnode *vp, struct ucred *cred, pid_t pid, int fflag) 2759f10f423SAlan Somers { 2769f10f423SAlan Somers struct fuse_flush_in *ffi; 2779f10f423SAlan Somers struct fuse_filehandle *fufh; 2789f10f423SAlan Somers struct fuse_dispatcher fdi; 2799f10f423SAlan Somers struct thread *td = curthread; 2809f10f423SAlan Somers struct mount *mp = vnode_mount(vp); 2819f10f423SAlan Somers int err; 2829f10f423SAlan Somers 2839f10f423SAlan Somers if (!fsess_isimpl(vnode_mount(vp), FUSE_FLUSH)) 2849f10f423SAlan Somers return 0; 2859f10f423SAlan Somers 286f067b609SAlan Somers err = fuse_filehandle_getrw(vp, fflag, &fufh, cred, pid); 2879f10f423SAlan Somers if (err) 2889f10f423SAlan Somers return err; 2899f10f423SAlan Somers 2909f10f423SAlan Somers fdisp_init(&fdi, sizeof(*ffi)); 2919f10f423SAlan Somers fdisp_make_vp(&fdi, FUSE_FLUSH, vp, td, cred); 2929f10f423SAlan Somers ffi = fdi.indata; 2939f10f423SAlan Somers ffi->fh = fufh->fh_id; 294f067b609SAlan Somers /* 295f067b609SAlan Somers * If the file has a POSIX lock then we're supposed to set lock_owner. 296f067b609SAlan Somers * If not, then lock_owner is undefined. So we may as well always set 297f067b609SAlan Somers * it. 298f067b609SAlan Somers */ 299f067b609SAlan Somers ffi->lock_owner = td->td_proc->p_pid; 3009f10f423SAlan Somers 3019f10f423SAlan Somers err = fdisp_wait_answ(&fdi); 3029f10f423SAlan Somers if (err == ENOSYS) { 3039f10f423SAlan Somers fsess_set_notimpl(mp, FUSE_FLUSH); 3049f10f423SAlan Somers err = 0; 3059f10f423SAlan Somers } 3069f10f423SAlan Somers fdisp_destroy(&fdi); 3079f10f423SAlan Somers return err; 308f8d4af10SAlan Somers } 309f8d4af10SAlan Somers 310f9b0e30bSAlan Somers /* Close wrapper for fifos. */ 311f9b0e30bSAlan Somers static int 312f9b0e30bSAlan Somers fuse_fifo_close(struct vop_close_args *ap) 313f9b0e30bSAlan Somers { 314f9b0e30bSAlan Somers return (fifo_specops.vop_close(ap)); 315f9b0e30bSAlan Somers } 316f9b0e30bSAlan Somers 3175fe58019SAttilio Rao /* 3185fe58019SAttilio Rao struct vnop_access_args { 3195fe58019SAttilio Rao struct vnode *a_vp; 3205fe58019SAttilio Rao #if VOP_ACCESS_TAKES_ACCMODE_T 3215fe58019SAttilio Rao accmode_t a_accmode; 3225fe58019SAttilio Rao #else 3235fe58019SAttilio Rao int a_mode; 3245fe58019SAttilio Rao #endif 3255fe58019SAttilio Rao struct ucred *a_cred; 3265fe58019SAttilio Rao struct thread *a_td; 3275fe58019SAttilio Rao }; 3285fe58019SAttilio Rao */ 3295fe58019SAttilio Rao static int 3305fe58019SAttilio Rao fuse_vnop_access(struct vop_access_args *ap) 3315fe58019SAttilio Rao { 3325fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 3335fe58019SAttilio Rao int accmode = ap->a_accmode; 3345fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 3355fe58019SAttilio Rao 3365fe58019SAttilio Rao struct fuse_data *data = fuse_get_mpdata(vnode_mount(vp)); 3375fe58019SAttilio Rao 3385fe58019SAttilio Rao int err; 3395fe58019SAttilio Rao 3405fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 3415fe58019SAttilio Rao if (vnode_isvroot(vp)) { 3425fe58019SAttilio Rao return 0; 3435fe58019SAttilio Rao } 3445fe58019SAttilio Rao return ENXIO; 3455fe58019SAttilio Rao } 3465fe58019SAttilio Rao if (!(data->dataflags & FSESS_INITED)) { 3475fe58019SAttilio Rao if (vnode_isvroot(vp)) { 348cc426dd3SMateusz Guzik if (priv_check_cred(cred, PRIV_VFS_ADMIN) || 3495fe58019SAttilio Rao (fuse_match_cred(data->daemoncred, cred) == 0)) { 3505fe58019SAttilio Rao return 0; 3515fe58019SAttilio Rao } 3525fe58019SAttilio Rao } 3535fe58019SAttilio Rao return EBADF; 3545fe58019SAttilio Rao } 3555fe58019SAttilio Rao if (vnode_islnk(vp)) { 3565fe58019SAttilio Rao return 0; 3575fe58019SAttilio Rao } 3585fe58019SAttilio Rao 359666f8543SAlan Somers err = fuse_internal_access(vp, accmode, ap->a_td, ap->a_cred); 3605fe58019SAttilio Rao return err; 3615fe58019SAttilio Rao } 3625fe58019SAttilio Rao 3635fe58019SAttilio Rao /* 364f067b609SAlan Somers * struct vop_advlock_args { 365f067b609SAlan Somers * struct vop_generic_args a_gen; 366f067b609SAlan Somers * struct vnode *a_vp; 367f067b609SAlan Somers * void *a_id; 368f067b609SAlan Somers * int a_op; 369f067b609SAlan Somers * struct flock *a_fl; 370f067b609SAlan Somers * int a_flags; 371f067b609SAlan Somers * } 372f067b609SAlan Somers */ 373f067b609SAlan Somers static int 374f067b609SAlan Somers fuse_vnop_advlock(struct vop_advlock_args *ap) 375f067b609SAlan Somers { 376f067b609SAlan Somers struct vnode *vp = ap->a_vp; 377f067b609SAlan Somers struct flock *fl = ap->a_fl; 378f067b609SAlan Somers struct thread *td = curthread; 379f067b609SAlan Somers struct ucred *cred = td->td_ucred; 380f067b609SAlan Somers pid_t pid = td->td_proc->p_pid; 381f067b609SAlan Somers struct fuse_filehandle *fufh; 382f067b609SAlan Somers struct fuse_dispatcher fdi; 383f067b609SAlan Somers struct fuse_lk_in *fli; 384f067b609SAlan Somers struct fuse_lk_out *flo; 385f067b609SAlan Somers enum fuse_opcode op; 386f067b609SAlan Somers int dataflags, err; 3878aa24ed3SAlan Somers int flags = ap->a_flags; 388f067b609SAlan Somers 389f067b609SAlan Somers dataflags = fuse_get_mpdata(vnode_mount(vp))->dataflags; 390f067b609SAlan Somers 391f067b609SAlan Somers if (fuse_isdeadfs(vp)) { 392f067b609SAlan Somers return ENXIO; 393f067b609SAlan Somers } 394f067b609SAlan Somers 395f067b609SAlan Somers if (!(dataflags & FSESS_POSIX_LOCKS)) 396f067b609SAlan Somers return vop_stdadvlock(ap); 3978aa24ed3SAlan Somers /* FUSE doesn't properly support flock until protocol 7.17 */ 3988aa24ed3SAlan Somers if (flags & F_FLOCK) 3998aa24ed3SAlan Somers return vop_stdadvlock(ap); 400f067b609SAlan Somers 401f067b609SAlan Somers err = fuse_filehandle_get_anyflags(vp, &fufh, cred, pid); 402f067b609SAlan Somers if (err) 403f067b609SAlan Somers return err; 404f067b609SAlan Somers 405f067b609SAlan Somers fdisp_init(&fdi, sizeof(*fli)); 406f067b609SAlan Somers 407f067b609SAlan Somers switch(ap->a_op) { 408f067b609SAlan Somers case F_GETLK: 409f067b609SAlan Somers op = FUSE_GETLK; 410f067b609SAlan Somers break; 411f067b609SAlan Somers case F_SETLK: 412f067b609SAlan Somers op = FUSE_SETLK; 413f067b609SAlan Somers break; 414f067b609SAlan Somers case F_SETLKW: 415f067b609SAlan Somers op = FUSE_SETLKW; 416f067b609SAlan Somers break; 417f067b609SAlan Somers default: 418f067b609SAlan Somers return EINVAL; 419f067b609SAlan Somers } 420f067b609SAlan Somers 421f067b609SAlan Somers fdisp_make_vp(&fdi, op, vp, td, cred); 422f067b609SAlan Somers fli = fdi.indata; 423f067b609SAlan Somers fli->fh = fufh->fh_id; 424f067b609SAlan Somers fli->owner = fl->l_pid; 425f067b609SAlan Somers fli->lk.start = fl->l_start; 426f067b609SAlan Somers if (fl->l_len != 0) 427f067b609SAlan Somers fli->lk.end = fl->l_start + fl->l_len - 1; 428f067b609SAlan Somers else 429f067b609SAlan Somers fli->lk.end = INT64_MAX; 430f067b609SAlan Somers fli->lk.type = fl->l_type; 431f067b609SAlan Somers fli->lk.pid = fl->l_pid; 432f067b609SAlan Somers 433f067b609SAlan Somers err = fdisp_wait_answ(&fdi); 434f067b609SAlan Somers fdisp_destroy(&fdi); 435f067b609SAlan Somers 436f067b609SAlan Somers if (err == 0 && op == FUSE_GETLK) { 437f067b609SAlan Somers flo = fdi.answ; 438f067b609SAlan Somers fl->l_type = flo->lk.type; 439f067b609SAlan Somers fl->l_pid = flo->lk.pid; 440f067b609SAlan Somers if (flo->lk.type != F_UNLCK) { 441f067b609SAlan Somers fl->l_start = flo->lk.start; 442f067b609SAlan Somers if (flo->lk.end == INT64_MAX) 443f067b609SAlan Somers fl->l_len = 0; 444f067b609SAlan Somers else 445f067b609SAlan Somers fl->l_len = flo->lk.end - flo->lk.start + 1; 446f067b609SAlan Somers fl->l_start = flo->lk.start; 447f067b609SAlan Somers } 448f067b609SAlan Somers } 449f067b609SAlan Somers 450f067b609SAlan Somers return err; 451f067b609SAlan Somers } 452f067b609SAlan Somers 453a1c9f4adSAlan Somers /* { 454a1c9f4adSAlan Somers struct vnode *a_vp; 455a1c9f4adSAlan Somers daddr_t a_bn; 456a1c9f4adSAlan Somers struct bufobj **a_bop; 457a1c9f4adSAlan Somers daddr_t *a_bnp; 458a1c9f4adSAlan Somers int *a_runp; 459a1c9f4adSAlan Somers int *a_runb; 460a1c9f4adSAlan Somers } */ 461a1c9f4adSAlan Somers static int 462a1c9f4adSAlan Somers fuse_vnop_bmap(struct vop_bmap_args *ap) 463a1c9f4adSAlan Somers { 464a1c9f4adSAlan Somers struct vnode *vp = ap->a_vp; 465a1c9f4adSAlan Somers struct bufobj **bo = ap->a_bop; 466a1c9f4adSAlan Somers struct thread *td = curthread; 467a1c9f4adSAlan Somers struct mount *mp; 468a1c9f4adSAlan Somers struct fuse_dispatcher fdi; 469a1c9f4adSAlan Somers struct fuse_bmap_in *fbi; 470a1c9f4adSAlan Somers struct fuse_bmap_out *fbo; 471a1c9f4adSAlan Somers struct fuse_data *data; 472a1c9f4adSAlan Somers uint64_t biosize; 473a1c9f4adSAlan Somers off_t filesize; 474a1c9f4adSAlan Somers daddr_t lbn = ap->a_bn; 475a1c9f4adSAlan Somers daddr_t *pbn = ap->a_bnp; 476a1c9f4adSAlan Somers int *runp = ap->a_runp; 477a1c9f4adSAlan Somers int *runb = ap->a_runb; 478a1c9f4adSAlan Somers int error = 0; 479a1c9f4adSAlan Somers int maxrun; 480a1c9f4adSAlan Somers 481a1c9f4adSAlan Somers if (fuse_isdeadfs(vp)) { 482a1c9f4adSAlan Somers return ENXIO; 483a1c9f4adSAlan Somers } 484a1c9f4adSAlan Somers 485a1c9f4adSAlan Somers mp = vnode_mount(vp); 486a1c9f4adSAlan Somers data = fuse_get_mpdata(mp); 487a1c9f4adSAlan Somers biosize = fuse_iosize(vp); 488a1c9f4adSAlan Somers maxrun = MIN(vp->v_mount->mnt_iosize_max / biosize - 1, 489a1c9f4adSAlan Somers data->max_readahead_blocks); 490a1c9f4adSAlan Somers 491a1c9f4adSAlan Somers if (bo != NULL) 492a1c9f4adSAlan Somers *bo = &vp->v_bufobj; 493a1c9f4adSAlan Somers 494a1c9f4adSAlan Somers /* 495a1c9f4adSAlan Somers * The FUSE_BMAP operation does not include the runp and runb 496a1c9f4adSAlan Somers * variables, so we must guess. Report nonzero contiguous runs so 497a1c9f4adSAlan Somers * cluster_read will combine adjacent reads. It's worthwhile to reduce 498a1c9f4adSAlan Somers * upcalls even if we don't know the true physical layout of the file. 499a1c9f4adSAlan Somers * 500a1c9f4adSAlan Somers * FUSE file systems may opt out of read clustering in two ways: 501a1c9f4adSAlan Somers * * mounting with -onoclusterr 502a1c9f4adSAlan Somers * * Setting max_readahead <= maxbcachebuf during FUSE_INIT 503a1c9f4adSAlan Somers */ 504a1c9f4adSAlan Somers if (runb != NULL) 505a1c9f4adSAlan Somers *runb = MIN(lbn, maxrun); 506a1c9f4adSAlan Somers if (runp != NULL) { 507a1c9f4adSAlan Somers error = fuse_vnode_size(vp, &filesize, td->td_ucred, td); 508a1c9f4adSAlan Somers if (error == 0) 50916f87834SAlan Somers *runp = MIN(MAX(0, filesize / (off_t)biosize - lbn - 1), 510a1c9f4adSAlan Somers maxrun); 511a1c9f4adSAlan Somers else 512a1c9f4adSAlan Somers *runp = 0; 513a1c9f4adSAlan Somers } 514a1c9f4adSAlan Somers 515a1c9f4adSAlan Somers if (fsess_isimpl(mp, FUSE_BMAP)) { 516a1c9f4adSAlan Somers fdisp_init(&fdi, sizeof(*fbi)); 517a1c9f4adSAlan Somers fdisp_make_vp(&fdi, FUSE_BMAP, vp, td, td->td_ucred); 518a1c9f4adSAlan Somers fbi = fdi.indata; 519a1c9f4adSAlan Somers fbi->block = lbn; 520a1c9f4adSAlan Somers fbi->blocksize = biosize; 521a1c9f4adSAlan Somers error = fdisp_wait_answ(&fdi); 522a1c9f4adSAlan Somers if (error == ENOSYS) { 523caeea8b4SAlan Somers fdisp_destroy(&fdi); 524a1c9f4adSAlan Somers fsess_set_notimpl(mp, FUSE_BMAP); 525a1c9f4adSAlan Somers error = 0; 526a1c9f4adSAlan Somers } else { 527a1c9f4adSAlan Somers fbo = fdi.answ; 528a1c9f4adSAlan Somers if (error == 0 && pbn != NULL) 529a1c9f4adSAlan Somers *pbn = fbo->block; 530caeea8b4SAlan Somers fdisp_destroy(&fdi); 531a1c9f4adSAlan Somers return error; 532a1c9f4adSAlan Somers } 533a1c9f4adSAlan Somers } 534a1c9f4adSAlan Somers 535a1c9f4adSAlan Somers /* If the daemon doesn't support BMAP, make up a sensible default */ 536a1c9f4adSAlan Somers if (pbn != NULL) 537a1c9f4adSAlan Somers *pbn = lbn * btodb(biosize); 538a1c9f4adSAlan Somers return (error); 539a1c9f4adSAlan Somers } 540a1c9f4adSAlan Somers 541f067b609SAlan Somers /* 5429f10f423SAlan Somers struct vop_close_args { 5435fe58019SAttilio Rao struct vnode *a_vp; 5445fe58019SAttilio Rao int a_fflag; 5455fe58019SAttilio Rao struct ucred *a_cred; 5465fe58019SAttilio Rao struct thread *a_td; 5475fe58019SAttilio Rao }; 5485fe58019SAttilio Rao */ 5495fe58019SAttilio Rao static int 5505fe58019SAttilio Rao fuse_vnop_close(struct vop_close_args *ap) 5515fe58019SAttilio Rao { 5525fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 5535fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 5545fe58019SAttilio Rao int fflag = ap->a_fflag; 555f8d4af10SAlan Somers struct thread *td = ap->a_td; 556f8d4af10SAlan Somers pid_t pid = td->td_proc->p_pid; 5579f10f423SAlan Somers int err = 0; 5585fe58019SAttilio Rao 55935cf0e7eSAlan Somers if (fuse_isdeadfs(vp)) 5605fe58019SAttilio Rao return 0; 56135cf0e7eSAlan Somers if (vnode_isdir(vp)) 56235cf0e7eSAlan Somers return 0; 56335cf0e7eSAlan Somers if (fflag & IO_NDELAY) 56435cf0e7eSAlan Somers return 0; 5655ec10aa5SAlan Somers 5669f10f423SAlan Somers err = fuse_flush(vp, cred, pid, fflag); 5675ec10aa5SAlan Somers /* TODO: close the file handle, if we're sure it's no longer used */ 5685fe58019SAttilio Rao if ((VTOFUD(vp)->flag & FN_SIZECHANGE) != 0) { 569f8d4af10SAlan Somers fuse_vnode_savesize(vp, cred, td->td_proc->p_pid); 5705fe58019SAttilio Rao } 5719f10f423SAlan Somers return err; 5725fe58019SAttilio Rao } 5735fe58019SAttilio Rao 57419ef317dSAlan Somers static void 57519ef317dSAlan Somers fdisp_make_mknod_for_fallback( 57619ef317dSAlan Somers struct fuse_dispatcher *fdip, 57719ef317dSAlan Somers struct componentname *cnp, 57819ef317dSAlan Somers struct vnode *dvp, 57919ef317dSAlan Somers uint64_t parentnid, 58019ef317dSAlan Somers struct thread *td, 58119ef317dSAlan Somers struct ucred *cred, 58219ef317dSAlan Somers mode_t mode, 58319ef317dSAlan Somers enum fuse_opcode *op) 58419ef317dSAlan Somers { 58519ef317dSAlan Somers struct fuse_mknod_in *fmni; 58619ef317dSAlan Somers 58719ef317dSAlan Somers fdisp_init(fdip, sizeof(*fmni) + cnp->cn_namelen + 1); 58819ef317dSAlan Somers *op = FUSE_MKNOD; 58919ef317dSAlan Somers fdisp_make(fdip, *op, vnode_mount(dvp), parentnid, td, cred); 59019ef317dSAlan Somers fmni = fdip->indata; 59119ef317dSAlan Somers fmni->mode = mode; 59219ef317dSAlan Somers fmni->rdev = 0; 59319ef317dSAlan Somers memcpy((char *)fdip->indata + sizeof(*fmni), cnp->cn_nameptr, 59419ef317dSAlan Somers cnp->cn_namelen); 59519ef317dSAlan Somers ((char *)fdip->indata)[sizeof(*fmni) + cnp->cn_namelen] = '\0'; 59619ef317dSAlan Somers } 5975fe58019SAttilio Rao /* 5985fe58019SAttilio Rao struct vnop_create_args { 5995fe58019SAttilio Rao struct vnode *a_dvp; 6005fe58019SAttilio Rao struct vnode **a_vpp; 6015fe58019SAttilio Rao struct componentname *a_cnp; 6025fe58019SAttilio Rao struct vattr *a_vap; 6035fe58019SAttilio Rao }; 6045fe58019SAttilio Rao */ 6055fe58019SAttilio Rao static int 6065fe58019SAttilio Rao fuse_vnop_create(struct vop_create_args *ap) 6075fe58019SAttilio Rao { 6085fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 6095fe58019SAttilio Rao struct vnode **vpp = ap->a_vpp; 6105fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 6115fe58019SAttilio Rao struct vattr *vap = ap->a_vap; 6125fe58019SAttilio Rao struct thread *td = cnp->cn_thread; 6135fe58019SAttilio Rao struct ucred *cred = cnp->cn_cred; 6145fe58019SAttilio Rao 615a4856c96SAlan Somers struct fuse_data *data; 616a4856c96SAlan Somers struct fuse_create_in *fci; 6175fe58019SAttilio Rao struct fuse_entry_out *feo; 61819ef317dSAlan Somers struct fuse_open_out *foo; 61919ef317dSAlan Somers struct fuse_dispatcher fdi, fdi2; 6205fe58019SAttilio Rao struct fuse_dispatcher *fdip = &fdi; 62119ef317dSAlan Somers struct fuse_dispatcher *fdip2 = NULL; 6225fe58019SAttilio Rao 6235fe58019SAttilio Rao int err; 6245fe58019SAttilio Rao 6255fe58019SAttilio Rao struct mount *mp = vnode_mount(dvp); 626a4856c96SAlan Somers data = fuse_get_mpdata(mp); 6275fe58019SAttilio Rao uint64_t parentnid = VTOFUD(dvp)->nid; 6285fe58019SAttilio Rao mode_t mode = MAKEIMODE(vap->va_type, vap->va_mode); 62919ef317dSAlan Somers enum fuse_opcode op; 6309e444871SAlan Somers int flags; 6319e444871SAlan Somers 632d5ff2688SAlan Somers if (fuse_isdeadfs(dvp)) 633d5ff2688SAlan Somers return ENXIO; 634d5ff2688SAlan Somers 635d5ff2688SAlan Somers /* FUSE expects sockets to be created with FUSE_MKNOD */ 636d5ff2688SAlan Somers if (vap->va_type == VSOCK) 637d5ff2688SAlan Somers return fuse_internal_mknod(dvp, vpp, cnp, vap); 638d5ff2688SAlan Somers 6399e444871SAlan Somers /* 6409e444871SAlan Somers * VOP_CREATE doesn't tell us the open(2) flags, so we guess. Only a 6419e444871SAlan Somers * writable mode makes sense, and we might as well include readability 6429e444871SAlan Somers * too. 6439e444871SAlan Somers */ 6449e444871SAlan Somers flags = O_RDWR; 6455fe58019SAttilio Rao 6465fe58019SAttilio Rao bzero(&fdi, sizeof(fdi)); 6475fe58019SAttilio Rao 648d5ff2688SAlan Somers if (vap->va_type != VREG) 649372b97d0SRick Macklem return (EINVAL); 6505fe58019SAttilio Rao 651d5ff2688SAlan Somers if (!fsess_isimpl(mp, FUSE_CREATE) || vap->va_type == VSOCK) { 65219ef317dSAlan Somers /* Fallback to FUSE_MKNOD/FUSE_OPEN */ 65319ef317dSAlan Somers fdisp_make_mknod_for_fallback(fdip, cnp, dvp, parentnid, td, 65419ef317dSAlan Somers cred, mode, &op); 65519ef317dSAlan Somers } else { 65619ef317dSAlan Somers /* Use FUSE_CREATE */ 657a4856c96SAlan Somers size_t insize; 658a4856c96SAlan Somers 65919ef317dSAlan Somers op = FUSE_CREATE; 660a4856c96SAlan Somers fdisp_init(fdip, sizeof(*fci) + cnp->cn_namelen + 1); 66119ef317dSAlan Somers fdisp_make(fdip, op, vnode_mount(dvp), parentnid, td, cred); 662a4856c96SAlan Somers fci = fdip->indata; 663a4856c96SAlan Somers fci->mode = mode; 664a4856c96SAlan Somers fci->flags = O_CREAT | flags; 665a4856c96SAlan Somers if (fuse_libabi_geq(data, 7, 12)) { 666a4856c96SAlan Somers insize = sizeof(*fci); 667a4856c96SAlan Somers fci->umask = td->td_proc->p_fd->fd_cmask; 668a4856c96SAlan Somers } else { 669a4856c96SAlan Somers insize = sizeof(struct fuse_open_in); 670a4856c96SAlan Somers } 671a4856c96SAlan Somers 672a4856c96SAlan Somers memcpy((char *)fdip->indata + insize, cnp->cn_nameptr, 6735fe58019SAttilio Rao cnp->cn_namelen); 674a4856c96SAlan Somers ((char *)fdip->indata)[insize + cnp->cn_namelen] = '\0'; 67519ef317dSAlan Somers } 6765fe58019SAttilio Rao 6775fe58019SAttilio Rao err = fdisp_wait_answ(fdip); 6785fe58019SAttilio Rao 6796de3b00dSAttilio Rao if (err) { 68019ef317dSAlan Somers if (err == ENOSYS && op == FUSE_CREATE) { 6815fe58019SAttilio Rao fsess_set_notimpl(mp, FUSE_CREATE); 682caeea8b4SAlan Somers fdisp_destroy(fdip); 68319ef317dSAlan Somers fdisp_make_mknod_for_fallback(fdip, cnp, dvp, 68419ef317dSAlan Somers parentnid, td, cred, mode, &op); 68519ef317dSAlan Somers err = fdisp_wait_answ(fdip); 68619ef317dSAlan Somers } 68719ef317dSAlan Somers if (err) 6885fe58019SAttilio Rao goto out; 6895fe58019SAttilio Rao } 690372b97d0SRick Macklem 6915fe58019SAttilio Rao feo = fdip->answ; 6925fe58019SAttilio Rao 693ede571e4SAlan Somers if ((err = fuse_internal_checkentry(feo, vap->va_type))) { 6945fe58019SAttilio Rao goto out; 6955fe58019SAttilio Rao } 69619ef317dSAlan Somers 69719ef317dSAlan Somers if (op == FUSE_CREATE) { 69819ef317dSAlan Somers foo = (struct fuse_open_out*)(feo + 1); 69919ef317dSAlan Somers } else { 70019ef317dSAlan Somers /* Issue a separate FUSE_OPEN */ 701a4856c96SAlan Somers struct fuse_open_in *foi; 702a4856c96SAlan Somers 70319ef317dSAlan Somers fdip2 = &fdi2; 70419ef317dSAlan Somers fdisp_init(fdip2, sizeof(*foi)); 70519ef317dSAlan Somers fdisp_make(fdip2, FUSE_OPEN, vnode_mount(dvp), feo->nodeid, td, 70619ef317dSAlan Somers cred); 70719ef317dSAlan Somers foi = fdip2->indata; 7089e444871SAlan Somers foi->flags = flags; 70919ef317dSAlan Somers err = fdisp_wait_answ(fdip2); 71019ef317dSAlan Somers if (err) 71119ef317dSAlan Somers goto out; 71219ef317dSAlan Somers foo = fdip2->answ; 71319ef317dSAlan Somers } 714ede571e4SAlan Somers err = fuse_vnode_get(mp, feo, feo->nodeid, dvp, vpp, cnp, vap->va_type); 7155fe58019SAttilio Rao if (err) { 7165fe58019SAttilio Rao struct fuse_release_in *fri; 7175fe58019SAttilio Rao uint64_t nodeid = feo->nodeid; 71819ef317dSAlan Somers uint64_t fh_id = foo->fh; 7195fe58019SAttilio Rao 7205fe58019SAttilio Rao fdisp_init(fdip, sizeof(*fri)); 7215fe58019SAttilio Rao fdisp_make(fdip, FUSE_RELEASE, mp, nodeid, td, cred); 7225fe58019SAttilio Rao fri = fdip->indata; 7235fe58019SAttilio Rao fri->fh = fh_id; 7249e444871SAlan Somers fri->flags = flags; 7255fe58019SAttilio Rao fuse_insert_callback(fdip->tick, fuse_internal_forget_callback); 726268c28edSAlan Somers fuse_insert_message(fdip->tick, false); 72719ef317dSAlan Somers goto out; 7285fe58019SAttilio Rao } 7295fe58019SAttilio Rao ASSERT_VOP_ELOCKED(*vpp, "fuse_vnop_create"); 7300269ae4cSAlan Somers fuse_internal_cache_attrs(*vpp, &feo->attr, feo->attr_valid, 731cad67791SAlan Somers feo->attr_valid_nsec, NULL); 7325fe58019SAttilio Rao 733a7e81cb3SAlan Somers fuse_filehandle_init(*vpp, FUFH_RDWR, NULL, td, cred, foo); 73419ef317dSAlan Somers fuse_vnode_open(*vpp, foo->open_flags, td); 735002e54b0SAlan Somers /* 736002e54b0SAlan Somers * Purge the parent's attribute cache because the daemon should've 737002e54b0SAlan Somers * updated its mtime and ctime 738002e54b0SAlan Somers */ 739002e54b0SAlan Somers fuse_vnode_clear_attr_cache(dvp); 7405fe58019SAttilio Rao cache_purge_negative(dvp); 7415fe58019SAttilio Rao 7425fe58019SAttilio Rao out: 74319ef317dSAlan Somers if (fdip2) 74419ef317dSAlan Somers fdisp_destroy(fdip2); 7455fe58019SAttilio Rao fdisp_destroy(fdip); 7465fe58019SAttilio Rao return err; 7475fe58019SAttilio Rao } 7485fe58019SAttilio Rao 7495fe58019SAttilio Rao /* 750915012e0SAlan Somers struct vnop_fdatasync_args { 751915012e0SAlan Somers struct vop_generic_args a_gen; 752915012e0SAlan Somers struct vnode * a_vp; 753915012e0SAlan Somers struct thread * a_td; 754915012e0SAlan Somers }; 7555fe58019SAttilio Rao */ 756915012e0SAlan Somers static int 757915012e0SAlan Somers fuse_vnop_fdatasync(struct vop_fdatasync_args *ap) 758915012e0SAlan Somers { 759915012e0SAlan Somers struct vnode *vp = ap->a_vp; 760915012e0SAlan Somers struct thread *td = ap->a_td; 761915012e0SAlan Somers int waitfor = MNT_WAIT; 762915012e0SAlan Somers 763915012e0SAlan Somers int err = 0; 764915012e0SAlan Somers 765915012e0SAlan Somers if (fuse_isdeadfs(vp)) { 766915012e0SAlan Somers return 0; 767915012e0SAlan Somers } 768915012e0SAlan Somers if ((err = vop_stdfdatasync_buf(ap))) 769915012e0SAlan Somers return err; 770915012e0SAlan Somers 771915012e0SAlan Somers return fuse_internal_fsync(vp, td, waitfor, true); 772915012e0SAlan Somers } 7735fe58019SAttilio Rao 7745fe58019SAttilio Rao /* 7755fe58019SAttilio Rao struct vnop_fsync_args { 776915012e0SAlan Somers struct vop_generic_args a_gen; 7775fe58019SAttilio Rao struct vnode * a_vp; 7785fe58019SAttilio Rao int a_waitfor; 7795fe58019SAttilio Rao struct thread * a_td; 7805fe58019SAttilio Rao }; 7815fe58019SAttilio Rao */ 7825fe58019SAttilio Rao static int 7835fe58019SAttilio Rao fuse_vnop_fsync(struct vop_fsync_args *ap) 7845fe58019SAttilio Rao { 7855fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 7865fe58019SAttilio Rao struct thread *td = ap->a_td; 78790612f3cSAlan Somers int waitfor = ap->a_waitfor; 788915012e0SAlan Somers int err = 0; 7895fe58019SAttilio Rao 7905fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 7915fe58019SAttilio Rao return 0; 7925fe58019SAttilio Rao } 7935fe58019SAttilio Rao if ((err = vop_stdfsync(ap))) 7945fe58019SAttilio Rao return err; 7955fe58019SAttilio Rao 796915012e0SAlan Somers return fuse_internal_fsync(vp, td, waitfor, false); 7975fe58019SAttilio Rao } 7985fe58019SAttilio Rao 7995fe58019SAttilio Rao /* 8005fe58019SAttilio Rao struct vnop_getattr_args { 8015fe58019SAttilio Rao struct vnode *a_vp; 8025fe58019SAttilio Rao struct vattr *a_vap; 8035fe58019SAttilio Rao struct ucred *a_cred; 8045fe58019SAttilio Rao struct thread *a_td; 8055fe58019SAttilio Rao }; 8065fe58019SAttilio Rao */ 8075fe58019SAttilio Rao static int 8085fe58019SAttilio Rao fuse_vnop_getattr(struct vop_getattr_args *ap) 8095fe58019SAttilio Rao { 8105fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 8115fe58019SAttilio Rao struct vattr *vap = ap->a_vap; 8125fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 8135fe58019SAttilio Rao struct thread *td = curthread; 8145fe58019SAttilio Rao 8155fe58019SAttilio Rao int err = 0; 8165fe58019SAttilio Rao int dataflags; 8175fe58019SAttilio Rao 8185fe58019SAttilio Rao dataflags = fuse_get_mpdata(vnode_mount(vp))->dataflags; 8195fe58019SAttilio Rao 8205fe58019SAttilio Rao /* Note that we are not bailing out on a dead file system just yet. */ 8215fe58019SAttilio Rao 8225fe58019SAttilio Rao if (!(dataflags & FSESS_INITED)) { 8235fe58019SAttilio Rao if (!vnode_isvroot(vp)) { 8245fe58019SAttilio Rao fdata_set_dead(fuse_get_mpdata(vnode_mount(vp))); 8255fe58019SAttilio Rao err = ENOTCONN; 8265fe58019SAttilio Rao return err; 8275fe58019SAttilio Rao } else { 8285fe58019SAttilio Rao goto fake; 8295fe58019SAttilio Rao } 8305fe58019SAttilio Rao } 831cad67791SAlan Somers err = fuse_internal_getattr(vp, vap, cred, td); 832cad67791SAlan Somers if (err == ENOTCONN && vnode_isvroot(vp)) { 833cf169498SAlan Somers /* see comment in fuse_vfsop_statfs() */ 8345fe58019SAttilio Rao goto fake; 835cad67791SAlan Somers } else { 8365fe58019SAttilio Rao return err; 837cad67791SAlan Somers } 8385fe58019SAttilio Rao 8395fe58019SAttilio Rao fake: 8405fe58019SAttilio Rao bzero(vap, sizeof(*vap)); 8415fe58019SAttilio Rao vap->va_type = vnode_vtype(vp); 8425fe58019SAttilio Rao 8435fe58019SAttilio Rao return 0; 8445fe58019SAttilio Rao } 8455fe58019SAttilio Rao 8465fe58019SAttilio Rao /* 8475fe58019SAttilio Rao struct vnop_inactive_args { 8485fe58019SAttilio Rao struct vnode *a_vp; 8495fe58019SAttilio Rao struct thread *a_td; 8505fe58019SAttilio Rao }; 8515fe58019SAttilio Rao */ 8525fe58019SAttilio Rao static int 8535fe58019SAttilio Rao fuse_vnop_inactive(struct vop_inactive_args *ap) 8545fe58019SAttilio Rao { 8555fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 8565fe58019SAttilio Rao struct thread *td = ap->a_td; 8575fe58019SAttilio Rao 8585fe58019SAttilio Rao struct fuse_vnode_data *fvdat = VTOFUD(vp); 8595ec10aa5SAlan Somers struct fuse_filehandle *fufh, *fufh_tmp; 8605fe58019SAttilio Rao 8615ec10aa5SAlan Somers int need_flush = 1; 8625fe58019SAttilio Rao 8635ec10aa5SAlan Somers LIST_FOREACH_SAFE(fufh, &fvdat->handles, next, fufh_tmp) { 8645fe58019SAttilio Rao if (need_flush && vp->v_type == VREG) { 8655fe58019SAttilio Rao if ((VTOFUD(vp)->flag & FN_SIZECHANGE) != 0) { 866f8d4af10SAlan Somers fuse_vnode_savesize(vp, NULL, 0); 8675fe58019SAttilio Rao } 8685940f822SAlan Somers if ((fvdat->flag & FN_REVOKED) != 0) 8695fe58019SAttilio Rao fuse_io_invalbuf(vp, td); 8705fe58019SAttilio Rao else 8715fe58019SAttilio Rao fuse_io_flushbuf(vp, MNT_WAIT, td); 8725fe58019SAttilio Rao need_flush = 0; 8735fe58019SAttilio Rao } 8745ec10aa5SAlan Somers fuse_filehandle_close(vp, fufh, td, NULL); 8755fe58019SAttilio Rao } 8765fe58019SAttilio Rao 877435ecf40SAlan Somers if ((fvdat->flag & FN_REVOKED) != 0) 8785fe58019SAttilio Rao vrecycle(vp); 879435ecf40SAlan Somers 8805fe58019SAttilio Rao return 0; 8815fe58019SAttilio Rao } 8825fe58019SAttilio Rao 8835fe58019SAttilio Rao /* 8845fe58019SAttilio Rao struct vnop_link_args { 8855fe58019SAttilio Rao struct vnode *a_tdvp; 8865fe58019SAttilio Rao struct vnode *a_vp; 8875fe58019SAttilio Rao struct componentname *a_cnp; 8885fe58019SAttilio Rao }; 8895fe58019SAttilio Rao */ 8905fe58019SAttilio Rao static int 8915fe58019SAttilio Rao fuse_vnop_link(struct vop_link_args *ap) 8925fe58019SAttilio Rao { 8935fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 8945fe58019SAttilio Rao struct vnode *tdvp = ap->a_tdvp; 8955fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 8965fe58019SAttilio Rao 8975fe58019SAttilio Rao struct vattr *vap = VTOVA(vp); 8985fe58019SAttilio Rao 8995fe58019SAttilio Rao struct fuse_dispatcher fdi; 9005fe58019SAttilio Rao struct fuse_entry_out *feo; 9015fe58019SAttilio Rao struct fuse_link_in fli; 9025fe58019SAttilio Rao 9035fe58019SAttilio Rao int err; 9045fe58019SAttilio Rao 9055fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 9065fe58019SAttilio Rao return ENXIO; 9075fe58019SAttilio Rao } 9085fe58019SAttilio Rao if (vnode_mount(tdvp) != vnode_mount(vp)) { 9095fe58019SAttilio Rao return EXDEV; 9105fe58019SAttilio Rao } 91178a7722fSConrad Meyer 91278a7722fSConrad Meyer /* 91378a7722fSConrad Meyer * This is a seatbelt check to protect naive userspace filesystems from 91478a7722fSConrad Meyer * themselves and the limitations of the FUSE IPC protocol. If a 91578a7722fSConrad Meyer * filesystem does not allow attribute caching, assume it is capable of 91678a7722fSConrad Meyer * validating that nlink does not overflow. 91778a7722fSConrad Meyer */ 91878a7722fSConrad Meyer if (vap != NULL && vap->va_nlink >= FUSE_LINK_MAX) 9195fe58019SAttilio Rao return EMLINK; 9205fe58019SAttilio Rao fli.oldnodeid = VTOI(vp); 9215fe58019SAttilio Rao 9225fe58019SAttilio Rao fdisp_init(&fdi, 0); 9235fe58019SAttilio Rao fuse_internal_newentry_makerequest(vnode_mount(tdvp), VTOI(tdvp), cnp, 9245fe58019SAttilio Rao FUSE_LINK, &fli, sizeof(fli), &fdi); 9255fe58019SAttilio Rao if ((err = fdisp_wait_answ(&fdi))) { 9265fe58019SAttilio Rao goto out; 9275fe58019SAttilio Rao } 9285fe58019SAttilio Rao feo = fdi.answ; 9295fe58019SAttilio Rao 9305fe58019SAttilio Rao err = fuse_internal_checkentry(feo, vnode_vtype(vp)); 931002e54b0SAlan Somers if (!err) { 932002e54b0SAlan Somers /* 933002e54b0SAlan Somers * Purge the parent's attribute cache because the daemon 934002e54b0SAlan Somers * should've updated its mtime and ctime 935002e54b0SAlan Somers */ 936002e54b0SAlan Somers fuse_vnode_clear_attr_cache(tdvp); 9370269ae4cSAlan Somers fuse_internal_cache_attrs(vp, &feo->attr, feo->attr_valid, 9384ae3a56cSAlan Somers feo->attr_valid_nsec, NULL); 939002e54b0SAlan Somers } 9405fe58019SAttilio Rao out: 9415fe58019SAttilio Rao fdisp_destroy(&fdi); 9425fe58019SAttilio Rao return err; 9435fe58019SAttilio Rao } 9445fe58019SAttilio Rao 945dc14d593SAlan Somers struct fuse_lookup_alloc_arg { 946dc14d593SAlan Somers struct fuse_entry_out *feo; 947dc14d593SAlan Somers struct componentname *cnp; 948dc14d593SAlan Somers uint64_t nid; 949dc14d593SAlan Somers enum vtype vtyp; 950dc14d593SAlan Somers }; 951dc14d593SAlan Somers 952dc14d593SAlan Somers /* Callback for vn_get_ino */ 953dc14d593SAlan Somers static int 954dc14d593SAlan Somers fuse_lookup_alloc(struct mount *mp, void *arg, int lkflags, struct vnode **vpp) 955dc14d593SAlan Somers { 956dc14d593SAlan Somers struct fuse_lookup_alloc_arg *flaa = arg; 957dc14d593SAlan Somers 958dc14d593SAlan Somers return fuse_vnode_get(mp, flaa->feo, flaa->nid, NULL, vpp, flaa->cnp, 959dc14d593SAlan Somers flaa->vtyp); 960dc14d593SAlan Somers } 961dc14d593SAlan Somers 962419e7ff6SAlan Somers SDT_PROBE_DEFINE3(fusefs, , vnops, cache_lookup, 963ccb75e49SAlan Somers "int", "struct timespec*", "struct timespec*"); 9645fe58019SAttilio Rao /* 9655fe58019SAttilio Rao struct vnop_lookup_args { 9665fe58019SAttilio Rao struct vnodeop_desc *a_desc; 9675fe58019SAttilio Rao struct vnode *a_dvp; 9685fe58019SAttilio Rao struct vnode **a_vpp; 9695fe58019SAttilio Rao struct componentname *a_cnp; 9705fe58019SAttilio Rao }; 9715fe58019SAttilio Rao */ 9725fe58019SAttilio Rao int 9735fe58019SAttilio Rao fuse_vnop_lookup(struct vop_lookup_args *ap) 9745fe58019SAttilio Rao { 9755fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 9765fe58019SAttilio Rao struct vnode **vpp = ap->a_vpp; 9775fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 9785fe58019SAttilio Rao struct thread *td = cnp->cn_thread; 9795fe58019SAttilio Rao struct ucred *cred = cnp->cn_cred; 9805fe58019SAttilio Rao 9815fe58019SAttilio Rao int nameiop = cnp->cn_nameiop; 9825fe58019SAttilio Rao int flags = cnp->cn_flags; 9835fe58019SAttilio Rao int wantparent = flags & (LOCKPARENT | WANTPARENT); 9845fe58019SAttilio Rao int islastcn = flags & ISLASTCN; 9855fe58019SAttilio Rao struct mount *mp = vnode_mount(dvp); 9865fe58019SAttilio Rao 9875fe58019SAttilio Rao int err = 0; 9885fe58019SAttilio Rao int lookup_err = 0; 9895fe58019SAttilio Rao struct vnode *vp = NULL; 9905fe58019SAttilio Rao 9915fe58019SAttilio Rao struct fuse_dispatcher fdi; 992438b8a6fSAlan Somers bool did_lookup = false; 99344f10c6eSAlan Somers struct fuse_entry_out *feo = NULL; 994438b8a6fSAlan Somers enum vtype vtyp; /* vnode type of target */ 995438b8a6fSAlan Somers off_t filesize; /* filesize of target */ 9965fe58019SAttilio Rao 9975fe58019SAttilio Rao uint64_t nid; 9985fe58019SAttilio Rao 9995fe58019SAttilio Rao if (fuse_isdeadfs(dvp)) { 10005fe58019SAttilio Rao *vpp = NULL; 10015fe58019SAttilio Rao return ENXIO; 10025fe58019SAttilio Rao } 100373825da3SAlan Somers if (!vnode_isdir(dvp)) 10045fe58019SAttilio Rao return ENOTDIR; 10055fe58019SAttilio Rao 100673825da3SAlan Somers if (islastcn && vfs_isrdonly(mp) && (nameiop != LOOKUP)) 100773825da3SAlan Somers return EROFS; 100873825da3SAlan Somers 1009*6a5abb1eSKyle Evans if ((cnp->cn_flags & NOEXECCHECK) != 0) 1010*6a5abb1eSKyle Evans cnp->cn_flags &= ~NOEXECCHECK; 1011*6a5abb1eSKyle Evans else if ((err = fuse_internal_access(dvp, VEXEC, td, cred))) 10125fe58019SAttilio Rao return err; 101373825da3SAlan Somers 10145fe58019SAttilio Rao if (flags & ISDOTDOT) { 1015e5b50fe7SAlan Somers KASSERT(VTOFUD(dvp)->flag & FN_PARENT_NID, 1016e5b50fe7SAlan Somers ("Looking up .. is TODO")); 10175fe58019SAttilio Rao nid = VTOFUD(dvp)->parent_nid; 1018438b8a6fSAlan Somers if (nid == 0) 10195fe58019SAttilio Rao return ENOENT; 1020438b8a6fSAlan Somers /* .. is obviously a directory */ 1021438b8a6fSAlan Somers vtyp = VDIR; 1022438b8a6fSAlan Somers filesize = 0; 10235fe58019SAttilio Rao } else if (cnp->cn_namelen == 1 && *(cnp->cn_nameptr) == '.') { 10245fe58019SAttilio Rao nid = VTOI(dvp); 1025438b8a6fSAlan Somers /* . is obviously a directory */ 1026438b8a6fSAlan Somers vtyp = VDIR; 1027438b8a6fSAlan Somers filesize = 0; 1028ccb75e49SAlan Somers } else { 10293f2c630cSAlan Somers struct timespec now, timeout; 10303f2c630cSAlan Somers 10313f2c630cSAlan Somers err = cache_lookup(dvp, vpp, cnp, &timeout, NULL); 10323f2c630cSAlan Somers getnanouptime(&now); 1033419e7ff6SAlan Somers SDT_PROBE3(fusefs, , vnops, cache_lookup, err, &timeout, &now); 1034ccb75e49SAlan Somers switch (err) { 1035ccb75e49SAlan Somers case -1: /* positive match */ 1036ccb75e49SAlan Somers if (timespeccmp(&timeout, &now, >)) { 1037560a55d0SAlan Somers counter_u64_add(fuse_lookup_cache_hits, 1); 10383f2c630cSAlan Somers } else { 10393f2c630cSAlan Somers /* Cache timeout */ 1040560a55d0SAlan Somers counter_u64_add(fuse_lookup_cache_misses, 1); 10410d2bf489SAlan Somers bintime_clear( 10420d2bf489SAlan Somers &VTOFUD(*vpp)->entry_cache_timeout); 10434683b905SAlan Somers cache_purge(*vpp); 1044ccb75e49SAlan Somers if (dvp != *vpp) 1045ccb75e49SAlan Somers vput(*vpp); 1046ccb75e49SAlan Somers else 1047ccb75e49SAlan Somers vrele(*vpp); 1048ccb75e49SAlan Somers *vpp = NULL; 10493f2c630cSAlan Somers break; 10503f2c630cSAlan Somers } 10513f2c630cSAlan Somers return 0; 10523f2c630cSAlan Somers 10533f2c630cSAlan Somers case 0: /* no match in cache */ 1054560a55d0SAlan Somers counter_u64_add(fuse_lookup_cache_misses, 1); 10553f2c630cSAlan Somers break; 10563f2c630cSAlan Somers 10573f2c630cSAlan Somers case ENOENT: /* negative match */ 10583f2c630cSAlan Somers getnanouptime(&now); 1059ccb75e49SAlan Somers if (timespeccmp(&timeout, &now, <=)) { 10603f2c630cSAlan Somers /* Cache timeout */ 1061ccb75e49SAlan Somers cache_purge_negative(dvp); 10623f2c630cSAlan Somers break; 10633f2c630cSAlan Somers } 10643f2c630cSAlan Somers /* fall through */ 10653f2c630cSAlan Somers default: 10663f2c630cSAlan Somers return err; 10673f2c630cSAlan Somers } 1068438b8a6fSAlan Somers 10695fe58019SAttilio Rao nid = VTOI(dvp); 10705fe58019SAttilio Rao fdisp_init(&fdi, cnp->cn_namelen + 1); 1071438b8a6fSAlan Somers fdisp_make(&fdi, FUSE_LOOKUP, mp, nid, td, cred); 10725fe58019SAttilio Rao 10735fe58019SAttilio Rao memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen); 10745fe58019SAttilio Rao ((char *)fdi.indata)[cnp->cn_namelen] = '\0'; 10755fe58019SAttilio Rao lookup_err = fdisp_wait_answ(&fdi); 1076438b8a6fSAlan Somers did_lookup = true; 10775fe58019SAttilio Rao 1078438b8a6fSAlan Somers if (!lookup_err) { 1079ccb75e49SAlan Somers /* lookup call succeeded */ 1080438b8a6fSAlan Somers feo = (struct fuse_entry_out *)fdi.answ; 1081e5b50fe7SAlan Somers nid = feo->nodeid; 108244f10c6eSAlan Somers if (nid == 0) { 108344f10c6eSAlan Somers /* zero nodeid means ENOENT and cache it */ 108444f10c6eSAlan Somers struct timespec timeout; 108544f10c6eSAlan Somers 10866248288eSAlan Somers fdi.answ_stat = ENOENT; 10875fe58019SAttilio Rao lookup_err = ENOENT; 108844f10c6eSAlan Somers if (cnp->cn_flags & MAKEENTRY) { 108944f10c6eSAlan Somers fuse_validity_2_timespec(feo, &timeout); 1090438b8a6fSAlan Somers cache_enter_time(dvp, *vpp, cnp, 1091438b8a6fSAlan Somers &timeout, NULL); 109244f10c6eSAlan Somers } 10935fe58019SAttilio Rao } else if (nid == FUSE_ROOT_ID) { 10945fe58019SAttilio Rao lookup_err = EINVAL; 10955fe58019SAttilio Rao } 1096438b8a6fSAlan Somers vtyp = IFTOVT(feo->attr.mode); 1097438b8a6fSAlan Somers filesize = feo->attr.size; 10985fe58019SAttilio Rao } 1099438b8a6fSAlan Somers if (lookup_err && (!fdi.answ_stat || lookup_err != ENOENT)) { 11005fe58019SAttilio Rao fdisp_destroy(&fdi); 11015fe58019SAttilio Rao return lookup_err; 11025fe58019SAttilio Rao } 1103438b8a6fSAlan Somers } 11045fe58019SAttilio Rao /* lookup_err, if non-zero, must be ENOENT at this point */ 11055fe58019SAttilio Rao 11065fe58019SAttilio Rao if (lookup_err) { 1107ff4fbdf5SAlan Somers /* Entry not found */ 1108ff4fbdf5SAlan Somers if ((nameiop == CREATE || nameiop == RENAME) && islastcn) { 1109666f8543SAlan Somers err = fuse_internal_access(dvp, VWRITE, td, cred); 11106124fd71SAlan Somers if (!err) { 11115fe58019SAttilio Rao /* 1112dc14d593SAlan Somers * Set the SAVENAME flag to hold onto the 11136124fd71SAlan Somers * pathname for use later in VOP_CREATE or 11146124fd71SAlan Somers * VOP_RENAME. 11155fe58019SAttilio Rao */ 11165fe58019SAttilio Rao cnp->cn_flags |= SAVENAME; 11175fe58019SAttilio Rao 11185fe58019SAttilio Rao err = EJUSTRETURN; 11195fe58019SAttilio Rao } 11206124fd71SAlan Somers } else { 11215fe58019SAttilio Rao err = ENOENT; 11226124fd71SAlan Somers } 11235fe58019SAttilio Rao } else { 1124ff4fbdf5SAlan Somers /* Entry was found */ 11255fe58019SAttilio Rao if (flags & ISDOTDOT) { 1126dc14d593SAlan Somers struct fuse_lookup_alloc_arg flaa; 11275fe58019SAttilio Rao 1128dc14d593SAlan Somers flaa.nid = nid; 1129dc14d593SAlan Somers flaa.feo = feo; 1130dc14d593SAlan Somers flaa.cnp = cnp; 1131dc14d593SAlan Somers flaa.vtyp = vtyp; 1132dc14d593SAlan Somers err = vn_vget_ino_gen(dvp, fuse_lookup_alloc, &flaa, 0, 1133dc14d593SAlan Somers &vp); 11345fe58019SAttilio Rao *vpp = vp; 11355fe58019SAttilio Rao } else if (nid == VTOI(dvp)) { 11365fe58019SAttilio Rao vref(dvp); 11375fe58019SAttilio Rao *vpp = dvp; 11385fe58019SAttilio Rao } else { 11393c324b94SConrad Meyer struct fuse_vnode_data *fvdat; 11403c324b94SConrad Meyer 114109176f09SConrad Meyer err = fuse_vnode_get(vnode_mount(dvp), feo, nid, dvp, 1142438b8a6fSAlan Somers &vp, cnp, vtyp); 11436124fd71SAlan Somers if (err) 11445fe58019SAttilio Rao goto out; 11456124fd71SAlan Somers *vpp = vp; 11466124fd71SAlan Somers 11473c324b94SConrad Meyer /* 11483c324b94SConrad Meyer * In the case where we are looking up a FUSE node 11493c324b94SConrad Meyer * represented by an existing cached vnode, and the 11503c324b94SConrad Meyer * true size reported by FUSE_LOOKUP doesn't match 11512013b723SAlan Somers * the vnode's cached size, then any cached writes 11522013b723SAlan Somers * beyond the file's current size are lost. 11533c324b94SConrad Meyer * 11546124fd71SAlan Somers * We can get here: 11556124fd71SAlan Somers * * following attribute cache expiration, or 11566124fd71SAlan Somers * * due a bug in the daemon, or 11573c324b94SConrad Meyer */ 11583c324b94SConrad Meyer fvdat = VTOFUD(vp); 11593c324b94SConrad Meyer if (vnode_isreg(vp) && 11602013b723SAlan Somers filesize != fvdat->cached_attrs.va_size && 11612013b723SAlan Somers fvdat->flag & FN_SIZECHANGE) { 11623c324b94SConrad Meyer /* 11633c324b94SConrad Meyer * The FN_SIZECHANGE flag reflects a dirty 11643c324b94SConrad Meyer * append. If userspace lets us know our cache 11653c324b94SConrad Meyer * is invalid, that write was lost. (Dirty 11663c324b94SConrad Meyer * writes that do not cause append are also 11673c324b94SConrad Meyer * lost, but we don't detect them here.) 11683c324b94SConrad Meyer * 11693c324b94SConrad Meyer * XXX: Maybe disable WB caching on this mount. 11703c324b94SConrad Meyer */ 11712013b723SAlan Somers printf("%s: WB cache incoherent on %s!\n", 11722013b723SAlan Somers __func__, 11733c324b94SConrad Meyer vnode_mount(vp)->mnt_stat.f_mntonname); 11743c324b94SConrad Meyer 11753c324b94SConrad Meyer fvdat->flag &= ~FN_SIZECHANGE; 11763c324b94SConrad Meyer } 11775fe58019SAttilio Rao 11786124fd71SAlan Somers MPASS(feo != NULL); 11790269ae4cSAlan Somers fuse_internal_cache_attrs(*vpp, &feo->attr, 1180438b8a6fSAlan Somers feo->attr_valid, feo->attr_valid_nsec, NULL); 11810d2bf489SAlan Somers fuse_validity_2_bintime(feo->entry_valid, 11820d2bf489SAlan Somers feo->entry_valid_nsec, 11830d2bf489SAlan Somers &fvdat->entry_cache_timeout); 11846124fd71SAlan Somers 11856124fd71SAlan Somers if ((nameiop == DELETE || nameiop == RENAME) && 11866124fd71SAlan Somers islastcn) 11876124fd71SAlan Somers { 11886124fd71SAlan Somers struct vattr dvattr; 11896124fd71SAlan Somers 11906124fd71SAlan Somers err = fuse_internal_access(dvp, VWRITE, td, 11916124fd71SAlan Somers cred); 11926124fd71SAlan Somers if (err != 0) 11936124fd71SAlan Somers goto out; 11946124fd71SAlan Somers /* 11956124fd71SAlan Somers * if the parent's sticky bit is set, check 11966124fd71SAlan Somers * whether we're allowed to remove the file. 11976124fd71SAlan Somers * Need to figure out the vnode locking to make 11986124fd71SAlan Somers * this work. 11996124fd71SAlan Somers */ 12006124fd71SAlan Somers fuse_internal_getattr(dvp, &dvattr, cred, td); 12016124fd71SAlan Somers if ((dvattr.va_mode & S_ISTXT) && 12026124fd71SAlan Somers fuse_internal_access(dvp, VADMIN, td, 12036124fd71SAlan Somers cred) && 12046124fd71SAlan Somers fuse_internal_access(*vpp, VADMIN, td, 12056124fd71SAlan Somers cred)) { 12066124fd71SAlan Somers err = EPERM; 12076124fd71SAlan Somers goto out; 12086124fd71SAlan Somers } 12096124fd71SAlan Somers } 12106124fd71SAlan Somers 12116124fd71SAlan Somers if (islastcn && ( 12126124fd71SAlan Somers (nameiop == DELETE) || 12136124fd71SAlan Somers (nameiop == RENAME && wantparent))) { 12146124fd71SAlan Somers cnp->cn_flags |= SAVENAME; 12156124fd71SAlan Somers } 12166124fd71SAlan Somers 12175fe58019SAttilio Rao } 12185fe58019SAttilio Rao } 12195fe58019SAttilio Rao out: 12206124fd71SAlan Somers if (err) { 12216124fd71SAlan Somers if (vp != NULL && dvp != vp) 12226124fd71SAlan Somers vput(vp); 12236124fd71SAlan Somers else if (vp != NULL) 12246124fd71SAlan Somers vrele(vp); 12256124fd71SAlan Somers *vpp = NULL; 12265fe58019SAttilio Rao } 1227438b8a6fSAlan Somers if (did_lookup) 12285fe58019SAttilio Rao fdisp_destroy(&fdi); 12295fe58019SAttilio Rao 12305fe58019SAttilio Rao return err; 12315fe58019SAttilio Rao } 12325fe58019SAttilio Rao 12335fe58019SAttilio Rao /* 12345fe58019SAttilio Rao struct vnop_mkdir_args { 12355fe58019SAttilio Rao struct vnode *a_dvp; 12365fe58019SAttilio Rao struct vnode **a_vpp; 12375fe58019SAttilio Rao struct componentname *a_cnp; 12385fe58019SAttilio Rao struct vattr *a_vap; 12395fe58019SAttilio Rao }; 12405fe58019SAttilio Rao */ 12415fe58019SAttilio Rao static int 12425fe58019SAttilio Rao fuse_vnop_mkdir(struct vop_mkdir_args *ap) 12435fe58019SAttilio Rao { 12445fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 12455fe58019SAttilio Rao struct vnode **vpp = ap->a_vpp; 12465fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 12475fe58019SAttilio Rao struct vattr *vap = ap->a_vap; 12485fe58019SAttilio Rao 12495fe58019SAttilio Rao struct fuse_mkdir_in fmdi; 12505fe58019SAttilio Rao 12515fe58019SAttilio Rao if (fuse_isdeadfs(dvp)) { 12525fe58019SAttilio Rao return ENXIO; 12535fe58019SAttilio Rao } 12545fe58019SAttilio Rao fmdi.mode = MAKEIMODE(vap->va_type, vap->va_mode); 1255a4856c96SAlan Somers fmdi.umask = curthread->td_proc->p_fd->fd_cmask; 12565fe58019SAttilio Rao 1257d9454fabSAttilio Rao return (fuse_internal_newentry(dvp, vpp, cnp, FUSE_MKDIR, &fmdi, 1258d9454fabSAttilio Rao sizeof(fmdi), VDIR)); 12595fe58019SAttilio Rao } 12605fe58019SAttilio Rao 12615fe58019SAttilio Rao /* 12625fe58019SAttilio Rao struct vnop_mknod_args { 12635fe58019SAttilio Rao struct vnode *a_dvp; 12645fe58019SAttilio Rao struct vnode **a_vpp; 12655fe58019SAttilio Rao struct componentname *a_cnp; 12665fe58019SAttilio Rao struct vattr *a_vap; 12675fe58019SAttilio Rao }; 12685fe58019SAttilio Rao */ 12695fe58019SAttilio Rao static int 12705fe58019SAttilio Rao fuse_vnop_mknod(struct vop_mknod_args *ap) 12715fe58019SAttilio Rao { 12725fe58019SAttilio Rao 1273bf4d7084SAlan Somers struct vnode *dvp = ap->a_dvp; 1274bf4d7084SAlan Somers struct vnode **vpp = ap->a_vpp; 1275bf4d7084SAlan Somers struct componentname *cnp = ap->a_cnp; 1276bf4d7084SAlan Somers struct vattr *vap = ap->a_vap; 12775fe58019SAttilio Rao 1278bf4d7084SAlan Somers if (fuse_isdeadfs(dvp)) 1279bf4d7084SAlan Somers return ENXIO; 1280bf4d7084SAlan Somers 1281d5ff2688SAlan Somers return fuse_internal_mknod(dvp, vpp, cnp, vap); 1282bf4d7084SAlan Somers } 12835fe58019SAttilio Rao 12845fe58019SAttilio Rao /* 1285e76986fdSAlan Somers struct vop_open_args { 12865fe58019SAttilio Rao struct vnode *a_vp; 12875fe58019SAttilio Rao int a_mode; 12885fe58019SAttilio Rao struct ucred *a_cred; 12895fe58019SAttilio Rao struct thread *a_td; 12905fe58019SAttilio Rao int a_fdidx; / struct file *a_fp; 12915fe58019SAttilio Rao }; 12925fe58019SAttilio Rao */ 12935fe58019SAttilio Rao static int 12945fe58019SAttilio Rao fuse_vnop_open(struct vop_open_args *ap) 12955fe58019SAttilio Rao { 12965fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 12979e444871SAlan Somers int a_mode = ap->a_mode; 12985fe58019SAttilio Rao struct thread *td = ap->a_td; 12995fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 1300f8d4af10SAlan Somers pid_t pid = td->td_proc->p_pid; 13015fe58019SAttilio Rao struct fuse_vnode_data *fvdat; 13025fe58019SAttilio Rao 1303bf4d7084SAlan Somers if (fuse_isdeadfs(vp)) 13045fe58019SAttilio Rao return ENXIO; 1305bf4d7084SAlan Somers if (vp->v_type == VCHR || vp->v_type == VBLK || vp->v_type == VFIFO) 1306bf4d7084SAlan Somers return (EOPNOTSUPP); 13079e444871SAlan Somers if ((a_mode & (FREAD | FWRITE | FEXEC)) == 0) 1308e7df9886SConrad Meyer return EINVAL; 1309e7df9886SConrad Meyer 13105fe58019SAttilio Rao fvdat = VTOFUD(vp); 13115fe58019SAttilio Rao 13129e444871SAlan Somers if (fuse_filehandle_validrw(vp, a_mode, cred, pid)) { 13135fccbf31SAlan Somers fuse_vnode_open(vp, 0, td); 13145fe58019SAttilio Rao return 0; 13155fe58019SAttilio Rao } 13165fe58019SAttilio Rao 13179e444871SAlan Somers return fuse_filehandle_open(vp, a_mode, NULL, td, cred); 13185fe58019SAttilio Rao } 13195fe58019SAttilio Rao 1320746c92e0SJohn Baldwin static int 1321746c92e0SJohn Baldwin fuse_vnop_pathconf(struct vop_pathconf_args *ap) 1322746c92e0SJohn Baldwin { 1323746c92e0SJohn Baldwin 1324746c92e0SJohn Baldwin switch (ap->a_name) { 1325746c92e0SJohn Baldwin case _PC_FILESIZEBITS: 1326746c92e0SJohn Baldwin *ap->a_retval = 64; 1327746c92e0SJohn Baldwin return (0); 1328599afe53SJohn Baldwin case _PC_NAME_MAX: 1329599afe53SJohn Baldwin *ap->a_retval = NAME_MAX; 1330599afe53SJohn Baldwin return (0); 1331599afe53SJohn Baldwin case _PC_LINK_MAX: 1332f83f3d79SJohn Baldwin *ap->a_retval = MIN(LONG_MAX, FUSE_LINK_MAX); 1333599afe53SJohn Baldwin return (0); 1334746c92e0SJohn Baldwin case _PC_SYMLINK_MAX: 1335746c92e0SJohn Baldwin *ap->a_retval = MAXPATHLEN; 1336746c92e0SJohn Baldwin return (0); 1337746c92e0SJohn Baldwin case _PC_NO_TRUNC: 1338746c92e0SJohn Baldwin *ap->a_retval = 1; 1339746c92e0SJohn Baldwin return (0); 1340746c92e0SJohn Baldwin default: 1341746c92e0SJohn Baldwin return (vop_stdpathconf(ap)); 1342746c92e0SJohn Baldwin } 1343746c92e0SJohn Baldwin } 1344746c92e0SJohn Baldwin 13455fe58019SAttilio Rao /* 13465fe58019SAttilio Rao struct vnop_read_args { 13475fe58019SAttilio Rao struct vnode *a_vp; 13485fe58019SAttilio Rao struct uio *a_uio; 13495fe58019SAttilio Rao int a_ioflag; 13505fe58019SAttilio Rao struct ucred *a_cred; 13515fe58019SAttilio Rao }; 13525fe58019SAttilio Rao */ 13535fe58019SAttilio Rao static int 13545fe58019SAttilio Rao fuse_vnop_read(struct vop_read_args *ap) 13555fe58019SAttilio Rao { 13565fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 13575fe58019SAttilio Rao struct uio *uio = ap->a_uio; 13585fe58019SAttilio Rao int ioflag = ap->a_ioflag; 13595fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 1360f8d4af10SAlan Somers pid_t pid = curthread->td_proc->p_pid; 13615fe58019SAttilio Rao 13625fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 13635fe58019SAttilio Rao return ENXIO; 13645fe58019SAttilio Rao } 1365ead063e0SEdward Tomasz Napierala 1366ead063e0SEdward Tomasz Napierala if (VTOFUD(vp)->flag & FN_DIRECTIO) { 1367ead063e0SEdward Tomasz Napierala ioflag |= IO_DIRECT; 1368ead063e0SEdward Tomasz Napierala } 1369ead063e0SEdward Tomasz Napierala 1370b9e20197SAlan Somers return fuse_io_dispatch(vp, uio, ioflag, cred, pid); 13715fe58019SAttilio Rao } 13725fe58019SAttilio Rao 13735fe58019SAttilio Rao /* 13745fe58019SAttilio Rao struct vnop_readdir_args { 13755fe58019SAttilio Rao struct vnode *a_vp; 13765fe58019SAttilio Rao struct uio *a_uio; 13775fe58019SAttilio Rao struct ucred *a_cred; 13785fe58019SAttilio Rao int *a_eofflag; 1379e76986fdSAlan Somers int *a_ncookies; 13805fe58019SAttilio Rao u_long **a_cookies; 13815fe58019SAttilio Rao }; 13825fe58019SAttilio Rao */ 13835fe58019SAttilio Rao static int 13845fe58019SAttilio Rao fuse_vnop_readdir(struct vop_readdir_args *ap) 13855fe58019SAttilio Rao { 13865fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 13875fe58019SAttilio Rao struct uio *uio = ap->a_uio; 13885fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 13895fe58019SAttilio Rao struct fuse_filehandle *fufh = NULL; 13905fe58019SAttilio Rao struct fuse_iov cookediov; 13915fe58019SAttilio Rao int err = 0; 1392e76986fdSAlan Somers u_long *cookies; 1393e76986fdSAlan Somers off_t startoff; 1394e76986fdSAlan Somers ssize_t tresid; 1395e76986fdSAlan Somers int ncookies; 1396e76986fdSAlan Somers bool closefufh = false; 1397f8d4af10SAlan Somers pid_t pid = curthread->td_proc->p_pid; 13985fe58019SAttilio Rao 1399e76986fdSAlan Somers if (ap->a_eofflag) 1400e76986fdSAlan Somers *ap->a_eofflag = 0; 14015fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 14025fe58019SAttilio Rao return ENXIO; 14035fe58019SAttilio Rao } 14045fe58019SAttilio Rao if ( /* XXXIP ((uio_iovcnt(uio) > 1)) || */ 14055fe58019SAttilio Rao (uio_resid(uio) < sizeof(struct dirent))) { 14065fe58019SAttilio Rao return EINVAL; 14075fe58019SAttilio Rao } 14085fe58019SAttilio Rao 1409e76986fdSAlan Somers tresid = uio->uio_resid; 1410e76986fdSAlan Somers startoff = uio->uio_offset; 141135cf0e7eSAlan Somers err = fuse_filehandle_get_dir(vp, &fufh, cred, pid); 1412e76986fdSAlan Somers if (err == EBADF && vnode_mount(vp)->mnt_flag & MNT_EXPORTED) { 1413e76986fdSAlan Somers /* 1414e76986fdSAlan Somers * nfsd will do VOP_READDIR without first doing VOP_OPEN. We 1415e76986fdSAlan Somers * must implicitly open the directory here 1416e76986fdSAlan Somers */ 1417e76986fdSAlan Somers err = fuse_filehandle_open(vp, FREAD, &fufh, curthread, cred); 1418e76986fdSAlan Somers if (err == 0) { 1419e76986fdSAlan Somers /* 1420e76986fdSAlan Somers * When a directory is opened, it must be read from 1421e76986fdSAlan Somers * the beginning. Hopefully, the "startoff" still 1422e76986fdSAlan Somers * exists as an offset cookie for the directory. 1423e76986fdSAlan Somers * If not, it will read the entire directory without 1424e76986fdSAlan Somers * returning any entries and just return eof. 1425e76986fdSAlan Somers */ 1426e76986fdSAlan Somers uio->uio_offset = 0; 1427e76986fdSAlan Somers } 1428e76986fdSAlan Somers closefufh = true; 1429e76986fdSAlan Somers } 143035cf0e7eSAlan Somers if (err) 14315fe58019SAttilio Rao return (err); 1432e76986fdSAlan Somers if (ap->a_ncookies != NULL) { 1433e76986fdSAlan Somers ncookies = uio->uio_resid / 1434e76986fdSAlan Somers (offsetof(struct dirent, d_name) + 4) + 1; 1435e76986fdSAlan Somers cookies = malloc(ncookies * sizeof(*cookies), M_TEMP, M_WAITOK); 1436e76986fdSAlan Somers *ap->a_ncookies = ncookies; 1437e76986fdSAlan Somers *ap->a_cookies = cookies; 1438e76986fdSAlan Somers } else { 1439e76986fdSAlan Somers ncookies = 0; 1440e76986fdSAlan Somers cookies = NULL; 1441e76986fdSAlan Somers } 14425fe58019SAttilio Rao #define DIRCOOKEDSIZE FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + MAXNAMLEN + 1) 14435fe58019SAttilio Rao fiov_init(&cookediov, DIRCOOKEDSIZE); 14445fe58019SAttilio Rao 1445e76986fdSAlan Somers err = fuse_internal_readdir(vp, uio, startoff, fufh, &cookediov, 1446e76986fdSAlan Somers &ncookies, cookies); 14475fe58019SAttilio Rao 14485fe58019SAttilio Rao fiov_teardown(&cookediov); 1449e76986fdSAlan Somers if (closefufh) 1450e76986fdSAlan Somers fuse_filehandle_close(vp, fufh, curthread, cred); 1451e76986fdSAlan Somers 1452e76986fdSAlan Somers if (ap->a_ncookies != NULL) { 1453e76986fdSAlan Somers if (err == 0) { 1454e76986fdSAlan Somers *ap->a_ncookies -= ncookies; 1455e76986fdSAlan Somers } else { 1456e76986fdSAlan Somers free(*ap->a_cookies, M_TEMP); 1457e76986fdSAlan Somers *ap->a_ncookies = 0; 1458e76986fdSAlan Somers *ap->a_cookies = NULL; 1459e76986fdSAlan Somers } 1460e76986fdSAlan Somers } 1461e76986fdSAlan Somers if (err == 0 && tresid == uio->uio_resid) 1462e76986fdSAlan Somers *ap->a_eofflag = 1; 14635ec10aa5SAlan Somers 14645fe58019SAttilio Rao return err; 14655fe58019SAttilio Rao } 14665fe58019SAttilio Rao 14675fe58019SAttilio Rao /* 14685fe58019SAttilio Rao struct vnop_readlink_args { 14695fe58019SAttilio Rao struct vnode *a_vp; 14705fe58019SAttilio Rao struct uio *a_uio; 14715fe58019SAttilio Rao struct ucred *a_cred; 14725fe58019SAttilio Rao }; 14735fe58019SAttilio Rao */ 14745fe58019SAttilio Rao static int 14755fe58019SAttilio Rao fuse_vnop_readlink(struct vop_readlink_args *ap) 14765fe58019SAttilio Rao { 14775fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 14785fe58019SAttilio Rao struct uio *uio = ap->a_uio; 14795fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 14805fe58019SAttilio Rao 14815fe58019SAttilio Rao struct fuse_dispatcher fdi; 14825fe58019SAttilio Rao int err; 14835fe58019SAttilio Rao 14845fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 14855fe58019SAttilio Rao return ENXIO; 14865fe58019SAttilio Rao } 14875fe58019SAttilio Rao if (!vnode_islnk(vp)) { 14885fe58019SAttilio Rao return EINVAL; 14895fe58019SAttilio Rao } 14905fe58019SAttilio Rao fdisp_init(&fdi, 0); 14915fe58019SAttilio Rao err = fdisp_simple_putget_vp(&fdi, FUSE_READLINK, vp, curthread, cred); 14925fe58019SAttilio Rao if (err) { 14935fe58019SAttilio Rao goto out; 14945fe58019SAttilio Rao } 14955fe58019SAttilio Rao if (((char *)fdi.answ)[0] == '/' && 14965fe58019SAttilio Rao fuse_get_mpdata(vnode_mount(vp))->dataflags & FSESS_PUSH_SYMLINKS_IN) { 14975fe58019SAttilio Rao char *mpth = vnode_mount(vp)->mnt_stat.f_mntonname; 14985fe58019SAttilio Rao 14995fe58019SAttilio Rao err = uiomove(mpth, strlen(mpth), uio); 15005fe58019SAttilio Rao } 15015fe58019SAttilio Rao if (!err) { 15025fe58019SAttilio Rao err = uiomove(fdi.answ, fdi.iosize, uio); 15035fe58019SAttilio Rao } 15045fe58019SAttilio Rao out: 15055fe58019SAttilio Rao fdisp_destroy(&fdi); 15065fe58019SAttilio Rao return err; 15075fe58019SAttilio Rao } 15085fe58019SAttilio Rao 15095fe58019SAttilio Rao /* 15105fe58019SAttilio Rao struct vnop_reclaim_args { 15115fe58019SAttilio Rao struct vnode *a_vp; 15125fe58019SAttilio Rao struct thread *a_td; 15135fe58019SAttilio Rao }; 15145fe58019SAttilio Rao */ 15155fe58019SAttilio Rao static int 15165fe58019SAttilio Rao fuse_vnop_reclaim(struct vop_reclaim_args *ap) 15175fe58019SAttilio Rao { 15185fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 15195fe58019SAttilio Rao struct thread *td = ap->a_td; 15205fe58019SAttilio Rao struct fuse_vnode_data *fvdat = VTOFUD(vp); 15215ec10aa5SAlan Somers struct fuse_filehandle *fufh, *fufh_tmp; 15225fe58019SAttilio Rao 15235fe58019SAttilio Rao if (!fvdat) { 15245fe58019SAttilio Rao panic("FUSE: no vnode data during recycling"); 15255fe58019SAttilio Rao } 15265ec10aa5SAlan Somers LIST_FOREACH_SAFE(fufh, &fvdat->handles, next, fufh_tmp) { 15275ec10aa5SAlan Somers printf("FUSE: vnode being reclaimed with open fufh " 15289e444871SAlan Somers "(type=%#x)", fufh->fufh_type); 15295ec10aa5SAlan Somers fuse_filehandle_close(vp, fufh, td, NULL); 15305fe58019SAttilio Rao } 15315fe58019SAttilio Rao 153242767f76SAlan Somers if (!fuse_isdeadfs(vp) && fvdat->nlookup > 0) { 15335fe58019SAttilio Rao fuse_internal_forget_send(vnode_mount(vp), td, NULL, VTOI(vp), 15345fe58019SAttilio Rao fvdat->nlookup); 15355fe58019SAttilio Rao } 15365fe58019SAttilio Rao cache_purge(vp); 15375fe58019SAttilio Rao vfs_hash_remove(vp); 15385fe58019SAttilio Rao fuse_vnode_destroy(vp); 15395fe58019SAttilio Rao 15405fe58019SAttilio Rao return 0; 15415fe58019SAttilio Rao } 15425fe58019SAttilio Rao 15435fe58019SAttilio Rao /* 15445fe58019SAttilio Rao struct vnop_remove_args { 15455fe58019SAttilio Rao struct vnode *a_dvp; 15465fe58019SAttilio Rao struct vnode *a_vp; 15475fe58019SAttilio Rao struct componentname *a_cnp; 15485fe58019SAttilio Rao }; 15495fe58019SAttilio Rao */ 15505fe58019SAttilio Rao static int 15515fe58019SAttilio Rao fuse_vnop_remove(struct vop_remove_args *ap) 15525fe58019SAttilio Rao { 15535fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 15545fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 15555fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 15565fe58019SAttilio Rao 15575fe58019SAttilio Rao int err; 15585fe58019SAttilio Rao 15595fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 15605fe58019SAttilio Rao return ENXIO; 15615fe58019SAttilio Rao } 15625fe58019SAttilio Rao if (vnode_isdir(vp)) { 15635fe58019SAttilio Rao return EPERM; 15645fe58019SAttilio Rao } 15655fe58019SAttilio Rao 15665fe58019SAttilio Rao err = fuse_internal_remove(dvp, vp, cnp, FUSE_UNLINK); 15675fe58019SAttilio Rao 15685fe58019SAttilio Rao return err; 15695fe58019SAttilio Rao } 15705fe58019SAttilio Rao 15715fe58019SAttilio Rao /* 15725fe58019SAttilio Rao struct vnop_rename_args { 15735fe58019SAttilio Rao struct vnode *a_fdvp; 15745fe58019SAttilio Rao struct vnode *a_fvp; 15755fe58019SAttilio Rao struct componentname *a_fcnp; 15765fe58019SAttilio Rao struct vnode *a_tdvp; 15775fe58019SAttilio Rao struct vnode *a_tvp; 15785fe58019SAttilio Rao struct componentname *a_tcnp; 15795fe58019SAttilio Rao }; 15805fe58019SAttilio Rao */ 15815fe58019SAttilio Rao static int 15825fe58019SAttilio Rao fuse_vnop_rename(struct vop_rename_args *ap) 15835fe58019SAttilio Rao { 15845fe58019SAttilio Rao struct vnode *fdvp = ap->a_fdvp; 15855fe58019SAttilio Rao struct vnode *fvp = ap->a_fvp; 15865fe58019SAttilio Rao struct componentname *fcnp = ap->a_fcnp; 15875fe58019SAttilio Rao struct vnode *tdvp = ap->a_tdvp; 15885fe58019SAttilio Rao struct vnode *tvp = ap->a_tvp; 15895fe58019SAttilio Rao struct componentname *tcnp = ap->a_tcnp; 15905fe58019SAttilio Rao struct fuse_data *data; 15918e45ec4eSAlan Somers bool newparent = fdvp != tdvp; 15928e45ec4eSAlan Somers bool isdir = fvp->v_type == VDIR; 15935fe58019SAttilio Rao int err = 0; 15945fe58019SAttilio Rao 15955fe58019SAttilio Rao if (fuse_isdeadfs(fdvp)) { 15965fe58019SAttilio Rao return ENXIO; 15975fe58019SAttilio Rao } 15985fe58019SAttilio Rao if (fvp->v_mount != tdvp->v_mount || 15995fe58019SAttilio Rao (tvp && fvp->v_mount != tvp->v_mount)) { 1600419e7ff6SAlan Somers SDT_PROBE2(fusefs, , vnops, trace, 1, "cross-device rename"); 16015fe58019SAttilio Rao err = EXDEV; 16025fe58019SAttilio Rao goto out; 16035fe58019SAttilio Rao } 16045fe58019SAttilio Rao cache_purge(fvp); 16055fe58019SAttilio Rao 16065fe58019SAttilio Rao /* 16075fe58019SAttilio Rao * FUSE library is expected to check if target directory is not 16085fe58019SAttilio Rao * under the source directory in the file system tree. 16095fe58019SAttilio Rao * Linux performs this check at VFS level. 16105fe58019SAttilio Rao */ 16118e45ec4eSAlan Somers /* 16128e45ec4eSAlan Somers * If source is a directory, and it will get a new parent, user must 16138e45ec4eSAlan Somers * have write permission to it, so ".." can be modified. 16148e45ec4eSAlan Somers */ 16155fe58019SAttilio Rao data = fuse_get_mpdata(vnode_mount(tdvp)); 16168e45ec4eSAlan Somers if (data->dataflags & FSESS_DEFAULT_PERMISSIONS && isdir && newparent) { 16178e45ec4eSAlan Somers err = fuse_internal_access(fvp, VWRITE, 16188e45ec4eSAlan Somers tcnp->cn_thread, tcnp->cn_cred); 16198e45ec4eSAlan Somers if (err) 16208e45ec4eSAlan Somers goto out; 16218e45ec4eSAlan Somers } 16225fe58019SAttilio Rao sx_xlock(&data->rename_lock); 16235fe58019SAttilio Rao err = fuse_internal_rename(fdvp, fcnp, tdvp, tcnp); 16245fe58019SAttilio Rao if (err == 0) { 1625d9454fabSAttilio Rao if (tdvp != fdvp) 16265fe58019SAttilio Rao fuse_vnode_setparent(fvp, tdvp); 16275fe58019SAttilio Rao if (tvp != NULL) 16285fe58019SAttilio Rao fuse_vnode_setparent(tvp, NULL); 16295fe58019SAttilio Rao } 16305fe58019SAttilio Rao sx_unlock(&data->rename_lock); 16315fe58019SAttilio Rao 16325fe58019SAttilio Rao if (tvp != NULL && tvp != fvp) { 16335fe58019SAttilio Rao cache_purge(tvp); 16345fe58019SAttilio Rao } 16355fe58019SAttilio Rao if (vnode_isdir(fvp)) { 16365fe58019SAttilio Rao if ((tvp != NULL) && vnode_isdir(tvp)) { 16375fe58019SAttilio Rao cache_purge(tdvp); 16385fe58019SAttilio Rao } 16395fe58019SAttilio Rao cache_purge(fdvp); 16405fe58019SAttilio Rao } 16415fe58019SAttilio Rao out: 16425fe58019SAttilio Rao if (tdvp == tvp) { 16435fe58019SAttilio Rao vrele(tdvp); 16445fe58019SAttilio Rao } else { 16455fe58019SAttilio Rao vput(tdvp); 16465fe58019SAttilio Rao } 16475fe58019SAttilio Rao if (tvp != NULL) { 16485fe58019SAttilio Rao vput(tvp); 16495fe58019SAttilio Rao } 16505fe58019SAttilio Rao vrele(fdvp); 16515fe58019SAttilio Rao vrele(fvp); 16525fe58019SAttilio Rao 16535fe58019SAttilio Rao return err; 16545fe58019SAttilio Rao } 16555fe58019SAttilio Rao 16565fe58019SAttilio Rao /* 16575fe58019SAttilio Rao struct vnop_rmdir_args { 16585fe58019SAttilio Rao struct vnode *a_dvp; 16595fe58019SAttilio Rao struct vnode *a_vp; 16605fe58019SAttilio Rao struct componentname *a_cnp; 16615fe58019SAttilio Rao } *ap; 16625fe58019SAttilio Rao */ 16635fe58019SAttilio Rao static int 16645fe58019SAttilio Rao fuse_vnop_rmdir(struct vop_rmdir_args *ap) 16655fe58019SAttilio Rao { 16665fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 16675fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 16685fe58019SAttilio Rao 16695fe58019SAttilio Rao int err; 16705fe58019SAttilio Rao 16715fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 16725fe58019SAttilio Rao return ENXIO; 16735fe58019SAttilio Rao } 16745fe58019SAttilio Rao if (VTOFUD(vp) == VTOFUD(dvp)) { 16755fe58019SAttilio Rao return EINVAL; 16765fe58019SAttilio Rao } 16775fe58019SAttilio Rao err = fuse_internal_remove(dvp, vp, ap->a_cnp, FUSE_RMDIR); 16785fe58019SAttilio Rao 16795fe58019SAttilio Rao return err; 16805fe58019SAttilio Rao } 16815fe58019SAttilio Rao 16825fe58019SAttilio Rao /* 16835fe58019SAttilio Rao struct vnop_setattr_args { 16845fe58019SAttilio Rao struct vnode *a_vp; 16855fe58019SAttilio Rao struct vattr *a_vap; 16865fe58019SAttilio Rao struct ucred *a_cred; 16875fe58019SAttilio Rao struct thread *a_td; 16885fe58019SAttilio Rao }; 16895fe58019SAttilio Rao */ 16905fe58019SAttilio Rao static int 16915fe58019SAttilio Rao fuse_vnop_setattr(struct vop_setattr_args *ap) 16925fe58019SAttilio Rao { 16935fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 16945fe58019SAttilio Rao struct vattr *vap = ap->a_vap; 16955fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 16965fe58019SAttilio Rao struct thread *td = curthread; 1697474ba6faSAlan Somers struct mount *mp; 1698474ba6faSAlan Somers struct fuse_data *data; 16994e83d655SAlan Somers struct vattr old_va; 1700474ba6faSAlan Somers int dataflags; 17014e83d655SAlan Somers int err = 0, err2; 1702ff4fbdf5SAlan Somers accmode_t accmode = 0; 1703a90e32deSAlan Somers bool checkperm; 1704a2bdd737SAlan Somers bool drop_suid = false; 17054e83d655SAlan Somers gid_t cr_gid; 17065fe58019SAttilio Rao 1707474ba6faSAlan Somers mp = vnode_mount(vp); 1708474ba6faSAlan Somers data = fuse_get_mpdata(mp); 1709474ba6faSAlan Somers dataflags = data->dataflags; 1710a90e32deSAlan Somers checkperm = dataflags & FSESS_DEFAULT_PERMISSIONS; 17114e83d655SAlan Somers if (cred->cr_ngroups > 0) 17124e83d655SAlan Somers cr_gid = cred->cr_groups[0]; 17134e83d655SAlan Somers else 17144e83d655SAlan Somers cr_gid = 0; 1715474ba6faSAlan Somers 17165fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 17175fe58019SAttilio Rao return ENXIO; 17185fe58019SAttilio Rao } 17195fe58019SAttilio Rao 17205fe58019SAttilio Rao if (vap->va_uid != (uid_t)VNOVAL) { 1721a90e32deSAlan Somers if (checkperm) { 1722474ba6faSAlan Somers /* Only root may change a file's owner */ 1723474ba6faSAlan Somers err = priv_check_cred(cred, PRIV_VFS_CHOWN); 17244e83d655SAlan Somers if (err) { 17254e83d655SAlan Somers /* As a special case, allow the null chown */ 17264e83d655SAlan Somers err2 = fuse_internal_getattr(vp, &old_va, cred, 17274e83d655SAlan Somers td); 17284e83d655SAlan Somers if (err2) 17294e83d655SAlan Somers return (err2); 17304e83d655SAlan Somers if (vap->va_uid != old_va.va_uid) 17314e83d655SAlan Somers return err; 17324e83d655SAlan Somers else 17334e83d655SAlan Somers accmode |= VADMIN; 1734a2bdd737SAlan Somers drop_suid = true; 17354e83d655SAlan Somers } else 17364e83d655SAlan Somers accmode |= VADMIN; 17374e83d655SAlan Somers } else 1738ff4fbdf5SAlan Somers accmode |= VADMIN; 17395fe58019SAttilio Rao } 17405fe58019SAttilio Rao if (vap->va_gid != (gid_t)VNOVAL) { 1741a2bdd737SAlan Somers if (checkperm && priv_check_cred(cred, PRIV_VFS_CHOWN)) 1742a2bdd737SAlan Somers drop_suid = true; 1743a90e32deSAlan Somers if (checkperm && !groupmember(vap->va_gid, cred)) 1744474ba6faSAlan Somers { 1745474ba6faSAlan Somers /* 1746474ba6faSAlan Somers * Non-root users may only chgrp to one of their own 1747474ba6faSAlan Somers * groups 1748474ba6faSAlan Somers */ 1749474ba6faSAlan Somers err = priv_check_cred(cred, PRIV_VFS_CHOWN); 17504e83d655SAlan Somers if (err) { 17514e83d655SAlan Somers /* As a special case, allow the null chgrp */ 17524e83d655SAlan Somers err2 = fuse_internal_getattr(vp, &old_va, cred, 17534e83d655SAlan Somers td); 17544e83d655SAlan Somers if (err2) 17554e83d655SAlan Somers return (err2); 17564e83d655SAlan Somers if (vap->va_gid != old_va.va_gid) 1757a90e32deSAlan Somers return err; 17584e83d655SAlan Somers accmode |= VADMIN; 17594e83d655SAlan Somers } else 17604e83d655SAlan Somers accmode |= VADMIN; 17614e83d655SAlan Somers } else 1762ff4fbdf5SAlan Somers accmode |= VADMIN; 17635fe58019SAttilio Rao } 17645fe58019SAttilio Rao if (vap->va_size != VNOVAL) { 1765a90e32deSAlan Somers switch (vp->v_type) { 1766a90e32deSAlan Somers case VDIR: 1767a90e32deSAlan Somers return (EISDIR); 1768a90e32deSAlan Somers case VLNK: 1769a90e32deSAlan Somers case VREG: 1770a90e32deSAlan Somers if (vfs_isrdonly(mp)) 1771a90e32deSAlan Somers return (EROFS); 1772a90e32deSAlan Somers break; 1773a90e32deSAlan Somers default: 1774a90e32deSAlan Somers /* 1775a90e32deSAlan Somers * According to POSIX, the result is unspecified 1776a90e32deSAlan Somers * for file types other than regular files, 1777a90e32deSAlan Somers * directories and shared memory objects. We 1778a90e32deSAlan Somers * don't support shared memory objects in the file 1779a90e32deSAlan Somers * system, and have dubious support for truncating 1780a90e32deSAlan Somers * symlinks. Just ignore the request in other cases. 1781a90e32deSAlan Somers */ 1782a90e32deSAlan Somers return (0); 1783a90e32deSAlan Somers } 17843fa12789SAlan Somers /* Don't set accmode. Permission to trunc is checked upstack */ 17855fe58019SAttilio Rao } 1786d943c93eSAlan Somers if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) { 1787d943c93eSAlan Somers if (vap->va_vaflags & VA_UTIMES_NULL) 1788d943c93eSAlan Somers accmode |= VWRITE; 1789d943c93eSAlan Somers else 1790ff4fbdf5SAlan Somers accmode |= VADMIN; 1791d943c93eSAlan Somers } 1792a2bdd737SAlan Somers if (drop_suid) { 1793a2bdd737SAlan Somers if (vap->va_mode != (mode_t)VNOVAL) 1794a2bdd737SAlan Somers vap->va_mode &= ~(S_ISUID | S_ISGID); 1795a2bdd737SAlan Somers else { 1796a2bdd737SAlan Somers err = fuse_internal_getattr(vp, &old_va, cred, td); 1797a2bdd737SAlan Somers if (err) 1798a2bdd737SAlan Somers return (err); 1799a2bdd737SAlan Somers vap->va_mode = old_va.va_mode & ~(S_ISUID | S_ISGID); 1800a2bdd737SAlan Somers } 1801a2bdd737SAlan Somers } 18025fe58019SAttilio Rao if (vap->va_mode != (mode_t)VNOVAL) { 1803e5ff3a7eSAlan Somers /* Only root may set the sticky bit on non-directories */ 1804a90e32deSAlan Somers if (checkperm && vp->v_type != VDIR && (vap->va_mode & S_ISTXT) 1805a90e32deSAlan Somers && priv_check_cred(cred, PRIV_VFS_STICKYFILE)) 1806a90e32deSAlan Somers return EFTYPE; 18078cfb4431SAlan Somers if (checkperm && (vap->va_mode & S_ISGID)) { 18088cfb4431SAlan Somers err = fuse_internal_getattr(vp, &old_va, cred, td); 18098cfb4431SAlan Somers if (err) 18108cfb4431SAlan Somers return (err); 18118cfb4431SAlan Somers if (!groupmember(old_va.va_gid, cred)) { 18128cfb4431SAlan Somers err = priv_check_cred(cred, PRIV_VFS_SETGID); 18138cfb4431SAlan Somers if (err) 18148cfb4431SAlan Somers return (err); 18158cfb4431SAlan Somers } 18168cfb4431SAlan Somers } 1817ff4fbdf5SAlan Somers accmode |= VADMIN; 18185fe58019SAttilio Rao } 18195fe58019SAttilio Rao 1820a90e32deSAlan Somers if (vfs_isrdonly(mp)) 1821a90e32deSAlan Somers return EROFS; 1822a90e32deSAlan Somers 1823666f8543SAlan Somers err = fuse_internal_access(vp, accmode, td, cred); 1824ff4fbdf5SAlan Somers if (err) 18255fe58019SAttilio Rao return err; 1826a90e32deSAlan Somers else 1827a90e32deSAlan Somers return fuse_internal_setattr(vp, vap, td, cred); 18285fe58019SAttilio Rao } 18295fe58019SAttilio Rao 18305fe58019SAttilio Rao /* 18315fe58019SAttilio Rao struct vnop_strategy_args { 18325fe58019SAttilio Rao struct vnode *a_vp; 18335fe58019SAttilio Rao struct buf *a_bp; 18345fe58019SAttilio Rao }; 18355fe58019SAttilio Rao */ 18365fe58019SAttilio Rao static int 18375fe58019SAttilio Rao fuse_vnop_strategy(struct vop_strategy_args *ap) 18385fe58019SAttilio Rao { 18395fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 18405fe58019SAttilio Rao struct buf *bp = ap->a_bp; 18415fe58019SAttilio Rao 18425fe58019SAttilio Rao if (!vp || fuse_isdeadfs(vp)) { 18435fe58019SAttilio Rao bp->b_ioflags |= BIO_ERROR; 18445fe58019SAttilio Rao bp->b_error = ENXIO; 18455fe58019SAttilio Rao bufdone(bp); 184698852a32SAlan Somers return 0; 18475fe58019SAttilio Rao } 18485fe58019SAttilio Rao 18495fe58019SAttilio Rao /* 1850f203d173SAlan Somers * VOP_STRATEGY always returns zero and signals error via bp->b_ioflags. 1851f203d173SAlan Somers * fuse_io_strategy sets bp's error fields 18525fe58019SAttilio Rao */ 1853f203d173SAlan Somers (void)fuse_io_strategy(vp, bp); 1854f203d173SAlan Somers 18555fe58019SAttilio Rao return 0; 18565fe58019SAttilio Rao } 18575fe58019SAttilio Rao 18585fe58019SAttilio Rao 18595fe58019SAttilio Rao /* 18605fe58019SAttilio Rao struct vnop_symlink_args { 18615fe58019SAttilio Rao struct vnode *a_dvp; 18625fe58019SAttilio Rao struct vnode **a_vpp; 18635fe58019SAttilio Rao struct componentname *a_cnp; 18645fe58019SAttilio Rao struct vattr *a_vap; 18655fe58019SAttilio Rao char *a_target; 18665fe58019SAttilio Rao }; 18675fe58019SAttilio Rao */ 18685fe58019SAttilio Rao static int 18695fe58019SAttilio Rao fuse_vnop_symlink(struct vop_symlink_args *ap) 18705fe58019SAttilio Rao { 18715fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 18725fe58019SAttilio Rao struct vnode **vpp = ap->a_vpp; 18735fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 18741493c2eeSBrooks Davis const char *target = ap->a_target; 18755fe58019SAttilio Rao 18765fe58019SAttilio Rao struct fuse_dispatcher fdi; 18775fe58019SAttilio Rao 18785fe58019SAttilio Rao int err; 18795fe58019SAttilio Rao size_t len; 18805fe58019SAttilio Rao 18815fe58019SAttilio Rao if (fuse_isdeadfs(dvp)) { 18825fe58019SAttilio Rao return ENXIO; 18835fe58019SAttilio Rao } 18845fe58019SAttilio Rao /* 18855fe58019SAttilio Rao * Unlike the other creator type calls, here we have to create a message 18865fe58019SAttilio Rao * where the name of the new entry comes first, and the data describing 18875fe58019SAttilio Rao * the entry comes second. 18885fe58019SAttilio Rao * Hence we can't rely on our handy fuse_internal_newentry() routine, 18895fe58019SAttilio Rao * but put together the message manually and just call the core part. 18905fe58019SAttilio Rao */ 18915fe58019SAttilio Rao 18925fe58019SAttilio Rao len = strlen(target) + 1; 18935fe58019SAttilio Rao fdisp_init(&fdi, len + cnp->cn_namelen + 1); 18945fe58019SAttilio Rao fdisp_make_vp(&fdi, FUSE_SYMLINK, dvp, curthread, NULL); 18955fe58019SAttilio Rao 18965fe58019SAttilio Rao memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen); 18975fe58019SAttilio Rao ((char *)fdi.indata)[cnp->cn_namelen] = '\0'; 18985fe58019SAttilio Rao memcpy((char *)fdi.indata + cnp->cn_namelen + 1, target, len); 18995fe58019SAttilio Rao 19005fe58019SAttilio Rao err = fuse_internal_newentry_core(dvp, vpp, cnp, VLNK, &fdi); 19015fe58019SAttilio Rao fdisp_destroy(&fdi); 19025fe58019SAttilio Rao return err; 19035fe58019SAttilio Rao } 19045fe58019SAttilio Rao 19055fe58019SAttilio Rao /* 19065fe58019SAttilio Rao struct vnop_write_args { 19075fe58019SAttilio Rao struct vnode *a_vp; 19085fe58019SAttilio Rao struct uio *a_uio; 19095fe58019SAttilio Rao int a_ioflag; 19105fe58019SAttilio Rao struct ucred *a_cred; 19115fe58019SAttilio Rao }; 19125fe58019SAttilio Rao */ 19135fe58019SAttilio Rao static int 19145fe58019SAttilio Rao fuse_vnop_write(struct vop_write_args *ap) 19155fe58019SAttilio Rao { 19165fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 19175fe58019SAttilio Rao struct uio *uio = ap->a_uio; 19185fe58019SAttilio Rao int ioflag = ap->a_ioflag; 19195fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 1920f8d4af10SAlan Somers pid_t pid = curthread->td_proc->p_pid; 19215fe58019SAttilio Rao 19225fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 19235fe58019SAttilio Rao return ENXIO; 19245fe58019SAttilio Rao } 19255fe58019SAttilio Rao 1926ead063e0SEdward Tomasz Napierala if (VTOFUD(vp)->flag & FN_DIRECTIO) { 1927ead063e0SEdward Tomasz Napierala ioflag |= IO_DIRECT; 1928ead063e0SEdward Tomasz Napierala } 1929ead063e0SEdward Tomasz Napierala 1930b9e20197SAlan Somers return fuse_io_dispatch(vp, uio, ioflag, cred, pid); 19315fe58019SAttilio Rao } 19325fe58019SAttilio Rao 1933b9e20197SAlan Somers static daddr_t 1934b9e20197SAlan Somers fuse_gbp_getblkno(struct vnode *vp, vm_ooffset_t off) 1935b9e20197SAlan Somers { 1936b9e20197SAlan Somers const int biosize = fuse_iosize(vp); 1937b9e20197SAlan Somers 1938b9e20197SAlan Somers return (off / biosize); 1939b9e20197SAlan Somers } 1940b9e20197SAlan Somers 1941b9e20197SAlan Somers static int 1942b9e20197SAlan Somers fuse_gbp_getblksz(struct vnode *vp, daddr_t lbn) 1943b9e20197SAlan Somers { 1944b9e20197SAlan Somers off_t filesize; 1945b9e20197SAlan Somers int blksz, err; 1946b9e20197SAlan Somers const int biosize = fuse_iosize(vp); 1947b9e20197SAlan Somers 1948b9e20197SAlan Somers err = fuse_vnode_size(vp, &filesize, NULL, NULL); 1949b9e20197SAlan Somers KASSERT(err == 0, ("vfs_bio_getpages can't handle errors here")); 1950b9e20197SAlan Somers if (err) 1951b9e20197SAlan Somers return biosize; 1952b9e20197SAlan Somers 1953b9e20197SAlan Somers if ((off_t)lbn * biosize >= filesize) { 1954b9e20197SAlan Somers blksz = 0; 1955b9e20197SAlan Somers } else if ((off_t)(lbn + 1) * biosize > filesize) { 1956b9e20197SAlan Somers blksz = filesize - (off_t)lbn *biosize; 1957b9e20197SAlan Somers } else { 1958b9e20197SAlan Somers blksz = biosize; 1959b9e20197SAlan Somers } 1960b9e20197SAlan Somers return (blksz); 1961b9e20197SAlan Somers } 1962b9e20197SAlan Somers 19635fe58019SAttilio Rao /* 19645fe58019SAttilio Rao struct vnop_getpages_args { 19655fe58019SAttilio Rao struct vnode *a_vp; 19665fe58019SAttilio Rao vm_page_t *a_m; 19675fe58019SAttilio Rao int a_count; 19685fe58019SAttilio Rao int a_reqpage; 19695fe58019SAttilio Rao }; 19705fe58019SAttilio Rao */ 19715fe58019SAttilio Rao static int 19725fe58019SAttilio Rao fuse_vnop_getpages(struct vop_getpages_args *ap) 19735fe58019SAttilio Rao { 1974b9e20197SAlan Somers struct vnode *vp = ap->a_vp; 19755fe58019SAttilio Rao 19765fe58019SAttilio Rao if (!fsess_opt_mmap(vnode_mount(vp))) { 1977419e7ff6SAlan Somers SDT_PROBE2(fusefs, , vnops, trace, 1, 1978cf169498SAlan Somers "called on non-cacheable vnode??\n"); 19795fe58019SAttilio Rao return (VM_PAGER_ERROR); 19805fe58019SAttilio Rao } 19815fe58019SAttilio Rao 1982b9e20197SAlan Somers return (vfs_bio_getpages(vp, ap->a_m, ap->a_count, ap->a_rbehind, 1983b9e20197SAlan Somers ap->a_rahead, fuse_gbp_getblkno, fuse_gbp_getblksz)); 19845fe58019SAttilio Rao } 19855fe58019SAttilio Rao 198604660064SFedor Uporov static const char extattr_namespace_separator = '.'; 198704660064SFedor Uporov 198804660064SFedor Uporov /* 198904660064SFedor Uporov struct vop_getextattr_args { 199004660064SFedor Uporov struct vop_generic_args a_gen; 199104660064SFedor Uporov struct vnode *a_vp; 199204660064SFedor Uporov int a_attrnamespace; 199304660064SFedor Uporov const char *a_name; 199404660064SFedor Uporov struct uio *a_uio; 199504660064SFedor Uporov size_t *a_size; 199604660064SFedor Uporov struct ucred *a_cred; 199704660064SFedor Uporov struct thread *a_td; 199804660064SFedor Uporov }; 199904660064SFedor Uporov */ 200004660064SFedor Uporov static int 200104660064SFedor Uporov fuse_vnop_getextattr(struct vop_getextattr_args *ap) 200204660064SFedor Uporov { 200304660064SFedor Uporov struct vnode *vp = ap->a_vp; 200404660064SFedor Uporov struct uio *uio = ap->a_uio; 200528f4f623SFedor Uporov struct fuse_dispatcher fdi; 200604660064SFedor Uporov struct fuse_getxattr_in *get_xattr_in; 200704660064SFedor Uporov struct fuse_getxattr_out *get_xattr_out; 200804660064SFedor Uporov struct mount *mp = vnode_mount(vp); 200904660064SFedor Uporov struct thread *td = ap->a_td; 201004660064SFedor Uporov struct ucred *cred = ap->a_cred; 201128f4f623SFedor Uporov char *prefix; 201228f4f623SFedor Uporov char *attr_str; 201328f4f623SFedor Uporov size_t len; 201428f4f623SFedor Uporov int err; 201504660064SFedor Uporov 201604660064SFedor Uporov if (fuse_isdeadfs(vp)) 201728f4f623SFedor Uporov return (ENXIO); 201804660064SFedor Uporov 20191f4a83f9SAlan Somers if (!fsess_isimpl(mp, FUSE_GETXATTR)) 20201f4a83f9SAlan Somers return EOPNOTSUPP; 20211f4a83f9SAlan Somers 2022666f8543SAlan Somers err = fuse_extattr_check_cred(vp, ap->a_attrnamespace, cred, td, VREAD); 2023ff4fbdf5SAlan Somers if (err) 2024ff4fbdf5SAlan Somers return err; 2025ff4fbdf5SAlan Somers 202604660064SFedor Uporov /* Default to looking for user attributes. */ 202704660064SFedor Uporov if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 202804660064SFedor Uporov prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 202904660064SFedor Uporov else 203004660064SFedor Uporov prefix = EXTATTR_NAMESPACE_USER_STRING; 203104660064SFedor Uporov 203204660064SFedor Uporov len = strlen(prefix) + sizeof(extattr_namespace_separator) + 203304660064SFedor Uporov strlen(ap->a_name) + 1; 203404660064SFedor Uporov 203504660064SFedor Uporov fdisp_init(&fdi, len + sizeof(*get_xattr_in)); 203604660064SFedor Uporov fdisp_make_vp(&fdi, FUSE_GETXATTR, vp, td, cred); 203704660064SFedor Uporov 203804660064SFedor Uporov get_xattr_in = fdi.indata; 203904660064SFedor Uporov /* 204004660064SFedor Uporov * Check to see whether we're querying the available size or 204104660064SFedor Uporov * issuing the actual request. If we pass in 0, we get back struct 204204660064SFedor Uporov * fuse_getxattr_out. If we pass in a non-zero size, we get back 204304660064SFedor Uporov * that much data, without the struct fuse_getxattr_out header. 204404660064SFedor Uporov */ 2045493b4a8cSFedor Uporov if (uio == NULL) 204604660064SFedor Uporov get_xattr_in->size = 0; 204704660064SFedor Uporov else 204804660064SFedor Uporov get_xattr_in->size = uio->uio_resid; 204904660064SFedor Uporov 205004660064SFedor Uporov attr_str = (char *)fdi.indata + sizeof(*get_xattr_in); 205104660064SFedor Uporov snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator, 205204660064SFedor Uporov ap->a_name); 205304660064SFedor Uporov 205404660064SFedor Uporov err = fdisp_wait_answ(&fdi); 205504660064SFedor Uporov if (err != 0) { 20561f4a83f9SAlan Somers if (err == ENOSYS) { 205704660064SFedor Uporov fsess_set_notimpl(mp, FUSE_GETXATTR); 20581f4a83f9SAlan Somers err = EOPNOTSUPP; 20591f4a83f9SAlan Somers } 206004660064SFedor Uporov goto out; 206104660064SFedor Uporov } 206204660064SFedor Uporov 206304660064SFedor Uporov get_xattr_out = fdi.answ; 206404660064SFedor Uporov 2065493b4a8cSFedor Uporov if (ap->a_size != NULL) 206604660064SFedor Uporov *ap->a_size = get_xattr_out->size; 2067493b4a8cSFedor Uporov 2068493b4a8cSFedor Uporov if (uio != NULL) 206904660064SFedor Uporov err = uiomove(fdi.answ, fdi.iosize, uio); 207004660064SFedor Uporov 207104660064SFedor Uporov out: 207204660064SFedor Uporov fdisp_destroy(&fdi); 207304660064SFedor Uporov return (err); 207404660064SFedor Uporov } 207504660064SFedor Uporov 207604660064SFedor Uporov /* 207704660064SFedor Uporov struct vop_setextattr_args { 207804660064SFedor Uporov struct vop_generic_args a_gen; 207904660064SFedor Uporov struct vnode *a_vp; 208004660064SFedor Uporov int a_attrnamespace; 208104660064SFedor Uporov const char *a_name; 208204660064SFedor Uporov struct uio *a_uio; 208304660064SFedor Uporov struct ucred *a_cred; 208404660064SFedor Uporov struct thread *a_td; 208504660064SFedor Uporov }; 208604660064SFedor Uporov */ 208704660064SFedor Uporov static int 208804660064SFedor Uporov fuse_vnop_setextattr(struct vop_setextattr_args *ap) 208904660064SFedor Uporov { 209004660064SFedor Uporov struct vnode *vp = ap->a_vp; 209104660064SFedor Uporov struct uio *uio = ap->a_uio; 209228f4f623SFedor Uporov struct fuse_dispatcher fdi; 209304660064SFedor Uporov struct fuse_setxattr_in *set_xattr_in; 209404660064SFedor Uporov struct mount *mp = vnode_mount(vp); 209528f4f623SFedor Uporov struct thread *td = ap->a_td; 209628f4f623SFedor Uporov struct ucred *cred = ap->a_cred; 209704660064SFedor Uporov char *prefix; 209804660064SFedor Uporov size_t len; 209904660064SFedor Uporov char *attr_str; 210028f4f623SFedor Uporov int err; 210104660064SFedor Uporov 210204660064SFedor Uporov if (fuse_isdeadfs(vp)) 210328f4f623SFedor Uporov return (ENXIO); 210404660064SFedor Uporov 21051f4a83f9SAlan Somers if (!fsess_isimpl(mp, FUSE_SETXATTR)) 21061f4a83f9SAlan Somers return EOPNOTSUPP; 21071f4a83f9SAlan Somers 2108666f8543SAlan Somers if (vfs_isrdonly(mp)) 2109666f8543SAlan Somers return EROFS; 2110666f8543SAlan Somers 2111ff4fbdf5SAlan Somers /* Deleting xattrs must use VOP_DELETEEXTATTR instead */ 21121f4a83f9SAlan Somers if (ap->a_uio == NULL) { 21131f4a83f9SAlan Somers /* 21141f4a83f9SAlan Somers * If we got here as fallback from VOP_DELETEEXTATTR, then 21151f4a83f9SAlan Somers * return EOPNOTSUPP. 21161f4a83f9SAlan Somers */ 21171f4a83f9SAlan Somers if (!fsess_isimpl(mp, FUSE_REMOVEXATTR)) 21181f4a83f9SAlan Somers return (EOPNOTSUPP); 21191f4a83f9SAlan Somers else 2120ff4fbdf5SAlan Somers return (EINVAL); 21211f4a83f9SAlan Somers } 2122ff4fbdf5SAlan Somers 2123666f8543SAlan Somers err = fuse_extattr_check_cred(vp, ap->a_attrnamespace, cred, td, 2124666f8543SAlan Somers VWRITE); 2125ff4fbdf5SAlan Somers if (err) 2126ff4fbdf5SAlan Somers return err; 2127ff4fbdf5SAlan Somers 212804660064SFedor Uporov /* Default to looking for user attributes. */ 212904660064SFedor Uporov if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 213004660064SFedor Uporov prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 213104660064SFedor Uporov else 213204660064SFedor Uporov prefix = EXTATTR_NAMESPACE_USER_STRING; 213304660064SFedor Uporov 213404660064SFedor Uporov len = strlen(prefix) + sizeof(extattr_namespace_separator) + 213504660064SFedor Uporov strlen(ap->a_name) + 1; 213604660064SFedor Uporov 213704660064SFedor Uporov fdisp_init(&fdi, len + sizeof(*set_xattr_in) + uio->uio_resid); 213804660064SFedor Uporov fdisp_make_vp(&fdi, FUSE_SETXATTR, vp, td, cred); 213904660064SFedor Uporov 214004660064SFedor Uporov set_xattr_in = fdi.indata; 214104660064SFedor Uporov set_xattr_in->size = uio->uio_resid; 214204660064SFedor Uporov 214304660064SFedor Uporov attr_str = (char *)fdi.indata + sizeof(*set_xattr_in); 214404660064SFedor Uporov snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator, 214504660064SFedor Uporov ap->a_name); 214604660064SFedor Uporov 214704660064SFedor Uporov err = uiomove((char *)fdi.indata + sizeof(*set_xattr_in) + len, 214804660064SFedor Uporov uio->uio_resid, uio); 214904660064SFedor Uporov if (err != 0) { 215004660064SFedor Uporov goto out; 215104660064SFedor Uporov } 215204660064SFedor Uporov 215304660064SFedor Uporov err = fdisp_wait_answ(&fdi); 215404660064SFedor Uporov 21551f4a83f9SAlan Somers if (err == ENOSYS) { 215604660064SFedor Uporov fsess_set_notimpl(mp, FUSE_SETXATTR); 21571f4a83f9SAlan Somers err = EOPNOTSUPP; 215804660064SFedor Uporov } 2159f0f7fc1bSAlan Somers if (err == ERESTART) { 2160f0f7fc1bSAlan Somers /* Can't restart after calling uiomove */ 2161f0f7fc1bSAlan Somers err = EINTR; 2162f0f7fc1bSAlan Somers } 216304660064SFedor Uporov 216404660064SFedor Uporov out: 216504660064SFedor Uporov fdisp_destroy(&fdi); 216604660064SFedor Uporov return (err); 216704660064SFedor Uporov } 216804660064SFedor Uporov 216904660064SFedor Uporov /* 217004660064SFedor Uporov * The Linux / FUSE extended attribute list is simply a collection of 217104660064SFedor Uporov * NUL-terminated strings. The FreeBSD extended attribute list is a single 217204660064SFedor Uporov * byte length followed by a non-NUL terminated string. So, this allows 217304660064SFedor Uporov * conversion of the Linux / FUSE format to the FreeBSD format in place. 217404660064SFedor Uporov * Linux attribute names are reported with the namespace as a prefix (e.g. 217504660064SFedor Uporov * "user.attribute_name"), but in FreeBSD they are reported without the 217604660064SFedor Uporov * namespace prefix (e.g. "attribute_name"). So, we're going from: 217704660064SFedor Uporov * 217804660064SFedor Uporov * user.attr_name1\0user.attr_name2\0 217904660064SFedor Uporov * 218004660064SFedor Uporov * to: 218104660064SFedor Uporov * 218204660064SFedor Uporov * <num>attr_name1<num>attr_name2 218304660064SFedor Uporov * 218404660064SFedor Uporov * Where "<num>" is a single byte number of characters in the attribute name. 218504660064SFedor Uporov * 218604660064SFedor Uporov * Args: 218704660064SFedor Uporov * prefix - exattr namespace prefix string 218804660064SFedor Uporov * list, list_len - input list with namespace prefixes 218904660064SFedor Uporov * bsd_list, bsd_list_len - output list compatible with bsd vfs 219004660064SFedor Uporov */ 219104660064SFedor Uporov static int 219204660064SFedor Uporov fuse_xattrlist_convert(char *prefix, const char *list, int list_len, 219304660064SFedor Uporov char *bsd_list, int *bsd_list_len) 219404660064SFedor Uporov { 219504660064SFedor Uporov int len, pos, dist_to_next, prefix_len; 219604660064SFedor Uporov 219704660064SFedor Uporov pos = 0; 219804660064SFedor Uporov *bsd_list_len = 0; 219904660064SFedor Uporov prefix_len = strlen(prefix); 220004660064SFedor Uporov 220104660064SFedor Uporov while (pos < list_len && list[pos] != '\0') { 220204660064SFedor Uporov dist_to_next = strlen(&list[pos]) + 1; 220304660064SFedor Uporov if (bcmp(&list[pos], prefix, prefix_len) == 0 && 220404660064SFedor Uporov list[pos + prefix_len] == extattr_namespace_separator) { 220504660064SFedor Uporov len = dist_to_next - 220604660064SFedor Uporov (prefix_len + sizeof(extattr_namespace_separator)) - 1; 220704660064SFedor Uporov if (len >= EXTATTR_MAXNAMELEN) 220804660064SFedor Uporov return (ENAMETOOLONG); 220904660064SFedor Uporov 221004660064SFedor Uporov bsd_list[*bsd_list_len] = len; 221104660064SFedor Uporov memcpy(&bsd_list[*bsd_list_len + 1], 221204660064SFedor Uporov &list[pos + prefix_len + 221304660064SFedor Uporov sizeof(extattr_namespace_separator)], len); 221404660064SFedor Uporov 221504660064SFedor Uporov *bsd_list_len += len + 1; 221604660064SFedor Uporov } 221704660064SFedor Uporov 221804660064SFedor Uporov pos += dist_to_next; 221904660064SFedor Uporov } 222004660064SFedor Uporov 222104660064SFedor Uporov return (0); 222204660064SFedor Uporov } 222304660064SFedor Uporov 222404660064SFedor Uporov /* 22255e633330SAlan Somers * List extended attributes 22265e633330SAlan Somers * 22275e633330SAlan Somers * The FUSE_LISTXATTR operation is based on Linux's listxattr(2) syscall, which 22285e633330SAlan Somers * has a number of differences compared to its FreeBSD equivalent, 22295e633330SAlan Somers * extattr_list_file: 22305e633330SAlan Somers * 22315e633330SAlan Somers * - FUSE_LISTXATTR returns all extended attributes across all namespaces, 22325e633330SAlan Somers * whereas listxattr(2) only returns attributes for a single namespace 22335e633330SAlan Somers * - FUSE_LISTXATTR prepends each attribute name with "namespace." 22345e633330SAlan Somers * - If the provided buffer is not large enough to hold the result, 22355e633330SAlan Somers * FUSE_LISTXATTR should return ERANGE, whereas listxattr is expected to 22365e633330SAlan Somers * return as many results as will fit. 22375e633330SAlan Somers */ 22385e633330SAlan Somers /* 223904660064SFedor Uporov struct vop_listextattr_args { 224004660064SFedor Uporov struct vop_generic_args a_gen; 224104660064SFedor Uporov struct vnode *a_vp; 224204660064SFedor Uporov int a_attrnamespace; 224304660064SFedor Uporov struct uio *a_uio; 224404660064SFedor Uporov size_t *a_size; 224504660064SFedor Uporov struct ucred *a_cred; 224604660064SFedor Uporov struct thread *a_td; 224704660064SFedor Uporov }; 224804660064SFedor Uporov */ 224904660064SFedor Uporov static int 225004660064SFedor Uporov fuse_vnop_listextattr(struct vop_listextattr_args *ap) 225104660064SFedor Uporov { 225204660064SFedor Uporov struct vnode *vp = ap->a_vp; 225304660064SFedor Uporov struct uio *uio = ap->a_uio; 225428f4f623SFedor Uporov struct fuse_dispatcher fdi; 2255493b4a8cSFedor Uporov struct fuse_listxattr_in *list_xattr_in; 2256493b4a8cSFedor Uporov struct fuse_listxattr_out *list_xattr_out; 225704660064SFedor Uporov struct mount *mp = vnode_mount(vp); 225828f4f623SFedor Uporov struct thread *td = ap->a_td; 225928f4f623SFedor Uporov struct ucred *cred = ap->a_cred; 226004660064SFedor Uporov char *prefix; 226104660064SFedor Uporov char *bsd_list = NULL; 2262493b4a8cSFedor Uporov char *linux_list; 226304660064SFedor Uporov int bsd_list_len; 2264493b4a8cSFedor Uporov int linux_list_len; 226528f4f623SFedor Uporov int err; 226604660064SFedor Uporov 226704660064SFedor Uporov if (fuse_isdeadfs(vp)) 226828f4f623SFedor Uporov return (ENXIO); 226904660064SFedor Uporov 22701f4a83f9SAlan Somers if (!fsess_isimpl(mp, FUSE_LISTXATTR)) 22711f4a83f9SAlan Somers return EOPNOTSUPP; 22721f4a83f9SAlan Somers 2273666f8543SAlan Somers err = fuse_extattr_check_cred(vp, ap->a_attrnamespace, cred, td, VREAD); 2274ff4fbdf5SAlan Somers if (err) 2275ff4fbdf5SAlan Somers return err; 2276ff4fbdf5SAlan Somers 227704660064SFedor Uporov /* 227804660064SFedor Uporov * Add space for a NUL and the period separator if enabled. 227904660064SFedor Uporov * Default to looking for user attributes. 228004660064SFedor Uporov */ 228104660064SFedor Uporov if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 228204660064SFedor Uporov prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 228304660064SFedor Uporov else 228404660064SFedor Uporov prefix = EXTATTR_NAMESPACE_USER_STRING; 228504660064SFedor Uporov 22863a79e8e7SAlan Somers fdisp_init(&fdi, sizeof(*list_xattr_in)); 228704660064SFedor Uporov fdisp_make_vp(&fdi, FUSE_LISTXATTR, vp, td, cred); 228804660064SFedor Uporov 2289493b4a8cSFedor Uporov /* 2290493b4a8cSFedor Uporov * Retrieve Linux / FUSE compatible list size. 2291493b4a8cSFedor Uporov */ 2292493b4a8cSFedor Uporov list_xattr_in = fdi.indata; 2293493b4a8cSFedor Uporov list_xattr_in->size = 0; 229404660064SFedor Uporov 229504660064SFedor Uporov err = fdisp_wait_answ(&fdi); 229604660064SFedor Uporov if (err != 0) { 22971f4a83f9SAlan Somers if (err == ENOSYS) { 229804660064SFedor Uporov fsess_set_notimpl(mp, FUSE_LISTXATTR); 22991f4a83f9SAlan Somers err = EOPNOTSUPP; 23001f4a83f9SAlan Somers } 230104660064SFedor Uporov goto out; 230204660064SFedor Uporov } 230304660064SFedor Uporov 2304493b4a8cSFedor Uporov list_xattr_out = fdi.answ; 2305493b4a8cSFedor Uporov linux_list_len = list_xattr_out->size; 2306493b4a8cSFedor Uporov if (linux_list_len == 0) { 2307493b4a8cSFedor Uporov if (ap->a_size != NULL) 2308493b4a8cSFedor Uporov *ap->a_size = linux_list_len; 230904660064SFedor Uporov goto out; 231004660064SFedor Uporov } 231104660064SFedor Uporov 231204660064SFedor Uporov /* 2313493b4a8cSFedor Uporov * Retrieve Linux / FUSE compatible list values. 2314493b4a8cSFedor Uporov */ 231512292a99SAlan Somers fdisp_refresh_vp(&fdi, FUSE_LISTXATTR, vp, td, cred); 2316493b4a8cSFedor Uporov list_xattr_in = fdi.indata; 23175e633330SAlan Somers list_xattr_in->size = linux_list_len; 2318493b4a8cSFedor Uporov 2319493b4a8cSFedor Uporov err = fdisp_wait_answ(&fdi); 23205e633330SAlan Somers if (err == ERANGE) { 23215e633330SAlan Somers /* 23225e633330SAlan Somers * Race detected. The attribute list must've grown since the 23235e633330SAlan Somers * first FUSE_LISTXATTR call. Start over. Go all the way back 23245e633330SAlan Somers * to userland so we can process signals, if necessary, before 23255e633330SAlan Somers * restarting. 23265e633330SAlan Somers */ 23275e633330SAlan Somers err = ERESTART; 23285e633330SAlan Somers goto out; 23295e633330SAlan Somers } else if (err != 0) 2330493b4a8cSFedor Uporov goto out; 2331493b4a8cSFedor Uporov 2332493b4a8cSFedor Uporov linux_list = fdi.answ; 23335e633330SAlan Somers /* FUSE doesn't allow the server to return more data than requested */ 23345e633330SAlan Somers if (fdi.iosize > linux_list_len) { 23355e633330SAlan Somers printf("WARNING: FUSE protocol violation. Server returned " 23365e633330SAlan Somers "more extended attribute data than requested; " 23375e633330SAlan Somers "should've returned ERANGE instead"); 23385e633330SAlan Somers } else { 23395e633330SAlan Somers /* But returning less data is fine */ 2340493b4a8cSFedor Uporov linux_list_len = fdi.iosize; 23415e633330SAlan Somers } 2342493b4a8cSFedor Uporov 2343493b4a8cSFedor Uporov /* 2344493b4a8cSFedor Uporov * Retrieve the BSD compatible list values. 234504660064SFedor Uporov * The Linux / FUSE attribute list format isn't the same 234604660064SFedor Uporov * as FreeBSD's format. So we need to transform it into 234704660064SFedor Uporov * FreeBSD's format before giving it to the user. 234804660064SFedor Uporov */ 2349493b4a8cSFedor Uporov bsd_list = malloc(linux_list_len, M_TEMP, M_WAITOK); 2350493b4a8cSFedor Uporov err = fuse_xattrlist_convert(prefix, linux_list, linux_list_len, 235104660064SFedor Uporov bsd_list, &bsd_list_len); 235204660064SFedor Uporov if (err != 0) 235304660064SFedor Uporov goto out; 235404660064SFedor Uporov 2355493b4a8cSFedor Uporov if (ap->a_size != NULL) 2356493b4a8cSFedor Uporov *ap->a_size = bsd_list_len; 2357493b4a8cSFedor Uporov 2358493b4a8cSFedor Uporov if (uio != NULL) 235904660064SFedor Uporov err = uiomove(bsd_list, bsd_list_len, uio); 236004660064SFedor Uporov 236104660064SFedor Uporov out: 236204660064SFedor Uporov free(bsd_list, M_TEMP); 236304660064SFedor Uporov fdisp_destroy(&fdi); 236404660064SFedor Uporov return (err); 236504660064SFedor Uporov } 236604660064SFedor Uporov 236704660064SFedor Uporov /* 236804660064SFedor Uporov struct vop_deleteextattr_args { 236904660064SFedor Uporov struct vop_generic_args a_gen; 237004660064SFedor Uporov struct vnode *a_vp; 237104660064SFedor Uporov int a_attrnamespace; 237204660064SFedor Uporov const char *a_name; 237304660064SFedor Uporov struct ucred *a_cred; 237404660064SFedor Uporov struct thread *a_td; 237504660064SFedor Uporov }; 237604660064SFedor Uporov */ 237704660064SFedor Uporov static int 237804660064SFedor Uporov fuse_vnop_deleteextattr(struct vop_deleteextattr_args *ap) 237904660064SFedor Uporov { 238004660064SFedor Uporov struct vnode *vp = ap->a_vp; 238128f4f623SFedor Uporov struct fuse_dispatcher fdi; 238204660064SFedor Uporov struct mount *mp = vnode_mount(vp); 238328f4f623SFedor Uporov struct thread *td = ap->a_td; 238428f4f623SFedor Uporov struct ucred *cred = ap->a_cred; 238504660064SFedor Uporov char *prefix; 238604660064SFedor Uporov size_t len; 238704660064SFedor Uporov char *attr_str; 238804660064SFedor Uporov int err; 238904660064SFedor Uporov 239004660064SFedor Uporov if (fuse_isdeadfs(vp)) 239128f4f623SFedor Uporov return (ENXIO); 239204660064SFedor Uporov 23931f4a83f9SAlan Somers if (!fsess_isimpl(mp, FUSE_REMOVEXATTR)) 23941f4a83f9SAlan Somers return EOPNOTSUPP; 23951f4a83f9SAlan Somers 2396666f8543SAlan Somers if (vfs_isrdonly(mp)) 2397666f8543SAlan Somers return EROFS; 2398666f8543SAlan Somers 2399666f8543SAlan Somers err = fuse_extattr_check_cred(vp, ap->a_attrnamespace, cred, td, 2400666f8543SAlan Somers VWRITE); 2401ff4fbdf5SAlan Somers if (err) 2402ff4fbdf5SAlan Somers return err; 2403ff4fbdf5SAlan Somers 240404660064SFedor Uporov /* Default to looking for user attributes. */ 240504660064SFedor Uporov if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 240604660064SFedor Uporov prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 240704660064SFedor Uporov else 240804660064SFedor Uporov prefix = EXTATTR_NAMESPACE_USER_STRING; 240904660064SFedor Uporov 241004660064SFedor Uporov len = strlen(prefix) + sizeof(extattr_namespace_separator) + 241104660064SFedor Uporov strlen(ap->a_name) + 1; 241204660064SFedor Uporov 241304660064SFedor Uporov fdisp_init(&fdi, len); 241404660064SFedor Uporov fdisp_make_vp(&fdi, FUSE_REMOVEXATTR, vp, td, cred); 241504660064SFedor Uporov 241604660064SFedor Uporov attr_str = fdi.indata; 241704660064SFedor Uporov snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator, 241804660064SFedor Uporov ap->a_name); 241904660064SFedor Uporov 242004660064SFedor Uporov err = fdisp_wait_answ(&fdi); 24211f4a83f9SAlan Somers if (err == ENOSYS) { 242204660064SFedor Uporov fsess_set_notimpl(mp, FUSE_REMOVEXATTR); 24231f4a83f9SAlan Somers err = EOPNOTSUPP; 242404660064SFedor Uporov } 242504660064SFedor Uporov 242604660064SFedor Uporov fdisp_destroy(&fdi); 242704660064SFedor Uporov return (err); 242804660064SFedor Uporov } 242904660064SFedor Uporov 24305fe58019SAttilio Rao /* 24315fe58019SAttilio Rao struct vnop_print_args { 24325fe58019SAttilio Rao struct vnode *a_vp; 24335fe58019SAttilio Rao }; 24345fe58019SAttilio Rao */ 24355fe58019SAttilio Rao static int 24365fe58019SAttilio Rao fuse_vnop_print(struct vop_print_args *ap) 24375fe58019SAttilio Rao { 24385fe58019SAttilio Rao struct fuse_vnode_data *fvdat = VTOFUD(ap->a_vp); 24395fe58019SAttilio Rao 24405fe58019SAttilio Rao printf("nodeid: %ju, parent nodeid: %ju, nlookup: %ju, flag: %#x\n", 24415fe58019SAttilio Rao (uintmax_t)VTOILLU(ap->a_vp), (uintmax_t)fvdat->parent_nid, 24425fe58019SAttilio Rao (uintmax_t)fvdat->nlookup, 24435fe58019SAttilio Rao fvdat->flag); 24445fe58019SAttilio Rao 24455fe58019SAttilio Rao return 0; 24465fe58019SAttilio Rao } 2447e5b50fe7SAlan Somers 2448e5b50fe7SAlan Somers /* 2449e5b50fe7SAlan Somers * Get an NFS filehandle for a FUSE file. 2450e5b50fe7SAlan Somers * 2451e5b50fe7SAlan Somers * This will only work for FUSE file systems that guarantee the uniqueness of 24520d2bf489SAlan Somers * nodeid:generation, which most don't. 2453e5b50fe7SAlan Somers */ 2454e5b50fe7SAlan Somers /* 2455e5b50fe7SAlan Somers vop_vptofh { 2456e5b50fe7SAlan Somers IN struct vnode *a_vp; 2457e5b50fe7SAlan Somers IN struct fid *a_fhp; 2458e5b50fe7SAlan Somers }; 2459e5b50fe7SAlan Somers */ 2460e5b50fe7SAlan Somers static int 2461e5b50fe7SAlan Somers fuse_vnop_vptofh(struct vop_vptofh_args *ap) 2462e5b50fe7SAlan Somers { 2463e5b50fe7SAlan Somers struct vnode *vp = ap->a_vp; 2464e5b50fe7SAlan Somers struct fuse_vnode_data *fvdat = VTOFUD(vp); 2465e5b50fe7SAlan Somers struct fuse_fid *fhp = (struct fuse_fid *)(ap->a_fhp); 2466e5b50fe7SAlan Somers _Static_assert(sizeof(struct fuse_fid) <= sizeof(struct fid), 2467e5b50fe7SAlan Somers "FUSE fid type is too big"); 2468e5b50fe7SAlan Somers struct mount *mp = vnode_mount(vp); 2469e5b50fe7SAlan Somers struct fuse_data *data = fuse_get_mpdata(mp); 2470e5b50fe7SAlan Somers struct vattr va; 2471e5b50fe7SAlan Somers int err; 2472e5b50fe7SAlan Somers 2473e5b50fe7SAlan Somers if (!(data->dataflags & FSESS_EXPORT_SUPPORT)) 2474e5b50fe7SAlan Somers return EOPNOTSUPP; 2475e5b50fe7SAlan Somers 2476e5b50fe7SAlan Somers err = fuse_internal_getattr(vp, &va, curthread->td_ucred, curthread); 2477e5b50fe7SAlan Somers if (err) 2478e5b50fe7SAlan Somers return err; 2479e5b50fe7SAlan Somers 2480e5b50fe7SAlan Somers /*ip = VTOI(ap->a_vp);*/ 2481e5b50fe7SAlan Somers /*ufhp = (struct ufid *)ap->a_fhp;*/ 2482e5b50fe7SAlan Somers fhp->len = sizeof(struct fuse_fid); 2483e5b50fe7SAlan Somers fhp->nid = fvdat->nid; 2484e5b50fe7SAlan Somers if (fvdat->generation <= UINT32_MAX) 2485e5b50fe7SAlan Somers fhp->gen = fvdat->generation; 2486e5b50fe7SAlan Somers else 2487e5b50fe7SAlan Somers return EOVERFLOW; 2488e5b50fe7SAlan Somers return (0); 2489e5b50fe7SAlan Somers } 2490e5b50fe7SAlan Somers 2491e5b50fe7SAlan Somers 2492