/* $NetBSD: tmpfs_vnops.c,v 1.150 2022/06/01 08:42:38 hannken Exp $ */ /* * Copyright (c) 2005, 2006, 2007, 2020 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Julio M. Merino Vidal, developed as part of Google's Summer of Code * 2005 program. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /* * tmpfs vnode interface. */ #include __KERNEL_RCSID(0, "$NetBSD: tmpfs_vnops.c,v 1.150 2022/06/01 08:42:38 hannken Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* * vnode operations vector used for files stored in a tmpfs file system. */ int (**tmpfs_vnodeop_p)(void *); const struct vnodeopv_entry_desc tmpfs_vnodeop_entries[] = { { &vop_default_desc, vn_default_error }, { &vop_parsepath_desc, genfs_parsepath }, { &vop_lookup_desc, tmpfs_lookup }, { &vop_create_desc, tmpfs_create }, { &vop_mknod_desc, tmpfs_mknod }, { &vop_open_desc, tmpfs_open }, { &vop_close_desc, tmpfs_close }, { &vop_access_desc, tmpfs_access }, { &vop_accessx_desc, genfs_accessx }, { &vop_getattr_desc, tmpfs_getattr }, { &vop_setattr_desc, tmpfs_setattr }, { &vop_read_desc, tmpfs_read }, { &vop_write_desc, tmpfs_write }, { &vop_fallocate_desc, genfs_eopnotsupp }, { &vop_fdiscard_desc, genfs_eopnotsupp }, { &vop_ioctl_desc, genfs_enoioctl }, { &vop_fcntl_desc, genfs_fcntl }, { &vop_poll_desc, genfs_poll }, { &vop_kqfilter_desc, genfs_kqfilter }, { &vop_revoke_desc, genfs_revoke }, { &vop_mmap_desc, genfs_mmap }, { &vop_fsync_desc, tmpfs_fsync }, { &vop_seek_desc, genfs_seek }, { &vop_remove_desc, tmpfs_remove }, { &vop_link_desc, tmpfs_link }, { &vop_rename_desc, tmpfs_rename }, { &vop_mkdir_desc, tmpfs_mkdir }, { &vop_rmdir_desc, tmpfs_rmdir }, { &vop_symlink_desc, tmpfs_symlink }, { &vop_readdir_desc, tmpfs_readdir }, { &vop_readlink_desc, tmpfs_readlink }, { &vop_abortop_desc, genfs_abortop }, { &vop_inactive_desc, tmpfs_inactive }, { &vop_reclaim_desc, tmpfs_reclaim }, { &vop_lock_desc, genfs_lock }, { &vop_unlock_desc, genfs_unlock }, { &vop_bmap_desc, genfs_eopnotsupp }, { &vop_strategy_desc, genfs_eopnotsupp }, { &vop_print_desc, tmpfs_print }, { &vop_pathconf_desc, tmpfs_pathconf }, { &vop_islocked_desc, genfs_islocked }, { &vop_advlock_desc, tmpfs_advlock }, { &vop_bwrite_desc, genfs_nullop }, { &vop_getpages_desc, tmpfs_getpages }, { &vop_putpages_desc, tmpfs_putpages }, { &vop_whiteout_desc, tmpfs_whiteout }, { NULL, NULL } }; const struct vnodeopv_desc tmpfs_vnodeop_opv_desc = { &tmpfs_vnodeop_p, tmpfs_vnodeop_entries }; /* * tmpfs_lookup: path name traversal routine. * * Arguments: dvp (directory being searched), vpp (result), * cnp (component name - path). * * => Caller holds a reference and lock on dvp. * => We return looked-up vnode (vpp) locked, with a reference held. */ int tmpfs_lookup(void *v) { struct vop_lookup_v2_args /* { struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; } */ *ap = v; vnode_t *dvp = ap->a_dvp, **vpp = ap->a_vpp; struct componentname *cnp = ap->a_cnp; const bool lastcn = (cnp->cn_flags & ISLASTCN) != 0; tmpfs_node_t *dnode, *tnode; tmpfs_dirent_t *de; int cachefound, iswhiteout; int error; KASSERT(VOP_ISLOCKED(dvp)); dnode = VP_TO_TMPFS_DIR(dvp); *vpp = NULL; /* Check accessibility of directory. */ error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred); if (error) { goto out; } /* * If requesting the last path component on a read-only file system * with a write operation, deny it. */ if (lastcn && (dvp->v_mount->mnt_flag & MNT_RDONLY) != 0 && (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) { error = EROFS; goto out; } /* * Avoid doing a linear scan of the directory if the requested * directory/name couple is already in the cache. */ cachefound = cache_lookup(dvp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_nameiop, cnp->cn_flags, &iswhiteout, vpp); if (iswhiteout) { cnp->cn_flags |= ISWHITEOUT; } if (cachefound && *vpp == NULLVP) { /* Negative cache hit. */ error = ENOENT; goto out; } else if (cachefound) { error = 0; goto out; } /* * Treat an unlinked directory as empty (no "." or "..") */ if (dnode->tn_links == 0) { KASSERT(dnode->tn_size == 0); error = ENOENT; goto out; } if (cnp->cn_flags & ISDOTDOT) { tmpfs_node_t *pnode; /* * Lookup of ".." case. */ if (lastcn && cnp->cn_nameiop == RENAME) { error = EINVAL; goto out; } KASSERT(dnode->tn_type == VDIR); pnode = dnode->tn_spec.tn_dir.tn_parent; if (pnode == NULL) { error = ENOENT; goto done; } error = vcache_get(dvp->v_mount, &pnode, sizeof(pnode), vpp); goto done; } else if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') { /* * Lookup of "." case. */ if (lastcn && cnp->cn_nameiop == RENAME) { error = EISDIR; goto out; } vref(dvp); *vpp = dvp; error = 0; goto done; } /* * Other lookup cases: perform directory scan. */ de = tmpfs_dir_lookup(dnode, cnp); if (de == NULL || de->td_node == TMPFS_NODE_WHITEOUT) { /* * The entry was not found in the directory. This is valid * if we are creating or renaming an entry and are working * on the last component of the path name. */ if (lastcn && (cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME)) { error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred); if (error) { goto out; } error = EJUSTRETURN; } else { error = ENOENT; } if (de) { KASSERT(de->td_node == TMPFS_NODE_WHITEOUT); cnp->cn_flags |= ISWHITEOUT; } goto done; } tnode = de->td_node; /* * If it is not the last path component and found a non-directory * or non-link entry (which may itself be pointing to a directory), * raise an error. */ if (!lastcn && tnode->tn_type != VDIR && tnode->tn_type != VLNK) { error = ENOTDIR; goto out; } /* Check the permissions. */ if (lastcn && (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) { error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred); if (error) goto out; if ((dnode->tn_mode & S_ISTXT) != 0) { error = kauth_authorize_vnode(cnp->cn_cred, KAUTH_VNODE_DELETE, tnode->tn_vnode, dnode->tn_vnode, genfs_can_sticky(dvp, cnp->cn_cred, dnode->tn_uid, tnode->tn_uid)); if (error) { error = EPERM; goto out; } } } /* Get a vnode for the matching entry. */ error = vcache_get(dvp->v_mount, &tnode, sizeof(tnode), vpp); done: /* * Cache the result, unless request was for creation (as it does * not improve the performance). */ if (cnp->cn_nameiop != CREATE) { cache_enter(dvp, *vpp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_flags); } out: KASSERT(VOP_ISLOCKED(dvp)); return error; } int tmpfs_create(void *v) { struct vop_create_v3_args /* { struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; struct vattr *a_vap; } */ *ap = v; vnode_t *dvp = ap->a_dvp, **vpp = ap->a_vpp; struct componentname *cnp = ap->a_cnp; struct vattr *vap = ap->a_vap; KASSERT(VOP_ISLOCKED(dvp)); KASSERT(vap->va_type == VREG || vap->va_type == VSOCK); return tmpfs_construct_node(dvp, vpp, vap, cnp, NULL); } int tmpfs_mknod(void *v) { struct vop_mknod_v3_args /* { struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; struct vattr *a_vap; } */ *ap = v; vnode_t *dvp = ap->a_dvp, **vpp = ap->a_vpp; struct componentname *cnp = ap->a_cnp; struct vattr *vap = ap->a_vap; enum vtype vt = vap->va_type; if (vt != VBLK && vt != VCHR && vt != VFIFO) { *vpp = NULL; return EINVAL; } return tmpfs_construct_node(dvp, vpp, vap, cnp, NULL); } int tmpfs_open(void *v) { struct vop_open_args /* { struct vnode *a_vp; int a_mode; kauth_cred_t a_cred; } */ *ap = v; vnode_t *vp = ap->a_vp; mode_t mode = ap->a_mode; tmpfs_node_t *node; KASSERT(VOP_ISLOCKED(vp)); node = VP_TO_TMPFS_NODE(vp); /* If the file is marked append-only, deny write requests. */ if ((node->tn_flags & APPEND) != 0 && (mode & (FWRITE | O_APPEND)) == FWRITE) { return EPERM; } return 0; } int tmpfs_close(void *v) { struct vop_close_args /* { struct vnode *a_vp; int a_fflag; kauth_cred_t a_cred; } */ *ap = v; vnode_t *vp __diagused = ap->a_vp; KASSERT(VOP_ISLOCKED(vp)); return 0; } int tmpfs_access(void *v) { struct vop_access_args /* { struct vnode *a_vp; accmode_t a_accmode; kauth_cred_t a_cred; } */ *ap = v; vnode_t *vp = ap->a_vp; accmode_t accmode = ap->a_accmode; kauth_cred_t cred = ap->a_cred; tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); const bool writing = (accmode & VWRITE) != 0; KASSERT(VOP_ISLOCKED(vp)); /* Possible? */ switch (vp->v_type) { case VDIR: case VLNK: case VREG: if (writing && (vp->v_mount->mnt_flag & MNT_RDONLY) != 0) { return EROFS; } break; case VBLK: case VCHR: case VSOCK: case VFIFO: break; default: return EINVAL; } if (writing && (node->tn_flags & IMMUTABLE) != 0) { return EPERM; } return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(accmode, vp->v_type, node->tn_mode), vp, NULL, genfs_can_access(vp, cred, node->tn_uid, node->tn_gid, node->tn_mode, NULL, accmode)); } int tmpfs_getattr(void *v) { struct vop_getattr_args /* { struct vnode *a_vp; struct vattr *a_vap; kauth_cred_t a_cred; } */ *ap = v; vnode_t *vp = ap->a_vp; struct vattr *vap = ap->a_vap; tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); vattr_null(vap); vap->va_type = vp->v_type; vap->va_mode = node->tn_mode; vap->va_nlink = node->tn_links; vap->va_uid = node->tn_uid; vap->va_gid = node->tn_gid; vap->va_fsid = vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0]; vap->va_fileid = node->tn_id; vap->va_size = node->tn_size; vap->va_blocksize = PAGE_SIZE; vap->va_gen = TMPFS_NODE_GEN(node); vap->va_flags = node->tn_flags; vap->va_rdev = (vp->v_type == VBLK || vp->v_type == VCHR) ? node->tn_spec.tn_dev.tn_rdev : VNOVAL; vap->va_bytes = round_page(node->tn_size); vap->va_filerev = VNOVAL; vap->va_vaflags = 0; vap->va_spare = VNOVAL; /* XXX */ mutex_enter(&node->tn_timelock); tmpfs_update_locked(vp, 0); vap->va_atime = node->tn_atime; vap->va_mtime = node->tn_mtime; vap->va_ctime = node->tn_ctime; vap->va_birthtime = node->tn_birthtime; mutex_exit(&node->tn_timelock); return 0; } int tmpfs_setattr(void *v) { struct vop_setattr_args /* { struct vnode *a_vp; struct vattr *a_vap; kauth_cred_t a_cred; } */ *ap = v; vnode_t *vp = ap->a_vp; struct vattr *vap = ap->a_vap; kauth_cred_t cred = ap->a_cred; lwp_t *l = curlwp; int error = 0; KASSERT(VOP_ISLOCKED(vp)); /* Abort if any unsettable attribute is given. */ if (vap->va_type != VNON || vap->va_nlink != VNOVAL || vap->va_fsid != VNOVAL || vap->va_fileid != VNOVAL || vap->va_blocksize != VNOVAL || vap->va_ctime.tv_sec != VNOVAL || vap->va_gen != VNOVAL || vap->va_rdev != VNOVAL || vap->va_bytes != VNOVAL) { return EINVAL; } if (error == 0 && vap->va_flags != VNOVAL) error = tmpfs_chflags(vp, vap->va_flags, cred, l); if (error == 0 && vap->va_size != VNOVAL) error = tmpfs_chsize(vp, vap->va_size, cred, l); if (error == 0 && (vap->va_uid != VNOVAL || vap->va_gid != VNOVAL)) error = tmpfs_chown(vp, vap->va_uid, vap->va_gid, cred, l); if (error == 0 && vap->va_mode != VNOVAL) error = tmpfs_chmod(vp, vap->va_mode, cred, l); const bool chsometime = vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL || vap->va_birthtime.tv_sec != VNOVAL; if (error == 0 && chsometime) { error = tmpfs_chtimes(vp, &vap->va_atime, &vap->va_mtime, &vap->va_birthtime, vap->va_vaflags, cred, l); } return error; } int tmpfs_read(void *v) { struct vop_read_args /* { struct vnode *a_vp; struct uio *a_uio; int a_ioflag; kauth_cred_t a_cred; } */ *ap = v; vnode_t *vp = ap->a_vp; struct uio *uio = ap->a_uio; const int ioflag = ap->a_ioflag; tmpfs_node_t *node; struct uvm_object *uobj; int error; KASSERT(VOP_ISLOCKED(vp)); if (vp->v_type == VDIR) { return EISDIR; } if (uio->uio_offset < 0 || vp->v_type != VREG) { return EINVAL; } /* Note: reading zero bytes should not update atime. */ if (uio->uio_resid == 0) { return 0; } node = VP_TO_TMPFS_NODE(vp); uobj = node->tn_spec.tn_reg.tn_aobj; error = 0; while (error == 0 && uio->uio_resid > 0) { vsize_t len; if (node->tn_size <= uio->uio_offset) { break; } len = MIN(node->tn_size - uio->uio_offset, uio->uio_resid); if (len == 0) { break; } error = ubc_uiomove(uobj, uio, len, IO_ADV_DECODE(ioflag), UBC_READ | UBC_PARTIALOK | UBC_VNODE_FLAGS(vp)); } if ((vp->v_mount->mnt_flag & MNT_NOATIME) == 0) tmpfs_update(vp, TMPFS_UPDATE_ATIME); return error; } int tmpfs_write(void *v) { struct vop_write_args /* { struct vnode *a_vp; struct uio *a_uio; int a_ioflag; kauth_cred_t a_cred; } */ *ap = v; vnode_t *vp = ap->a_vp; struct uio *uio = ap->a_uio; const int ioflag = ap->a_ioflag; tmpfs_node_t *node; struct uvm_object *uobj; off_t oldsize; int error, ubc_flags; KASSERT(VOP_ISLOCKED(vp)); node = VP_TO_TMPFS_NODE(vp); oldsize = node->tn_size; if ((vp->v_mount->mnt_flag & MNT_RDONLY) != 0) { error = EROFS; goto out; } if (uio->uio_offset < 0 || vp->v_type != VREG) { error = EINVAL; goto out; } if (uio->uio_resid == 0) { error = 0; goto out; } if (ioflag & IO_APPEND) { uio->uio_offset = node->tn_size; } if (uio->uio_offset + uio->uio_resid > node->tn_size) { error = tmpfs_reg_resize(vp, uio->uio_offset + uio->uio_resid); if (error) goto out; } /* * If we're extending the file and have data to write that would * not leave an un-zeroed hole, we can avoid fault processing and * zeroing of pages on allocation. * * Don't do this if the file is mapped and we need to touch an * existing page, because writing a mapping of the file into itself * could cause a deadlock on PG_BUSY. * * New pages will not become visible until finished here (because * of PG_BUSY and the vnode lock). */ ubc_flags = UBC_WRITE | UBC_VNODE_FLAGS(vp); #if 0 /* * XXX disable use of UBC_FAULTBUSY for now, this check is insufficient * because it does not zero uninitialized parts of pages in all of * the cases where zeroing is needed. */ if (uio->uio_offset >= oldsize && ((uio->uio_offset & (PAGE_SIZE - 1)) == 0 || ((vp->v_vflag & VV_MAPPED) == 0 && trunc_page(uio->uio_offset) == trunc_page(oldsize)))) { ubc_flags |= UBC_FAULTBUSY; } #endif uobj = node->tn_spec.tn_reg.tn_aobj; error = 0; while (error == 0 && uio->uio_resid > 0) { vsize_t len; len = MIN(node->tn_size - uio->uio_offset, uio->uio_resid); if (len == 0) { break; } error = ubc_uiomove(uobj, uio, len, IO_ADV_DECODE(ioflag), ubc_flags); } if (error) { (void)tmpfs_reg_resize(vp, oldsize); } tmpfs_update(vp, TMPFS_UPDATE_MTIME | TMPFS_UPDATE_CTIME); out: if (error) { KASSERT(oldsize == node->tn_size); } else { KASSERT(uio->uio_resid == 0); } return error; } int tmpfs_fsync(void *v) { struct vop_fsync_args /* { struct vnode *a_vp; kauth_cred_t a_cred; int a_flags; off_t a_offlo; off_t a_offhi; struct lwp *a_l; } */ *ap = v; vnode_t *vp __diagused = ap->a_vp; /* Nothing to do. Should be up to date. */ KASSERT(VOP_ISLOCKED(vp)); return 0; } /* * tmpfs_remove: unlink a file. * * => Both directory (dvp) and file (vp) are locked. * => We unlock and drop the reference on both. */ int tmpfs_remove(void *v) { struct vop_remove_v3_args /* { struct vnode *a_dvp; struct vnode *a_vp; struct componentname *a_cnp; nlink_t ctx_vp_new_nlink; } */ *ap = v; vnode_t *dvp = ap->a_dvp, *vp = ap->a_vp; tmpfs_node_t *dnode, *node; tmpfs_dirent_t *de; int error, tflags; KASSERT(VOP_ISLOCKED(dvp)); KASSERT(VOP_ISLOCKED(vp)); if (vp->v_type == VDIR) { error = EPERM; goto out; } dnode = VP_TO_TMPFS_DIR(dvp); node = VP_TO_TMPFS_NODE(vp); /* * Files marked as immutable or append-only cannot be deleted. * Likewise, files residing on directories marked as append-only * cannot be deleted. */ if (node->tn_flags & (IMMUTABLE | APPEND)) { error = EPERM; goto out; } if (dnode->tn_flags & APPEND) { error = EPERM; goto out; } /* Lookup the directory entry (check the cached hint first). */ de = tmpfs_dir_cached(node); if (de == NULL) { struct componentname *cnp = ap->a_cnp; de = tmpfs_dir_lookup(dnode, cnp); } KASSERT(de && de->td_node == node); /* * Remove the entry from the directory (drops the link count) and * destroy it or replace with a whiteout. * * Note: the inode referred by it will not be destroyed until the * vnode is reclaimed/recycled. */ tmpfs_dir_detach(dnode, de); if (ap->a_cnp->cn_flags & DOWHITEOUT) tmpfs_dir_attach(dnode, de, TMPFS_NODE_WHITEOUT); else tmpfs_free_dirent(VFS_TO_TMPFS(vp->v_mount), de); tflags = TMPFS_UPDATE_MTIME | TMPFS_UPDATE_CTIME; if (node->tn_links > 0) { /* We removed a hard link. */ tflags |= TMPFS_UPDATE_CTIME; } ap->ctx_vp_new_nlink = node->tn_links; tmpfs_update(dvp, tflags); error = 0; out: /* Drop the reference and unlock the node. */ if (dvp == vp) { vrele(vp); } else { vput(vp); } return error; } /* * tmpfs_link: create a hard link. */ int tmpfs_link(void *v) { struct vop_link_v2_args /* { struct vnode *a_dvp; struct vnode *a_vp; struct componentname *a_cnp; } */ *ap = v; vnode_t *dvp = ap->a_dvp; vnode_t *vp = ap->a_vp; struct componentname *cnp = ap->a_cnp; tmpfs_node_t *dnode, *node; tmpfs_dirent_t *de; int error; KASSERT(dvp != vp); KASSERT(VOP_ISLOCKED(dvp)); KASSERT(vp->v_type != VDIR); KASSERT(dvp->v_mount == vp->v_mount); dnode = VP_TO_TMPFS_DIR(dvp); node = VP_TO_TMPFS_NODE(vp); vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); /* Check for maximum number of links limit. */ if (node->tn_links == LINK_MAX) { error = EMLINK; goto out; } KASSERT(node->tn_links < LINK_MAX); /* We cannot create links of files marked immutable or append-only. */ if (node->tn_flags & (IMMUTABLE | APPEND)) { error = EPERM; goto out; } error = kauth_authorize_vnode(cnp->cn_cred, KAUTH_VNODE_ADD_LINK, vp, dvp, 0); if (error) goto out; /* Allocate a new directory entry to represent the inode. */ error = tmpfs_alloc_dirent(VFS_TO_TMPFS(vp->v_mount), cnp->cn_nameptr, cnp->cn_namelen, &de); if (error) { goto out; } /* * Insert the entry into the directory. * It will increase the inode link count. */ tmpfs_dir_attach(dnode, de, node); tmpfs_update(dvp, TMPFS_UPDATE_MTIME | TMPFS_UPDATE_CTIME); /* Update the timestamps. */ tmpfs_update(vp, TMPFS_UPDATE_CTIME); error = 0; out: VOP_UNLOCK(vp); return error; } int tmpfs_mkdir(void *v) { struct vop_mkdir_v3_args /* { struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; struct vattr *a_vap; } */ *ap = v; vnode_t *dvp = ap->a_dvp; vnode_t **vpp = ap->a_vpp; struct componentname *cnp = ap->a_cnp; struct vattr *vap = ap->a_vap; KASSERT(vap->va_type == VDIR); return tmpfs_construct_node(dvp, vpp, vap, cnp, NULL); } int tmpfs_rmdir(void *v) { struct vop_rmdir_v2_args /* { struct vnode *a_dvp; struct vnode *a_vp; struct componentname *a_cnp; } */ *ap = v; vnode_t *dvp = ap->a_dvp; vnode_t *vp = ap->a_vp; tmpfs_mount_t *tmp = VFS_TO_TMPFS(dvp->v_mount); tmpfs_node_t *dnode = VP_TO_TMPFS_DIR(dvp); tmpfs_node_t *node = VP_TO_TMPFS_DIR(vp); tmpfs_dirent_t *de; int error = 0; KASSERT(VOP_ISLOCKED(dvp)); KASSERT(VOP_ISLOCKED(vp)); /* * Directories with more than two entries ('.' and '..') cannot be * removed. There may be whiteout entries, which we will destroy. */ if (node->tn_size > 0) { /* * If never had whiteout entries, the directory is certainly * not empty. Otherwise, scan for any non-whiteout entry. */ if ((node->tn_gen & TMPFS_WHITEOUT_BIT) == 0) { error = ENOTEMPTY; goto out; } TAILQ_FOREACH(de, &node->tn_spec.tn_dir.tn_dir, td_entries) { if (de->td_node != TMPFS_NODE_WHITEOUT) { error = ENOTEMPTY; goto out; } } KASSERT(error == 0); } KASSERT(node->tn_spec.tn_dir.tn_parent == dnode); /* Lookup the directory entry (check the cached hint first). */ de = tmpfs_dir_cached(node); if (de == NULL) { struct componentname *cnp = ap->a_cnp; de = tmpfs_dir_lookup(dnode, cnp); } KASSERT(de && de->td_node == node); /* Check flags to see if we are allowed to remove the directory. */ if (dnode->tn_flags & APPEND || node->tn_flags & (IMMUTABLE | APPEND)) { error = EPERM; goto out; } /* Decrement the link count for the virtual '.' entry. */ node->tn_links--; /* Detach the directory entry from the directory. */ tmpfs_dir_detach(dnode, de); /* Purge the cache for parent. */ cache_purge(dvp); /* * Destroy the directory entry or replace it with a whiteout. * * Note: the inode referred by it will not be destroyed until the * vnode is reclaimed. */ if (ap->a_cnp->cn_flags & DOWHITEOUT) tmpfs_dir_attach(dnode, de, TMPFS_NODE_WHITEOUT); else tmpfs_free_dirent(tmp, de); /* Destroy the whiteout entries from the node. */ while ((de = TAILQ_FIRST(&node->tn_spec.tn_dir.tn_dir)) != NULL) { KASSERT(de->td_node == TMPFS_NODE_WHITEOUT); tmpfs_dir_detach(node, de); tmpfs_free_dirent(tmp, de); } tmpfs_update(dvp, TMPFS_UPDATE_MTIME | TMPFS_UPDATE_CTIME); KASSERT(node->tn_size == 0); KASSERT(node->tn_links == 0); out: /* Release the node. */ KASSERT(dvp != vp); vput(vp); return error; } int tmpfs_symlink(void *v) { struct vop_symlink_v3_args /* { struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; struct vattr *a_vap; char *a_target; } */ *ap = v; vnode_t *dvp = ap->a_dvp; vnode_t **vpp = ap->a_vpp; struct componentname *cnp = ap->a_cnp; struct vattr *vap = ap->a_vap; char *target = ap->a_target; KASSERT(vap->va_type == VLNK); return tmpfs_construct_node(dvp, vpp, vap, cnp, target); } int tmpfs_readdir(void *v) { struct vop_readdir_args /* { struct vnode *a_vp; struct uio *a_uio; kauth_cred_t a_cred; int *a_eofflag; off_t **a_cookies; int *ncookies; } */ *ap = v; vnode_t *vp = ap->a_vp; struct uio *uio = ap->a_uio; int *eofflag = ap->a_eofflag; off_t **cookies = ap->a_cookies; int *ncookies = ap->a_ncookies; off_t startoff, cnt; tmpfs_node_t *node; int error; KASSERT(VOP_ISLOCKED(vp)); /* This operation only makes sense on directory nodes. */ if (vp->v_type != VDIR) { return ENOTDIR; } node = VP_TO_TMPFS_DIR(vp); startoff = uio->uio_offset; cnt = 0; /* * Retrieve the directory entries, unless it is being destroyed. */ if (node->tn_links) { error = tmpfs_dir_getdents(node, uio, &cnt); } else { error = 0; } if (eofflag != NULL) { *eofflag = !error && uio->uio_offset == TMPFS_DIRSEQ_EOF; } if (error || cookies == NULL || ncookies == NULL) { return error; } /* Update NFS-related variables, if any. */ tmpfs_dirent_t *de = NULL; off_t i, off = startoff; *cookies = malloc(cnt * sizeof(off_t), M_TEMP, M_WAITOK); *ncookies = cnt; for (i = 0; i < cnt; i++) { KASSERT(off != TMPFS_DIRSEQ_EOF); if (off != TMPFS_DIRSEQ_DOT) { if (off == TMPFS_DIRSEQ_DOTDOT) { de = TAILQ_FIRST(&node->tn_spec.tn_dir.tn_dir); } else if (de != NULL) { de = TAILQ_NEXT(de, td_entries); } else { de = tmpfs_dir_lookupbyseq(node, off); KASSERT(de != NULL); de = TAILQ_NEXT(de, td_entries); } if (de == NULL) { off = TMPFS_DIRSEQ_EOF; } else { off = tmpfs_dir_getseq(node, de); } } else { off = TMPFS_DIRSEQ_DOTDOT; } (*cookies)[i] = off; } KASSERT(uio->uio_offset == off); return error; } int tmpfs_readlink(void *v) { struct vop_readlink_args /* { struct vnode *a_vp; struct uio *a_uio; kauth_cred_t a_cred; } */ *ap = v; vnode_t *vp = ap->a_vp; struct uio *uio = ap->a_uio; tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); int error; KASSERT(VOP_ISLOCKED(vp)); KASSERT(uio->uio_offset == 0); KASSERT(vp->v_type == VLNK); /* Note: readlink(2) returns the path without NUL terminator. */ if (node->tn_size > 0) { error = uiomove(node->tn_spec.tn_lnk.tn_link, MIN(node->tn_size, uio->uio_resid), uio); } else { error = 0; } tmpfs_update(vp, TMPFS_UPDATE_ATIME); return error; } int tmpfs_inactive(void *v) { struct vop_inactive_v2_args /* { struct vnode *a_vp; bool *a_recycle; } */ *ap = v; vnode_t *vp = ap->a_vp; tmpfs_node_t *node; int error = 0; KASSERT(VOP_ISLOCKED(vp)); node = VP_TO_TMPFS_NODE(vp); if (node->tn_links == 0) { /* * Mark node as dead by setting its generation to zero. */ atomic_and_32(&node->tn_gen, ~TMPFS_NODE_GEN_MASK); /* * If the file has been deleted, truncate it, otherwise VFS * will quite rightly try to write back dirty data, which in * the case of tmpfs/UAO means needless page deactivations. */ if (vp->v_type == VREG) { error = tmpfs_reg_resize(vp, 0); } *ap->a_recycle = true; } else { tmpfs_update(vp, 0); *ap->a_recycle = false; } return error; } int tmpfs_reclaim(void *v) { struct vop_reclaim_v2_args /* { struct vnode *a_vp; } */ *ap = v; vnode_t *vp = ap->a_vp; tmpfs_mount_t *tmp = VFS_TO_TMPFS(vp->v_mount); tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); /* Unlock vnode. We still have exclusive access to it. */ VOP_UNLOCK(vp); /* Disassociate inode from vnode. */ node->tn_vnode = NULL; vp->v_data = NULL; /* If inode is not referenced, i.e. no links, then destroy it. */ if (node->tn_links == 0) tmpfs_free_node(tmp, node); return 0; } int tmpfs_pathconf(void *v) { struct vop_pathconf_args /* { struct vnode *a_vp; int a_name; register_t *a_retval; } */ *ap = v; register_t *retval = ap->a_retval; switch (ap->a_name) { case _PC_LINK_MAX: *retval = LINK_MAX; return 0; case _PC_NAME_MAX: *retval = TMPFS_MAXNAMLEN; return 0; case _PC_PATH_MAX: *retval = PATH_MAX; return 0; case _PC_PIPE_BUF: *retval = PIPE_BUF; return 0; case _PC_CHOWN_RESTRICTED: *retval = 1; return 0; case _PC_NO_TRUNC: *retval = 1; return 0; case _PC_SYNC_IO: *retval = 1; return 0; case _PC_FILESIZEBITS: *retval = sizeof(off_t) * CHAR_BIT; return 0; default: return genfs_pathconf(ap); } } int tmpfs_advlock(void *v) { struct vop_advlock_args /* { struct vnode *a_vp; void * a_id; int a_op; struct flock *a_fl; int a_flags; } */ *ap = v; vnode_t *vp = ap->a_vp; tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); return lf_advlock(v, &node->tn_lockf, node->tn_size); } int tmpfs_getpages(void *v) { struct vop_getpages_args /* { struct vnode *a_vp; voff_t a_offset; struct vm_page **a_m; int *a_count; int a_centeridx; vm_prot_t a_access_type; int a_advice; int a_flags; } */ * const ap = v; vnode_t *vp = ap->a_vp; const voff_t offset = ap->a_offset; struct vm_page **pgs = ap->a_m; const int centeridx = ap->a_centeridx; const vm_prot_t access_type = ap->a_access_type; const int advice = ap->a_advice; const int flags = ap->a_flags; int error, iflag, npages = *ap->a_count; tmpfs_node_t *node; struct uvm_object *uobj; KASSERT(vp->v_type == VREG); KASSERT(rw_lock_held(vp->v_uobj.vmobjlock)); /* * Currently, PGO_PASTEOF is not supported. */ if (vp->v_size <= offset + (centeridx << PAGE_SHIFT)) { if ((flags & PGO_LOCKED) == 0) rw_exit(vp->v_uobj.vmobjlock); return EINVAL; } if (vp->v_size < offset + (npages << PAGE_SHIFT)) { npages = (round_page(vp->v_size) - offset) >> PAGE_SHIFT; } /* * Check for reclaimed vnode. v_interlock is not held here, but * VI_DEADCHECK is set with vmobjlock held. */ iflag = atomic_load_relaxed(&vp->v_iflag); if (__predict_false((iflag & VI_DEADCHECK) != 0)) { mutex_enter(vp->v_interlock); error = vdead_check(vp, VDEAD_NOWAIT); mutex_exit(vp->v_interlock); if (error) { if ((flags & PGO_LOCKED) == 0) rw_exit(vp->v_uobj.vmobjlock); return error; } } node = VP_TO_TMPFS_NODE(vp); uobj = node->tn_spec.tn_reg.tn_aobj; /* * Update timestamp lazily. The update will be made real when * a synchronous update is next made -- or by tmpfs_getattr, * tmpfs_putpages, and tmpfs_inactive. */ if ((flags & PGO_NOTIMESTAMP) == 0) { u_int tflags = 0; if ((vp->v_mount->mnt_flag & MNT_NOATIME) == 0) tflags |= TMPFS_UPDATE_ATIME; if ((access_type & VM_PROT_WRITE) != 0) { tflags |= TMPFS_UPDATE_MTIME; if (vp->v_mount->mnt_flag & MNT_RELATIME) tflags |= TMPFS_UPDATE_ATIME; } tmpfs_update_lazily(vp, tflags); } /* Invoke the pager. The vnode vmobjlock is shared with the UAO. */ KASSERT(vp->v_uobj.vmobjlock == uobj->vmobjlock); error = (*uobj->pgops->pgo_get)(uobj, offset, pgs, &npages, centeridx, access_type, advice, flags); #if defined(DEBUG) if (!error && pgs) { KASSERT(pgs[centeridx] != NULL); } #endif return error; } int tmpfs_putpages(void *v) { struct vop_putpages_args /* { struct vnode *a_vp; voff_t a_offlo; voff_t a_offhi; int a_flags; } */ * const ap = v; vnode_t *vp = ap->a_vp; const voff_t offlo = ap->a_offlo; const voff_t offhi = ap->a_offhi; const int flags = ap->a_flags; tmpfs_node_t *node; struct uvm_object *uobj; int error; KASSERT(rw_write_held(vp->v_uobj.vmobjlock)); if (vp->v_type != VREG) { rw_exit(vp->v_uobj.vmobjlock); return 0; } node = VP_TO_TMPFS_NODE(vp); uobj = node->tn_spec.tn_reg.tn_aobj; KASSERT(vp->v_uobj.vmobjlock == uobj->vmobjlock); error = (*uobj->pgops->pgo_put)(uobj, offlo, offhi, flags); /* XXX mtime */ /* Process deferred updates. */ tmpfs_update(vp, 0); return error; } int tmpfs_whiteout(void *v) { struct vop_whiteout_args /* { struct vnode *a_dvp; struct componentname *a_cnp; int a_flags; } */ *ap = v; vnode_t *dvp = ap->a_dvp; struct componentname *cnp = ap->a_cnp; const int flags = ap->a_flags; tmpfs_mount_t *tmp = VFS_TO_TMPFS(dvp->v_mount); tmpfs_node_t *dnode = VP_TO_TMPFS_DIR(dvp); tmpfs_dirent_t *de; int error; switch (flags) { case LOOKUP: break; case CREATE: error = tmpfs_alloc_dirent(tmp, cnp->cn_nameptr, cnp->cn_namelen, &de); if (error) return error; tmpfs_dir_attach(dnode, de, TMPFS_NODE_WHITEOUT); break; case DELETE: cnp->cn_flags &= ~DOWHITEOUT; /* when in doubt, cargo cult */ de = tmpfs_dir_lookup(dnode, cnp); if (de == NULL) return ENOENT; tmpfs_dir_detach(dnode, de); tmpfs_free_dirent(tmp, de); break; } tmpfs_update(dvp, TMPFS_UPDATE_MTIME | TMPFS_UPDATE_CTIME); return 0; } int tmpfs_print(void *v) { struct vop_print_args /* { struct vnode *a_vp; } */ *ap = v; vnode_t *vp = ap->a_vp; tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); printf("tag VT_TMPFS, tmpfs_node %p, flags 0x%x, links %d\n" "\tmode 0%o, owner %d, group %d, size %" PRIdMAX, node, node->tn_flags, node->tn_links, node->tn_mode, node->tn_uid, node->tn_gid, (uintmax_t)node->tn_size); if (vp->v_type == VFIFO) { VOCALL(fifo_vnodeop_p, VOFFSET(vop_print), v); } printf("\n"); return 0; }