 @@ -1,17 +1,17 @@
-/*	$NetBSD: tmpfs.h,v 1.55 2018/04/19 21:50:09 christos Exp $	*/
+/*	$NetBSD: tmpfs.h,v 1.56 2020/05/17 19:39:15 ad Exp $	*/
 /*
- * Copyright (c) 2005, 2006, 2007 The NetBSD Foundation, Inc.
+ * Copyright (c) 2005, 2006, 2007, 2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Julio M. Merino Vidal, developed as part of Google's Summer of Code
  * 2005 program.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -102,30 +102,32 @@ typedef struct tmpfs_node {
 	/* Inode identifier and generation number. */
 	ino_t			tn_id;
 	uint32_t		tn_gen;
 	/* The inode size. */
 	off_t			tn_size;
 	/* Generic node attributes. */
 	uid_t			tn_uid;
 	gid_t			tn_gid;
 	mode_t			tn_mode;
 	int			tn_flags;
 	nlink_t			tn_links;
 	unsigned		tn_tflags;
 	struct timespec		tn_atime;
 	struct timespec		tn_mtime;
 	struct timespec		tn_ctime;
 	struct timespec		tn_birthtime;
 	kmutex_t		tn_timelock;
 	/* Head of byte-level lock list (used by tmpfs_advlock). */
 	struct lockf *		tn_lockf;
 	union {
 		/* Type case: VBLK or VCHR. */
 		struct {
 			dev_t			tn_rdev;
 		} tn_dev;
 		/* Type case: VDIR. */
 		struct {
 			/* Parent directory (root inode points to itself). */
 @@ -264,26 +266,28 @@ uint32_t	tmpfs_dir_getseq(tmpfs_node_t *
 tmpfs_dirent_t *tmpfs_dir_lookupbyseq(tmpfs_node_t *, off_t);
 int		tmpfs_dir_getdents(tmpfs_node_t *, struct uio *, off_t *);
 int		tmpfs_reg_resize(vnode_t *, off_t);
 int		tmpfs_chflags(vnode_t *, int, kauth_cred_t, lwp_t *);
 int		tmpfs_chmod(vnode_t *, mode_t, kauth_cred_t, lwp_t *);
 int		tmpfs_chown(vnode_t *, uid_t, gid_t, kauth_cred_t, lwp_t *);
 int		tmpfs_chsize(vnode_t *, u_quad_t, kauth_cred_t, lwp_t *);
 int		tmpfs_chtimes(vnode_t *, const struct timespec *,
 		    const struct timespec *, const struct timespec *, int,
 		    kauth_cred_t, lwp_t *);
 void		tmpfs_update(vnode_t *, unsigned);
 void		tmpfs_update_locked(vnode_t *, unsigned);
 void		tmpfs_update_lazily(vnode_t *, unsigned);
 /*
  * Prototypes for tmpfs_mem.c.
  */
 void		tmpfs_mntmem_init(tmpfs_mount_t *, uint64_t);
 void		tmpfs_mntmem_destroy(tmpfs_mount_t *);
 int		tmpfs_mntmem_set(tmpfs_mount_t *, uint64_t);
 size_t		tmpfs_mem_info(bool);
 uint64_t	tmpfs_bytes_max(tmpfs_mount_t *);
 size_t		tmpfs_pages_avail(tmpfs_mount_t *);
 bool		tmpfs_mem_incr(tmpfs_mount_t *, size_t);

 @@ -1,17 +1,17 @@
-/*	$NetBSD: tmpfs_subr.c,v 1.111 2020/05/16 18:31:49 christos Exp $	*/
+/*	$NetBSD: tmpfs_subr.c,v 1.112 2020/05/17 19:39:15 ad Exp $	*/
 /*
- * Copyright (c) 2005-2013 The NetBSD Foundation, Inc.
+ * Copyright (c) 2005-2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Julio M. Merino Vidal, developed as part of Google's Summer of Code
  * 2005 program, and by Mindaugas Rasiukevicius.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -63,27 +63,27 @@
+ *
  *	If an inode has references within the file system (tn_links > 0) and
  *	its inactive vnode gets reclaimed/recycled - then the association is
  *	broken in tmpfs_reclaim().  In such case, an inode will always pass
  *	tmpfs_lookup() and thus vcache_get() to associate a new vnode.
+ *
  * Lock order
+ *
  *	vnode_t::v_vlock ->
  *		vnode_t::v_interlock
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: tmpfs_subr.c,v 1.111 2020/05/16 18:31:49 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: tmpfs_subr.c,v 1.112 2020/05/17 19:39:15 ad Exp $");
 #include <sys/param.h>
 #include <sys/cprng.h>
 #include <sys/dirent.h>
 #include <sys/event.h>
 #include <sys/kmem.h>
 #include <sys/mount.h>
 #include <sys/namei.h>
 #include <sys/time.h>
 #include <sys/stat.h>
 #include <sys/systm.h>
 #include <sys/vnode.h>
 #include <sys/kauth.h>
 @@ -220,30 +220,32 @@ tmpfs_newvnode(struct mount *mp, struct
 	 * tmpfs_inactive() uses generation zero to mark dead nodes.
 	 */
 	do {
 		node->tn_gen = TMPFS_NODE_GEN_MASK & cprng_fast32();
 	} while (node->tn_gen == 0);
 	/* Generic initialization. */
 	KASSERT((int)vap->va_type != VNOVAL);
 	node->tn_type = vap->va_type;
 	node->tn_size = 0;
 	node->tn_flags = 0;
 	node->tn_lockf = NULL;
 	node->tn_tflags = 0;
 	vfs_timestamp(&node->tn_atime);
 	node->tn_birthtime = node->tn_atime;
 	node->tn_ctime = node->tn_atime;
 	node->tn_mtime = node->tn_atime;
 	mutex_init(&node->tn_timelock, MUTEX_DEFAULT, IPL_NONE);
 	if (dvp == NULL) {
 		KASSERT(vap->va_uid != VNOVAL && vap->va_gid != VNOVAL);
 		node->tn_uid = vap->va_uid;
 		node->tn_gid = vap->va_gid;
 		vp->v_vflag |= VV_ROOT;
 	} else {
 		KASSERT(dnode != NULL);
 		node->tn_uid = kauth_cred_geteuid(cred);
 		node->tn_gid = dnode->tn_gid;
+	}
 	KASSERT(vap->va_mode != VNOVAL);
 	node->tn_mode = vap->va_mode;
 @@ -340,26 +342,27 @@ tmpfs_free_node(tmpfs_mount_t *tmp, tmpf
 	case VDIR:
 		KASSERT(node->tn_size == 0);
 		KASSERT(node->tn_spec.tn_dir.tn_seq_arena == NULL);
 		KASSERT(TAILQ_EMPTY(&node->tn_spec.tn_dir.tn_dir));
 		KASSERT(node->tn_spec.tn_dir.tn_parent == NULL ||
 		    node == tmp->tm_root);
 		break;
 	default:
 		break;
+	}
 	KASSERT(node->tn_vnode == NULL);
 	KASSERT(node->tn_links == 0);
 	mutex_destroy(&node->tn_timelock);
 	tmpfs_node_put(tmp, node);
+}
 /*
  * tmpfs_construct_node: allocate a new file of specified type and adds it
  * into the parent directory.
+ *
  * => Credentials of the caller are used.
  */
 int
 tmpfs_construct_node(vnode_t *dvp, vnode_t **vpp, struct vattr *vap,
     struct componentname *cnp, char *target)
+{
 @@ -1157,50 +1160,89 @@ tmpfs_chtimes(vnode_t *vp, const struct
 	/* Disallow this operation if the file system is mounted read-only. */
 	if (vp->v_mount->mnt_flag & MNT_RDONLY)
 		return EROFS;
 	/* Immutable or append-only files cannot be modified, either. */
 	if (node->tn_flags & (IMMUTABLE | APPEND))
 		return EPERM;
 	error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_TIMES, vp, NULL,
 	    genfs_can_chtimes(vp, cred, node->tn_uid, vaflags));
 	if (error)
 		return error;
 	mutex_enter(&node->tn_timelock);
 	if (atime->tv_sec != VNOVAL) {
 		atomic_and_uint(&node->tn_tflags, ~TMPFS_UPDATE_ATIME);
 		node->tn_atime = *atime;
+	}
 	if (mtime->tv_sec != VNOVAL) {
 		atomic_and_uint(&node->tn_tflags, ~TMPFS_UPDATE_MTIME);
 		node->tn_mtime = *mtime;
+	}
 	if (btime->tv_sec != VNOVAL) {
 		node->tn_birthtime = *btime;
+	}
 	mutex_exit(&node->tn_timelock);
 	VN_KNOTE(vp, NOTE_ATTRIB);
 	return 0;
+}
 /*
- * tmpfs_update: update the timestamps as indicated by the flags.
+ * tmpfs_update_locked: update the timestamps as indicated by the flags.
  */
 void
-tmpfs_update(vnode_t *vp, unsigned tflags)
+tmpfs_update_locked(vnode_t *vp, unsigned tflags)
+{
 	tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp);
 	struct timespec nowtm;
-	if (tflags == 0) {
+	KASSERT(mutex_owned(&node->tn_timelock));
 	if ((tflags |= atomic_swap_uint(&node->tn_tflags, 0)) == 0) {
 		return;
+	}
 	vfs_timestamp(&nowtm);
 	if (tflags & TMPFS_UPDATE_ATIME) {
 		node->tn_atime = nowtm;
+	}
 	if (tflags & TMPFS_UPDATE_MTIME) {
 		node->tn_mtime = nowtm;
+	}
 	if (tflags & TMPFS_UPDATE_CTIME) {
 		node->tn_ctime = nowtm;
+	}
+}
 /*
  * tmpfs_update: update the timestamps as indicated by the flags.
  */
 void
 tmpfs_update(vnode_t *vp, unsigned tflags)
+{
 	tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp);
 	if ((tflags | atomic_load_relaxed(&node->tn_tflags)) == 0) {
 		return;
+	}
 	mutex_enter(&node->tn_timelock);
 	tmpfs_update_locked(vp, tflags);
 	mutex_exit(&node->tn_timelock);
+}
 /*
  * tmpfs_update_lazily: schedule a deferred timestamp update.
  */
 void
 tmpfs_update_lazily(vnode_t *vp, unsigned tflags)
+{
 	tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp);
 	unsigned cur;
 	cur = atomic_load_relaxed(&node->tn_tflags);
 	if ((cur & tflags) != tflags) {
 		atomic_or_uint(&node->tn_tflags, tflags);
 		return;
+	}
+}

 @@ -1,17 +1,17 @@
