xref: /freebsd/sys/fs/tmpfs/tmpfs_vnops.c (revision abd80ddb9474948fb291becc395d72b40927a32b)
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