Home | History | Annotate | Line # | Download | only in tmpfs
tmpfs_vnops.c revision 1.64
      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