xref: /freebsd/sys/fs/tmpfs/tmpfs_vnops.c (revision 6472ac3d8a86336899b6cfb789a4cd9897e3fab5)
1 /*	$NetBSD: tmpfs_vnops.c,v 1.39 2007/07/23 15:41:01 jmmv Exp $	*/
2 
3 /*-
4  * Copyright (c) 2005, 2006 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Julio M. Merino Vidal, developed as part of Google's Summer of Code
9  * 2005 program.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30  * POSSIBILITY OF SUCH DAMAGE.
31  */
32 
33 /*
34  * tmpfs vnode interface.
35  */
36 #include <sys/cdefs.h>
37 __FBSDID("$FreeBSD$");
38 
39 #include <sys/param.h>
40 #include <sys/fcntl.h>
41 #include <sys/lockf.h>
42 #include <sys/namei.h>
43 #include <sys/priv.h>
44 #include <sys/proc.h>
45 #include <sys/sched.h>
46 #include <sys/sf_buf.h>
47 #include <sys/stat.h>
48 #include <sys/systm.h>
49 #include <sys/unistd.h>
50 #include <sys/vnode.h>
51 
52 #include <vm/vm.h>
53 #include <vm/vm_object.h>
54 #include <vm/vm_page.h>
55 #include <vm/vm_pager.h>
56 
57 #include <machine/_inttypes.h>
58 
59 #include <fs/fifofs/fifo.h>
60 #include <fs/tmpfs/tmpfs_vnops.h>
61 #include <fs/tmpfs/tmpfs.h>
62 
63 /* --------------------------------------------------------------------- */
64 
65 static int
66 tmpfs_lookup(struct vop_cachedlookup_args *v)
67 {
68 	struct vnode *dvp = v->a_dvp;
69 	struct vnode **vpp = v->a_vpp;
70 	struct componentname *cnp = v->a_cnp;
71 
72 	int error;
73 	struct tmpfs_dirent *de;
74 	struct tmpfs_node *dnode;
75 
76 	dnode = VP_TO_TMPFS_DIR(dvp);
77 	*vpp = NULLVP;
78 
79 	/* Check accessibility of requested node as a first step. */
80 	error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, cnp->cn_thread);
81 	if (error != 0)
82 		goto out;
83 
84 	/* We cannot be requesting the parent directory of the root node. */
85 	MPASS(IMPLIES(dnode->tn_type == VDIR &&
86 	    dnode->tn_dir.tn_parent == dnode,
87 	    !(cnp->cn_flags & ISDOTDOT)));
88 
89 	TMPFS_ASSERT_LOCKED(dnode);
90 	if (dnode->tn_dir.tn_parent == NULL) {
91 		error = ENOENT;
92 		goto out;
93 	}
94 	if (cnp->cn_flags & ISDOTDOT) {
95 		int ltype = 0;
96 
97 		ltype = VOP_ISLOCKED(dvp);
98 		vhold(dvp);
99 		VOP_UNLOCK(dvp, 0);
100 		/* Allocate a new vnode on the matching entry. */
101 		error = tmpfs_alloc_vp(dvp->v_mount, dnode->tn_dir.tn_parent,
102 		    cnp->cn_lkflags, vpp);
103 
104 		vn_lock(dvp, ltype | LK_RETRY);
105 		vdrop(dvp);
106 	} else if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
107 		VREF(dvp);
108 		*vpp = dvp;
109 		error = 0;
110 	} else {
111 		de = tmpfs_dir_lookup(dnode, NULL, cnp);
112 		if (de != NULL && de->td_node == NULL)
113 			cnp->cn_flags |= ISWHITEOUT;
114 		if (de == NULL || de->td_node == NULL) {
115 			/* The entry was not found in the directory.
116 			 * This is OK if we are creating or renaming an
117 			 * entry and are working on the last component of
118 			 * the path name. */
119 			if ((cnp->cn_flags & ISLASTCN) &&
120 			    (cnp->cn_nameiop == CREATE || \
121 			    cnp->cn_nameiop == RENAME ||
122 			    (cnp->cn_nameiop == DELETE &&
123 			    cnp->cn_flags & DOWHITEOUT &&
124 			    cnp->cn_flags & ISWHITEOUT))) {
125 				error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred,
126 				    cnp->cn_thread);
127 				if (error != 0)
128 					goto out;
129 
130 				/* Keep the component name in the buffer for
131 				 * future uses. */
132 				cnp->cn_flags |= SAVENAME;
133 
134 				error = EJUSTRETURN;
135 			} else
136 				error = ENOENT;
137 		} else {
138 			struct tmpfs_node *tnode;
139 
140 			/* The entry was found, so get its associated
141 			 * tmpfs_node. */
142 			tnode = de->td_node;
143 
144 			/* If we are not at the last path component and
145 			 * found a non-directory or non-link entry (which
146 			 * may itself be pointing to a directory), raise
147 			 * an error. */
148 			if ((tnode->tn_type != VDIR &&
149 			    tnode->tn_type != VLNK) &&
150 			    !(cnp->cn_flags & ISLASTCN)) {
151 				error = ENOTDIR;
152 				goto out;
153 			}
154 
155 			/* If we are deleting or renaming the entry, keep
156 			 * track of its tmpfs_dirent so that it can be
157 			 * easily deleted later. */
158 			if ((cnp->cn_flags & ISLASTCN) &&
159 			    (cnp->cn_nameiop == DELETE ||
160 			    cnp->cn_nameiop == RENAME)) {
161 				error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred,
162 				    cnp->cn_thread);
163 				if (error != 0)
164 					goto out;
165 
166 				/* Allocate a new vnode on the matching entry. */
167 				error = tmpfs_alloc_vp(dvp->v_mount, tnode,
168 						cnp->cn_lkflags, vpp);
169 				if (error != 0)
170 					goto out;
171 
172 				if ((dnode->tn_mode & S_ISTXT) &&
173 				  VOP_ACCESS(dvp, VADMIN, cnp->cn_cred, cnp->cn_thread) &&
174 				  VOP_ACCESS(*vpp, VADMIN, cnp->cn_cred, cnp->cn_thread)) {
175 					error = EPERM;
176 					vput(*vpp);
177 					*vpp = NULL;
178 					goto out;
179 				}
180 				cnp->cn_flags |= SAVENAME;
181 			} else {
182 				error = tmpfs_alloc_vp(dvp->v_mount, tnode,
183 						cnp->cn_lkflags, vpp);
184 			}
185 		}
186 	}
187 
188 	/* Store the result of this lookup in the cache.  Avoid this if the
189 	 * request was for creation, as it does not improve timings on
190 	 * emprical tests. */
191 	if ((cnp->cn_flags & MAKEENTRY) && cnp->cn_nameiop != CREATE)
192 		cache_enter(dvp, *vpp, cnp);
193 
194 out:
195 	/* If there were no errors, *vpp cannot be null and it must be
196 	 * locked. */
197 	MPASS(IFF(error == 0, *vpp != NULLVP && VOP_ISLOCKED(*vpp)));
198 
199 	return error;
200 }
201 
202 /* --------------------------------------------------------------------- */
203 
204 static int
205 tmpfs_create(struct vop_create_args *v)
206 {
207 	struct vnode *dvp = v->a_dvp;
208 	struct vnode **vpp = v->a_vpp;
209 	struct componentname *cnp = v->a_cnp;
210 	struct vattr *vap = v->a_vap;
211 
212 	MPASS(vap->va_type == VREG || vap->va_type == VSOCK);
213 
214 	return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
215 }
216 /* --------------------------------------------------------------------- */
217 
218 static int
219 tmpfs_mknod(struct vop_mknod_args *v)
220 {
221 	struct vnode *dvp = v->a_dvp;
222 	struct vnode **vpp = v->a_vpp;
223 	struct componentname *cnp = v->a_cnp;
224 	struct vattr *vap = v->a_vap;
225 
226 	if (vap->va_type != VBLK && vap->va_type != VCHR &&
227 	    vap->va_type != VFIFO)
228 		return EINVAL;
229 
230 	return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
231 }
232 
233 /* --------------------------------------------------------------------- */
234 
235 static int
236 tmpfs_open(struct vop_open_args *v)
237 {
238 	struct vnode *vp = v->a_vp;
239 	int mode = v->a_mode;
240 
241 	int error;
242 	struct tmpfs_node *node;
243 
244 	MPASS(VOP_ISLOCKED(vp));
245 
246 	node = VP_TO_TMPFS_NODE(vp);
247 
248 	/* The file is still active but all its names have been removed
249 	 * (e.g. by a "rmdir $(pwd)").  It cannot be opened any more as
250 	 * it is about to die. */
251 	if (node->tn_links < 1)
252 		return (ENOENT);
253 
254 	/* If the file is marked append-only, deny write requests. */
255 	if (node->tn_flags & APPEND && (mode & (FWRITE | O_APPEND)) == FWRITE)
256 		error = EPERM;
257 	else {
258 		error = 0;
259 		vnode_create_vobject(vp, node->tn_size, v->a_td);
260 	}
261 
262 	MPASS(VOP_ISLOCKED(vp));
263 	return error;
264 }
265 
266 /* --------------------------------------------------------------------- */
267 
268 static int
269 tmpfs_close(struct vop_close_args *v)
270 {
271 	struct vnode *vp = v->a_vp;
272 
273 	MPASS(VOP_ISLOCKED(vp));
274 
275 	/* Update node times. */
276 	tmpfs_update(vp);
277 
278 	return (0);
279 }
280 
281 /* --------------------------------------------------------------------- */
282 
283 int
284 tmpfs_access(struct vop_access_args *v)
285 {
286 	struct vnode *vp = v->a_vp;
287 	accmode_t accmode = v->a_accmode;
288 	struct ucred *cred = v->a_cred;
289 
290 	int error;
291 	struct tmpfs_node *node;
292 
293 	MPASS(VOP_ISLOCKED(vp));
294 
295 	node = VP_TO_TMPFS_NODE(vp);
296 
297 	switch (vp->v_type) {
298 	case VDIR:
299 		/* FALLTHROUGH */
300 	case VLNK:
301 		/* FALLTHROUGH */
302 	case VREG:
303 		if (accmode & VWRITE && vp->v_mount->mnt_flag & MNT_RDONLY) {
304 			error = EROFS;
305 			goto out;
306 		}
307 		break;
308 
309 	case VBLK:
310 		/* FALLTHROUGH */
311 	case VCHR:
312 		/* FALLTHROUGH */
313 	case VSOCK:
314 		/* FALLTHROUGH */
315 	case VFIFO:
316 		break;
317 
318 	default:
319 		error = EINVAL;
320 		goto out;
321 	}
322 
323 	if (accmode & VWRITE && node->tn_flags & IMMUTABLE) {
324 		error = EPERM;
325 		goto out;
326 	}
327 
328 	error = vaccess(vp->v_type, node->tn_mode, node->tn_uid,
329 	    node->tn_gid, accmode, cred, NULL);
330 
331 out:
332 	MPASS(VOP_ISLOCKED(vp));
333 
334 	return error;
335 }
336 
337 /* --------------------------------------------------------------------- */
338 
339 int
340 tmpfs_getattr(struct vop_getattr_args *v)
341 {
342 	struct vnode *vp = v->a_vp;
343 	struct vattr *vap = v->a_vap;
344 
345 	struct tmpfs_node *node;
346 
347 	node = VP_TO_TMPFS_NODE(vp);
348 
349 	tmpfs_update(vp);
350 
351 	vap->va_type = vp->v_type;
352 	vap->va_mode = node->tn_mode;
353 	vap->va_nlink = node->tn_links;
354 	vap->va_uid = node->tn_uid;
355 	vap->va_gid = node->tn_gid;
356 	vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
357 	vap->va_fileid = node->tn_id;
358 	vap->va_size = node->tn_size;
359 	vap->va_blocksize = PAGE_SIZE;
360 	vap->va_atime = node->tn_atime;
361 	vap->va_mtime = node->tn_mtime;
362 	vap->va_ctime = node->tn_ctime;
363 	vap->va_birthtime = node->tn_birthtime;
364 	vap->va_gen = node->tn_gen;
365 	vap->va_flags = node->tn_flags;
366 	vap->va_rdev = (vp->v_type == VBLK || vp->v_type == VCHR) ?
367 		node->tn_rdev : NODEV;
368 	vap->va_bytes = round_page(node->tn_size);
369 	vap->va_filerev = 0;
370 
371 	return 0;
372 }
373 
374 /* --------------------------------------------------------------------- */
375 
376 /* XXX Should this operation be atomic?  I think it should, but code in
377  * XXX other places (e.g., ufs) doesn't seem to be... */
378 int
379 tmpfs_setattr(struct vop_setattr_args *v)
380 {
381 	struct vnode *vp = v->a_vp;
382 	struct vattr *vap = v->a_vap;
383 	struct ucred *cred = v->a_cred;
384 	struct thread *td = curthread;
385 
386 	int error;
387 
388 	MPASS(VOP_ISLOCKED(vp));
389 
390 	error = 0;
391 
392 	/* Abort if any unsettable attribute is given. */
393 	if (vap->va_type != VNON ||
394 	    vap->va_nlink != VNOVAL ||
395 	    vap->va_fsid != VNOVAL ||
396 	    vap->va_fileid != VNOVAL ||
397 	    vap->va_blocksize != VNOVAL ||
398 	    vap->va_gen != VNOVAL ||
399 	    vap->va_rdev != VNOVAL ||
400 	    vap->va_bytes != VNOVAL)
401 		error = EINVAL;
402 
403 	if (error == 0 && (vap->va_flags != VNOVAL))
404 		error = tmpfs_chflags(vp, vap->va_flags, cred, td);
405 
406 	if (error == 0 && (vap->va_size != VNOVAL))
407 		error = tmpfs_chsize(vp, vap->va_size, cred, td);
408 
409 	if (error == 0 && (vap->va_uid != VNOVAL || vap->va_gid != VNOVAL))
410 		error = tmpfs_chown(vp, vap->va_uid, vap->va_gid, cred, td);
411 
412 	if (error == 0 && (vap->va_mode != (mode_t)VNOVAL))
413 		error = tmpfs_chmod(vp, vap->va_mode, cred, td);
414 
415 	if (error == 0 && ((vap->va_atime.tv_sec != VNOVAL &&
416 	    vap->va_atime.tv_nsec != VNOVAL) ||
417 	    (vap->va_mtime.tv_sec != VNOVAL &&
418 	    vap->va_mtime.tv_nsec != VNOVAL) ||
419 	    (vap->va_birthtime.tv_sec != VNOVAL &&
420 	    vap->va_birthtime.tv_nsec != VNOVAL)))
421 		error = tmpfs_chtimes(vp, &vap->va_atime, &vap->va_mtime,
422 			&vap->va_birthtime, vap->va_vaflags, cred, td);
423 
424 	/* Update the node times.  We give preference to the error codes
425 	 * generated by this function rather than the ones that may arise
426 	 * from tmpfs_update. */
427 	tmpfs_update(vp);
428 
429 	MPASS(VOP_ISLOCKED(vp));
430 
431 	return error;
432 }
433 
434 /* --------------------------------------------------------------------- */
435 static int
436 tmpfs_nocacheread(vm_object_t tobj, vm_pindex_t idx,
437     vm_offset_t offset, size_t tlen, struct uio *uio)
438 {
439 	vm_page_t	m;
440 	int		error;
441 
442 	VM_OBJECT_LOCK(tobj);
443 	vm_object_pip_add(tobj, 1);
444 	m = vm_page_grab(tobj, idx, VM_ALLOC_WIRED |
445 	    VM_ALLOC_ZERO | VM_ALLOC_NORMAL | VM_ALLOC_RETRY);
446 	if (m->valid != VM_PAGE_BITS_ALL) {
447 		if (vm_pager_has_page(tobj, idx, NULL, NULL)) {
448 			error = vm_pager_get_pages(tobj, &m, 1, 0);
449 			if (error != 0) {
450 				printf("tmpfs get pages from pager error [read]\n");
451 				goto out;
452 			}
453 		} else
454 			vm_page_zero_invalid(m, TRUE);
455 	}
456 	VM_OBJECT_UNLOCK(tobj);
457 	error = uiomove_fromphys(&m, offset, tlen, uio);
458 	VM_OBJECT_LOCK(tobj);
459 out:
460 	vm_page_lock(m);
461 	vm_page_unwire(m, TRUE);
462 	vm_page_unlock(m);
463 	vm_page_wakeup(m);
464 	vm_object_pip_subtract(tobj, 1);
465 	VM_OBJECT_UNLOCK(tobj);
466 
467 	return (error);
468 }
469 
470 static __inline int
471 tmpfs_nocacheread_buf(vm_object_t tobj, vm_pindex_t idx,
472     vm_offset_t offset, size_t tlen, void *buf)
473 {
474 	struct uio uio;
475 	struct iovec iov;
476 
477 	uio.uio_iovcnt = 1;
478 	uio.uio_iov = &iov;
479 	iov.iov_base = buf;
480 	iov.iov_len = tlen;
481 
482 	uio.uio_offset = 0;
483 	uio.uio_resid = tlen;
484 	uio.uio_rw = UIO_READ;
485 	uio.uio_segflg = UIO_SYSSPACE;
486 	uio.uio_td = curthread;
487 
488 	return (tmpfs_nocacheread(tobj, idx, offset, tlen, &uio));
489 }
490 
491 static int
492 tmpfs_mappedread(vm_object_t vobj, vm_object_t tobj, size_t len, struct uio *uio)
493 {
494 	struct sf_buf	*sf;
495 	vm_pindex_t	idx;
496 	vm_page_t	m;
497 	vm_offset_t	offset;
498 	off_t		addr;
499 	size_t		tlen;
500 	char		*ma;
501 	int		error;
502 
503 	addr = uio->uio_offset;
504 	idx = OFF_TO_IDX(addr);
505 	offset = addr & PAGE_MASK;
506 	tlen = MIN(PAGE_SIZE - offset, len);
507 
508 	if ((vobj == NULL) ||
509 	    (vobj->resident_page_count == 0 && vobj->cache == NULL))
510 		goto nocache;
511 
512 	VM_OBJECT_LOCK(vobj);
513 lookupvpg:
514 	if (((m = vm_page_lookup(vobj, idx)) != NULL) &&
515 	    vm_page_is_valid(m, offset, tlen)) {
516 		if ((m->oflags & VPO_BUSY) != 0) {
517 			/*
518 			 * Reference the page before unlocking and sleeping so
519 			 * that the page daemon is less likely to reclaim it.
520 			 */
521 			vm_page_reference(m);
522 			vm_page_sleep(m, "tmfsmr");
523 			goto lookupvpg;
524 		}
525 		vm_page_busy(m);
526 		VM_OBJECT_UNLOCK(vobj);
527 		error = uiomove_fromphys(&m, offset, tlen, uio);
528 		VM_OBJECT_LOCK(vobj);
529 		vm_page_wakeup(m);
530 		VM_OBJECT_UNLOCK(vobj);
531 		return	(error);
532 	} else if (m != NULL && uio->uio_segflg == UIO_NOCOPY) {
533 		KASSERT(offset == 0,
534 		    ("unexpected offset in tmpfs_mappedread for sendfile"));
535 		if ((m->oflags & VPO_BUSY) != 0) {
536 			/*
537 			 * Reference the page before unlocking and sleeping so
538 			 * that the page daemon is less likely to reclaim it.
539 			 */
540 			vm_page_reference(m);
541 			vm_page_sleep(m, "tmfsmr");
542 			goto lookupvpg;
543 		}
544 		vm_page_busy(m);
545 		VM_OBJECT_UNLOCK(vobj);
546 		sched_pin();
547 		sf = sf_buf_alloc(m, SFB_CPUPRIVATE);
548 		ma = (char *)sf_buf_kva(sf);
549 		error = tmpfs_nocacheread_buf(tobj, idx, 0, tlen, ma);
550 		if (error == 0) {
551 			if (tlen != PAGE_SIZE)
552 				bzero(ma + tlen, PAGE_SIZE - tlen);
553 			uio->uio_offset += tlen;
554 			uio->uio_resid -= tlen;
555 		}
556 		sf_buf_free(sf);
557 		sched_unpin();
558 		VM_OBJECT_LOCK(vobj);
559 		if (error == 0)
560 			m->valid = VM_PAGE_BITS_ALL;
561 		vm_page_wakeup(m);
562 		VM_OBJECT_UNLOCK(vobj);
563 		return	(error);
564 	}
565 	VM_OBJECT_UNLOCK(vobj);
566 nocache:
567 	error = tmpfs_nocacheread(tobj, idx, offset, tlen, uio);
568 
569 	return	(error);
570 }
571 
572 static int
573 tmpfs_read(struct vop_read_args *v)
574 {
575 	struct vnode *vp = v->a_vp;
576 	struct uio *uio = v->a_uio;
577 
578 	struct tmpfs_node *node;
579 	vm_object_t uobj;
580 	size_t len;
581 	int resid;
582 
583 	int error = 0;
584 
585 	node = VP_TO_TMPFS_NODE(vp);
586 
587 	if (vp->v_type != VREG) {
588 		error = EISDIR;
589 		goto out;
590 	}
591 
592 	if (uio->uio_offset < 0) {
593 		error = EINVAL;
594 		goto out;
595 	}
596 
597 	node->tn_status |= TMPFS_NODE_ACCESSED;
598 
599 	uobj = node->tn_reg.tn_aobj;
600 	while ((resid = uio->uio_resid) > 0) {
601 		error = 0;
602 		if (node->tn_size <= uio->uio_offset)
603 			break;
604 		len = MIN(node->tn_size - uio->uio_offset, resid);
605 		if (len == 0)
606 			break;
607 		error = tmpfs_mappedread(vp->v_object, uobj, len, uio);
608 		if ((error != 0) || (resid == uio->uio_resid))
609 			break;
610 	}
611 
612 out:
613 
614 	return error;
615 }
616 
617 /* --------------------------------------------------------------------- */
618 
619 static int
620 tmpfs_mappedwrite(vm_object_t vobj, vm_object_t tobj, size_t len, struct uio *uio)
621 {
622 	vm_pindex_t	idx;
623 	vm_page_t	vpg, tpg;
624 	vm_offset_t	offset;
625 	off_t		addr;
626 	size_t		tlen;
627 	int		error;
628 
629 	error = 0;
630 
631 	addr = uio->uio_offset;
632 	idx = OFF_TO_IDX(addr);
633 	offset = addr & PAGE_MASK;
634 	tlen = MIN(PAGE_SIZE - offset, len);
635 
636 	if ((vobj == NULL) ||
637 	    (vobj->resident_page_count == 0 && vobj->cache == NULL)) {
638 		vpg = NULL;
639 		goto nocache;
640 	}
641 
642 	VM_OBJECT_LOCK(vobj);
643 lookupvpg:
644 	if (((vpg = vm_page_lookup(vobj, idx)) != NULL) &&
645 	    vm_page_is_valid(vpg, offset, tlen)) {
646 		if ((vpg->oflags & VPO_BUSY) != 0) {
647 			/*
648 			 * Reference the page before unlocking and sleeping so
649 			 * that the page daemon is less likely to reclaim it.
650 			 */
651 			vm_page_reference(vpg);
652 			vm_page_sleep(vpg, "tmfsmw");
653 			goto lookupvpg;
654 		}
655 		vm_page_busy(vpg);
656 		vm_page_undirty(vpg);
657 		VM_OBJECT_UNLOCK(vobj);
658 		error = uiomove_fromphys(&vpg, offset, tlen, uio);
659 	} else {
660 		if (__predict_false(vobj->cache != NULL))
661 			vm_page_cache_free(vobj, idx, idx + 1);
662 		VM_OBJECT_UNLOCK(vobj);
663 		vpg = NULL;
664 	}
665 nocache:
666 	VM_OBJECT_LOCK(tobj);
667 	vm_object_pip_add(tobj, 1);
668 	tpg = vm_page_grab(tobj, idx, VM_ALLOC_WIRED |
669 	    VM_ALLOC_ZERO | VM_ALLOC_NORMAL | VM_ALLOC_RETRY);
670 	if (tpg->valid != VM_PAGE_BITS_ALL) {
671 		if (vm_pager_has_page(tobj, idx, NULL, NULL)) {
672 			error = vm_pager_get_pages(tobj, &tpg, 1, 0);
673 			if (error != 0) {
674 				printf("tmpfs get pages from pager error [write]\n");
675 				goto out;
676 			}
677 		} else
678 			vm_page_zero_invalid(tpg, TRUE);
679 	}
680 	VM_OBJECT_UNLOCK(tobj);
681 	if (vpg == NULL)
682 		error = uiomove_fromphys(&tpg, offset, tlen, uio);
683 	else {
684 		KASSERT(vpg->valid == VM_PAGE_BITS_ALL, ("parts of vpg invalid"));
685 		pmap_copy_page(vpg, tpg);
686 	}
687 	VM_OBJECT_LOCK(tobj);
688 out:
689 	if (vobj != NULL)
690 		VM_OBJECT_LOCK(vobj);
691 	if (error == 0) {
692 		KASSERT(tpg->valid == VM_PAGE_BITS_ALL,
693 		    ("parts of tpg invalid"));
694 		vm_page_dirty(tpg);
695 	}
696 	vm_page_lock(tpg);
697 	vm_page_unwire(tpg, TRUE);
698 	vm_page_unlock(tpg);
699 	vm_page_wakeup(tpg);
700 	if (vpg != NULL)
701 		vm_page_wakeup(vpg);
702 	if (vobj != NULL)
703 		VM_OBJECT_UNLOCK(vobj);
704 	vm_object_pip_subtract(tobj, 1);
705 	VM_OBJECT_UNLOCK(tobj);
706 
707 	return	(error);
708 }
709 
710 static int
711 tmpfs_write(struct vop_write_args *v)
712 {
713 	struct vnode *vp = v->a_vp;
714 	struct uio *uio = v->a_uio;
715 	int ioflag = v->a_ioflag;
716 
717 	boolean_t extended;
718 	int error = 0;
719 	off_t oldsize;
720 	struct tmpfs_node *node;
721 	vm_object_t uobj;
722 	size_t len;
723 	int resid;
724 
725 	node = VP_TO_TMPFS_NODE(vp);
726 	oldsize = node->tn_size;
727 
728 	if (uio->uio_offset < 0 || vp->v_type != VREG) {
729 		error = EINVAL;
730 		goto out;
731 	}
732 
733 	if (uio->uio_resid == 0) {
734 		error = 0;
735 		goto out;
736 	}
737 
738 	if (ioflag & IO_APPEND)
739 		uio->uio_offset = node->tn_size;
740 
741 	if (uio->uio_offset + uio->uio_resid >
742 	  VFS_TO_TMPFS(vp->v_mount)->tm_maxfilesize)
743 		return (EFBIG);
744 
745 	if (vn_rlimit_fsize(vp, uio, uio->uio_td))
746 		return (EFBIG);
747 
748 	extended = uio->uio_offset + uio->uio_resid > node->tn_size;
749 	if (extended) {
750 		error = tmpfs_reg_resize(vp, uio->uio_offset + uio->uio_resid);
751 		if (error != 0)
752 			goto out;
753 	}
754 
755 	uobj = node->tn_reg.tn_aobj;
756 	while ((resid = uio->uio_resid) > 0) {
757 		if (node->tn_size <= uio->uio_offset)
758 			break;
759 		len = MIN(node->tn_size - uio->uio_offset, resid);
760 		if (len == 0)
761 			break;
762 		error = tmpfs_mappedwrite(vp->v_object, uobj, len, uio);
763 		if ((error != 0) || (resid == uio->uio_resid))
764 			break;
765 	}
766 
767 	node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_MODIFIED |
768 	    (extended ? TMPFS_NODE_CHANGED : 0);
769 
770 	if (node->tn_mode & (S_ISUID | S_ISGID)) {
771 		if (priv_check_cred(v->a_cred, PRIV_VFS_RETAINSUGID, 0))
772 			node->tn_mode &= ~(S_ISUID | S_ISGID);
773 	}
774 
775 	if (error != 0)
776 		(void)tmpfs_reg_resize(vp, oldsize);
777 
778 out:
779 	MPASS(IMPLIES(error == 0, uio->uio_resid == 0));
780 	MPASS(IMPLIES(error != 0, oldsize == node->tn_size));
781 
782 	return error;
783 }
784 
785 /* --------------------------------------------------------------------- */
786 
787 static int
788 tmpfs_fsync(struct vop_fsync_args *v)
789 {
790 	struct vnode *vp = v->a_vp;
791 
792 	MPASS(VOP_ISLOCKED(vp));
793 
794 	tmpfs_update(vp);
795 
796 	return 0;
797 }
798 
799 /* --------------------------------------------------------------------- */
800 
801 static int
802 tmpfs_remove(struct vop_remove_args *v)
803 {
804 	struct vnode *dvp = v->a_dvp;
805 	struct vnode *vp = v->a_vp;
806 
807 	int error;
808 	struct tmpfs_dirent *de;
809 	struct tmpfs_mount *tmp;
810 	struct tmpfs_node *dnode;
811 	struct tmpfs_node *node;
812 
813 	MPASS(VOP_ISLOCKED(dvp));
814 	MPASS(VOP_ISLOCKED(vp));
815 
816 	if (vp->v_type == VDIR) {
817 		error = EISDIR;
818 		goto out;
819 	}
820 
821 	dnode = VP_TO_TMPFS_DIR(dvp);
822 	node = VP_TO_TMPFS_NODE(vp);
823 	tmp = VFS_TO_TMPFS(vp->v_mount);
824 	de = tmpfs_dir_lookup(dnode, node, v->a_cnp);
825 	MPASS(de != NULL);
826 
827 	/* Files marked as immutable or append-only cannot be deleted. */
828 	if ((node->tn_flags & (IMMUTABLE | APPEND | NOUNLINK)) ||
829 	    (dnode->tn_flags & APPEND)) {
830 		error = EPERM;
831 		goto out;
832 	}
833 
834 	/* Remove the entry from the directory; as it is a file, we do not
835 	 * have to change the number of hard links of the directory. */
836 	tmpfs_dir_detach(dvp, de);
837 	if (v->a_cnp->cn_flags & DOWHITEOUT)
838 		tmpfs_dir_whiteout_add(dvp, v->a_cnp);
839 
840 	/* Free the directory entry we just deleted.  Note that the node
841 	 * referred by it will not be removed until the vnode is really
842 	 * reclaimed. */
843 	tmpfs_free_dirent(tmp, de, TRUE);
844 
845 	node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED;
846 	error = 0;
847 
848 out:
849 
850 	return error;
851 }
852 
853 /* --------------------------------------------------------------------- */
854 
855 static int
856 tmpfs_link(struct vop_link_args *v)
857 {
858 	struct vnode *dvp = v->a_tdvp;
859 	struct vnode *vp = v->a_vp;
860 	struct componentname *cnp = v->a_cnp;
861 
862 	int error;
863 	struct tmpfs_dirent *de;
864 	struct tmpfs_node *node;
865 
866 	MPASS(VOP_ISLOCKED(dvp));
867 	MPASS(cnp->cn_flags & HASBUF);
868 	MPASS(dvp != vp); /* XXX When can this be false? */
869 
870 	node = VP_TO_TMPFS_NODE(vp);
871 
872 	/* XXX: Why aren't the following two tests done by the caller? */
873 
874 	/* Hard links of directories are forbidden. */
875 	if (vp->v_type == VDIR) {
876 		error = EPERM;
877 		goto out;
878 	}
879 
880 	/* Cannot create cross-device links. */
881 	if (dvp->v_mount != vp->v_mount) {
882 		error = EXDEV;
883 		goto out;
884 	}
885 
886 	/* Ensure that we do not overflow the maximum number of links imposed
887 	 * by the system. */
888 	MPASS(node->tn_links <= LINK_MAX);
889 	if (node->tn_links == LINK_MAX) {
890 		error = EMLINK;
891 		goto out;
892 	}
893 
894 	/* We cannot create links of files marked immutable or append-only. */
895 	if (node->tn_flags & (IMMUTABLE | APPEND)) {
896 		error = EPERM;
897 		goto out;
898 	}
899 
900 	/* Allocate a new directory entry to represent the node. */
901 	error = tmpfs_alloc_dirent(VFS_TO_TMPFS(vp->v_mount), node,
902 	    cnp->cn_nameptr, cnp->cn_namelen, &de);
903 	if (error != 0)
904 		goto out;
905 
906 	/* Insert the new directory entry into the appropriate directory. */
907 	if (cnp->cn_flags & ISWHITEOUT)
908 		tmpfs_dir_whiteout_remove(dvp, cnp);
909 	tmpfs_dir_attach(dvp, de);
910 
911 	/* vp link count has changed, so update node times. */
912 	node->tn_status |= TMPFS_NODE_CHANGED;
913 	tmpfs_update(vp);
914 
915 	error = 0;
916 
917 out:
918 	return error;
919 }
920 
921 /* --------------------------------------------------------------------- */
922 
923 static int
924 tmpfs_rename(struct vop_rename_args *v)
925 {
926 	struct vnode *fdvp = v->a_fdvp;
927 	struct vnode *fvp = v->a_fvp;
928 	struct componentname *fcnp = v->a_fcnp;
929 	struct vnode *tdvp = v->a_tdvp;
930 	struct vnode *tvp = v->a_tvp;
931 	struct componentname *tcnp = v->a_tcnp;
932 
933 	char *newname;
934 	int error;
935 	struct tmpfs_dirent *de;
936 	struct tmpfs_mount *tmp;
937 	struct tmpfs_node *fdnode;
938 	struct tmpfs_node *fnode;
939 	struct tmpfs_node *tnode;
940 	struct tmpfs_node *tdnode;
941 
942 	MPASS(VOP_ISLOCKED(tdvp));
943 	MPASS(IMPLIES(tvp != NULL, VOP_ISLOCKED(tvp)));
944 	MPASS(fcnp->cn_flags & HASBUF);
945 	MPASS(tcnp->cn_flags & HASBUF);
946 
947   	tnode = (tvp == NULL) ? NULL : VP_TO_TMPFS_NODE(tvp);
948 
949 	/* Disallow cross-device renames.
950 	 * XXX Why isn't this done by the caller? */
951 	if (fvp->v_mount != tdvp->v_mount ||
952 	    (tvp != NULL && fvp->v_mount != tvp->v_mount)) {
953 		error = EXDEV;
954 		goto out;
955 	}
956 
957 	tmp = VFS_TO_TMPFS(tdvp->v_mount);
958 	tdnode = VP_TO_TMPFS_DIR(tdvp);
959 
960 	/* If source and target are the same file, there is nothing to do. */
961 	if (fvp == tvp) {
962 		error = 0;
963 		goto out;
964 	}
965 
966 	/* If we need to move the directory between entries, lock the
967 	 * source so that we can safely operate on it. */
968 	if (tdvp != fdvp) {
969 		error = vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY);
970 		if (error != 0)
971 			goto out;
972 	}
973 	fdnode = VP_TO_TMPFS_DIR(fdvp);
974 	fnode = VP_TO_TMPFS_NODE(fvp);
975 	de = tmpfs_dir_lookup(fdnode, fnode, fcnp);
976 
977 	/* Entry can disappear before we lock fdvp,
978 	 * also avoid manipulating '.' and '..' entries. */
979 	if (de == NULL) {
980 		if ((fcnp->cn_flags & ISDOTDOT) != 0 ||
981 		    (fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.'))
982 			error = EINVAL;
983 		else
984 			error = ENOENT;
985 		goto out_locked;
986 	}
987 	MPASS(de->td_node == fnode);
988 
989 	/* If re-naming a directory to another preexisting directory
990 	 * ensure that the target directory is empty so that its
991 	 * removal causes no side effects.
992 	 * Kern_rename gurantees the destination to be a directory
993 	 * if the source is one. */
994 	if (tvp != NULL) {
995 		MPASS(tnode != NULL);
996 
997 		if ((tnode->tn_flags & (NOUNLINK | IMMUTABLE | APPEND)) ||
998 		    (tdnode->tn_flags & (APPEND | IMMUTABLE))) {
999 			error = EPERM;
1000 			goto out_locked;
1001 		}
1002 
1003 		if (fnode->tn_type == VDIR && tnode->tn_type == VDIR) {
1004 			if (tnode->tn_size > 0) {
1005 				error = ENOTEMPTY;
1006 				goto out_locked;
1007 			}
1008 		} else if (fnode->tn_type == VDIR && tnode->tn_type != VDIR) {
1009 			error = ENOTDIR;
1010 			goto out_locked;
1011 		} else if (fnode->tn_type != VDIR && tnode->tn_type == VDIR) {
1012 			error = EISDIR;
1013 			goto out_locked;
1014 		} else {
1015 			MPASS(fnode->tn_type != VDIR &&
1016 				tnode->tn_type != VDIR);
1017 		}
1018 	}
1019 
1020 	if ((fnode->tn_flags & (NOUNLINK | IMMUTABLE | APPEND))
1021 	    || (fdnode->tn_flags & (APPEND | IMMUTABLE))) {
1022 		error = EPERM;
1023 		goto out_locked;
1024 	}
1025 
1026 	/* Ensure that we have enough memory to hold the new name, if it
1027 	 * has to be changed. */
1028 	if (fcnp->cn_namelen != tcnp->cn_namelen ||
1029 	    bcmp(fcnp->cn_nameptr, tcnp->cn_nameptr, fcnp->cn_namelen) != 0) {
1030 		newname = malloc(tcnp->cn_namelen, M_TMPFSNAME, M_WAITOK);
1031 	} else
1032 		newname = NULL;
1033 
1034 	/* If the node is being moved to another directory, we have to do
1035 	 * the move. */
1036 	if (fdnode != tdnode) {
1037 		/* In case we are moving a directory, we have to adjust its
1038 		 * parent to point to the new parent. */
1039 		if (de->td_node->tn_type == VDIR) {
1040 			struct tmpfs_node *n;
1041 
1042 			/* Ensure the target directory is not a child of the
1043 			 * directory being moved.  Otherwise, we'd end up
1044 			 * with stale nodes. */
1045 			n = tdnode;
1046 			/* TMPFS_LOCK garanties that no nodes are freed while
1047 			 * traversing the list. Nodes can only be marked as
1048 			 * removed: tn_parent == NULL. */
1049 			TMPFS_LOCK(tmp);
1050 			TMPFS_NODE_LOCK(n);
1051 			while (n != n->tn_dir.tn_parent) {
1052 				struct tmpfs_node *parent;
1053 
1054 				if (n == fnode) {
1055 					TMPFS_NODE_UNLOCK(n);
1056 					TMPFS_UNLOCK(tmp);
1057 					error = EINVAL;
1058 					if (newname != NULL)
1059 						    free(newname, M_TMPFSNAME);
1060 					goto out_locked;
1061 				}
1062 				parent = n->tn_dir.tn_parent;
1063 				TMPFS_NODE_UNLOCK(n);
1064 				if (parent == NULL) {
1065 					n = NULL;
1066 					break;
1067 				}
1068 				TMPFS_NODE_LOCK(parent);
1069 				if (parent->tn_dir.tn_parent == NULL) {
1070 					TMPFS_NODE_UNLOCK(parent);
1071 					n = NULL;
1072 					break;
1073 				}
1074 				n = parent;
1075 			}
1076 			TMPFS_UNLOCK(tmp);
1077 			if (n == NULL) {
1078 				error = EINVAL;
1079 				if (newname != NULL)
1080 					    free(newname, M_TMPFSNAME);
1081 				goto out_locked;
1082 			}
1083 			TMPFS_NODE_UNLOCK(n);
1084 
1085 			/* Adjust the parent pointer. */
1086 			TMPFS_VALIDATE_DIR(fnode);
1087 			TMPFS_NODE_LOCK(de->td_node);
1088 			de->td_node->tn_dir.tn_parent = tdnode;
1089 			TMPFS_NODE_UNLOCK(de->td_node);
1090 
1091 			/* As a result of changing the target of the '..'
1092 			 * entry, the link count of the source and target
1093 			 * directories has to be adjusted. */
1094 			TMPFS_NODE_LOCK(tdnode);
1095 			TMPFS_ASSERT_LOCKED(tdnode);
1096 			tdnode->tn_links++;
1097 			TMPFS_NODE_UNLOCK(tdnode);
1098 
1099 			TMPFS_NODE_LOCK(fdnode);
1100 			TMPFS_ASSERT_LOCKED(fdnode);
1101 			fdnode->tn_links--;
1102 			TMPFS_NODE_UNLOCK(fdnode);
1103 		}
1104 
1105 		/* Do the move: just remove the entry from the source directory
1106 		 * and insert it into the target one. */
1107 		tmpfs_dir_detach(fdvp, de);
1108 		if (fcnp->cn_flags & DOWHITEOUT)
1109 			tmpfs_dir_whiteout_add(fdvp, fcnp);
1110 		if (tcnp->cn_flags & ISWHITEOUT)
1111 			tmpfs_dir_whiteout_remove(tdvp, tcnp);
1112 		tmpfs_dir_attach(tdvp, de);
1113 	}
1114 
1115 	/* If the name has changed, we need to make it effective by changing
1116 	 * it in the directory entry. */
1117 	if (newname != NULL) {
1118 		MPASS(tcnp->cn_namelen <= MAXNAMLEN);
1119 
1120 		free(de->td_name, M_TMPFSNAME);
1121 		de->td_namelen = (uint16_t)tcnp->cn_namelen;
1122 		memcpy(newname, tcnp->cn_nameptr, tcnp->cn_namelen);
1123 		de->td_name = newname;
1124 
1125 		fnode->tn_status |= TMPFS_NODE_CHANGED;
1126 		tdnode->tn_status |= TMPFS_NODE_MODIFIED;
1127 	}
1128 
1129 	/* If we are overwriting an entry, we have to remove the old one
1130 	 * from the target directory. */
1131 	if (tvp != NULL) {
1132 		/* Remove the old entry from the target directory. */
1133 		de = tmpfs_dir_lookup(tdnode, tnode, tcnp);
1134 		tmpfs_dir_detach(tdvp, de);
1135 
1136 		/* Free the directory entry we just deleted.  Note that the
1137 		 * node referred by it will not be removed until the vnode is
1138 		 * really reclaimed. */
1139 		tmpfs_free_dirent(VFS_TO_TMPFS(tvp->v_mount), de, TRUE);
1140 	}
1141 	cache_purge(fvp);
1142 
1143 	error = 0;
1144 
1145 out_locked:
1146 	if (fdnode != tdnode)
1147 		VOP_UNLOCK(fdvp, 0);
1148 
1149 out:
1150 	/* Release target nodes. */
1151 	/* XXX: I don't understand when tdvp can be the same as tvp, but
1152 	 * other code takes care of this... */
1153 	if (tdvp == tvp)
1154 		vrele(tdvp);
1155 	else
1156 		vput(tdvp);
1157 	if (tvp != NULL)
1158 		vput(tvp);
1159 
1160 	/* Release source nodes. */
1161 	vrele(fdvp);
1162 	vrele(fvp);
1163 
1164 	return error;
1165 }
1166 
1167 /* --------------------------------------------------------------------- */
1168 
1169 static int
1170 tmpfs_mkdir(struct vop_mkdir_args *v)
1171 {
1172 	struct vnode *dvp = v->a_dvp;
1173 	struct vnode **vpp = v->a_vpp;
1174 	struct componentname *cnp = v->a_cnp;
1175 	struct vattr *vap = v->a_vap;
1176 
1177 	MPASS(vap->va_type == VDIR);
1178 
1179 	return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
1180 }
1181 
1182 /* --------------------------------------------------------------------- */
1183 
1184 static int
1185 tmpfs_rmdir(struct vop_rmdir_args *v)
1186 {
1187 	struct vnode *dvp = v->a_dvp;
1188 	struct vnode *vp = v->a_vp;
1189 
1190 	int error;
1191 	struct tmpfs_dirent *de;
1192 	struct tmpfs_mount *tmp;
1193 	struct tmpfs_node *dnode;
1194 	struct tmpfs_node *node;
1195 
1196 	MPASS(VOP_ISLOCKED(dvp));
1197 	MPASS(VOP_ISLOCKED(vp));
1198 
1199 	tmp = VFS_TO_TMPFS(dvp->v_mount);
1200 	dnode = VP_TO_TMPFS_DIR(dvp);
1201 	node = VP_TO_TMPFS_DIR(vp);
1202 
1203 	/* Directories with more than two entries ('.' and '..') cannot be
1204 	 * removed. */
1205 	 if (node->tn_size > 0) {
1206 		 error = ENOTEMPTY;
1207 		 goto out;
1208 	 }
1209 
1210 	if ((dnode->tn_flags & APPEND)
1211 	    || (node->tn_flags & (NOUNLINK | IMMUTABLE | APPEND))) {
1212 		error = EPERM;
1213 		goto out;
1214 	}
1215 
1216 	/* This invariant holds only if we are not trying to remove "..".
1217 	  * We checked for that above so this is safe now. */
1218 	MPASS(node->tn_dir.tn_parent == dnode);
1219 
1220 	/* Get the directory entry associated with node (vp).  This was
1221 	 * filled by tmpfs_lookup while looking up the entry. */
1222 	de = tmpfs_dir_lookup(dnode, node, v->a_cnp);
1223 	MPASS(TMPFS_DIRENT_MATCHES(de,
1224 	    v->a_cnp->cn_nameptr,
1225 	    v->a_cnp->cn_namelen));
1226 
1227 	/* Check flags to see if we are allowed to remove the directory. */
1228 	if (dnode->tn_flags & APPEND
1229 		|| node->tn_flags & (NOUNLINK | IMMUTABLE | APPEND)) {
1230 		error = EPERM;
1231 		goto out;
1232 	}
1233 
1234 
1235 	/* Detach the directory entry from the directory (dnode). */
1236 	tmpfs_dir_detach(dvp, de);
1237 	if (v->a_cnp->cn_flags & DOWHITEOUT)
1238 		tmpfs_dir_whiteout_add(dvp, v->a_cnp);
1239 
1240 	/* No vnode should be allocated for this entry from this point */
1241 	TMPFS_NODE_LOCK(node);
1242 	TMPFS_ASSERT_ELOCKED(node);
1243 	node->tn_links--;
1244 	node->tn_dir.tn_parent = NULL;
1245 	node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED | \
1246 	    TMPFS_NODE_MODIFIED;
1247 
1248 	TMPFS_NODE_UNLOCK(node);
1249 
1250 	TMPFS_NODE_LOCK(dnode);
1251 	TMPFS_ASSERT_ELOCKED(dnode);
1252 	dnode->tn_links--;
1253 	dnode->tn_status |= TMPFS_NODE_ACCESSED | \
1254 	    TMPFS_NODE_CHANGED | TMPFS_NODE_MODIFIED;
1255 	TMPFS_NODE_UNLOCK(dnode);
1256 
1257 	cache_purge(dvp);
1258 	cache_purge(vp);
1259 
1260 	/* Free the directory entry we just deleted.  Note that the node
1261 	 * referred by it will not be removed until the vnode is really
1262 	 * reclaimed. */
1263 	tmpfs_free_dirent(tmp, de, TRUE);
1264 
1265 	/* Release the deleted vnode (will destroy the node, notify
1266 	 * interested parties and clean it from the cache). */
1267 
1268 	dnode->tn_status |= TMPFS_NODE_CHANGED;
1269 	tmpfs_update(dvp);
1270 
1271 	error = 0;
1272 
1273 out:
1274 	return error;
1275 }
1276 
1277 /* --------------------------------------------------------------------- */
1278 
1279 static int
1280 tmpfs_symlink(struct vop_symlink_args *v)
1281 {
1282 	struct vnode *dvp = v->a_dvp;
1283 	struct vnode **vpp = v->a_vpp;
1284 	struct componentname *cnp = v->a_cnp;
1285 	struct vattr *vap = v->a_vap;
1286 	char *target = v->a_target;
1287 
1288 #ifdef notyet /* XXX FreeBSD BUG: kern_symlink is not setting VLNK */
1289 	MPASS(vap->va_type == VLNK);
1290 #else
1291 	vap->va_type = VLNK;
1292 #endif
1293 
1294 	return tmpfs_alloc_file(dvp, vpp, vap, cnp, target);
1295 }
1296 
1297 /* --------------------------------------------------------------------- */
1298 
1299 static int
1300 tmpfs_readdir(struct vop_readdir_args *v)
1301 {
1302 	struct vnode *vp = v->a_vp;
1303 	struct uio *uio = v->a_uio;
1304 	int *eofflag = v->a_eofflag;
1305 	u_long **cookies = v->a_cookies;
1306 	int *ncookies = v->a_ncookies;
1307 
1308 	int error;
1309 	off_t startoff;
1310 	off_t cnt = 0;
1311 	struct tmpfs_node *node;
1312 
1313 	/* This operation only makes sense on directory nodes. */
1314 	if (vp->v_type != VDIR)
1315 		return ENOTDIR;
1316 
1317 	node = VP_TO_TMPFS_DIR(vp);
1318 
1319 	startoff = uio->uio_offset;
1320 
1321 	if (uio->uio_offset == TMPFS_DIRCOOKIE_DOT) {
1322 		error = tmpfs_dir_getdotdent(node, uio);
1323 		if (error != 0)
1324 			goto outok;
1325 		cnt++;
1326 	}
1327 
1328 	if (uio->uio_offset == TMPFS_DIRCOOKIE_DOTDOT) {
1329 		error = tmpfs_dir_getdotdotdent(node, uio);
1330 		if (error != 0)
1331 			goto outok;
1332 		cnt++;
1333 	}
1334 
1335 	error = tmpfs_dir_getdents(node, uio, &cnt);
1336 
1337 outok:
1338 	MPASS(error >= -1);
1339 
1340 	if (error == -1)
1341 		error = (cnt != 0) ? 0 : EINVAL;
1342 
1343 	if (eofflag != NULL)
1344 		*eofflag =
1345 		    (error == 0 && uio->uio_offset == TMPFS_DIRCOOKIE_EOF);
1346 
1347 	/* Update NFS-related variables. */
1348 	if (error == 0 && cookies != NULL && ncookies != NULL) {
1349 		off_t i;
1350 		off_t off = startoff;
1351 		struct tmpfs_dirent *de = NULL;
1352 
1353 		*ncookies = cnt;
1354 		*cookies = malloc(cnt * sizeof(off_t), M_TEMP, M_WAITOK);
1355 
1356 		for (i = 0; i < cnt; i++) {
1357 			MPASS(off != TMPFS_DIRCOOKIE_EOF);
1358 			if (off == TMPFS_DIRCOOKIE_DOT) {
1359 				off = TMPFS_DIRCOOKIE_DOTDOT;
1360 			} else {
1361 				if (off == TMPFS_DIRCOOKIE_DOTDOT) {
1362 					de = TAILQ_FIRST(&node->tn_dir.tn_dirhead);
1363 				} else if (de != NULL) {
1364 					de = TAILQ_NEXT(de, td_entries);
1365 				} else {
1366 					de = tmpfs_dir_lookupbycookie(node,
1367 					    off);
1368 					MPASS(de != NULL);
1369 					de = TAILQ_NEXT(de, td_entries);
1370 				}
1371 				if (de == NULL)
1372 					off = TMPFS_DIRCOOKIE_EOF;
1373 				else
1374 					off = tmpfs_dircookie(de);
1375 			}
1376 
1377 			(*cookies)[i] = off;
1378 		}
1379 		MPASS(uio->uio_offset == off);
1380 	}
1381 
1382 	return error;
1383 }
1384 
1385 /* --------------------------------------------------------------------- */
1386 
1387 static int
1388 tmpfs_readlink(struct vop_readlink_args *v)
1389 {
1390 	struct vnode *vp = v->a_vp;
1391 	struct uio *uio = v->a_uio;
1392 
1393 	int error;
1394 	struct tmpfs_node *node;
1395 
1396 	MPASS(uio->uio_offset == 0);
1397 	MPASS(vp->v_type == VLNK);
1398 
1399 	node = VP_TO_TMPFS_NODE(vp);
1400 
1401 	error = uiomove(node->tn_link, MIN(node->tn_size, uio->uio_resid),
1402 	    uio);
1403 	node->tn_status |= TMPFS_NODE_ACCESSED;
1404 
1405 	return error;
1406 }
1407 
1408 /* --------------------------------------------------------------------- */
1409 
1410 static int
1411 tmpfs_inactive(struct vop_inactive_args *v)
1412 {
1413 	struct vnode *vp = v->a_vp;
1414 	struct thread *l = v->a_td;
1415 
1416 	struct tmpfs_node *node;
1417 
1418 	MPASS(VOP_ISLOCKED(vp));
1419 
1420 	node = VP_TO_TMPFS_NODE(vp);
1421 
1422 	if (node->tn_links == 0)
1423 		vrecycle(vp, l);
1424 
1425 	return 0;
1426 }
1427 
1428 /* --------------------------------------------------------------------- */
1429 
1430 int
1431 tmpfs_reclaim(struct vop_reclaim_args *v)
1432 {
1433 	struct vnode *vp = v->a_vp;
1434 
1435 	struct tmpfs_mount *tmp;
1436 	struct tmpfs_node *node;
1437 
1438 	node = VP_TO_TMPFS_NODE(vp);
1439 	tmp = VFS_TO_TMPFS(vp->v_mount);
1440 
1441 	vnode_destroy_vobject(vp);
1442 	cache_purge(vp);
1443 
1444 	TMPFS_NODE_LOCK(node);
1445 	TMPFS_ASSERT_ELOCKED(node);
1446 	tmpfs_free_vp(vp);
1447 
1448 	/* If the node referenced by this vnode was deleted by the user,
1449 	 * we must free its associated data structures (now that the vnode
1450 	 * is being reclaimed). */
1451 	if (node->tn_links == 0 &&
1452 	    (node->tn_vpstate & TMPFS_VNODE_ALLOCATING) == 0) {
1453 		node->tn_vpstate = TMPFS_VNODE_DOOMED;
1454 		TMPFS_NODE_UNLOCK(node);
1455 		tmpfs_free_node(tmp, node);
1456 	} else
1457 		TMPFS_NODE_UNLOCK(node);
1458 
1459 	MPASS(vp->v_data == NULL);
1460 	return 0;
1461 }
1462 
1463 /* --------------------------------------------------------------------- */
1464 
1465 static int
1466 tmpfs_print(struct vop_print_args *v)
1467 {
1468 	struct vnode *vp = v->a_vp;
1469 
1470 	struct tmpfs_node *node;
1471 
1472 	node = VP_TO_TMPFS_NODE(vp);
1473 
1474 	printf("tag VT_TMPFS, tmpfs_node %p, flags 0x%x, links %d\n",
1475 	    node, node->tn_flags, node->tn_links);
1476 	printf("\tmode 0%o, owner %d, group %d, size %" PRIdMAX
1477 	    ", status 0x%x\n",
1478 	    node->tn_mode, node->tn_uid, node->tn_gid,
1479 	    (uintmax_t)node->tn_size, node->tn_status);
1480 
1481 	if (vp->v_type == VFIFO)
1482 		fifo_printinfo(vp);
1483 
1484 	printf("\n");
1485 
1486 	return 0;
1487 }
1488 
1489 /* --------------------------------------------------------------------- */
1490 
1491 static int
1492 tmpfs_pathconf(struct vop_pathconf_args *v)
1493 {
1494 	int name = v->a_name;
1495 	register_t *retval = v->a_retval;
1496 
1497 	int error;
1498 
1499 	error = 0;
1500 
1501 	switch (name) {
1502 	case _PC_LINK_MAX:
1503 		*retval = LINK_MAX;
1504 		break;
1505 
1506 	case _PC_NAME_MAX:
1507 		*retval = NAME_MAX;
1508 		break;
1509 
1510 	case _PC_PATH_MAX:
1511 		*retval = PATH_MAX;
1512 		break;
1513 
1514 	case _PC_PIPE_BUF:
1515 		*retval = PIPE_BUF;
1516 		break;
1517 
1518 	case _PC_CHOWN_RESTRICTED:
1519 		*retval = 1;
1520 		break;
1521 
1522 	case _PC_NO_TRUNC:
1523 		*retval = 1;
1524 		break;
1525 
1526 	case _PC_SYNC_IO:
1527 		*retval = 1;
1528 		break;
1529 
1530 	case _PC_FILESIZEBITS:
1531 		*retval = 0; /* XXX Don't know which value should I return. */
1532 		break;
1533 
1534 	default:
1535 		error = EINVAL;
1536 	}
1537 
1538 	return error;
1539 }
1540 
1541 static int
1542 tmpfs_vptofh(struct vop_vptofh_args *ap)
1543 {
1544 	struct tmpfs_fid *tfhp;
1545 	struct tmpfs_node *node;
1546 
1547 	tfhp = (struct tmpfs_fid *)ap->a_fhp;
1548 	node = VP_TO_TMPFS_NODE(ap->a_vp);
1549 
1550 	tfhp->tf_len = sizeof(struct tmpfs_fid);
1551 	tfhp->tf_id = node->tn_id;
1552 	tfhp->tf_gen = node->tn_gen;
1553 
1554 	return (0);
1555 }
1556 
1557 static int
1558 tmpfs_whiteout(struct vop_whiteout_args *ap)
1559 {
1560 	struct vnode *dvp = ap->a_dvp;
1561 	struct componentname *cnp = ap->a_cnp;
1562 	struct tmpfs_dirent *de;
1563 
1564 	switch (ap->a_flags) {
1565 	case LOOKUP:
1566 		return (0);
1567 	case CREATE:
1568 		de = tmpfs_dir_lookup(VP_TO_TMPFS_DIR(dvp), NULL, cnp);
1569 		if (de != NULL)
1570 			return (de->td_node == NULL ? 0 : EEXIST);
1571 		return (tmpfs_dir_whiteout_add(dvp, cnp));
1572 	case DELETE:
1573 		tmpfs_dir_whiteout_remove(dvp, cnp);
1574 		return (0);
1575 	default:
1576 		panic("tmpfs_whiteout: unknown op");
1577 	}
1578 }
1579 
1580 /* --------------------------------------------------------------------- */
1581 
1582 /*
1583  * vnode operations vector used for files stored in a tmpfs file system.
1584  */
1585 struct vop_vector tmpfs_vnodeop_entries = {
1586 	.vop_default =			&default_vnodeops,
1587 	.vop_lookup =			vfs_cache_lookup,
1588 	.vop_cachedlookup =		tmpfs_lookup,
1589 	.vop_create =			tmpfs_create,
1590 	.vop_mknod =			tmpfs_mknod,
1591 	.vop_open =			tmpfs_open,
1592 	.vop_close =			tmpfs_close,
1593 	.vop_access =			tmpfs_access,
1594 	.vop_getattr =			tmpfs_getattr,
1595 	.vop_setattr =			tmpfs_setattr,
1596 	.vop_read =			tmpfs_read,
1597 	.vop_write =			tmpfs_write,
1598 	.vop_fsync =			tmpfs_fsync,
1599 	.vop_remove =			tmpfs_remove,
1600 	.vop_link =			tmpfs_link,
1601 	.vop_rename =			tmpfs_rename,
1602 	.vop_mkdir =			tmpfs_mkdir,
1603 	.vop_rmdir =			tmpfs_rmdir,
1604 	.vop_symlink =			tmpfs_symlink,
1605 	.vop_readdir =			tmpfs_readdir,
1606 	.vop_readlink =			tmpfs_readlink,
1607 	.vop_inactive =			tmpfs_inactive,
1608 	.vop_reclaim =			tmpfs_reclaim,
1609 	.vop_print =			tmpfs_print,
1610 	.vop_pathconf =			tmpfs_pathconf,
1611 	.vop_vptofh =			tmpfs_vptofh,
1612 	.vop_whiteout =			tmpfs_whiteout,
1613 	.vop_bmap =			VOP_EOPNOTSUPP,
1614 };
1615 
1616