-/*	$NetBSD: tmpfs_vnops.c,v 1.138 2020/05/16 18:31:49 christos Exp $	*/
+/*	$NetBSD: tmpfs_vnops.c,v 1.139 2020/05/17 19:39:15 ad Exp $	*/
 /*
- * Copyright (c) 2005, 2006, 2007 The NetBSD Foundation, Inc.
+ * Copyright (c) 2005, 2006, 2007, 2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Julio M. Merino Vidal, developed as part of Google's Summer of Code
  * 2005 program.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -25,27 +25,27 @@
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * tmpfs vnode interface.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: tmpfs_vnops.c,v 1.138 2020/05/16 18:31:49 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: tmpfs_vnops.c,v 1.139 2020/05/17 19:39:15 ad Exp $");
 #include <sys/param.h>
 #include <sys/dirent.h>
 #include <sys/fcntl.h>
 #include <sys/event.h>
 #include <sys/malloc.h>
 #include <sys/namei.h>
 #include <sys/stat.h>
 #include <sys/uio.h>
 #include <sys/unistd.h>
 #include <sys/vnode.h>
 #include <sys/lockf.h>
 #include <sys/kauth.h>
 @@ -428,39 +428,43 @@ tmpfs_getattr(void *v)
 	tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp);
 	vattr_null(vap);
 	vap->va_type = vp->v_type;
 	vap->va_mode = node->tn_mode;
 	vap->va_nlink = node->tn_links;
 	vap->va_uid = node->tn_uid;
 	vap->va_gid = node->tn_gid;
 	vap->va_fsid = vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0];
 	vap->va_fileid = node->tn_id;
 	vap->va_size = node->tn_size;
 	vap->va_blocksize = PAGE_SIZE;
 	vap->va_atime = node->tn_atime;
 	vap->va_mtime = node->tn_mtime;
 	vap->va_ctime = node->tn_ctime;
 	vap->va_birthtime = node->tn_birthtime;
 	vap->va_gen = TMPFS_NODE_GEN(node);
 	vap->va_flags = node->tn_flags;
 	vap->va_rdev = (vp->v_type == VBLK || vp->v_type == VCHR) ?
 	    node->tn_spec.tn_dev.tn_rdev : VNOVAL;
 	vap->va_bytes = round_page(node->tn_size);
 	vap->va_filerev = VNOVAL;
 	vap->va_vaflags = 0;
 	vap->va_spare = VNOVAL; /* XXX */
 	mutex_enter(&node->tn_timelock);
 	tmpfs_update_locked(vp, 0);
 	vap->va_atime = node->tn_atime;
 	vap->va_mtime = node->tn_mtime;
 	vap->va_ctime = node->tn_ctime;
 	vap->va_birthtime = node->tn_birthtime;
 	mutex_exit(&node->tn_timelock);
 	return 0;
