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 * 365fe58019SAttilio Rao * Redistribution and use in source and binary forms, with or without 375fe58019SAttilio Rao * modification, are permitted provided that the following conditions 385fe58019SAttilio Rao * are met: 395fe58019SAttilio Rao * 1. Redistributions of source code must retain the above copyright 405fe58019SAttilio Rao * notice, this list of conditions and the following disclaimer. 415fe58019SAttilio Rao * 2. Redistributions in binary form must reproduce the above copyright 425fe58019SAttilio Rao * notice, this list of conditions and the following disclaimer in the 435fe58019SAttilio Rao * documentation and/or other materials provided with the distribution. 445fe58019SAttilio Rao * 455fe58019SAttilio Rao * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND 465fe58019SAttilio Rao * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 475fe58019SAttilio Rao * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 485fe58019SAttilio Rao * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 495fe58019SAttilio Rao * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 505fe58019SAttilio Rao * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 515fe58019SAttilio Rao * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 525fe58019SAttilio Rao * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 535fe58019SAttilio Rao * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 545fe58019SAttilio Rao * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 555fe58019SAttilio Rao * SUCH DAMAGE. 565fe58019SAttilio Rao */ 575fe58019SAttilio Rao 585fe58019SAttilio Rao #include <sys/cdefs.h> 595fe58019SAttilio Rao __FBSDID("$FreeBSD$"); 605fe58019SAttilio Rao 61cf169498SAlan Somers #include <sys/param.h> 625fe58019SAttilio Rao #include <sys/module.h> 635fe58019SAttilio Rao #include <sys/systm.h> 645fe58019SAttilio Rao #include <sys/errno.h> 655fe58019SAttilio Rao #include <sys/kernel.h> 665fe58019SAttilio Rao #include <sys/conf.h> 675fe58019SAttilio Rao #include <sys/uio.h> 685fe58019SAttilio Rao #include <sys/malloc.h> 695fe58019SAttilio Rao #include <sys/queue.h> 70*91898857SMark Johnston #include <sys/limits.h> 715fe58019SAttilio Rao #include <sys/lock.h> 7289f6b863SAttilio Rao #include <sys/rwlock.h> 735fe58019SAttilio Rao #include <sys/sx.h> 745fe58019SAttilio Rao #include <sys/proc.h> 755fe58019SAttilio Rao #include <sys/mount.h> 765fe58019SAttilio Rao #include <sys/vnode.h> 775fe58019SAttilio Rao #include <sys/namei.h> 7804660064SFedor Uporov #include <sys/extattr.h> 795fe58019SAttilio Rao #include <sys/stat.h> 805fe58019SAttilio Rao #include <sys/unistd.h> 815fe58019SAttilio Rao #include <sys/filedesc.h> 825fe58019SAttilio Rao #include <sys/file.h> 835fe58019SAttilio Rao #include <sys/fcntl.h> 845fe58019SAttilio Rao #include <sys/dirent.h> 855fe58019SAttilio Rao #include <sys/bio.h> 865fe58019SAttilio Rao #include <sys/buf.h> 875fe58019SAttilio Rao #include <sys/sysctl.h> 88ca148cdaSGleb Smirnoff #include <sys/vmmeter.h> 895fe58019SAttilio Rao 905fe58019SAttilio Rao #include <vm/vm.h> 915fe58019SAttilio Rao #include <vm/vm_extern.h> 925fe58019SAttilio Rao #include <vm/pmap.h> 935fe58019SAttilio Rao #include <vm/vm_map.h> 945fe58019SAttilio Rao #include <vm/vm_page.h> 955fe58019SAttilio Rao #include <vm/vm_param.h> 965fe58019SAttilio Rao #include <vm/vm_object.h> 975fe58019SAttilio Rao #include <vm/vm_pager.h> 985fe58019SAttilio Rao #include <vm/vnode_pager.h> 995fe58019SAttilio Rao #include <vm/vm_object.h> 1005fe58019SAttilio Rao 1015fe58019SAttilio Rao #include "fuse.h" 1025fe58019SAttilio Rao #include "fuse_file.h" 1035fe58019SAttilio Rao #include "fuse_internal.h" 1045fe58019SAttilio Rao #include "fuse_ipc.h" 1055fe58019SAttilio Rao #include "fuse_node.h" 1065fe58019SAttilio Rao #include "fuse_param.h" 1075fe58019SAttilio Rao #include "fuse_io.h" 1085fe58019SAttilio Rao 1095fe58019SAttilio Rao #include <sys/priv.h> 1105fe58019SAttilio Rao 111cf169498SAlan Somers SDT_PROVIDER_DECLARE(fuse); 112cf169498SAlan Somers /* 113cf169498SAlan Somers * Fuse trace probe: 114cf169498SAlan Somers * arg0: verbosity. Higher numbers give more verbose messages 115cf169498SAlan Somers * arg1: Textual message 116cf169498SAlan Somers */ 117cf169498SAlan Somers SDT_PROBE_DEFINE2(fuse, , vnops, trace, "int", "char*"); 1185fe58019SAttilio Rao 1195fe58019SAttilio Rao /* vnode ops */ 1205fe58019SAttilio Rao static vop_access_t fuse_vnop_access; 1215fe58019SAttilio Rao static vop_close_t fuse_vnop_close; 1225fe58019SAttilio Rao static vop_create_t fuse_vnop_create; 12304660064SFedor Uporov static vop_deleteextattr_t fuse_vnop_deleteextattr; 1245fe58019SAttilio Rao static vop_fsync_t fuse_vnop_fsync; 1255fe58019SAttilio Rao static vop_getattr_t fuse_vnop_getattr; 12604660064SFedor Uporov static vop_getextattr_t fuse_vnop_getextattr; 1275fe58019SAttilio Rao static vop_inactive_t fuse_vnop_inactive; 1285fe58019SAttilio Rao static vop_link_t fuse_vnop_link; 12904660064SFedor Uporov static vop_listextattr_t fuse_vnop_listextattr; 1305fe58019SAttilio Rao static vop_lookup_t fuse_vnop_lookup; 1315fe58019SAttilio Rao static vop_mkdir_t fuse_vnop_mkdir; 1325fe58019SAttilio Rao static vop_mknod_t fuse_vnop_mknod; 1335fe58019SAttilio Rao static vop_open_t fuse_vnop_open; 134746c92e0SJohn Baldwin static vop_pathconf_t fuse_vnop_pathconf; 1355fe58019SAttilio Rao static vop_read_t fuse_vnop_read; 1365fe58019SAttilio Rao static vop_readdir_t fuse_vnop_readdir; 1375fe58019SAttilio Rao static vop_readlink_t fuse_vnop_readlink; 1385fe58019SAttilio Rao static vop_reclaim_t fuse_vnop_reclaim; 1395fe58019SAttilio Rao static vop_remove_t fuse_vnop_remove; 1405fe58019SAttilio Rao static vop_rename_t fuse_vnop_rename; 1415fe58019SAttilio Rao static vop_rmdir_t fuse_vnop_rmdir; 1425fe58019SAttilio Rao static vop_setattr_t fuse_vnop_setattr; 14304660064SFedor Uporov static vop_setextattr_t fuse_vnop_setextattr; 1445fe58019SAttilio Rao static vop_strategy_t fuse_vnop_strategy; 1455fe58019SAttilio Rao static vop_symlink_t fuse_vnop_symlink; 1465fe58019SAttilio Rao static vop_write_t fuse_vnop_write; 1475fe58019SAttilio Rao static vop_getpages_t fuse_vnop_getpages; 1485fe58019SAttilio Rao static vop_putpages_t fuse_vnop_putpages; 1495fe58019SAttilio Rao static vop_print_t fuse_vnop_print; 1505fe58019SAttilio Rao 1515fe58019SAttilio Rao struct vop_vector fuse_vnops = { 1525fe58019SAttilio Rao .vop_default = &default_vnodeops, 1535fe58019SAttilio Rao .vop_access = fuse_vnop_access, 1545fe58019SAttilio Rao .vop_close = fuse_vnop_close, 1555fe58019SAttilio Rao .vop_create = fuse_vnop_create, 15604660064SFedor Uporov .vop_deleteextattr = fuse_vnop_deleteextattr, 1575fe58019SAttilio Rao .vop_fsync = fuse_vnop_fsync, 1585fe58019SAttilio Rao .vop_getattr = fuse_vnop_getattr, 15904660064SFedor Uporov .vop_getextattr = fuse_vnop_getextattr, 1605fe58019SAttilio Rao .vop_inactive = fuse_vnop_inactive, 1615fe58019SAttilio Rao .vop_link = fuse_vnop_link, 16204660064SFedor Uporov .vop_listextattr = fuse_vnop_listextattr, 1635fe58019SAttilio Rao .vop_lookup = fuse_vnop_lookup, 1645fe58019SAttilio Rao .vop_mkdir = fuse_vnop_mkdir, 1655fe58019SAttilio Rao .vop_mknod = fuse_vnop_mknod, 1665fe58019SAttilio Rao .vop_open = fuse_vnop_open, 167746c92e0SJohn Baldwin .vop_pathconf = fuse_vnop_pathconf, 1685fe58019SAttilio Rao .vop_read = fuse_vnop_read, 1695fe58019SAttilio Rao .vop_readdir = fuse_vnop_readdir, 1705fe58019SAttilio Rao .vop_readlink = fuse_vnop_readlink, 1715fe58019SAttilio Rao .vop_reclaim = fuse_vnop_reclaim, 1725fe58019SAttilio Rao .vop_remove = fuse_vnop_remove, 1735fe58019SAttilio Rao .vop_rename = fuse_vnop_rename, 1745fe58019SAttilio Rao .vop_rmdir = fuse_vnop_rmdir, 1755fe58019SAttilio Rao .vop_setattr = fuse_vnop_setattr, 17604660064SFedor Uporov .vop_setextattr = fuse_vnop_setextattr, 1775fe58019SAttilio Rao .vop_strategy = fuse_vnop_strategy, 1785fe58019SAttilio Rao .vop_symlink = fuse_vnop_symlink, 1795fe58019SAttilio Rao .vop_write = fuse_vnop_write, 1805fe58019SAttilio Rao .vop_getpages = fuse_vnop_getpages, 1815fe58019SAttilio Rao .vop_putpages = fuse_vnop_putpages, 1825fe58019SAttilio Rao .vop_print = fuse_vnop_print, 1835fe58019SAttilio Rao }; 1845fe58019SAttilio Rao 1855fe58019SAttilio Rao static u_long fuse_lookup_cache_hits = 0; 1865fe58019SAttilio Rao 187123af6ecSAlan Somers SYSCTL_ULONG(_vfs_fusefs, OID_AUTO, lookup_cache_hits, CTLFLAG_RD, 188bd4cb2a4SConrad Meyer &fuse_lookup_cache_hits, 0, "number of positive cache hits in lookup"); 1895fe58019SAttilio Rao 1905fe58019SAttilio Rao static u_long fuse_lookup_cache_misses = 0; 1915fe58019SAttilio Rao 192123af6ecSAlan Somers SYSCTL_ULONG(_vfs_fusefs, OID_AUTO, lookup_cache_misses, CTLFLAG_RD, 193bd4cb2a4SConrad Meyer &fuse_lookup_cache_misses, 0, "number of cache misses in lookup"); 1945fe58019SAttilio Rao 1955fe58019SAttilio Rao int fuse_lookup_cache_enable = 1; 1965fe58019SAttilio Rao 197123af6ecSAlan Somers SYSCTL_INT(_vfs_fusefs, OID_AUTO, lookup_cache_enable, CTLFLAG_RW, 198bd4cb2a4SConrad Meyer &fuse_lookup_cache_enable, 0, "if non-zero, enable lookup cache"); 1995fe58019SAttilio Rao 2005fe58019SAttilio Rao /* 2015fe58019SAttilio Rao * XXX: This feature is highly experimental and can bring to instabilities, 2025fe58019SAttilio Rao * needs revisiting before to be enabled by default. 2035fe58019SAttilio Rao */ 2045fe58019SAttilio Rao static int fuse_reclaim_revoked = 0; 2055fe58019SAttilio Rao 206123af6ecSAlan Somers SYSCTL_INT(_vfs_fusefs, OID_AUTO, reclaim_revoked, CTLFLAG_RW, 2075fe58019SAttilio Rao &fuse_reclaim_revoked, 0, ""); 2085fe58019SAttilio Rao 209756a5412SGleb Smirnoff uma_zone_t fuse_pbuf_zone; 2105fe58019SAttilio Rao 2115fe58019SAttilio Rao #define fuse_vm_page_lock(m) vm_page_lock((m)); 2125fe58019SAttilio Rao #define fuse_vm_page_unlock(m) vm_page_unlock((m)); 2135fe58019SAttilio Rao #define fuse_vm_page_lock_queues() ((void)0) 2145fe58019SAttilio Rao #define fuse_vm_page_unlock_queues() ((void)0) 2155fe58019SAttilio Rao 2165fe58019SAttilio Rao /* 2175fe58019SAttilio Rao struct vnop_access_args { 2185fe58019SAttilio Rao struct vnode *a_vp; 2195fe58019SAttilio Rao #if VOP_ACCESS_TAKES_ACCMODE_T 2205fe58019SAttilio Rao accmode_t a_accmode; 2215fe58019SAttilio Rao #else 2225fe58019SAttilio Rao int a_mode; 2235fe58019SAttilio Rao #endif 2245fe58019SAttilio Rao struct ucred *a_cred; 2255fe58019SAttilio Rao struct thread *a_td; 2265fe58019SAttilio Rao }; 2275fe58019SAttilio Rao */ 2285fe58019SAttilio Rao static int 2295fe58019SAttilio Rao fuse_vnop_access(struct vop_access_args *ap) 2305fe58019SAttilio Rao { 2315fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 2325fe58019SAttilio Rao int accmode = ap->a_accmode; 2335fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 2345fe58019SAttilio Rao 2355fe58019SAttilio Rao struct fuse_access_param facp; 2365fe58019SAttilio Rao struct fuse_data *data = fuse_get_mpdata(vnode_mount(vp)); 2375fe58019SAttilio Rao 2385fe58019SAttilio Rao int err; 2395fe58019SAttilio Rao 2405fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 2415fe58019SAttilio Rao if (vnode_isvroot(vp)) { 2425fe58019SAttilio Rao return 0; 2435fe58019SAttilio Rao } 2445fe58019SAttilio Rao return ENXIO; 2455fe58019SAttilio Rao } 2465fe58019SAttilio Rao if (!(data->dataflags & FSESS_INITED)) { 2475fe58019SAttilio Rao if (vnode_isvroot(vp)) { 248cc426dd3SMateusz Guzik if (priv_check_cred(cred, PRIV_VFS_ADMIN) || 2495fe58019SAttilio Rao (fuse_match_cred(data->daemoncred, cred) == 0)) { 2505fe58019SAttilio Rao return 0; 2515fe58019SAttilio Rao } 2525fe58019SAttilio Rao } 2535fe58019SAttilio Rao return EBADF; 2545fe58019SAttilio Rao } 2555fe58019SAttilio Rao if (vnode_islnk(vp)) { 2565fe58019SAttilio Rao return 0; 2575fe58019SAttilio Rao } 2585fe58019SAttilio Rao bzero(&facp, sizeof(facp)); 2595fe58019SAttilio Rao 2605fe58019SAttilio Rao err = fuse_internal_access(vp, accmode, &facp, ap->a_td, ap->a_cred); 2615fe58019SAttilio Rao return err; 2625fe58019SAttilio Rao } 2635fe58019SAttilio Rao 2645fe58019SAttilio Rao /* 2655fe58019SAttilio Rao struct vnop_close_args { 2665fe58019SAttilio Rao struct vnode *a_vp; 2675fe58019SAttilio Rao int a_fflag; 2685fe58019SAttilio Rao struct ucred *a_cred; 2695fe58019SAttilio Rao struct thread *a_td; 2705fe58019SAttilio Rao }; 2715fe58019SAttilio Rao */ 2725fe58019SAttilio Rao static int 2735fe58019SAttilio Rao fuse_vnop_close(struct vop_close_args *ap) 2745fe58019SAttilio Rao { 2755fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 2765fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 2775fe58019SAttilio Rao int fflag = ap->a_fflag; 2785fe58019SAttilio Rao fufh_type_t fufh_type; 2795fe58019SAttilio Rao 2805fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 2815fe58019SAttilio Rao return 0; 2825fe58019SAttilio Rao } 2835fe58019SAttilio Rao if (vnode_isdir(vp)) { 2845fe58019SAttilio Rao if (fuse_filehandle_valid(vp, FUFH_RDONLY)) { 2855fe58019SAttilio Rao fuse_filehandle_close(vp, FUFH_RDONLY, NULL, cred); 2865fe58019SAttilio Rao } 2875fe58019SAttilio Rao return 0; 2885fe58019SAttilio Rao } 2895fe58019SAttilio Rao if (fflag & IO_NDELAY) { 2905fe58019SAttilio Rao return 0; 2915fe58019SAttilio Rao } 2925fe58019SAttilio Rao fufh_type = fuse_filehandle_xlate_from_fflags(fflag); 2935fe58019SAttilio Rao 2945fe58019SAttilio Rao if (!fuse_filehandle_valid(vp, fufh_type)) { 2955fe58019SAttilio Rao int i; 2965fe58019SAttilio Rao 2975fe58019SAttilio Rao for (i = 0; i < FUFH_MAXTYPE; i++) 2985fe58019SAttilio Rao if (fuse_filehandle_valid(vp, i)) 2995fe58019SAttilio Rao break; 3005fe58019SAttilio Rao if (i == FUFH_MAXTYPE) 3015fe58019SAttilio Rao panic("FUSE: fufh type %d found to be invalid in close" 3025fe58019SAttilio Rao " (fflag=0x%x)\n", 3035fe58019SAttilio Rao fufh_type, fflag); 3045fe58019SAttilio Rao } 3055fe58019SAttilio Rao if ((VTOFUD(vp)->flag & FN_SIZECHANGE) != 0) { 3065fe58019SAttilio Rao fuse_vnode_savesize(vp, cred); 3075fe58019SAttilio Rao } 3085fe58019SAttilio Rao return 0; 3095fe58019SAttilio Rao } 3105fe58019SAttilio Rao 3115fe58019SAttilio Rao /* 3125fe58019SAttilio Rao struct vnop_create_args { 3135fe58019SAttilio Rao struct vnode *a_dvp; 3145fe58019SAttilio Rao struct vnode **a_vpp; 3155fe58019SAttilio Rao struct componentname *a_cnp; 3165fe58019SAttilio Rao struct vattr *a_vap; 3175fe58019SAttilio Rao }; 3185fe58019SAttilio Rao */ 3195fe58019SAttilio Rao static int 3205fe58019SAttilio Rao fuse_vnop_create(struct vop_create_args *ap) 3215fe58019SAttilio Rao { 3225fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 3235fe58019SAttilio Rao struct vnode **vpp = ap->a_vpp; 3245fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 3255fe58019SAttilio Rao struct vattr *vap = ap->a_vap; 3265fe58019SAttilio Rao struct thread *td = cnp->cn_thread; 3275fe58019SAttilio Rao struct ucred *cred = cnp->cn_cred; 3285fe58019SAttilio Rao 3295fe58019SAttilio Rao struct fuse_open_in *foi; 3305fe58019SAttilio Rao struct fuse_entry_out *feo; 3315fe58019SAttilio Rao struct fuse_dispatcher fdi; 3325fe58019SAttilio Rao struct fuse_dispatcher *fdip = &fdi; 3335fe58019SAttilio Rao 3345fe58019SAttilio Rao int err; 3355fe58019SAttilio Rao 3365fe58019SAttilio Rao struct mount *mp = vnode_mount(dvp); 3375fe58019SAttilio Rao uint64_t parentnid = VTOFUD(dvp)->nid; 3385fe58019SAttilio Rao mode_t mode = MAKEIMODE(vap->va_type, vap->va_mode); 3395fe58019SAttilio Rao uint64_t x_fh_id; 3405fe58019SAttilio Rao uint32_t x_open_flags; 3415fe58019SAttilio Rao 3425fe58019SAttilio Rao if (fuse_isdeadfs(dvp)) { 3435fe58019SAttilio Rao return ENXIO; 3445fe58019SAttilio Rao } 3455fe58019SAttilio Rao bzero(&fdi, sizeof(fdi)); 3465fe58019SAttilio Rao 3475fe58019SAttilio Rao /* XXX: Will we ever want devices ? */ 3485fe58019SAttilio Rao if ((vap->va_type != VREG)) { 349372b97d0SRick Macklem printf("fuse_vnop_create: unsupported va_type %d\n", 350372b97d0SRick Macklem vap->va_type); 351372b97d0SRick Macklem return (EINVAL); 3525fe58019SAttilio Rao } 3535fe58019SAttilio Rao 3545fe58019SAttilio Rao fdisp_init(fdip, sizeof(*foi) + cnp->cn_namelen + 1); 3555fe58019SAttilio Rao if (!fsess_isimpl(mp, FUSE_CREATE)) { 356cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1, 357cf169498SAlan Somers "eh, daemon doesn't implement create?"); 3585fe58019SAttilio Rao return (EINVAL); 3595fe58019SAttilio Rao } 3605fe58019SAttilio Rao fdisp_make(fdip, FUSE_CREATE, vnode_mount(dvp), parentnid, td, cred); 3615fe58019SAttilio Rao 3625fe58019SAttilio Rao foi = fdip->indata; 3635fe58019SAttilio Rao foi->mode = mode; 3645fe58019SAttilio Rao foi->flags = O_CREAT | O_RDWR; 3655fe58019SAttilio Rao 3665fe58019SAttilio Rao memcpy((char *)fdip->indata + sizeof(*foi), cnp->cn_nameptr, 3675fe58019SAttilio Rao cnp->cn_namelen); 3685fe58019SAttilio Rao ((char *)fdip->indata)[sizeof(*foi) + cnp->cn_namelen] = '\0'; 3695fe58019SAttilio Rao 3705fe58019SAttilio Rao err = fdisp_wait_answ(fdip); 3715fe58019SAttilio Rao 3726de3b00dSAttilio Rao if (err) { 3736de3b00dSAttilio Rao if (err == ENOSYS) 3745fe58019SAttilio Rao fsess_set_notimpl(mp, FUSE_CREATE); 3755fe58019SAttilio Rao goto out; 3765fe58019SAttilio Rao } 377372b97d0SRick Macklem 3785fe58019SAttilio Rao feo = fdip->answ; 3795fe58019SAttilio Rao 3805fe58019SAttilio Rao if ((err = fuse_internal_checkentry(feo, VREG))) { 3815fe58019SAttilio Rao goto out; 3825fe58019SAttilio Rao } 38309176f09SConrad Meyer err = fuse_vnode_get(mp, feo, feo->nodeid, dvp, vpp, cnp, VREG); 3845fe58019SAttilio Rao if (err) { 3855fe58019SAttilio Rao struct fuse_release_in *fri; 3865fe58019SAttilio Rao uint64_t nodeid = feo->nodeid; 3875fe58019SAttilio Rao uint64_t fh_id = ((struct fuse_open_out *)(feo + 1))->fh; 3885fe58019SAttilio Rao 3895fe58019SAttilio Rao fdisp_init(fdip, sizeof(*fri)); 3905fe58019SAttilio Rao fdisp_make(fdip, FUSE_RELEASE, mp, nodeid, td, cred); 3915fe58019SAttilio Rao fri = fdip->indata; 3925fe58019SAttilio Rao fri->fh = fh_id; 3935fe58019SAttilio Rao fri->flags = OFLAGS(mode); 3945fe58019SAttilio Rao fuse_insert_callback(fdip->tick, fuse_internal_forget_callback); 3955fe58019SAttilio Rao fuse_insert_message(fdip->tick); 3965fe58019SAttilio Rao return err; 3975fe58019SAttilio Rao } 3985fe58019SAttilio Rao ASSERT_VOP_ELOCKED(*vpp, "fuse_vnop_create"); 3995fe58019SAttilio Rao 4005fe58019SAttilio Rao fdip->answ = feo + 1; 4015fe58019SAttilio Rao 4025fe58019SAttilio Rao x_fh_id = ((struct fuse_open_out *)(feo + 1))->fh; 4035fe58019SAttilio Rao x_open_flags = ((struct fuse_open_out *)(feo + 1))->open_flags; 4045fe58019SAttilio Rao fuse_filehandle_init(*vpp, FUFH_RDWR, NULL, x_fh_id); 4055fe58019SAttilio Rao fuse_vnode_open(*vpp, x_open_flags, td); 4065fe58019SAttilio Rao cache_purge_negative(dvp); 4075fe58019SAttilio Rao 4085fe58019SAttilio Rao out: 4095fe58019SAttilio Rao fdisp_destroy(fdip); 4105fe58019SAttilio Rao return err; 4115fe58019SAttilio Rao } 4125fe58019SAttilio Rao 4135fe58019SAttilio Rao /* 4145fe58019SAttilio Rao * Our vnop_fsync roughly corresponds to the FUSE_FSYNC method. The Linux 4155fe58019SAttilio Rao * version of FUSE also has a FUSE_FLUSH method. 4165fe58019SAttilio Rao * 4175fe58019SAttilio Rao * On Linux, fsync() synchronizes a file's complete in-core state with that 4185fe58019SAttilio Rao * on disk. The call is not supposed to return until the system has completed 4195fe58019SAttilio Rao * that action or until an error is detected. 4205fe58019SAttilio Rao * 4215fe58019SAttilio Rao * Linux also has an fdatasync() call that is similar to fsync() but is not 4225fe58019SAttilio Rao * required to update the metadata such as access time and modification time. 4235fe58019SAttilio Rao */ 4245fe58019SAttilio Rao 4255fe58019SAttilio Rao /* 4265fe58019SAttilio Rao struct vnop_fsync_args { 4275fe58019SAttilio Rao struct vnodeop_desc *a_desc; 4285fe58019SAttilio Rao struct vnode * a_vp; 4295fe58019SAttilio Rao struct ucred * a_cred; 4305fe58019SAttilio Rao int a_waitfor; 4315fe58019SAttilio Rao struct thread * a_td; 4325fe58019SAttilio Rao }; 4335fe58019SAttilio Rao */ 4345fe58019SAttilio Rao static int 4355fe58019SAttilio Rao fuse_vnop_fsync(struct vop_fsync_args *ap) 4365fe58019SAttilio Rao { 4375fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 4385fe58019SAttilio Rao struct thread *td = ap->a_td; 4395fe58019SAttilio Rao 4405fe58019SAttilio Rao struct fuse_filehandle *fufh; 4415fe58019SAttilio Rao struct fuse_vnode_data *fvdat = VTOFUD(vp); 4425fe58019SAttilio Rao 4435fe58019SAttilio Rao int type, err = 0; 4445fe58019SAttilio Rao 4455fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 4465fe58019SAttilio Rao return 0; 4475fe58019SAttilio Rao } 4485fe58019SAttilio Rao if ((err = vop_stdfsync(ap))) 4495fe58019SAttilio Rao return err; 4505fe58019SAttilio Rao 4515fe58019SAttilio Rao if (!fsess_isimpl(vnode_mount(vp), 4525fe58019SAttilio Rao (vnode_vtype(vp) == VDIR ? FUSE_FSYNCDIR : FUSE_FSYNC))) { 4535fe58019SAttilio Rao goto out; 4545fe58019SAttilio Rao } 4555fe58019SAttilio Rao for (type = 0; type < FUFH_MAXTYPE; type++) { 4565fe58019SAttilio Rao fufh = &(fvdat->fufh[type]); 4575fe58019SAttilio Rao if (FUFH_IS_VALID(fufh)) { 4585fe58019SAttilio Rao fuse_internal_fsync(vp, td, NULL, fufh); 4595fe58019SAttilio Rao } 4605fe58019SAttilio Rao } 4615fe58019SAttilio Rao 4625fe58019SAttilio Rao out: 4635fe58019SAttilio Rao return 0; 4645fe58019SAttilio Rao } 4655fe58019SAttilio Rao 4665fe58019SAttilio Rao /* 4675fe58019SAttilio Rao struct vnop_getattr_args { 4685fe58019SAttilio Rao struct vnode *a_vp; 4695fe58019SAttilio Rao struct vattr *a_vap; 4705fe58019SAttilio Rao struct ucred *a_cred; 4715fe58019SAttilio Rao struct thread *a_td; 4725fe58019SAttilio Rao }; 4735fe58019SAttilio Rao */ 4745fe58019SAttilio Rao static int 4755fe58019SAttilio Rao fuse_vnop_getattr(struct vop_getattr_args *ap) 4765fe58019SAttilio Rao { 4775fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 4785fe58019SAttilio Rao struct vattr *vap = ap->a_vap; 4795fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 4805fe58019SAttilio Rao struct thread *td = curthread; 4815fe58019SAttilio Rao struct fuse_vnode_data *fvdat = VTOFUD(vp); 4827e4844f7SAlan Somers struct fuse_attr_out *fao; 4835fe58019SAttilio Rao 4845fe58019SAttilio Rao int err = 0; 4855fe58019SAttilio Rao int dataflags; 4865fe58019SAttilio Rao struct fuse_dispatcher fdi; 4875fe58019SAttilio Rao 4885fe58019SAttilio Rao dataflags = fuse_get_mpdata(vnode_mount(vp))->dataflags; 4895fe58019SAttilio Rao 4905fe58019SAttilio Rao /* Note that we are not bailing out on a dead file system just yet. */ 4915fe58019SAttilio Rao 4925fe58019SAttilio Rao if (!(dataflags & FSESS_INITED)) { 4935fe58019SAttilio Rao if (!vnode_isvroot(vp)) { 4945fe58019SAttilio Rao fdata_set_dead(fuse_get_mpdata(vnode_mount(vp))); 4955fe58019SAttilio Rao err = ENOTCONN; 4965fe58019SAttilio Rao return err; 4975fe58019SAttilio Rao } else { 4985fe58019SAttilio Rao goto fake; 4995fe58019SAttilio Rao } 5005fe58019SAttilio Rao } 5015fe58019SAttilio Rao fdisp_init(&fdi, 0); 5025fe58019SAttilio Rao if ((err = fdisp_simple_putget_vp(&fdi, FUSE_GETATTR, vp, td, cred))) { 5035fe58019SAttilio Rao if ((err == ENOTCONN) && vnode_isvroot(vp)) { 504cf169498SAlan Somers /* see comment in fuse_vfsop_statfs() */ 5055fe58019SAttilio Rao fdisp_destroy(&fdi); 5065fe58019SAttilio Rao goto fake; 5075fe58019SAttilio Rao } 5085fe58019SAttilio Rao if (err == ENOENT) { 5095fe58019SAttilio Rao fuse_internal_vnode_disappear(vp); 5105fe58019SAttilio Rao } 5115fe58019SAttilio Rao goto out; 5125fe58019SAttilio Rao } 51378a7722fSConrad Meyer 5147e4844f7SAlan Somers fao = (struct fuse_attr_out *)fdi.answ; 5157e4844f7SAlan Somers fuse_internal_cache_attrs(vp, &fao->attr, fao->attr_valid, 5167e4844f7SAlan Somers fao->attr_valid_nsec, vap); 517d9454fabSAttilio Rao if (vap->va_type != vnode_vtype(vp)) { 518d9454fabSAttilio Rao fuse_internal_vnode_disappear(vp); 519d9454fabSAttilio Rao err = ENOENT; 520d9454fabSAttilio Rao goto out; 521d9454fabSAttilio Rao } 5225fe58019SAttilio Rao if ((fvdat->flag & FN_SIZECHANGE) != 0) 5235fe58019SAttilio Rao vap->va_size = fvdat->filesize; 5245fe58019SAttilio Rao 5255fe58019SAttilio Rao if (vnode_isreg(vp) && (fvdat->flag & FN_SIZECHANGE) == 0) { 5265fe58019SAttilio Rao /* 5275fe58019SAttilio Rao * This is for those cases when the file size changed without us 5285fe58019SAttilio Rao * knowing, and we want to catch up. 5295fe58019SAttilio Rao */ 5305fe58019SAttilio Rao off_t new_filesize = ((struct fuse_attr_out *) 5315fe58019SAttilio Rao fdi.answ)->attr.size; 5325fe58019SAttilio Rao 5335fe58019SAttilio Rao if (fvdat->filesize != new_filesize) { 53465417f5eSAlan Somers fuse_vnode_setsize(vp, new_filesize); 535194e691aSConrad Meyer fvdat->flag &= ~FN_SIZECHANGE; 5365fe58019SAttilio Rao } 5375fe58019SAttilio Rao } 5385fe58019SAttilio Rao 5395fe58019SAttilio Rao out: 5405fe58019SAttilio Rao fdisp_destroy(&fdi); 5415fe58019SAttilio Rao return err; 5425fe58019SAttilio Rao 5435fe58019SAttilio Rao fake: 5445fe58019SAttilio Rao bzero(vap, sizeof(*vap)); 5455fe58019SAttilio Rao vap->va_type = vnode_vtype(vp); 5465fe58019SAttilio Rao 5475fe58019SAttilio Rao return 0; 5485fe58019SAttilio Rao } 5495fe58019SAttilio Rao 5505fe58019SAttilio Rao /* 5515fe58019SAttilio Rao struct vnop_inactive_args { 5525fe58019SAttilio Rao struct vnode *a_vp; 5535fe58019SAttilio Rao struct thread *a_td; 5545fe58019SAttilio Rao }; 5555fe58019SAttilio Rao */ 5565fe58019SAttilio Rao static int 5575fe58019SAttilio Rao fuse_vnop_inactive(struct vop_inactive_args *ap) 5585fe58019SAttilio Rao { 5595fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 5605fe58019SAttilio Rao struct thread *td = ap->a_td; 5615fe58019SAttilio Rao 5625fe58019SAttilio Rao struct fuse_vnode_data *fvdat = VTOFUD(vp); 5635fe58019SAttilio Rao struct fuse_filehandle *fufh = NULL; 5645fe58019SAttilio Rao 5655fe58019SAttilio Rao int type, need_flush = 1; 5665fe58019SAttilio Rao 5675fe58019SAttilio Rao for (type = 0; type < FUFH_MAXTYPE; type++) { 5685fe58019SAttilio Rao fufh = &(fvdat->fufh[type]); 5695fe58019SAttilio Rao if (FUFH_IS_VALID(fufh)) { 5705fe58019SAttilio Rao if (need_flush && vp->v_type == VREG) { 5715fe58019SAttilio Rao if ((VTOFUD(vp)->flag & FN_SIZECHANGE) != 0) { 5725fe58019SAttilio Rao fuse_vnode_savesize(vp, NULL); 5735fe58019SAttilio Rao } 5745fe58019SAttilio Rao if (fuse_data_cache_invalidate || 5755fe58019SAttilio Rao (fvdat->flag & FN_REVOKED) != 0) 5765fe58019SAttilio Rao fuse_io_invalbuf(vp, td); 5775fe58019SAttilio Rao else 5785fe58019SAttilio Rao fuse_io_flushbuf(vp, MNT_WAIT, td); 5795fe58019SAttilio Rao need_flush = 0; 5805fe58019SAttilio Rao } 5815fe58019SAttilio Rao fuse_filehandle_close(vp, type, td, NULL); 5825fe58019SAttilio Rao } 5835fe58019SAttilio Rao } 5845fe58019SAttilio Rao 5855fe58019SAttilio Rao if ((fvdat->flag & FN_REVOKED) != 0 && fuse_reclaim_revoked) { 5865fe58019SAttilio Rao vrecycle(vp); 5875fe58019SAttilio Rao } 5885fe58019SAttilio Rao return 0; 5895fe58019SAttilio Rao } 5905fe58019SAttilio Rao 5915fe58019SAttilio Rao /* 5925fe58019SAttilio Rao struct vnop_link_args { 5935fe58019SAttilio Rao struct vnode *a_tdvp; 5945fe58019SAttilio Rao struct vnode *a_vp; 5955fe58019SAttilio Rao struct componentname *a_cnp; 5965fe58019SAttilio Rao }; 5975fe58019SAttilio Rao */ 5985fe58019SAttilio Rao static int 5995fe58019SAttilio Rao fuse_vnop_link(struct vop_link_args *ap) 6005fe58019SAttilio Rao { 6015fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 6025fe58019SAttilio Rao struct vnode *tdvp = ap->a_tdvp; 6035fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 6045fe58019SAttilio Rao 6055fe58019SAttilio Rao struct vattr *vap = VTOVA(vp); 6065fe58019SAttilio Rao 6075fe58019SAttilio Rao struct fuse_dispatcher fdi; 6085fe58019SAttilio Rao struct fuse_entry_out *feo; 6095fe58019SAttilio Rao struct fuse_link_in fli; 6105fe58019SAttilio Rao 6115fe58019SAttilio Rao int err; 6125fe58019SAttilio Rao 6135fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 6145fe58019SAttilio Rao return ENXIO; 6155fe58019SAttilio Rao } 6165fe58019SAttilio Rao if (vnode_mount(tdvp) != vnode_mount(vp)) { 6175fe58019SAttilio Rao return EXDEV; 6185fe58019SAttilio Rao } 61978a7722fSConrad Meyer 62078a7722fSConrad Meyer /* 62178a7722fSConrad Meyer * This is a seatbelt check to protect naive userspace filesystems from 62278a7722fSConrad Meyer * themselves and the limitations of the FUSE IPC protocol. If a 62378a7722fSConrad Meyer * filesystem does not allow attribute caching, assume it is capable of 62478a7722fSConrad Meyer * validating that nlink does not overflow. 62578a7722fSConrad Meyer */ 62678a7722fSConrad Meyer if (vap != NULL && vap->va_nlink >= FUSE_LINK_MAX) 6275fe58019SAttilio Rao return EMLINK; 6285fe58019SAttilio Rao fli.oldnodeid = VTOI(vp); 6295fe58019SAttilio Rao 6305fe58019SAttilio Rao fdisp_init(&fdi, 0); 6315fe58019SAttilio Rao fuse_internal_newentry_makerequest(vnode_mount(tdvp), VTOI(tdvp), cnp, 6325fe58019SAttilio Rao FUSE_LINK, &fli, sizeof(fli), &fdi); 6335fe58019SAttilio Rao if ((err = fdisp_wait_answ(&fdi))) { 6345fe58019SAttilio Rao goto out; 6355fe58019SAttilio Rao } 6365fe58019SAttilio Rao feo = fdi.answ; 6375fe58019SAttilio Rao 6385fe58019SAttilio Rao err = fuse_internal_checkentry(feo, vnode_vtype(vp)); 6395fe58019SAttilio Rao out: 6405fe58019SAttilio Rao fdisp_destroy(&fdi); 6415fe58019SAttilio Rao return err; 6425fe58019SAttilio Rao } 6435fe58019SAttilio Rao 6445fe58019SAttilio Rao /* 6455fe58019SAttilio Rao struct vnop_lookup_args { 6465fe58019SAttilio Rao struct vnodeop_desc *a_desc; 6475fe58019SAttilio Rao struct vnode *a_dvp; 6485fe58019SAttilio Rao struct vnode **a_vpp; 6495fe58019SAttilio Rao struct componentname *a_cnp; 6505fe58019SAttilio Rao }; 6515fe58019SAttilio Rao */ 6525fe58019SAttilio Rao int 6535fe58019SAttilio Rao fuse_vnop_lookup(struct vop_lookup_args *ap) 6545fe58019SAttilio Rao { 6555fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 6565fe58019SAttilio Rao struct vnode **vpp = ap->a_vpp; 6575fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 6585fe58019SAttilio Rao struct thread *td = cnp->cn_thread; 6595fe58019SAttilio Rao struct ucred *cred = cnp->cn_cred; 6605fe58019SAttilio Rao 6615fe58019SAttilio Rao int nameiop = cnp->cn_nameiop; 6625fe58019SAttilio Rao int flags = cnp->cn_flags; 6635fe58019SAttilio Rao int wantparent = flags & (LOCKPARENT | WANTPARENT); 6645fe58019SAttilio Rao int islastcn = flags & ISLASTCN; 6655fe58019SAttilio Rao struct mount *mp = vnode_mount(dvp); 6665fe58019SAttilio Rao 6675fe58019SAttilio Rao int err = 0; 6685fe58019SAttilio Rao int lookup_err = 0; 6695fe58019SAttilio Rao struct vnode *vp = NULL; 6705fe58019SAttilio Rao 6715fe58019SAttilio Rao struct fuse_dispatcher fdi; 6725fe58019SAttilio Rao enum fuse_opcode op; 6735fe58019SAttilio Rao 6745fe58019SAttilio Rao uint64_t nid; 6755fe58019SAttilio Rao struct fuse_access_param facp; 6765fe58019SAttilio Rao 6775fe58019SAttilio Rao if (fuse_isdeadfs(dvp)) { 6785fe58019SAttilio Rao *vpp = NULL; 6795fe58019SAttilio Rao return ENXIO; 6805fe58019SAttilio Rao } 6815fe58019SAttilio Rao if (!vnode_isdir(dvp)) { 6825fe58019SAttilio Rao return ENOTDIR; 6835fe58019SAttilio Rao } 6845fe58019SAttilio Rao if (islastcn && vfs_isrdonly(mp) && (nameiop != LOOKUP)) { 6855fe58019SAttilio Rao return EROFS; 6865fe58019SAttilio Rao } 6875fe58019SAttilio Rao /* 6885fe58019SAttilio Rao * We do access check prior to doing anything else only in the case 6895fe58019SAttilio Rao * when we are at fs root (we'd like to say, "we are at the first 6905fe58019SAttilio Rao * component", but that's not exactly the same... nevermind). 6915fe58019SAttilio Rao * See further comments at further access checks. 6925fe58019SAttilio Rao */ 6935fe58019SAttilio Rao 6945fe58019SAttilio Rao bzero(&facp, sizeof(facp)); 6955fe58019SAttilio Rao if (vnode_isvroot(dvp)) { /* early permission check hack */ 6965fe58019SAttilio Rao if ((err = fuse_internal_access(dvp, VEXEC, &facp, td, cred))) { 6975fe58019SAttilio Rao return err; 6985fe58019SAttilio Rao } 6995fe58019SAttilio Rao } 7005fe58019SAttilio Rao if (flags & ISDOTDOT) { 7015fe58019SAttilio Rao nid = VTOFUD(dvp)->parent_nid; 7025fe58019SAttilio Rao if (nid == 0) { 7035fe58019SAttilio Rao return ENOENT; 7045fe58019SAttilio Rao } 7055fe58019SAttilio Rao fdisp_init(&fdi, 0); 7065fe58019SAttilio Rao op = FUSE_GETATTR; 7075fe58019SAttilio Rao goto calldaemon; 7085fe58019SAttilio Rao } else if (cnp->cn_namelen == 1 && *(cnp->cn_nameptr) == '.') { 7095fe58019SAttilio Rao nid = VTOI(dvp); 7105fe58019SAttilio Rao fdisp_init(&fdi, 0); 7115fe58019SAttilio Rao op = FUSE_GETATTR; 7125fe58019SAttilio Rao goto calldaemon; 7135fe58019SAttilio Rao } else if (fuse_lookup_cache_enable) { 7145fe58019SAttilio Rao err = cache_lookup(dvp, vpp, cnp, NULL, NULL); 7155fe58019SAttilio Rao switch (err) { 7165fe58019SAttilio Rao 7175fe58019SAttilio Rao case -1: /* positive match */ 7185fe58019SAttilio Rao atomic_add_acq_long(&fuse_lookup_cache_hits, 1); 7195fe58019SAttilio Rao return 0; 7205fe58019SAttilio Rao 7215fe58019SAttilio Rao case 0: /* no match in cache */ 7225fe58019SAttilio Rao atomic_add_acq_long(&fuse_lookup_cache_misses, 1); 7235fe58019SAttilio Rao break; 7245fe58019SAttilio Rao 7255fe58019SAttilio Rao case ENOENT: /* negative match */ 7265fe58019SAttilio Rao /* fall through */ 7275fe58019SAttilio Rao default: 7285fe58019SAttilio Rao return err; 7295fe58019SAttilio Rao } 7305fe58019SAttilio Rao } 7315fe58019SAttilio Rao nid = VTOI(dvp); 7325fe58019SAttilio Rao fdisp_init(&fdi, cnp->cn_namelen + 1); 7335fe58019SAttilio Rao op = FUSE_LOOKUP; 7345fe58019SAttilio Rao 7355fe58019SAttilio Rao calldaemon: 7365fe58019SAttilio Rao fdisp_make(&fdi, op, mp, nid, td, cred); 7375fe58019SAttilio Rao 7385fe58019SAttilio Rao if (op == FUSE_LOOKUP) { 7395fe58019SAttilio Rao memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen); 7405fe58019SAttilio Rao ((char *)fdi.indata)[cnp->cn_namelen] = '\0'; 7415fe58019SAttilio Rao } 7425fe58019SAttilio Rao lookup_err = fdisp_wait_answ(&fdi); 7435fe58019SAttilio Rao 7445fe58019SAttilio Rao if ((op == FUSE_LOOKUP) && !lookup_err) { /* lookup call succeeded */ 7455fe58019SAttilio Rao nid = ((struct fuse_entry_out *)fdi.answ)->nodeid; 7465fe58019SAttilio Rao if (!nid) { 7475fe58019SAttilio Rao /* 7485fe58019SAttilio Rao * zero nodeid is the same as "not found", 7495fe58019SAttilio Rao * but it's also cacheable (which we keep 7505fe58019SAttilio Rao * keep on doing not as of writing this) 7515fe58019SAttilio Rao */ 7525fe58019SAttilio Rao lookup_err = ENOENT; 7535fe58019SAttilio Rao } else if (nid == FUSE_ROOT_ID) { 7545fe58019SAttilio Rao lookup_err = EINVAL; 7555fe58019SAttilio Rao } 7565fe58019SAttilio Rao } 7575fe58019SAttilio Rao if (lookup_err && 7585fe58019SAttilio Rao (!fdi.answ_stat || lookup_err != ENOENT || op != FUSE_LOOKUP)) { 7595fe58019SAttilio Rao fdisp_destroy(&fdi); 7605fe58019SAttilio Rao return lookup_err; 7615fe58019SAttilio Rao } 7625fe58019SAttilio Rao /* lookup_err, if non-zero, must be ENOENT at this point */ 7635fe58019SAttilio Rao 7645fe58019SAttilio Rao if (lookup_err) { 7655fe58019SAttilio Rao 7665fe58019SAttilio Rao if ((nameiop == CREATE || nameiop == RENAME) && islastcn 7675fe58019SAttilio Rao /* && directory dvp has not been removed */ ) { 7685fe58019SAttilio Rao 7695fe58019SAttilio Rao if (vfs_isrdonly(mp)) { 7705fe58019SAttilio Rao err = EROFS; 7715fe58019SAttilio Rao goto out; 7725fe58019SAttilio Rao } 7735fe58019SAttilio Rao #if 0 /* THINK_ABOUT_THIS */ 7745fe58019SAttilio Rao if ((err = fuse_internal_access(dvp, VWRITE, cred, td, &facp))) { 7755fe58019SAttilio Rao goto out; 7765fe58019SAttilio Rao } 7775fe58019SAttilio Rao #endif 7785fe58019SAttilio Rao 7795fe58019SAttilio Rao /* 7805fe58019SAttilio Rao * Possibly record the position of a slot in the 7815fe58019SAttilio Rao * directory large enough for the new component name. 7825fe58019SAttilio Rao * This can be recorded in the vnode private data for 7835fe58019SAttilio Rao * dvp. Set the SAVENAME flag to hold onto the 7845fe58019SAttilio Rao * pathname for use later in VOP_CREATE or VOP_RENAME. 7855fe58019SAttilio Rao */ 7865fe58019SAttilio Rao cnp->cn_flags |= SAVENAME; 7875fe58019SAttilio Rao 7885fe58019SAttilio Rao err = EJUSTRETURN; 7895fe58019SAttilio Rao goto out; 7905fe58019SAttilio Rao } 7915fe58019SAttilio Rao /* Consider inserting name into cache. */ 7925fe58019SAttilio Rao 7935fe58019SAttilio Rao /* 7945fe58019SAttilio Rao * No we can't use negative caching, as the fs 7955fe58019SAttilio Rao * changes are out of our control. 7965fe58019SAttilio Rao * False positives' falseness turns out just as things 7975fe58019SAttilio Rao * go by, but false negatives' falseness doesn't. 7985fe58019SAttilio Rao * (and aiding the caching mechanism with extra control 7995fe58019SAttilio Rao * mechanisms comes quite close to beating the whole purpose 8005fe58019SAttilio Rao * caching...) 8015fe58019SAttilio Rao */ 8025fe58019SAttilio Rao #if 0 8036c21f6edSKonstantin Belousov if ((cnp->cn_flags & MAKEENTRY) != 0) { 804cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1, 805cf169498SAlan Somers "inserting NULL into cache"); 8065fe58019SAttilio Rao cache_enter(dvp, NULL, cnp); 8075fe58019SAttilio Rao } 8085fe58019SAttilio Rao #endif 8095fe58019SAttilio Rao err = ENOENT; 8105fe58019SAttilio Rao goto out; 8115fe58019SAttilio Rao 8125fe58019SAttilio Rao } else { 8135fe58019SAttilio Rao 8145fe58019SAttilio Rao /* !lookup_err */ 8155fe58019SAttilio Rao 8165fe58019SAttilio Rao struct fuse_entry_out *feo = NULL; 8175fe58019SAttilio Rao struct fuse_attr *fattr = NULL; 8185fe58019SAttilio Rao 8195fe58019SAttilio Rao if (op == FUSE_GETATTR) { 8205fe58019SAttilio Rao fattr = &((struct fuse_attr_out *)fdi.answ)->attr; 8215fe58019SAttilio Rao } else { 8225fe58019SAttilio Rao feo = (struct fuse_entry_out *)fdi.answ; 8235fe58019SAttilio Rao fattr = &(feo->attr); 8245fe58019SAttilio Rao } 8255fe58019SAttilio Rao 8265fe58019SAttilio Rao /* 8275fe58019SAttilio Rao * If deleting, and at end of pathname, return parameters 8285fe58019SAttilio Rao * which can be used to remove file. If the wantparent flag 8295fe58019SAttilio Rao * isn't set, we return only the directory, otherwise we go on 8305fe58019SAttilio Rao * and lock the inode, being careful with ".". 8315fe58019SAttilio Rao */ 8325fe58019SAttilio Rao if (nameiop == DELETE && islastcn) { 8335fe58019SAttilio Rao /* 8345fe58019SAttilio Rao * Check for write access on directory. 8355fe58019SAttilio Rao */ 8365fe58019SAttilio Rao facp.xuid = fattr->uid; 8375fe58019SAttilio Rao facp.facc_flags |= FACCESS_STICKY; 8385fe58019SAttilio Rao err = fuse_internal_access(dvp, VWRITE, &facp, td, cred); 8395fe58019SAttilio Rao facp.facc_flags &= ~FACCESS_XQUERIES; 8405fe58019SAttilio Rao 8415fe58019SAttilio Rao if (err) { 8425fe58019SAttilio Rao goto out; 8435fe58019SAttilio Rao } 8445fe58019SAttilio Rao if (nid == VTOI(dvp)) { 8455fe58019SAttilio Rao vref(dvp); 8465fe58019SAttilio Rao *vpp = dvp; 8475fe58019SAttilio Rao } else { 84809176f09SConrad Meyer err = fuse_vnode_get(dvp->v_mount, feo, nid, 84909176f09SConrad Meyer dvp, &vp, cnp, IFTOVT(fattr->mode)); 8505fe58019SAttilio Rao if (err) 8515fe58019SAttilio Rao goto out; 8525fe58019SAttilio Rao *vpp = vp; 8535fe58019SAttilio Rao } 8545fe58019SAttilio Rao 8555fe58019SAttilio Rao /* 8565fe58019SAttilio Rao * Save the name for use in VOP_RMDIR and VOP_REMOVE 8575fe58019SAttilio Rao * later. 8585fe58019SAttilio Rao */ 8595fe58019SAttilio Rao cnp->cn_flags |= SAVENAME; 8605fe58019SAttilio Rao goto out; 8615fe58019SAttilio Rao 8625fe58019SAttilio Rao } 8635fe58019SAttilio Rao /* 8645fe58019SAttilio Rao * If rewriting (RENAME), return the inode and the 8655fe58019SAttilio Rao * information required to rewrite the present directory 8665fe58019SAttilio Rao * Must get inode of directory entry to verify it's a 8675fe58019SAttilio Rao * regular file, or empty directory. 8685fe58019SAttilio Rao */ 8695fe58019SAttilio Rao if (nameiop == RENAME && wantparent && islastcn) { 8705fe58019SAttilio Rao 8715fe58019SAttilio Rao #if 0 /* THINK_ABOUT_THIS */ 8725fe58019SAttilio Rao if ((err = fuse_internal_access(dvp, VWRITE, cred, td, &facp))) { 8735fe58019SAttilio Rao goto out; 8745fe58019SAttilio Rao } 8755fe58019SAttilio Rao #endif 8765fe58019SAttilio Rao 8775fe58019SAttilio Rao /* 8785fe58019SAttilio Rao * Check for "." 8795fe58019SAttilio Rao */ 8805fe58019SAttilio Rao if (nid == VTOI(dvp)) { 8815fe58019SAttilio Rao err = EISDIR; 8825fe58019SAttilio Rao goto out; 8835fe58019SAttilio Rao } 88409176f09SConrad Meyer err = fuse_vnode_get(vnode_mount(dvp), feo, nid, dvp, 88509176f09SConrad Meyer &vp, cnp, IFTOVT(fattr->mode)); 8865fe58019SAttilio Rao if (err) { 8875fe58019SAttilio Rao goto out; 8885fe58019SAttilio Rao } 8895fe58019SAttilio Rao *vpp = vp; 8905fe58019SAttilio Rao /* 8915fe58019SAttilio Rao * Save the name for use in VOP_RENAME later. 8925fe58019SAttilio Rao */ 8935fe58019SAttilio Rao cnp->cn_flags |= SAVENAME; 8945fe58019SAttilio Rao 8955fe58019SAttilio Rao goto out; 8965fe58019SAttilio Rao } 8975fe58019SAttilio Rao if (flags & ISDOTDOT) { 8985fe58019SAttilio Rao struct mount *mp; 8995fe58019SAttilio Rao int ltype; 9005fe58019SAttilio Rao 9015fe58019SAttilio Rao /* 9025fe58019SAttilio Rao * Expanded copy of vn_vget_ino() so that 9035fe58019SAttilio Rao * fuse_vnode_get() can be used. 9045fe58019SAttilio Rao */ 9055fe58019SAttilio Rao mp = dvp->v_mount; 9065fe58019SAttilio Rao ltype = VOP_ISLOCKED(dvp); 9075fe58019SAttilio Rao err = vfs_busy(mp, MBF_NOWAIT); 9085fe58019SAttilio Rao if (err != 0) { 9095fe58019SAttilio Rao vfs_ref(mp); 9105fe58019SAttilio Rao VOP_UNLOCK(dvp, 0); 9115fe58019SAttilio Rao err = vfs_busy(mp, 0); 9125fe58019SAttilio Rao vn_lock(dvp, ltype | LK_RETRY); 9135fe58019SAttilio Rao vfs_rel(mp); 9145fe58019SAttilio Rao if (err) 9155fe58019SAttilio Rao goto out; 9165fe58019SAttilio Rao if ((dvp->v_iflag & VI_DOOMED) != 0) { 9175fe58019SAttilio Rao err = ENOENT; 9185fe58019SAttilio Rao vfs_unbusy(mp); 9195fe58019SAttilio Rao goto out; 9205fe58019SAttilio Rao } 9215fe58019SAttilio Rao } 9225fe58019SAttilio Rao VOP_UNLOCK(dvp, 0); 92309176f09SConrad Meyer err = fuse_vnode_get(vnode_mount(dvp), feo, nid, NULL, 92409176f09SConrad Meyer &vp, cnp, IFTOVT(fattr->mode)); 9255fe58019SAttilio Rao vfs_unbusy(mp); 9265fe58019SAttilio Rao vn_lock(dvp, ltype | LK_RETRY); 9275fe58019SAttilio Rao if ((dvp->v_iflag & VI_DOOMED) != 0) { 9285fe58019SAttilio Rao if (err == 0) 9295fe58019SAttilio Rao vput(vp); 9305fe58019SAttilio Rao err = ENOENT; 9315fe58019SAttilio Rao } 9325fe58019SAttilio Rao if (err) 9335fe58019SAttilio Rao goto out; 9345fe58019SAttilio Rao *vpp = vp; 9355fe58019SAttilio Rao } else if (nid == VTOI(dvp)) { 9365fe58019SAttilio Rao vref(dvp); 9375fe58019SAttilio Rao *vpp = dvp; 9385fe58019SAttilio Rao } else { 9393c324b94SConrad Meyer struct fuse_vnode_data *fvdat; 9403c324b94SConrad Meyer 94109176f09SConrad Meyer err = fuse_vnode_get(vnode_mount(dvp), feo, nid, dvp, 94209176f09SConrad Meyer &vp, cnp, IFTOVT(fattr->mode)); 9435fe58019SAttilio Rao if (err) { 9445fe58019SAttilio Rao goto out; 9455fe58019SAttilio Rao } 9465fe58019SAttilio Rao fuse_vnode_setparent(vp, dvp); 9473c324b94SConrad Meyer 9483c324b94SConrad Meyer /* 9493c324b94SConrad Meyer * In the case where we are looking up a FUSE node 9503c324b94SConrad Meyer * represented by an existing cached vnode, and the 9513c324b94SConrad Meyer * true size reported by FUSE_LOOKUP doesn't match 9523c324b94SConrad Meyer * the vnode's cached size, fix the vnode cache to 9533c324b94SConrad Meyer * match the real object size. 9543c324b94SConrad Meyer * 9553c324b94SConrad Meyer * This can occur via FUSE distributed filesystems, 9563c324b94SConrad Meyer * irregular files, etc. 9573c324b94SConrad Meyer */ 9583c324b94SConrad Meyer fvdat = VTOFUD(vp); 9593c324b94SConrad Meyer if (vnode_isreg(vp) && 9603c324b94SConrad Meyer fattr->size != fvdat->filesize) { 9613c324b94SConrad Meyer /* 9623c324b94SConrad Meyer * The FN_SIZECHANGE flag reflects a dirty 9633c324b94SConrad Meyer * append. If userspace lets us know our cache 9643c324b94SConrad Meyer * is invalid, that write was lost. (Dirty 9653c324b94SConrad Meyer * writes that do not cause append are also 9663c324b94SConrad Meyer * lost, but we don't detect them here.) 9673c324b94SConrad Meyer * 9683c324b94SConrad Meyer * XXX: Maybe disable WB caching on this mount. 9693c324b94SConrad Meyer */ 9703c324b94SConrad Meyer if (fvdat->flag & FN_SIZECHANGE) 9713c324b94SConrad Meyer printf("%s: WB cache incoherent on " 9723c324b94SConrad Meyer "%s!\n", __func__, 9733c324b94SConrad Meyer vnode_mount(vp)->mnt_stat.f_mntonname); 9743c324b94SConrad Meyer 97565417f5eSAlan Somers (void)fuse_vnode_setsize(vp, fattr->size); 9763c324b94SConrad Meyer fvdat->flag &= ~FN_SIZECHANGE; 9773c324b94SConrad Meyer } 9785fe58019SAttilio Rao *vpp = vp; 9795fe58019SAttilio Rao } 9805fe58019SAttilio Rao 9815fe58019SAttilio Rao if (op == FUSE_GETATTR) { 9827e4844f7SAlan Somers struct fuse_attr_out *fao = 9837e4844f7SAlan Somers (struct fuse_attr_out*)fdi.answ; 9847e4844f7SAlan Somers fuse_internal_cache_attrs(*vpp, 9857e4844f7SAlan Somers &fao->attr, fao->attr_valid, 9867e4844f7SAlan Somers fao->attr_valid_nsec, NULL); 9875fe58019SAttilio Rao } else { 9887e4844f7SAlan Somers struct fuse_entry_out *feo = 9897e4844f7SAlan Somers (struct fuse_entry_out*)fdi.answ; 9907e4844f7SAlan Somers fuse_internal_cache_attrs(*vpp, 9917e4844f7SAlan Somers &feo->attr, feo->attr_valid, 9927e4844f7SAlan Somers feo->attr_valid_nsec, NULL); 9935fe58019SAttilio Rao } 9945fe58019SAttilio Rao 9955fe58019SAttilio Rao /* Insert name into cache if appropriate. */ 9965fe58019SAttilio Rao 9975fe58019SAttilio Rao /* 9985fe58019SAttilio Rao * Nooo, caching is evil. With caching, we can't avoid stale 9995fe58019SAttilio Rao * information taking over the playground (cached info is not 10005fe58019SAttilio Rao * just positive/negative, it does have qualitative aspects, 10015fe58019SAttilio Rao * too). And a (VOP/FUSE)_GETATTR is always thrown anyway, when 10025fe58019SAttilio Rao * walking down along cached path components, and that's not 10035fe58019SAttilio Rao * any cheaper than FUSE_LOOKUP. This might change with 10045fe58019SAttilio Rao * implementing kernel side attr caching, but... In Linux, 10055fe58019SAttilio Rao * lookup results are not cached, and the daemon is bombarded 10065fe58019SAttilio Rao * with FUSE_LOOKUPS on and on. This shows that by design, the 10075fe58019SAttilio Rao * daemon is expected to handle frequent lookup queries 10085fe58019SAttilio Rao * efficiently, do its caching in userspace, and so on. 10095fe58019SAttilio Rao * 10105fe58019SAttilio Rao * So just leave the name cache alone. 10115fe58019SAttilio Rao */ 10125fe58019SAttilio Rao 10135fe58019SAttilio Rao /* 10145fe58019SAttilio Rao * Well, now I know, Linux caches lookups, but with a 10155fe58019SAttilio Rao * timeout... So it's the same thing as attribute caching: 10165fe58019SAttilio Rao * we can deal with it when implement timeouts. 10175fe58019SAttilio Rao */ 10185fe58019SAttilio Rao #if 0 10195fe58019SAttilio Rao if (cnp->cn_flags & MAKEENTRY) { 10205fe58019SAttilio Rao cache_enter(dvp, *vpp, cnp); 10215fe58019SAttilio Rao } 10225fe58019SAttilio Rao #endif 10235fe58019SAttilio Rao } 10245fe58019SAttilio Rao out: 10255fe58019SAttilio Rao if (!lookup_err) { 10265fe58019SAttilio Rao 10275fe58019SAttilio Rao /* No lookup error; need to clean up. */ 10285fe58019SAttilio Rao 10295fe58019SAttilio Rao if (err) { /* Found inode; exit with no vnode. */ 10305fe58019SAttilio Rao if (op == FUSE_LOOKUP) { 10315fe58019SAttilio Rao fuse_internal_forget_send(vnode_mount(dvp), td, cred, 10325fe58019SAttilio Rao nid, 1); 10335fe58019SAttilio Rao } 10345fe58019SAttilio Rao fdisp_destroy(&fdi); 10355fe58019SAttilio Rao return err; 10365fe58019SAttilio Rao } else { 10375fe58019SAttilio Rao #ifndef NO_EARLY_PERM_CHECK_HACK 10385fe58019SAttilio Rao if (!islastcn) { 10395fe58019SAttilio Rao /* 10405fe58019SAttilio Rao * We have the attributes of the next item 10415fe58019SAttilio Rao * *now*, and it's a fact, and we do not 10425fe58019SAttilio Rao * have to do extra work for it (ie, beg the 10435fe58019SAttilio Rao * daemon), and it neither depends on such 10445fe58019SAttilio Rao * accidental things like attr caching. So 10455fe58019SAttilio Rao * the big idea: check credentials *now*, 10465fe58019SAttilio Rao * not at the beginning of the next call to 10475fe58019SAttilio Rao * lookup. 10485fe58019SAttilio Rao * 10495fe58019SAttilio Rao * The first item of the lookup chain (fs root) 10505fe58019SAttilio Rao * won't be checked then here, of course, as 10515fe58019SAttilio Rao * its never "the next". But go and see that 10525fe58019SAttilio Rao * the root is taken care about at the very 10535fe58019SAttilio Rao * beginning of this function. 10545fe58019SAttilio Rao * 10555fe58019SAttilio Rao * Now, given we want to do the access check 10565fe58019SAttilio Rao * this way, one might ask: so then why not 10575fe58019SAttilio Rao * do the access check just after fetching 10585fe58019SAttilio Rao * the inode and its attributes from the 10595fe58019SAttilio Rao * daemon? Why bother with producing the 10605fe58019SAttilio Rao * corresponding vnode at all if something 10615fe58019SAttilio Rao * is not OK? We know what's the deal as 10625fe58019SAttilio Rao * soon as we get those attrs... There is 10635fe58019SAttilio Rao * one bit of info though not given us by 10645fe58019SAttilio Rao * the daemon: whether his response is 1065b3a15dddSPedro F. Giffuni * authoritative or not... His response should 10665fe58019SAttilio Rao * be ignored if something is mounted over 10675fe58019SAttilio Rao * the dir in question. But that can be 10685fe58019SAttilio Rao * known only by having the vnode... 10695fe58019SAttilio Rao */ 10705fe58019SAttilio Rao int tmpvtype = vnode_vtype(*vpp); 10715fe58019SAttilio Rao 10725fe58019SAttilio Rao bzero(&facp, sizeof(facp)); 10735fe58019SAttilio Rao /*the early perm check hack */ 10745fe58019SAttilio Rao facp.facc_flags |= FACCESS_VA_VALID; 10755fe58019SAttilio Rao 10765fe58019SAttilio Rao if ((tmpvtype != VDIR) && (tmpvtype != VLNK)) { 10775fe58019SAttilio Rao err = ENOTDIR; 10785fe58019SAttilio Rao } 10795fe58019SAttilio Rao if (!err && !vnode_mountedhere(*vpp)) { 10805fe58019SAttilio Rao err = fuse_internal_access(*vpp, VEXEC, &facp, td, cred); 10815fe58019SAttilio Rao } 10825fe58019SAttilio Rao if (err) { 10835fe58019SAttilio Rao if (tmpvtype == VLNK) 1084cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1085cf169498SAlan Somers 1, "weird, permission " 1086cf169498SAlan Somers "error with a symlink?"); 10875fe58019SAttilio Rao vput(*vpp); 10885fe58019SAttilio Rao *vpp = NULL; 10895fe58019SAttilio Rao } 10905fe58019SAttilio Rao } 10915fe58019SAttilio Rao #endif 10925fe58019SAttilio Rao } 10935fe58019SAttilio Rao } 10945fe58019SAttilio Rao fdisp_destroy(&fdi); 10955fe58019SAttilio Rao 10965fe58019SAttilio Rao return err; 10975fe58019SAttilio Rao } 10985fe58019SAttilio Rao 10995fe58019SAttilio Rao /* 11005fe58019SAttilio Rao struct vnop_mkdir_args { 11015fe58019SAttilio Rao struct vnode *a_dvp; 11025fe58019SAttilio Rao struct vnode **a_vpp; 11035fe58019SAttilio Rao struct componentname *a_cnp; 11045fe58019SAttilio Rao struct vattr *a_vap; 11055fe58019SAttilio Rao }; 11065fe58019SAttilio Rao */ 11075fe58019SAttilio Rao static int 11085fe58019SAttilio Rao fuse_vnop_mkdir(struct vop_mkdir_args *ap) 11095fe58019SAttilio Rao { 11105fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 11115fe58019SAttilio Rao struct vnode **vpp = ap->a_vpp; 11125fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 11135fe58019SAttilio Rao struct vattr *vap = ap->a_vap; 11145fe58019SAttilio Rao 11155fe58019SAttilio Rao struct fuse_mkdir_in fmdi; 11165fe58019SAttilio Rao 11175fe58019SAttilio Rao if (fuse_isdeadfs(dvp)) { 11185fe58019SAttilio Rao return ENXIO; 11195fe58019SAttilio Rao } 11205fe58019SAttilio Rao fmdi.mode = MAKEIMODE(vap->va_type, vap->va_mode); 11215fe58019SAttilio Rao 1122d9454fabSAttilio Rao return (fuse_internal_newentry(dvp, vpp, cnp, FUSE_MKDIR, &fmdi, 1123d9454fabSAttilio Rao sizeof(fmdi), VDIR)); 11245fe58019SAttilio Rao } 11255fe58019SAttilio Rao 11265fe58019SAttilio Rao /* 11275fe58019SAttilio Rao struct vnop_mknod_args { 11285fe58019SAttilio Rao struct vnode *a_dvp; 11295fe58019SAttilio Rao struct vnode **a_vpp; 11305fe58019SAttilio Rao struct componentname *a_cnp; 11315fe58019SAttilio Rao struct vattr *a_vap; 11325fe58019SAttilio Rao }; 11335fe58019SAttilio Rao */ 11345fe58019SAttilio Rao static int 11355fe58019SAttilio Rao fuse_vnop_mknod(struct vop_mknod_args *ap) 11365fe58019SAttilio Rao { 11375fe58019SAttilio Rao 11385fe58019SAttilio Rao return (EINVAL); 11395fe58019SAttilio Rao } 11405fe58019SAttilio Rao 11415fe58019SAttilio Rao 11425fe58019SAttilio Rao /* 11435fe58019SAttilio Rao struct vnop_open_args { 11445fe58019SAttilio Rao struct vnode *a_vp; 11455fe58019SAttilio Rao int a_mode; 11465fe58019SAttilio Rao struct ucred *a_cred; 11475fe58019SAttilio Rao struct thread *a_td; 11485fe58019SAttilio Rao int a_fdidx; / struct file *a_fp; 11495fe58019SAttilio Rao }; 11505fe58019SAttilio Rao */ 11515fe58019SAttilio Rao static int 11525fe58019SAttilio Rao fuse_vnop_open(struct vop_open_args *ap) 11535fe58019SAttilio Rao { 11545fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 11555fe58019SAttilio Rao int mode = ap->a_mode; 11565fe58019SAttilio Rao struct thread *td = ap->a_td; 11575fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 11585fe58019SAttilio Rao 11595fe58019SAttilio Rao fufh_type_t fufh_type; 11605fe58019SAttilio Rao struct fuse_vnode_data *fvdat; 11615fe58019SAttilio Rao 11625fe58019SAttilio Rao int error, isdir = 0; 11631390cca2SRick Macklem int32_t fuse_open_flags; 11645fe58019SAttilio Rao 11655fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 11665fe58019SAttilio Rao return ENXIO; 11675fe58019SAttilio Rao } 1168e7df9886SConrad Meyer if ((mode & (FREAD | FWRITE)) == 0) 1169e7df9886SConrad Meyer return EINVAL; 1170e7df9886SConrad Meyer 11715fe58019SAttilio Rao fvdat = VTOFUD(vp); 11725fe58019SAttilio Rao 11735fe58019SAttilio Rao if (vnode_isdir(vp)) { 11745fe58019SAttilio Rao isdir = 1; 11755fe58019SAttilio Rao } 11761390cca2SRick Macklem fuse_open_flags = 0; 11775fe58019SAttilio Rao if (isdir) { 11785fe58019SAttilio Rao fufh_type = FUFH_RDONLY; 11795fe58019SAttilio Rao } else { 11805fe58019SAttilio Rao fufh_type = fuse_filehandle_xlate_from_fflags(mode); 11811390cca2SRick Macklem /* 11821390cca2SRick Macklem * For WRONLY opens, force DIRECT_IO. This is necessary 11831390cca2SRick Macklem * since writing a partial block through the buffer cache 11841390cca2SRick Macklem * will result in a read of the block and that read won't 11851390cca2SRick Macklem * be allowed by the WRONLY open. 11861390cca2SRick Macklem */ 11871390cca2SRick Macklem if (fufh_type == FUFH_WRONLY || 11881390cca2SRick Macklem (fvdat->flag & FN_DIRECTIO) != 0) 11891390cca2SRick Macklem fuse_open_flags = FOPEN_DIRECT_IO; 11905fe58019SAttilio Rao } 11915fe58019SAttilio Rao 1192e6e24456SRick Macklem if (fuse_filehandle_validrw(vp, fufh_type) != FUFH_INVALID) { 11931390cca2SRick Macklem fuse_vnode_open(vp, fuse_open_flags, td); 11945fe58019SAttilio Rao return 0; 11955fe58019SAttilio Rao } 11965fe58019SAttilio Rao error = fuse_filehandle_open(vp, fufh_type, NULL, td, cred); 11975fe58019SAttilio Rao 11985fe58019SAttilio Rao return error; 11995fe58019SAttilio Rao } 12005fe58019SAttilio Rao 1201746c92e0SJohn Baldwin static int 1202746c92e0SJohn Baldwin fuse_vnop_pathconf(struct vop_pathconf_args *ap) 1203746c92e0SJohn Baldwin { 1204746c92e0SJohn Baldwin 1205746c92e0SJohn Baldwin switch (ap->a_name) { 1206746c92e0SJohn Baldwin case _PC_FILESIZEBITS: 1207746c92e0SJohn Baldwin *ap->a_retval = 64; 1208746c92e0SJohn Baldwin return (0); 1209599afe53SJohn Baldwin case _PC_NAME_MAX: 1210599afe53SJohn Baldwin *ap->a_retval = NAME_MAX; 1211599afe53SJohn Baldwin return (0); 1212599afe53SJohn Baldwin case _PC_LINK_MAX: 1213f83f3d79SJohn Baldwin *ap->a_retval = MIN(LONG_MAX, FUSE_LINK_MAX); 1214599afe53SJohn Baldwin return (0); 1215746c92e0SJohn Baldwin case _PC_SYMLINK_MAX: 1216746c92e0SJohn Baldwin *ap->a_retval = MAXPATHLEN; 1217746c92e0SJohn Baldwin return (0); 1218746c92e0SJohn Baldwin case _PC_NO_TRUNC: 1219746c92e0SJohn Baldwin *ap->a_retval = 1; 1220746c92e0SJohn Baldwin return (0); 1221746c92e0SJohn Baldwin default: 1222746c92e0SJohn Baldwin return (vop_stdpathconf(ap)); 1223746c92e0SJohn Baldwin } 1224746c92e0SJohn Baldwin } 1225746c92e0SJohn Baldwin 12265fe58019SAttilio Rao /* 12275fe58019SAttilio Rao struct vnop_read_args { 12285fe58019SAttilio Rao struct vnode *a_vp; 12295fe58019SAttilio Rao struct uio *a_uio; 12305fe58019SAttilio Rao int a_ioflag; 12315fe58019SAttilio Rao struct ucred *a_cred; 12325fe58019SAttilio Rao }; 12335fe58019SAttilio Rao */ 12345fe58019SAttilio Rao static int 12355fe58019SAttilio Rao fuse_vnop_read(struct vop_read_args *ap) 12365fe58019SAttilio Rao { 12375fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 12385fe58019SAttilio Rao struct uio *uio = ap->a_uio; 12395fe58019SAttilio Rao int ioflag = ap->a_ioflag; 12405fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 12415fe58019SAttilio Rao 12425fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 12435fe58019SAttilio Rao return ENXIO; 12445fe58019SAttilio Rao } 1245ead063e0SEdward Tomasz Napierala 1246ead063e0SEdward Tomasz Napierala if (VTOFUD(vp)->flag & FN_DIRECTIO) { 1247ead063e0SEdward Tomasz Napierala ioflag |= IO_DIRECT; 1248ead063e0SEdward Tomasz Napierala } 1249ead063e0SEdward Tomasz Napierala 12505fe58019SAttilio Rao return fuse_io_dispatch(vp, uio, ioflag, cred); 12515fe58019SAttilio Rao } 12525fe58019SAttilio Rao 12535fe58019SAttilio Rao /* 12545fe58019SAttilio Rao struct vnop_readdir_args { 12555fe58019SAttilio Rao struct vnode *a_vp; 12565fe58019SAttilio Rao struct uio *a_uio; 12575fe58019SAttilio Rao struct ucred *a_cred; 12585fe58019SAttilio Rao int *a_eofflag; 12595fe58019SAttilio Rao int *ncookies; 12605fe58019SAttilio Rao u_long **a_cookies; 12615fe58019SAttilio Rao }; 12625fe58019SAttilio Rao */ 12635fe58019SAttilio Rao static int 12645fe58019SAttilio Rao fuse_vnop_readdir(struct vop_readdir_args *ap) 12655fe58019SAttilio Rao { 12665fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 12675fe58019SAttilio Rao struct uio *uio = ap->a_uio; 12685fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 12695fe58019SAttilio Rao 12705fe58019SAttilio Rao struct fuse_filehandle *fufh = NULL; 12715fe58019SAttilio Rao struct fuse_iov cookediov; 12725fe58019SAttilio Rao 12735fe58019SAttilio Rao int err = 0; 12745fe58019SAttilio Rao int freefufh = 0; 12755fe58019SAttilio Rao 12765fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 12775fe58019SAttilio Rao return ENXIO; 12785fe58019SAttilio Rao } 12795fe58019SAttilio Rao if ( /* XXXIP ((uio_iovcnt(uio) > 1)) || */ 12805fe58019SAttilio Rao (uio_resid(uio) < sizeof(struct dirent))) { 12815fe58019SAttilio Rao return EINVAL; 12825fe58019SAttilio Rao } 12835fe58019SAttilio Rao 12845fe58019SAttilio Rao if (!fuse_filehandle_valid(vp, FUFH_RDONLY)) { 1285cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1, 1286cf169498SAlan Somers "calling readdir() before open()"); 12875fe58019SAttilio Rao err = fuse_filehandle_open(vp, FUFH_RDONLY, &fufh, NULL, cred); 12885fe58019SAttilio Rao freefufh = 1; 12895fe58019SAttilio Rao } else { 12905fe58019SAttilio Rao err = fuse_filehandle_get(vp, FUFH_RDONLY, &fufh); 12915fe58019SAttilio Rao } 12925fe58019SAttilio Rao if (err) { 12935fe58019SAttilio Rao return (err); 12945fe58019SAttilio Rao } 12955fe58019SAttilio Rao #define DIRCOOKEDSIZE FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + MAXNAMLEN + 1) 12965fe58019SAttilio Rao fiov_init(&cookediov, DIRCOOKEDSIZE); 12975fe58019SAttilio Rao 12985fe58019SAttilio Rao err = fuse_internal_readdir(vp, uio, fufh, &cookediov); 12995fe58019SAttilio Rao 13005fe58019SAttilio Rao fiov_teardown(&cookediov); 13015fe58019SAttilio Rao if (freefufh) { 13025fe58019SAttilio Rao fuse_filehandle_close(vp, FUFH_RDONLY, NULL, cred); 13035fe58019SAttilio Rao } 13045fe58019SAttilio Rao return err; 13055fe58019SAttilio Rao } 13065fe58019SAttilio Rao 13075fe58019SAttilio Rao /* 13085fe58019SAttilio Rao struct vnop_readlink_args { 13095fe58019SAttilio Rao struct vnode *a_vp; 13105fe58019SAttilio Rao struct uio *a_uio; 13115fe58019SAttilio Rao struct ucred *a_cred; 13125fe58019SAttilio Rao }; 13135fe58019SAttilio Rao */ 13145fe58019SAttilio Rao static int 13155fe58019SAttilio Rao fuse_vnop_readlink(struct vop_readlink_args *ap) 13165fe58019SAttilio Rao { 13175fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 13185fe58019SAttilio Rao struct uio *uio = ap->a_uio; 13195fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 13205fe58019SAttilio Rao 13215fe58019SAttilio Rao struct fuse_dispatcher fdi; 13225fe58019SAttilio Rao int err; 13235fe58019SAttilio Rao 13245fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 13255fe58019SAttilio Rao return ENXIO; 13265fe58019SAttilio Rao } 13275fe58019SAttilio Rao if (!vnode_islnk(vp)) { 13285fe58019SAttilio Rao return EINVAL; 13295fe58019SAttilio Rao } 13305fe58019SAttilio Rao fdisp_init(&fdi, 0); 13315fe58019SAttilio Rao err = fdisp_simple_putget_vp(&fdi, FUSE_READLINK, vp, curthread, cred); 13325fe58019SAttilio Rao if (err) { 13335fe58019SAttilio Rao goto out; 13345fe58019SAttilio Rao } 13355fe58019SAttilio Rao if (((char *)fdi.answ)[0] == '/' && 13365fe58019SAttilio Rao fuse_get_mpdata(vnode_mount(vp))->dataflags & FSESS_PUSH_SYMLINKS_IN) { 13375fe58019SAttilio Rao char *mpth = vnode_mount(vp)->mnt_stat.f_mntonname; 13385fe58019SAttilio Rao 13395fe58019SAttilio Rao err = uiomove(mpth, strlen(mpth), uio); 13405fe58019SAttilio Rao } 13415fe58019SAttilio Rao if (!err) { 13425fe58019SAttilio Rao err = uiomove(fdi.answ, fdi.iosize, uio); 13435fe58019SAttilio Rao } 13445fe58019SAttilio Rao out: 13455fe58019SAttilio Rao fdisp_destroy(&fdi); 13465fe58019SAttilio Rao return err; 13475fe58019SAttilio Rao } 13485fe58019SAttilio Rao 13495fe58019SAttilio Rao /* 13505fe58019SAttilio Rao struct vnop_reclaim_args { 13515fe58019SAttilio Rao struct vnode *a_vp; 13525fe58019SAttilio Rao struct thread *a_td; 13535fe58019SAttilio Rao }; 13545fe58019SAttilio Rao */ 13555fe58019SAttilio Rao static int 13565fe58019SAttilio Rao fuse_vnop_reclaim(struct vop_reclaim_args *ap) 13575fe58019SAttilio Rao { 13585fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 13595fe58019SAttilio Rao struct thread *td = ap->a_td; 13605fe58019SAttilio Rao 13615fe58019SAttilio Rao struct fuse_vnode_data *fvdat = VTOFUD(vp); 13625fe58019SAttilio Rao struct fuse_filehandle *fufh = NULL; 13635fe58019SAttilio Rao 13645fe58019SAttilio Rao int type; 13655fe58019SAttilio Rao 13665fe58019SAttilio Rao if (!fvdat) { 13675fe58019SAttilio Rao panic("FUSE: no vnode data during recycling"); 13685fe58019SAttilio Rao } 13695fe58019SAttilio Rao for (type = 0; type < FUFH_MAXTYPE; type++) { 13705fe58019SAttilio Rao fufh = &(fvdat->fufh[type]); 13715fe58019SAttilio Rao if (FUFH_IS_VALID(fufh)) { 13725fe58019SAttilio Rao printf("FUSE: vnode being reclaimed but fufh (type=%d) is valid", 13735fe58019SAttilio Rao type); 13745fe58019SAttilio Rao fuse_filehandle_close(vp, type, td, NULL); 13755fe58019SAttilio Rao } 13765fe58019SAttilio Rao } 13775fe58019SAttilio Rao 13785fe58019SAttilio Rao if ((!fuse_isdeadfs(vp)) && (fvdat->nlookup)) { 13795fe58019SAttilio Rao fuse_internal_forget_send(vnode_mount(vp), td, NULL, VTOI(vp), 13805fe58019SAttilio Rao fvdat->nlookup); 13815fe58019SAttilio Rao } 13825fe58019SAttilio Rao fuse_vnode_setparent(vp, NULL); 13835fe58019SAttilio Rao cache_purge(vp); 13845fe58019SAttilio Rao vfs_hash_remove(vp); 13855fe58019SAttilio Rao vnode_destroy_vobject(vp); 13865fe58019SAttilio Rao fuse_vnode_destroy(vp); 13875fe58019SAttilio Rao 13885fe58019SAttilio Rao return 0; 13895fe58019SAttilio Rao } 13905fe58019SAttilio Rao 13915fe58019SAttilio Rao /* 13925fe58019SAttilio Rao struct vnop_remove_args { 13935fe58019SAttilio Rao struct vnode *a_dvp; 13945fe58019SAttilio Rao struct vnode *a_vp; 13955fe58019SAttilio Rao struct componentname *a_cnp; 13965fe58019SAttilio Rao }; 13975fe58019SAttilio Rao */ 13985fe58019SAttilio Rao static int 13995fe58019SAttilio Rao fuse_vnop_remove(struct vop_remove_args *ap) 14005fe58019SAttilio Rao { 14015fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 14025fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 14035fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 14045fe58019SAttilio Rao 14055fe58019SAttilio Rao int err; 14065fe58019SAttilio Rao 14075fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 14085fe58019SAttilio Rao return ENXIO; 14095fe58019SAttilio Rao } 14105fe58019SAttilio Rao if (vnode_isdir(vp)) { 14115fe58019SAttilio Rao return EPERM; 14125fe58019SAttilio Rao } 14135fe58019SAttilio Rao cache_purge(vp); 14145fe58019SAttilio Rao 14155fe58019SAttilio Rao err = fuse_internal_remove(dvp, vp, cnp, FUSE_UNLINK); 14165fe58019SAttilio Rao 1417d9454fabSAttilio Rao if (err == 0) 14185fe58019SAttilio Rao fuse_internal_vnode_disappear(vp); 14195fe58019SAttilio Rao return err; 14205fe58019SAttilio Rao } 14215fe58019SAttilio Rao 14225fe58019SAttilio Rao /* 14235fe58019SAttilio Rao struct vnop_rename_args { 14245fe58019SAttilio Rao struct vnode *a_fdvp; 14255fe58019SAttilio Rao struct vnode *a_fvp; 14265fe58019SAttilio Rao struct componentname *a_fcnp; 14275fe58019SAttilio Rao struct vnode *a_tdvp; 14285fe58019SAttilio Rao struct vnode *a_tvp; 14295fe58019SAttilio Rao struct componentname *a_tcnp; 14305fe58019SAttilio Rao }; 14315fe58019SAttilio Rao */ 14325fe58019SAttilio Rao static int 14335fe58019SAttilio Rao fuse_vnop_rename(struct vop_rename_args *ap) 14345fe58019SAttilio Rao { 14355fe58019SAttilio Rao struct vnode *fdvp = ap->a_fdvp; 14365fe58019SAttilio Rao struct vnode *fvp = ap->a_fvp; 14375fe58019SAttilio Rao struct componentname *fcnp = ap->a_fcnp; 14385fe58019SAttilio Rao struct vnode *tdvp = ap->a_tdvp; 14395fe58019SAttilio Rao struct vnode *tvp = ap->a_tvp; 14405fe58019SAttilio Rao struct componentname *tcnp = ap->a_tcnp; 14415fe58019SAttilio Rao struct fuse_data *data; 14425fe58019SAttilio Rao 14435fe58019SAttilio Rao int err = 0; 14445fe58019SAttilio Rao 14455fe58019SAttilio Rao if (fuse_isdeadfs(fdvp)) { 14465fe58019SAttilio Rao return ENXIO; 14475fe58019SAttilio Rao } 14485fe58019SAttilio Rao if (fvp->v_mount != tdvp->v_mount || 14495fe58019SAttilio Rao (tvp && fvp->v_mount != tvp->v_mount)) { 1450cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1, "cross-device rename"); 14515fe58019SAttilio Rao err = EXDEV; 14525fe58019SAttilio Rao goto out; 14535fe58019SAttilio Rao } 14545fe58019SAttilio Rao cache_purge(fvp); 14555fe58019SAttilio Rao 14565fe58019SAttilio Rao /* 14575fe58019SAttilio Rao * FUSE library is expected to check if target directory is not 14585fe58019SAttilio Rao * under the source directory in the file system tree. 14595fe58019SAttilio Rao * Linux performs this check at VFS level. 14605fe58019SAttilio Rao */ 14615fe58019SAttilio Rao data = fuse_get_mpdata(vnode_mount(tdvp)); 14625fe58019SAttilio Rao sx_xlock(&data->rename_lock); 14635fe58019SAttilio Rao err = fuse_internal_rename(fdvp, fcnp, tdvp, tcnp); 14645fe58019SAttilio Rao if (err == 0) { 1465d9454fabSAttilio Rao if (tdvp != fdvp) 14665fe58019SAttilio Rao fuse_vnode_setparent(fvp, tdvp); 14675fe58019SAttilio Rao if (tvp != NULL) 14685fe58019SAttilio Rao fuse_vnode_setparent(tvp, NULL); 14695fe58019SAttilio Rao } 14705fe58019SAttilio Rao sx_unlock(&data->rename_lock); 14715fe58019SAttilio Rao 14725fe58019SAttilio Rao if (tvp != NULL && tvp != fvp) { 14735fe58019SAttilio Rao cache_purge(tvp); 14745fe58019SAttilio Rao } 14755fe58019SAttilio Rao if (vnode_isdir(fvp)) { 14765fe58019SAttilio Rao if ((tvp != NULL) && vnode_isdir(tvp)) { 14775fe58019SAttilio Rao cache_purge(tdvp); 14785fe58019SAttilio Rao } 14795fe58019SAttilio Rao cache_purge(fdvp); 14805fe58019SAttilio Rao } 14815fe58019SAttilio Rao out: 14825fe58019SAttilio Rao if (tdvp == tvp) { 14835fe58019SAttilio Rao vrele(tdvp); 14845fe58019SAttilio Rao } else { 14855fe58019SAttilio Rao vput(tdvp); 14865fe58019SAttilio Rao } 14875fe58019SAttilio Rao if (tvp != NULL) { 14885fe58019SAttilio Rao vput(tvp); 14895fe58019SAttilio Rao } 14905fe58019SAttilio Rao vrele(fdvp); 14915fe58019SAttilio Rao vrele(fvp); 14925fe58019SAttilio Rao 14935fe58019SAttilio Rao return err; 14945fe58019SAttilio Rao } 14955fe58019SAttilio Rao 14965fe58019SAttilio Rao /* 14975fe58019SAttilio Rao struct vnop_rmdir_args { 14985fe58019SAttilio Rao struct vnode *a_dvp; 14995fe58019SAttilio Rao struct vnode *a_vp; 15005fe58019SAttilio Rao struct componentname *a_cnp; 15015fe58019SAttilio Rao } *ap; 15025fe58019SAttilio Rao */ 15035fe58019SAttilio Rao static int 15045fe58019SAttilio Rao fuse_vnop_rmdir(struct vop_rmdir_args *ap) 15055fe58019SAttilio Rao { 15065fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 15075fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 15085fe58019SAttilio Rao 15095fe58019SAttilio Rao int err; 15105fe58019SAttilio Rao 15115fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 15125fe58019SAttilio Rao return ENXIO; 15135fe58019SAttilio Rao } 15145fe58019SAttilio Rao if (VTOFUD(vp) == VTOFUD(dvp)) { 15155fe58019SAttilio Rao return EINVAL; 15165fe58019SAttilio Rao } 15175fe58019SAttilio Rao err = fuse_internal_remove(dvp, vp, ap->a_cnp, FUSE_RMDIR); 15185fe58019SAttilio Rao 1519d9454fabSAttilio Rao if (err == 0) 15205fe58019SAttilio Rao fuse_internal_vnode_disappear(vp); 15215fe58019SAttilio Rao return err; 15225fe58019SAttilio Rao } 15235fe58019SAttilio Rao 15245fe58019SAttilio Rao /* 15255fe58019SAttilio Rao struct vnop_setattr_args { 15265fe58019SAttilio Rao struct vnode *a_vp; 15275fe58019SAttilio Rao struct vattr *a_vap; 15285fe58019SAttilio Rao struct ucred *a_cred; 15295fe58019SAttilio Rao struct thread *a_td; 15305fe58019SAttilio Rao }; 15315fe58019SAttilio Rao */ 15325fe58019SAttilio Rao static int 15335fe58019SAttilio Rao fuse_vnop_setattr(struct vop_setattr_args *ap) 15345fe58019SAttilio Rao { 15355fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 15365fe58019SAttilio Rao struct vattr *vap = ap->a_vap; 15375fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 15385fe58019SAttilio Rao struct thread *td = curthread; 15395fe58019SAttilio Rao 15405fe58019SAttilio Rao struct fuse_dispatcher fdi; 15415fe58019SAttilio Rao struct fuse_setattr_in *fsai; 15425fe58019SAttilio Rao struct fuse_access_param facp; 15435fe58019SAttilio Rao 15445fe58019SAttilio Rao int err = 0; 15455fe58019SAttilio Rao enum vtype vtyp; 15465fe58019SAttilio Rao int sizechanged = 0; 15475fe58019SAttilio Rao uint64_t newsize = 0; 15485fe58019SAttilio Rao 15495fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 15505fe58019SAttilio Rao return ENXIO; 15515fe58019SAttilio Rao } 15525fe58019SAttilio Rao fdisp_init(&fdi, sizeof(*fsai)); 15535fe58019SAttilio Rao fdisp_make_vp(&fdi, FUSE_SETATTR, vp, td, cred); 15545fe58019SAttilio Rao fsai = fdi.indata; 15555fe58019SAttilio Rao fsai->valid = 0; 15565fe58019SAttilio Rao 15575fe58019SAttilio Rao bzero(&facp, sizeof(facp)); 15585fe58019SAttilio Rao 15595fe58019SAttilio Rao facp.xuid = vap->va_uid; 15605fe58019SAttilio Rao facp.xgid = vap->va_gid; 15615fe58019SAttilio Rao 15625fe58019SAttilio Rao if (vap->va_uid != (uid_t)VNOVAL) { 15635fe58019SAttilio Rao facp.facc_flags |= FACCESS_CHOWN; 15645fe58019SAttilio Rao fsai->uid = vap->va_uid; 15655fe58019SAttilio Rao fsai->valid |= FATTR_UID; 15665fe58019SAttilio Rao } 15675fe58019SAttilio Rao if (vap->va_gid != (gid_t)VNOVAL) { 15685fe58019SAttilio Rao facp.facc_flags |= FACCESS_CHOWN; 15695fe58019SAttilio Rao fsai->gid = vap->va_gid; 15705fe58019SAttilio Rao fsai->valid |= FATTR_GID; 15715fe58019SAttilio Rao } 15725fe58019SAttilio Rao if (vap->va_size != VNOVAL) { 15735fe58019SAttilio Rao 15745fe58019SAttilio Rao struct fuse_filehandle *fufh = NULL; 15755fe58019SAttilio Rao 15765fe58019SAttilio Rao /*Truncate to a new value. */ 15775fe58019SAttilio Rao fsai->size = vap->va_size; 15785fe58019SAttilio Rao sizechanged = 1; 15795fe58019SAttilio Rao newsize = vap->va_size; 15805fe58019SAttilio Rao fsai->valid |= FATTR_SIZE; 15815fe58019SAttilio Rao 15825fe58019SAttilio Rao fuse_filehandle_getrw(vp, FUFH_WRONLY, &fufh); 15835fe58019SAttilio Rao if (fufh) { 15845fe58019SAttilio Rao fsai->fh = fufh->fh_id; 15855fe58019SAttilio Rao fsai->valid |= FATTR_FH; 15865fe58019SAttilio Rao } 15875fe58019SAttilio Rao } 15885fe58019SAttilio Rao if (vap->va_atime.tv_sec != VNOVAL) { 15895fe58019SAttilio Rao fsai->atime = vap->va_atime.tv_sec; 15905fe58019SAttilio Rao fsai->atimensec = vap->va_atime.tv_nsec; 15915fe58019SAttilio Rao fsai->valid |= FATTR_ATIME; 15925fe58019SAttilio Rao } 15935fe58019SAttilio Rao if (vap->va_mtime.tv_sec != VNOVAL) { 15945fe58019SAttilio Rao fsai->mtime = vap->va_mtime.tv_sec; 15955fe58019SAttilio Rao fsai->mtimensec = vap->va_mtime.tv_nsec; 15965fe58019SAttilio Rao fsai->valid |= FATTR_MTIME; 15975fe58019SAttilio Rao } 15985fe58019SAttilio Rao if (vap->va_mode != (mode_t)VNOVAL) { 15995fe58019SAttilio Rao fsai->mode = vap->va_mode & ALLPERMS; 16005fe58019SAttilio Rao fsai->valid |= FATTR_MODE; 16015fe58019SAttilio Rao } 16025fe58019SAttilio Rao if (!fsai->valid) { 16035fe58019SAttilio Rao goto out; 16045fe58019SAttilio Rao } 16055fe58019SAttilio Rao vtyp = vnode_vtype(vp); 16065fe58019SAttilio Rao 16075fe58019SAttilio Rao if (fsai->valid & FATTR_SIZE && vtyp == VDIR) { 16085fe58019SAttilio Rao err = EISDIR; 16095fe58019SAttilio Rao goto out; 16105fe58019SAttilio Rao } 16115fe58019SAttilio Rao if (vfs_isrdonly(vnode_mount(vp)) && (fsai->valid & ~FATTR_SIZE || vtyp == VREG)) { 16125fe58019SAttilio Rao err = EROFS; 16135fe58019SAttilio Rao goto out; 16145fe58019SAttilio Rao } 16155fe58019SAttilio Rao if (fsai->valid & ~FATTR_SIZE) { 16165fe58019SAttilio Rao /*err = fuse_internal_access(vp, VADMIN, context, &facp); */ 16175fe58019SAttilio Rao /*XXX */ 16185fe58019SAttilio Rao err = 0; 16195fe58019SAttilio Rao } 16205fe58019SAttilio Rao facp.facc_flags &= ~FACCESS_XQUERIES; 16215fe58019SAttilio Rao 16225fe58019SAttilio Rao if (err && !(fsai->valid & ~(FATTR_ATIME | FATTR_MTIME)) && 16235fe58019SAttilio Rao vap->va_vaflags & VA_UTIMES_NULL) { 16245fe58019SAttilio Rao err = fuse_internal_access(vp, VWRITE, &facp, td, cred); 16255fe58019SAttilio Rao } 1626d9454fabSAttilio Rao if (err) 16275fe58019SAttilio Rao goto out; 1628d9454fabSAttilio Rao if ((err = fdisp_wait_answ(&fdi))) 16295fe58019SAttilio Rao goto out; 16305fe58019SAttilio Rao vtyp = IFTOVT(((struct fuse_attr_out *)fdi.answ)->attr.mode); 16315fe58019SAttilio Rao 16325fe58019SAttilio Rao if (vnode_vtype(vp) != vtyp) { 16335fe58019SAttilio Rao if (vnode_vtype(vp) == VNON && vtyp != VNON) { 1634cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1, "FUSE: Dang! " 1635cf169498SAlan Somers "vnode_vtype is VNON and vtype isn't."); 16365fe58019SAttilio Rao } else { 16375fe58019SAttilio Rao /* 16385fe58019SAttilio Rao * STALE vnode, ditch 16395fe58019SAttilio Rao * 1640cf169498SAlan Somers * The vnode has changed its type "behind our back". 1641cf169498SAlan Somers * There's nothing really we can do, so let us just 1642cf169498SAlan Somers * force an internal revocation and tell the caller to 1643cf169498SAlan Somers * try again, if interested. 16445fe58019SAttilio Rao */ 16455fe58019SAttilio Rao fuse_internal_vnode_disappear(vp); 16465fe58019SAttilio Rao err = EAGAIN; 16475fe58019SAttilio Rao } 16485fe58019SAttilio Rao } 16497e4844f7SAlan Somers if (err == 0) { 16507e4844f7SAlan Somers struct fuse_attr_out *fao = (struct fuse_attr_out*)fdi.answ; 16517e4844f7SAlan Somers fuse_internal_cache_attrs(vp, &fao->attr, fao->attr_valid, 16527e4844f7SAlan Somers fao->attr_valid_nsec, NULL); 16537e4844f7SAlan Somers } 1654194e691aSConrad Meyer 16555fe58019SAttilio Rao out: 16565fe58019SAttilio Rao fdisp_destroy(&fdi); 16575fe58019SAttilio Rao if (!err && sizechanged) { 165865417f5eSAlan Somers fuse_vnode_setsize(vp, newsize); 16595fe58019SAttilio Rao VTOFUD(vp)->flag &= ~FN_SIZECHANGE; 16605fe58019SAttilio Rao } 16615fe58019SAttilio Rao return err; 16625fe58019SAttilio Rao } 16635fe58019SAttilio Rao 16645fe58019SAttilio Rao /* 16655fe58019SAttilio Rao struct vnop_strategy_args { 16665fe58019SAttilio Rao struct vnode *a_vp; 16675fe58019SAttilio Rao struct buf *a_bp; 16685fe58019SAttilio Rao }; 16695fe58019SAttilio Rao */ 16705fe58019SAttilio Rao static int 16715fe58019SAttilio Rao fuse_vnop_strategy(struct vop_strategy_args *ap) 16725fe58019SAttilio Rao { 16735fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 16745fe58019SAttilio Rao struct buf *bp = ap->a_bp; 16755fe58019SAttilio Rao 16765fe58019SAttilio Rao if (!vp || fuse_isdeadfs(vp)) { 16775fe58019SAttilio Rao bp->b_ioflags |= BIO_ERROR; 16785fe58019SAttilio Rao bp->b_error = ENXIO; 16795fe58019SAttilio Rao bufdone(bp); 16805fe58019SAttilio Rao return ENXIO; 16815fe58019SAttilio Rao } 16825fe58019SAttilio Rao if (bp->b_iocmd == BIO_WRITE) 16835fe58019SAttilio Rao fuse_vnode_refreshsize(vp, NOCRED); 16845fe58019SAttilio Rao 16855fe58019SAttilio Rao (void)fuse_io_strategy(vp, bp); 16865fe58019SAttilio Rao 16875fe58019SAttilio Rao /* 16885fe58019SAttilio Rao * This is a dangerous function. If returns error, that might mean a 16895fe58019SAttilio Rao * panic. We prefer pretty much anything over being forced to panic 16905fe58019SAttilio Rao * by a malicious daemon (a demon?). So we just return 0 anyway. You 16915fe58019SAttilio Rao * should never mind this: this function has its own error 16925fe58019SAttilio Rao * propagation mechanism via the argument buffer, so 16935fe58019SAttilio Rao * not-that-melodramatic residents of the call chain still will be 16945fe58019SAttilio Rao * able to know what to do. 16955fe58019SAttilio Rao */ 16965fe58019SAttilio Rao return 0; 16975fe58019SAttilio Rao } 16985fe58019SAttilio Rao 16995fe58019SAttilio Rao 17005fe58019SAttilio Rao /* 17015fe58019SAttilio Rao struct vnop_symlink_args { 17025fe58019SAttilio Rao struct vnode *a_dvp; 17035fe58019SAttilio Rao struct vnode **a_vpp; 17045fe58019SAttilio Rao struct componentname *a_cnp; 17055fe58019SAttilio Rao struct vattr *a_vap; 17065fe58019SAttilio Rao char *a_target; 17075fe58019SAttilio Rao }; 17085fe58019SAttilio Rao */ 17095fe58019SAttilio Rao static int 17105fe58019SAttilio Rao fuse_vnop_symlink(struct vop_symlink_args *ap) 17115fe58019SAttilio Rao { 17125fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 17135fe58019SAttilio Rao struct vnode **vpp = ap->a_vpp; 17145fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 17151493c2eeSBrooks Davis const char *target = ap->a_target; 17165fe58019SAttilio Rao 17175fe58019SAttilio Rao struct fuse_dispatcher fdi; 17185fe58019SAttilio Rao 17195fe58019SAttilio Rao int err; 17205fe58019SAttilio Rao size_t len; 17215fe58019SAttilio Rao 17225fe58019SAttilio Rao if (fuse_isdeadfs(dvp)) { 17235fe58019SAttilio Rao return ENXIO; 17245fe58019SAttilio Rao } 17255fe58019SAttilio Rao /* 17265fe58019SAttilio Rao * Unlike the other creator type calls, here we have to create a message 17275fe58019SAttilio Rao * where the name of the new entry comes first, and the data describing 17285fe58019SAttilio Rao * the entry comes second. 17295fe58019SAttilio Rao * Hence we can't rely on our handy fuse_internal_newentry() routine, 17305fe58019SAttilio Rao * but put together the message manually and just call the core part. 17315fe58019SAttilio Rao */ 17325fe58019SAttilio Rao 17335fe58019SAttilio Rao len = strlen(target) + 1; 17345fe58019SAttilio Rao fdisp_init(&fdi, len + cnp->cn_namelen + 1); 17355fe58019SAttilio Rao fdisp_make_vp(&fdi, FUSE_SYMLINK, dvp, curthread, NULL); 17365fe58019SAttilio Rao 17375fe58019SAttilio Rao memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen); 17385fe58019SAttilio Rao ((char *)fdi.indata)[cnp->cn_namelen] = '\0'; 17395fe58019SAttilio Rao memcpy((char *)fdi.indata + cnp->cn_namelen + 1, target, len); 17405fe58019SAttilio Rao 17415fe58019SAttilio Rao err = fuse_internal_newentry_core(dvp, vpp, cnp, VLNK, &fdi); 17425fe58019SAttilio Rao fdisp_destroy(&fdi); 17435fe58019SAttilio Rao return err; 17445fe58019SAttilio Rao } 17455fe58019SAttilio Rao 17465fe58019SAttilio Rao /* 17475fe58019SAttilio Rao struct vnop_write_args { 17485fe58019SAttilio Rao struct vnode *a_vp; 17495fe58019SAttilio Rao struct uio *a_uio; 17505fe58019SAttilio Rao int a_ioflag; 17515fe58019SAttilio Rao struct ucred *a_cred; 17525fe58019SAttilio Rao }; 17535fe58019SAttilio Rao */ 17545fe58019SAttilio Rao static int 17555fe58019SAttilio Rao fuse_vnop_write(struct vop_write_args *ap) 17565fe58019SAttilio Rao { 17575fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 17585fe58019SAttilio Rao struct uio *uio = ap->a_uio; 17595fe58019SAttilio Rao int ioflag = ap->a_ioflag; 17605fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 17615fe58019SAttilio Rao 17625fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 17635fe58019SAttilio Rao return ENXIO; 17645fe58019SAttilio Rao } 17655fe58019SAttilio Rao fuse_vnode_refreshsize(vp, cred); 17665fe58019SAttilio Rao 1767ead063e0SEdward Tomasz Napierala if (VTOFUD(vp)->flag & FN_DIRECTIO) { 1768ead063e0SEdward Tomasz Napierala ioflag |= IO_DIRECT; 1769ead063e0SEdward Tomasz Napierala } 1770ead063e0SEdward Tomasz Napierala 17715fe58019SAttilio Rao return fuse_io_dispatch(vp, uio, ioflag, cred); 17725fe58019SAttilio Rao } 17735fe58019SAttilio Rao 1774cf169498SAlan Somers SDT_PROBE_DEFINE1(fuse, , vnops, vnop_getpages_error, "int"); 17755fe58019SAttilio Rao /* 17765fe58019SAttilio Rao struct vnop_getpages_args { 17775fe58019SAttilio Rao struct vnode *a_vp; 17785fe58019SAttilio Rao vm_page_t *a_m; 17795fe58019SAttilio Rao int a_count; 17805fe58019SAttilio Rao int a_reqpage; 17815fe58019SAttilio Rao }; 17825fe58019SAttilio Rao */ 17835fe58019SAttilio Rao static int 17845fe58019SAttilio Rao fuse_vnop_getpages(struct vop_getpages_args *ap) 17855fe58019SAttilio Rao { 17865fe58019SAttilio Rao int i, error, nextoff, size, toff, count, npages; 17875fe58019SAttilio Rao struct uio uio; 17885fe58019SAttilio Rao struct iovec iov; 17895fe58019SAttilio Rao vm_offset_t kva; 17905fe58019SAttilio Rao struct buf *bp; 17915fe58019SAttilio Rao struct vnode *vp; 17925fe58019SAttilio Rao struct thread *td; 17935fe58019SAttilio Rao struct ucred *cred; 17945fe58019SAttilio Rao vm_page_t *pages; 17955fe58019SAttilio Rao 17965fe58019SAttilio Rao vp = ap->a_vp; 17975fe58019SAttilio Rao KASSERT(vp->v_object, ("objectless vp passed to getpages")); 17985fe58019SAttilio Rao td = curthread; /* XXX */ 17995fe58019SAttilio Rao cred = curthread->td_ucred; /* XXX */ 18005fe58019SAttilio Rao pages = ap->a_m; 1801f17f88d3SGleb Smirnoff npages = ap->a_count; 18025fe58019SAttilio Rao 18035fe58019SAttilio Rao if (!fsess_opt_mmap(vnode_mount(vp))) { 1804cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1, 1805cf169498SAlan Somers "called on non-cacheable vnode??\n"); 18065fe58019SAttilio Rao return (VM_PAGER_ERROR); 18075fe58019SAttilio Rao } 18085fe58019SAttilio Rao 18095fe58019SAttilio Rao /* 1810b0cd2017SGleb Smirnoff * If the last page is partially valid, just return it and allow 1811b0cd2017SGleb Smirnoff * the pager to zero-out the blanks. Partially valid pages can 1812b0cd2017SGleb Smirnoff * only occur at the file EOF. 1813b0cd2017SGleb Smirnoff * 1814b0cd2017SGleb Smirnoff * XXXGL: is that true for FUSE, which is a local filesystem, 1815b0cd2017SGleb Smirnoff * but still somewhat disconnected from the kernel? 18165fe58019SAttilio Rao */ 181789f6b863SAttilio Rao VM_OBJECT_WLOCK(vp->v_object); 1818f17f88d3SGleb Smirnoff if (pages[npages - 1]->valid != 0 && --npages == 0) 1819f17f88d3SGleb Smirnoff goto out; 182089f6b863SAttilio Rao VM_OBJECT_WUNLOCK(vp->v_object); 18215fe58019SAttilio Rao 18225fe58019SAttilio Rao /* 18235fe58019SAttilio Rao * We use only the kva address for the buffer, but this is extremely 1824b3a15dddSPedro F. Giffuni * convenient and fast. 18255fe58019SAttilio Rao */ 1826756a5412SGleb Smirnoff bp = uma_zalloc(fuse_pbuf_zone, M_WAITOK); 18275fe58019SAttilio Rao 18285fe58019SAttilio Rao kva = (vm_offset_t)bp->b_data; 18295fe58019SAttilio Rao pmap_qenter(kva, pages, npages); 183083c9dea1SGleb Smirnoff VM_CNT_INC(v_vnodein); 183183c9dea1SGleb Smirnoff VM_CNT_ADD(v_vnodepgsin, npages); 18325fe58019SAttilio Rao 1833f17f88d3SGleb Smirnoff count = npages << PAGE_SHIFT; 18345fe58019SAttilio Rao iov.iov_base = (caddr_t)kva; 18355fe58019SAttilio Rao iov.iov_len = count; 18365fe58019SAttilio Rao uio.uio_iov = &iov; 18375fe58019SAttilio Rao uio.uio_iovcnt = 1; 18385fe58019SAttilio Rao uio.uio_offset = IDX_TO_OFF(pages[0]->pindex); 18395fe58019SAttilio Rao uio.uio_resid = count; 18405fe58019SAttilio Rao uio.uio_segflg = UIO_SYSSPACE; 18415fe58019SAttilio Rao uio.uio_rw = UIO_READ; 18425fe58019SAttilio Rao uio.uio_td = td; 18435fe58019SAttilio Rao 18445fe58019SAttilio Rao error = fuse_io_dispatch(vp, &uio, IO_DIRECT, cred); 18455fe58019SAttilio Rao pmap_qremove(kva, npages); 18465fe58019SAttilio Rao 1847756a5412SGleb Smirnoff uma_zfree(fuse_pbuf_zone, bp); 18485fe58019SAttilio Rao 18495fe58019SAttilio Rao if (error && (uio.uio_resid == count)) { 1850cf169498SAlan Somers SDT_PROBE1(fuse, , vnops, vnop_getpages_error, error); 18515fe58019SAttilio Rao return VM_PAGER_ERROR; 18525fe58019SAttilio Rao } 18535fe58019SAttilio Rao /* 18545fe58019SAttilio Rao * Calculate the number of bytes read and validate only that number 18555fe58019SAttilio Rao * of bytes. Note that due to pending writes, size may be 0. This 18565fe58019SAttilio Rao * does not mean that the remaining data is invalid! 18575fe58019SAttilio Rao */ 18585fe58019SAttilio Rao 18595fe58019SAttilio Rao size = count - uio.uio_resid; 186089f6b863SAttilio Rao VM_OBJECT_WLOCK(vp->v_object); 18615fe58019SAttilio Rao fuse_vm_page_lock_queues(); 18625fe58019SAttilio Rao for (i = 0, toff = 0; i < npages; i++, toff = nextoff) { 18635fe58019SAttilio Rao vm_page_t m; 18645fe58019SAttilio Rao 18655fe58019SAttilio Rao nextoff = toff + PAGE_SIZE; 18665fe58019SAttilio Rao m = pages[i]; 18675fe58019SAttilio Rao 18685fe58019SAttilio Rao if (nextoff <= size) { 18695fe58019SAttilio Rao /* 18705fe58019SAttilio Rao * Read operation filled an entire page 18715fe58019SAttilio Rao */ 18725fe58019SAttilio Rao m->valid = VM_PAGE_BITS_ALL; 18735fe58019SAttilio Rao KASSERT(m->dirty == 0, 18745fe58019SAttilio Rao ("fuse_getpages: page %p is dirty", m)); 18755fe58019SAttilio Rao } else if (size > toff) { 18765fe58019SAttilio Rao /* 18775fe58019SAttilio Rao * Read operation filled a partial page. 18785fe58019SAttilio Rao */ 18795fe58019SAttilio Rao m->valid = 0; 18805fe58019SAttilio Rao vm_page_set_valid_range(m, 0, size - toff); 18815fe58019SAttilio Rao KASSERT(m->dirty == 0, 18825fe58019SAttilio Rao ("fuse_getpages: page %p is dirty", m)); 18835fe58019SAttilio Rao } else { 18845fe58019SAttilio Rao /* 1885b3a15dddSPedro F. Giffuni * Read operation was short. If no error occurred 18865fe58019SAttilio Rao * we may have hit a zero-fill section. We simply 18875fe58019SAttilio Rao * leave valid set to 0. 18885fe58019SAttilio Rao */ 18895fe58019SAttilio Rao ; 18905fe58019SAttilio Rao } 18915fe58019SAttilio Rao } 18925fe58019SAttilio Rao fuse_vm_page_unlock_queues(); 1893f17f88d3SGleb Smirnoff out: 189489f6b863SAttilio Rao VM_OBJECT_WUNLOCK(vp->v_object); 1895f17f88d3SGleb Smirnoff if (ap->a_rbehind) 1896f17f88d3SGleb Smirnoff *ap->a_rbehind = 0; 1897f17f88d3SGleb Smirnoff if (ap->a_rahead) 1898f17f88d3SGleb Smirnoff *ap->a_rahead = 0; 1899f17f88d3SGleb Smirnoff return (VM_PAGER_OK); 19005fe58019SAttilio Rao } 19015fe58019SAttilio Rao 19025fe58019SAttilio Rao /* 19035fe58019SAttilio Rao struct vnop_putpages_args { 19045fe58019SAttilio Rao struct vnode *a_vp; 19055fe58019SAttilio Rao vm_page_t *a_m; 19065fe58019SAttilio Rao int a_count; 19075fe58019SAttilio Rao int a_sync; 19085fe58019SAttilio Rao int *a_rtvals; 19095fe58019SAttilio Rao vm_ooffset_t a_offset; 19105fe58019SAttilio Rao }; 19115fe58019SAttilio Rao */ 19125fe58019SAttilio Rao static int 19135fe58019SAttilio Rao fuse_vnop_putpages(struct vop_putpages_args *ap) 19145fe58019SAttilio Rao { 19155fe58019SAttilio Rao struct uio uio; 19165fe58019SAttilio Rao struct iovec iov; 19175fe58019SAttilio Rao vm_offset_t kva; 19185fe58019SAttilio Rao struct buf *bp; 19195fe58019SAttilio Rao int i, error, npages, count; 19205fe58019SAttilio Rao off_t offset; 19215fe58019SAttilio Rao int *rtvals; 19225fe58019SAttilio Rao struct vnode *vp; 19235fe58019SAttilio Rao struct thread *td; 19245fe58019SAttilio Rao struct ucred *cred; 19255fe58019SAttilio Rao vm_page_t *pages; 19265fe58019SAttilio Rao vm_ooffset_t fsize; 19275fe58019SAttilio Rao 19285fe58019SAttilio Rao vp = ap->a_vp; 19295fe58019SAttilio Rao KASSERT(vp->v_object, ("objectless vp passed to putpages")); 19305fe58019SAttilio Rao fsize = vp->v_object->un_pager.vnp.vnp_size; 19315fe58019SAttilio Rao td = curthread; /* XXX */ 19325fe58019SAttilio Rao cred = curthread->td_ucred; /* XXX */ 19335fe58019SAttilio Rao pages = ap->a_m; 19345fe58019SAttilio Rao count = ap->a_count; 19355fe58019SAttilio Rao rtvals = ap->a_rtvals; 19365fe58019SAttilio Rao npages = btoc(count); 19375fe58019SAttilio Rao offset = IDX_TO_OFF(pages[0]->pindex); 19385fe58019SAttilio Rao 19395fe58019SAttilio Rao if (!fsess_opt_mmap(vnode_mount(vp))) { 1940cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1, 1941cf169498SAlan Somers "called on non-cacheable vnode??\n"); 19425fe58019SAttilio Rao } 19435fe58019SAttilio Rao for (i = 0; i < npages; i++) 19445fe58019SAttilio Rao rtvals[i] = VM_PAGER_AGAIN; 19455fe58019SAttilio Rao 19465fe58019SAttilio Rao /* 19475fe58019SAttilio Rao * When putting pages, do not extend file past EOF. 19485fe58019SAttilio Rao */ 19495fe58019SAttilio Rao 19505fe58019SAttilio Rao if (offset + count > fsize) { 19515fe58019SAttilio Rao count = fsize - offset; 19525fe58019SAttilio Rao if (count < 0) 19535fe58019SAttilio Rao count = 0; 19545fe58019SAttilio Rao } 19555fe58019SAttilio Rao /* 19565fe58019SAttilio Rao * We use only the kva address for the buffer, but this is extremely 1957b3a15dddSPedro F. Giffuni * convenient and fast. 19585fe58019SAttilio Rao */ 1959756a5412SGleb Smirnoff bp = uma_zalloc(fuse_pbuf_zone, M_WAITOK); 19605fe58019SAttilio Rao 19615fe58019SAttilio Rao kva = (vm_offset_t)bp->b_data; 19625fe58019SAttilio Rao pmap_qenter(kva, pages, npages); 196383c9dea1SGleb Smirnoff VM_CNT_INC(v_vnodeout); 196483c9dea1SGleb Smirnoff VM_CNT_ADD(v_vnodepgsout, count); 19655fe58019SAttilio Rao 19665fe58019SAttilio Rao iov.iov_base = (caddr_t)kva; 19675fe58019SAttilio Rao iov.iov_len = count; 19685fe58019SAttilio Rao uio.uio_iov = &iov; 19695fe58019SAttilio Rao uio.uio_iovcnt = 1; 19705fe58019SAttilio Rao uio.uio_offset = offset; 19715fe58019SAttilio Rao uio.uio_resid = count; 19725fe58019SAttilio Rao uio.uio_segflg = UIO_SYSSPACE; 19735fe58019SAttilio Rao uio.uio_rw = UIO_WRITE; 19745fe58019SAttilio Rao uio.uio_td = td; 19755fe58019SAttilio Rao 19765fe58019SAttilio Rao error = fuse_io_dispatch(vp, &uio, IO_DIRECT, cred); 19775fe58019SAttilio Rao 19785fe58019SAttilio Rao pmap_qremove(kva, npages); 1979756a5412SGleb Smirnoff uma_zfree(fuse_pbuf_zone, bp); 19805fe58019SAttilio Rao 19815fe58019SAttilio Rao if (!error) { 19825fe58019SAttilio Rao int nwritten = round_page(count - uio.uio_resid) / PAGE_SIZE; 19835fe58019SAttilio Rao 19845fe58019SAttilio Rao for (i = 0; i < nwritten; i++) { 19855fe58019SAttilio Rao rtvals[i] = VM_PAGER_OK; 198689f6b863SAttilio Rao VM_OBJECT_WLOCK(pages[i]->object); 19875fe58019SAttilio Rao vm_page_undirty(pages[i]); 198889f6b863SAttilio Rao VM_OBJECT_WUNLOCK(pages[i]->object); 19895fe58019SAttilio Rao } 19905fe58019SAttilio Rao } 19915fe58019SAttilio Rao return rtvals[0]; 19925fe58019SAttilio Rao } 19935fe58019SAttilio Rao 199404660064SFedor Uporov static const char extattr_namespace_separator = '.'; 199504660064SFedor Uporov 199604660064SFedor Uporov /* 199704660064SFedor Uporov struct vop_getextattr_args { 199804660064SFedor Uporov struct vop_generic_args a_gen; 199904660064SFedor Uporov struct vnode *a_vp; 200004660064SFedor Uporov int a_attrnamespace; 200104660064SFedor Uporov const char *a_name; 200204660064SFedor Uporov struct uio *a_uio; 200304660064SFedor Uporov size_t *a_size; 200404660064SFedor Uporov struct ucred *a_cred; 200504660064SFedor Uporov struct thread *a_td; 200604660064SFedor Uporov }; 200704660064SFedor Uporov */ 200804660064SFedor Uporov static int 200904660064SFedor Uporov fuse_vnop_getextattr(struct vop_getextattr_args *ap) 201004660064SFedor Uporov { 201104660064SFedor Uporov struct vnode *vp = ap->a_vp; 201204660064SFedor Uporov struct uio *uio = ap->a_uio; 201328f4f623SFedor Uporov struct fuse_dispatcher fdi; 201404660064SFedor Uporov struct fuse_getxattr_in *get_xattr_in; 201504660064SFedor Uporov struct fuse_getxattr_out *get_xattr_out; 201604660064SFedor Uporov struct mount *mp = vnode_mount(vp); 201704660064SFedor Uporov struct thread *td = ap->a_td; 201804660064SFedor Uporov struct ucred *cred = ap->a_cred; 201928f4f623SFedor Uporov char *prefix; 202028f4f623SFedor Uporov char *attr_str; 202128f4f623SFedor Uporov size_t len; 202228f4f623SFedor Uporov int err; 202304660064SFedor Uporov 202404660064SFedor Uporov if (fuse_isdeadfs(vp)) 202528f4f623SFedor Uporov return (ENXIO); 202604660064SFedor Uporov 202704660064SFedor Uporov /* Default to looking for user attributes. */ 202804660064SFedor Uporov if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 202904660064SFedor Uporov prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 203004660064SFedor Uporov else 203104660064SFedor Uporov prefix = EXTATTR_NAMESPACE_USER_STRING; 203204660064SFedor Uporov 203304660064SFedor Uporov len = strlen(prefix) + sizeof(extattr_namespace_separator) + 203404660064SFedor Uporov strlen(ap->a_name) + 1; 203504660064SFedor Uporov 203604660064SFedor Uporov fdisp_init(&fdi, len + sizeof(*get_xattr_in)); 203704660064SFedor Uporov fdisp_make_vp(&fdi, FUSE_GETXATTR, vp, td, cred); 203804660064SFedor Uporov 203904660064SFedor Uporov get_xattr_in = fdi.indata; 204004660064SFedor Uporov /* 204104660064SFedor Uporov * Check to see whether we're querying the available size or 204204660064SFedor Uporov * issuing the actual request. If we pass in 0, we get back struct 204304660064SFedor Uporov * fuse_getxattr_out. If we pass in a non-zero size, we get back 204404660064SFedor Uporov * that much data, without the struct fuse_getxattr_out header. 204504660064SFedor Uporov */ 2046493b4a8cSFedor Uporov if (uio == NULL) 204704660064SFedor Uporov get_xattr_in->size = 0; 204804660064SFedor Uporov else 204904660064SFedor Uporov get_xattr_in->size = uio->uio_resid; 205004660064SFedor Uporov 205104660064SFedor Uporov attr_str = (char *)fdi.indata + sizeof(*get_xattr_in); 205204660064SFedor Uporov snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator, 205304660064SFedor Uporov ap->a_name); 205404660064SFedor Uporov 205504660064SFedor Uporov err = fdisp_wait_answ(&fdi); 205604660064SFedor Uporov if (err != 0) { 205704660064SFedor Uporov if (err == ENOSYS) 205804660064SFedor Uporov fsess_set_notimpl(mp, FUSE_GETXATTR); 205904660064SFedor Uporov goto out; 206004660064SFedor Uporov } 206104660064SFedor Uporov 206204660064SFedor Uporov get_xattr_out = fdi.answ; 206304660064SFedor Uporov 2064493b4a8cSFedor Uporov if (ap->a_size != NULL) 206504660064SFedor Uporov *ap->a_size = get_xattr_out->size; 2066493b4a8cSFedor Uporov 2067493b4a8cSFedor Uporov if (uio != NULL) 206804660064SFedor Uporov err = uiomove(fdi.answ, fdi.iosize, uio); 206904660064SFedor Uporov 207004660064SFedor Uporov out: 207104660064SFedor Uporov fdisp_destroy(&fdi); 207204660064SFedor Uporov return (err); 207304660064SFedor Uporov } 207404660064SFedor Uporov 207504660064SFedor Uporov /* 207604660064SFedor Uporov struct vop_setextattr_args { 207704660064SFedor Uporov struct vop_generic_args a_gen; 207804660064SFedor Uporov struct vnode *a_vp; 207904660064SFedor Uporov int a_attrnamespace; 208004660064SFedor Uporov const char *a_name; 208104660064SFedor Uporov struct uio *a_uio; 208204660064SFedor Uporov struct ucred *a_cred; 208304660064SFedor Uporov struct thread *a_td; 208404660064SFedor Uporov }; 208504660064SFedor Uporov */ 208604660064SFedor Uporov static int 208704660064SFedor Uporov fuse_vnop_setextattr(struct vop_setextattr_args *ap) 208804660064SFedor Uporov { 208904660064SFedor Uporov struct vnode *vp = ap->a_vp; 209004660064SFedor Uporov struct uio *uio = ap->a_uio; 209128f4f623SFedor Uporov struct fuse_dispatcher fdi; 209204660064SFedor Uporov struct fuse_setxattr_in *set_xattr_in; 209304660064SFedor Uporov struct mount *mp = vnode_mount(vp); 209428f4f623SFedor Uporov struct thread *td = ap->a_td; 209528f4f623SFedor Uporov struct ucred *cred = ap->a_cred; 209604660064SFedor Uporov char *prefix; 209704660064SFedor Uporov size_t len; 209804660064SFedor Uporov char *attr_str; 209928f4f623SFedor Uporov int err; 210004660064SFedor Uporov 210104660064SFedor Uporov if (fuse_isdeadfs(vp)) 210228f4f623SFedor Uporov return (ENXIO); 210304660064SFedor Uporov 210404660064SFedor Uporov /* Default to looking for user attributes. */ 210504660064SFedor Uporov if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 210604660064SFedor Uporov prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 210704660064SFedor Uporov else 210804660064SFedor Uporov prefix = EXTATTR_NAMESPACE_USER_STRING; 210904660064SFedor Uporov 211004660064SFedor Uporov len = strlen(prefix) + sizeof(extattr_namespace_separator) + 211104660064SFedor Uporov strlen(ap->a_name) + 1; 211204660064SFedor Uporov 211304660064SFedor Uporov fdisp_init(&fdi, len + sizeof(*set_xattr_in) + uio->uio_resid); 211404660064SFedor Uporov fdisp_make_vp(&fdi, FUSE_SETXATTR, vp, td, cred); 211504660064SFedor Uporov 211604660064SFedor Uporov set_xattr_in = fdi.indata; 211704660064SFedor Uporov set_xattr_in->size = uio->uio_resid; 211804660064SFedor Uporov 211904660064SFedor Uporov attr_str = (char *)fdi.indata + sizeof(*set_xattr_in); 212004660064SFedor Uporov snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator, 212104660064SFedor Uporov ap->a_name); 212204660064SFedor Uporov 212304660064SFedor Uporov err = uiomove((char *)fdi.indata + sizeof(*set_xattr_in) + len, 212404660064SFedor Uporov uio->uio_resid, uio); 212504660064SFedor Uporov if (err != 0) { 212604660064SFedor Uporov goto out; 212704660064SFedor Uporov } 212804660064SFedor Uporov 212904660064SFedor Uporov err = fdisp_wait_answ(&fdi); 213004660064SFedor Uporov 213104660064SFedor Uporov if (err != 0) { 213204660064SFedor Uporov if (err == ENOSYS) 213304660064SFedor Uporov fsess_set_notimpl(mp, FUSE_SETXATTR); 213404660064SFedor Uporov goto out; 213504660064SFedor Uporov } 213604660064SFedor Uporov 213704660064SFedor Uporov out: 213804660064SFedor Uporov fdisp_destroy(&fdi); 213904660064SFedor Uporov return (err); 214004660064SFedor Uporov } 214104660064SFedor Uporov 214204660064SFedor Uporov /* 214304660064SFedor Uporov * The Linux / FUSE extended attribute list is simply a collection of 214404660064SFedor Uporov * NUL-terminated strings. The FreeBSD extended attribute list is a single 214504660064SFedor Uporov * byte length followed by a non-NUL terminated string. So, this allows 214604660064SFedor Uporov * conversion of the Linux / FUSE format to the FreeBSD format in place. 214704660064SFedor Uporov * Linux attribute names are reported with the namespace as a prefix (e.g. 214804660064SFedor Uporov * "user.attribute_name"), but in FreeBSD they are reported without the 214904660064SFedor Uporov * namespace prefix (e.g. "attribute_name"). So, we're going from: 215004660064SFedor Uporov * 215104660064SFedor Uporov * user.attr_name1\0user.attr_name2\0 215204660064SFedor Uporov * 215304660064SFedor Uporov * to: 215404660064SFedor Uporov * 215504660064SFedor Uporov * <num>attr_name1<num>attr_name2 215604660064SFedor Uporov * 215704660064SFedor Uporov * Where "<num>" is a single byte number of characters in the attribute name. 215804660064SFedor Uporov * 215904660064SFedor Uporov * Args: 216004660064SFedor Uporov * prefix - exattr namespace prefix string 216104660064SFedor Uporov * list, list_len - input list with namespace prefixes 216204660064SFedor Uporov * bsd_list, bsd_list_len - output list compatible with bsd vfs 216304660064SFedor Uporov */ 216404660064SFedor Uporov static int 216504660064SFedor Uporov fuse_xattrlist_convert(char *prefix, const char *list, int list_len, 216604660064SFedor Uporov char *bsd_list, int *bsd_list_len) 216704660064SFedor Uporov { 216804660064SFedor Uporov int len, pos, dist_to_next, prefix_len; 216904660064SFedor Uporov 217004660064SFedor Uporov pos = 0; 217104660064SFedor Uporov *bsd_list_len = 0; 217204660064SFedor Uporov prefix_len = strlen(prefix); 217304660064SFedor Uporov 217404660064SFedor Uporov while (pos < list_len && list[pos] != '\0') { 217504660064SFedor Uporov dist_to_next = strlen(&list[pos]) + 1; 217604660064SFedor Uporov if (bcmp(&list[pos], prefix, prefix_len) == 0 && 217704660064SFedor Uporov list[pos + prefix_len] == extattr_namespace_separator) { 217804660064SFedor Uporov len = dist_to_next - 217904660064SFedor Uporov (prefix_len + sizeof(extattr_namespace_separator)) - 1; 218004660064SFedor Uporov if (len >= EXTATTR_MAXNAMELEN) 218104660064SFedor Uporov return (ENAMETOOLONG); 218204660064SFedor Uporov 218304660064SFedor Uporov bsd_list[*bsd_list_len] = len; 218404660064SFedor Uporov memcpy(&bsd_list[*bsd_list_len + 1], 218504660064SFedor Uporov &list[pos + prefix_len + 218604660064SFedor Uporov sizeof(extattr_namespace_separator)], len); 218704660064SFedor Uporov 218804660064SFedor Uporov *bsd_list_len += len + 1; 218904660064SFedor Uporov } 219004660064SFedor Uporov 219104660064SFedor Uporov pos += dist_to_next; 219204660064SFedor Uporov } 219304660064SFedor Uporov 219404660064SFedor Uporov return (0); 219504660064SFedor Uporov } 219604660064SFedor Uporov 219704660064SFedor Uporov /* 219804660064SFedor Uporov struct vop_listextattr_args { 219904660064SFedor Uporov struct vop_generic_args a_gen; 220004660064SFedor Uporov struct vnode *a_vp; 220104660064SFedor Uporov int a_attrnamespace; 220204660064SFedor Uporov struct uio *a_uio; 220304660064SFedor Uporov size_t *a_size; 220404660064SFedor Uporov struct ucred *a_cred; 220504660064SFedor Uporov struct thread *a_td; 220604660064SFedor Uporov }; 220704660064SFedor Uporov */ 220804660064SFedor Uporov static int 220904660064SFedor Uporov fuse_vnop_listextattr(struct vop_listextattr_args *ap) 221004660064SFedor Uporov { 221104660064SFedor Uporov struct vnode *vp = ap->a_vp; 221204660064SFedor Uporov struct uio *uio = ap->a_uio; 221328f4f623SFedor Uporov struct fuse_dispatcher fdi; 2214493b4a8cSFedor Uporov struct fuse_listxattr_in *list_xattr_in; 2215493b4a8cSFedor Uporov struct fuse_listxattr_out *list_xattr_out; 221604660064SFedor Uporov struct mount *mp = vnode_mount(vp); 221728f4f623SFedor Uporov struct thread *td = ap->a_td; 221828f4f623SFedor Uporov struct ucred *cred = ap->a_cred; 221904660064SFedor Uporov size_t len; 222004660064SFedor Uporov char *prefix; 222104660064SFedor Uporov char *attr_str; 222204660064SFedor Uporov char *bsd_list = NULL; 2223493b4a8cSFedor Uporov char *linux_list; 222404660064SFedor Uporov int bsd_list_len; 2225493b4a8cSFedor Uporov int linux_list_len; 222628f4f623SFedor Uporov int err; 222704660064SFedor Uporov 222804660064SFedor Uporov if (fuse_isdeadfs(vp)) 222928f4f623SFedor Uporov return (ENXIO); 223004660064SFedor Uporov 223104660064SFedor Uporov /* 223204660064SFedor Uporov * Add space for a NUL and the period separator if enabled. 223304660064SFedor Uporov * Default to looking for user attributes. 223404660064SFedor Uporov */ 223504660064SFedor Uporov if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 223604660064SFedor Uporov prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 223704660064SFedor Uporov else 223804660064SFedor Uporov prefix = EXTATTR_NAMESPACE_USER_STRING; 223904660064SFedor Uporov 224004660064SFedor Uporov len = strlen(prefix) + sizeof(extattr_namespace_separator) + 1; 224104660064SFedor Uporov 2242493b4a8cSFedor Uporov fdisp_init(&fdi, sizeof(*list_xattr_in) + len); 224304660064SFedor Uporov fdisp_make_vp(&fdi, FUSE_LISTXATTR, vp, td, cred); 224404660064SFedor Uporov 2245493b4a8cSFedor Uporov /* 2246493b4a8cSFedor Uporov * Retrieve Linux / FUSE compatible list size. 2247493b4a8cSFedor Uporov */ 2248493b4a8cSFedor Uporov list_xattr_in = fdi.indata; 2249493b4a8cSFedor Uporov list_xattr_in->size = 0; 2250493b4a8cSFedor Uporov attr_str = (char *)fdi.indata + sizeof(*list_xattr_in); 225104660064SFedor Uporov snprintf(attr_str, len, "%s%c", prefix, extattr_namespace_separator); 225204660064SFedor Uporov 225304660064SFedor Uporov err = fdisp_wait_answ(&fdi); 225404660064SFedor Uporov if (err != 0) { 225504660064SFedor Uporov if (err == ENOSYS) 225604660064SFedor Uporov fsess_set_notimpl(mp, FUSE_LISTXATTR); 225704660064SFedor Uporov goto out; 225804660064SFedor Uporov } 225904660064SFedor Uporov 2260493b4a8cSFedor Uporov list_xattr_out = fdi.answ; 2261493b4a8cSFedor Uporov linux_list_len = list_xattr_out->size; 2262493b4a8cSFedor Uporov if (linux_list_len == 0) { 2263493b4a8cSFedor Uporov if (ap->a_size != NULL) 2264493b4a8cSFedor Uporov *ap->a_size = linux_list_len; 226504660064SFedor Uporov goto out; 226604660064SFedor Uporov } 226704660064SFedor Uporov 226804660064SFedor Uporov /* 2269493b4a8cSFedor Uporov * Retrieve Linux / FUSE compatible list values. 2270493b4a8cSFedor Uporov */ 2271493b4a8cSFedor Uporov fdisp_make_vp(&fdi, FUSE_LISTXATTR, vp, td, cred); 2272493b4a8cSFedor Uporov list_xattr_in = fdi.indata; 2273493b4a8cSFedor Uporov list_xattr_in->size = linux_list_len + sizeof(*list_xattr_out); 2274493b4a8cSFedor Uporov attr_str = (char *)fdi.indata + sizeof(*list_xattr_in); 2275493b4a8cSFedor Uporov snprintf(attr_str, len, "%s%c", prefix, extattr_namespace_separator); 2276493b4a8cSFedor Uporov 2277493b4a8cSFedor Uporov err = fdisp_wait_answ(&fdi); 2278493b4a8cSFedor Uporov if (err != 0) 2279493b4a8cSFedor Uporov goto out; 2280493b4a8cSFedor Uporov 2281493b4a8cSFedor Uporov linux_list = fdi.answ; 2282493b4a8cSFedor Uporov linux_list_len = fdi.iosize; 2283493b4a8cSFedor Uporov 2284493b4a8cSFedor Uporov /* 2285493b4a8cSFedor Uporov * Retrieve the BSD compatible list values. 228604660064SFedor Uporov * The Linux / FUSE attribute list format isn't the same 228704660064SFedor Uporov * as FreeBSD's format. So we need to transform it into 228804660064SFedor Uporov * FreeBSD's format before giving it to the user. 228904660064SFedor Uporov */ 2290493b4a8cSFedor Uporov bsd_list = malloc(linux_list_len, M_TEMP, M_WAITOK); 2291493b4a8cSFedor Uporov err = fuse_xattrlist_convert(prefix, linux_list, linux_list_len, 229204660064SFedor Uporov bsd_list, &bsd_list_len); 229304660064SFedor Uporov if (err != 0) 229404660064SFedor Uporov goto out; 229504660064SFedor Uporov 2296493b4a8cSFedor Uporov if (ap->a_size != NULL) 2297493b4a8cSFedor Uporov *ap->a_size = bsd_list_len; 2298493b4a8cSFedor Uporov 2299493b4a8cSFedor Uporov if (uio != NULL) 230004660064SFedor Uporov err = uiomove(bsd_list, bsd_list_len, uio); 230104660064SFedor Uporov 230204660064SFedor Uporov out: 230304660064SFedor Uporov free(bsd_list, M_TEMP); 230404660064SFedor Uporov fdisp_destroy(&fdi); 230504660064SFedor Uporov return (err); 230604660064SFedor Uporov } 230704660064SFedor Uporov 230804660064SFedor Uporov /* 230904660064SFedor Uporov struct vop_deleteextattr_args { 231004660064SFedor Uporov struct vop_generic_args a_gen; 231104660064SFedor Uporov struct vnode *a_vp; 231204660064SFedor Uporov int a_attrnamespace; 231304660064SFedor Uporov const char *a_name; 231404660064SFedor Uporov struct ucred *a_cred; 231504660064SFedor Uporov struct thread *a_td; 231604660064SFedor Uporov }; 231704660064SFedor Uporov */ 231804660064SFedor Uporov static int 231904660064SFedor Uporov fuse_vnop_deleteextattr(struct vop_deleteextattr_args *ap) 232004660064SFedor Uporov { 232104660064SFedor Uporov struct vnode *vp = ap->a_vp; 232228f4f623SFedor Uporov struct fuse_dispatcher fdi; 232304660064SFedor Uporov struct mount *mp = vnode_mount(vp); 232428f4f623SFedor Uporov struct thread *td = ap->a_td; 232528f4f623SFedor Uporov struct ucred *cred = ap->a_cred; 232604660064SFedor Uporov char *prefix; 232704660064SFedor Uporov size_t len; 232804660064SFedor Uporov char *attr_str; 232904660064SFedor Uporov int err; 233004660064SFedor Uporov 233104660064SFedor Uporov if (fuse_isdeadfs(vp)) 233228f4f623SFedor Uporov return (ENXIO); 233304660064SFedor Uporov 233404660064SFedor Uporov /* Default to looking for user attributes. */ 233504660064SFedor Uporov if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 233604660064SFedor Uporov prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 233704660064SFedor Uporov else 233804660064SFedor Uporov prefix = EXTATTR_NAMESPACE_USER_STRING; 233904660064SFedor Uporov 234004660064SFedor Uporov len = strlen(prefix) + sizeof(extattr_namespace_separator) + 234104660064SFedor Uporov strlen(ap->a_name) + 1; 234204660064SFedor Uporov 234304660064SFedor Uporov fdisp_init(&fdi, len); 234404660064SFedor Uporov fdisp_make_vp(&fdi, FUSE_REMOVEXATTR, vp, td, cred); 234504660064SFedor Uporov 234604660064SFedor Uporov attr_str = fdi.indata; 234704660064SFedor Uporov snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator, 234804660064SFedor Uporov ap->a_name); 234904660064SFedor Uporov 235004660064SFedor Uporov err = fdisp_wait_answ(&fdi); 235104660064SFedor Uporov if (err != 0) { 235204660064SFedor Uporov if (err == ENOSYS) 235304660064SFedor Uporov fsess_set_notimpl(mp, FUSE_REMOVEXATTR); 235404660064SFedor Uporov } 235504660064SFedor Uporov 235604660064SFedor Uporov fdisp_destroy(&fdi); 235704660064SFedor Uporov return (err); 235804660064SFedor Uporov } 235904660064SFedor Uporov 23605fe58019SAttilio Rao /* 23615fe58019SAttilio Rao struct vnop_print_args { 23625fe58019SAttilio Rao struct vnode *a_vp; 23635fe58019SAttilio Rao }; 23645fe58019SAttilio Rao */ 23655fe58019SAttilio Rao static int 23665fe58019SAttilio Rao fuse_vnop_print(struct vop_print_args *ap) 23675fe58019SAttilio Rao { 23685fe58019SAttilio Rao struct fuse_vnode_data *fvdat = VTOFUD(ap->a_vp); 23695fe58019SAttilio Rao 23705fe58019SAttilio Rao printf("nodeid: %ju, parent nodeid: %ju, nlookup: %ju, flag: %#x\n", 23715fe58019SAttilio Rao (uintmax_t)VTOILLU(ap->a_vp), (uintmax_t)fvdat->parent_nid, 23725fe58019SAttilio Rao (uintmax_t)fvdat->nlookup, 23735fe58019SAttilio Rao fvdat->flag); 23745fe58019SAttilio Rao 23755fe58019SAttilio Rao return 0; 23765fe58019SAttilio Rao } 2377