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> 705fe58019SAttilio Rao #include <sys/lock.h> 7189f6b863SAttilio Rao #include <sys/rwlock.h> 725fe58019SAttilio Rao #include <sys/sx.h> 735fe58019SAttilio Rao #include <sys/proc.h> 745fe58019SAttilio Rao #include <sys/mount.h> 755fe58019SAttilio Rao #include <sys/vnode.h> 765fe58019SAttilio Rao #include <sys/namei.h> 7704660064SFedor Uporov #include <sys/extattr.h> 785fe58019SAttilio Rao #include <sys/stat.h> 795fe58019SAttilio Rao #include <sys/unistd.h> 805fe58019SAttilio Rao #include <sys/filedesc.h> 815fe58019SAttilio Rao #include <sys/file.h> 825fe58019SAttilio Rao #include <sys/fcntl.h> 835fe58019SAttilio Rao #include <sys/dirent.h> 845fe58019SAttilio Rao #include <sys/bio.h> 855fe58019SAttilio Rao #include <sys/buf.h> 865fe58019SAttilio Rao #include <sys/sysctl.h> 87ca148cdaSGleb Smirnoff #include <sys/vmmeter.h> 885fe58019SAttilio Rao 895fe58019SAttilio Rao #include <vm/vm.h> 905fe58019SAttilio Rao #include <vm/vm_extern.h> 915fe58019SAttilio Rao #include <vm/pmap.h> 925fe58019SAttilio Rao #include <vm/vm_map.h> 935fe58019SAttilio Rao #include <vm/vm_page.h> 945fe58019SAttilio Rao #include <vm/vm_param.h> 955fe58019SAttilio Rao #include <vm/vm_object.h> 965fe58019SAttilio Rao #include <vm/vm_pager.h> 975fe58019SAttilio Rao #include <vm/vnode_pager.h> 985fe58019SAttilio Rao #include <vm/vm_object.h> 995fe58019SAttilio Rao 1005fe58019SAttilio Rao #include "fuse.h" 1015fe58019SAttilio Rao #include "fuse_file.h" 1025fe58019SAttilio Rao #include "fuse_internal.h" 1035fe58019SAttilio Rao #include "fuse_ipc.h" 1045fe58019SAttilio Rao #include "fuse_node.h" 1055fe58019SAttilio Rao #include "fuse_io.h" 1065fe58019SAttilio Rao 1075fe58019SAttilio Rao #include <sys/priv.h> 1085fe58019SAttilio Rao 109fd2749f2SAlan Somers /* Maximum number of hardlinks to a single FUSE file */ 110fd2749f2SAlan Somers #define FUSE_LINK_MAX UINT32_MAX 111fd2749f2SAlan Somers 112cf169498SAlan Somers SDT_PROVIDER_DECLARE(fuse); 113cf169498SAlan Somers /* 114cf169498SAlan Somers * Fuse trace probe: 115cf169498SAlan Somers * arg0: verbosity. Higher numbers give more verbose messages 116cf169498SAlan Somers * arg1: Textual message 117cf169498SAlan Somers */ 118cf169498SAlan Somers SDT_PROBE_DEFINE2(fuse, , vnops, trace, "int", "char*"); 1195fe58019SAttilio Rao 1205fe58019SAttilio Rao /* vnode ops */ 1215fe58019SAttilio Rao static vop_access_t fuse_vnop_access; 1225fe58019SAttilio Rao static vop_close_t fuse_vnop_close; 1235fe58019SAttilio Rao static vop_create_t fuse_vnop_create; 12404660064SFedor Uporov static vop_deleteextattr_t fuse_vnop_deleteextattr; 125915012e0SAlan Somers static vop_fdatasync_t fuse_vnop_fdatasync; 1265fe58019SAttilio Rao static vop_fsync_t fuse_vnop_fsync; 1275fe58019SAttilio Rao static vop_getattr_t fuse_vnop_getattr; 12804660064SFedor Uporov static vop_getextattr_t fuse_vnop_getextattr; 1295fe58019SAttilio Rao static vop_inactive_t fuse_vnop_inactive; 1305fe58019SAttilio Rao static vop_link_t fuse_vnop_link; 13104660064SFedor Uporov static vop_listextattr_t fuse_vnop_listextattr; 1325fe58019SAttilio Rao static vop_lookup_t fuse_vnop_lookup; 1335fe58019SAttilio Rao static vop_mkdir_t fuse_vnop_mkdir; 1345fe58019SAttilio Rao static vop_mknod_t fuse_vnop_mknod; 1355fe58019SAttilio Rao static vop_open_t fuse_vnop_open; 136746c92e0SJohn Baldwin static vop_pathconf_t fuse_vnop_pathconf; 1375fe58019SAttilio Rao static vop_read_t fuse_vnop_read; 1385fe58019SAttilio Rao static vop_readdir_t fuse_vnop_readdir; 1395fe58019SAttilio Rao static vop_readlink_t fuse_vnop_readlink; 1405fe58019SAttilio Rao static vop_reclaim_t fuse_vnop_reclaim; 1415fe58019SAttilio Rao static vop_remove_t fuse_vnop_remove; 1425fe58019SAttilio Rao static vop_rename_t fuse_vnop_rename; 1435fe58019SAttilio Rao static vop_rmdir_t fuse_vnop_rmdir; 1445fe58019SAttilio Rao static vop_setattr_t fuse_vnop_setattr; 14504660064SFedor Uporov static vop_setextattr_t fuse_vnop_setextattr; 1465fe58019SAttilio Rao static vop_strategy_t fuse_vnop_strategy; 1475fe58019SAttilio Rao static vop_symlink_t fuse_vnop_symlink; 1485fe58019SAttilio Rao static vop_write_t fuse_vnop_write; 1495fe58019SAttilio Rao static vop_getpages_t fuse_vnop_getpages; 1505fe58019SAttilio Rao static vop_putpages_t fuse_vnop_putpages; 1515fe58019SAttilio Rao static vop_print_t fuse_vnop_print; 1525fe58019SAttilio Rao 1535fe58019SAttilio Rao struct vop_vector fuse_vnops = { 1545fe58019SAttilio Rao .vop_default = &default_vnodeops, 1555fe58019SAttilio Rao .vop_access = fuse_vnop_access, 1565fe58019SAttilio Rao .vop_close = fuse_vnop_close, 1575fe58019SAttilio Rao .vop_create = fuse_vnop_create, 15804660064SFedor Uporov .vop_deleteextattr = fuse_vnop_deleteextattr, 1595fe58019SAttilio Rao .vop_fsync = fuse_vnop_fsync, 160915012e0SAlan Somers .vop_fdatasync = fuse_vnop_fdatasync, 1615fe58019SAttilio Rao .vop_getattr = fuse_vnop_getattr, 16204660064SFedor Uporov .vop_getextattr = fuse_vnop_getextattr, 1635fe58019SAttilio Rao .vop_inactive = fuse_vnop_inactive, 1645fe58019SAttilio Rao .vop_link = fuse_vnop_link, 16504660064SFedor Uporov .vop_listextattr = fuse_vnop_listextattr, 1665fe58019SAttilio Rao .vop_lookup = fuse_vnop_lookup, 1675fe58019SAttilio Rao .vop_mkdir = fuse_vnop_mkdir, 1685fe58019SAttilio Rao .vop_mknod = fuse_vnop_mknod, 1695fe58019SAttilio Rao .vop_open = fuse_vnop_open, 170746c92e0SJohn Baldwin .vop_pathconf = fuse_vnop_pathconf, 1715fe58019SAttilio Rao .vop_read = fuse_vnop_read, 1725fe58019SAttilio Rao .vop_readdir = fuse_vnop_readdir, 1735fe58019SAttilio Rao .vop_readlink = fuse_vnop_readlink, 1745fe58019SAttilio Rao .vop_reclaim = fuse_vnop_reclaim, 1755fe58019SAttilio Rao .vop_remove = fuse_vnop_remove, 1765fe58019SAttilio Rao .vop_rename = fuse_vnop_rename, 1775fe58019SAttilio Rao .vop_rmdir = fuse_vnop_rmdir, 1785fe58019SAttilio Rao .vop_setattr = fuse_vnop_setattr, 17904660064SFedor Uporov .vop_setextattr = fuse_vnop_setextattr, 1805fe58019SAttilio Rao .vop_strategy = fuse_vnop_strategy, 1815fe58019SAttilio Rao .vop_symlink = fuse_vnop_symlink, 1825fe58019SAttilio Rao .vop_write = fuse_vnop_write, 1835fe58019SAttilio Rao .vop_getpages = fuse_vnop_getpages, 1845fe58019SAttilio Rao .vop_putpages = fuse_vnop_putpages, 1855fe58019SAttilio Rao .vop_print = fuse_vnop_print, 1865fe58019SAttilio Rao }; 1875fe58019SAttilio Rao 1885fe58019SAttilio Rao static u_long fuse_lookup_cache_hits = 0; 1895fe58019SAttilio Rao 190123af6ecSAlan Somers SYSCTL_ULONG(_vfs_fusefs, OID_AUTO, lookup_cache_hits, CTLFLAG_RD, 191bd4cb2a4SConrad Meyer &fuse_lookup_cache_hits, 0, "number of positive cache hits in lookup"); 1925fe58019SAttilio Rao 1935fe58019SAttilio Rao static u_long fuse_lookup_cache_misses = 0; 1945fe58019SAttilio Rao 195123af6ecSAlan Somers SYSCTL_ULONG(_vfs_fusefs, OID_AUTO, lookup_cache_misses, CTLFLAG_RD, 196bd4cb2a4SConrad Meyer &fuse_lookup_cache_misses, 0, "number of cache misses in lookup"); 1975fe58019SAttilio Rao 198*3f2c630cSAlan Somers int fuse_lookup_cache_expire = 0; 1995fe58019SAttilio Rao 200*3f2c630cSAlan Somers SYSCTL_INT(_vfs_fusefs, OID_AUTO, lookup_cache_expire, CTLFLAG_RW, 201*3f2c630cSAlan Somers &fuse_lookup_cache_expire, 0, 202*3f2c630cSAlan Somers "if non-zero, expire fuse lookup cache entries at the proper time"); 2035fe58019SAttilio Rao 2045fe58019SAttilio Rao /* 2055fe58019SAttilio Rao * XXX: This feature is highly experimental and can bring to instabilities, 2065fe58019SAttilio Rao * needs revisiting before to be enabled by default. 2075fe58019SAttilio Rao */ 2085fe58019SAttilio Rao static int fuse_reclaim_revoked = 0; 2095fe58019SAttilio Rao 210123af6ecSAlan Somers SYSCTL_INT(_vfs_fusefs, OID_AUTO, reclaim_revoked, CTLFLAG_RW, 2115fe58019SAttilio Rao &fuse_reclaim_revoked, 0, ""); 2125fe58019SAttilio Rao 213756a5412SGleb Smirnoff uma_zone_t fuse_pbuf_zone; 2145fe58019SAttilio Rao 2155fe58019SAttilio Rao #define fuse_vm_page_lock(m) vm_page_lock((m)); 2165fe58019SAttilio Rao #define fuse_vm_page_unlock(m) vm_page_unlock((m)); 2175fe58019SAttilio Rao #define fuse_vm_page_lock_queues() ((void)0) 2185fe58019SAttilio Rao #define fuse_vm_page_unlock_queues() ((void)0) 2195fe58019SAttilio Rao 220f8d4af10SAlan Somers /* Get a filehandle for a directory */ 221f8d4af10SAlan Somers static int 222f8d4af10SAlan Somers fuse_filehandle_get_dir(struct vnode *vp, struct fuse_filehandle **fufhp, 223f8d4af10SAlan Somers struct ucred *cred, pid_t pid) 224f8d4af10SAlan Somers { 2259f10f423SAlan Somers if (fuse_filehandle_get(vp, FREAD, fufhp, cred, pid) == 0) 226f8d4af10SAlan Somers return 0; 2279f10f423SAlan Somers return fuse_filehandle_get(vp, FEXEC, fufhp, cred, pid); 2289f10f423SAlan Somers } 2299f10f423SAlan Somers 2309f10f423SAlan Somers /* Send FUSE_FLUSH for this vnode */ 2319f10f423SAlan Somers static int 2329f10f423SAlan Somers fuse_flush(struct vnode *vp, struct ucred *cred, pid_t pid, int fflag) 2339f10f423SAlan Somers { 2349f10f423SAlan Somers struct fuse_flush_in *ffi; 2359f10f423SAlan Somers struct fuse_filehandle *fufh; 2369f10f423SAlan Somers struct fuse_dispatcher fdi; 2379f10f423SAlan Somers struct thread *td = curthread; 2389f10f423SAlan Somers struct mount *mp = vnode_mount(vp); 2399f10f423SAlan Somers int err; 2409f10f423SAlan Somers 2419f10f423SAlan Somers if (!fsess_isimpl(vnode_mount(vp), FUSE_FLUSH)) 2429f10f423SAlan Somers return 0; 2439f10f423SAlan Somers 2449f10f423SAlan Somers err = fuse_filehandle_get(vp, fflag, &fufh, cred, pid); 2459f10f423SAlan Somers if (err) 2469f10f423SAlan Somers return err; 2479f10f423SAlan Somers 2489f10f423SAlan Somers fdisp_init(&fdi, sizeof(*ffi)); 2499f10f423SAlan Somers fdisp_make_vp(&fdi, FUSE_FLUSH, vp, td, cred); 2509f10f423SAlan Somers ffi = fdi.indata; 2519f10f423SAlan Somers ffi->fh = fufh->fh_id; 2529f10f423SAlan Somers 2539f10f423SAlan Somers err = fdisp_wait_answ(&fdi); 2549f10f423SAlan Somers if (err == ENOSYS) { 2559f10f423SAlan Somers fsess_set_notimpl(mp, FUSE_FLUSH); 2569f10f423SAlan Somers err = 0; 2579f10f423SAlan Somers } 2589f10f423SAlan Somers fdisp_destroy(&fdi); 2599f10f423SAlan Somers return err; 260f8d4af10SAlan Somers } 261f8d4af10SAlan Somers 2625fe58019SAttilio Rao /* 2635fe58019SAttilio Rao struct vnop_access_args { 2645fe58019SAttilio Rao struct vnode *a_vp; 2655fe58019SAttilio Rao #if VOP_ACCESS_TAKES_ACCMODE_T 2665fe58019SAttilio Rao accmode_t a_accmode; 2675fe58019SAttilio Rao #else 2685fe58019SAttilio Rao int a_mode; 2695fe58019SAttilio Rao #endif 2705fe58019SAttilio Rao struct ucred *a_cred; 2715fe58019SAttilio Rao struct thread *a_td; 2725fe58019SAttilio Rao }; 2735fe58019SAttilio Rao */ 2745fe58019SAttilio Rao static int 2755fe58019SAttilio Rao fuse_vnop_access(struct vop_access_args *ap) 2765fe58019SAttilio Rao { 2775fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 2785fe58019SAttilio Rao int accmode = ap->a_accmode; 2795fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 2805fe58019SAttilio Rao 2815fe58019SAttilio Rao struct fuse_access_param facp; 2825fe58019SAttilio Rao struct fuse_data *data = fuse_get_mpdata(vnode_mount(vp)); 2835fe58019SAttilio Rao 2845fe58019SAttilio Rao int err; 2855fe58019SAttilio Rao 2865fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 2875fe58019SAttilio Rao if (vnode_isvroot(vp)) { 2885fe58019SAttilio Rao return 0; 2895fe58019SAttilio Rao } 2905fe58019SAttilio Rao return ENXIO; 2915fe58019SAttilio Rao } 2925fe58019SAttilio Rao if (!(data->dataflags & FSESS_INITED)) { 2935fe58019SAttilio Rao if (vnode_isvroot(vp)) { 294cc426dd3SMateusz Guzik if (priv_check_cred(cred, PRIV_VFS_ADMIN) || 2955fe58019SAttilio Rao (fuse_match_cred(data->daemoncred, cred) == 0)) { 2965fe58019SAttilio Rao return 0; 2975fe58019SAttilio Rao } 2985fe58019SAttilio Rao } 2995fe58019SAttilio Rao return EBADF; 3005fe58019SAttilio Rao } 3015fe58019SAttilio Rao if (vnode_islnk(vp)) { 3025fe58019SAttilio Rao return 0; 3035fe58019SAttilio Rao } 3045fe58019SAttilio Rao bzero(&facp, sizeof(facp)); 3055fe58019SAttilio Rao 3065fe58019SAttilio Rao err = fuse_internal_access(vp, accmode, &facp, ap->a_td, ap->a_cred); 3075fe58019SAttilio Rao return err; 3085fe58019SAttilio Rao } 3095fe58019SAttilio Rao 3105fe58019SAttilio Rao /* 3119f10f423SAlan Somers struct vop_close_args { 3125fe58019SAttilio Rao struct vnode *a_vp; 3135fe58019SAttilio Rao int a_fflag; 3145fe58019SAttilio Rao struct ucred *a_cred; 3155fe58019SAttilio Rao struct thread *a_td; 3165fe58019SAttilio Rao }; 3175fe58019SAttilio Rao */ 3185fe58019SAttilio Rao static int 3195fe58019SAttilio Rao fuse_vnop_close(struct vop_close_args *ap) 3205fe58019SAttilio Rao { 3215fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 3225fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 3235fe58019SAttilio Rao int fflag = ap->a_fflag; 324f8d4af10SAlan Somers struct thread *td = ap->a_td; 325f8d4af10SAlan Somers pid_t pid = td->td_proc->p_pid; 3269f10f423SAlan Somers int err = 0; 3275fe58019SAttilio Rao 32835cf0e7eSAlan Somers if (fuse_isdeadfs(vp)) 3295fe58019SAttilio Rao return 0; 33035cf0e7eSAlan Somers if (vnode_isdir(vp)) 33135cf0e7eSAlan Somers return 0; 33235cf0e7eSAlan Somers if (fflag & IO_NDELAY) 33335cf0e7eSAlan Somers return 0; 3345ec10aa5SAlan Somers 3359f10f423SAlan Somers err = fuse_flush(vp, cred, pid, fflag); 3365ec10aa5SAlan Somers /* TODO: close the file handle, if we're sure it's no longer used */ 3375fe58019SAttilio Rao if ((VTOFUD(vp)->flag & FN_SIZECHANGE) != 0) { 338f8d4af10SAlan Somers fuse_vnode_savesize(vp, cred, td->td_proc->p_pid); 3395fe58019SAttilio Rao } 3409f10f423SAlan Somers return err; 3415fe58019SAttilio Rao } 3425fe58019SAttilio Rao 34319ef317dSAlan Somers static void 34419ef317dSAlan Somers fdisp_make_mknod_for_fallback( 34519ef317dSAlan Somers struct fuse_dispatcher *fdip, 34619ef317dSAlan Somers struct componentname *cnp, 34719ef317dSAlan Somers struct vnode *dvp, 34819ef317dSAlan Somers uint64_t parentnid, 34919ef317dSAlan Somers struct thread *td, 35019ef317dSAlan Somers struct ucred *cred, 35119ef317dSAlan Somers mode_t mode, 35219ef317dSAlan Somers enum fuse_opcode *op) 35319ef317dSAlan Somers { 35419ef317dSAlan Somers struct fuse_mknod_in *fmni; 35519ef317dSAlan Somers 35619ef317dSAlan Somers fdisp_init(fdip, sizeof(*fmni) + cnp->cn_namelen + 1); 35719ef317dSAlan Somers *op = FUSE_MKNOD; 35819ef317dSAlan Somers fdisp_make(fdip, *op, vnode_mount(dvp), parentnid, td, cred); 35919ef317dSAlan Somers fmni = fdip->indata; 36019ef317dSAlan Somers fmni->mode = mode; 36119ef317dSAlan Somers fmni->rdev = 0; 36219ef317dSAlan Somers memcpy((char *)fdip->indata + sizeof(*fmni), cnp->cn_nameptr, 36319ef317dSAlan Somers cnp->cn_namelen); 36419ef317dSAlan Somers ((char *)fdip->indata)[sizeof(*fmni) + cnp->cn_namelen] = '\0'; 36519ef317dSAlan Somers } 3665fe58019SAttilio Rao /* 3675fe58019SAttilio Rao struct vnop_create_args { 3685fe58019SAttilio Rao struct vnode *a_dvp; 3695fe58019SAttilio Rao struct vnode **a_vpp; 3705fe58019SAttilio Rao struct componentname *a_cnp; 3715fe58019SAttilio Rao struct vattr *a_vap; 3725fe58019SAttilio Rao }; 3735fe58019SAttilio Rao */ 3745fe58019SAttilio Rao static int 3755fe58019SAttilio Rao fuse_vnop_create(struct vop_create_args *ap) 3765fe58019SAttilio Rao { 3775fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 3785fe58019SAttilio Rao struct vnode **vpp = ap->a_vpp; 3795fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 3805fe58019SAttilio Rao struct vattr *vap = ap->a_vap; 3815fe58019SAttilio Rao struct thread *td = cnp->cn_thread; 3825fe58019SAttilio Rao struct ucred *cred = cnp->cn_cred; 3835fe58019SAttilio Rao 3845fe58019SAttilio Rao struct fuse_open_in *foi; 3855fe58019SAttilio Rao struct fuse_entry_out *feo; 38619ef317dSAlan Somers struct fuse_open_out *foo; 38719ef317dSAlan Somers struct fuse_dispatcher fdi, fdi2; 3885fe58019SAttilio Rao struct fuse_dispatcher *fdip = &fdi; 38919ef317dSAlan Somers struct fuse_dispatcher *fdip2 = NULL; 3905fe58019SAttilio Rao 3915fe58019SAttilio Rao int err; 3925fe58019SAttilio Rao 3935fe58019SAttilio Rao struct mount *mp = vnode_mount(dvp); 3945fe58019SAttilio Rao uint64_t parentnid = VTOFUD(dvp)->nid; 3955fe58019SAttilio Rao mode_t mode = MAKEIMODE(vap->va_type, vap->va_mode); 39619ef317dSAlan Somers enum fuse_opcode op; 3979e444871SAlan Somers int flags; 3989e444871SAlan Somers 3999e444871SAlan Somers /* 4009e444871SAlan Somers * VOP_CREATE doesn't tell us the open(2) flags, so we guess. Only a 4019e444871SAlan Somers * writable mode makes sense, and we might as well include readability 4029e444871SAlan Somers * too. 4039e444871SAlan Somers */ 4049e444871SAlan Somers flags = O_RDWR; 4055fe58019SAttilio Rao 4065fe58019SAttilio Rao if (fuse_isdeadfs(dvp)) { 4075fe58019SAttilio Rao return ENXIO; 4085fe58019SAttilio Rao } 4095fe58019SAttilio Rao bzero(&fdi, sizeof(fdi)); 4105fe58019SAttilio Rao 41119ef317dSAlan Somers if ((vap->va_type != VREG)) 412372b97d0SRick Macklem return (EINVAL); 4135fe58019SAttilio Rao 4145fe58019SAttilio Rao if (!fsess_isimpl(mp, FUSE_CREATE)) { 41519ef317dSAlan Somers /* Fallback to FUSE_MKNOD/FUSE_OPEN */ 41619ef317dSAlan Somers fdisp_make_mknod_for_fallback(fdip, cnp, dvp, parentnid, td, 41719ef317dSAlan Somers cred, mode, &op); 41819ef317dSAlan Somers } else { 41919ef317dSAlan Somers /* Use FUSE_CREATE */ 42019ef317dSAlan Somers op = FUSE_CREATE; 42119ef317dSAlan Somers fdisp_init(fdip, sizeof(*foi) + cnp->cn_namelen + 1); 42219ef317dSAlan Somers fdisp_make(fdip, op, vnode_mount(dvp), parentnid, td, cred); 4235fe58019SAttilio Rao foi = fdip->indata; 4245fe58019SAttilio Rao foi->mode = mode; 4259e444871SAlan Somers foi->flags = O_CREAT | flags; 4265fe58019SAttilio Rao memcpy((char *)fdip->indata + sizeof(*foi), cnp->cn_nameptr, 4275fe58019SAttilio Rao cnp->cn_namelen); 4285fe58019SAttilio Rao ((char *)fdip->indata)[sizeof(*foi) + cnp->cn_namelen] = '\0'; 42919ef317dSAlan Somers } 4305fe58019SAttilio Rao 4315fe58019SAttilio Rao err = fdisp_wait_answ(fdip); 4325fe58019SAttilio Rao 4336de3b00dSAttilio Rao if (err) { 43419ef317dSAlan Somers if (err == ENOSYS && op == FUSE_CREATE) { 4355fe58019SAttilio Rao fsess_set_notimpl(mp, FUSE_CREATE); 43619ef317dSAlan Somers fdisp_make_mknod_for_fallback(fdip, cnp, dvp, 43719ef317dSAlan Somers parentnid, td, cred, mode, &op); 43819ef317dSAlan Somers err = fdisp_wait_answ(fdip); 43919ef317dSAlan Somers } 44019ef317dSAlan Somers if (err) 4415fe58019SAttilio Rao goto out; 4425fe58019SAttilio Rao } 443372b97d0SRick Macklem 4445fe58019SAttilio Rao feo = fdip->answ; 4455fe58019SAttilio Rao 4465fe58019SAttilio Rao if ((err = fuse_internal_checkentry(feo, VREG))) { 4475fe58019SAttilio Rao goto out; 4485fe58019SAttilio Rao } 44919ef317dSAlan Somers 45019ef317dSAlan Somers if (op == FUSE_CREATE) { 45119ef317dSAlan Somers foo = (struct fuse_open_out*)(feo + 1); 45219ef317dSAlan Somers } else { 45319ef317dSAlan Somers /* Issue a separate FUSE_OPEN */ 45419ef317dSAlan Somers fdip2 = &fdi2; 45519ef317dSAlan Somers fdisp_init(fdip2, sizeof(*foi)); 45619ef317dSAlan Somers fdisp_make(fdip2, FUSE_OPEN, vnode_mount(dvp), feo->nodeid, td, 45719ef317dSAlan Somers cred); 45819ef317dSAlan Somers foi = fdip2->indata; 45919ef317dSAlan Somers foi->mode = mode; 4609e444871SAlan Somers foi->flags = flags; 46119ef317dSAlan Somers err = fdisp_wait_answ(fdip2); 46219ef317dSAlan Somers if (err) 46319ef317dSAlan Somers goto out; 46419ef317dSAlan Somers foo = fdip2->answ; 46519ef317dSAlan Somers } 46609176f09SConrad Meyer err = fuse_vnode_get(mp, feo, feo->nodeid, dvp, vpp, cnp, VREG); 4675fe58019SAttilio Rao if (err) { 4685fe58019SAttilio Rao struct fuse_release_in *fri; 4695fe58019SAttilio Rao uint64_t nodeid = feo->nodeid; 47019ef317dSAlan Somers uint64_t fh_id = foo->fh; 4715fe58019SAttilio Rao 4725fe58019SAttilio Rao fdisp_init(fdip, sizeof(*fri)); 4735fe58019SAttilio Rao fdisp_make(fdip, FUSE_RELEASE, mp, nodeid, td, cred); 4745fe58019SAttilio Rao fri = fdip->indata; 4755fe58019SAttilio Rao fri->fh = fh_id; 4769e444871SAlan Somers fri->flags = flags; 4775fe58019SAttilio Rao fuse_insert_callback(fdip->tick, fuse_internal_forget_callback); 4785fe58019SAttilio Rao fuse_insert_message(fdip->tick); 47919ef317dSAlan Somers goto out; 4805fe58019SAttilio Rao } 4815fe58019SAttilio Rao ASSERT_VOP_ELOCKED(*vpp, "fuse_vnop_create"); 482cad67791SAlan Somers fuse_internal_cache_attrs(*vpp, &feo->attr, feo->attr_valid, 483cad67791SAlan Somers feo->attr_valid_nsec, NULL); 4845fe58019SAttilio Rao 485a7e81cb3SAlan Somers fuse_filehandle_init(*vpp, FUFH_RDWR, NULL, td, cred, foo); 48619ef317dSAlan Somers fuse_vnode_open(*vpp, foo->open_flags, td); 4875fe58019SAttilio Rao cache_purge_negative(dvp); 4885fe58019SAttilio Rao 4895fe58019SAttilio Rao out: 49019ef317dSAlan Somers if (fdip2) 49119ef317dSAlan Somers fdisp_destroy(fdip2); 4925fe58019SAttilio Rao fdisp_destroy(fdip); 4935fe58019SAttilio Rao return err; 4945fe58019SAttilio Rao } 4955fe58019SAttilio Rao 4965fe58019SAttilio Rao /* 497915012e0SAlan Somers struct vnop_fdatasync_args { 498915012e0SAlan Somers struct vop_generic_args a_gen; 499915012e0SAlan Somers struct vnode * a_vp; 500915012e0SAlan Somers struct thread * a_td; 501915012e0SAlan Somers }; 5025fe58019SAttilio Rao */ 503915012e0SAlan Somers static int 504915012e0SAlan Somers fuse_vnop_fdatasync(struct vop_fdatasync_args *ap) 505915012e0SAlan Somers { 506915012e0SAlan Somers struct vnode *vp = ap->a_vp; 507915012e0SAlan Somers struct thread *td = ap->a_td; 508915012e0SAlan Somers int waitfor = MNT_WAIT; 509915012e0SAlan Somers 510915012e0SAlan Somers int err = 0; 511915012e0SAlan Somers 512915012e0SAlan Somers if (fuse_isdeadfs(vp)) { 513915012e0SAlan Somers return 0; 514915012e0SAlan Somers } 515915012e0SAlan Somers if ((err = vop_stdfdatasync_buf(ap))) 516915012e0SAlan Somers return err; 517915012e0SAlan Somers 518915012e0SAlan Somers return fuse_internal_fsync(vp, td, waitfor, true); 519915012e0SAlan Somers } 5205fe58019SAttilio Rao 5215fe58019SAttilio Rao /* 5225fe58019SAttilio Rao struct vnop_fsync_args { 523915012e0SAlan Somers struct vop_generic_args a_gen; 5245fe58019SAttilio Rao struct vnode * a_vp; 5255fe58019SAttilio Rao int a_waitfor; 5265fe58019SAttilio Rao struct thread * a_td; 5275fe58019SAttilio Rao }; 5285fe58019SAttilio Rao */ 5295fe58019SAttilio Rao static int 5305fe58019SAttilio Rao fuse_vnop_fsync(struct vop_fsync_args *ap) 5315fe58019SAttilio Rao { 5325fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 5335fe58019SAttilio Rao struct thread *td = ap->a_td; 53490612f3cSAlan Somers int waitfor = ap->a_waitfor; 535915012e0SAlan Somers int err = 0; 5365fe58019SAttilio Rao 5375fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 5385fe58019SAttilio Rao return 0; 5395fe58019SAttilio Rao } 5405fe58019SAttilio Rao if ((err = vop_stdfsync(ap))) 5415fe58019SAttilio Rao return err; 5425fe58019SAttilio Rao 543915012e0SAlan Somers return fuse_internal_fsync(vp, td, waitfor, false); 5445fe58019SAttilio Rao } 5455fe58019SAttilio Rao 5465fe58019SAttilio Rao /* 5475fe58019SAttilio Rao struct vnop_getattr_args { 5485fe58019SAttilio Rao struct vnode *a_vp; 5495fe58019SAttilio Rao struct vattr *a_vap; 5505fe58019SAttilio Rao struct ucred *a_cred; 5515fe58019SAttilio Rao struct thread *a_td; 5525fe58019SAttilio Rao }; 5535fe58019SAttilio Rao */ 5545fe58019SAttilio Rao static int 5555fe58019SAttilio Rao fuse_vnop_getattr(struct vop_getattr_args *ap) 5565fe58019SAttilio Rao { 5575fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 5585fe58019SAttilio Rao struct vattr *vap = ap->a_vap; 5595fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 5605fe58019SAttilio Rao struct thread *td = curthread; 5615fe58019SAttilio Rao 5625fe58019SAttilio Rao int err = 0; 5635fe58019SAttilio Rao int dataflags; 5645fe58019SAttilio Rao 5655fe58019SAttilio Rao dataflags = fuse_get_mpdata(vnode_mount(vp))->dataflags; 5665fe58019SAttilio Rao 5675fe58019SAttilio Rao /* Note that we are not bailing out on a dead file system just yet. */ 5685fe58019SAttilio Rao 5695fe58019SAttilio Rao if (!(dataflags & FSESS_INITED)) { 5705fe58019SAttilio Rao if (!vnode_isvroot(vp)) { 5715fe58019SAttilio Rao fdata_set_dead(fuse_get_mpdata(vnode_mount(vp))); 5725fe58019SAttilio Rao err = ENOTCONN; 5735fe58019SAttilio Rao return err; 5745fe58019SAttilio Rao } else { 5755fe58019SAttilio Rao goto fake; 5765fe58019SAttilio Rao } 5775fe58019SAttilio Rao } 578cad67791SAlan Somers err = fuse_internal_getattr(vp, vap, cred, td); 579cad67791SAlan Somers if (err == ENOTCONN && vnode_isvroot(vp)) { 580cf169498SAlan Somers /* see comment in fuse_vfsop_statfs() */ 5815fe58019SAttilio Rao goto fake; 582cad67791SAlan Somers } else { 5835fe58019SAttilio Rao return err; 584cad67791SAlan Somers } 5855fe58019SAttilio Rao 5865fe58019SAttilio Rao fake: 5875fe58019SAttilio Rao bzero(vap, sizeof(*vap)); 5885fe58019SAttilio Rao vap->va_type = vnode_vtype(vp); 5895fe58019SAttilio Rao 5905fe58019SAttilio Rao return 0; 5915fe58019SAttilio Rao } 5925fe58019SAttilio Rao 5935fe58019SAttilio Rao /* 5945fe58019SAttilio Rao struct vnop_inactive_args { 5955fe58019SAttilio Rao struct vnode *a_vp; 5965fe58019SAttilio Rao struct thread *a_td; 5975fe58019SAttilio Rao }; 5985fe58019SAttilio Rao */ 5995fe58019SAttilio Rao static int 6005fe58019SAttilio Rao fuse_vnop_inactive(struct vop_inactive_args *ap) 6015fe58019SAttilio Rao { 6025fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 6035fe58019SAttilio Rao struct thread *td = ap->a_td; 6045fe58019SAttilio Rao 6055fe58019SAttilio Rao struct fuse_vnode_data *fvdat = VTOFUD(vp); 6065ec10aa5SAlan Somers struct fuse_filehandle *fufh, *fufh_tmp; 6075fe58019SAttilio Rao 6085ec10aa5SAlan Somers int need_flush = 1; 6095fe58019SAttilio Rao 6105ec10aa5SAlan Somers LIST_FOREACH_SAFE(fufh, &fvdat->handles, next, fufh_tmp) { 6115fe58019SAttilio Rao if (need_flush && vp->v_type == VREG) { 6125fe58019SAttilio Rao if ((VTOFUD(vp)->flag & FN_SIZECHANGE) != 0) { 613f8d4af10SAlan Somers fuse_vnode_savesize(vp, NULL, 0); 6145fe58019SAttilio Rao } 6155fe58019SAttilio Rao if (fuse_data_cache_invalidate || 6165fe58019SAttilio Rao (fvdat->flag & FN_REVOKED) != 0) 6175fe58019SAttilio Rao fuse_io_invalbuf(vp, td); 6185fe58019SAttilio Rao else 6195fe58019SAttilio Rao fuse_io_flushbuf(vp, MNT_WAIT, td); 6205fe58019SAttilio Rao need_flush = 0; 6215fe58019SAttilio Rao } 6225ec10aa5SAlan Somers fuse_filehandle_close(vp, fufh, td, NULL); 6235fe58019SAttilio Rao } 6245fe58019SAttilio Rao 6255fe58019SAttilio Rao if ((fvdat->flag & FN_REVOKED) != 0 && fuse_reclaim_revoked) { 6265fe58019SAttilio Rao vrecycle(vp); 6275fe58019SAttilio Rao } 6285fe58019SAttilio Rao return 0; 6295fe58019SAttilio Rao } 6305fe58019SAttilio Rao 6315fe58019SAttilio Rao /* 6325fe58019SAttilio Rao struct vnop_link_args { 6335fe58019SAttilio Rao struct vnode *a_tdvp; 6345fe58019SAttilio Rao struct vnode *a_vp; 6355fe58019SAttilio Rao struct componentname *a_cnp; 6365fe58019SAttilio Rao }; 6375fe58019SAttilio Rao */ 6385fe58019SAttilio Rao static int 6395fe58019SAttilio Rao fuse_vnop_link(struct vop_link_args *ap) 6405fe58019SAttilio Rao { 6415fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 6425fe58019SAttilio Rao struct vnode *tdvp = ap->a_tdvp; 6435fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 6445fe58019SAttilio Rao 6455fe58019SAttilio Rao struct vattr *vap = VTOVA(vp); 6465fe58019SAttilio Rao 6475fe58019SAttilio Rao struct fuse_dispatcher fdi; 6485fe58019SAttilio Rao struct fuse_entry_out *feo; 6495fe58019SAttilio Rao struct fuse_link_in fli; 6505fe58019SAttilio Rao 6515fe58019SAttilio Rao int err; 6525fe58019SAttilio Rao 6535fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 6545fe58019SAttilio Rao return ENXIO; 6555fe58019SAttilio Rao } 6565fe58019SAttilio Rao if (vnode_mount(tdvp) != vnode_mount(vp)) { 6575fe58019SAttilio Rao return EXDEV; 6585fe58019SAttilio Rao } 65978a7722fSConrad Meyer 66078a7722fSConrad Meyer /* 66178a7722fSConrad Meyer * This is a seatbelt check to protect naive userspace filesystems from 66278a7722fSConrad Meyer * themselves and the limitations of the FUSE IPC protocol. If a 66378a7722fSConrad Meyer * filesystem does not allow attribute caching, assume it is capable of 66478a7722fSConrad Meyer * validating that nlink does not overflow. 66578a7722fSConrad Meyer */ 66678a7722fSConrad Meyer if (vap != NULL && vap->va_nlink >= FUSE_LINK_MAX) 6675fe58019SAttilio Rao return EMLINK; 6685fe58019SAttilio Rao fli.oldnodeid = VTOI(vp); 6695fe58019SAttilio Rao 6705fe58019SAttilio Rao fdisp_init(&fdi, 0); 6715fe58019SAttilio Rao fuse_internal_newentry_makerequest(vnode_mount(tdvp), VTOI(tdvp), cnp, 6725fe58019SAttilio Rao FUSE_LINK, &fli, sizeof(fli), &fdi); 6735fe58019SAttilio Rao if ((err = fdisp_wait_answ(&fdi))) { 6745fe58019SAttilio Rao goto out; 6755fe58019SAttilio Rao } 6765fe58019SAttilio Rao feo = fdi.answ; 6775fe58019SAttilio Rao 6785fe58019SAttilio Rao err = fuse_internal_checkentry(feo, vnode_vtype(vp)); 6795fe58019SAttilio Rao out: 6805fe58019SAttilio Rao fdisp_destroy(&fdi); 6815fe58019SAttilio Rao return err; 6825fe58019SAttilio Rao } 6835fe58019SAttilio Rao 6845fe58019SAttilio Rao /* 6855fe58019SAttilio Rao struct vnop_lookup_args { 6865fe58019SAttilio Rao struct vnodeop_desc *a_desc; 6875fe58019SAttilio Rao struct vnode *a_dvp; 6885fe58019SAttilio Rao struct vnode **a_vpp; 6895fe58019SAttilio Rao struct componentname *a_cnp; 6905fe58019SAttilio Rao }; 6915fe58019SAttilio Rao */ 6925fe58019SAttilio Rao int 6935fe58019SAttilio Rao fuse_vnop_lookup(struct vop_lookup_args *ap) 6945fe58019SAttilio Rao { 6955fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 6965fe58019SAttilio Rao struct vnode **vpp = ap->a_vpp; 6975fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 6985fe58019SAttilio Rao struct thread *td = cnp->cn_thread; 6995fe58019SAttilio Rao struct ucred *cred = cnp->cn_cred; 7005fe58019SAttilio Rao 7015fe58019SAttilio Rao int nameiop = cnp->cn_nameiop; 7025fe58019SAttilio Rao int flags = cnp->cn_flags; 7035fe58019SAttilio Rao int wantparent = flags & (LOCKPARENT | WANTPARENT); 7045fe58019SAttilio Rao int islastcn = flags & ISLASTCN; 7055fe58019SAttilio Rao struct mount *mp = vnode_mount(dvp); 7065fe58019SAttilio Rao 7075fe58019SAttilio Rao int err = 0; 7085fe58019SAttilio Rao int lookup_err = 0; 7095fe58019SAttilio Rao struct vnode *vp = NULL; 7105fe58019SAttilio Rao 7115fe58019SAttilio Rao struct fuse_dispatcher fdi; 7125fe58019SAttilio Rao enum fuse_opcode op; 7135fe58019SAttilio Rao 7145fe58019SAttilio Rao uint64_t nid; 7155fe58019SAttilio Rao struct fuse_access_param facp; 7165fe58019SAttilio Rao 7175fe58019SAttilio Rao if (fuse_isdeadfs(dvp)) { 7185fe58019SAttilio Rao *vpp = NULL; 7195fe58019SAttilio Rao return ENXIO; 7205fe58019SAttilio Rao } 7215fe58019SAttilio Rao if (!vnode_isdir(dvp)) { 7225fe58019SAttilio Rao return ENOTDIR; 7235fe58019SAttilio Rao } 7245fe58019SAttilio Rao if (islastcn && vfs_isrdonly(mp) && (nameiop != LOOKUP)) { 7255fe58019SAttilio Rao return EROFS; 7265fe58019SAttilio Rao } 7275fe58019SAttilio Rao /* 7285fe58019SAttilio Rao * We do access check prior to doing anything else only in the case 7295fe58019SAttilio Rao * when we are at fs root (we'd like to say, "we are at the first 7305fe58019SAttilio Rao * component", but that's not exactly the same... nevermind). 7315fe58019SAttilio Rao * See further comments at further access checks. 7325fe58019SAttilio Rao */ 7335fe58019SAttilio Rao 7345fe58019SAttilio Rao bzero(&facp, sizeof(facp)); 7355fe58019SAttilio Rao if (vnode_isvroot(dvp)) { /* early permission check hack */ 7365fe58019SAttilio Rao if ((err = fuse_internal_access(dvp, VEXEC, &facp, td, cred))) { 7375fe58019SAttilio Rao return err; 7385fe58019SAttilio Rao } 7395fe58019SAttilio Rao } 7405fe58019SAttilio Rao if (flags & ISDOTDOT) { 7415fe58019SAttilio Rao nid = VTOFUD(dvp)->parent_nid; 7425fe58019SAttilio Rao if (nid == 0) { 7435fe58019SAttilio Rao return ENOENT; 7445fe58019SAttilio Rao } 7455fe58019SAttilio Rao fdisp_init(&fdi, 0); 7465fe58019SAttilio Rao op = FUSE_GETATTR; 7475fe58019SAttilio Rao goto calldaemon; 7485fe58019SAttilio Rao } else if (cnp->cn_namelen == 1 && *(cnp->cn_nameptr) == '.') { 7495fe58019SAttilio Rao nid = VTOI(dvp); 7505fe58019SAttilio Rao fdisp_init(&fdi, 0); 7515fe58019SAttilio Rao op = FUSE_GETATTR; 7525fe58019SAttilio Rao goto calldaemon; 753*3f2c630cSAlan Somers } else if (fuse_lookup_cache_expire) { 754*3f2c630cSAlan Somers struct timespec now, timeout; 755*3f2c630cSAlan Somers 756*3f2c630cSAlan Somers err = cache_lookup(dvp, vpp, cnp, &timeout, NULL); 757*3f2c630cSAlan Somers switch (err) { 758*3f2c630cSAlan Somers 759*3f2c630cSAlan Somers case -1: /* positive match */ 760*3f2c630cSAlan Somers getnanouptime(&now); 761*3f2c630cSAlan Somers if (timespeccmp(&timeout, &now, <=)) { 762*3f2c630cSAlan Somers atomic_add_acq_long(&fuse_lookup_cache_hits, 1); 763*3f2c630cSAlan Somers } else { 764*3f2c630cSAlan Somers /* Cache timeout */ 765*3f2c630cSAlan Somers atomic_add_acq_long(&fuse_lookup_cache_misses, 766*3f2c630cSAlan Somers 1); 767*3f2c630cSAlan Somers cache_purge(*vpp); 768*3f2c630cSAlan Somers break; 769*3f2c630cSAlan Somers } 770*3f2c630cSAlan Somers return 0; 771*3f2c630cSAlan Somers 772*3f2c630cSAlan Somers case 0: /* no match in cache */ 773*3f2c630cSAlan Somers atomic_add_acq_long(&fuse_lookup_cache_misses, 1); 774*3f2c630cSAlan Somers break; 775*3f2c630cSAlan Somers 776*3f2c630cSAlan Somers case ENOENT: /* negative match */ 777*3f2c630cSAlan Somers getnanouptime(&now); 778*3f2c630cSAlan Somers if (timespeccmp(&timeout, &now, >)) { 779*3f2c630cSAlan Somers /* Cache timeout */ 780*3f2c630cSAlan Somers printf("Purging vnode %p name=%s\n", *vpp, 781*3f2c630cSAlan Somers cnp->cn_nameptr); 782*3f2c630cSAlan Somers fuse_internal_vnode_disappear(*vpp); 783*3f2c630cSAlan Somers break; 784*3f2c630cSAlan Somers } 785*3f2c630cSAlan Somers /* fall through */ 786*3f2c630cSAlan Somers default: 787*3f2c630cSAlan Somers return err; 788*3f2c630cSAlan Somers } 789*3f2c630cSAlan Somers } else { 7905fe58019SAttilio Rao err = cache_lookup(dvp, vpp, cnp, NULL, NULL); 7915fe58019SAttilio Rao switch (err) { 7925fe58019SAttilio Rao 7935fe58019SAttilio Rao case -1: /* positive match */ 7945fe58019SAttilio Rao atomic_add_acq_long(&fuse_lookup_cache_hits, 1); 7955fe58019SAttilio Rao return 0; 7965fe58019SAttilio Rao 7975fe58019SAttilio Rao case 0: /* no match in cache */ 7985fe58019SAttilio Rao atomic_add_acq_long(&fuse_lookup_cache_misses, 1); 7995fe58019SAttilio Rao break; 8005fe58019SAttilio Rao 8015fe58019SAttilio Rao case ENOENT: /* negative match */ 8025fe58019SAttilio Rao /* fall through */ 8035fe58019SAttilio Rao default: 8045fe58019SAttilio Rao return err; 8055fe58019SAttilio Rao } 8065fe58019SAttilio Rao } 8075fe58019SAttilio Rao nid = VTOI(dvp); 8085fe58019SAttilio Rao fdisp_init(&fdi, cnp->cn_namelen + 1); 8095fe58019SAttilio Rao op = FUSE_LOOKUP; 8105fe58019SAttilio Rao 8115fe58019SAttilio Rao calldaemon: 8125fe58019SAttilio Rao fdisp_make(&fdi, op, mp, nid, td, cred); 8135fe58019SAttilio Rao 8145fe58019SAttilio Rao if (op == FUSE_LOOKUP) { 8155fe58019SAttilio Rao memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen); 8165fe58019SAttilio Rao ((char *)fdi.indata)[cnp->cn_namelen] = '\0'; 8175fe58019SAttilio Rao } 8185fe58019SAttilio Rao lookup_err = fdisp_wait_answ(&fdi); 8195fe58019SAttilio Rao 8205fe58019SAttilio Rao if ((op == FUSE_LOOKUP) && !lookup_err) { /* lookup call succeeded */ 8215fe58019SAttilio Rao nid = ((struct fuse_entry_out *)fdi.answ)->nodeid; 8225fe58019SAttilio Rao if (!nid) { 8235fe58019SAttilio Rao /* 8245fe58019SAttilio Rao * zero nodeid is the same as "not found", 8255fe58019SAttilio Rao * but it's also cacheable (which we keep 8265fe58019SAttilio Rao * keep on doing not as of writing this) 8275fe58019SAttilio Rao */ 8286248288eSAlan Somers fdi.answ_stat = ENOENT; 8295fe58019SAttilio Rao lookup_err = ENOENT; 8305fe58019SAttilio Rao } else if (nid == FUSE_ROOT_ID) { 8315fe58019SAttilio Rao lookup_err = EINVAL; 8325fe58019SAttilio Rao } 8335fe58019SAttilio Rao } 8345fe58019SAttilio Rao if (lookup_err && 8355fe58019SAttilio Rao (!fdi.answ_stat || lookup_err != ENOENT || op != FUSE_LOOKUP)) { 8365fe58019SAttilio Rao fdisp_destroy(&fdi); 8375fe58019SAttilio Rao return lookup_err; 8385fe58019SAttilio Rao } 8395fe58019SAttilio Rao /* lookup_err, if non-zero, must be ENOENT at this point */ 8405fe58019SAttilio Rao 8415fe58019SAttilio Rao if (lookup_err) { 8425fe58019SAttilio Rao 8435fe58019SAttilio Rao if ((nameiop == CREATE || nameiop == RENAME) && islastcn 8445fe58019SAttilio Rao /* && directory dvp has not been removed */ ) { 8455fe58019SAttilio Rao 8465fe58019SAttilio Rao if (vfs_isrdonly(mp)) { 8475fe58019SAttilio Rao err = EROFS; 8485fe58019SAttilio Rao goto out; 8495fe58019SAttilio Rao } 8505fe58019SAttilio Rao #if 0 /* THINK_ABOUT_THIS */ 8515fe58019SAttilio Rao if ((err = fuse_internal_access(dvp, VWRITE, cred, td, &facp))) { 8525fe58019SAttilio Rao goto out; 8535fe58019SAttilio Rao } 8545fe58019SAttilio Rao #endif 8555fe58019SAttilio Rao 8565fe58019SAttilio Rao /* 8575fe58019SAttilio Rao * Possibly record the position of a slot in the 8585fe58019SAttilio Rao * directory large enough for the new component name. 8595fe58019SAttilio Rao * This can be recorded in the vnode private data for 8605fe58019SAttilio Rao * dvp. Set the SAVENAME flag to hold onto the 8615fe58019SAttilio Rao * pathname for use later in VOP_CREATE or VOP_RENAME. 8625fe58019SAttilio Rao */ 8635fe58019SAttilio Rao cnp->cn_flags |= SAVENAME; 8645fe58019SAttilio Rao 8655fe58019SAttilio Rao err = EJUSTRETURN; 8665fe58019SAttilio Rao goto out; 8675fe58019SAttilio Rao } 8685fe58019SAttilio Rao /* Consider inserting name into cache. */ 8695fe58019SAttilio Rao 8705fe58019SAttilio Rao /* 8715fe58019SAttilio Rao * No we can't use negative caching, as the fs 8725fe58019SAttilio Rao * changes are out of our control. 8735fe58019SAttilio Rao * False positives' falseness turns out just as things 8745fe58019SAttilio Rao * go by, but false negatives' falseness doesn't. 8755fe58019SAttilio Rao * (and aiding the caching mechanism with extra control 8765fe58019SAttilio Rao * mechanisms comes quite close to beating the whole purpose 8775fe58019SAttilio Rao * caching...) 8785fe58019SAttilio Rao */ 8795fe58019SAttilio Rao #if 0 8806c21f6edSKonstantin Belousov if ((cnp->cn_flags & MAKEENTRY) != 0) { 881cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1, 882cf169498SAlan Somers "inserting NULL into cache"); 8835fe58019SAttilio Rao cache_enter(dvp, NULL, cnp); 8845fe58019SAttilio Rao } 8855fe58019SAttilio Rao #endif 8865fe58019SAttilio Rao err = ENOENT; 8875fe58019SAttilio Rao goto out; 8885fe58019SAttilio Rao 8895fe58019SAttilio Rao } else { 8905fe58019SAttilio Rao 8915fe58019SAttilio Rao /* !lookup_err */ 8925fe58019SAttilio Rao 8935fe58019SAttilio Rao struct fuse_entry_out *feo = NULL; 8945fe58019SAttilio Rao struct fuse_attr *fattr = NULL; 8955fe58019SAttilio Rao 8965fe58019SAttilio Rao if (op == FUSE_GETATTR) { 8975fe58019SAttilio Rao fattr = &((struct fuse_attr_out *)fdi.answ)->attr; 8985fe58019SAttilio Rao } else { 8995fe58019SAttilio Rao feo = (struct fuse_entry_out *)fdi.answ; 9005fe58019SAttilio Rao fattr = &(feo->attr); 9015fe58019SAttilio Rao } 9025fe58019SAttilio Rao 9035fe58019SAttilio Rao /* 9045fe58019SAttilio Rao * If deleting, and at end of pathname, return parameters 9055fe58019SAttilio Rao * which can be used to remove file. If the wantparent flag 9065fe58019SAttilio Rao * isn't set, we return only the directory, otherwise we go on 9075fe58019SAttilio Rao * and lock the inode, being careful with ".". 9085fe58019SAttilio Rao */ 9095fe58019SAttilio Rao if (nameiop == DELETE && islastcn) { 9105fe58019SAttilio Rao /* 9115fe58019SAttilio Rao * Check for write access on directory. 9125fe58019SAttilio Rao */ 9135fe58019SAttilio Rao facp.xuid = fattr->uid; 9145fe58019SAttilio Rao facp.facc_flags |= FACCESS_STICKY; 9155fe58019SAttilio Rao err = fuse_internal_access(dvp, VWRITE, &facp, td, cred); 9165fe58019SAttilio Rao facp.facc_flags &= ~FACCESS_XQUERIES; 9175fe58019SAttilio Rao 9185fe58019SAttilio Rao if (err) { 9195fe58019SAttilio Rao goto out; 9205fe58019SAttilio Rao } 9215fe58019SAttilio Rao if (nid == VTOI(dvp)) { 9225fe58019SAttilio Rao vref(dvp); 9235fe58019SAttilio Rao *vpp = dvp; 9245fe58019SAttilio Rao } else { 92509176f09SConrad Meyer err = fuse_vnode_get(dvp->v_mount, feo, nid, 92609176f09SConrad Meyer dvp, &vp, cnp, IFTOVT(fattr->mode)); 9275fe58019SAttilio Rao if (err) 9285fe58019SAttilio Rao goto out; 9295fe58019SAttilio Rao *vpp = vp; 9305fe58019SAttilio Rao } 9315fe58019SAttilio Rao 9325fe58019SAttilio Rao /* 9335fe58019SAttilio Rao * Save the name for use in VOP_RMDIR and VOP_REMOVE 9345fe58019SAttilio Rao * later. 9355fe58019SAttilio Rao */ 9365fe58019SAttilio Rao cnp->cn_flags |= SAVENAME; 9375fe58019SAttilio Rao goto out; 9385fe58019SAttilio Rao 9395fe58019SAttilio Rao } 9405fe58019SAttilio Rao /* 9415fe58019SAttilio Rao * If rewriting (RENAME), return the inode and the 9425fe58019SAttilio Rao * information required to rewrite the present directory 9435fe58019SAttilio Rao * Must get inode of directory entry to verify it's a 9445fe58019SAttilio Rao * regular file, or empty directory. 9455fe58019SAttilio Rao */ 9465fe58019SAttilio Rao if (nameiop == RENAME && wantparent && islastcn) { 9475fe58019SAttilio Rao 9485fe58019SAttilio Rao #if 0 /* THINK_ABOUT_THIS */ 9495fe58019SAttilio Rao if ((err = fuse_internal_access(dvp, VWRITE, cred, td, &facp))) { 9505fe58019SAttilio Rao goto out; 9515fe58019SAttilio Rao } 9525fe58019SAttilio Rao #endif 9535fe58019SAttilio Rao 9545fe58019SAttilio Rao /* 9555fe58019SAttilio Rao * Check for "." 9565fe58019SAttilio Rao */ 9575fe58019SAttilio Rao if (nid == VTOI(dvp)) { 9585fe58019SAttilio Rao err = EISDIR; 9595fe58019SAttilio Rao goto out; 9605fe58019SAttilio Rao } 96109176f09SConrad Meyer err = fuse_vnode_get(vnode_mount(dvp), feo, nid, dvp, 96209176f09SConrad Meyer &vp, cnp, IFTOVT(fattr->mode)); 9635fe58019SAttilio Rao if (err) { 9645fe58019SAttilio Rao goto out; 9655fe58019SAttilio Rao } 9665fe58019SAttilio Rao *vpp = vp; 9675fe58019SAttilio Rao /* 9685fe58019SAttilio Rao * Save the name for use in VOP_RENAME later. 9695fe58019SAttilio Rao */ 9705fe58019SAttilio Rao cnp->cn_flags |= SAVENAME; 9715fe58019SAttilio Rao 9725fe58019SAttilio Rao goto out; 9735fe58019SAttilio Rao } 9745fe58019SAttilio Rao if (flags & ISDOTDOT) { 9755fe58019SAttilio Rao struct mount *mp; 9765fe58019SAttilio Rao int ltype; 9775fe58019SAttilio Rao 9785fe58019SAttilio Rao /* 9795fe58019SAttilio Rao * Expanded copy of vn_vget_ino() so that 9805fe58019SAttilio Rao * fuse_vnode_get() can be used. 9815fe58019SAttilio Rao */ 9825fe58019SAttilio Rao mp = dvp->v_mount; 9835fe58019SAttilio Rao ltype = VOP_ISLOCKED(dvp); 9845fe58019SAttilio Rao err = vfs_busy(mp, MBF_NOWAIT); 9855fe58019SAttilio Rao if (err != 0) { 9865fe58019SAttilio Rao vfs_ref(mp); 9875fe58019SAttilio Rao VOP_UNLOCK(dvp, 0); 9885fe58019SAttilio Rao err = vfs_busy(mp, 0); 9895fe58019SAttilio Rao vn_lock(dvp, ltype | LK_RETRY); 9905fe58019SAttilio Rao vfs_rel(mp); 9915fe58019SAttilio Rao if (err) 9925fe58019SAttilio Rao goto out; 9935fe58019SAttilio Rao if ((dvp->v_iflag & VI_DOOMED) != 0) { 9945fe58019SAttilio Rao err = ENOENT; 9955fe58019SAttilio Rao vfs_unbusy(mp); 9965fe58019SAttilio Rao goto out; 9975fe58019SAttilio Rao } 9985fe58019SAttilio Rao } 9995fe58019SAttilio Rao VOP_UNLOCK(dvp, 0); 100009176f09SConrad Meyer err = fuse_vnode_get(vnode_mount(dvp), feo, nid, NULL, 100109176f09SConrad Meyer &vp, cnp, IFTOVT(fattr->mode)); 10025fe58019SAttilio Rao vfs_unbusy(mp); 10035fe58019SAttilio Rao vn_lock(dvp, ltype | LK_RETRY); 10045fe58019SAttilio Rao if ((dvp->v_iflag & VI_DOOMED) != 0) { 10055fe58019SAttilio Rao if (err == 0) 10065fe58019SAttilio Rao vput(vp); 10075fe58019SAttilio Rao err = ENOENT; 10085fe58019SAttilio Rao } 10095fe58019SAttilio Rao if (err) 10105fe58019SAttilio Rao goto out; 10115fe58019SAttilio Rao *vpp = vp; 10125fe58019SAttilio Rao } else if (nid == VTOI(dvp)) { 10135fe58019SAttilio Rao vref(dvp); 10145fe58019SAttilio Rao *vpp = dvp; 10155fe58019SAttilio Rao } else { 10163c324b94SConrad Meyer struct fuse_vnode_data *fvdat; 10173c324b94SConrad Meyer 101809176f09SConrad Meyer err = fuse_vnode_get(vnode_mount(dvp), feo, nid, dvp, 101909176f09SConrad Meyer &vp, cnp, IFTOVT(fattr->mode)); 10205fe58019SAttilio Rao if (err) { 10215fe58019SAttilio Rao goto out; 10225fe58019SAttilio Rao } 10235fe58019SAttilio Rao fuse_vnode_setparent(vp, dvp); 10243c324b94SConrad Meyer 10253c324b94SConrad Meyer /* 10263c324b94SConrad Meyer * In the case where we are looking up a FUSE node 10273c324b94SConrad Meyer * represented by an existing cached vnode, and the 10283c324b94SConrad Meyer * true size reported by FUSE_LOOKUP doesn't match 10293c324b94SConrad Meyer * the vnode's cached size, fix the vnode cache to 10303c324b94SConrad Meyer * match the real object size. 10313c324b94SConrad Meyer * 10323c324b94SConrad Meyer * This can occur via FUSE distributed filesystems, 10333c324b94SConrad Meyer * irregular files, etc. 10343c324b94SConrad Meyer */ 10353c324b94SConrad Meyer fvdat = VTOFUD(vp); 10363c324b94SConrad Meyer if (vnode_isreg(vp) && 10373c324b94SConrad Meyer fattr->size != fvdat->filesize) { 10383c324b94SConrad Meyer /* 10393c324b94SConrad Meyer * The FN_SIZECHANGE flag reflects a dirty 10403c324b94SConrad Meyer * append. If userspace lets us know our cache 10413c324b94SConrad Meyer * is invalid, that write was lost. (Dirty 10423c324b94SConrad Meyer * writes that do not cause append are also 10433c324b94SConrad Meyer * lost, but we don't detect them here.) 10443c324b94SConrad Meyer * 10453c324b94SConrad Meyer * XXX: Maybe disable WB caching on this mount. 10463c324b94SConrad Meyer */ 10473c324b94SConrad Meyer if (fvdat->flag & FN_SIZECHANGE) 10483c324b94SConrad Meyer printf("%s: WB cache incoherent on " 10493c324b94SConrad Meyer "%s!\n", __func__, 10503c324b94SConrad Meyer vnode_mount(vp)->mnt_stat.f_mntonname); 10513c324b94SConrad Meyer 10523c324b94SConrad Meyer (void)fuse_vnode_setsize(vp, cred, fattr->size); 10533c324b94SConrad Meyer fvdat->flag &= ~FN_SIZECHANGE; 10543c324b94SConrad Meyer } 10555fe58019SAttilio Rao *vpp = vp; 10565fe58019SAttilio Rao } 10575fe58019SAttilio Rao 10585fe58019SAttilio Rao if (op == FUSE_GETATTR) { 10597e4844f7SAlan Somers struct fuse_attr_out *fao = 10607e4844f7SAlan Somers (struct fuse_attr_out*)fdi.answ; 10617e4844f7SAlan Somers fuse_internal_cache_attrs(*vpp, 10627e4844f7SAlan Somers &fao->attr, fao->attr_valid, 10637e4844f7SAlan Somers fao->attr_valid_nsec, NULL); 10645fe58019SAttilio Rao } else { 10657e4844f7SAlan Somers struct fuse_entry_out *feo = 10667e4844f7SAlan Somers (struct fuse_entry_out*)fdi.answ; 10677e4844f7SAlan Somers fuse_internal_cache_attrs(*vpp, 10687e4844f7SAlan Somers &feo->attr, feo->attr_valid, 10697e4844f7SAlan Somers feo->attr_valid_nsec, NULL); 10705fe58019SAttilio Rao } 10715fe58019SAttilio Rao 10725fe58019SAttilio Rao /* Insert name into cache if appropriate. */ 10735fe58019SAttilio Rao 10745fe58019SAttilio Rao /* 10755fe58019SAttilio Rao * Nooo, caching is evil. With caching, we can't avoid stale 10765fe58019SAttilio Rao * information taking over the playground (cached info is not 10775fe58019SAttilio Rao * just positive/negative, it does have qualitative aspects, 10785fe58019SAttilio Rao * too). And a (VOP/FUSE)_GETATTR is always thrown anyway, when 10795fe58019SAttilio Rao * walking down along cached path components, and that's not 10805fe58019SAttilio Rao * any cheaper than FUSE_LOOKUP. This might change with 10815fe58019SAttilio Rao * implementing kernel side attr caching, but... In Linux, 10825fe58019SAttilio Rao * lookup results are not cached, and the daemon is bombarded 10835fe58019SAttilio Rao * with FUSE_LOOKUPS on and on. This shows that by design, the 10845fe58019SAttilio Rao * daemon is expected to handle frequent lookup queries 10855fe58019SAttilio Rao * efficiently, do its caching in userspace, and so on. 10865fe58019SAttilio Rao * 10875fe58019SAttilio Rao * So just leave the name cache alone. 10885fe58019SAttilio Rao */ 10895fe58019SAttilio Rao 10905fe58019SAttilio Rao /* 10915fe58019SAttilio Rao * Well, now I know, Linux caches lookups, but with a 10925fe58019SAttilio Rao * timeout... So it's the same thing as attribute caching: 10935fe58019SAttilio Rao * we can deal with it when implement timeouts. 10945fe58019SAttilio Rao */ 10955fe58019SAttilio Rao #if 0 10965fe58019SAttilio Rao if (cnp->cn_flags & MAKEENTRY) { 10975fe58019SAttilio Rao cache_enter(dvp, *vpp, cnp); 10985fe58019SAttilio Rao } 10995fe58019SAttilio Rao #endif 11005fe58019SAttilio Rao } 11015fe58019SAttilio Rao out: 11025fe58019SAttilio Rao if (!lookup_err) { 11035fe58019SAttilio Rao 11045fe58019SAttilio Rao /* No lookup error; need to clean up. */ 11055fe58019SAttilio Rao 11065fe58019SAttilio Rao if (err) { /* Found inode; exit with no vnode. */ 11075fe58019SAttilio Rao if (op == FUSE_LOOKUP) { 11085fe58019SAttilio Rao fuse_internal_forget_send(vnode_mount(dvp), td, cred, 11095fe58019SAttilio Rao nid, 1); 11105fe58019SAttilio Rao } 11115fe58019SAttilio Rao fdisp_destroy(&fdi); 11125fe58019SAttilio Rao return err; 11135fe58019SAttilio Rao } else { 11145fe58019SAttilio Rao #ifndef NO_EARLY_PERM_CHECK_HACK 11155fe58019SAttilio Rao if (!islastcn) { 11165fe58019SAttilio Rao /* 11175fe58019SAttilio Rao * We have the attributes of the next item 11185fe58019SAttilio Rao * *now*, and it's a fact, and we do not 11195fe58019SAttilio Rao * have to do extra work for it (ie, beg the 11205fe58019SAttilio Rao * daemon), and it neither depends on such 11215fe58019SAttilio Rao * accidental things like attr caching. So 11225fe58019SAttilio Rao * the big idea: check credentials *now*, 11235fe58019SAttilio Rao * not at the beginning of the next call to 11245fe58019SAttilio Rao * lookup. 11255fe58019SAttilio Rao * 11265fe58019SAttilio Rao * The first item of the lookup chain (fs root) 11275fe58019SAttilio Rao * won't be checked then here, of course, as 11285fe58019SAttilio Rao * its never "the next". But go and see that 11295fe58019SAttilio Rao * the root is taken care about at the very 11305fe58019SAttilio Rao * beginning of this function. 11315fe58019SAttilio Rao * 11325fe58019SAttilio Rao * Now, given we want to do the access check 11335fe58019SAttilio Rao * this way, one might ask: so then why not 11345fe58019SAttilio Rao * do the access check just after fetching 11355fe58019SAttilio Rao * the inode and its attributes from the 11365fe58019SAttilio Rao * daemon? Why bother with producing the 11375fe58019SAttilio Rao * corresponding vnode at all if something 11385fe58019SAttilio Rao * is not OK? We know what's the deal as 11395fe58019SAttilio Rao * soon as we get those attrs... There is 11405fe58019SAttilio Rao * one bit of info though not given us by 11415fe58019SAttilio Rao * the daemon: whether his response is 1142b3a15dddSPedro F. Giffuni * authoritative or not... His response should 11435fe58019SAttilio Rao * be ignored if something is mounted over 11445fe58019SAttilio Rao * the dir in question. But that can be 11455fe58019SAttilio Rao * known only by having the vnode... 11465fe58019SAttilio Rao */ 11475fe58019SAttilio Rao int tmpvtype = vnode_vtype(*vpp); 11485fe58019SAttilio Rao 11495fe58019SAttilio Rao bzero(&facp, sizeof(facp)); 11505fe58019SAttilio Rao /*the early perm check hack */ 11515fe58019SAttilio Rao facp.facc_flags |= FACCESS_VA_VALID; 11525fe58019SAttilio Rao 11535fe58019SAttilio Rao if ((tmpvtype != VDIR) && (tmpvtype != VLNK)) { 11545fe58019SAttilio Rao err = ENOTDIR; 11555fe58019SAttilio Rao } 11565fe58019SAttilio Rao if (!err && !vnode_mountedhere(*vpp)) { 11575fe58019SAttilio Rao err = fuse_internal_access(*vpp, VEXEC, &facp, td, cred); 11585fe58019SAttilio Rao } 11595fe58019SAttilio Rao if (err) { 11605fe58019SAttilio Rao if (tmpvtype == VLNK) 1161cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1162cf169498SAlan Somers 1, "weird, permission " 1163cf169498SAlan Somers "error with a symlink?"); 11645fe58019SAttilio Rao vput(*vpp); 11655fe58019SAttilio Rao *vpp = NULL; 11665fe58019SAttilio Rao } 11675fe58019SAttilio Rao } 11685fe58019SAttilio Rao #endif 11695fe58019SAttilio Rao } 11705fe58019SAttilio Rao } 11715fe58019SAttilio Rao fdisp_destroy(&fdi); 11725fe58019SAttilio Rao 11735fe58019SAttilio Rao return err; 11745fe58019SAttilio Rao } 11755fe58019SAttilio Rao 11765fe58019SAttilio Rao /* 11775fe58019SAttilio Rao struct vnop_mkdir_args { 11785fe58019SAttilio Rao struct vnode *a_dvp; 11795fe58019SAttilio Rao struct vnode **a_vpp; 11805fe58019SAttilio Rao struct componentname *a_cnp; 11815fe58019SAttilio Rao struct vattr *a_vap; 11825fe58019SAttilio Rao }; 11835fe58019SAttilio Rao */ 11845fe58019SAttilio Rao static int 11855fe58019SAttilio Rao fuse_vnop_mkdir(struct vop_mkdir_args *ap) 11865fe58019SAttilio Rao { 11875fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 11885fe58019SAttilio Rao struct vnode **vpp = ap->a_vpp; 11895fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 11905fe58019SAttilio Rao struct vattr *vap = ap->a_vap; 11915fe58019SAttilio Rao 11925fe58019SAttilio Rao struct fuse_mkdir_in fmdi; 11935fe58019SAttilio Rao 11945fe58019SAttilio Rao if (fuse_isdeadfs(dvp)) { 11955fe58019SAttilio Rao return ENXIO; 11965fe58019SAttilio Rao } 11975fe58019SAttilio Rao fmdi.mode = MAKEIMODE(vap->va_type, vap->va_mode); 11985fe58019SAttilio Rao 1199d9454fabSAttilio Rao return (fuse_internal_newentry(dvp, vpp, cnp, FUSE_MKDIR, &fmdi, 1200d9454fabSAttilio Rao sizeof(fmdi), VDIR)); 12015fe58019SAttilio Rao } 12025fe58019SAttilio Rao 12035fe58019SAttilio Rao /* 12045fe58019SAttilio Rao struct vnop_mknod_args { 12055fe58019SAttilio Rao struct vnode *a_dvp; 12065fe58019SAttilio Rao struct vnode **a_vpp; 12075fe58019SAttilio Rao struct componentname *a_cnp; 12085fe58019SAttilio Rao struct vattr *a_vap; 12095fe58019SAttilio Rao }; 12105fe58019SAttilio Rao */ 12115fe58019SAttilio Rao static int 12125fe58019SAttilio Rao fuse_vnop_mknod(struct vop_mknod_args *ap) 12135fe58019SAttilio Rao { 12145fe58019SAttilio Rao 1215bf4d7084SAlan Somers struct vnode *dvp = ap->a_dvp; 1216bf4d7084SAlan Somers struct vnode **vpp = ap->a_vpp; 1217bf4d7084SAlan Somers struct componentname *cnp = ap->a_cnp; 1218bf4d7084SAlan Somers struct vattr *vap = ap->a_vap; 1219bf4d7084SAlan Somers struct fuse_mknod_in fmni; 12205fe58019SAttilio Rao 1221bf4d7084SAlan Somers if (fuse_isdeadfs(dvp)) 1222bf4d7084SAlan Somers return ENXIO; 1223bf4d7084SAlan Somers 1224bf4d7084SAlan Somers fmni.mode = MAKEIMODE(vap->va_type, vap->va_mode); 1225bf4d7084SAlan Somers fmni.rdev = vap->va_rdev; 1226bf4d7084SAlan Somers return (fuse_internal_newentry(dvp, vpp, cnp, FUSE_MKNOD, &fmni, 1227bf4d7084SAlan Somers sizeof(fmni), vap->va_type)); 1228bf4d7084SAlan Somers } 12295fe58019SAttilio Rao 12305fe58019SAttilio Rao /* 12315fe58019SAttilio Rao struct vnop_open_args { 12325fe58019SAttilio Rao struct vnode *a_vp; 12335fe58019SAttilio Rao int a_mode; 12345fe58019SAttilio Rao struct ucred *a_cred; 12355fe58019SAttilio Rao struct thread *a_td; 12365fe58019SAttilio Rao int a_fdidx; / struct file *a_fp; 12375fe58019SAttilio Rao }; 12385fe58019SAttilio Rao */ 12395fe58019SAttilio Rao static int 12405fe58019SAttilio Rao fuse_vnop_open(struct vop_open_args *ap) 12415fe58019SAttilio Rao { 12425fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 12439e444871SAlan Somers int a_mode = ap->a_mode; 12445fe58019SAttilio Rao struct thread *td = ap->a_td; 12455fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 1246f8d4af10SAlan Somers pid_t pid = td->td_proc->p_pid; 12475fe58019SAttilio Rao struct fuse_vnode_data *fvdat; 12485fe58019SAttilio Rao 1249bf4d7084SAlan Somers if (fuse_isdeadfs(vp)) 12505fe58019SAttilio Rao return ENXIO; 1251bf4d7084SAlan Somers if (vp->v_type == VCHR || vp->v_type == VBLK || vp->v_type == VFIFO) 1252bf4d7084SAlan Somers return (EOPNOTSUPP); 12539e444871SAlan Somers if ((a_mode & (FREAD | FWRITE | FEXEC)) == 0) 1254e7df9886SConrad Meyer return EINVAL; 1255e7df9886SConrad Meyer 12565fe58019SAttilio Rao fvdat = VTOFUD(vp); 12575fe58019SAttilio Rao 12589e444871SAlan Somers if (fuse_filehandle_validrw(vp, a_mode, cred, pid)) { 12595fccbf31SAlan Somers fuse_vnode_open(vp, 0, td); 12605fe58019SAttilio Rao return 0; 12615fe58019SAttilio Rao } 12625fe58019SAttilio Rao 12639e444871SAlan Somers return fuse_filehandle_open(vp, a_mode, NULL, td, cred); 12645fe58019SAttilio Rao } 12655fe58019SAttilio Rao 1266746c92e0SJohn Baldwin static int 1267746c92e0SJohn Baldwin fuse_vnop_pathconf(struct vop_pathconf_args *ap) 1268746c92e0SJohn Baldwin { 1269746c92e0SJohn Baldwin 1270746c92e0SJohn Baldwin switch (ap->a_name) { 1271746c92e0SJohn Baldwin case _PC_FILESIZEBITS: 1272746c92e0SJohn Baldwin *ap->a_retval = 64; 1273746c92e0SJohn Baldwin return (0); 1274599afe53SJohn Baldwin case _PC_NAME_MAX: 1275599afe53SJohn Baldwin *ap->a_retval = NAME_MAX; 1276599afe53SJohn Baldwin return (0); 1277599afe53SJohn Baldwin case _PC_LINK_MAX: 1278f83f3d79SJohn Baldwin *ap->a_retval = MIN(LONG_MAX, FUSE_LINK_MAX); 1279599afe53SJohn Baldwin return (0); 1280746c92e0SJohn Baldwin case _PC_SYMLINK_MAX: 1281746c92e0SJohn Baldwin *ap->a_retval = MAXPATHLEN; 1282746c92e0SJohn Baldwin return (0); 1283746c92e0SJohn Baldwin case _PC_NO_TRUNC: 1284746c92e0SJohn Baldwin *ap->a_retval = 1; 1285746c92e0SJohn Baldwin return (0); 1286746c92e0SJohn Baldwin default: 1287746c92e0SJohn Baldwin return (vop_stdpathconf(ap)); 1288746c92e0SJohn Baldwin } 1289746c92e0SJohn Baldwin } 1290746c92e0SJohn Baldwin 12915fe58019SAttilio Rao /* 12925fe58019SAttilio Rao struct vnop_read_args { 12935fe58019SAttilio Rao struct vnode *a_vp; 12945fe58019SAttilio Rao struct uio *a_uio; 12955fe58019SAttilio Rao int a_ioflag; 12965fe58019SAttilio Rao struct ucred *a_cred; 12975fe58019SAttilio Rao }; 12985fe58019SAttilio Rao */ 12995fe58019SAttilio Rao static int 13005fe58019SAttilio Rao fuse_vnop_read(struct vop_read_args *ap) 13015fe58019SAttilio Rao { 13025fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 13035fe58019SAttilio Rao struct uio *uio = ap->a_uio; 13045fe58019SAttilio Rao int ioflag = ap->a_ioflag; 13055fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 1306f8d4af10SAlan Somers pid_t pid = curthread->td_proc->p_pid; 13075fe58019SAttilio Rao 13085fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 13095fe58019SAttilio Rao return ENXIO; 13105fe58019SAttilio Rao } 1311ead063e0SEdward Tomasz Napierala 1312ead063e0SEdward Tomasz Napierala if (VTOFUD(vp)->flag & FN_DIRECTIO) { 1313ead063e0SEdward Tomasz Napierala ioflag |= IO_DIRECT; 1314ead063e0SEdward Tomasz Napierala } 1315ead063e0SEdward Tomasz Napierala 1316f8d4af10SAlan Somers return fuse_io_dispatch(vp, uio, ioflag, cred, pid); 13175fe58019SAttilio Rao } 13185fe58019SAttilio Rao 13195fe58019SAttilio Rao /* 13205fe58019SAttilio Rao struct vnop_readdir_args { 13215fe58019SAttilio Rao struct vnode *a_vp; 13225fe58019SAttilio Rao struct uio *a_uio; 13235fe58019SAttilio Rao struct ucred *a_cred; 13245fe58019SAttilio Rao int *a_eofflag; 13255fe58019SAttilio Rao int *ncookies; 13265fe58019SAttilio Rao u_long **a_cookies; 13275fe58019SAttilio Rao }; 13285fe58019SAttilio Rao */ 13295fe58019SAttilio Rao static int 13305fe58019SAttilio Rao fuse_vnop_readdir(struct vop_readdir_args *ap) 13315fe58019SAttilio Rao { 13325fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 13335fe58019SAttilio Rao struct uio *uio = ap->a_uio; 13345fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 13355fe58019SAttilio Rao struct fuse_filehandle *fufh = NULL; 13365fe58019SAttilio Rao struct fuse_iov cookediov; 13375fe58019SAttilio Rao int err = 0; 1338f8d4af10SAlan Somers pid_t pid = curthread->td_proc->p_pid; 13395fe58019SAttilio Rao 13405fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 13415fe58019SAttilio Rao return ENXIO; 13425fe58019SAttilio Rao } 13435fe58019SAttilio Rao if ( /* XXXIP ((uio_iovcnt(uio) > 1)) || */ 13445fe58019SAttilio Rao (uio_resid(uio) < sizeof(struct dirent))) { 13455fe58019SAttilio Rao return EINVAL; 13465fe58019SAttilio Rao } 13475fe58019SAttilio Rao 134835cf0e7eSAlan Somers err = fuse_filehandle_get_dir(vp, &fufh, cred, pid); 134935cf0e7eSAlan Somers if (err) 13505fe58019SAttilio Rao return (err); 13515fe58019SAttilio Rao #define DIRCOOKEDSIZE FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + MAXNAMLEN + 1) 13525fe58019SAttilio Rao fiov_init(&cookediov, DIRCOOKEDSIZE); 13535fe58019SAttilio Rao 13545fe58019SAttilio Rao err = fuse_internal_readdir(vp, uio, fufh, &cookediov); 13555fe58019SAttilio Rao 13565fe58019SAttilio Rao fiov_teardown(&cookediov); 13575ec10aa5SAlan Somers 13585fe58019SAttilio Rao return err; 13595fe58019SAttilio Rao } 13605fe58019SAttilio Rao 13615fe58019SAttilio Rao /* 13625fe58019SAttilio Rao struct vnop_readlink_args { 13635fe58019SAttilio Rao struct vnode *a_vp; 13645fe58019SAttilio Rao struct uio *a_uio; 13655fe58019SAttilio Rao struct ucred *a_cred; 13665fe58019SAttilio Rao }; 13675fe58019SAttilio Rao */ 13685fe58019SAttilio Rao static int 13695fe58019SAttilio Rao fuse_vnop_readlink(struct vop_readlink_args *ap) 13705fe58019SAttilio Rao { 13715fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 13725fe58019SAttilio Rao struct uio *uio = ap->a_uio; 13735fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 13745fe58019SAttilio Rao 13755fe58019SAttilio Rao struct fuse_dispatcher fdi; 13765fe58019SAttilio Rao int err; 13775fe58019SAttilio Rao 13785fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 13795fe58019SAttilio Rao return ENXIO; 13805fe58019SAttilio Rao } 13815fe58019SAttilio Rao if (!vnode_islnk(vp)) { 13825fe58019SAttilio Rao return EINVAL; 13835fe58019SAttilio Rao } 13845fe58019SAttilio Rao fdisp_init(&fdi, 0); 13855fe58019SAttilio Rao err = fdisp_simple_putget_vp(&fdi, FUSE_READLINK, vp, curthread, cred); 13865fe58019SAttilio Rao if (err) { 13875fe58019SAttilio Rao goto out; 13885fe58019SAttilio Rao } 13895fe58019SAttilio Rao if (((char *)fdi.answ)[0] == '/' && 13905fe58019SAttilio Rao fuse_get_mpdata(vnode_mount(vp))->dataflags & FSESS_PUSH_SYMLINKS_IN) { 13915fe58019SAttilio Rao char *mpth = vnode_mount(vp)->mnt_stat.f_mntonname; 13925fe58019SAttilio Rao 13935fe58019SAttilio Rao err = uiomove(mpth, strlen(mpth), uio); 13945fe58019SAttilio Rao } 13955fe58019SAttilio Rao if (!err) { 13965fe58019SAttilio Rao err = uiomove(fdi.answ, fdi.iosize, uio); 13975fe58019SAttilio Rao } 13985fe58019SAttilio Rao out: 13995fe58019SAttilio Rao fdisp_destroy(&fdi); 14005fe58019SAttilio Rao return err; 14015fe58019SAttilio Rao } 14025fe58019SAttilio Rao 14035fe58019SAttilio Rao /* 14045fe58019SAttilio Rao struct vnop_reclaim_args { 14055fe58019SAttilio Rao struct vnode *a_vp; 14065fe58019SAttilio Rao struct thread *a_td; 14075fe58019SAttilio Rao }; 14085fe58019SAttilio Rao */ 14095fe58019SAttilio Rao static int 14105fe58019SAttilio Rao fuse_vnop_reclaim(struct vop_reclaim_args *ap) 14115fe58019SAttilio Rao { 14125fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 14135fe58019SAttilio Rao struct thread *td = ap->a_td; 14145fe58019SAttilio Rao struct fuse_vnode_data *fvdat = VTOFUD(vp); 14155ec10aa5SAlan Somers struct fuse_filehandle *fufh, *fufh_tmp; 14165fe58019SAttilio Rao 14175fe58019SAttilio Rao if (!fvdat) { 14185fe58019SAttilio Rao panic("FUSE: no vnode data during recycling"); 14195fe58019SAttilio Rao } 14205ec10aa5SAlan Somers LIST_FOREACH_SAFE(fufh, &fvdat->handles, next, fufh_tmp) { 14215ec10aa5SAlan Somers printf("FUSE: vnode being reclaimed with open fufh " 14229e444871SAlan Somers "(type=%#x)", fufh->fufh_type); 14235ec10aa5SAlan Somers fuse_filehandle_close(vp, fufh, td, NULL); 14245fe58019SAttilio Rao } 14255fe58019SAttilio Rao 14265fe58019SAttilio Rao if ((!fuse_isdeadfs(vp)) && (fvdat->nlookup)) { 14275fe58019SAttilio Rao fuse_internal_forget_send(vnode_mount(vp), td, NULL, VTOI(vp), 14285fe58019SAttilio Rao fvdat->nlookup); 14295fe58019SAttilio Rao } 14305fe58019SAttilio Rao fuse_vnode_setparent(vp, NULL); 14315fe58019SAttilio Rao cache_purge(vp); 14325fe58019SAttilio Rao vfs_hash_remove(vp); 14335fe58019SAttilio Rao vnode_destroy_vobject(vp); 14345fe58019SAttilio Rao fuse_vnode_destroy(vp); 14355fe58019SAttilio Rao 14365fe58019SAttilio Rao return 0; 14375fe58019SAttilio Rao } 14385fe58019SAttilio Rao 14395fe58019SAttilio Rao /* 14405fe58019SAttilio Rao struct vnop_remove_args { 14415fe58019SAttilio Rao struct vnode *a_dvp; 14425fe58019SAttilio Rao struct vnode *a_vp; 14435fe58019SAttilio Rao struct componentname *a_cnp; 14445fe58019SAttilio Rao }; 14455fe58019SAttilio Rao */ 14465fe58019SAttilio Rao static int 14475fe58019SAttilio Rao fuse_vnop_remove(struct vop_remove_args *ap) 14485fe58019SAttilio Rao { 14495fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 14505fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 14515fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 14525fe58019SAttilio Rao 14535fe58019SAttilio Rao int err; 14545fe58019SAttilio Rao 14555fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 14565fe58019SAttilio Rao return ENXIO; 14575fe58019SAttilio Rao } 14585fe58019SAttilio Rao if (vnode_isdir(vp)) { 14595fe58019SAttilio Rao return EPERM; 14605fe58019SAttilio Rao } 14615fe58019SAttilio Rao cache_purge(vp); 14625fe58019SAttilio Rao 14635fe58019SAttilio Rao err = fuse_internal_remove(dvp, vp, cnp, FUSE_UNLINK); 14645fe58019SAttilio Rao 1465d9454fabSAttilio Rao if (err == 0) 14665fe58019SAttilio Rao fuse_internal_vnode_disappear(vp); 14675fe58019SAttilio Rao return err; 14685fe58019SAttilio Rao } 14695fe58019SAttilio Rao 14705fe58019SAttilio Rao /* 14715fe58019SAttilio Rao struct vnop_rename_args { 14725fe58019SAttilio Rao struct vnode *a_fdvp; 14735fe58019SAttilio Rao struct vnode *a_fvp; 14745fe58019SAttilio Rao struct componentname *a_fcnp; 14755fe58019SAttilio Rao struct vnode *a_tdvp; 14765fe58019SAttilio Rao struct vnode *a_tvp; 14775fe58019SAttilio Rao struct componentname *a_tcnp; 14785fe58019SAttilio Rao }; 14795fe58019SAttilio Rao */ 14805fe58019SAttilio Rao static int 14815fe58019SAttilio Rao fuse_vnop_rename(struct vop_rename_args *ap) 14825fe58019SAttilio Rao { 14835fe58019SAttilio Rao struct vnode *fdvp = ap->a_fdvp; 14845fe58019SAttilio Rao struct vnode *fvp = ap->a_fvp; 14855fe58019SAttilio Rao struct componentname *fcnp = ap->a_fcnp; 14865fe58019SAttilio Rao struct vnode *tdvp = ap->a_tdvp; 14875fe58019SAttilio Rao struct vnode *tvp = ap->a_tvp; 14885fe58019SAttilio Rao struct componentname *tcnp = ap->a_tcnp; 14895fe58019SAttilio Rao struct fuse_data *data; 14905fe58019SAttilio Rao 14915fe58019SAttilio Rao int err = 0; 14925fe58019SAttilio Rao 14935fe58019SAttilio Rao if (fuse_isdeadfs(fdvp)) { 14945fe58019SAttilio Rao return ENXIO; 14955fe58019SAttilio Rao } 14965fe58019SAttilio Rao if (fvp->v_mount != tdvp->v_mount || 14975fe58019SAttilio Rao (tvp && fvp->v_mount != tvp->v_mount)) { 1498cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1, "cross-device rename"); 14995fe58019SAttilio Rao err = EXDEV; 15005fe58019SAttilio Rao goto out; 15015fe58019SAttilio Rao } 15025fe58019SAttilio Rao cache_purge(fvp); 15035fe58019SAttilio Rao 15045fe58019SAttilio Rao /* 15055fe58019SAttilio Rao * FUSE library is expected to check if target directory is not 15065fe58019SAttilio Rao * under the source directory in the file system tree. 15075fe58019SAttilio Rao * Linux performs this check at VFS level. 15085fe58019SAttilio Rao */ 15095fe58019SAttilio Rao data = fuse_get_mpdata(vnode_mount(tdvp)); 15105fe58019SAttilio Rao sx_xlock(&data->rename_lock); 15115fe58019SAttilio Rao err = fuse_internal_rename(fdvp, fcnp, tdvp, tcnp); 15125fe58019SAttilio Rao if (err == 0) { 1513d9454fabSAttilio Rao if (tdvp != fdvp) 15145fe58019SAttilio Rao fuse_vnode_setparent(fvp, tdvp); 15155fe58019SAttilio Rao if (tvp != NULL) 15165fe58019SAttilio Rao fuse_vnode_setparent(tvp, NULL); 15175fe58019SAttilio Rao } 15185fe58019SAttilio Rao sx_unlock(&data->rename_lock); 15195fe58019SAttilio Rao 15205fe58019SAttilio Rao if (tvp != NULL && tvp != fvp) { 15215fe58019SAttilio Rao cache_purge(tvp); 15225fe58019SAttilio Rao } 15235fe58019SAttilio Rao if (vnode_isdir(fvp)) { 15245fe58019SAttilio Rao if ((tvp != NULL) && vnode_isdir(tvp)) { 15255fe58019SAttilio Rao cache_purge(tdvp); 15265fe58019SAttilio Rao } 15275fe58019SAttilio Rao cache_purge(fdvp); 15285fe58019SAttilio Rao } 15295fe58019SAttilio Rao out: 15305fe58019SAttilio Rao if (tdvp == tvp) { 15315fe58019SAttilio Rao vrele(tdvp); 15325fe58019SAttilio Rao } else { 15335fe58019SAttilio Rao vput(tdvp); 15345fe58019SAttilio Rao } 15355fe58019SAttilio Rao if (tvp != NULL) { 15365fe58019SAttilio Rao vput(tvp); 15375fe58019SAttilio Rao } 15385fe58019SAttilio Rao vrele(fdvp); 15395fe58019SAttilio Rao vrele(fvp); 15405fe58019SAttilio Rao 15415fe58019SAttilio Rao return err; 15425fe58019SAttilio Rao } 15435fe58019SAttilio Rao 15445fe58019SAttilio Rao /* 15455fe58019SAttilio Rao struct vnop_rmdir_args { 15465fe58019SAttilio Rao struct vnode *a_dvp; 15475fe58019SAttilio Rao struct vnode *a_vp; 15485fe58019SAttilio Rao struct componentname *a_cnp; 15495fe58019SAttilio Rao } *ap; 15505fe58019SAttilio Rao */ 15515fe58019SAttilio Rao static int 15525fe58019SAttilio Rao fuse_vnop_rmdir(struct vop_rmdir_args *ap) 15535fe58019SAttilio Rao { 15545fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 15555fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 15565fe58019SAttilio Rao 15575fe58019SAttilio Rao int err; 15585fe58019SAttilio Rao 15595fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 15605fe58019SAttilio Rao return ENXIO; 15615fe58019SAttilio Rao } 15625fe58019SAttilio Rao if (VTOFUD(vp) == VTOFUD(dvp)) { 15635fe58019SAttilio Rao return EINVAL; 15645fe58019SAttilio Rao } 15655fe58019SAttilio Rao err = fuse_internal_remove(dvp, vp, ap->a_cnp, FUSE_RMDIR); 15665fe58019SAttilio Rao 1567d9454fabSAttilio Rao if (err == 0) 15685fe58019SAttilio Rao fuse_internal_vnode_disappear(vp); 15695fe58019SAttilio Rao return err; 15705fe58019SAttilio Rao } 15715fe58019SAttilio Rao 15725fe58019SAttilio Rao /* 15735fe58019SAttilio Rao struct vnop_setattr_args { 15745fe58019SAttilio Rao struct vnode *a_vp; 15755fe58019SAttilio Rao struct vattr *a_vap; 15765fe58019SAttilio Rao struct ucred *a_cred; 15775fe58019SAttilio Rao struct thread *a_td; 15785fe58019SAttilio Rao }; 15795fe58019SAttilio Rao */ 15805fe58019SAttilio Rao static int 15815fe58019SAttilio Rao fuse_vnop_setattr(struct vop_setattr_args *ap) 15825fe58019SAttilio Rao { 15835fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 15845fe58019SAttilio Rao struct vattr *vap = ap->a_vap; 15855fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 15865fe58019SAttilio Rao struct thread *td = curthread; 15875fe58019SAttilio Rao struct fuse_dispatcher fdi; 15885fe58019SAttilio Rao struct fuse_setattr_in *fsai; 15895fe58019SAttilio Rao struct fuse_access_param facp; 1590f8d4af10SAlan Somers pid_t pid = td->td_proc->p_pid; 15915fe58019SAttilio Rao 15925fe58019SAttilio Rao int err = 0; 15935fe58019SAttilio Rao enum vtype vtyp; 15945fe58019SAttilio Rao int sizechanged = 0; 15955fe58019SAttilio Rao uint64_t newsize = 0; 15965fe58019SAttilio Rao 15975fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 15985fe58019SAttilio Rao return ENXIO; 15995fe58019SAttilio Rao } 16005fe58019SAttilio Rao fdisp_init(&fdi, sizeof(*fsai)); 16015fe58019SAttilio Rao fdisp_make_vp(&fdi, FUSE_SETATTR, vp, td, cred); 16025fe58019SAttilio Rao fsai = fdi.indata; 16035fe58019SAttilio Rao fsai->valid = 0; 16045fe58019SAttilio Rao 16055fe58019SAttilio Rao bzero(&facp, sizeof(facp)); 16065fe58019SAttilio Rao 16075fe58019SAttilio Rao facp.xuid = vap->va_uid; 16085fe58019SAttilio Rao facp.xgid = vap->va_gid; 16095fe58019SAttilio Rao 16105fe58019SAttilio Rao if (vap->va_uid != (uid_t)VNOVAL) { 16115fe58019SAttilio Rao facp.facc_flags |= FACCESS_CHOWN; 16125fe58019SAttilio Rao fsai->uid = vap->va_uid; 16135fe58019SAttilio Rao fsai->valid |= FATTR_UID; 16145fe58019SAttilio Rao } 16155fe58019SAttilio Rao if (vap->va_gid != (gid_t)VNOVAL) { 16165fe58019SAttilio Rao facp.facc_flags |= FACCESS_CHOWN; 16175fe58019SAttilio Rao fsai->gid = vap->va_gid; 16185fe58019SAttilio Rao fsai->valid |= FATTR_GID; 16195fe58019SAttilio Rao } 16205fe58019SAttilio Rao if (vap->va_size != VNOVAL) { 16215fe58019SAttilio Rao 16225fe58019SAttilio Rao struct fuse_filehandle *fufh = NULL; 16235fe58019SAttilio Rao 16245fe58019SAttilio Rao /*Truncate to a new value. */ 16255fe58019SAttilio Rao fsai->size = vap->va_size; 16265fe58019SAttilio Rao sizechanged = 1; 16275fe58019SAttilio Rao newsize = vap->va_size; 16285fe58019SAttilio Rao fsai->valid |= FATTR_SIZE; 16295fe58019SAttilio Rao 16309f10f423SAlan Somers fuse_filehandle_getrw(vp, FWRITE, &fufh, cred, pid); 16315fe58019SAttilio Rao if (fufh) { 16325fe58019SAttilio Rao fsai->fh = fufh->fh_id; 16335fe58019SAttilio Rao fsai->valid |= FATTR_FH; 16345fe58019SAttilio Rao } 16355fe58019SAttilio Rao } 16365fe58019SAttilio Rao if (vap->va_atime.tv_sec != VNOVAL) { 16375fe58019SAttilio Rao fsai->atime = vap->va_atime.tv_sec; 16385fe58019SAttilio Rao fsai->atimensec = vap->va_atime.tv_nsec; 16395fe58019SAttilio Rao fsai->valid |= FATTR_ATIME; 16405fe58019SAttilio Rao } 16415fe58019SAttilio Rao if (vap->va_mtime.tv_sec != VNOVAL) { 16425fe58019SAttilio Rao fsai->mtime = vap->va_mtime.tv_sec; 16435fe58019SAttilio Rao fsai->mtimensec = vap->va_mtime.tv_nsec; 16445fe58019SAttilio Rao fsai->valid |= FATTR_MTIME; 16455fe58019SAttilio Rao } 16465fe58019SAttilio Rao if (vap->va_mode != (mode_t)VNOVAL) { 16475fe58019SAttilio Rao fsai->mode = vap->va_mode & ALLPERMS; 16485fe58019SAttilio Rao fsai->valid |= FATTR_MODE; 16495fe58019SAttilio Rao } 16505fe58019SAttilio Rao if (!fsai->valid) { 16515fe58019SAttilio Rao goto out; 16525fe58019SAttilio Rao } 16535fe58019SAttilio Rao vtyp = vnode_vtype(vp); 16545fe58019SAttilio Rao 16555fe58019SAttilio Rao if (fsai->valid & FATTR_SIZE && vtyp == VDIR) { 16565fe58019SAttilio Rao err = EISDIR; 16575fe58019SAttilio Rao goto out; 16585fe58019SAttilio Rao } 16595fe58019SAttilio Rao if (vfs_isrdonly(vnode_mount(vp)) && (fsai->valid & ~FATTR_SIZE || vtyp == VREG)) { 16605fe58019SAttilio Rao err = EROFS; 16615fe58019SAttilio Rao goto out; 16625fe58019SAttilio Rao } 16635fe58019SAttilio Rao 1664d9454fabSAttilio Rao if ((err = fdisp_wait_answ(&fdi))) 16655fe58019SAttilio Rao goto out; 16665fe58019SAttilio Rao vtyp = IFTOVT(((struct fuse_attr_out *)fdi.answ)->attr.mode); 16675fe58019SAttilio Rao 16685fe58019SAttilio Rao if (vnode_vtype(vp) != vtyp) { 16695fe58019SAttilio Rao if (vnode_vtype(vp) == VNON && vtyp != VNON) { 1670cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1, "FUSE: Dang! " 1671cf169498SAlan Somers "vnode_vtype is VNON and vtype isn't."); 16725fe58019SAttilio Rao } else { 16735fe58019SAttilio Rao /* 16745fe58019SAttilio Rao * STALE vnode, ditch 16755fe58019SAttilio Rao * 1676cf169498SAlan Somers * The vnode has changed its type "behind our back". 1677cf169498SAlan Somers * There's nothing really we can do, so let us just 1678cf169498SAlan Somers * force an internal revocation and tell the caller to 1679cf169498SAlan Somers * try again, if interested. 16805fe58019SAttilio Rao */ 16815fe58019SAttilio Rao fuse_internal_vnode_disappear(vp); 16825fe58019SAttilio Rao err = EAGAIN; 16835fe58019SAttilio Rao } 16845fe58019SAttilio Rao } 16857e4844f7SAlan Somers if (err == 0) { 16867e4844f7SAlan Somers struct fuse_attr_out *fao = (struct fuse_attr_out*)fdi.answ; 16877e4844f7SAlan Somers fuse_internal_cache_attrs(vp, &fao->attr, fao->attr_valid, 16887e4844f7SAlan Somers fao->attr_valid_nsec, NULL); 16897e4844f7SAlan Somers } 1690194e691aSConrad Meyer 16915fe58019SAttilio Rao out: 16925fe58019SAttilio Rao fdisp_destroy(&fdi); 16935fe58019SAttilio Rao if (!err && sizechanged) { 16945fe58019SAttilio Rao fuse_vnode_setsize(vp, cred, newsize); 16955fe58019SAttilio Rao VTOFUD(vp)->flag &= ~FN_SIZECHANGE; 16965fe58019SAttilio Rao } 16975fe58019SAttilio Rao return err; 16985fe58019SAttilio Rao } 16995fe58019SAttilio Rao 17005fe58019SAttilio Rao /* 17015fe58019SAttilio Rao struct vnop_strategy_args { 17025fe58019SAttilio Rao struct vnode *a_vp; 17035fe58019SAttilio Rao struct buf *a_bp; 17045fe58019SAttilio Rao }; 17055fe58019SAttilio Rao */ 17065fe58019SAttilio Rao static int 17075fe58019SAttilio Rao fuse_vnop_strategy(struct vop_strategy_args *ap) 17085fe58019SAttilio Rao { 17095fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 17105fe58019SAttilio Rao struct buf *bp = ap->a_bp; 17115fe58019SAttilio Rao 17125fe58019SAttilio Rao if (!vp || fuse_isdeadfs(vp)) { 17135fe58019SAttilio Rao bp->b_ioflags |= BIO_ERROR; 17145fe58019SAttilio Rao bp->b_error = ENXIO; 17155fe58019SAttilio Rao bufdone(bp); 171698852a32SAlan Somers return 0; 17175fe58019SAttilio Rao } 1718f203d173SAlan Somers if (bp->b_iocmd == BIO_WRITE) { 1719f203d173SAlan Somers int err; 17205fe58019SAttilio Rao 1721f203d173SAlan Somers err = fuse_vnode_refreshsize(vp, NOCRED); 1722f203d173SAlan Somers if (err) { 1723f203d173SAlan Somers bp->b_ioflags |= BIO_ERROR; 1724f203d173SAlan Somers bp->b_error = err; 172598852a32SAlan Somers bufdone(bp); 1726f203d173SAlan Somers return 0; 1727f203d173SAlan Somers } 1728f203d173SAlan Somers } 17295fe58019SAttilio Rao 17305fe58019SAttilio Rao /* 1731f203d173SAlan Somers * VOP_STRATEGY always returns zero and signals error via bp->b_ioflags. 1732f203d173SAlan Somers * fuse_io_strategy sets bp's error fields 17335fe58019SAttilio Rao */ 1734f203d173SAlan Somers (void)fuse_io_strategy(vp, bp); 1735f203d173SAlan Somers 17365fe58019SAttilio Rao return 0; 17375fe58019SAttilio Rao } 17385fe58019SAttilio Rao 17395fe58019SAttilio Rao 17405fe58019SAttilio Rao /* 17415fe58019SAttilio Rao struct vnop_symlink_args { 17425fe58019SAttilio Rao struct vnode *a_dvp; 17435fe58019SAttilio Rao struct vnode **a_vpp; 17445fe58019SAttilio Rao struct componentname *a_cnp; 17455fe58019SAttilio Rao struct vattr *a_vap; 17465fe58019SAttilio Rao char *a_target; 17475fe58019SAttilio Rao }; 17485fe58019SAttilio Rao */ 17495fe58019SAttilio Rao static int 17505fe58019SAttilio Rao fuse_vnop_symlink(struct vop_symlink_args *ap) 17515fe58019SAttilio Rao { 17525fe58019SAttilio Rao struct vnode *dvp = ap->a_dvp; 17535fe58019SAttilio Rao struct vnode **vpp = ap->a_vpp; 17545fe58019SAttilio Rao struct componentname *cnp = ap->a_cnp; 17551493c2eeSBrooks Davis const char *target = ap->a_target; 17565fe58019SAttilio Rao 17575fe58019SAttilio Rao struct fuse_dispatcher fdi; 17585fe58019SAttilio Rao 17595fe58019SAttilio Rao int err; 17605fe58019SAttilio Rao size_t len; 17615fe58019SAttilio Rao 17625fe58019SAttilio Rao if (fuse_isdeadfs(dvp)) { 17635fe58019SAttilio Rao return ENXIO; 17645fe58019SAttilio Rao } 17655fe58019SAttilio Rao /* 17665fe58019SAttilio Rao * Unlike the other creator type calls, here we have to create a message 17675fe58019SAttilio Rao * where the name of the new entry comes first, and the data describing 17685fe58019SAttilio Rao * the entry comes second. 17695fe58019SAttilio Rao * Hence we can't rely on our handy fuse_internal_newentry() routine, 17705fe58019SAttilio Rao * but put together the message manually and just call the core part. 17715fe58019SAttilio Rao */ 17725fe58019SAttilio Rao 17735fe58019SAttilio Rao len = strlen(target) + 1; 17745fe58019SAttilio Rao fdisp_init(&fdi, len + cnp->cn_namelen + 1); 17755fe58019SAttilio Rao fdisp_make_vp(&fdi, FUSE_SYMLINK, dvp, curthread, NULL); 17765fe58019SAttilio Rao 17775fe58019SAttilio Rao memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen); 17785fe58019SAttilio Rao ((char *)fdi.indata)[cnp->cn_namelen] = '\0'; 17795fe58019SAttilio Rao memcpy((char *)fdi.indata + cnp->cn_namelen + 1, target, len); 17805fe58019SAttilio Rao 17815fe58019SAttilio Rao err = fuse_internal_newentry_core(dvp, vpp, cnp, VLNK, &fdi); 17825fe58019SAttilio Rao fdisp_destroy(&fdi); 17835fe58019SAttilio Rao return err; 17845fe58019SAttilio Rao } 17855fe58019SAttilio Rao 17865fe58019SAttilio Rao /* 17875fe58019SAttilio Rao struct vnop_write_args { 17885fe58019SAttilio Rao struct vnode *a_vp; 17895fe58019SAttilio Rao struct uio *a_uio; 17905fe58019SAttilio Rao int a_ioflag; 17915fe58019SAttilio Rao struct ucred *a_cred; 17925fe58019SAttilio Rao }; 17935fe58019SAttilio Rao */ 17945fe58019SAttilio Rao static int 17955fe58019SAttilio Rao fuse_vnop_write(struct vop_write_args *ap) 17965fe58019SAttilio Rao { 17975fe58019SAttilio Rao struct vnode *vp = ap->a_vp; 17985fe58019SAttilio Rao struct uio *uio = ap->a_uio; 17995fe58019SAttilio Rao int ioflag = ap->a_ioflag; 18005fe58019SAttilio Rao struct ucred *cred = ap->a_cred; 1801f8d4af10SAlan Somers pid_t pid = curthread->td_proc->p_pid; 1802f203d173SAlan Somers int err; 18035fe58019SAttilio Rao 18045fe58019SAttilio Rao if (fuse_isdeadfs(vp)) { 18055fe58019SAttilio Rao return ENXIO; 18065fe58019SAttilio Rao } 1807f203d173SAlan Somers err = fuse_vnode_refreshsize(vp, cred); 1808f203d173SAlan Somers if (err) 1809f203d173SAlan Somers return err; 18105fe58019SAttilio Rao 1811ead063e0SEdward Tomasz Napierala if (VTOFUD(vp)->flag & FN_DIRECTIO) { 1812ead063e0SEdward Tomasz Napierala ioflag |= IO_DIRECT; 1813ead063e0SEdward Tomasz Napierala } 1814ead063e0SEdward Tomasz Napierala 1815f8d4af10SAlan Somers return fuse_io_dispatch(vp, uio, ioflag, cred, pid); 18165fe58019SAttilio Rao } 18175fe58019SAttilio Rao 1818cf169498SAlan Somers SDT_PROBE_DEFINE1(fuse, , vnops, vnop_getpages_error, "int"); 18195fe58019SAttilio Rao /* 18205fe58019SAttilio Rao struct vnop_getpages_args { 18215fe58019SAttilio Rao struct vnode *a_vp; 18225fe58019SAttilio Rao vm_page_t *a_m; 18235fe58019SAttilio Rao int a_count; 18245fe58019SAttilio Rao int a_reqpage; 18255fe58019SAttilio Rao }; 18265fe58019SAttilio Rao */ 18275fe58019SAttilio Rao static int 18285fe58019SAttilio Rao fuse_vnop_getpages(struct vop_getpages_args *ap) 18295fe58019SAttilio Rao { 18305fe58019SAttilio Rao int i, error, nextoff, size, toff, count, npages; 18315fe58019SAttilio Rao struct uio uio; 18325fe58019SAttilio Rao struct iovec iov; 18335fe58019SAttilio Rao vm_offset_t kva; 18345fe58019SAttilio Rao struct buf *bp; 18355fe58019SAttilio Rao struct vnode *vp; 18365fe58019SAttilio Rao struct thread *td; 18375fe58019SAttilio Rao struct ucred *cred; 18385fe58019SAttilio Rao vm_page_t *pages; 1839f8d4af10SAlan Somers pid_t pid = curthread->td_proc->p_pid; 18405fe58019SAttilio Rao 18415fe58019SAttilio Rao vp = ap->a_vp; 18425fe58019SAttilio Rao KASSERT(vp->v_object, ("objectless vp passed to getpages")); 18435fe58019SAttilio Rao td = curthread; /* XXX */ 18445fe58019SAttilio Rao cred = curthread->td_ucred; /* XXX */ 18455fe58019SAttilio Rao pages = ap->a_m; 1846f17f88d3SGleb Smirnoff npages = ap->a_count; 18475fe58019SAttilio Rao 18485fe58019SAttilio Rao if (!fsess_opt_mmap(vnode_mount(vp))) { 1849cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1, 1850cf169498SAlan Somers "called on non-cacheable vnode??\n"); 18515fe58019SAttilio Rao return (VM_PAGER_ERROR); 18525fe58019SAttilio Rao } 18535fe58019SAttilio Rao 18545fe58019SAttilio Rao /* 1855b0cd2017SGleb Smirnoff * If the last page is partially valid, just return it and allow 1856b0cd2017SGleb Smirnoff * the pager to zero-out the blanks. Partially valid pages can 1857b0cd2017SGleb Smirnoff * only occur at the file EOF. 1858b0cd2017SGleb Smirnoff * 1859b0cd2017SGleb Smirnoff * XXXGL: is that true for FUSE, which is a local filesystem, 1860b0cd2017SGleb Smirnoff * but still somewhat disconnected from the kernel? 18615fe58019SAttilio Rao */ 186289f6b863SAttilio Rao VM_OBJECT_WLOCK(vp->v_object); 1863f17f88d3SGleb Smirnoff if (pages[npages - 1]->valid != 0 && --npages == 0) 1864f17f88d3SGleb Smirnoff goto out; 186589f6b863SAttilio Rao VM_OBJECT_WUNLOCK(vp->v_object); 18665fe58019SAttilio Rao 18675fe58019SAttilio Rao /* 18685fe58019SAttilio Rao * We use only the kva address for the buffer, but this is extremely 1869b3a15dddSPedro F. Giffuni * convenient and fast. 18705fe58019SAttilio Rao */ 1871756a5412SGleb Smirnoff bp = uma_zalloc(fuse_pbuf_zone, M_WAITOK); 18725fe58019SAttilio Rao 18735fe58019SAttilio Rao kva = (vm_offset_t)bp->b_data; 18745fe58019SAttilio Rao pmap_qenter(kva, pages, npages); 187583c9dea1SGleb Smirnoff VM_CNT_INC(v_vnodein); 187683c9dea1SGleb Smirnoff VM_CNT_ADD(v_vnodepgsin, npages); 18775fe58019SAttilio Rao 1878f17f88d3SGleb Smirnoff count = npages << PAGE_SHIFT; 18795fe58019SAttilio Rao iov.iov_base = (caddr_t)kva; 18805fe58019SAttilio Rao iov.iov_len = count; 18815fe58019SAttilio Rao uio.uio_iov = &iov; 18825fe58019SAttilio Rao uio.uio_iovcnt = 1; 18835fe58019SAttilio Rao uio.uio_offset = IDX_TO_OFF(pages[0]->pindex); 18845fe58019SAttilio Rao uio.uio_resid = count; 18855fe58019SAttilio Rao uio.uio_segflg = UIO_SYSSPACE; 18865fe58019SAttilio Rao uio.uio_rw = UIO_READ; 18875fe58019SAttilio Rao uio.uio_td = td; 18885fe58019SAttilio Rao 1889f8d4af10SAlan Somers error = fuse_io_dispatch(vp, &uio, IO_DIRECT, cred, pid); 18905fe58019SAttilio Rao pmap_qremove(kva, npages); 18915fe58019SAttilio Rao 1892756a5412SGleb Smirnoff uma_zfree(fuse_pbuf_zone, bp); 18935fe58019SAttilio Rao 18945fe58019SAttilio Rao if (error && (uio.uio_resid == count)) { 1895cf169498SAlan Somers SDT_PROBE1(fuse, , vnops, vnop_getpages_error, error); 18965fe58019SAttilio Rao return VM_PAGER_ERROR; 18975fe58019SAttilio Rao } 18985fe58019SAttilio Rao /* 18995fe58019SAttilio Rao * Calculate the number of bytes read and validate only that number 19005fe58019SAttilio Rao * of bytes. Note that due to pending writes, size may be 0. This 19015fe58019SAttilio Rao * does not mean that the remaining data is invalid! 19025fe58019SAttilio Rao */ 19035fe58019SAttilio Rao 19045fe58019SAttilio Rao size = count - uio.uio_resid; 190589f6b863SAttilio Rao VM_OBJECT_WLOCK(vp->v_object); 19065fe58019SAttilio Rao fuse_vm_page_lock_queues(); 19075fe58019SAttilio Rao for (i = 0, toff = 0; i < npages; i++, toff = nextoff) { 19085fe58019SAttilio Rao vm_page_t m; 19095fe58019SAttilio Rao 19105fe58019SAttilio Rao nextoff = toff + PAGE_SIZE; 19115fe58019SAttilio Rao m = pages[i]; 19125fe58019SAttilio Rao 19135fe58019SAttilio Rao if (nextoff <= size) { 19145fe58019SAttilio Rao /* 19155fe58019SAttilio Rao * Read operation filled an entire page 19165fe58019SAttilio Rao */ 19175fe58019SAttilio Rao m->valid = VM_PAGE_BITS_ALL; 19185fe58019SAttilio Rao KASSERT(m->dirty == 0, 19195fe58019SAttilio Rao ("fuse_getpages: page %p is dirty", m)); 19205fe58019SAttilio Rao } else if (size > toff) { 19215fe58019SAttilio Rao /* 19225fe58019SAttilio Rao * Read operation filled a partial page. 19235fe58019SAttilio Rao */ 19245fe58019SAttilio Rao m->valid = 0; 19255fe58019SAttilio Rao vm_page_set_valid_range(m, 0, size - toff); 19265fe58019SAttilio Rao KASSERT(m->dirty == 0, 19275fe58019SAttilio Rao ("fuse_getpages: page %p is dirty", m)); 19285fe58019SAttilio Rao } else { 19295fe58019SAttilio Rao /* 1930b3a15dddSPedro F. Giffuni * Read operation was short. If no error occurred 19315fe58019SAttilio Rao * we may have hit a zero-fill section. We simply 19325fe58019SAttilio Rao * leave valid set to 0. 19335fe58019SAttilio Rao */ 19345fe58019SAttilio Rao ; 19355fe58019SAttilio Rao } 19365fe58019SAttilio Rao } 19375fe58019SAttilio Rao fuse_vm_page_unlock_queues(); 1938f17f88d3SGleb Smirnoff out: 193989f6b863SAttilio Rao VM_OBJECT_WUNLOCK(vp->v_object); 1940f17f88d3SGleb Smirnoff if (ap->a_rbehind) 1941f17f88d3SGleb Smirnoff *ap->a_rbehind = 0; 1942f17f88d3SGleb Smirnoff if (ap->a_rahead) 1943f17f88d3SGleb Smirnoff *ap->a_rahead = 0; 1944f17f88d3SGleb Smirnoff return (VM_PAGER_OK); 19455fe58019SAttilio Rao } 19465fe58019SAttilio Rao 19475fe58019SAttilio Rao /* 19485fe58019SAttilio Rao struct vnop_putpages_args { 19495fe58019SAttilio Rao struct vnode *a_vp; 19505fe58019SAttilio Rao vm_page_t *a_m; 19515fe58019SAttilio Rao int a_count; 19525fe58019SAttilio Rao int a_sync; 19535fe58019SAttilio Rao int *a_rtvals; 19545fe58019SAttilio Rao vm_ooffset_t a_offset; 19555fe58019SAttilio Rao }; 19565fe58019SAttilio Rao */ 19575fe58019SAttilio Rao static int 19585fe58019SAttilio Rao fuse_vnop_putpages(struct vop_putpages_args *ap) 19595fe58019SAttilio Rao { 19605fe58019SAttilio Rao struct uio uio; 19615fe58019SAttilio Rao struct iovec iov; 19625fe58019SAttilio Rao vm_offset_t kva; 19635fe58019SAttilio Rao struct buf *bp; 19645fe58019SAttilio Rao int i, error, npages, count; 19655fe58019SAttilio Rao off_t offset; 19665fe58019SAttilio Rao int *rtvals; 19675fe58019SAttilio Rao struct vnode *vp; 19685fe58019SAttilio Rao struct thread *td; 19695fe58019SAttilio Rao struct ucred *cred; 19705fe58019SAttilio Rao vm_page_t *pages; 19715fe58019SAttilio Rao vm_ooffset_t fsize; 1972f8d4af10SAlan Somers pid_t pid = curthread->td_proc->p_pid; 19735fe58019SAttilio Rao 19745fe58019SAttilio Rao vp = ap->a_vp; 19755fe58019SAttilio Rao KASSERT(vp->v_object, ("objectless vp passed to putpages")); 19765fe58019SAttilio Rao fsize = vp->v_object->un_pager.vnp.vnp_size; 19775fe58019SAttilio Rao td = curthread; /* XXX */ 19785fe58019SAttilio Rao cred = curthread->td_ucred; /* XXX */ 19795fe58019SAttilio Rao pages = ap->a_m; 19805fe58019SAttilio Rao count = ap->a_count; 19815fe58019SAttilio Rao rtvals = ap->a_rtvals; 19825fe58019SAttilio Rao npages = btoc(count); 19835fe58019SAttilio Rao offset = IDX_TO_OFF(pages[0]->pindex); 19845fe58019SAttilio Rao 19855fe58019SAttilio Rao if (!fsess_opt_mmap(vnode_mount(vp))) { 1986cf169498SAlan Somers SDT_PROBE2(fuse, , vnops, trace, 1, 1987cf169498SAlan Somers "called on non-cacheable vnode??\n"); 19885fe58019SAttilio Rao } 19895fe58019SAttilio Rao for (i = 0; i < npages; i++) 19905fe58019SAttilio Rao rtvals[i] = VM_PAGER_AGAIN; 19915fe58019SAttilio Rao 19925fe58019SAttilio Rao /* 19935fe58019SAttilio Rao * When putting pages, do not extend file past EOF. 19945fe58019SAttilio Rao */ 19955fe58019SAttilio Rao 19965fe58019SAttilio Rao if (offset + count > fsize) { 19975fe58019SAttilio Rao count = fsize - offset; 19985fe58019SAttilio Rao if (count < 0) 19995fe58019SAttilio Rao count = 0; 20005fe58019SAttilio Rao } 20015fe58019SAttilio Rao /* 20025fe58019SAttilio Rao * We use only the kva address for the buffer, but this is extremely 2003b3a15dddSPedro F. Giffuni * convenient and fast. 20045fe58019SAttilio Rao */ 2005756a5412SGleb Smirnoff bp = uma_zalloc(fuse_pbuf_zone, M_WAITOK); 20065fe58019SAttilio Rao 20075fe58019SAttilio Rao kva = (vm_offset_t)bp->b_data; 20085fe58019SAttilio Rao pmap_qenter(kva, pages, npages); 200983c9dea1SGleb Smirnoff VM_CNT_INC(v_vnodeout); 201083c9dea1SGleb Smirnoff VM_CNT_ADD(v_vnodepgsout, count); 20115fe58019SAttilio Rao 20125fe58019SAttilio Rao iov.iov_base = (caddr_t)kva; 20135fe58019SAttilio Rao iov.iov_len = count; 20145fe58019SAttilio Rao uio.uio_iov = &iov; 20155fe58019SAttilio Rao uio.uio_iovcnt = 1; 20165fe58019SAttilio Rao uio.uio_offset = offset; 20175fe58019SAttilio Rao uio.uio_resid = count; 20185fe58019SAttilio Rao uio.uio_segflg = UIO_SYSSPACE; 20195fe58019SAttilio Rao uio.uio_rw = UIO_WRITE; 20205fe58019SAttilio Rao uio.uio_td = td; 20215fe58019SAttilio Rao 2022f8d4af10SAlan Somers error = fuse_io_dispatch(vp, &uio, IO_DIRECT, cred, pid); 20235fe58019SAttilio Rao 20245fe58019SAttilio Rao pmap_qremove(kva, npages); 2025756a5412SGleb Smirnoff uma_zfree(fuse_pbuf_zone, bp); 20265fe58019SAttilio Rao 20275fe58019SAttilio Rao if (!error) { 20285fe58019SAttilio Rao int nwritten = round_page(count - uio.uio_resid) / PAGE_SIZE; 20295fe58019SAttilio Rao 20305fe58019SAttilio Rao for (i = 0; i < nwritten; i++) { 20315fe58019SAttilio Rao rtvals[i] = VM_PAGER_OK; 203289f6b863SAttilio Rao VM_OBJECT_WLOCK(pages[i]->object); 20335fe58019SAttilio Rao vm_page_undirty(pages[i]); 203489f6b863SAttilio Rao VM_OBJECT_WUNLOCK(pages[i]->object); 20355fe58019SAttilio Rao } 20365fe58019SAttilio Rao } 20375fe58019SAttilio Rao return rtvals[0]; 20385fe58019SAttilio Rao } 20395fe58019SAttilio Rao 204004660064SFedor Uporov static const char extattr_namespace_separator = '.'; 204104660064SFedor Uporov 204204660064SFedor Uporov /* 204304660064SFedor Uporov struct vop_getextattr_args { 204404660064SFedor Uporov struct vop_generic_args a_gen; 204504660064SFedor Uporov struct vnode *a_vp; 204604660064SFedor Uporov int a_attrnamespace; 204704660064SFedor Uporov const char *a_name; 204804660064SFedor Uporov struct uio *a_uio; 204904660064SFedor Uporov size_t *a_size; 205004660064SFedor Uporov struct ucred *a_cred; 205104660064SFedor Uporov struct thread *a_td; 205204660064SFedor Uporov }; 205304660064SFedor Uporov */ 205404660064SFedor Uporov static int 205504660064SFedor Uporov fuse_vnop_getextattr(struct vop_getextattr_args *ap) 205604660064SFedor Uporov { 205704660064SFedor Uporov struct vnode *vp = ap->a_vp; 205804660064SFedor Uporov struct uio *uio = ap->a_uio; 205928f4f623SFedor Uporov struct fuse_dispatcher fdi; 206004660064SFedor Uporov struct fuse_getxattr_in *get_xattr_in; 206104660064SFedor Uporov struct fuse_getxattr_out *get_xattr_out; 206204660064SFedor Uporov struct mount *mp = vnode_mount(vp); 206304660064SFedor Uporov struct thread *td = ap->a_td; 206404660064SFedor Uporov struct ucred *cred = ap->a_cred; 206528f4f623SFedor Uporov char *prefix; 206628f4f623SFedor Uporov char *attr_str; 206728f4f623SFedor Uporov size_t len; 206828f4f623SFedor Uporov int err; 206904660064SFedor Uporov 207004660064SFedor Uporov if (fuse_isdeadfs(vp)) 207128f4f623SFedor Uporov return (ENXIO); 207204660064SFedor Uporov 207304660064SFedor Uporov /* Default to looking for user attributes. */ 207404660064SFedor Uporov if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 207504660064SFedor Uporov prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 207604660064SFedor Uporov else 207704660064SFedor Uporov prefix = EXTATTR_NAMESPACE_USER_STRING; 207804660064SFedor Uporov 207904660064SFedor Uporov len = strlen(prefix) + sizeof(extattr_namespace_separator) + 208004660064SFedor Uporov strlen(ap->a_name) + 1; 208104660064SFedor Uporov 208204660064SFedor Uporov fdisp_init(&fdi, len + sizeof(*get_xattr_in)); 208304660064SFedor Uporov fdisp_make_vp(&fdi, FUSE_GETXATTR, vp, td, cred); 208404660064SFedor Uporov 208504660064SFedor Uporov get_xattr_in = fdi.indata; 208604660064SFedor Uporov /* 208704660064SFedor Uporov * Check to see whether we're querying the available size or 208804660064SFedor Uporov * issuing the actual request. If we pass in 0, we get back struct 208904660064SFedor Uporov * fuse_getxattr_out. If we pass in a non-zero size, we get back 209004660064SFedor Uporov * that much data, without the struct fuse_getxattr_out header. 209104660064SFedor Uporov */ 2092493b4a8cSFedor Uporov if (uio == NULL) 209304660064SFedor Uporov get_xattr_in->size = 0; 209404660064SFedor Uporov else 209504660064SFedor Uporov get_xattr_in->size = uio->uio_resid; 209604660064SFedor Uporov 209704660064SFedor Uporov attr_str = (char *)fdi.indata + sizeof(*get_xattr_in); 209804660064SFedor Uporov snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator, 209904660064SFedor Uporov ap->a_name); 210004660064SFedor Uporov 210104660064SFedor Uporov err = fdisp_wait_answ(&fdi); 210204660064SFedor Uporov if (err != 0) { 210304660064SFedor Uporov if (err == ENOSYS) 210404660064SFedor Uporov fsess_set_notimpl(mp, FUSE_GETXATTR); 210504660064SFedor Uporov goto out; 210604660064SFedor Uporov } 210704660064SFedor Uporov 210804660064SFedor Uporov get_xattr_out = fdi.answ; 210904660064SFedor Uporov 2110493b4a8cSFedor Uporov if (ap->a_size != NULL) 211104660064SFedor Uporov *ap->a_size = get_xattr_out->size; 2112493b4a8cSFedor Uporov 2113493b4a8cSFedor Uporov if (uio != NULL) 211404660064SFedor Uporov err = uiomove(fdi.answ, fdi.iosize, uio); 211504660064SFedor Uporov 211604660064SFedor Uporov out: 211704660064SFedor Uporov fdisp_destroy(&fdi); 211804660064SFedor Uporov return (err); 211904660064SFedor Uporov } 212004660064SFedor Uporov 212104660064SFedor Uporov /* 212204660064SFedor Uporov struct vop_setextattr_args { 212304660064SFedor Uporov struct vop_generic_args a_gen; 212404660064SFedor Uporov struct vnode *a_vp; 212504660064SFedor Uporov int a_attrnamespace; 212604660064SFedor Uporov const char *a_name; 212704660064SFedor Uporov struct uio *a_uio; 212804660064SFedor Uporov struct ucred *a_cred; 212904660064SFedor Uporov struct thread *a_td; 213004660064SFedor Uporov }; 213104660064SFedor Uporov */ 213204660064SFedor Uporov static int 213304660064SFedor Uporov fuse_vnop_setextattr(struct vop_setextattr_args *ap) 213404660064SFedor Uporov { 213504660064SFedor Uporov struct vnode *vp = ap->a_vp; 213604660064SFedor Uporov struct uio *uio = ap->a_uio; 213728f4f623SFedor Uporov struct fuse_dispatcher fdi; 213804660064SFedor Uporov struct fuse_setxattr_in *set_xattr_in; 213904660064SFedor Uporov struct mount *mp = vnode_mount(vp); 214028f4f623SFedor Uporov struct thread *td = ap->a_td; 214128f4f623SFedor Uporov struct ucred *cred = ap->a_cred; 214204660064SFedor Uporov char *prefix; 214304660064SFedor Uporov size_t len; 214404660064SFedor Uporov char *attr_str; 214528f4f623SFedor Uporov int err; 214604660064SFedor Uporov 214704660064SFedor Uporov if (fuse_isdeadfs(vp)) 214828f4f623SFedor Uporov return (ENXIO); 214904660064SFedor Uporov 215004660064SFedor Uporov /* Default to looking for user attributes. */ 215104660064SFedor Uporov if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 215204660064SFedor Uporov prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 215304660064SFedor Uporov else 215404660064SFedor Uporov prefix = EXTATTR_NAMESPACE_USER_STRING; 215504660064SFedor Uporov 215604660064SFedor Uporov len = strlen(prefix) + sizeof(extattr_namespace_separator) + 215704660064SFedor Uporov strlen(ap->a_name) + 1; 215804660064SFedor Uporov 215904660064SFedor Uporov fdisp_init(&fdi, len + sizeof(*set_xattr_in) + uio->uio_resid); 216004660064SFedor Uporov fdisp_make_vp(&fdi, FUSE_SETXATTR, vp, td, cred); 216104660064SFedor Uporov 216204660064SFedor Uporov set_xattr_in = fdi.indata; 216304660064SFedor Uporov set_xattr_in->size = uio->uio_resid; 216404660064SFedor Uporov 216504660064SFedor Uporov attr_str = (char *)fdi.indata + sizeof(*set_xattr_in); 216604660064SFedor Uporov snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator, 216704660064SFedor Uporov ap->a_name); 216804660064SFedor Uporov 216904660064SFedor Uporov err = uiomove((char *)fdi.indata + sizeof(*set_xattr_in) + len, 217004660064SFedor Uporov uio->uio_resid, uio); 217104660064SFedor Uporov if (err != 0) { 217204660064SFedor Uporov goto out; 217304660064SFedor Uporov } 217404660064SFedor Uporov 217504660064SFedor Uporov err = fdisp_wait_answ(&fdi); 217604660064SFedor Uporov 217704660064SFedor Uporov if (err != 0) { 217804660064SFedor Uporov if (err == ENOSYS) 217904660064SFedor Uporov fsess_set_notimpl(mp, FUSE_SETXATTR); 218004660064SFedor Uporov goto out; 218104660064SFedor Uporov } 218204660064SFedor Uporov 218304660064SFedor Uporov out: 218404660064SFedor Uporov fdisp_destroy(&fdi); 218504660064SFedor Uporov return (err); 218604660064SFedor Uporov } 218704660064SFedor Uporov 218804660064SFedor Uporov /* 218904660064SFedor Uporov * The Linux / FUSE extended attribute list is simply a collection of 219004660064SFedor Uporov * NUL-terminated strings. The FreeBSD extended attribute list is a single 219104660064SFedor Uporov * byte length followed by a non-NUL terminated string. So, this allows 219204660064SFedor Uporov * conversion of the Linux / FUSE format to the FreeBSD format in place. 219304660064SFedor Uporov * Linux attribute names are reported with the namespace as a prefix (e.g. 219404660064SFedor Uporov * "user.attribute_name"), but in FreeBSD they are reported without the 219504660064SFedor Uporov * namespace prefix (e.g. "attribute_name"). So, we're going from: 219604660064SFedor Uporov * 219704660064SFedor Uporov * user.attr_name1\0user.attr_name2\0 219804660064SFedor Uporov * 219904660064SFedor Uporov * to: 220004660064SFedor Uporov * 220104660064SFedor Uporov * <num>attr_name1<num>attr_name2 220204660064SFedor Uporov * 220304660064SFedor Uporov * Where "<num>" is a single byte number of characters in the attribute name. 220404660064SFedor Uporov * 220504660064SFedor Uporov * Args: 220604660064SFedor Uporov * prefix - exattr namespace prefix string 220704660064SFedor Uporov * list, list_len - input list with namespace prefixes 220804660064SFedor Uporov * bsd_list, bsd_list_len - output list compatible with bsd vfs 220904660064SFedor Uporov */ 221004660064SFedor Uporov static int 221104660064SFedor Uporov fuse_xattrlist_convert(char *prefix, const char *list, int list_len, 221204660064SFedor Uporov char *bsd_list, int *bsd_list_len) 221304660064SFedor Uporov { 221404660064SFedor Uporov int len, pos, dist_to_next, prefix_len; 221504660064SFedor Uporov 221604660064SFedor Uporov pos = 0; 221704660064SFedor Uporov *bsd_list_len = 0; 221804660064SFedor Uporov prefix_len = strlen(prefix); 221904660064SFedor Uporov 222004660064SFedor Uporov while (pos < list_len && list[pos] != '\0') { 222104660064SFedor Uporov dist_to_next = strlen(&list[pos]) + 1; 222204660064SFedor Uporov if (bcmp(&list[pos], prefix, prefix_len) == 0 && 222304660064SFedor Uporov list[pos + prefix_len] == extattr_namespace_separator) { 222404660064SFedor Uporov len = dist_to_next - 222504660064SFedor Uporov (prefix_len + sizeof(extattr_namespace_separator)) - 1; 222604660064SFedor Uporov if (len >= EXTATTR_MAXNAMELEN) 222704660064SFedor Uporov return (ENAMETOOLONG); 222804660064SFedor Uporov 222904660064SFedor Uporov bsd_list[*bsd_list_len] = len; 223004660064SFedor Uporov memcpy(&bsd_list[*bsd_list_len + 1], 223104660064SFedor Uporov &list[pos + prefix_len + 223204660064SFedor Uporov sizeof(extattr_namespace_separator)], len); 223304660064SFedor Uporov 223404660064SFedor Uporov *bsd_list_len += len + 1; 223504660064SFedor Uporov } 223604660064SFedor Uporov 223704660064SFedor Uporov pos += dist_to_next; 223804660064SFedor Uporov } 223904660064SFedor Uporov 224004660064SFedor Uporov return (0); 224104660064SFedor Uporov } 224204660064SFedor Uporov 224304660064SFedor Uporov /* 224404660064SFedor Uporov struct vop_listextattr_args { 224504660064SFedor Uporov struct vop_generic_args a_gen; 224604660064SFedor Uporov struct vnode *a_vp; 224704660064SFedor Uporov int a_attrnamespace; 224804660064SFedor Uporov struct uio *a_uio; 224904660064SFedor Uporov size_t *a_size; 225004660064SFedor Uporov struct ucred *a_cred; 225104660064SFedor Uporov struct thread *a_td; 225204660064SFedor Uporov }; 225304660064SFedor Uporov */ 225404660064SFedor Uporov static int 225504660064SFedor Uporov fuse_vnop_listextattr(struct vop_listextattr_args *ap) 225604660064SFedor Uporov { 225704660064SFedor Uporov struct vnode *vp = ap->a_vp; 225804660064SFedor Uporov struct uio *uio = ap->a_uio; 225928f4f623SFedor Uporov struct fuse_dispatcher fdi; 2260493b4a8cSFedor Uporov struct fuse_listxattr_in *list_xattr_in; 2261493b4a8cSFedor Uporov struct fuse_listxattr_out *list_xattr_out; 226204660064SFedor Uporov struct mount *mp = vnode_mount(vp); 226328f4f623SFedor Uporov struct thread *td = ap->a_td; 226428f4f623SFedor Uporov struct ucred *cred = ap->a_cred; 226504660064SFedor Uporov size_t len; 226604660064SFedor Uporov char *prefix; 226704660064SFedor Uporov char *attr_str; 226804660064SFedor Uporov char *bsd_list = NULL; 2269493b4a8cSFedor Uporov char *linux_list; 227004660064SFedor Uporov int bsd_list_len; 2271493b4a8cSFedor Uporov int linux_list_len; 227228f4f623SFedor Uporov int err; 227304660064SFedor Uporov 227404660064SFedor Uporov if (fuse_isdeadfs(vp)) 227528f4f623SFedor Uporov return (ENXIO); 227604660064SFedor Uporov 227704660064SFedor Uporov /* 227804660064SFedor Uporov * Add space for a NUL and the period separator if enabled. 227904660064SFedor Uporov * Default to looking for user attributes. 228004660064SFedor Uporov */ 228104660064SFedor Uporov if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 228204660064SFedor Uporov prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 228304660064SFedor Uporov else 228404660064SFedor Uporov prefix = EXTATTR_NAMESPACE_USER_STRING; 228504660064SFedor Uporov 228604660064SFedor Uporov len = strlen(prefix) + sizeof(extattr_namespace_separator) + 1; 228704660064SFedor Uporov 2288493b4a8cSFedor Uporov fdisp_init(&fdi, sizeof(*list_xattr_in) + len); 228904660064SFedor Uporov fdisp_make_vp(&fdi, FUSE_LISTXATTR, vp, td, cred); 229004660064SFedor Uporov 2291493b4a8cSFedor Uporov /* 2292493b4a8cSFedor Uporov * Retrieve Linux / FUSE compatible list size. 2293493b4a8cSFedor Uporov */ 2294493b4a8cSFedor Uporov list_xattr_in = fdi.indata; 2295493b4a8cSFedor Uporov list_xattr_in->size = 0; 2296493b4a8cSFedor Uporov attr_str = (char *)fdi.indata + sizeof(*list_xattr_in); 229704660064SFedor Uporov snprintf(attr_str, len, "%s%c", prefix, extattr_namespace_separator); 229804660064SFedor Uporov 229904660064SFedor Uporov err = fdisp_wait_answ(&fdi); 230004660064SFedor Uporov if (err != 0) { 230104660064SFedor Uporov if (err == ENOSYS) 230204660064SFedor Uporov fsess_set_notimpl(mp, FUSE_LISTXATTR); 230304660064SFedor Uporov goto out; 230404660064SFedor Uporov } 230504660064SFedor Uporov 2306493b4a8cSFedor Uporov list_xattr_out = fdi.answ; 2307493b4a8cSFedor Uporov linux_list_len = list_xattr_out->size; 2308493b4a8cSFedor Uporov if (linux_list_len == 0) { 2309493b4a8cSFedor Uporov if (ap->a_size != NULL) 2310493b4a8cSFedor Uporov *ap->a_size = linux_list_len; 231104660064SFedor Uporov goto out; 231204660064SFedor Uporov } 231304660064SFedor Uporov 231404660064SFedor Uporov /* 2315493b4a8cSFedor Uporov * Retrieve Linux / FUSE compatible list values. 2316493b4a8cSFedor Uporov */ 231712292a99SAlan Somers fdisp_refresh_vp(&fdi, FUSE_LISTXATTR, vp, td, cred); 2318493b4a8cSFedor Uporov list_xattr_in = fdi.indata; 2319493b4a8cSFedor Uporov list_xattr_in->size = linux_list_len + sizeof(*list_xattr_out); 232012292a99SAlan Somers list_xattr_in->flags = 0; 2321493b4a8cSFedor Uporov attr_str = (char *)fdi.indata + sizeof(*list_xattr_in); 2322493b4a8cSFedor Uporov snprintf(attr_str, len, "%s%c", prefix, extattr_namespace_separator); 2323493b4a8cSFedor Uporov 2324493b4a8cSFedor Uporov err = fdisp_wait_answ(&fdi); 2325493b4a8cSFedor Uporov if (err != 0) 2326493b4a8cSFedor Uporov goto out; 2327493b4a8cSFedor Uporov 2328493b4a8cSFedor Uporov linux_list = fdi.answ; 2329493b4a8cSFedor Uporov linux_list_len = fdi.iosize; 2330493b4a8cSFedor Uporov 2331493b4a8cSFedor Uporov /* 2332493b4a8cSFedor Uporov * Retrieve the BSD compatible list values. 233304660064SFedor Uporov * The Linux / FUSE attribute list format isn't the same 233404660064SFedor Uporov * as FreeBSD's format. So we need to transform it into 233504660064SFedor Uporov * FreeBSD's format before giving it to the user. 233604660064SFedor Uporov */ 2337493b4a8cSFedor Uporov bsd_list = malloc(linux_list_len, M_TEMP, M_WAITOK); 2338493b4a8cSFedor Uporov err = fuse_xattrlist_convert(prefix, linux_list, linux_list_len, 233904660064SFedor Uporov bsd_list, &bsd_list_len); 234004660064SFedor Uporov if (err != 0) 234104660064SFedor Uporov goto out; 234204660064SFedor Uporov 2343493b4a8cSFedor Uporov if (ap->a_size != NULL) 2344493b4a8cSFedor Uporov *ap->a_size = bsd_list_len; 2345493b4a8cSFedor Uporov 2346493b4a8cSFedor Uporov if (uio != NULL) 234704660064SFedor Uporov err = uiomove(bsd_list, bsd_list_len, uio); 234804660064SFedor Uporov 234904660064SFedor Uporov out: 235004660064SFedor Uporov free(bsd_list, M_TEMP); 235104660064SFedor Uporov fdisp_destroy(&fdi); 235204660064SFedor Uporov return (err); 235304660064SFedor Uporov } 235404660064SFedor Uporov 235504660064SFedor Uporov /* 235604660064SFedor Uporov struct vop_deleteextattr_args { 235704660064SFedor Uporov struct vop_generic_args a_gen; 235804660064SFedor Uporov struct vnode *a_vp; 235904660064SFedor Uporov int a_attrnamespace; 236004660064SFedor Uporov const char *a_name; 236104660064SFedor Uporov struct ucred *a_cred; 236204660064SFedor Uporov struct thread *a_td; 236304660064SFedor Uporov }; 236404660064SFedor Uporov */ 236504660064SFedor Uporov static int 236604660064SFedor Uporov fuse_vnop_deleteextattr(struct vop_deleteextattr_args *ap) 236704660064SFedor Uporov { 236804660064SFedor Uporov struct vnode *vp = ap->a_vp; 236928f4f623SFedor Uporov struct fuse_dispatcher fdi; 237004660064SFedor Uporov struct mount *mp = vnode_mount(vp); 237128f4f623SFedor Uporov struct thread *td = ap->a_td; 237228f4f623SFedor Uporov struct ucred *cred = ap->a_cred; 237304660064SFedor Uporov char *prefix; 237404660064SFedor Uporov size_t len; 237504660064SFedor Uporov char *attr_str; 237604660064SFedor Uporov int err; 237704660064SFedor Uporov 237804660064SFedor Uporov if (fuse_isdeadfs(vp)) 237928f4f623SFedor Uporov return (ENXIO); 238004660064SFedor Uporov 238104660064SFedor Uporov /* Default to looking for user attributes. */ 238204660064SFedor Uporov if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM) 238304660064SFedor Uporov prefix = EXTATTR_NAMESPACE_SYSTEM_STRING; 238404660064SFedor Uporov else 238504660064SFedor Uporov prefix = EXTATTR_NAMESPACE_USER_STRING; 238604660064SFedor Uporov 238704660064SFedor Uporov len = strlen(prefix) + sizeof(extattr_namespace_separator) + 238804660064SFedor Uporov strlen(ap->a_name) + 1; 238904660064SFedor Uporov 239004660064SFedor Uporov fdisp_init(&fdi, len); 239104660064SFedor Uporov fdisp_make_vp(&fdi, FUSE_REMOVEXATTR, vp, td, cred); 239204660064SFedor Uporov 239304660064SFedor Uporov attr_str = fdi.indata; 239404660064SFedor Uporov snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator, 239504660064SFedor Uporov ap->a_name); 239604660064SFedor Uporov 239704660064SFedor Uporov err = fdisp_wait_answ(&fdi); 239804660064SFedor Uporov if (err != 0) { 239904660064SFedor Uporov if (err == ENOSYS) 240004660064SFedor Uporov fsess_set_notimpl(mp, FUSE_REMOVEXATTR); 240104660064SFedor Uporov } 240204660064SFedor Uporov 240304660064SFedor Uporov fdisp_destroy(&fdi); 240404660064SFedor Uporov return (err); 240504660064SFedor Uporov } 240604660064SFedor Uporov 24075fe58019SAttilio Rao /* 24085fe58019SAttilio Rao struct vnop_print_args { 24095fe58019SAttilio Rao struct vnode *a_vp; 24105fe58019SAttilio Rao }; 24115fe58019SAttilio Rao */ 24125fe58019SAttilio Rao static int 24135fe58019SAttilio Rao fuse_vnop_print(struct vop_print_args *ap) 24145fe58019SAttilio Rao { 24155fe58019SAttilio Rao struct fuse_vnode_data *fvdat = VTOFUD(ap->a_vp); 24165fe58019SAttilio Rao 24175fe58019SAttilio Rao printf("nodeid: %ju, parent nodeid: %ju, nlookup: %ju, flag: %#x\n", 24185fe58019SAttilio Rao (uintmax_t)VTOILLU(ap->a_vp), (uintmax_t)fvdat->parent_nid, 24195fe58019SAttilio Rao (uintmax_t)fvdat->nlookup, 24205fe58019SAttilio Rao fvdat->flag); 24215fe58019SAttilio Rao 24225fe58019SAttilio Rao return 0; 24235fe58019SAttilio Rao } 2424