+}
 int
 tmpfs_setattr(void *v)
+{
 	struct vop_setattr_args /* {
 		struct vnode	*a_vp;
 		struct vattr	*a_vap;
 		kauth_cred_t	a_cred;
 	} */ *ap = v;
 	vnode_t *vp = ap->a_vp;
 	struct vattr *vap = ap->a_vap;
 @@ -651,27 +655,27 @@ tmpfs_fsync(void *v)
  * => We unlock and drop the reference on both.
  */
 int
 tmpfs_remove(void *v)
+{
 	struct vop_remove_v2_args /* {
 		struct vnode *a_dvp;
 		struct vnode *a_vp;
 		struct componentname *a_cnp;
 	} */ *ap = v;
 	vnode_t *dvp = ap->a_dvp, *vp = ap->a_vp;
 	tmpfs_node_t *dnode, *node;
 	tmpfs_dirent_t *de;
-	int error;
+	int error, tflags;
 	KASSERT(VOP_ISLOCKED(dvp));
 	KASSERT(VOP_ISLOCKED(vp));
 	if (vp->v_type == VDIR) {
 		error = EPERM;
 		goto out;
+	}
 	dnode = VP_TO_TMPFS_DIR(dvp);
 	node = VP_TO_TMPFS_NODE(vp);
 	/*
 	 * Files marked as immutable or append-only cannot be deleted.
 @@ -700,31 +704,32 @@ tmpfs_remove(void *v)
 	 * destroy it or replace with a whiteout.
+	 *
 	 * Note: the inode referred by it will not be destroyed until the
 	 * vnode is reclaimed/recycled.
 	 */
 	tmpfs_dir_detach(dnode, de);
 	if (ap->a_cnp->cn_flags & DOWHITEOUT)
 		tmpfs_dir_attach(dnode, de, TMPFS_NODE_WHITEOUT);
 	else
 		tmpfs_free_dirent(VFS_TO_TMPFS(vp->v_mount), de);
 	tflags = TMPFS_UPDATE_MTIME | TMPFS_UPDATE_CTIME;
 	if (node->tn_links > 0) {
 		/* We removed a hard link. */
-		tmpfs_update(vp, TMPFS_UPDATE_CTIME);
+		tflags |= TMPFS_UPDATE_CTIME;
+	}
-	tmpfs_update(dvp, TMPFS_UPDATE_MTIME | TMPFS_UPDATE_CTIME);
+	tmpfs_update(dvp, tflags);
 	error = 0;
 out:
 	/* Drop the reference and unlock the node. */
 	if (dvp == vp) {
 		vrele(vp);
 	} else {
 		vput(vp);
+	}
 	return error;
+}
 /*
  * tmpfs_link: create a hard link.
 @@ -1052,26 +1057,27 @@ tmpfs_inactive(void *v)
 		 */
 		atomic_and_32(&node->tn_gen, ~TMPFS_NODE_GEN_MASK);
 		/*
 		 * If the file has been deleted, truncate it, otherwise VFS
 		 * will quite rightly try to write back dirty data, which in
 		 * the case of tmpfs/UAO means needless page deactivations.
 		 */
 		if (vp->v_type == VREG) {
 			error = tmpfs_reg_resize(vp, 0);
+		}
 		*ap->a_recycle = true;
 	} else {
 		tmpfs_update(vp, 0);
 		*ap->a_recycle = false;
+	}
 	return error;
