1ad3638eeSXin LI /* $NetBSD: tmpfs_vnops.c,v 1.39 2007/07/23 15:41:01 jmmv Exp $ */ 2d1fa59e9SXin LI 3e08d5567SXin LI /*- 4d63027b6SPedro F. Giffuni * SPDX-License-Identifier: BSD-2-Clause-NetBSD 5d63027b6SPedro F. Giffuni * 6ad3638eeSXin LI * Copyright (c) 2005, 2006 The NetBSD Foundation, Inc. 7d1fa59e9SXin LI * All rights reserved. 8d1fa59e9SXin LI * 9d1fa59e9SXin LI * This code is derived from software contributed to The NetBSD Foundation 10d1fa59e9SXin LI * by Julio M. Merino Vidal, developed as part of Google's Summer of Code 11d1fa59e9SXin LI * 2005 program. 12d1fa59e9SXin LI * 13d1fa59e9SXin LI * Redistribution and use in source and binary forms, with or without 14d1fa59e9SXin LI * modification, are permitted provided that the following conditions 15d1fa59e9SXin LI * are met: 16d1fa59e9SXin LI * 1. Redistributions of source code must retain the above copyright 17d1fa59e9SXin LI * notice, this list of conditions and the following disclaimer. 18d1fa59e9SXin LI * 2. Redistributions in binary form must reproduce the above copyright 19d1fa59e9SXin LI * notice, this list of conditions and the following disclaimer in the 20d1fa59e9SXin LI * documentation and/or other materials provided with the distribution. 21d1fa59e9SXin LI * 22d1fa59e9SXin LI * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 23d1fa59e9SXin LI * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 24d1fa59e9SXin LI * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 25d1fa59e9SXin LI * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 26d1fa59e9SXin LI * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27d1fa59e9SXin LI * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28d1fa59e9SXin LI * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29d1fa59e9SXin LI * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30d1fa59e9SXin LI * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31d1fa59e9SXin LI * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32d1fa59e9SXin LI * POSSIBILITY OF SUCH DAMAGE. 33d1fa59e9SXin LI */ 34d1fa59e9SXin LI 35d1fa59e9SXin LI /* 36d1fa59e9SXin LI * tmpfs vnode interface. 37d1fa59e9SXin LI */ 38d1fa59e9SXin LI #include <sys/cdefs.h> 39d1fa59e9SXin LI __FBSDID("$FreeBSD$"); 40d1fa59e9SXin LI 41d1fa59e9SXin LI #include <sys/param.h> 426d2e2df7SMark Johnston #include <sys/systm.h> 43135beaf6SGleb Smirnoff #include <sys/dirent.h> 44d1fa59e9SXin LI #include <sys/fcntl.h> 4535b1a3abSJohn Baldwin #include <sys/limits.h> 46d1fa59e9SXin LI #include <sys/lockf.h> 4789f6b863SAttilio Rao #include <sys/lock.h> 48135beaf6SGleb Smirnoff #include <sys/mount.h> 49d1fa59e9SXin LI #include <sys/namei.h> 50d1fa59e9SXin LI #include <sys/priv.h> 51d1fa59e9SXin LI #include <sys/proc.h> 5289f6b863SAttilio Rao #include <sys/rwlock.h> 533fa0694aSXin LI #include <sys/sched.h> 54d1fa59e9SXin LI #include <sys/stat.h> 55db94ad12SGleb Kurtsou #include <sys/sysctl.h> 56d1fa59e9SXin LI #include <sys/unistd.h> 57d1fa59e9SXin LI #include <sys/vnode.h> 58d1fa59e9SXin LI 59d1fa59e9SXin LI #include <vm/vm.h> 601c771f92SKonstantin Belousov #include <vm/vm_param.h> 61d1fa59e9SXin LI #include <vm/vm_object.h> 622984411dSAlan Cox 63d1fa59e9SXin LI #include <fs/tmpfs/tmpfs_vnops.h> 64d1fa59e9SXin LI #include <fs/tmpfs/tmpfs.h> 65d1fa59e9SXin LI 66db94ad12SGleb Kurtsou SYSCTL_DECL(_vfs_tmpfs); 67db94ad12SGleb Kurtsou 68db94ad12SGleb Kurtsou static volatile int tmpfs_rename_restarts; 69db94ad12SGleb Kurtsou SYSCTL_INT(_vfs_tmpfs, OID_AUTO, rename_restarts, CTLFLAG_RD, 70db94ad12SGleb Kurtsou __DEVOLATILE(int *, &tmpfs_rename_restarts), 0, 71db94ad12SGleb Kurtsou "Times rename had to restart due to lock contention"); 72db94ad12SGleb Kurtsou 73a96539bfSXin LI static int 74eb2c06b6SKonstantin Belousov tmpfs_vn_get_ino_alloc(struct mount *mp, void *arg, int lkflags, 75eb2c06b6SKonstantin Belousov struct vnode **rvp) 76eb2c06b6SKonstantin Belousov { 77eb2c06b6SKonstantin Belousov 78eb2c06b6SKonstantin Belousov return (tmpfs_alloc_vp(mp, arg, lkflags, rvp)); 79eb2c06b6SKonstantin Belousov } 80eb2c06b6SKonstantin Belousov 81eb2c06b6SKonstantin Belousov static int 8200ac6a98SKonstantin Belousov tmpfs_lookup1(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp) 83d1fa59e9SXin LI { 84d1fa59e9SXin LI struct tmpfs_dirent *de; 8564c25043SKonstantin Belousov struct tmpfs_node *dnode, *pnode; 8664c25043SKonstantin Belousov struct tmpfs_mount *tm; 87eb2c06b6SKonstantin Belousov int error; 88d1fa59e9SXin LI 89d1fa59e9SXin LI dnode = VP_TO_TMPFS_DIR(dvp); 90d1fa59e9SXin LI *vpp = NULLVP; 91d1fa59e9SXin LI 92d1fa59e9SXin LI /* Check accessibility of requested node as a first step. */ 93dfd233edSAttilio Rao error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, cnp->cn_thread); 94d1fa59e9SXin LI if (error != 0) 95d1fa59e9SXin LI goto out; 96d1fa59e9SXin LI 97d1fa59e9SXin LI /* We cannot be requesting the parent directory of the root node. */ 98d1fa59e9SXin LI MPASS(IMPLIES(dnode->tn_type == VDIR && 99d1fa59e9SXin LI dnode->tn_dir.tn_parent == dnode, 100d1fa59e9SXin LI !(cnp->cn_flags & ISDOTDOT))); 101d1fa59e9SXin LI 10282cf92d4SXin LI TMPFS_ASSERT_LOCKED(dnode); 10382cf92d4SXin LI if (dnode->tn_dir.tn_parent == NULL) { 10482cf92d4SXin LI error = ENOENT; 10582cf92d4SXin LI goto out; 10682cf92d4SXin LI } 107d1fa59e9SXin LI if (cnp->cn_flags & ISDOTDOT) { 10864c25043SKonstantin Belousov tm = VFS_TO_TMPFS(dvp->v_mount); 10964c25043SKonstantin Belousov pnode = dnode->tn_dir.tn_parent; 11064c25043SKonstantin Belousov tmpfs_ref_node(pnode); 111eb2c06b6SKonstantin Belousov error = vn_vget_ino_gen(dvp, tmpfs_vn_get_ino_alloc, 11264c25043SKonstantin Belousov pnode, cnp->cn_lkflags, vpp); 11364c25043SKonstantin Belousov tmpfs_free_node(tm, pnode); 114eb2c06b6SKonstantin Belousov if (error != 0) 115eb2c06b6SKonstantin Belousov goto out; 116d1fa59e9SXin LI } else if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') { 117d1fa59e9SXin LI VREF(dvp); 118d1fa59e9SXin LI *vpp = dvp; 119d1fa59e9SXin LI error = 0; 120d1fa59e9SXin LI } else { 121e3c7e753SKonstantin Belousov de = tmpfs_dir_lookup(dnode, NULL, cnp); 12299d57a6bSEd Schouten if (de != NULL && de->td_node == NULL) 12399d57a6bSEd Schouten cnp->cn_flags |= ISWHITEOUT; 12499d57a6bSEd Schouten if (de == NULL || de->td_node == NULL) { 125bba7ed20SKonstantin Belousov /* 126bba7ed20SKonstantin Belousov * The entry was not found in the directory. 127d1fa59e9SXin LI * This is OK if we are creating or renaming an 128d1fa59e9SXin LI * entry and are working on the last component of 129bba7ed20SKonstantin Belousov * the path name. 130bba7ed20SKonstantin Belousov */ 131d1fa59e9SXin LI if ((cnp->cn_flags & ISLASTCN) && 132d1fa59e9SXin LI (cnp->cn_nameiop == CREATE || \ 13399d57a6bSEd Schouten cnp->cn_nameiop == RENAME || 13499d57a6bSEd Schouten (cnp->cn_nameiop == DELETE && 13599d57a6bSEd Schouten cnp->cn_flags & DOWHITEOUT && 13699d57a6bSEd Schouten cnp->cn_flags & ISWHITEOUT))) { 137d1fa59e9SXin LI error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, 138d1fa59e9SXin LI cnp->cn_thread); 139d1fa59e9SXin LI if (error != 0) 140d1fa59e9SXin LI goto out; 141d1fa59e9SXin LI 142bba7ed20SKonstantin Belousov /* 143bba7ed20SKonstantin Belousov * Keep the component name in the buffer for 144bba7ed20SKonstantin Belousov * future uses. 145bba7ed20SKonstantin Belousov */ 146d1fa59e9SXin LI cnp->cn_flags |= SAVENAME; 147d1fa59e9SXin LI 148d1fa59e9SXin LI error = EJUSTRETURN; 149d1fa59e9SXin LI } else 150d1fa59e9SXin LI error = ENOENT; 151d1fa59e9SXin LI } else { 152d1fa59e9SXin LI struct tmpfs_node *tnode; 153d1fa59e9SXin LI 154bba7ed20SKonstantin Belousov /* 155bba7ed20SKonstantin Belousov * The entry was found, so get its associated 156bba7ed20SKonstantin Belousov * tmpfs_node. 157bba7ed20SKonstantin Belousov */ 158d1fa59e9SXin LI tnode = de->td_node; 159d1fa59e9SXin LI 160bba7ed20SKonstantin Belousov /* 161bba7ed20SKonstantin Belousov * If we are not at the last path component and 162d1fa59e9SXin LI * found a non-directory or non-link entry (which 163d1fa59e9SXin LI * may itself be pointing to a directory), raise 164bba7ed20SKonstantin Belousov * an error. 165bba7ed20SKonstantin Belousov */ 166d1fa59e9SXin LI if ((tnode->tn_type != VDIR && 167d1fa59e9SXin LI tnode->tn_type != VLNK) && 168d1fa59e9SXin LI !(cnp->cn_flags & ISLASTCN)) { 169d1fa59e9SXin LI error = ENOTDIR; 170d1fa59e9SXin LI goto out; 171d1fa59e9SXin LI } 172d1fa59e9SXin LI 173bba7ed20SKonstantin Belousov /* 174bba7ed20SKonstantin Belousov * If we are deleting or renaming the entry, keep 175d1fa59e9SXin LI * track of its tmpfs_dirent so that it can be 176bba7ed20SKonstantin Belousov * easily deleted later. 177bba7ed20SKonstantin Belousov */ 178d1fa59e9SXin LI if ((cnp->cn_flags & ISLASTCN) && 179d1fa59e9SXin LI (cnp->cn_nameiop == DELETE || 180d1fa59e9SXin LI cnp->cn_nameiop == RENAME)) { 181d1fa59e9SXin LI error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, 182d1fa59e9SXin LI cnp->cn_thread); 183d1fa59e9SXin LI if (error != 0) 184d1fa59e9SXin LI goto out; 185d1fa59e9SXin LI 186d1fa59e9SXin LI /* Allocate a new vnode on the matching entry. */ 1870ae6383dSXin LI error = tmpfs_alloc_vp(dvp->v_mount, tnode, 188dfd233edSAttilio Rao cnp->cn_lkflags, vpp); 189d1fa59e9SXin LI if (error != 0) 190d1fa59e9SXin LI goto out; 191d1fa59e9SXin LI 192d1fa59e9SXin LI if ((dnode->tn_mode & S_ISTXT) && 193bba7ed20SKonstantin Belousov VOP_ACCESS(dvp, VADMIN, cnp->cn_cred, 194bba7ed20SKonstantin Belousov cnp->cn_thread) && VOP_ACCESS(*vpp, VADMIN, 195bba7ed20SKonstantin Belousov cnp->cn_cred, cnp->cn_thread)) { 196d1fa59e9SXin LI error = EPERM; 197d1fa59e9SXin LI vput(*vpp); 198d1fa59e9SXin LI *vpp = NULL; 199d1fa59e9SXin LI goto out; 200d1fa59e9SXin LI } 201d1fa59e9SXin LI cnp->cn_flags |= SAVENAME; 2020ae6383dSXin LI } else { 2030ae6383dSXin LI error = tmpfs_alloc_vp(dvp->v_mount, tnode, 204dfd233edSAttilio Rao cnp->cn_lkflags, vpp); 20522bdc15aSKonstantin Belousov if (error != 0) 20622bdc15aSKonstantin Belousov goto out; 207d1fa59e9SXin LI } 208d1fa59e9SXin LI } 209d1fa59e9SXin LI } 210d1fa59e9SXin LI 211bba7ed20SKonstantin Belousov /* 212bba7ed20SKonstantin Belousov * Store the result of this lookup in the cache. Avoid this if the 213d1fa59e9SXin LI * request was for creation, as it does not improve timings on 214bba7ed20SKonstantin Belousov * emprical tests. 215bba7ed20SKonstantin Belousov */ 21600ac6a98SKonstantin Belousov if ((cnp->cn_flags & MAKEENTRY) != 0 && tmpfs_use_nc(dvp)) 217d1fa59e9SXin LI cache_enter(dvp, *vpp, cnp); 218d1fa59e9SXin LI 219d1fa59e9SXin LI out: 220bba7ed20SKonstantin Belousov /* 221bba7ed20SKonstantin Belousov * If there were no errors, *vpp cannot be null and it must be 222bba7ed20SKonstantin Belousov * locked. 223bba7ed20SKonstantin Belousov */ 22481c794f9SAttilio Rao MPASS(IFF(error == 0, *vpp != NULLVP && VOP_ISLOCKED(*vpp))); 225d1fa59e9SXin LI 226bba7ed20SKonstantin Belousov return (error); 227d1fa59e9SXin LI } 228d1fa59e9SXin LI 229a96539bfSXin LI static int 23000ac6a98SKonstantin Belousov tmpfs_cached_lookup(struct vop_cachedlookup_args *v) 23100ac6a98SKonstantin Belousov { 23200ac6a98SKonstantin Belousov 23300ac6a98SKonstantin Belousov return (tmpfs_lookup1(v->a_dvp, v->a_vpp, v->a_cnp)); 23400ac6a98SKonstantin Belousov } 23500ac6a98SKonstantin Belousov 23600ac6a98SKonstantin Belousov static int 23700ac6a98SKonstantin Belousov tmpfs_lookup(struct vop_lookup_args *v) 23800ac6a98SKonstantin Belousov { 23900ac6a98SKonstantin Belousov 24000ac6a98SKonstantin Belousov return (tmpfs_lookup1(v->a_dvp, v->a_vpp, v->a_cnp)); 24100ac6a98SKonstantin Belousov } 24200ac6a98SKonstantin Belousov 24300ac6a98SKonstantin Belousov static int 244d1fa59e9SXin LI tmpfs_create(struct vop_create_args *v) 245d1fa59e9SXin LI { 246d1fa59e9SXin LI struct vnode *dvp = v->a_dvp; 247d1fa59e9SXin LI struct vnode **vpp = v->a_vpp; 248d1fa59e9SXin LI struct componentname *cnp = v->a_cnp; 249d1fa59e9SXin LI struct vattr *vap = v->a_vap; 250789bdfdbSKonstantin Belousov int error; 251d1fa59e9SXin LI 252d1fa59e9SXin LI MPASS(vap->va_type == VREG || vap->va_type == VSOCK); 253d1fa59e9SXin LI 254789bdfdbSKonstantin Belousov error = tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL); 25500ac6a98SKonstantin Belousov if (error == 0 && (cnp->cn_flags & MAKEENTRY) != 0 && tmpfs_use_nc(dvp)) 256789bdfdbSKonstantin Belousov cache_enter(dvp, *vpp, cnp); 257789bdfdbSKonstantin Belousov return (error); 258d1fa59e9SXin LI } 259d1fa59e9SXin LI 260a96539bfSXin LI static int 261d1fa59e9SXin LI tmpfs_mknod(struct vop_mknod_args *v) 262d1fa59e9SXin LI { 263d1fa59e9SXin LI struct vnode *dvp = v->a_dvp; 264d1fa59e9SXin LI struct vnode **vpp = v->a_vpp; 265d1fa59e9SXin LI struct componentname *cnp = v->a_cnp; 266d1fa59e9SXin LI struct vattr *vap = v->a_vap; 267d1fa59e9SXin LI 268d1fa59e9SXin LI if (vap->va_type != VBLK && vap->va_type != VCHR && 269d1fa59e9SXin LI vap->va_type != VFIFO) 270d1fa59e9SXin LI return EINVAL; 271d1fa59e9SXin LI 272d1fa59e9SXin LI return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL); 273d1fa59e9SXin LI } 274d1fa59e9SXin LI 275a96539bfSXin LI static int 276d1fa59e9SXin LI tmpfs_open(struct vop_open_args *v) 277d1fa59e9SXin LI { 278d1fa59e9SXin LI struct vnode *vp = v->a_vp; 279d1fa59e9SXin LI int mode = v->a_mode; 280d1fa59e9SXin LI 281d1fa59e9SXin LI int error; 282d1fa59e9SXin LI struct tmpfs_node *node; 283d1fa59e9SXin LI 28481c794f9SAttilio Rao MPASS(VOP_ISLOCKED(vp)); 285d1fa59e9SXin LI 286d1fa59e9SXin LI node = VP_TO_TMPFS_NODE(vp); 287d1fa59e9SXin LI 288d1fa59e9SXin LI /* The file is still active but all its names have been removed 289d1fa59e9SXin LI * (e.g. by a "rmdir $(pwd)"). It cannot be opened any more as 290d1fa59e9SXin LI * it is about to die. */ 291d1fa59e9SXin LI if (node->tn_links < 1) 292d1fa59e9SXin LI return (ENOENT); 293d1fa59e9SXin LI 294d1fa59e9SXin LI /* If the file is marked append-only, deny write requests. */ 295d1fa59e9SXin LI if (node->tn_flags & APPEND && (mode & (FWRITE | O_APPEND)) == FWRITE) 296d1fa59e9SXin LI error = EPERM; 297d1fa59e9SXin LI else { 298d1fa59e9SXin LI error = 0; 299df6b240bSKonstantin Belousov /* For regular files, the call below is nop. */ 30055781cb9SKonstantin Belousov KASSERT(vp->v_type != VREG || (node->tn_reg.tn_aobj->flags & 30155781cb9SKonstantin Belousov OBJ_DEAD) == 0, ("dead object")); 302d1fa59e9SXin LI vnode_create_vobject(vp, node->tn_size, v->a_td); 303d1fa59e9SXin LI } 304d1fa59e9SXin LI 30581c794f9SAttilio Rao MPASS(VOP_ISLOCKED(vp)); 306d1fa59e9SXin LI return error; 307d1fa59e9SXin LI } 308d1fa59e9SXin LI 309a96539bfSXin LI static int 310d1fa59e9SXin LI tmpfs_close(struct vop_close_args *v) 311d1fa59e9SXin LI { 312d1fa59e9SXin LI struct vnode *vp = v->a_vp; 313d1fa59e9SXin LI 3144d2f3d2cSAlan Cox /* Update node times. */ 315d1fa59e9SXin LI tmpfs_update(vp); 316d1fa59e9SXin LI 3174d2f3d2cSAlan Cox return (0); 318d1fa59e9SXin LI } 319d1fa59e9SXin LI 320d1fa59e9SXin LI int 321d1fa59e9SXin LI tmpfs_access(struct vop_access_args *v) 322d1fa59e9SXin LI { 323d1fa59e9SXin LI struct vnode *vp = v->a_vp; 32415bc6b2bSEdward Tomasz Napierala accmode_t accmode = v->a_accmode; 325d1fa59e9SXin LI struct ucred *cred = v->a_cred; 326ba08feecSMateusz Guzik mode_t all_x = S_IXUSR | S_IXGRP | S_IXOTH; 327d1fa59e9SXin LI int error; 328d1fa59e9SXin LI struct tmpfs_node *node; 329d1fa59e9SXin LI 33081c794f9SAttilio Rao MPASS(VOP_ISLOCKED(vp)); 331d1fa59e9SXin LI 332d1fa59e9SXin LI node = VP_TO_TMPFS_NODE(vp); 333d1fa59e9SXin LI 3340f4b850eSMateusz Guzik /* 3350f4b850eSMateusz Guzik * Common case path lookup. 3360f4b850eSMateusz Guzik */ 337ba08feecSMateusz Guzik if (__predict_true(accmode == VEXEC && (node->tn_mode & all_x) == all_x)) 3380f4b850eSMateusz Guzik return (0); 3390f4b850eSMateusz Guzik 340d1fa59e9SXin LI switch (vp->v_type) { 341d1fa59e9SXin LI case VDIR: 342d1fa59e9SXin LI /* FALLTHROUGH */ 343d1fa59e9SXin LI case VLNK: 344d1fa59e9SXin LI /* FALLTHROUGH */ 345d1fa59e9SXin LI case VREG: 34615bc6b2bSEdward Tomasz Napierala if (accmode & VWRITE && vp->v_mount->mnt_flag & MNT_RDONLY) { 347d1fa59e9SXin LI error = EROFS; 348d1fa59e9SXin LI goto out; 349d1fa59e9SXin LI } 350d1fa59e9SXin LI break; 351d1fa59e9SXin LI 352d1fa59e9SXin LI case VBLK: 353d1fa59e9SXin LI /* FALLTHROUGH */ 354d1fa59e9SXin LI case VCHR: 355d1fa59e9SXin LI /* FALLTHROUGH */ 356d1fa59e9SXin LI case VSOCK: 357d1fa59e9SXin LI /* FALLTHROUGH */ 358d1fa59e9SXin LI case VFIFO: 359d1fa59e9SXin LI break; 360d1fa59e9SXin LI 361d1fa59e9SXin LI default: 362d1fa59e9SXin LI error = EINVAL; 363d1fa59e9SXin LI goto out; 364d1fa59e9SXin LI } 365d1fa59e9SXin LI 36615bc6b2bSEdward Tomasz Napierala if (accmode & VWRITE && node->tn_flags & IMMUTABLE) { 367d1fa59e9SXin LI error = EPERM; 368d1fa59e9SXin LI goto out; 369d1fa59e9SXin LI } 370d1fa59e9SXin LI 371d1fa59e9SXin LI error = vaccess(vp->v_type, node->tn_mode, node->tn_uid, 37215bc6b2bSEdward Tomasz Napierala node->tn_gid, accmode, cred, NULL); 373d1fa59e9SXin LI 374d1fa59e9SXin LI out: 37581c794f9SAttilio Rao MPASS(VOP_ISLOCKED(vp)); 376d1fa59e9SXin LI 377d1fa59e9SXin LI return error; 378d1fa59e9SXin LI } 379d1fa59e9SXin LI 380d1fa59e9SXin LI int 381d1fa59e9SXin LI tmpfs_getattr(struct vop_getattr_args *v) 382d1fa59e9SXin LI { 383d1fa59e9SXin LI struct vnode *vp = v->a_vp; 384d1fa59e9SXin LI struct vattr *vap = v->a_vap; 385677c3c0cSWill Andrews vm_object_t obj; 386d1fa59e9SXin LI struct tmpfs_node *node; 387d1fa59e9SXin LI 388d1fa59e9SXin LI node = VP_TO_TMPFS_NODE(vp); 389d1fa59e9SXin LI 390d1fa59e9SXin LI tmpfs_update(vp); 391d1fa59e9SXin LI 392d1fa59e9SXin LI vap->va_type = vp->v_type; 393d1fa59e9SXin LI vap->va_mode = node->tn_mode; 394d1fa59e9SXin LI vap->va_nlink = node->tn_links; 395d1fa59e9SXin LI vap->va_uid = node->tn_uid; 396d1fa59e9SXin LI vap->va_gid = node->tn_gid; 397d1fa59e9SXin LI vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; 398d1fa59e9SXin LI vap->va_fileid = node->tn_id; 399d1fa59e9SXin LI vap->va_size = node->tn_size; 400d1fa59e9SXin LI vap->va_blocksize = PAGE_SIZE; 401d1fa59e9SXin LI vap->va_atime = node->tn_atime; 402d1fa59e9SXin LI vap->va_mtime = node->tn_mtime; 403d1fa59e9SXin LI vap->va_ctime = node->tn_ctime; 404d1fa59e9SXin LI vap->va_birthtime = node->tn_birthtime; 405d1fa59e9SXin LI vap->va_gen = node->tn_gen; 406d1fa59e9SXin LI vap->va_flags = node->tn_flags; 407d1fa59e9SXin LI vap->va_rdev = (vp->v_type == VBLK || vp->v_type == VCHR) ? 4084c5a20e3SKonstantin Belousov node->tn_rdev : NODEV; 409677c3c0cSWill Andrews if (vp->v_type == VREG) { 410677c3c0cSWill Andrews obj = node->tn_reg.tn_aobj; 411677c3c0cSWill Andrews vap->va_bytes = (u_quad_t)obj->resident_page_count * PAGE_SIZE; 412677c3c0cSWill Andrews } else 413677c3c0cSWill Andrews vap->va_bytes = node->tn_size; 41486dacdfeSKonstantin Belousov vap->va_filerev = 0; 415d1fa59e9SXin LI 416d1fa59e9SXin LI return 0; 417d1fa59e9SXin LI } 418d1fa59e9SXin LI 419d1fa59e9SXin LI int 420d1fa59e9SXin LI tmpfs_setattr(struct vop_setattr_args *v) 421d1fa59e9SXin LI { 422d1fa59e9SXin LI struct vnode *vp = v->a_vp; 423d1fa59e9SXin LI struct vattr *vap = v->a_vap; 424d1fa59e9SXin LI struct ucred *cred = v->a_cred; 4250359a12eSAttilio Rao struct thread *td = curthread; 426d1fa59e9SXin LI 427d1fa59e9SXin LI int error; 428d1fa59e9SXin LI 42981c794f9SAttilio Rao MPASS(VOP_ISLOCKED(vp)); 430d1fa59e9SXin LI 431d1fa59e9SXin LI error = 0; 432d1fa59e9SXin LI 433d1fa59e9SXin LI /* Abort if any unsettable attribute is given. */ 434d1fa59e9SXin LI if (vap->va_type != VNON || 435d1fa59e9SXin LI vap->va_nlink != VNOVAL || 436d1fa59e9SXin LI vap->va_fsid != VNOVAL || 437d1fa59e9SXin LI vap->va_fileid != VNOVAL || 438d1fa59e9SXin LI vap->va_blocksize != VNOVAL || 439d1fa59e9SXin LI vap->va_gen != VNOVAL || 440d1fa59e9SXin LI vap->va_rdev != VNOVAL || 441d1fa59e9SXin LI vap->va_bytes != VNOVAL) 442d1fa59e9SXin LI error = EINVAL; 443d1fa59e9SXin LI 444d1fa59e9SXin LI if (error == 0 && (vap->va_flags != VNOVAL)) 4450359a12eSAttilio Rao error = tmpfs_chflags(vp, vap->va_flags, cred, td); 446d1fa59e9SXin LI 447d1fa59e9SXin LI if (error == 0 && (vap->va_size != VNOVAL)) 4480359a12eSAttilio Rao error = tmpfs_chsize(vp, vap->va_size, cred, td); 449d1fa59e9SXin LI 450d1fa59e9SXin LI if (error == 0 && (vap->va_uid != VNOVAL || vap->va_gid != VNOVAL)) 4510359a12eSAttilio Rao error = tmpfs_chown(vp, vap->va_uid, vap->va_gid, cred, td); 452d1fa59e9SXin LI 453d1fa59e9SXin LI if (error == 0 && (vap->va_mode != (mode_t)VNOVAL)) 4540359a12eSAttilio Rao error = tmpfs_chmod(vp, vap->va_mode, cred, td); 455d1fa59e9SXin LI 456d1fa59e9SXin LI if (error == 0 && ((vap->va_atime.tv_sec != VNOVAL && 457d1fa59e9SXin LI vap->va_atime.tv_nsec != VNOVAL) || 458d1fa59e9SXin LI (vap->va_mtime.tv_sec != VNOVAL && 459d1fa59e9SXin LI vap->va_mtime.tv_nsec != VNOVAL) || 460d1fa59e9SXin LI (vap->va_birthtime.tv_sec != VNOVAL && 461d1fa59e9SXin LI vap->va_birthtime.tv_nsec != VNOVAL))) 4627b81a399SKonstantin Belousov error = tmpfs_chtimes(vp, vap, cred, td); 463d1fa59e9SXin LI 464d1fa59e9SXin LI /* Update the node times. We give preference to the error codes 465d1fa59e9SXin LI * generated by this function rather than the ones that may arise 466d1fa59e9SXin LI * from tmpfs_update. */ 467d1fa59e9SXin LI tmpfs_update(vp); 468d1fa59e9SXin LI 46981c794f9SAttilio Rao MPASS(VOP_ISLOCKED(vp)); 470d1fa59e9SXin LI 471d1fa59e9SXin LI return error; 472d1fa59e9SXin LI } 473d1fa59e9SXin LI 474d1fa59e9SXin LI static int 475d1fa59e9SXin LI tmpfs_read(struct vop_read_args *v) 476d1fa59e9SXin LI { 47741cf41fdSKonstantin Belousov struct vnode *vp; 47841cf41fdSKonstantin Belousov struct uio *uio; 479d1fa59e9SXin LI struct tmpfs_node *node; 480d1fa59e9SXin LI 48141cf41fdSKonstantin Belousov vp = v->a_vp; 48241cf41fdSKonstantin Belousov if (vp->v_type != VREG) 48341cf41fdSKonstantin Belousov return (EISDIR); 48441cf41fdSKonstantin Belousov uio = v->a_uio; 48541cf41fdSKonstantin Belousov if (uio->uio_offset < 0) 48641cf41fdSKonstantin Belousov return (EINVAL); 487d1fa59e9SXin LI node = VP_TO_TMPFS_NODE(vp); 488e1cdc30fSKonstantin Belousov tmpfs_set_status(VFS_TO_TMPFS(vp->v_mount), node, TMPFS_NODE_ACCESSED); 48941cf41fdSKonstantin Belousov return (uiomove_object(node->tn_reg.tn_aobj, node->tn_size, uio)); 490c5be7783SXin LI } 491c5be7783SXin LI 492c5be7783SXin LI static int 493d1fa59e9SXin LI tmpfs_write(struct vop_write_args *v) 494d1fa59e9SXin LI { 49541cf41fdSKonstantin Belousov struct vnode *vp; 49641cf41fdSKonstantin Belousov struct uio *uio; 497d1fa59e9SXin LI struct tmpfs_node *node; 49841cf41fdSKonstantin Belousov off_t oldsize; 49941cf41fdSKonstantin Belousov int error, ioflag; 500d1fa59e9SXin LI 50141cf41fdSKonstantin Belousov vp = v->a_vp; 50241cf41fdSKonstantin Belousov uio = v->a_uio; 50341cf41fdSKonstantin Belousov ioflag = v->a_ioflag; 50441cf41fdSKonstantin Belousov error = 0; 505d1fa59e9SXin LI node = VP_TO_TMPFS_NODE(vp); 506d1fa59e9SXin LI oldsize = node->tn_size; 507d1fa59e9SXin LI 50841cf41fdSKonstantin Belousov if (uio->uio_offset < 0 || vp->v_type != VREG) 50941cf41fdSKonstantin Belousov return (EINVAL); 51041cf41fdSKonstantin Belousov if (uio->uio_resid == 0) 51141cf41fdSKonstantin Belousov return (0); 512d1fa59e9SXin LI if (ioflag & IO_APPEND) 513d1fa59e9SXin LI uio->uio_offset = node->tn_size; 514d1fa59e9SXin LI if (uio->uio_offset + uio->uio_resid > 515d1fa59e9SXin LI VFS_TO_TMPFS(vp->v_mount)->tm_maxfilesize) 516d1fa59e9SXin LI return (EFBIG); 517307d88b7SEdward Tomasz Napierala if (vn_rlimit_fsize(vp, uio, uio->uio_td)) 518d1fa59e9SXin LI return (EFBIG); 519f1a90a7bSKonstantin Belousov if (uio->uio_offset + uio->uio_resid > node->tn_size) { 5200b05cac3SAlan Cox error = tmpfs_reg_resize(vp, uio->uio_offset + uio->uio_resid, 5210b05cac3SAlan Cox FALSE); 522d1fa59e9SXin LI if (error != 0) 523d1fa59e9SXin LI goto out; 524d1fa59e9SXin LI } 525d1fa59e9SXin LI 52641cf41fdSKonstantin Belousov error = uiomove_object(node->tn_reg.tn_aobj, node->tn_size, uio); 527d1fa59e9SXin LI node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_MODIFIED | 528311d39f2SKonstantin Belousov TMPFS_NODE_CHANGED; 529d1fa59e9SXin LI if (node->tn_mode & (S_ISUID | S_ISGID)) { 530cc426dd3SMateusz Guzik if (priv_check_cred(v->a_cred, PRIV_VFS_RETAINSUGID)) 531d1fa59e9SXin LI node->tn_mode &= ~(S_ISUID | S_ISGID); 532d1fa59e9SXin LI } 533d1fa59e9SXin LI if (error != 0) 5340b05cac3SAlan Cox (void)tmpfs_reg_resize(vp, oldsize, TRUE); 535d1fa59e9SXin LI 536d1fa59e9SXin LI out: 537d1fa59e9SXin LI MPASS(IMPLIES(error == 0, uio->uio_resid == 0)); 538d1fa59e9SXin LI MPASS(IMPLIES(error != 0, oldsize == node->tn_size)); 539d1fa59e9SXin LI 54041cf41fdSKonstantin Belousov return (error); 541d1fa59e9SXin LI } 542d1fa59e9SXin LI 543a96539bfSXin LI static int 544d1fa59e9SXin LI tmpfs_fsync(struct vop_fsync_args *v) 545d1fa59e9SXin LI { 546d1fa59e9SXin LI struct vnode *vp = v->a_vp; 547d1fa59e9SXin LI 54881c794f9SAttilio Rao MPASS(VOP_ISLOCKED(vp)); 549d1fa59e9SXin LI 550f40cb1c6SKonstantin Belousov tmpfs_check_mtime(vp); 551d1fa59e9SXin LI tmpfs_update(vp); 552d1fa59e9SXin LI 553d1fa59e9SXin LI return 0; 554d1fa59e9SXin LI } 555d1fa59e9SXin LI 556a96539bfSXin LI static int 557d1fa59e9SXin LI tmpfs_remove(struct vop_remove_args *v) 558d1fa59e9SXin LI { 559d1fa59e9SXin LI struct vnode *dvp = v->a_dvp; 560d1fa59e9SXin LI struct vnode *vp = v->a_vp; 561d1fa59e9SXin LI 562d1fa59e9SXin LI int error; 563d1fa59e9SXin LI struct tmpfs_dirent *de; 564d1fa59e9SXin LI struct tmpfs_mount *tmp; 565d1fa59e9SXin LI struct tmpfs_node *dnode; 566d1fa59e9SXin LI struct tmpfs_node *node; 567d1fa59e9SXin LI 56881c794f9SAttilio Rao MPASS(VOP_ISLOCKED(dvp)); 56981c794f9SAttilio Rao MPASS(VOP_ISLOCKED(vp)); 570d1fa59e9SXin LI 571d1fa59e9SXin LI if (vp->v_type == VDIR) { 572d1fa59e9SXin LI error = EISDIR; 573d1fa59e9SXin LI goto out; 574d1fa59e9SXin LI } 575d1fa59e9SXin LI 576d1fa59e9SXin LI dnode = VP_TO_TMPFS_DIR(dvp); 577d1fa59e9SXin LI node = VP_TO_TMPFS_NODE(vp); 578d1fa59e9SXin LI tmp = VFS_TO_TMPFS(vp->v_mount); 579e3c7e753SKonstantin Belousov de = tmpfs_dir_lookup(dnode, node, v->a_cnp); 580d1fa59e9SXin LI MPASS(de != NULL); 581d1fa59e9SXin LI 582d1fa59e9SXin LI /* Files marked as immutable or append-only cannot be deleted. */ 583d1fa59e9SXin LI if ((node->tn_flags & (IMMUTABLE | APPEND | NOUNLINK)) || 584d1fa59e9SXin LI (dnode->tn_flags & APPEND)) { 585d1fa59e9SXin LI error = EPERM; 586d1fa59e9SXin LI goto out; 587d1fa59e9SXin LI } 588d1fa59e9SXin LI 589d1fa59e9SXin LI /* Remove the entry from the directory; as it is a file, we do not 590d1fa59e9SXin LI * have to change the number of hard links of the directory. */ 591d1fa59e9SXin LI tmpfs_dir_detach(dvp, de); 59299d57a6bSEd Schouten if (v->a_cnp->cn_flags & DOWHITEOUT) 59399d57a6bSEd Schouten tmpfs_dir_whiteout_add(dvp, v->a_cnp); 594d1fa59e9SXin LI 595d1fa59e9SXin LI /* Free the directory entry we just deleted. Note that the node 596d1fa59e9SXin LI * referred by it will not be removed until the vnode is really 597d1fa59e9SXin LI * reclaimed. */ 5984fd5efe7SGleb Kurtsou tmpfs_free_dirent(tmp, de); 599d1fa59e9SXin LI 6007ded42baSAlan Cox node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED; 601d1fa59e9SXin LI error = 0; 602d1fa59e9SXin LI 603d1fa59e9SXin LI out: 604d1fa59e9SXin LI 605d1fa59e9SXin LI return error; 606d1fa59e9SXin LI } 607d1fa59e9SXin LI 608a96539bfSXin LI static int 609d1fa59e9SXin LI tmpfs_link(struct vop_link_args *v) 610d1fa59e9SXin LI { 611d1fa59e9SXin LI struct vnode *dvp = v->a_tdvp; 612d1fa59e9SXin LI struct vnode *vp = v->a_vp; 613d1fa59e9SXin LI struct componentname *cnp = v->a_cnp; 614d1fa59e9SXin LI 615d1fa59e9SXin LI int error; 616d1fa59e9SXin LI struct tmpfs_dirent *de; 617d1fa59e9SXin LI struct tmpfs_node *node; 618d1fa59e9SXin LI 61981c794f9SAttilio Rao MPASS(VOP_ISLOCKED(dvp)); 620d1fa59e9SXin LI MPASS(cnp->cn_flags & HASBUF); 621d1fa59e9SXin LI MPASS(dvp != vp); /* XXX When can this be false? */ 622706f8080SKonstantin Belousov node = VP_TO_TMPFS_NODE(vp); 623706f8080SKonstantin Belousov 624d1fa59e9SXin LI /* Ensure that we do not overflow the maximum number of links imposed 625d1fa59e9SXin LI * by the system. */ 62635b1a3abSJohn Baldwin MPASS(node->tn_links <= TMPFS_LINK_MAX); 62735b1a3abSJohn Baldwin if (node->tn_links == TMPFS_LINK_MAX) { 628d1fa59e9SXin LI error = EMLINK; 629d1fa59e9SXin LI goto out; 630d1fa59e9SXin LI } 631d1fa59e9SXin LI 632d1fa59e9SXin LI /* We cannot create links of files marked immutable or append-only. */ 633d1fa59e9SXin LI if (node->tn_flags & (IMMUTABLE | APPEND)) { 634d1fa59e9SXin LI error = EPERM; 635d1fa59e9SXin LI goto out; 636d1fa59e9SXin LI } 637d1fa59e9SXin LI 638d1fa59e9SXin LI /* Allocate a new directory entry to represent the node. */ 639d1fa59e9SXin LI error = tmpfs_alloc_dirent(VFS_TO_TMPFS(vp->v_mount), node, 640d1fa59e9SXin LI cnp->cn_nameptr, cnp->cn_namelen, &de); 641d1fa59e9SXin LI if (error != 0) 642d1fa59e9SXin LI goto out; 643d1fa59e9SXin LI 644d1fa59e9SXin LI /* Insert the new directory entry into the appropriate directory. */ 64599d57a6bSEd Schouten if (cnp->cn_flags & ISWHITEOUT) 64699d57a6bSEd Schouten tmpfs_dir_whiteout_remove(dvp, cnp); 647d1fa59e9SXin LI tmpfs_dir_attach(dvp, de); 648d1fa59e9SXin LI 649d1fa59e9SXin LI /* vp link count has changed, so update node times. */ 650d1fa59e9SXin LI node->tn_status |= TMPFS_NODE_CHANGED; 651d1fa59e9SXin LI tmpfs_update(vp); 652d1fa59e9SXin LI 653d1fa59e9SXin LI error = 0; 654d1fa59e9SXin LI 655a96539bfSXin LI out: 656d1fa59e9SXin LI return error; 657d1fa59e9SXin LI } 658d1fa59e9SXin LI 659db94ad12SGleb Kurtsou /* 660db94ad12SGleb Kurtsou * We acquire all but fdvp locks using non-blocking acquisitions. If we 661db94ad12SGleb Kurtsou * fail to acquire any lock in the path we will drop all held locks, 662db94ad12SGleb Kurtsou * acquire the new lock in a blocking fashion, and then release it and 663db94ad12SGleb Kurtsou * restart the rename. This acquire/release step ensures that we do not 664db94ad12SGleb Kurtsou * spin on a lock waiting for release. On error release all vnode locks 665db94ad12SGleb Kurtsou * and decrement references the way tmpfs_rename() would do. 666db94ad12SGleb Kurtsou */ 667db94ad12SGleb Kurtsou static int 668db94ad12SGleb Kurtsou tmpfs_rename_relock(struct vnode *fdvp, struct vnode **fvpp, 669db94ad12SGleb Kurtsou struct vnode *tdvp, struct vnode **tvpp, 670db94ad12SGleb Kurtsou struct componentname *fcnp, struct componentname *tcnp) 671db94ad12SGleb Kurtsou { 672db94ad12SGleb Kurtsou struct vnode *nvp; 673db94ad12SGleb Kurtsou struct mount *mp; 674db94ad12SGleb Kurtsou struct tmpfs_dirent *de; 675db94ad12SGleb Kurtsou int error, restarts = 0; 676db94ad12SGleb Kurtsou 677db94ad12SGleb Kurtsou VOP_UNLOCK(tdvp, 0); 678db94ad12SGleb Kurtsou if (*tvpp != NULL && *tvpp != tdvp) 679db94ad12SGleb Kurtsou VOP_UNLOCK(*tvpp, 0); 680db94ad12SGleb Kurtsou mp = fdvp->v_mount; 681db94ad12SGleb Kurtsou 682db94ad12SGleb Kurtsou relock: 683db94ad12SGleb Kurtsou restarts += 1; 684db94ad12SGleb Kurtsou error = vn_lock(fdvp, LK_EXCLUSIVE); 685db94ad12SGleb Kurtsou if (error) 686db94ad12SGleb Kurtsou goto releout; 687db94ad12SGleb Kurtsou if (vn_lock(tdvp, LK_EXCLUSIVE | LK_NOWAIT) != 0) { 688db94ad12SGleb Kurtsou VOP_UNLOCK(fdvp, 0); 689db94ad12SGleb Kurtsou error = vn_lock(tdvp, LK_EXCLUSIVE); 690db94ad12SGleb Kurtsou if (error) 691db94ad12SGleb Kurtsou goto releout; 692db94ad12SGleb Kurtsou VOP_UNLOCK(tdvp, 0); 693db94ad12SGleb Kurtsou goto relock; 694db94ad12SGleb Kurtsou } 695db94ad12SGleb Kurtsou /* 696db94ad12SGleb Kurtsou * Re-resolve fvp to be certain it still exists and fetch the 697db94ad12SGleb Kurtsou * correct vnode. 698db94ad12SGleb Kurtsou */ 699db94ad12SGleb Kurtsou de = tmpfs_dir_lookup(VP_TO_TMPFS_DIR(fdvp), NULL, fcnp); 700db94ad12SGleb Kurtsou if (de == NULL) { 701db94ad12SGleb Kurtsou VOP_UNLOCK(fdvp, 0); 702db94ad12SGleb Kurtsou VOP_UNLOCK(tdvp, 0); 703db94ad12SGleb Kurtsou if ((fcnp->cn_flags & ISDOTDOT) != 0 || 704db94ad12SGleb Kurtsou (fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.')) 705db94ad12SGleb Kurtsou error = EINVAL; 706db94ad12SGleb Kurtsou else 707db94ad12SGleb Kurtsou error = ENOENT; 708db94ad12SGleb Kurtsou goto releout; 709db94ad12SGleb Kurtsou } 710db94ad12SGleb Kurtsou error = tmpfs_alloc_vp(mp, de->td_node, LK_EXCLUSIVE | LK_NOWAIT, &nvp); 711db94ad12SGleb Kurtsou if (error != 0) { 712db94ad12SGleb Kurtsou VOP_UNLOCK(fdvp, 0); 713db94ad12SGleb Kurtsou VOP_UNLOCK(tdvp, 0); 714db94ad12SGleb Kurtsou if (error != EBUSY) 715db94ad12SGleb Kurtsou goto releout; 716db94ad12SGleb Kurtsou error = tmpfs_alloc_vp(mp, de->td_node, LK_EXCLUSIVE, &nvp); 717db94ad12SGleb Kurtsou if (error != 0) 718db94ad12SGleb Kurtsou goto releout; 719db94ad12SGleb Kurtsou VOP_UNLOCK(nvp, 0); 720db94ad12SGleb Kurtsou /* 721db94ad12SGleb Kurtsou * Concurrent rename race. 722db94ad12SGleb Kurtsou */ 723db94ad12SGleb Kurtsou if (nvp == tdvp) { 724db94ad12SGleb Kurtsou vrele(nvp); 725db94ad12SGleb Kurtsou error = EINVAL; 726db94ad12SGleb Kurtsou goto releout; 727db94ad12SGleb Kurtsou } 728db94ad12SGleb Kurtsou vrele(*fvpp); 729db94ad12SGleb Kurtsou *fvpp = nvp; 730db94ad12SGleb Kurtsou goto relock; 731db94ad12SGleb Kurtsou } 732db94ad12SGleb Kurtsou vrele(*fvpp); 733db94ad12SGleb Kurtsou *fvpp = nvp; 734db94ad12SGleb Kurtsou VOP_UNLOCK(*fvpp, 0); 735db94ad12SGleb Kurtsou /* 736db94ad12SGleb Kurtsou * Re-resolve tvp and acquire the vnode lock if present. 737db94ad12SGleb Kurtsou */ 738db94ad12SGleb Kurtsou de = tmpfs_dir_lookup(VP_TO_TMPFS_DIR(tdvp), NULL, tcnp); 739db94ad12SGleb Kurtsou /* 740db94ad12SGleb Kurtsou * If tvp disappeared we just carry on. 741db94ad12SGleb Kurtsou */ 742db94ad12SGleb Kurtsou if (de == NULL && *tvpp != NULL) { 743db94ad12SGleb Kurtsou vrele(*tvpp); 744db94ad12SGleb Kurtsou *tvpp = NULL; 745db94ad12SGleb Kurtsou } 746db94ad12SGleb Kurtsou /* 747db94ad12SGleb Kurtsou * Get the tvp ino if the lookup succeeded. We may have to restart 748db94ad12SGleb Kurtsou * if the non-blocking acquire fails. 749db94ad12SGleb Kurtsou */ 750db94ad12SGleb Kurtsou if (de != NULL) { 751db94ad12SGleb Kurtsou nvp = NULL; 752db94ad12SGleb Kurtsou error = tmpfs_alloc_vp(mp, de->td_node, 753db94ad12SGleb Kurtsou LK_EXCLUSIVE | LK_NOWAIT, &nvp); 754db94ad12SGleb Kurtsou if (*tvpp != NULL) 755db94ad12SGleb Kurtsou vrele(*tvpp); 756db94ad12SGleb Kurtsou *tvpp = nvp; 757db94ad12SGleb Kurtsou if (error != 0) { 758db94ad12SGleb Kurtsou VOP_UNLOCK(fdvp, 0); 759db94ad12SGleb Kurtsou VOP_UNLOCK(tdvp, 0); 760db94ad12SGleb Kurtsou if (error != EBUSY) 761db94ad12SGleb Kurtsou goto releout; 762db94ad12SGleb Kurtsou error = tmpfs_alloc_vp(mp, de->td_node, LK_EXCLUSIVE, 763db94ad12SGleb Kurtsou &nvp); 764db94ad12SGleb Kurtsou if (error != 0) 765db94ad12SGleb Kurtsou goto releout; 766db94ad12SGleb Kurtsou VOP_UNLOCK(nvp, 0); 767db94ad12SGleb Kurtsou /* 768db94ad12SGleb Kurtsou * fdvp contains fvp, thus tvp (=fdvp) is not empty. 769db94ad12SGleb Kurtsou */ 770db94ad12SGleb Kurtsou if (nvp == fdvp) { 771db94ad12SGleb Kurtsou error = ENOTEMPTY; 772db94ad12SGleb Kurtsou goto releout; 773db94ad12SGleb Kurtsou } 774db94ad12SGleb Kurtsou goto relock; 775db94ad12SGleb Kurtsou } 776db94ad12SGleb Kurtsou } 777db94ad12SGleb Kurtsou tmpfs_rename_restarts += restarts; 778db94ad12SGleb Kurtsou 779db94ad12SGleb Kurtsou return (0); 780db94ad12SGleb Kurtsou 781db94ad12SGleb Kurtsou releout: 782db94ad12SGleb Kurtsou vrele(fdvp); 783db94ad12SGleb Kurtsou vrele(*fvpp); 784db94ad12SGleb Kurtsou vrele(tdvp); 785db94ad12SGleb Kurtsou if (*tvpp != NULL) 786db94ad12SGleb Kurtsou vrele(*tvpp); 787db94ad12SGleb Kurtsou tmpfs_rename_restarts += restarts; 788db94ad12SGleb Kurtsou 789db94ad12SGleb Kurtsou return (error); 790db94ad12SGleb Kurtsou } 791db94ad12SGleb Kurtsou 792a96539bfSXin LI static int 793d1fa59e9SXin LI tmpfs_rename(struct vop_rename_args *v) 794d1fa59e9SXin LI { 795d1fa59e9SXin LI struct vnode *fdvp = v->a_fdvp; 796d1fa59e9SXin LI struct vnode *fvp = v->a_fvp; 797d1fa59e9SXin LI struct componentname *fcnp = v->a_fcnp; 798d1fa59e9SXin LI struct vnode *tdvp = v->a_tdvp; 799d1fa59e9SXin LI struct vnode *tvp = v->a_tvp; 800d1fa59e9SXin LI struct componentname *tcnp = v->a_tcnp; 801d1fa59e9SXin LI char *newname; 802d1fa59e9SXin LI struct tmpfs_dirent *de; 80382cf92d4SXin LI struct tmpfs_mount *tmp; 804d1fa59e9SXin LI struct tmpfs_node *fdnode; 805d1fa59e9SXin LI struct tmpfs_node *fnode; 8060ae6383dSXin LI struct tmpfs_node *tnode; 807d1fa59e9SXin LI struct tmpfs_node *tdnode; 808f7e69a6fSKonstantin Belousov int error; 809d1fa59e9SXin LI 81081c794f9SAttilio Rao MPASS(VOP_ISLOCKED(tdvp)); 81181c794f9SAttilio Rao MPASS(IMPLIES(tvp != NULL, VOP_ISLOCKED(tvp))); 812d1fa59e9SXin LI MPASS(fcnp->cn_flags & HASBUF); 813d1fa59e9SXin LI MPASS(tcnp->cn_flags & HASBUF); 814d1fa59e9SXin LI 815f7e69a6fSKonstantin Belousov /* 816f7e69a6fSKonstantin Belousov * Disallow cross-device renames. 817f7e69a6fSKonstantin Belousov * XXX Why isn't this done by the caller? 818f7e69a6fSKonstantin Belousov */ 819d1fa59e9SXin LI if (fvp->v_mount != tdvp->v_mount || 820d1fa59e9SXin LI (tvp != NULL && fvp->v_mount != tvp->v_mount)) { 821d1fa59e9SXin LI error = EXDEV; 822d1fa59e9SXin LI goto out; 823d1fa59e9SXin LI } 824d1fa59e9SXin LI 825d1fa59e9SXin LI /* If source and target are the same file, there is nothing to do. */ 826d1fa59e9SXin LI if (fvp == tvp) { 827d1fa59e9SXin LI error = 0; 828d1fa59e9SXin LI goto out; 829d1fa59e9SXin LI } 830d1fa59e9SXin LI 831f7e69a6fSKonstantin Belousov /* 832f7e69a6fSKonstantin Belousov * If we need to move the directory between entries, lock the 833f7e69a6fSKonstantin Belousov * source so that we can safely operate on it. 834f7e69a6fSKonstantin Belousov */ 835db94ad12SGleb Kurtsou if (fdvp != tdvp && fdvp != tvp) { 836db94ad12SGleb Kurtsou if (vn_lock(fdvp, LK_EXCLUSIVE | LK_NOWAIT) != 0) { 837db94ad12SGleb Kurtsou error = tmpfs_rename_relock(fdvp, &fvp, tdvp, &tvp, 838db94ad12SGleb Kurtsou fcnp, tcnp); 839dbe257d2SKonstantin Belousov if (error != 0) 840db94ad12SGleb Kurtsou return (error); 841db94ad12SGleb Kurtsou ASSERT_VOP_ELOCKED(fdvp, 842db94ad12SGleb Kurtsou "tmpfs_rename: fdvp not locked"); 843db94ad12SGleb Kurtsou ASSERT_VOP_ELOCKED(tdvp, 844db94ad12SGleb Kurtsou "tmpfs_rename: tdvp not locked"); 845db94ad12SGleb Kurtsou if (tvp != NULL) 846db94ad12SGleb Kurtsou ASSERT_VOP_ELOCKED(tvp, 847db94ad12SGleb Kurtsou "tmpfs_rename: tvp not locked"); 848db94ad12SGleb Kurtsou if (fvp == tvp) { 849db94ad12SGleb Kurtsou error = 0; 850db94ad12SGleb Kurtsou goto out_locked; 851db94ad12SGleb Kurtsou } 852db94ad12SGleb Kurtsou } 853db94ad12SGleb Kurtsou } 854db94ad12SGleb Kurtsou 855db94ad12SGleb Kurtsou tmp = VFS_TO_TMPFS(tdvp->v_mount); 856db94ad12SGleb Kurtsou tdnode = VP_TO_TMPFS_DIR(tdvp); 857db94ad12SGleb Kurtsou tnode = (tvp == NULL) ? NULL : VP_TO_TMPFS_NODE(tvp); 8587871e52bSXin LI fdnode = VP_TO_TMPFS_DIR(fdvp); 8597871e52bSXin LI fnode = VP_TO_TMPFS_NODE(fvp); 860e3c7e753SKonstantin Belousov de = tmpfs_dir_lookup(fdnode, fnode, fcnp); 8617871e52bSXin LI 862f7e69a6fSKonstantin Belousov /* 863f7e69a6fSKonstantin Belousov * Entry can disappear before we lock fdvp, 864f7e69a6fSKonstantin Belousov * also avoid manipulating '.' and '..' entries. 865f7e69a6fSKonstantin Belousov */ 866d1fa59e9SXin LI if (de == NULL) { 867b2143ecbSIvan Voras if ((fcnp->cn_flags & ISDOTDOT) != 0 || 868b2143ecbSIvan Voras (fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.')) 869d1fa59e9SXin LI error = EINVAL; 870b2143ecbSIvan Voras else 871b2143ecbSIvan Voras error = ENOENT; 8727871e52bSXin LI goto out_locked; 873d1fa59e9SXin LI } 874d1fa59e9SXin LI MPASS(de->td_node == fnode); 875d1fa59e9SXin LI 876f7e69a6fSKonstantin Belousov /* 877f7e69a6fSKonstantin Belousov * If re-naming a directory to another preexisting directory 878d1fa59e9SXin LI * ensure that the target directory is empty so that its 879d1fa59e9SXin LI * removal causes no side effects. 880b3a15dddSPedro F. Giffuni * Kern_rename guarantees the destination to be a directory 881f7e69a6fSKonstantin Belousov * if the source is one. 882f7e69a6fSKonstantin Belousov */ 883d1fa59e9SXin LI if (tvp != NULL) { 8840ae6383dSXin LI MPASS(tnode != NULL); 885d1fa59e9SXin LI 886d1fa59e9SXin LI if ((tnode->tn_flags & (NOUNLINK | IMMUTABLE | APPEND)) || 887d1fa59e9SXin LI (tdnode->tn_flags & (APPEND | IMMUTABLE))) { 888d1fa59e9SXin LI error = EPERM; 8897871e52bSXin LI goto out_locked; 890d1fa59e9SXin LI } 891d1fa59e9SXin LI 8920ae6383dSXin LI if (fnode->tn_type == VDIR && tnode->tn_type == VDIR) { 8930ae6383dSXin LI if (tnode->tn_size > 0) { 894d1fa59e9SXin LI error = ENOTEMPTY; 8957871e52bSXin LI goto out_locked; 896d1fa59e9SXin LI } 8970ae6383dSXin LI } else if (fnode->tn_type == VDIR && tnode->tn_type != VDIR) { 8980ae6383dSXin LI error = ENOTDIR; 8997871e52bSXin LI goto out_locked; 9000ae6383dSXin LI } else if (fnode->tn_type != VDIR && tnode->tn_type == VDIR) { 9010ae6383dSXin LI error = EISDIR; 9027871e52bSXin LI goto out_locked; 9030ae6383dSXin LI } else { 9040ae6383dSXin LI MPASS(fnode->tn_type != VDIR && 9050ae6383dSXin LI tnode->tn_type != VDIR); 9060ae6383dSXin LI } 907d1fa59e9SXin LI } 908d1fa59e9SXin LI 909d1fa59e9SXin LI if ((fnode->tn_flags & (NOUNLINK | IMMUTABLE | APPEND)) 910d1fa59e9SXin LI || (fdnode->tn_flags & (APPEND | IMMUTABLE))) { 911d1fa59e9SXin LI error = EPERM; 912d1fa59e9SXin LI goto out_locked; 913d1fa59e9SXin LI } 914d1fa59e9SXin LI 915f7e69a6fSKonstantin Belousov /* 916f7e69a6fSKonstantin Belousov * Ensure that we have enough memory to hold the new name, if it 917f7e69a6fSKonstantin Belousov * has to be changed. 918f7e69a6fSKonstantin Belousov */ 919d1fa59e9SXin LI if (fcnp->cn_namelen != tcnp->cn_namelen || 920ae72afe0SDavid E. O'Brien bcmp(fcnp->cn_nameptr, tcnp->cn_nameptr, fcnp->cn_namelen) != 0) { 9219b258fcaSXin LI newname = malloc(tcnp->cn_namelen, M_TMPFSNAME, M_WAITOK); 922d1fa59e9SXin LI } else 923d1fa59e9SXin LI newname = NULL; 924d1fa59e9SXin LI 925f7e69a6fSKonstantin Belousov /* 926f7e69a6fSKonstantin Belousov * If the node is being moved to another directory, we have to do 927f7e69a6fSKonstantin Belousov * the move. 928f7e69a6fSKonstantin Belousov */ 929d1fa59e9SXin LI if (fdnode != tdnode) { 930f7e69a6fSKonstantin Belousov /* 931f7e69a6fSKonstantin Belousov * In case we are moving a directory, we have to adjust its 932f7e69a6fSKonstantin Belousov * parent to point to the new parent. 933f7e69a6fSKonstantin Belousov */ 934d1fa59e9SXin LI if (de->td_node->tn_type == VDIR) { 935d1fa59e9SXin LI struct tmpfs_node *n; 936d1fa59e9SXin LI 937f7e69a6fSKonstantin Belousov /* 938f7e69a6fSKonstantin Belousov * Ensure the target directory is not a child of the 939d1fa59e9SXin LI * directory being moved. Otherwise, we'd end up 940f7e69a6fSKonstantin Belousov * with stale nodes. 941f7e69a6fSKonstantin Belousov */ 942d1fa59e9SXin LI n = tdnode; 943f7e69a6fSKonstantin Belousov /* 944f7e69a6fSKonstantin Belousov * TMPFS_LOCK guaranties that no nodes are freed while 94582cf92d4SXin LI * traversing the list. Nodes can only be marked as 946f7e69a6fSKonstantin Belousov * removed: tn_parent == NULL. 947f7e69a6fSKonstantin Belousov */ 94882cf92d4SXin LI TMPFS_LOCK(tmp); 94982cf92d4SXin LI TMPFS_NODE_LOCK(n); 950d1fa59e9SXin LI while (n != n->tn_dir.tn_parent) { 95182cf92d4SXin LI struct tmpfs_node *parent; 95282cf92d4SXin LI 953d1fa59e9SXin LI if (n == fnode) { 95482cf92d4SXin LI TMPFS_NODE_UNLOCK(n); 95582cf92d4SXin LI TMPFS_UNLOCK(tmp); 956d1fa59e9SXin LI error = EINVAL; 957d1fa59e9SXin LI if (newname != NULL) 9589b258fcaSXin LI free(newname, M_TMPFSNAME); 959d1fa59e9SXin LI goto out_locked; 960d1fa59e9SXin LI } 96182cf92d4SXin LI parent = n->tn_dir.tn_parent; 96282cf92d4SXin LI TMPFS_NODE_UNLOCK(n); 96382cf92d4SXin LI if (parent == NULL) { 96482cf92d4SXin LI n = NULL; 96582cf92d4SXin LI break; 966d1fa59e9SXin LI } 96782cf92d4SXin LI TMPFS_NODE_LOCK(parent); 96882cf92d4SXin LI if (parent->tn_dir.tn_parent == NULL) { 96982cf92d4SXin LI TMPFS_NODE_UNLOCK(parent); 97082cf92d4SXin LI n = NULL; 97182cf92d4SXin LI break; 97282cf92d4SXin LI } 97382cf92d4SXin LI n = parent; 97482cf92d4SXin LI } 97582cf92d4SXin LI TMPFS_UNLOCK(tmp); 97682cf92d4SXin LI if (n == NULL) { 97782cf92d4SXin LI error = EINVAL; 97882cf92d4SXin LI if (newname != NULL) 97982cf92d4SXin LI free(newname, M_TMPFSNAME); 98082cf92d4SXin LI goto out_locked; 98182cf92d4SXin LI } 98282cf92d4SXin LI TMPFS_NODE_UNLOCK(n); 983d1fa59e9SXin LI 984d1fa59e9SXin LI /* Adjust the parent pointer. */ 985d1fa59e9SXin LI TMPFS_VALIDATE_DIR(fnode); 98682cf92d4SXin LI TMPFS_NODE_LOCK(de->td_node); 987d1fa59e9SXin LI de->td_node->tn_dir.tn_parent = tdnode; 98882cf92d4SXin LI TMPFS_NODE_UNLOCK(de->td_node); 989d1fa59e9SXin LI 990f7e69a6fSKonstantin Belousov /* 991f7e69a6fSKonstantin Belousov * As a result of changing the target of the '..' 992d1fa59e9SXin LI * entry, the link count of the source and target 993f7e69a6fSKonstantin Belousov * directories has to be adjusted. 994f7e69a6fSKonstantin Belousov */ 99582cf92d4SXin LI TMPFS_NODE_LOCK(tdnode); 99682cf92d4SXin LI TMPFS_ASSERT_LOCKED(tdnode); 997d1fa59e9SXin LI tdnode->tn_links++; 99882cf92d4SXin LI TMPFS_NODE_UNLOCK(tdnode); 99982cf92d4SXin LI 100082cf92d4SXin LI TMPFS_NODE_LOCK(fdnode); 100182cf92d4SXin LI TMPFS_ASSERT_LOCKED(fdnode); 100282cf92d4SXin LI fdnode->tn_links--; 100382cf92d4SXin LI TMPFS_NODE_UNLOCK(fdnode); 1004d1fa59e9SXin LI } 10054fd5efe7SGleb Kurtsou } 1006d1fa59e9SXin LI 1007f7e69a6fSKonstantin Belousov /* 1008f7e69a6fSKonstantin Belousov * Do the move: just remove the entry from the source directory 1009f7e69a6fSKonstantin Belousov * and insert it into the target one. 1010f7e69a6fSKonstantin Belousov */ 1011d1fa59e9SXin LI tmpfs_dir_detach(fdvp, de); 10124fd5efe7SGleb Kurtsou 101399d57a6bSEd Schouten if (fcnp->cn_flags & DOWHITEOUT) 101499d57a6bSEd Schouten tmpfs_dir_whiteout_add(fdvp, fcnp); 101599d57a6bSEd Schouten if (tcnp->cn_flags & ISWHITEOUT) 101699d57a6bSEd Schouten tmpfs_dir_whiteout_remove(tdvp, tcnp); 1017d1fa59e9SXin LI 1018f7e69a6fSKonstantin Belousov /* 1019f7e69a6fSKonstantin Belousov * If the name has changed, we need to make it effective by changing 1020f7e69a6fSKonstantin Belousov * it in the directory entry. 1021f7e69a6fSKonstantin Belousov */ 1022d1fa59e9SXin LI if (newname != NULL) { 1023d1fa59e9SXin LI MPASS(tcnp->cn_namelen <= MAXNAMLEN); 1024d1fa59e9SXin LI 10254fd5efe7SGleb Kurtsou free(de->ud.td_name, M_TMPFSNAME); 10264fd5efe7SGleb Kurtsou de->ud.td_name = newname; 10274fd5efe7SGleb Kurtsou tmpfs_dirent_init(de, tcnp->cn_nameptr, tcnp->cn_namelen); 1028d1fa59e9SXin LI 1029d1fa59e9SXin LI fnode->tn_status |= TMPFS_NODE_CHANGED; 1030d1fa59e9SXin LI tdnode->tn_status |= TMPFS_NODE_MODIFIED; 1031d1fa59e9SXin LI } 1032d1fa59e9SXin LI 1033f7e69a6fSKonstantin Belousov /* 1034f7e69a6fSKonstantin Belousov * If we are overwriting an entry, we have to remove the old one 1035f7e69a6fSKonstantin Belousov * from the target directory. 1036f7e69a6fSKonstantin Belousov */ 1037d1fa59e9SXin LI if (tvp != NULL) { 10384fd5efe7SGleb Kurtsou struct tmpfs_dirent *tde; 10394fd5efe7SGleb Kurtsou 1040d1fa59e9SXin LI /* Remove the old entry from the target directory. */ 10414fd5efe7SGleb Kurtsou tde = tmpfs_dir_lookup(tdnode, tnode, tcnp); 10424fd5efe7SGleb Kurtsou tmpfs_dir_detach(tdvp, tde); 1043d1fa59e9SXin LI 1044f7e69a6fSKonstantin Belousov /* 1045f7e69a6fSKonstantin Belousov * Free the directory entry we just deleted. Note that the 1046d1fa59e9SXin LI * node referred by it will not be removed until the vnode is 1047f7e69a6fSKonstantin Belousov * really reclaimed. 1048f7e69a6fSKonstantin Belousov */ 10494fd5efe7SGleb Kurtsou tmpfs_free_dirent(VFS_TO_TMPFS(tvp->v_mount), tde); 1050d1fa59e9SXin LI } 10514fd5efe7SGleb Kurtsou 10524fd5efe7SGleb Kurtsou tmpfs_dir_attach(tdvp, de); 10534fd5efe7SGleb Kurtsou 105400ac6a98SKonstantin Belousov if (tmpfs_use_nc(fvp)) { 1055948fa27dSPeter Holm cache_purge(fvp); 105658d65e80SJohn Baldwin if (tvp != NULL) 105758d65e80SJohn Baldwin cache_purge(tvp); 10580d3bb4afSKonstantin Belousov cache_purge_negative(tdvp); 105900ac6a98SKonstantin Belousov } 1060d1fa59e9SXin LI 1061d1fa59e9SXin LI error = 0; 1062d1fa59e9SXin LI 1063d1fa59e9SXin LI out_locked: 10646e92aee4SIvan Voras if (fdvp != tdvp && fdvp != tvp) 106522db15c0SAttilio Rao VOP_UNLOCK(fdvp, 0); 1066d1fa59e9SXin LI 1067d1fa59e9SXin LI out: 1068f7e69a6fSKonstantin Belousov /* 1069f7e69a6fSKonstantin Belousov * Release target nodes. 1070f7e69a6fSKonstantin Belousov * XXX: I don't understand when tdvp can be the same as tvp, but 1071f7e69a6fSKonstantin Belousov * other code takes care of this... 1072f7e69a6fSKonstantin Belousov */ 1073d1fa59e9SXin LI if (tdvp == tvp) 1074d1fa59e9SXin LI vrele(tdvp); 1075d1fa59e9SXin LI else 1076d1fa59e9SXin LI vput(tdvp); 1077d1fa59e9SXin LI if (tvp != NULL) 1078d1fa59e9SXin LI vput(tvp); 1079d1fa59e9SXin LI 1080d1fa59e9SXin LI /* Release source nodes. */ 1081d1fa59e9SXin LI vrele(fdvp); 1082d1fa59e9SXin LI vrele(fvp); 1083d1fa59e9SXin LI 1084f7e69a6fSKonstantin Belousov return (error); 1085d1fa59e9SXin LI } 1086d1fa59e9SXin LI 1087a96539bfSXin LI static int 1088d1fa59e9SXin LI tmpfs_mkdir(struct vop_mkdir_args *v) 1089d1fa59e9SXin LI { 1090d1fa59e9SXin LI struct vnode *dvp = v->a_dvp; 1091d1fa59e9SXin LI struct vnode **vpp = v->a_vpp; 1092d1fa59e9SXin LI struct componentname *cnp = v->a_cnp; 1093d1fa59e9SXin LI struct vattr *vap = v->a_vap; 1094d1fa59e9SXin LI 1095d1fa59e9SXin LI MPASS(vap->va_type == VDIR); 1096d1fa59e9SXin LI 1097d1fa59e9SXin LI return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL); 1098d1fa59e9SXin LI } 1099d1fa59e9SXin LI 1100a96539bfSXin LI static int 1101d1fa59e9SXin LI tmpfs_rmdir(struct vop_rmdir_args *v) 1102d1fa59e9SXin LI { 1103d1fa59e9SXin LI struct vnode *dvp = v->a_dvp; 1104d1fa59e9SXin LI struct vnode *vp = v->a_vp; 1105d1fa59e9SXin LI 1106d1fa59e9SXin LI int error; 1107d1fa59e9SXin LI struct tmpfs_dirent *de; 1108d1fa59e9SXin LI struct tmpfs_mount *tmp; 1109d1fa59e9SXin LI struct tmpfs_node *dnode; 1110d1fa59e9SXin LI struct tmpfs_node *node; 1111d1fa59e9SXin LI 111281c794f9SAttilio Rao MPASS(VOP_ISLOCKED(dvp)); 111381c794f9SAttilio Rao MPASS(VOP_ISLOCKED(vp)); 1114d1fa59e9SXin LI 1115d1fa59e9SXin LI tmp = VFS_TO_TMPFS(dvp->v_mount); 1116d1fa59e9SXin LI dnode = VP_TO_TMPFS_DIR(dvp); 1117d1fa59e9SXin LI node = VP_TO_TMPFS_DIR(vp); 1118d1fa59e9SXin LI 1119d1fa59e9SXin LI /* Directories with more than two entries ('.' and '..') cannot be 1120d1fa59e9SXin LI * removed. */ 1121d1fa59e9SXin LI if (node->tn_size > 0) { 1122d1fa59e9SXin LI error = ENOTEMPTY; 1123d1fa59e9SXin LI goto out; 1124d1fa59e9SXin LI } 1125d1fa59e9SXin LI 1126d1fa59e9SXin LI if ((dnode->tn_flags & APPEND) 1127d1fa59e9SXin LI || (node->tn_flags & (NOUNLINK | IMMUTABLE | APPEND))) { 1128d1fa59e9SXin LI error = EPERM; 1129d1fa59e9SXin LI goto out; 1130d1fa59e9SXin LI } 1131d1fa59e9SXin LI 1132d1fa59e9SXin LI /* This invariant holds only if we are not trying to remove "..". 1133d1fa59e9SXin LI * We checked for that above so this is safe now. */ 1134d1fa59e9SXin LI MPASS(node->tn_dir.tn_parent == dnode); 1135d1fa59e9SXin LI 1136d1fa59e9SXin LI /* Get the directory entry associated with node (vp). This was 1137d1fa59e9SXin LI * filled by tmpfs_lookup while looking up the entry. */ 1138e3c7e753SKonstantin Belousov de = tmpfs_dir_lookup(dnode, node, v->a_cnp); 1139d1fa59e9SXin LI MPASS(TMPFS_DIRENT_MATCHES(de, 1140d1fa59e9SXin LI v->a_cnp->cn_nameptr, 1141d1fa59e9SXin LI v->a_cnp->cn_namelen)); 1142d1fa59e9SXin LI 1143d1fa59e9SXin LI /* Check flags to see if we are allowed to remove the directory. */ 11445dc11286SKonstantin Belousov if ((dnode->tn_flags & APPEND) != 0 || 11455dc11286SKonstantin Belousov (node->tn_flags & (NOUNLINK | IMMUTABLE | APPEND)) != 0) { 1146d1fa59e9SXin LI error = EPERM; 1147d1fa59e9SXin LI goto out; 1148d1fa59e9SXin LI } 1149d1fa59e9SXin LI 115082cf92d4SXin LI 1151d1fa59e9SXin LI /* Detach the directory entry from the directory (dnode). */ 1152d1fa59e9SXin LI tmpfs_dir_detach(dvp, de); 115399d57a6bSEd Schouten if (v->a_cnp->cn_flags & DOWHITEOUT) 115499d57a6bSEd Schouten tmpfs_dir_whiteout_add(dvp, v->a_cnp); 1155d1fa59e9SXin LI 115682cf92d4SXin LI /* No vnode should be allocated for this entry from this point */ 115782cf92d4SXin LI TMPFS_NODE_LOCK(node); 1158d1fa59e9SXin LI node->tn_links--; 115982cf92d4SXin LI node->tn_dir.tn_parent = NULL; 11605dc11286SKonstantin Belousov node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED | 1161d1fa59e9SXin LI TMPFS_NODE_MODIFIED; 116282cf92d4SXin LI 116382cf92d4SXin LI TMPFS_NODE_UNLOCK(node); 116482cf92d4SXin LI 116582cf92d4SXin LI TMPFS_NODE_LOCK(dnode); 116682cf92d4SXin LI dnode->tn_links--; 11675dc11286SKonstantin Belousov dnode->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED | 11685dc11286SKonstantin Belousov TMPFS_NODE_MODIFIED; 116982cf92d4SXin LI TMPFS_NODE_UNLOCK(dnode); 1170d1fa59e9SXin LI 117100ac6a98SKonstantin Belousov if (tmpfs_use_nc(dvp)) { 1172d1fa59e9SXin LI cache_purge(dvp); 1173d1fa59e9SXin LI cache_purge(vp); 117400ac6a98SKonstantin Belousov } 1175d1fa59e9SXin LI 1176d1fa59e9SXin LI /* Free the directory entry we just deleted. Note that the node 1177d1fa59e9SXin LI * referred by it will not be removed until the vnode is really 1178d1fa59e9SXin LI * reclaimed. */ 11794fd5efe7SGleb Kurtsou tmpfs_free_dirent(tmp, de); 1180d1fa59e9SXin LI 1181d1fa59e9SXin LI /* Release the deleted vnode (will destroy the node, notify 1182d1fa59e9SXin LI * interested parties and clean it from the cache). */ 1183d1fa59e9SXin LI 1184d1fa59e9SXin LI dnode->tn_status |= TMPFS_NODE_CHANGED; 1185d1fa59e9SXin LI tmpfs_update(dvp); 1186d1fa59e9SXin LI 1187d1fa59e9SXin LI error = 0; 1188d1fa59e9SXin LI 1189d1fa59e9SXin LI out: 1190d1fa59e9SXin LI return error; 1191d1fa59e9SXin LI } 1192d1fa59e9SXin LI 1193a96539bfSXin LI static int 1194d1fa59e9SXin LI tmpfs_symlink(struct vop_symlink_args *v) 1195d1fa59e9SXin LI { 1196d1fa59e9SXin LI struct vnode *dvp = v->a_dvp; 1197d1fa59e9SXin LI struct vnode **vpp = v->a_vpp; 1198d1fa59e9SXin LI struct componentname *cnp = v->a_cnp; 1199d1fa59e9SXin LI struct vattr *vap = v->a_vap; 12001493c2eeSBrooks Davis const char *target = v->a_target; 1201d1fa59e9SXin LI 1202d1fa59e9SXin LI #ifdef notyet /* XXX FreeBSD BUG: kern_symlink is not setting VLNK */ 1203d1fa59e9SXin LI MPASS(vap->va_type == VLNK); 1204d1fa59e9SXin LI #else 1205d1fa59e9SXin LI vap->va_type = VLNK; 1206d1fa59e9SXin LI #endif 1207d1fa59e9SXin LI 1208d1fa59e9SXin LI return tmpfs_alloc_file(dvp, vpp, vap, cnp, target); 1209d1fa59e9SXin LI } 1210d1fa59e9SXin LI 1211a96539bfSXin LI static int 1212e1cdc30fSKonstantin Belousov tmpfs_readdir(struct vop_readdir_args *va) 1213d1fa59e9SXin LI { 1214e1cdc30fSKonstantin Belousov struct vnode *vp; 1215e1cdc30fSKonstantin Belousov struct uio *uio; 1216e1cdc30fSKonstantin Belousov struct tmpfs_mount *tm; 1217d1fa59e9SXin LI struct tmpfs_node *node; 1218e1cdc30fSKonstantin Belousov u_long **cookies; 1219e1cdc30fSKonstantin Belousov int *eofflag, *ncookies; 1220e1cdc30fSKonstantin Belousov ssize_t startresid; 1221e1cdc30fSKonstantin Belousov int error, maxcookies; 1222e1cdc30fSKonstantin Belousov 1223e1cdc30fSKonstantin Belousov vp = va->a_vp; 1224e1cdc30fSKonstantin Belousov uio = va->a_uio; 1225e1cdc30fSKonstantin Belousov eofflag = va->a_eofflag; 1226e1cdc30fSKonstantin Belousov cookies = va->a_cookies; 1227e1cdc30fSKonstantin Belousov ncookies = va->a_ncookies; 1228d1fa59e9SXin LI 1229d1fa59e9SXin LI /* This operation only makes sense on directory nodes. */ 1230ad3638eeSXin LI if (vp->v_type != VDIR) 1231ad3638eeSXin LI return ENOTDIR; 1232d1fa59e9SXin LI 1233ac09d109SBryan Drewery maxcookies = 0; 1234d1fa59e9SXin LI node = VP_TO_TMPFS_DIR(vp); 1235e1cdc30fSKonstantin Belousov tm = VFS_TO_TMPFS(vp->v_mount); 1236d1fa59e9SXin LI 12374fd5efe7SGleb Kurtsou startresid = uio->uio_resid; 1238d1fa59e9SXin LI 1239ac09d109SBryan Drewery /* Allocate cookies for NFS and compat modules. */ 12404fd5efe7SGleb Kurtsou if (cookies != NULL && ncookies != NULL) { 1241ac09d109SBryan Drewery maxcookies = howmany(node->tn_size, 1242ac09d109SBryan Drewery sizeof(struct tmpfs_dirent)) + 2; 1243ac09d109SBryan Drewery *cookies = malloc(maxcookies * sizeof(**cookies), M_TEMP, 1244ac09d109SBryan Drewery M_WAITOK); 12454fd5efe7SGleb Kurtsou *ncookies = 0; 1246d1fa59e9SXin LI } 1247d1fa59e9SXin LI 1248ac09d109SBryan Drewery if (cookies == NULL) 1249e1cdc30fSKonstantin Belousov error = tmpfs_dir_getdents(tm, node, uio, 0, NULL, NULL); 12504fd5efe7SGleb Kurtsou else 1251e1cdc30fSKonstantin Belousov error = tmpfs_dir_getdents(tm, node, uio, maxcookies, *cookies, 1252ac09d109SBryan Drewery ncookies); 12531f32d012SXin LI 1254ac09d109SBryan Drewery /* Buffer was filled without hitting EOF. */ 12554fd5efe7SGleb Kurtsou if (error == EJUSTRETURN) 12564fd5efe7SGleb Kurtsou error = (uio->uio_resid != startresid) ? 0 : EINVAL; 12571f32d012SXin LI 1258785eb42aSMark Johnston if (error != 0 && cookies != NULL && ncookies != NULL) { 12594fd5efe7SGleb Kurtsou free(*cookies, M_TEMP); 1260785eb42aSMark Johnston *cookies = NULL; 1261785eb42aSMark Johnston *ncookies = 0; 1262785eb42aSMark Johnston } 1263d1fa59e9SXin LI 1264d1fa59e9SXin LI if (eofflag != NULL) 1265d1fa59e9SXin LI *eofflag = 1266d1fa59e9SXin LI (error == 0 && uio->uio_offset == TMPFS_DIRCOOKIE_EOF); 1267d1fa59e9SXin LI 1268d1fa59e9SXin LI return error; 1269d1fa59e9SXin LI } 1270d1fa59e9SXin LI 1271a96539bfSXin LI static int 1272d1fa59e9SXin LI tmpfs_readlink(struct vop_readlink_args *v) 1273d1fa59e9SXin LI { 1274d1fa59e9SXin LI struct vnode *vp = v->a_vp; 1275d1fa59e9SXin LI struct uio *uio = v->a_uio; 1276d1fa59e9SXin LI 1277d1fa59e9SXin LI int error; 1278d1fa59e9SXin LI struct tmpfs_node *node; 1279d1fa59e9SXin LI 1280d1fa59e9SXin LI MPASS(uio->uio_offset == 0); 1281d1fa59e9SXin LI MPASS(vp->v_type == VLNK); 1282d1fa59e9SXin LI 1283d1fa59e9SXin LI node = VP_TO_TMPFS_NODE(vp); 1284d1fa59e9SXin LI 1285d1fa59e9SXin LI error = uiomove(node->tn_link, MIN(node->tn_size, uio->uio_resid), 1286d1fa59e9SXin LI uio); 1287e1cdc30fSKonstantin Belousov tmpfs_set_status(VFS_TO_TMPFS(vp->v_mount), node, TMPFS_NODE_ACCESSED); 1288d1fa59e9SXin LI 12895dc11286SKonstantin Belousov return (error); 1290d1fa59e9SXin LI } 1291d1fa59e9SXin LI 1292a96539bfSXin LI static int 1293d1fa59e9SXin LI tmpfs_inactive(struct vop_inactive_args *v) 1294d1fa59e9SXin LI { 1295f40cb1c6SKonstantin Belousov struct vnode *vp; 1296d1fa59e9SXin LI struct tmpfs_node *node; 1297d1fa59e9SXin LI 1298f40cb1c6SKonstantin Belousov vp = v->a_vp; 1299d1fa59e9SXin LI node = VP_TO_TMPFS_NODE(vp); 1300d1fa59e9SXin LI if (node->tn_links == 0) 1301af6e6b87SEdward Tomasz Napierala vrecycle(vp); 1302f40cb1c6SKonstantin Belousov else 1303f40cb1c6SKonstantin Belousov tmpfs_check_mtime(vp); 1304f40cb1c6SKonstantin Belousov return (0); 1305d1fa59e9SXin LI } 1306d1fa59e9SXin LI 1307a89cd2a4SMateusz Guzik static int 1308a89cd2a4SMateusz Guzik tmpfs_need_inactive(struct vop_need_inactive_args *ap) 1309a89cd2a4SMateusz Guzik { 1310a89cd2a4SMateusz Guzik struct vnode *vp; 1311a89cd2a4SMateusz Guzik struct tmpfs_node *node; 1312a89cd2a4SMateusz Guzik struct vm_object *obj; 1313a89cd2a4SMateusz Guzik 1314a89cd2a4SMateusz Guzik vp = ap->a_vp; 1315a89cd2a4SMateusz Guzik node = VP_TO_TMPFS_NODE(vp); 1316a89cd2a4SMateusz Guzik if (node->tn_links == 0) 1317a89cd2a4SMateusz Guzik goto need; 1318a89cd2a4SMateusz Guzik if (vp->v_type == VREG) { 1319a89cd2a4SMateusz Guzik obj = vp->v_object; 132067d0e293SJeff Roberson if (obj->generation != obj->cleangeneration) 1321a89cd2a4SMateusz Guzik goto need; 1322a89cd2a4SMateusz Guzik } 1323a89cd2a4SMateusz Guzik return (0); 1324a89cd2a4SMateusz Guzik need: 1325a89cd2a4SMateusz Guzik return (1); 1326a89cd2a4SMateusz Guzik } 1327a89cd2a4SMateusz Guzik 1328d1fa59e9SXin LI int 1329d1fa59e9SXin LI tmpfs_reclaim(struct vop_reclaim_args *v) 1330d1fa59e9SXin LI { 1331d1fa59e9SXin LI struct vnode *vp = v->a_vp; 1332d1fa59e9SXin LI 1333d1fa59e9SXin LI struct tmpfs_mount *tmp; 1334d1fa59e9SXin LI struct tmpfs_node *node; 1335d1fa59e9SXin LI 1336d1fa59e9SXin LI node = VP_TO_TMPFS_NODE(vp); 1337d1fa59e9SXin LI tmp = VFS_TO_TMPFS(vp->v_mount); 1338d1fa59e9SXin LI 1339158cc900SKonstantin Belousov if (vp->v_type == VREG) 1340158cc900SKonstantin Belousov tmpfs_destroy_vobject(vp, node->tn_reg.tn_aobj); 13416f2af3fcSKonstantin Belousov vp->v_object = NULL; 134200ac6a98SKonstantin Belousov if (tmpfs_use_nc(vp)) 1343d1fa59e9SXin LI cache_purge(vp); 134482cf92d4SXin LI 134582cf92d4SXin LI TMPFS_NODE_LOCK(node); 1346d1fa59e9SXin LI tmpfs_free_vp(vp); 1347d1fa59e9SXin LI 1348d1fa59e9SXin LI /* If the node referenced by this vnode was deleted by the user, 1349d1fa59e9SXin LI * we must free its associated data structures (now that the vnode 1350d1fa59e9SXin LI * is being reclaimed). */ 135182cf92d4SXin LI if (node->tn_links == 0 && 135282cf92d4SXin LI (node->tn_vpstate & TMPFS_VNODE_ALLOCATING) == 0) { 135382cf92d4SXin LI node->tn_vpstate = TMPFS_VNODE_DOOMED; 135482cf92d4SXin LI TMPFS_NODE_UNLOCK(node); 1355d1fa59e9SXin LI tmpfs_free_node(tmp, node); 135682cf92d4SXin LI } else 135782cf92d4SXin LI TMPFS_NODE_UNLOCK(node); 1358d1fa59e9SXin LI 1359d1fa59e9SXin LI MPASS(vp->v_data == NULL); 1360d1fa59e9SXin LI return 0; 1361d1fa59e9SXin LI } 1362d1fa59e9SXin LI 13635b01ccb0SJohn Baldwin int 1364d1fa59e9SXin LI tmpfs_print(struct vop_print_args *v) 1365d1fa59e9SXin LI { 1366d1fa59e9SXin LI struct vnode *vp = v->a_vp; 1367d1fa59e9SXin LI 1368d1fa59e9SXin LI struct tmpfs_node *node; 1369d1fa59e9SXin LI 1370d1fa59e9SXin LI node = VP_TO_TMPFS_NODE(vp); 1371d1fa59e9SXin LI 13721c324569SKonstantin Belousov printf("tag VT_TMPFS, tmpfs_node %p, flags 0x%lx, links %jd\n", 13731c324569SKonstantin Belousov node, node->tn_flags, (uintmax_t)node->tn_links); 13740662ee98STijl Coosemans printf("\tmode 0%o, owner %d, group %d, size %jd, status 0x%x\n", 1375d1fa59e9SXin LI node->tn_mode, node->tn_uid, node->tn_gid, 13760662ee98STijl Coosemans (intmax_t)node->tn_size, node->tn_status); 1377d1fa59e9SXin LI 1378d1fa59e9SXin LI if (vp->v_type == VFIFO) 1379d1fa59e9SXin LI fifo_printinfo(vp); 1380d1fa59e9SXin LI 1381d1fa59e9SXin LI printf("\n"); 1382d1fa59e9SXin LI 1383d1fa59e9SXin LI return 0; 1384d1fa59e9SXin LI } 1385d1fa59e9SXin LI 1386b501cc5dSJohn Baldwin int 1387d1fa59e9SXin LI tmpfs_pathconf(struct vop_pathconf_args *v) 1388d1fa59e9SXin LI { 1389b501cc5dSJohn Baldwin struct vnode *vp = v->a_vp; 1390d1fa59e9SXin LI int name = v->a_name; 1391b1288166SJohn Baldwin long *retval = v->a_retval; 1392d1fa59e9SXin LI 1393d1fa59e9SXin LI int error; 1394d1fa59e9SXin LI 1395d1fa59e9SXin LI error = 0; 1396d1fa59e9SXin LI 1397d1fa59e9SXin LI switch (name) { 1398599afe53SJohn Baldwin case _PC_LINK_MAX: 139935b1a3abSJohn Baldwin *retval = TMPFS_LINK_MAX; 1400599afe53SJohn Baldwin break; 1401599afe53SJohn Baldwin 1402599afe53SJohn Baldwin case _PC_NAME_MAX: 1403599afe53SJohn Baldwin *retval = NAME_MAX; 1404599afe53SJohn Baldwin break; 1405599afe53SJohn Baldwin 1406b501cc5dSJohn Baldwin case _PC_PIPE_BUF: 1407b501cc5dSJohn Baldwin if (vp->v_type == VDIR || vp->v_type == VFIFO) 1408b501cc5dSJohn Baldwin *retval = PIPE_BUF; 1409b501cc5dSJohn Baldwin else 1410b501cc5dSJohn Baldwin error = EINVAL; 1411b501cc5dSJohn Baldwin break; 1412b501cc5dSJohn Baldwin 1413599afe53SJohn Baldwin case _PC_CHOWN_RESTRICTED: 1414599afe53SJohn Baldwin *retval = 1; 1415599afe53SJohn Baldwin break; 1416599afe53SJohn Baldwin 1417d1fa59e9SXin LI case _PC_NO_TRUNC: 1418d1fa59e9SXin LI *retval = 1; 1419d1fa59e9SXin LI break; 1420d1fa59e9SXin LI 1421d1fa59e9SXin LI case _PC_SYNC_IO: 1422d1fa59e9SXin LI *retval = 1; 1423d1fa59e9SXin LI break; 1424d1fa59e9SXin LI 1425d1fa59e9SXin LI case _PC_FILESIZEBITS: 14269d1d1d19SJohn Baldwin *retval = 64; 1427d1fa59e9SXin LI break; 1428d1fa59e9SXin LI 1429d1fa59e9SXin LI default: 143015a88f81SJohn Baldwin error = vop_stdpathconf(v); 1431d1fa59e9SXin LI } 1432d1fa59e9SXin LI 1433d1fa59e9SXin LI return error; 1434d1fa59e9SXin LI } 1435d1fa59e9SXin LI 1436dfdcada3SDoug Rabson static int 1437d1fa59e9SXin LI tmpfs_vptofh(struct vop_vptofh_args *ap) 1438d1fa59e9SXin LI { 1439d1fa59e9SXin LI struct tmpfs_fid *tfhp; 1440d1fa59e9SXin LI struct tmpfs_node *node; 1441d1fa59e9SXin LI 1442d1fa59e9SXin LI tfhp = (struct tmpfs_fid *)ap->a_fhp; 1443d1fa59e9SXin LI node = VP_TO_TMPFS_NODE(ap->a_vp); 1444d1fa59e9SXin LI 1445d1fa59e9SXin LI tfhp->tf_len = sizeof(struct tmpfs_fid); 1446d1fa59e9SXin LI tfhp->tf_id = node->tn_id; 1447d1fa59e9SXin LI tfhp->tf_gen = node->tn_gen; 1448d1fa59e9SXin LI 1449d1fa59e9SXin LI return (0); 1450d1fa59e9SXin LI } 1451a96539bfSXin LI 145299d57a6bSEd Schouten static int 145399d57a6bSEd Schouten tmpfs_whiteout(struct vop_whiteout_args *ap) 145499d57a6bSEd Schouten { 145599d57a6bSEd Schouten struct vnode *dvp = ap->a_dvp; 145699d57a6bSEd Schouten struct componentname *cnp = ap->a_cnp; 145799d57a6bSEd Schouten struct tmpfs_dirent *de; 145899d57a6bSEd Schouten 145999d57a6bSEd Schouten switch (ap->a_flags) { 146099d57a6bSEd Schouten case LOOKUP: 146199d57a6bSEd Schouten return (0); 146299d57a6bSEd Schouten case CREATE: 146399d57a6bSEd Schouten de = tmpfs_dir_lookup(VP_TO_TMPFS_DIR(dvp), NULL, cnp); 146499d57a6bSEd Schouten if (de != NULL) 146599d57a6bSEd Schouten return (de->td_node == NULL ? 0 : EEXIST); 146699d57a6bSEd Schouten return (tmpfs_dir_whiteout_add(dvp, cnp)); 146799d57a6bSEd Schouten case DELETE: 146899d57a6bSEd Schouten tmpfs_dir_whiteout_remove(dvp, cnp); 146999d57a6bSEd Schouten return (0); 147099d57a6bSEd Schouten default: 147199d57a6bSEd Schouten panic("tmpfs_whiteout: unknown op"); 147299d57a6bSEd Schouten } 147399d57a6bSEd Schouten } 147499d57a6bSEd Schouten 147508c053e7SKonstantin Belousov static int 147608c053e7SKonstantin Belousov tmpfs_vptocnp_dir(struct tmpfs_node *tn, struct tmpfs_node *tnp, 147708c053e7SKonstantin Belousov struct tmpfs_dirent **pde) 147808c053e7SKonstantin Belousov { 147908c053e7SKonstantin Belousov struct tmpfs_dir_cursor dc; 148008c053e7SKonstantin Belousov struct tmpfs_dirent *de; 148108c053e7SKonstantin Belousov 148208c053e7SKonstantin Belousov for (de = tmpfs_dir_first(tnp, &dc); de != NULL; 148308c053e7SKonstantin Belousov de = tmpfs_dir_next(tnp, &dc)) { 148408c053e7SKonstantin Belousov if (de->td_node == tn) { 148508c053e7SKonstantin Belousov *pde = de; 148608c053e7SKonstantin Belousov return (0); 148708c053e7SKonstantin Belousov } 148808c053e7SKonstantin Belousov } 148908c053e7SKonstantin Belousov return (ENOENT); 149008c053e7SKonstantin Belousov } 149108c053e7SKonstantin Belousov 149208c053e7SKonstantin Belousov static int 149308c053e7SKonstantin Belousov tmpfs_vptocnp_fill(struct vnode *vp, struct tmpfs_node *tn, 149408c053e7SKonstantin Belousov struct tmpfs_node *tnp, char *buf, int *buflen, struct vnode **dvp) 149508c053e7SKonstantin Belousov { 149608c053e7SKonstantin Belousov struct tmpfs_dirent *de; 149708c053e7SKonstantin Belousov int error, i; 149808c053e7SKonstantin Belousov 149908c053e7SKonstantin Belousov error = vn_vget_ino_gen(vp, tmpfs_vn_get_ino_alloc, tnp, LK_SHARED, 150008c053e7SKonstantin Belousov dvp); 150108c053e7SKonstantin Belousov if (error != 0) 150208c053e7SKonstantin Belousov return (error); 150308c053e7SKonstantin Belousov error = tmpfs_vptocnp_dir(tn, tnp, &de); 150408c053e7SKonstantin Belousov if (error == 0) { 150508c053e7SKonstantin Belousov i = *buflen; 150608c053e7SKonstantin Belousov i -= de->td_namelen; 150708c053e7SKonstantin Belousov if (i < 0) { 150808c053e7SKonstantin Belousov error = ENOMEM; 150908c053e7SKonstantin Belousov } else { 151008c053e7SKonstantin Belousov bcopy(de->ud.td_name, buf + i, de->td_namelen); 151108c053e7SKonstantin Belousov *buflen = i; 151208c053e7SKonstantin Belousov } 151308c053e7SKonstantin Belousov } 151408c053e7SKonstantin Belousov if (error == 0) { 151508c053e7SKonstantin Belousov if (vp != *dvp) 151608c053e7SKonstantin Belousov VOP_UNLOCK(*dvp, 0); 151708c053e7SKonstantin Belousov } else { 151808c053e7SKonstantin Belousov if (vp != *dvp) 151908c053e7SKonstantin Belousov vput(*dvp); 152008c053e7SKonstantin Belousov else 152108c053e7SKonstantin Belousov vrele(vp); 152208c053e7SKonstantin Belousov } 152308c053e7SKonstantin Belousov return (error); 152408c053e7SKonstantin Belousov } 152508c053e7SKonstantin Belousov 152608c053e7SKonstantin Belousov static int 152708c053e7SKonstantin Belousov tmpfs_vptocnp(struct vop_vptocnp_args *ap) 152808c053e7SKonstantin Belousov { 152908c053e7SKonstantin Belousov struct vnode *vp, **dvp; 153008c053e7SKonstantin Belousov struct tmpfs_node *tn, *tnp, *tnp1; 153108c053e7SKonstantin Belousov struct tmpfs_dirent *de; 153208c053e7SKonstantin Belousov struct tmpfs_mount *tm; 153308c053e7SKonstantin Belousov char *buf; 153408c053e7SKonstantin Belousov int *buflen; 153508c053e7SKonstantin Belousov int error; 153608c053e7SKonstantin Belousov 153708c053e7SKonstantin Belousov vp = ap->a_vp; 153808c053e7SKonstantin Belousov dvp = ap->a_vpp; 153908c053e7SKonstantin Belousov buf = ap->a_buf; 154008c053e7SKonstantin Belousov buflen = ap->a_buflen; 154108c053e7SKonstantin Belousov 154208c053e7SKonstantin Belousov tm = VFS_TO_TMPFS(vp->v_mount); 154308c053e7SKonstantin Belousov tn = VP_TO_TMPFS_NODE(vp); 154408c053e7SKonstantin Belousov if (tn->tn_type == VDIR) { 154508c053e7SKonstantin Belousov tnp = tn->tn_dir.tn_parent; 154608c053e7SKonstantin Belousov if (tnp == NULL) 154708c053e7SKonstantin Belousov return (ENOENT); 154808c053e7SKonstantin Belousov tmpfs_ref_node(tnp); 154908c053e7SKonstantin Belousov error = tmpfs_vptocnp_fill(vp, tn, tn->tn_dir.tn_parent, buf, 155008c053e7SKonstantin Belousov buflen, dvp); 155108c053e7SKonstantin Belousov tmpfs_free_node(tm, tnp); 155208c053e7SKonstantin Belousov return (error); 155308c053e7SKonstantin Belousov } 155408c053e7SKonstantin Belousov restart: 155508c053e7SKonstantin Belousov TMPFS_LOCK(tm); 155608c053e7SKonstantin Belousov LIST_FOREACH_SAFE(tnp, &tm->tm_nodes_used, tn_entries, tnp1) { 155708c053e7SKonstantin Belousov if (tnp->tn_type != VDIR) 155808c053e7SKonstantin Belousov continue; 155908c053e7SKonstantin Belousov TMPFS_NODE_LOCK(tnp); 156008c053e7SKonstantin Belousov tmpfs_ref_node_locked(tnp); 156108c053e7SKonstantin Belousov 156208c053e7SKonstantin Belousov /* 156308c053e7SKonstantin Belousov * tn_vnode cannot be instantiated while we hold the 156408c053e7SKonstantin Belousov * node lock, so the directory cannot be changed while 156508c053e7SKonstantin Belousov * we iterate over it. Do this to avoid instantiating 156608c053e7SKonstantin Belousov * vnode for directories which cannot point to our 156708c053e7SKonstantin Belousov * node. 156808c053e7SKonstantin Belousov */ 156908c053e7SKonstantin Belousov error = tnp->tn_vnode == NULL ? tmpfs_vptocnp_dir(tn, tnp, 157008c053e7SKonstantin Belousov &de) : 0; 157108c053e7SKonstantin Belousov 157208c053e7SKonstantin Belousov if (error == 0) { 157308c053e7SKonstantin Belousov TMPFS_NODE_UNLOCK(tnp); 157408c053e7SKonstantin Belousov TMPFS_UNLOCK(tm); 157508c053e7SKonstantin Belousov error = tmpfs_vptocnp_fill(vp, tn, tnp, buf, buflen, 157608c053e7SKonstantin Belousov dvp); 157708c053e7SKonstantin Belousov if (error == 0) { 157808c053e7SKonstantin Belousov tmpfs_free_node(tm, tnp); 157908c053e7SKonstantin Belousov return (0); 158008c053e7SKonstantin Belousov } 1581*abd80ddbSMateusz Guzik if (VN_IS_DOOMED(vp)) { 158208c053e7SKonstantin Belousov tmpfs_free_node(tm, tnp); 158308c053e7SKonstantin Belousov return (ENOENT); 158408c053e7SKonstantin Belousov } 158508c053e7SKonstantin Belousov TMPFS_LOCK(tm); 158608c053e7SKonstantin Belousov TMPFS_NODE_LOCK(tnp); 158708c053e7SKonstantin Belousov } 158808c053e7SKonstantin Belousov if (tmpfs_free_node_locked(tm, tnp, false)) { 158908c053e7SKonstantin Belousov goto restart; 159008c053e7SKonstantin Belousov } else { 159108c053e7SKonstantin Belousov KASSERT(tnp->tn_refcount > 0, 159208c053e7SKonstantin Belousov ("node %p refcount zero", tnp)); 159308c053e7SKonstantin Belousov tnp1 = LIST_NEXT(tnp, tn_entries); 159408c053e7SKonstantin Belousov TMPFS_NODE_UNLOCK(tnp); 159508c053e7SKonstantin Belousov } 159608c053e7SKonstantin Belousov } 159708c053e7SKonstantin Belousov TMPFS_UNLOCK(tm); 159808c053e7SKonstantin Belousov return (ENOENT); 159908c053e7SKonstantin Belousov } 160008c053e7SKonstantin Belousov 1601a96539bfSXin LI /* 1602bba7ed20SKonstantin Belousov * Vnode operations vector used for files stored in a tmpfs file system. 1603a96539bfSXin LI */ 1604a96539bfSXin LI struct vop_vector tmpfs_vnodeop_entries = { 1605a96539bfSXin LI .vop_default = &default_vnodeops, 1606a96539bfSXin LI .vop_lookup = vfs_cache_lookup, 160700ac6a98SKonstantin Belousov .vop_cachedlookup = tmpfs_cached_lookup, 1608a96539bfSXin LI .vop_create = tmpfs_create, 1609a96539bfSXin LI .vop_mknod = tmpfs_mknod, 1610a96539bfSXin LI .vop_open = tmpfs_open, 1611a96539bfSXin LI .vop_close = tmpfs_close, 1612a96539bfSXin LI .vop_access = tmpfs_access, 1613a96539bfSXin LI .vop_getattr = tmpfs_getattr, 1614a96539bfSXin LI .vop_setattr = tmpfs_setattr, 1615a96539bfSXin LI .vop_read = tmpfs_read, 1616a96539bfSXin LI .vop_write = tmpfs_write, 1617a96539bfSXin LI .vop_fsync = tmpfs_fsync, 1618a96539bfSXin LI .vop_remove = tmpfs_remove, 1619a96539bfSXin LI .vop_link = tmpfs_link, 1620a96539bfSXin LI .vop_rename = tmpfs_rename, 1621a96539bfSXin LI .vop_mkdir = tmpfs_mkdir, 1622a96539bfSXin LI .vop_rmdir = tmpfs_rmdir, 1623a96539bfSXin LI .vop_symlink = tmpfs_symlink, 1624a96539bfSXin LI .vop_readdir = tmpfs_readdir, 1625a96539bfSXin LI .vop_readlink = tmpfs_readlink, 1626a96539bfSXin LI .vop_inactive = tmpfs_inactive, 1627a89cd2a4SMateusz Guzik .vop_need_inactive = tmpfs_need_inactive, 1628a96539bfSXin LI .vop_reclaim = tmpfs_reclaim, 1629a96539bfSXin LI .vop_print = tmpfs_print, 1630a96539bfSXin LI .vop_pathconf = tmpfs_pathconf, 1631a96539bfSXin LI .vop_vptofh = tmpfs_vptofh, 163299d57a6bSEd Schouten .vop_whiteout = tmpfs_whiteout, 1633a96539bfSXin LI .vop_bmap = VOP_EOPNOTSUPP, 163408c053e7SKonstantin Belousov .vop_vptocnp = tmpfs_vptocnp, 1635a96539bfSXin LI }; 1636a96539bfSXin LI 163700ac6a98SKonstantin Belousov /* 163800ac6a98SKonstantin Belousov * Same vector for mounts which do not use namecache. 163900ac6a98SKonstantin Belousov */ 164000ac6a98SKonstantin Belousov struct vop_vector tmpfs_vnodeop_nonc_entries = { 164100ac6a98SKonstantin Belousov .vop_default = &tmpfs_vnodeop_entries, 164200ac6a98SKonstantin Belousov .vop_lookup = tmpfs_lookup, 164300ac6a98SKonstantin Belousov }; 1644