xref: /netbsd-src/sys/fs/tmpfs/tmpfs_vnops.c (revision 6deb2c22d20de1d75d538e8a5c57b573926fd157)
1 /*	$NetBSD: tmpfs_vnops.c,v 1.64 2009/10/17 22:20:56 njoly Exp $	*/
2 
3 /*
4  * Copyright (c) 2005, 2006, 2007 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 
37 #include <sys/cdefs.h>
38 __KERNEL_RCSID(0, "$NetBSD: tmpfs_vnops.c,v 1.64 2009/10/17 22:20:56 njoly Exp $");
39 
40 #include <sys/param.h>
41 #include <sys/dirent.h>
42 #include <sys/fcntl.h>
43 #include <sys/event.h>
44 #include <sys/malloc.h>
45 #include <sys/namei.h>
46 #include <sys/proc.h>
47 #include <sys/stat.h>
48 #include <sys/uio.h>
49 #include <sys/unistd.h>
50 #include <sys/vnode.h>
51 #include <sys/lockf.h>
52 #include <sys/kauth.h>
53 
54 #include <uvm/uvm.h>
55 
56 #include <miscfs/fifofs/fifo.h>
57 #include <miscfs/genfs/genfs.h>
58 #include <fs/tmpfs/tmpfs_vnops.h>
59 #include <fs/tmpfs/tmpfs.h>
60 
61 /* --------------------------------------------------------------------- */
62 
63 /*
64  * vnode operations vector used for files stored in a tmpfs file system.
65  */
66 int (**tmpfs_vnodeop_p)(void *);
67 const struct vnodeopv_entry_desc tmpfs_vnodeop_entries[] = {
68 	{ &vop_default_desc,		vn_default_error },
69 	{ &vop_lookup_desc,		tmpfs_lookup },
70 	{ &vop_create_desc,		tmpfs_create },
71 	{ &vop_mknod_desc,		tmpfs_mknod },
72 	{ &vop_open_desc,		tmpfs_open },
73 	{ &vop_close_desc,		tmpfs_close },
74 	{ &vop_access_desc,		tmpfs_access },
75 	{ &vop_getattr_desc,		tmpfs_getattr },
76 	{ &vop_setattr_desc,		tmpfs_setattr },
77 	{ &vop_read_desc,		tmpfs_read },
78 	{ &vop_write_desc,		tmpfs_write },
79 	{ &vop_ioctl_desc,		tmpfs_ioctl },
80 	{ &vop_fcntl_desc,		tmpfs_fcntl },
81 	{ &vop_poll_desc,		tmpfs_poll },
82 	{ &vop_kqfilter_desc,		tmpfs_kqfilter },
83 	{ &vop_revoke_desc,		tmpfs_revoke },
84 	{ &vop_mmap_desc,		tmpfs_mmap },
85 	{ &vop_fsync_desc,		tmpfs_fsync },
86 	{ &vop_seek_desc,		tmpfs_seek },
87 	{ &vop_remove_desc,		tmpfs_remove },
88 	{ &vop_link_desc,		tmpfs_link },
89 	{ &vop_rename_desc,		tmpfs_rename },
90 	{ &vop_mkdir_desc,		tmpfs_mkdir },
91 	{ &vop_rmdir_desc,		tmpfs_rmdir },
92 	{ &vop_symlink_desc,		tmpfs_symlink },
93 	{ &vop_readdir_desc,		tmpfs_readdir },
94 	{ &vop_readlink_desc,		tmpfs_readlink },
95 	{ &vop_abortop_desc,		tmpfs_abortop },
96 	{ &vop_inactive_desc,		tmpfs_inactive },
97 	{ &vop_reclaim_desc,		tmpfs_reclaim },
98 	{ &vop_lock_desc,		tmpfs_lock },
99 	{ &vop_unlock_desc,		tmpfs_unlock },
100 	{ &vop_bmap_desc,		tmpfs_bmap },
101 	{ &vop_strategy_desc,		tmpfs_strategy },
102 	{ &vop_print_desc,		tmpfs_print },
103 	{ &vop_pathconf_desc,		tmpfs_pathconf },
104 	{ &vop_islocked_desc,		tmpfs_islocked },
105 	{ &vop_advlock_desc,		tmpfs_advlock },
106 	{ &vop_bwrite_desc,		tmpfs_bwrite },
107 	{ &vop_getpages_desc,		tmpfs_getpages },
108 	{ &vop_putpages_desc,		tmpfs_putpages },
109 	{ NULL, NULL }
110 };
111 const struct vnodeopv_desc tmpfs_vnodeop_opv_desc =
112 	{ &tmpfs_vnodeop_p, tmpfs_vnodeop_entries };
113 
114 /* --------------------------------------------------------------------- */
115 
116 int
117 tmpfs_lookup(void *v)
118 {
119 	struct vnode *dvp = ((struct vop_lookup_args *)v)->a_dvp;
120 	struct vnode **vpp = ((struct vop_lookup_args *)v)->a_vpp;
121 	struct componentname *cnp = ((struct vop_lookup_args *)v)->a_cnp;
122 
123 	int error;
124 	struct tmpfs_dirent *de;
125 	struct tmpfs_node *dnode;
126 
127 	KASSERT(VOP_ISLOCKED(dvp));
128 
129 	dnode = VP_TO_TMPFS_DIR(dvp);
130 	*vpp = NULL;
131 
132 	/* Check accessibility of requested node as a first step. */
133 	error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred);
134 	if (error != 0)
135 		goto out;
136 
137 	/* If requesting the last path component on a read-only file system
138 	 * with a write operation, deny it. */
139 	if ((cnp->cn_flags & ISLASTCN) &&
140 	    (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
141 	    (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
142 		error = EROFS;
143 		goto out;
144 	}
145 
146 	/* Avoid doing a linear scan of the directory if the requested
147 	 * directory/name couple is already in the cache. */
148 	error = cache_lookup(dvp, vpp, cnp);
149 	if (error >= 0)
150 		goto out;
151 
152 	/* We cannot be requesting the parent directory of the root node. */
153 	KASSERT(IMPLIES(dnode->tn_type == VDIR &&
154 	    dnode->tn_spec.tn_dir.tn_parent == dnode,
155 	    !(cnp->cn_flags & ISDOTDOT)));
156 
157 	if (cnp->cn_flags & ISDOTDOT) {
158 		VOP_UNLOCK(dvp, 0);
159 
160 		/* Allocate a new vnode on the matching entry. */
161 		error = tmpfs_alloc_vp(dvp->v_mount,
162 		    dnode->tn_spec.tn_dir.tn_parent, vpp);
163 
164 		vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
165 	} else if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
166 		VREF(dvp);
167 		*vpp = dvp;
168 		error = 0;
169 	} else {
170 		de = tmpfs_dir_lookup(dnode, cnp);
171 		if (de == NULL) {
172 			/* The entry was not found in the directory.
173 			 * This is OK iff we are creating or renaming an
174 			 * entry and are working on the last component of
175 			 * the path name. */
176 			if ((cnp->cn_flags & ISLASTCN) &&
177 			    (cnp->cn_nameiop == CREATE || \
178 			    cnp->cn_nameiop == RENAME)) {
179 				error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
180 				if (error != 0)
181 					goto out;
182 
183 				/* Keep the component name in the buffer for
184 				 * future uses. */
185 				cnp->cn_flags |= SAVENAME;
186 
187 				error = EJUSTRETURN;
188 			} else
189 				error = ENOENT;
190 		} else {
191 			struct tmpfs_node *tnode;
192 
193 			/* The entry was found, so get its associated
194 			 * tmpfs_node. */
195 			tnode = de->td_node;
196 
197 			/* If we are not at the last path component and
198 			 * found a non-directory or non-link entry (which
199 			 * may itself be pointing to a directory), raise
200 			 * an error. */
201 			if ((tnode->tn_type != VDIR &&
202 			    tnode->tn_type != VLNK) &&
203 			    !(cnp->cn_flags & ISLASTCN)) {
204 				error = ENOTDIR;
205 				goto out;
206 			}
207 
208 			/* Check permissions */
209 			if ((cnp->cn_flags & ISLASTCN) &&
210 			    (cnp->cn_nameiop == DELETE ||
211 			    cnp->cn_nameiop == RENAME)) {
212 				kauth_action_t action = 0;
213 
214 				/* This is the file-system's decision. */
215 				if ((dnode->tn_mode & S_ISTXT) != 0 &&
216 				    kauth_cred_geteuid(cnp->cn_cred) != dnode->tn_uid &&
217 				    kauth_cred_geteuid(cnp->cn_cred) != tnode->tn_uid)
218 					error = EPERM;
219 				else
220 					error = 0;
221 
222 				/* Only bother if we're not already failing it. */
223 				if (!error) {
224 					error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
225 				}
226 
227 				if (cnp->cn_nameiop == DELETE)
228 					action |= KAUTH_VNODE_DELETE;
229 				else /* if (cnp->cn_nameiop == RENAME) */
230 					action |= KAUTH_VNODE_RENAME;
231 
232 				error = kauth_authorize_vnode(cnp->cn_cred,
233 				    action, *vpp, dvp, error);
234 				if (error != 0)
235 					goto out;
236 
237 				cnp->cn_flags |= SAVENAME;
238 			} else
239 				de = NULL;
240 
241 			/* Allocate a new vnode on the matching entry. */
242 			error = tmpfs_alloc_vp(dvp->v_mount, tnode, vpp);
243 		}
244 	}
245 
246 	/* Store the result of this lookup in the cache.  Avoid this if the
247 	 * request was for creation, as it does not improve timings on
248 	 * emprical tests. */
249 	if ((cnp->cn_flags & MAKEENTRY) && cnp->cn_nameiop != CREATE &&
250 	    (cnp->cn_flags & ISDOTDOT) == 0)
251 		cache_enter(dvp, *vpp, cnp);
252 
253 out:
254 	/* If there were no errors, *vpp cannot be null and it must be
255 	 * locked. */
256 	KASSERT(IFF(error == 0, *vpp != NULL && VOP_ISLOCKED(*vpp)));
257 
258 	/* dvp must always be locked. */
259 	KASSERT(VOP_ISLOCKED(dvp));
260 
261 	return error;
262 }
263 
264 /* --------------------------------------------------------------------- */
265 
266 int
267 tmpfs_create(void *v)
268 {
269 	struct vnode *dvp = ((struct vop_create_args *)v)->a_dvp;
270 	struct vnode **vpp = ((struct vop_create_args *)v)->a_vpp;
271 	struct componentname *cnp = ((struct vop_create_args *)v)->a_cnp;
272 	struct vattr *vap = ((struct vop_create_args *)v)->a_vap;
273 
274 	KASSERT(vap->va_type == VREG || vap->va_type == VSOCK);
275 
276 	return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
277 }
278 /* --------------------------------------------------------------------- */
279 
280 int
281 tmpfs_mknod(void *v)
282 {
283 	struct vnode *dvp = ((struct vop_mknod_args *)v)->a_dvp;
284 	struct vnode **vpp = ((struct vop_mknod_args *)v)->a_vpp;
285 	struct componentname *cnp = ((struct vop_mknod_args *)v)->a_cnp;
286 	struct vattr *vap = ((struct vop_mknod_args *)v)->a_vap;
287 
288 	if (vap->va_type != VBLK && vap->va_type != VCHR &&
289 	    vap->va_type != VFIFO) {
290 		vput(dvp);
291 		return EINVAL;
292 	}
293 
294 	return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
295 }
296 
297 /* --------------------------------------------------------------------- */
298 
299 int
300 tmpfs_open(void *v)
301 {
302 	struct vnode *vp = ((struct vop_open_args *)v)->a_vp;
303 	int mode = ((struct vop_open_args *)v)->a_mode;
304 
305 	int error;
306 	struct tmpfs_node *node;
307 
308 	KASSERT(VOP_ISLOCKED(vp));
309 
310 	node = VP_TO_TMPFS_NODE(vp);
311 
312 	/* The file is still active but all its names have been removed
313 	 * (e.g. by a "rmdir $(pwd)").  It cannot be opened any more as
314 	 * it is about to die. */
315 	if (node->tn_links < 1) {
316 		error = ENOENT;
317 		goto out;
318 	}
319 
320 	/* If the file is marked append-only, deny write requests. */
321 	if (node->tn_flags & APPEND && (mode & (FWRITE | O_APPEND)) == FWRITE)
322 		error = EPERM;
323 	else
324 		error = 0;
325 
326 out:
327 	KASSERT(VOP_ISLOCKED(vp));
328 
329 	return error;
330 }
331 
332 /* --------------------------------------------------------------------- */
333 
334 int
335 tmpfs_close(void *v)
336 {
337 	struct vnode *vp = ((struct vop_close_args *)v)->a_vp;
338 
339 	struct tmpfs_node *node;
340 
341 	KASSERT(VOP_ISLOCKED(vp));
342 
343 	node = VP_TO_TMPFS_NODE(vp);
344 
345 	if (node->tn_links > 0) {
346 		/* Update node times.  No need to do it if the node has
347 		 * been deleted, because it will vanish after we return. */
348 		tmpfs_update(vp, NULL, NULL, NULL, UPDATE_CLOSE);
349 	}
350 
351 	return 0;
352 }
353 
354 /* --------------------------------------------------------------------- */
355 
356 static int
357 tmpfs_check_possible(struct vnode *vp, struct tmpfs_node *node, mode_t mode)
358 {
359 	int error = 0;
360 
361 	switch (vp->v_type) {
362 	case VDIR:
363 		/* FALLTHROUGH */
364 	case VLNK:
365 		/* FALLTHROUGH */
366 	case VREG:
367 		if (mode & VWRITE && vp->v_mount->mnt_flag & MNT_RDONLY) {
368 			error = EROFS;
369 			goto out;
370 		}
371 		break;
372 
373 	case VBLK:
374 		/* FALLTHROUGH */
375 	case VCHR:
376 		/* FALLTHROUGH */
377 	case VSOCK:
378 		/* FALLTHROUGH */
379 	case VFIFO:
380 		break;
381 
382 	default:
383 		error = EINVAL;
384 		goto out;
385 	}
386 
387 	if (mode & VWRITE && node->tn_flags & IMMUTABLE) {
388 		error = EPERM;
389 		goto out;
390 	}
391 
392  out:
393 	return error;
394 }
395 
396 static int
397 tmpfs_check_permitted(struct vnode *vp, struct tmpfs_node *node, mode_t mode,
398     kauth_cred_t cred)
399 {
400 
401 	return genfs_can_access(vp->v_type, node->tn_mode, node->tn_uid,
402 	    node->tn_gid, mode, cred);
403 }
404 
405 int
406 tmpfs_access(void *v)
407 {
408 	struct vnode *vp = ((struct vop_access_args *)v)->a_vp;
409 	int mode = ((struct vop_access_args *)v)->a_mode;
410 	kauth_cred_t cred = ((struct vop_access_args *)v)->a_cred;
411 
412 	int error;
413 	struct tmpfs_node *node;
414 
415 	KASSERT(VOP_ISLOCKED(vp));
416 
417 	node = VP_TO_TMPFS_NODE(vp);
418 
419 	error = tmpfs_check_possible(vp, node, mode);
420 	if (error)
421 		goto out;
422 
423 	error = tmpfs_check_permitted(vp, node, mode, cred);
424 
425 	error = kauth_authorize_vnode(cred, kauth_mode_to_action(mode), vp,
426 	    NULL, error);
427 
428 out:
429 	KASSERT(VOP_ISLOCKED(vp));
430 
431 	return error;
432 }
433 
434 /* --------------------------------------------------------------------- */
435 
436 int
437 tmpfs_getattr(void *v)
438 {
439 	struct vnode *vp = ((struct vop_getattr_args *)v)->a_vp;
440 	struct vattr *vap = ((struct vop_getattr_args *)v)->a_vap;
441 
442 	struct tmpfs_node *node;
443 
444 	node = VP_TO_TMPFS_NODE(vp);
445 
446 	VATTR_NULL(vap);
447 
448 	tmpfs_itimes(vp, NULL, NULL, NULL);
449 
450 	vap->va_type = vp->v_type;
451 	vap->va_mode = node->tn_mode;
452 	vap->va_nlink = node->tn_links;
453 	vap->va_uid = node->tn_uid;
454 	vap->va_gid = node->tn_gid;
455 	vap->va_fsid = vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0];
456 	vap->va_fileid = node->tn_id;
457 	vap->va_size = node->tn_size;
458 	vap->va_blocksize = PAGE_SIZE;
459 	vap->va_atime = node->tn_atime;
460 	vap->va_mtime = node->tn_mtime;
461 	vap->va_ctime = node->tn_ctime;
462 	vap->va_birthtime = node->tn_birthtime;
463 	vap->va_gen = node->tn_gen;
464 	vap->va_flags = node->tn_flags;
465 	vap->va_rdev = (vp->v_type == VBLK || vp->v_type == VCHR) ?
466 		node->tn_spec.tn_dev.tn_rdev : VNOVAL;
467 	vap->va_bytes = round_page(node->tn_size);
468 	vap->va_filerev = VNOVAL;
469 	vap->va_vaflags = 0;
470 	vap->va_spare = VNOVAL; /* XXX */
471 
472 	return 0;
473 }
474 
475 /* --------------------------------------------------------------------- */
476 
477 #define GOODTIME(tv)	((tv)->tv_sec != VNOVAL || (tv)->tv_nsec != VNOVAL)
478 /* XXX Should this operation be atomic?  I think it should, but code in
479  * XXX other places (e.g., ufs) doesn't seem to be... */
480 int
481 tmpfs_setattr(void *v)
482 {
483 	struct vnode *vp = ((struct vop_setattr_args *)v)->a_vp;
484 	struct vattr *vap = ((struct vop_setattr_args *)v)->a_vap;
485 	kauth_cred_t cred = ((struct vop_setattr_args *)v)->a_cred;
486 	struct lwp *l = curlwp;
487 
488 	int error;
489 
490 	KASSERT(VOP_ISLOCKED(vp));
491 
492 	error = 0;
493 
494 	/* Abort if any unsettable attribute is given. */
495 	if (vap->va_type != VNON ||
496 	    vap->va_nlink != VNOVAL ||
497 	    vap->va_fsid != VNOVAL ||
498 	    vap->va_fileid != VNOVAL ||
499 	    vap->va_blocksize != VNOVAL ||
500 	    GOODTIME(&vap->va_ctime) ||
501 	    vap->va_gen != VNOVAL ||
502 	    vap->va_rdev != VNOVAL ||
503 	    vap->va_bytes != VNOVAL)
504 		error = EINVAL;
505 
506 	if (error == 0 && (vap->va_flags != VNOVAL))
507 		error = tmpfs_chflags(vp, vap->va_flags, cred, l);
508 
509 	if (error == 0 && (vap->va_size != VNOVAL))
510 		error = tmpfs_chsize(vp, vap->va_size, cred, l);
511 
512 	if (error == 0 && (vap->va_uid != VNOVAL || vap->va_gid != VNOVAL))
513 		error = tmpfs_chown(vp, vap->va_uid, vap->va_gid, cred, l);
514 
515 	if (error == 0 && (vap->va_mode != VNOVAL))
516 		error = tmpfs_chmod(vp, vap->va_mode, cred, l);
517 
518 	if (error == 0 && (GOODTIME(&vap->va_atime) || GOODTIME(&vap->va_mtime)
519 	    || GOODTIME(&vap->va_birthtime)))
520 		if ((error = tmpfs_chtimes(vp, &vap->va_atime, &vap->va_mtime,
521 		    &vap->va_birthtime, vap->va_vaflags, cred, l)) == 0)
522 			return 0;
523 
524 	/* Update the node times.  We give preference to the error codes
525 	 * generated by this function rather than the ones that may arise
526 	 * from tmpfs_update. */
527 	tmpfs_update(vp, NULL, NULL, NULL, 0);
528 
529 	KASSERT(VOP_ISLOCKED(vp));
530 
531 	return error;
532 }
533 
534 /* --------------------------------------------------------------------- */
535 
536 int
537 tmpfs_read(void *v)
538 {
539 	struct vnode *vp = ((struct vop_read_args *)v)->a_vp;
540 	struct uio *uio = ((struct vop_read_args *)v)->a_uio;
541 	int ioflag = ((struct vop_read_args *)v)->a_ioflag;
542 
543 	int error;
544 	struct tmpfs_node *node;
545 	struct uvm_object *uobj;
546 
547 	KASSERT(VOP_ISLOCKED(vp));
548 
549 	node = VP_TO_TMPFS_NODE(vp);
550 
551 	if (vp->v_type != VREG) {
552 		error = EISDIR;
553 		goto out;
554 	}
555 
556 	if (uio->uio_offset < 0) {
557 		error = EINVAL;
558 		goto out;
559 	}
560 
561 	node->tn_status |= TMPFS_NODE_ACCESSED;
562 
563 	uobj = node->tn_spec.tn_reg.tn_aobj;
564 	error = 0;
565 	while (error == 0 && uio->uio_resid > 0) {
566 		vsize_t len;
567 
568 		if (node->tn_size <= uio->uio_offset)
569 			break;
570 
571 		len = MIN(node->tn_size - uio->uio_offset, uio->uio_resid);
572 		if (len == 0)
573 			break;
574 
575 		error = ubc_uiomove(uobj, uio, len, IO_ADV_DECODE(ioflag),
576 		    UBC_READ | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp));
577 	}
578 
579 out:
580 	KASSERT(VOP_ISLOCKED(vp));
581 
582 	return error;
583 }
584 
585 /* --------------------------------------------------------------------- */
586 
587 int
588 tmpfs_write(void *v)
589 {
590 	struct vnode *vp = ((struct vop_write_args *)v)->a_vp;
591 	struct uio *uio = ((struct vop_write_args *)v)->a_uio;
592 	int ioflag = ((struct vop_write_args *)v)->a_ioflag;
593 
594 	bool extended;
595 	int error;
596 	off_t oldsize;
597 	struct proc *p = curproc;
598 	struct tmpfs_node *node;
599 	struct uvm_object *uobj;
600 
601 	KASSERT(VOP_ISLOCKED(vp));
602 
603 	node = VP_TO_TMPFS_NODE(vp);
604 	oldsize = node->tn_size;
605 
606 	if (uio->uio_offset < 0 || vp->v_type != VREG) {
607 		error = EINVAL;
608 		goto out;
609 	}
610 
611 	if (uio->uio_resid == 0) {
612 		error = 0;
613 		goto out;
614 	}
615 
616 	if (((uio->uio_offset + uio->uio_resid) >
617 	    p->p_rlimit[RLIMIT_FSIZE].rlim_cur)) {
618 		mutex_enter(proc_lock);
619 		psignal(p, SIGXFSZ);
620 		mutex_exit(proc_lock);
621 		error = EFBIG;
622 		goto out;
623 	}
624 
625 	if (ioflag & IO_APPEND)
626 		uio->uio_offset = node->tn_size;
627 
628 	extended = uio->uio_offset + uio->uio_resid > node->tn_size;
629 	if (extended) {
630 		error = tmpfs_reg_resize(vp, uio->uio_offset + uio->uio_resid);
631 		if (error != 0)
632 			goto out;
633 	}
634 
635 	uobj = node->tn_spec.tn_reg.tn_aobj;
636 	error = 0;
637 	while (error == 0 && uio->uio_resid > 0) {
638 		vsize_t len;
639 
640 		len = MIN(node->tn_size - uio->uio_offset, uio->uio_resid);
641 		if (len == 0)
642 			break;
643 
644 		error = ubc_uiomove(uobj, uio, len, IO_ADV_DECODE(ioflag),
645 		    UBC_WRITE | UBC_UNMAP_FLAG(vp));
646 	}
647 
648 	node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_MODIFIED |
649 	    (extended ? TMPFS_NODE_CHANGED : 0);
650 
651 	if (error != 0)
652 		(void)tmpfs_reg_resize(vp, oldsize);
653 
654 	VN_KNOTE(vp, NOTE_WRITE);
655 
656 out:
657 	KASSERT(VOP_ISLOCKED(vp));
658 	KASSERT(IMPLIES(error == 0, uio->uio_resid == 0));
659 	KASSERT(IMPLIES(error != 0, oldsize == node->tn_size));
660 
661 	return error;
662 }
663 
664 /* --------------------------------------------------------------------- */
665 
666 int
667 tmpfs_fsync(void *v)
668 {
669 	struct vnode *vp = ((struct vop_fsync_args *)v)->a_vp;
670 
671 	KASSERT(VOP_ISLOCKED(vp));
672 
673 	tmpfs_update(vp, NULL, NULL, NULL, 0);
674 
675 	return 0;
676 }
677 
678 /* --------------------------------------------------------------------- */
679 
680 int
681 tmpfs_remove(void *v)
682 {
683 	struct vnode *dvp = ((struct vop_remove_args *)v)->a_dvp;
684 	struct vnode *vp = ((struct vop_remove_args *)v)->a_vp;
685 	struct componentname *cnp = (((struct vop_remove_args *)v)->a_cnp);
686 
687 	int error;
688 	struct tmpfs_dirent *de;
689 	struct tmpfs_mount *tmp;
690 	struct tmpfs_node *dnode;
691 	struct tmpfs_node *node;
692 
693 	KASSERT(VOP_ISLOCKED(dvp));
694 	KASSERT(VOP_ISLOCKED(vp));
695 
696 	if (vp->v_type == VDIR) {
697 		error = EPERM;
698 		goto out;
699 	}
700 
701 	dnode = VP_TO_TMPFS_DIR(dvp);
702 	node = VP_TO_TMPFS_NODE(vp);
703 	tmp = VFS_TO_TMPFS(vp->v_mount);
704 	de = tmpfs_dir_lookup(dnode, cnp);
705 	KASSERT(de);
706 	KASSERT(de->td_node == node);
707 
708 	/* Files marked as immutable or append-only cannot be deleted. */
709 	if (node->tn_flags & (IMMUTABLE | APPEND)) {
710 		error = EPERM;
711 		goto out;
712 	}
713 
714 	/* Remove the entry from the directory; as it is a file, we do not
715 	 * have to change the number of hard links of the directory. */
716 	tmpfs_dir_detach(dvp, de);
717 
718 	/* Free the directory entry we just deleted.  Note that the node
719 	 * referred by it will not be removed until the vnode is really
720 	 * reclaimed. */
721 	tmpfs_free_dirent(tmp, de, true);
722 
723 	error = 0;
724 
725 out:
726 	vput(vp);
727 	if (dvp == vp)
728 		vrele(dvp);
729 	else
730 		vput(dvp);
731 	PNBUF_PUT(cnp->cn_pnbuf);
732 
733 	return error;
734 }
735 
736 /* --------------------------------------------------------------------- */
737 
738 int
739 tmpfs_link(void *v)
740 {
741 	struct vnode *dvp = ((struct vop_link_args *)v)->a_dvp;
742 	struct vnode *vp = ((struct vop_link_args *)v)->a_vp;
743 	struct componentname *cnp = ((struct vop_link_args *)v)->a_cnp;
744 
745 	int error;
746 	struct tmpfs_dirent *de;
747 	struct tmpfs_node *dnode;
748 	struct tmpfs_node *node;
749 
750 	KASSERT(VOP_ISLOCKED(dvp));
751 	KASSERT(cnp->cn_flags & HASBUF);
752 	KASSERT(dvp != vp); /* XXX When can this be false? */
753 
754 	dnode = VP_TO_TMPFS_DIR(dvp);
755 	node = VP_TO_TMPFS_NODE(vp);
756 
757 	/* Lock vp because we will need to run tmpfs_update over it, which
758 	 * needs the vnode to be locked. */
759 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
760 
761 	/* XXX: Why aren't the following two tests done by the caller? */
762 
763 	/* Hard links of directories are forbidden. */
764 	if (vp->v_type == VDIR) {
765 		error = EPERM;
766 		goto out;
767 	}
768 
769 	/* Cannot create cross-device links. */
770 	if (dvp->v_mount != vp->v_mount) {
771 		error = EXDEV;
772 		goto out;
773 	}
774 
775 	/* Ensure that we do not overflow the maximum number of links imposed
776 	 * by the system. */
777 	KASSERT(node->tn_links <= LINK_MAX);
778 	if (node->tn_links == LINK_MAX) {
779 		error = EMLINK;
780 		goto out;
781 	}
782 
783 	/* We cannot create links of files marked immutable or append-only. */
784 	if (node->tn_flags & (IMMUTABLE | APPEND)) {
785 		error = EPERM;
786 		goto out;
787 	}
788 
789 	/* Allocate a new directory entry to represent the node. */
790 	error = tmpfs_alloc_dirent(VFS_TO_TMPFS(vp->v_mount), node,
791 	    cnp->cn_nameptr, cnp->cn_namelen, &de);
792 	if (error != 0)
793 		goto out;
794 
795 	/* Insert the new directory entry into the appropriate directory. */
796 	tmpfs_dir_attach(dvp, de);
797 
798 	/* vp link count has changed, so update node times. */
799 	node->tn_status |= TMPFS_NODE_CHANGED;
800 	tmpfs_update(vp, NULL, NULL, NULL, 0);
801 
802 	error = 0;
803 
804 out:
805 	VOP_UNLOCK(vp, 0);
806 	PNBUF_PUT(cnp->cn_pnbuf);
807 	vput(dvp);
808 
809 	return error;
810 }
811 
812 /*
813  * tmpfs_rename: rename routine.
814  *
815  * Arguments: fdvp (from-parent vnode), fvp (from-leaf), tdvp (to-parent)
816  * and tvp (to-leaf), if exists (NULL if not).
817  *
818  * => Caller holds a reference on fdvp and fvp, they are unlocked.
819  *    Note: fdvp and fvp can refer to the same object (i.e. when it is root).
820  *
821  * => Both tdvp and tvp are referenced and locked.  It is our responsibility
822  *    to release the references and unlock them (or destroy).
823  */
824 int
825 tmpfs_rename(void *v)
826 {
827 	struct vnode *fdvp = ((struct vop_rename_args *)v)->a_fdvp;
828 	struct vnode *fvp = ((struct vop_rename_args *)v)->a_fvp;
829 	struct componentname *fcnp = ((struct vop_rename_args *)v)->a_fcnp;
830 	struct vnode *tdvp = ((struct vop_rename_args *)v)->a_tdvp;
831 	struct vnode *tvp = ((struct vop_rename_args *)v)->a_tvp;
832 	struct componentname *tcnp = ((struct vop_rename_args *)v)->a_tcnp;
833 
834 	char *newname;
835 	int error;
836 	struct tmpfs_dirent *de, *de2;
837 	struct tmpfs_mount *tmp;
838 	struct tmpfs_node *fdnode;
839 	struct tmpfs_node *fnode;
840 	struct tmpfs_node *tnode;
841 	struct tmpfs_node *tdnode;
842 	size_t namelen;
843 
844 	KASSERT(VOP_ISLOCKED(tdvp));
845 	KASSERT(IMPLIES(tvp != NULL, VOP_ISLOCKED(tvp) == LK_EXCLUSIVE));
846 	KASSERT(fcnp->cn_flags & HASBUF);
847 	KASSERT(tcnp->cn_flags & HASBUF);
848 
849 	newname = NULL;
850 	namelen = 0;
851 	tmp = NULL;
852 
853 	/* Disallow cross-device renames. */
854 	if (fvp->v_mount != tdvp->v_mount ||
855 	    (tvp != NULL && fvp->v_mount != tvp->v_mount)) {
856 		error = EXDEV;
857 		goto out_unlocked;
858 	}
859 
860 	fnode = VP_TO_TMPFS_NODE(fvp);
861 	fdnode = VP_TO_TMPFS_DIR(fdvp);
862 	tnode = (tvp == NULL) ? NULL : VP_TO_TMPFS_NODE(tvp);
863 	tdnode = VP_TO_TMPFS_DIR(tdvp);
864 	tmp = VFS_TO_TMPFS(tdvp->v_mount);
865 
866 	if (fdvp == tvp) {
867 		error = 0;
868 		goto out_unlocked;
869 	}
870 
871 	/* If we need to move the directory between entries, lock the
872 	 * source so that we can safely operate on it. */
873 
874 	/* XXX: this is a potential locking order violation! */
875 	if (fdnode != tdnode) {
876 		vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY);
877 	}
878 
879 	/*
880 	 * If the node we were renaming has scarpered, just give up.
881 	 */
882 	de = tmpfs_dir_lookup(fdnode, fcnp);
883 	if (de == NULL || de->td_node != fnode) {
884 		error = ENOENT;
885 		goto out;
886 	}
887 
888 	/* If source and target is the same vnode, remove the source link. */
889 	if (fvp == tvp) {
890 		/*
891 		 * Detach and free the directory entry.  Drops the link
892 		 * count on the node.
893 		 */
894 		tmpfs_dir_detach(fdvp, de);
895 		tmpfs_free_dirent(VFS_TO_TMPFS(fvp->v_mount), de, true);
896 		VN_KNOTE(fdvp, NOTE_WRITE);
897 		goto out_ok;
898 	}
899 
900 	/* If replacing an existing entry, ensure we can do the operation. */
901 	if (tvp != NULL) {
902 		KASSERT(tnode != NULL);
903 		if (fnode->tn_type == VDIR && tnode->tn_type == VDIR) {
904 			if (tnode->tn_size > 0) {
905 				error = ENOTEMPTY;
906 				goto out;
907 			}
908 		} else if (fnode->tn_type == VDIR && tnode->tn_type != VDIR) {
909 			error = ENOTDIR;
910 			goto out;
911 		} else if (fnode->tn_type != VDIR && tnode->tn_type == VDIR) {
912 			error = EISDIR;
913 			goto out;
914 		} else {
915 			KASSERT(fnode->tn_type != VDIR &&
916 			        tnode->tn_type != VDIR);
917 		}
918 	}
919 
920 	/* Ensure that we have enough memory to hold the new name, if it
921 	 * has to be changed. */
922 	namelen = tcnp->cn_namelen;
923 	if (fcnp->cn_namelen != tcnp->cn_namelen ||
924 	    memcmp(fcnp->cn_nameptr, tcnp->cn_nameptr, fcnp->cn_namelen) != 0) {
925 		newname = tmpfs_str_pool_get(&tmp->tm_str_pool, namelen, 0);
926 		if (newname == NULL) {
927 			error = ENOSPC;
928 			goto out;
929 		}
930 	}
931 
932 	/* If the node is being moved to another directory, we have to do
933 	 * the move. */
934 	if (fdnode != tdnode) {
935 		/* In case we are moving a directory, we have to adjust its
936 		 * parent to point to the new parent. */
937 		if (de->td_node->tn_type == VDIR) {
938 			struct tmpfs_node *n;
939 
940 			/* Ensure the target directory is not a child of the
941 			 * directory being moved.  Otherwise, we'd end up
942 			 * with stale nodes. */
943 			n = tdnode;
944 			while (n != n->tn_spec.tn_dir.tn_parent) {
945 				if (n == fnode) {
946 					error = EINVAL;
947 					goto out;
948 				}
949 				n = n->tn_spec.tn_dir.tn_parent;
950 			}
951 
952 			/* Adjust the parent pointer. */
953 			TMPFS_VALIDATE_DIR(fnode);
954 			de->td_node->tn_spec.tn_dir.tn_parent = tdnode;
955 
956 			/* As a result of changing the target of the '..'
957 			 * entry, the link count of the source and target
958 			 * directories has to be adjusted. */
959 			fdnode->tn_links--;
960 			tdnode->tn_links++;
961 		}
962 
963 		/* Do the move: just remove the entry from the source directory
964 		 * and insert it into the target one. */
965 		tmpfs_dir_detach(fdvp, de);
966 		tmpfs_dir_attach(tdvp, de);
967 
968 		/* Notify listeners of fdvp about the change in the directory.
969 		 * We can do it at this point because we aren't touching fdvp
970 		 * any more below. */
971 		VN_KNOTE(fdvp, NOTE_WRITE);
972 	}
973 
974 	/* If we are overwriting an entry, we have to remove the old one
975 	 * from the target directory. */
976 	if (tvp != NULL) {
977 		KASSERT(tnode != NULL);
978 
979 		/* Remove the old entry from the target directory.
980 		 * Note! This relies on tmpfs_dir_attach() putting the new
981 		 * node on the end of the target's node list. */
982 		de2 = tmpfs_dir_lookup(tdnode, tcnp);
983 		KASSERT(de2 != NULL);
984 		KASSERT(de2->td_node == tnode);
985 		tmpfs_dir_detach(tdvp, de2);
986 
987 		/* Free the directory entry we just deleted.  Note that the
988 		 * node referred by it will not be removed until the vnode is
989 		 * really reclaimed. */
990 		tmpfs_free_dirent(VFS_TO_TMPFS(tvp->v_mount), de2, true);
991 	}
992 
993 	/* If the name has changed, we need to make it effective by changing
994 	 * it in the directory entry. */
995 	if (newname != NULL) {
996 		KASSERT(tcnp->cn_namelen < MAXNAMLEN);
997 		KASSERT(tcnp->cn_namelen < 0xffff);
998 
999 		tmpfs_str_pool_put(&tmp->tm_str_pool, de->td_name,
1000 		    de->td_namelen);
1001 		de->td_namelen = (uint16_t)namelen;
1002 		memcpy(newname, tcnp->cn_nameptr, namelen);
1003 		de->td_name = newname;
1004 		newname = NULL;
1005 
1006 		fnode->tn_status |= TMPFS_NODE_CHANGED;
1007 		tdnode->tn_status |= TMPFS_NODE_MODIFIED;
1008 	}
1009  out_ok:
1010 	/* Notify listeners of tdvp about the change in the directory (either
1011 	 * because a new entry was added or because one was removed) and
1012 	 * listeners of fvp about the rename. */
1013 	VN_KNOTE(tdvp, NOTE_WRITE);
1014 	VN_KNOTE(fvp, NOTE_RENAME);
1015 
1016 	error = 0;
1017 
1018  out:
1019 	if (fdnode != tdnode)
1020 		VOP_UNLOCK(fdvp, 0);
1021 
1022  out_unlocked:
1023 	/* Release target nodes. */
1024 	if (tdvp == tvp)
1025 		vrele(tdvp);
1026 	else
1027 		vput(tdvp);
1028 	if (tvp != NULL)
1029 		vput(tvp);
1030 
1031 	/* Release source nodes. */
1032 	vrele(fdvp);
1033 	vrele(fvp);
1034 
1035 	if (newname != NULL)
1036 		tmpfs_str_pool_put(&tmp->tm_str_pool, newname, namelen);
1037 
1038 	return error;
1039 }
1040 
1041 /* --------------------------------------------------------------------- */
1042 
1043 int
1044 tmpfs_mkdir(void *v)
1045 {
1046 	struct vnode *dvp = ((struct vop_mkdir_args *)v)->a_dvp;
1047 	struct vnode **vpp = ((struct vop_mkdir_args *)v)->a_vpp;
1048 	struct componentname *cnp = ((struct vop_mkdir_args *)v)->a_cnp;
1049 	struct vattr *vap = ((struct vop_mkdir_args *)v)->a_vap;
1050 
1051 	KASSERT(vap->va_type == VDIR);
1052 
1053 	return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
1054 }
1055 
1056 /* --------------------------------------------------------------------- */
1057 
1058 int
1059 tmpfs_rmdir(void *v)
1060 {
1061 	struct vnode *dvp = ((struct vop_rmdir_args *)v)->a_dvp;
1062 	struct vnode *vp = ((struct vop_rmdir_args *)v)->a_vp;
1063 	struct componentname *cnp = ((struct vop_rmdir_args *)v)->a_cnp;
1064 
1065 	int error;
1066 	struct tmpfs_dirent *de;
1067 	struct tmpfs_mount *tmp;
1068 	struct tmpfs_node *dnode;
1069 	struct tmpfs_node *node;
1070 
1071 	KASSERT(VOP_ISLOCKED(dvp));
1072 	KASSERT(VOP_ISLOCKED(vp));
1073 
1074 	tmp = VFS_TO_TMPFS(dvp->v_mount);
1075 	dnode = VP_TO_TMPFS_DIR(dvp);
1076 	node = VP_TO_TMPFS_DIR(vp);
1077 	error = 0;
1078 
1079 	/* Directories with more than two entries ('.' and '..') cannot be
1080 	 * removed. */
1081 	if (node->tn_size > 0) {
1082 		error = ENOTEMPTY;
1083 		goto out;
1084 	}
1085 
1086 	/* This invariant holds only if we are not trying to remove "..".
1087 	 * We checked for that above so this is safe now. */
1088 	KASSERT(node->tn_spec.tn_dir.tn_parent == dnode);
1089 
1090 	/* Get the directory entry associated with node (vp). */
1091 	de = tmpfs_dir_lookup(dnode, cnp);
1092 	KASSERT(de);
1093 	KASSERT(de->td_node == node);
1094 
1095 	/* Check flags to see if we are allowed to remove the directory. */
1096 	if (dnode->tn_flags & APPEND || node->tn_flags & (IMMUTABLE | APPEND)) {
1097 		error = EPERM;
1098 		goto out;
1099 	}
1100 
1101 	/* Detach the directory entry from the directory (dnode). */
1102 	tmpfs_dir_detach(dvp, de);
1103 
1104 	node->tn_links--;
1105 	node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED | \
1106 	    TMPFS_NODE_MODIFIED;
1107 	node->tn_spec.tn_dir.tn_parent->tn_links--;
1108 	node->tn_spec.tn_dir.tn_parent->tn_status |= TMPFS_NODE_ACCESSED | \
1109 	    TMPFS_NODE_CHANGED | TMPFS_NODE_MODIFIED;
1110 
1111 	/* Release the parent. */
1112 	cache_purge(dvp); /* XXX Is this needed? */
1113 
1114 	/* Free the directory entry we just deleted.  Note that the node
1115 	 * referred by it will not be removed until the vnode is really
1116 	 * reclaimed. */
1117 	tmpfs_free_dirent(tmp, de, true);
1118 
1119 	KASSERT(node->tn_links == 0);
1120  out:
1121 	/* Release the nodes. */
1122 	vput(dvp);
1123 	vput(vp);
1124 	PNBUF_PUT(cnp->cn_pnbuf);
1125 
1126 	return error;
1127 }
1128 
1129 /* --------------------------------------------------------------------- */
1130 
1131 int
1132 tmpfs_symlink(void *v)
1133 {
1134 	struct vnode *dvp = ((struct vop_symlink_args *)v)->a_dvp;
1135 	struct vnode **vpp = ((struct vop_symlink_args *)v)->a_vpp;
1136 	struct componentname *cnp = ((struct vop_symlink_args *)v)->a_cnp;
1137 	struct vattr *vap = ((struct vop_symlink_args *)v)->a_vap;
1138 	char *target = ((struct vop_symlink_args *)v)->a_target;
1139 
1140 	KASSERT(vap->va_type == VLNK);
1141 
1142 	return tmpfs_alloc_file(dvp, vpp, vap, cnp, target);
1143 }
1144 
1145 /* --------------------------------------------------------------------- */
1146 
1147 int
1148 tmpfs_readdir(void *v)
1149 {
1150 	struct vnode *vp = ((struct vop_readdir_args *)v)->a_vp;
1151 	struct uio *uio = ((struct vop_readdir_args *)v)->a_uio;
1152 	int *eofflag = ((struct vop_readdir_args *)v)->a_eofflag;
1153 	off_t **cookies = ((struct vop_readdir_args *)v)->a_cookies;
1154 	int *ncookies = ((struct vop_readdir_args *)v)->a_ncookies;
1155 
1156 	int error;
1157 	off_t startoff;
1158 	off_t cnt;
1159 	struct tmpfs_node *node;
1160 
1161 	KASSERT(VOP_ISLOCKED(vp));
1162 
1163 	/* This operation only makes sense on directory nodes. */
1164 	if (vp->v_type != VDIR) {
1165 		error = ENOTDIR;
1166 		goto out;
1167 	}
1168 
1169 	node = VP_TO_TMPFS_DIR(vp);
1170 
1171 	startoff = uio->uio_offset;
1172 
1173 	cnt = 0;
1174 	if (uio->uio_offset == TMPFS_DIRCOOKIE_DOT) {
1175 		error = tmpfs_dir_getdotdent(node, uio);
1176 		if (error == -1) {
1177 			error = 0;
1178 			goto outok;
1179 		} else if (error != 0)
1180 			goto outok;
1181 		cnt++;
1182 	}
1183 
1184 	if (uio->uio_offset == TMPFS_DIRCOOKIE_DOTDOT) {
1185 		error = tmpfs_dir_getdotdotdent(node, uio);
1186 		if (error == -1) {
1187 			error = 0;
1188 			goto outok;
1189 		} else if (error != 0)
1190 			goto outok;
1191 		cnt++;
1192 	}
1193 
1194 	error = tmpfs_dir_getdents(node, uio, &cnt);
1195 	if (error == -1)
1196 		error = 0;
1197 	KASSERT(error >= 0);
1198 
1199 outok:
1200 	/* This label assumes that startoff has been
1201 	 * initialized.  If the compiler didn't spit out warnings, we'd
1202 	 * simply make this one be 'out' and drop 'outok'. */
1203 
1204 	if (eofflag != NULL)
1205 		*eofflag =
1206 		    (error == 0 && uio->uio_offset == TMPFS_DIRCOOKIE_EOF);
1207 
1208 	/* Update NFS-related variables. */
1209 	if (error == 0 && cookies != NULL && ncookies != NULL) {
1210 		off_t i;
1211 		off_t off = startoff;
1212 		struct tmpfs_dirent *de = NULL;
1213 
1214 		*ncookies = cnt;
1215 		*cookies = malloc(cnt * sizeof(off_t), M_TEMP, M_WAITOK);
1216 
1217 		for (i = 0; i < cnt; i++) {
1218 			KASSERT(off != TMPFS_DIRCOOKIE_EOF);
1219 			if (off == TMPFS_DIRCOOKIE_DOT) {
1220 				off = TMPFS_DIRCOOKIE_DOTDOT;
1221 			} else {
1222 				if (off == TMPFS_DIRCOOKIE_DOTDOT) {
1223 					de = TAILQ_FIRST(&node->tn_spec.
1224 					    tn_dir.tn_dir);
1225 				} else if (de != NULL) {
1226 					de = TAILQ_NEXT(de, td_entries);
1227 				} else {
1228 					de = tmpfs_dir_lookupbycookie(node,
1229 					    off);
1230 					KASSERT(de != NULL);
1231 					de = TAILQ_NEXT(de, td_entries);
1232 				}
1233 				if (de == NULL) {
1234 					off = TMPFS_DIRCOOKIE_EOF;
1235 				} else {
1236 					off = tmpfs_dircookie(de);
1237 				}
1238 			}
1239 
1240 			(*cookies)[i] = off;
1241 		}
1242 		KASSERT(uio->uio_offset == off);
1243 	}
1244 
1245 out:
1246 	KASSERT(VOP_ISLOCKED(vp));
1247 
1248 	return error;
1249 }
1250 
1251 /* --------------------------------------------------------------------- */
1252 
1253 int
1254 tmpfs_readlink(void *v)
1255 {
1256 	struct vnode *vp = ((struct vop_readlink_args *)v)->a_vp;
1257 	struct uio *uio = ((struct vop_readlink_args *)v)->a_uio;
1258 
1259 	int error;
1260 	struct tmpfs_node *node;
1261 
1262 	KASSERT(VOP_ISLOCKED(vp));
1263 	KASSERT(uio->uio_offset == 0);
1264 	KASSERT(vp->v_type == VLNK);
1265 
1266 	node = VP_TO_TMPFS_NODE(vp);
1267 
1268 	error = uiomove(node->tn_spec.tn_lnk.tn_link,
1269 	    MIN(node->tn_size, uio->uio_resid), uio);
1270 	node->tn_status |= TMPFS_NODE_ACCESSED;
1271 
1272 	KASSERT(VOP_ISLOCKED(vp));
1273 
1274 	return error;
1275 }
1276 
1277 /* --------------------------------------------------------------------- */
1278 
1279 int
1280 tmpfs_inactive(void *v)
1281 {
1282 	struct vnode *vp = ((struct vop_inactive_args *)v)->a_vp;
1283 
1284 	struct tmpfs_node *node;
1285 
1286 	KASSERT(VOP_ISLOCKED(vp));
1287 
1288 	node = VP_TO_TMPFS_NODE(vp);
1289 	*((struct vop_inactive_args *)v)->a_recycle = (node->tn_links == 0);
1290 	VOP_UNLOCK(vp, 0);
1291 
1292 	return 0;
1293 }
1294 
1295 /* --------------------------------------------------------------------- */
1296 
1297 int
1298 tmpfs_reclaim(void *v)
1299 {
1300 	struct vnode *vp = ((struct vop_reclaim_args *)v)->a_vp;
1301 
1302 	struct tmpfs_mount *tmp;
1303 	struct tmpfs_node *node;
1304 
1305 	node = VP_TO_TMPFS_NODE(vp);
1306 	tmp = VFS_TO_TMPFS(vp->v_mount);
1307 
1308 	cache_purge(vp);
1309 	tmpfs_free_vp(vp);
1310 
1311 	/* If the node referenced by this vnode was deleted by the user,
1312 	 * we must free its associated data structures (now that the vnode
1313 	 * is being reclaimed). */
1314 	if (node->tn_links == 0)
1315 		tmpfs_free_node(tmp, node);
1316 
1317 	KASSERT(vp->v_data == NULL);
1318 
1319 	return 0;
1320 }
1321 
1322 /* --------------------------------------------------------------------- */
1323 
1324 int
1325 tmpfs_print(void *v)
1326 {
1327 	struct vnode *vp = ((struct vop_print_args *)v)->a_vp;
1328 
1329 	struct tmpfs_node *node;
1330 
1331 	node = VP_TO_TMPFS_NODE(vp);
1332 
1333 	printf("tag VT_TMPFS, tmpfs_node %p, flags 0x%x, links %d\n",
1334 	    node, node->tn_flags, node->tn_links);
1335 	printf("\tmode 0%o, owner %d, group %d, size %" PRIdMAX
1336 	    ", status 0x%x\n",
1337 	    node->tn_mode, node->tn_uid, node->tn_gid,
1338 	    (uintmax_t)node->tn_size, node->tn_status);
1339 	if (vp->v_type == VFIFO)
1340 		fifo_printinfo(vp);
1341 	printf("\n");
1342 
1343 	return 0;
1344 }
1345 
1346 /* --------------------------------------------------------------------- */
1347 
1348 int
1349 tmpfs_pathconf(void *v)
1350 {
1351 	int name = ((struct vop_pathconf_args *)v)->a_name;
1352 	register_t *retval = ((struct vop_pathconf_args *)v)->a_retval;
1353 
1354 	int error;
1355 
1356 	error = 0;
1357 
1358 	switch (name) {
1359 	case _PC_LINK_MAX:
1360 		*retval = LINK_MAX;
1361 		break;
1362 
1363 	case _PC_NAME_MAX:
1364 		*retval = NAME_MAX;
1365 		break;
1366 
1367 	case _PC_PATH_MAX:
1368 		*retval = PATH_MAX;
1369 		break;
1370 
1371 	case _PC_PIPE_BUF:
1372 		*retval = PIPE_BUF;
1373 		break;
1374 
1375 	case _PC_CHOWN_RESTRICTED:
1376 		*retval = 1;
1377 		break;
1378 
1379 	case _PC_NO_TRUNC:
1380 		*retval = 1;
1381 		break;
1382 
1383 	case _PC_SYNC_IO:
1384 		*retval = 1;
1385 		break;
1386 
1387 	case _PC_FILESIZEBITS:
1388 		*retval = 0; /* XXX Don't know which value should I return. */
1389 		break;
1390 
1391 	default:
1392 		error = EINVAL;
1393 	}
1394 
1395 	return error;
1396 }
1397 
1398 /* --------------------------------------------------------------------- */
1399 
1400 int
1401 tmpfs_advlock(void *v)
1402 {
1403 	struct vnode *vp = ((struct vop_advlock_args *)v)->a_vp;
1404 
1405 	struct tmpfs_node *node;
1406 
1407 	node = VP_TO_TMPFS_NODE(vp);
1408 
1409 	return lf_advlock(v, &node->tn_lockf, node->tn_size);
1410 }
1411 
1412 /* --------------------------------------------------------------------- */
1413 
1414 int
1415 tmpfs_getpages(void *v)
1416 {
1417 	struct vnode *vp = ((struct vop_getpages_args *)v)->a_vp;
1418 	voff_t offset = ((struct vop_getpages_args *)v)->a_offset;
1419 	struct vm_page **m = ((struct vop_getpages_args *)v)->a_m;
1420 	int *count = ((struct vop_getpages_args *)v)->a_count;
1421 	int centeridx = ((struct vop_getpages_args *)v)->a_centeridx;
1422 	vm_prot_t access_type = ((struct vop_getpages_args *)v)->a_access_type;
1423 	int advice = ((struct vop_getpages_args *)v)->a_advice;
1424 	int flags = ((struct vop_getpages_args *)v)->a_flags;
1425 
1426 	int error;
1427 	int i;
1428 	struct tmpfs_node *node;
1429 	struct uvm_object *uobj;
1430 	int npages = *count;
1431 
1432 	KASSERT(vp->v_type == VREG);
1433 	KASSERT(mutex_owned(&vp->v_interlock));
1434 
1435 	node = VP_TO_TMPFS_NODE(vp);
1436 	uobj = node->tn_spec.tn_reg.tn_aobj;
1437 
1438 	/* We currently don't rely on PGO_PASTEOF. */
1439 
1440 	if (vp->v_size <= offset + (centeridx << PAGE_SHIFT)) {
1441 		if ((flags & PGO_LOCKED) == 0)
1442 			mutex_exit(&vp->v_interlock);
1443 		return EINVAL;
1444 	}
1445 
1446 	if (vp->v_size < offset + (npages << PAGE_SHIFT)) {
1447 		npages = (round_page(vp->v_size) - offset) >> PAGE_SHIFT;
1448 	}
1449 
1450 	if ((flags & PGO_LOCKED) != 0)
1451 		return EBUSY;
1452 
1453 	if ((flags & PGO_NOTIMESTAMP) == 0) {
1454 		if ((vp->v_mount->mnt_flag & MNT_NOATIME) == 0)
1455 			node->tn_status |= TMPFS_NODE_ACCESSED;
1456 
1457 		if ((access_type & VM_PROT_WRITE) != 0)
1458 			node->tn_status |= TMPFS_NODE_MODIFIED;
1459 	}
1460 
1461 	mutex_exit(&vp->v_interlock);
1462 
1463 	/*
1464 	 * Make sure that the array on which we will store the
1465 	 * gotten pages is clean.  Otherwise uao_get (pointed to by
1466 	 * the pgo_get below) gets confused and does not return the
1467 	 * appropriate pages.
1468 	 *
1469 	 * XXX This shall be revisited when kern/32166 is addressed
1470 	 * because the loop to clean m[i] will most likely be redundant
1471 	 * as well as the PGO_ALLPAGES flag.
1472 	 */
1473 	if (m != NULL)
1474 		for (i = 0; i < npages; i++)
1475 			m[i] = NULL;
1476 	mutex_enter(&uobj->vmobjlock);
1477 	error = (*uobj->pgops->pgo_get)(uobj, offset, m, &npages, centeridx,
1478 	    access_type, advice, flags | PGO_ALLPAGES);
1479 #if defined(DEBUG)
1480 	{
1481 		/* Make sure that all the pages we return are valid. */
1482 		int dbgi;
1483 		if (error == 0 && m != NULL)
1484 			for (dbgi = 0; dbgi < npages; dbgi++)
1485 				KASSERT(m[dbgi] != NULL);
1486 	}
1487 #endif
1488 
1489 	return error;
1490 }
1491 
1492 /* --------------------------------------------------------------------- */
1493 
1494 int
1495 tmpfs_putpages(void *v)
1496 {
1497 	struct vnode *vp = ((struct vop_putpages_args *)v)->a_vp;
1498 	voff_t offlo = ((struct vop_putpages_args *)v)->a_offlo;
1499 	voff_t offhi = ((struct vop_putpages_args *)v)->a_offhi;
1500 	int flags = ((struct vop_putpages_args *)v)->a_flags;
1501 
1502 	int error;
1503 	struct tmpfs_node *node;
1504 	struct uvm_object *uobj;
1505 
1506 	KASSERT(mutex_owned(&vp->v_interlock));
1507 
1508 	node = VP_TO_TMPFS_NODE(vp);
1509 
1510 	if (vp->v_type != VREG) {
1511 		mutex_exit(&vp->v_interlock);
1512 		return 0;
1513 	}
1514 
1515 	uobj = node->tn_spec.tn_reg.tn_aobj;
1516 	mutex_exit(&vp->v_interlock);
1517 
1518 	mutex_enter(&uobj->vmobjlock);
1519 	error = (*uobj->pgops->pgo_put)(uobj, offlo, offhi, flags);
1520 
1521 	/* XXX mtime */
1522 
1523 	return error;
1524 }
1525