+}
 int
 tmpfs_reclaim(void *v)
+{
 	struct vop_reclaim_v2_args /* {
 		struct vnode *a_vp;
 	} */ *ap = v;
 	vnode_t *vp = ap->a_vp;
 @@ -1160,91 +1166,101 @@ tmpfs_getpages(void *v)
 		int *a_count;
 		int a_centeridx;
 		vm_prot_t a_access_type;
 		int a_advice;
 		int a_flags;
 	} */ * const ap = v;
 	vnode_t *vp = ap->a_vp;
 	const voff_t offset = ap->a_offset;
 	struct vm_page **pgs = ap->a_m;
 	const int centeridx = ap->a_centeridx;
 	const vm_prot_t access_type = ap->a_access_type;
 	const int advice = ap->a_advice;
 	const int flags = ap->a_flags;
-	int error, npages = *ap->a_count;
+	int error, iflag, npages = *ap->a_count;
 	tmpfs_node_t *node;
 	struct uvm_object *uobj;
 	KASSERT(vp->v_type == VREG);
 	KASSERT(rw_lock_held(vp->v_uobj.vmobjlock));
 	/*
 	 * Currently, PGO_PASTEOF is not supported.
 	 */
 	if (vp->v_size <= offset + (centeridx << PAGE_SHIFT)) {
 		if ((flags & PGO_LOCKED) == 0)
 			rw_exit(vp->v_uobj.vmobjlock);
 		return EINVAL;
+	}
 	if (vp->v_size < offset + (npages << PAGE_SHIFT)) {
 		npages = (round_page(vp->v_size) - offset) >> PAGE_SHIFT;
+	}
-	if ((flags & PGO_LOCKED) != 0)
+	/*
-		return EBUSY;
+	 * Check for reclaimed vnode.  v_interlock is not held here, but
 	 * VI_DEADCHECK is set with vmobjlock held.
-	mutex_enter(vp->v_interlock);
+	 */
-	error = vdead_check(vp, VDEAD_NOWAIT);
+	iflag = atomic_load_relaxed(&vp->v_iflag);
-	mutex_exit(vp->v_interlock);
+	if (__predict_false((iflag & VI_DEADCHECK) != 0) {
-	if (error != 0)
+		mutex_enter(vp->v_interlock);
-		return ENOENT;
+		error = vdead_check(vp, VDEAD_NOWAIT);
 		mutex_exit(vp->v_interlock);
 		if (error) {
 			if ((flags & PGO_LOCKED) == 0)
 				rw_exit(vp->v_uobj.vmobjlock);
 			return error;
+		}
+	}
 	node = VP_TO_TMPFS_NODE(vp);
 	uobj = node->tn_spec.tn_reg.tn_aobj;
 	/*
 	 * Update timestamp lazily.  The update will be made real when
 	 * a synchronous update is next made -- or by tmpfs_getattr,
 	 * tmpfs_putpages, and tmpfs_inactive.
 	 */
 	if ((flags & PGO_NOTIMESTAMP) == 0) {
 		u_int tflags = 0;
 		if ((vp->v_mount->mnt_flag & MNT_NOATIME) == 0)
 			tflags |= TMPFS_UPDATE_ATIME;
 		if ((access_type & VM_PROT_WRITE) != 0) {
 			tflags |= TMPFS_UPDATE_MTIME;
 			if (vp->v_mount->mnt_flag & MNT_RELATIME)
 				tflags |= TMPFS_UPDATE_ATIME;
+		}
-		tmpfs_update(vp, tflags);
+		tmpfs_update_lazily(vp, tflags);
+	}
 	/*
 	 * Invoke the pager.
+	 *
 	 * Clean the array of pages before.  XXX: PR/32166
 	 * Note that vnode lock is shared with underlying UVM object.
 	 */
-	if (pgs) {
+	if ((flags & PGO_LOCKED) == 0 && pgs) {
 		memset(pgs, 0, sizeof(struct vm_pages *) * npages);
+	}
 	KASSERT(vp->v_uobj.vmobjlock == uobj->vmobjlock);
 	error = (*uobj->pgops->pgo_get)(uobj, offset, pgs, &npages, centeridx,
-	    access_type, advice, flags | PGO_ALLPAGES);
+	    access_type, advice, flags);
 #if defined(DEBUG)
 	if (!error && pgs) {
-		for (int i = 0; i < npages; i++) {
+		KASSERT(pgs[centeridx] != NULL);
 			KASSERT(pgs[i] != NULL);
+	}
 #endif
 	return error;
+}
 int
 tmpfs_putpages(void *v)
+{
 	struct vop_putpages_args /* {
 		struct vnode *a_vp;
 		voff_t a_offlo;
 		voff_t a_offhi;
 		int a_flags;
 @@ -1262,26 +1278,28 @@ tmpfs_putpages(void *v)
 	if (vp->v_type != VREG) {
 		rw_exit(vp->v_uobj.vmobjlock);
 		return 0;
+	}
 	node = VP_TO_TMPFS_NODE(vp);
 	uobj = node->tn_spec.tn_reg.tn_aobj;
 	KASSERT(vp->v_uobj.vmobjlock == uobj->vmobjlock);
 	error = (*uobj->pgops->pgo_put)(uobj, offlo, offhi, flags);
 	/* XXX mtime */
 	/* Process deferred updates. */
 	tmpfs_update(vp, 0);
 	return error;
+}
 int
 tmpfs_whiteout(void *v)
+{
 	struct vop_whiteout_args /* {
 		struct vnode		*a_dvp;
 		struct componentname	*a_cnp;
 		int			a_flags;
 	} */ *ap = v;
 	vnode_t *dvp = ap->a_dvp;
 	struct componentname *cnp = ap->a_cnp;