int
tmpfs_vget(struct tmpfs_node *tn, struct vnode *vpp)
{
	struct vnode *vp = NULL, *vp0 = NULL;
	kmutex_t *interlock = NULL;	/* default */
	int error;

	/*
	 * Try to get an existing vnode for this tmpfs node.
	 */
	error = tmpfs_vnode_get(tn, &vp);
	KASSERT((vp == NULL) == (error == 0));
	if (error != ENOENT)
		goto out;

	/*
	 * There is none.  Create a new vnode for it instead.
	 */
	if (tn->tn_type == VREG)
		interlock = tn->tn_spec.tn_reg.tn_aobj->vmobjlock;
	error = getnewvnode(VT_TMPFS, mp, tmpfs_vnodeop_p, interlock, &vp);
	if (error) {
		KASSERT(vp == NULL);
		goto out;
	}

	/*
	 * Try to associate this vnode with the tmpfs node.  If someone
	 * else beat us to it, release ours and use theirs instead.
	 */
	error = tmpfs_vnode_intern(tn, vp, &vp0);
	KASSERT((vp0 == NULL) == (error == 0));
	if (vp0 != vp) {
		ungetnewvnode(vp);
		vp = vp0;
		goto out;
	}

	/*
	 * Initialize the new vnode.
	 */
	vp->v_type = tn->tn_type;
	switch (tn->tn_type) {
	case VBLK:
	case VCHR:
		vp->v_op = tmpfs_specop_p;
		spec_node_init(vp, tn->tn_spec.tn_dev.tn_rdev);
		break;
	case VDIR:
		vp->v_vflag |= (tn->tn_spec.tn_dir.tn_parent == node?
		    VV_ROOT : 0);
		break;
	case VFIFO:
		vp->v_op = tmpfs_fifoop_p;
		break;
	case VLNK:
	case VREG:
	case VSOCK:
		break;
	default:
		KASSERT(0);
	}

	uvm_vnp_setsize(vp, tn->tn_size);
	vp->v_data = tn;
	tn->tn_vnode = vp;

	/*
	 * All done!  Let anyone else trying to get this vnode have it.
	 */
	vready(vp);

out:	*vpp = vp;
	return error;
}

int
tmpfs_clean(void *v)
{
	struct vop_clean_args /* {
		struct vnode *a_vp;
	} */ *ap = v;

	return 0;

}

int
tmpfs_destroy(void *v)
{
	struct vop_destroy_args /* {
		struct vnode *a_vp;
	} */ *ap = v;
	struct vnode *vp = ap->a_vp;
	struct tmpfs_node *tn = VP_TO_TMPFS_NODE(vp);
	struct mount *mp = v->v_mount;
	struct tmpfs_mount *tmp = VFS_TO_TMPFS(mp);

	tmpfs_vnode_remove(mp, tn);

	if (tn->tn_links == 0)
		tmpfs_free_node(tmp, tn);

	return 0;
}

int
tmpfs_vnode_get(struct tmpfs_node *tn, struct vnode *vpp)
{
	struct vnode *vp;
	int s, error;

	s = pserialize_read_enter(); /* mutex_enter(&tn->tn_vlock) */
	if ((vp = tn->tn_vnode) != NULL) {
		vpreget(vp);
		pserialize_read_exit(s); /* mutex_exit(&tn->tn_vlock) */
		error = vget(vp, VGET_INTR);
		if (error)
			goto fail;
		*vpp = vp;
		return 0;
	}
	pserialize_read_exit(s); /* mutex_exit(&tn->tn_vlock) */

	error = ENOENT;
fail:	KASSERT(error);
	*vpp = NULL;
	return error;
}

int
tmpfs_vnode_intern(struct tmpfs_node *tn, struct vnode *vp, struct vnode **vpp)
{
	struct vnode *vp0;
	int error;

retry:	mutex_enter(&tn->tn_vlock);
	if ((vp0 = tn->tn_vnode) != NULL) {
		vpreget(vp0);
		mutex_exit(&tn->tn_vlock);
		error = vget(vp0, VGET_INTR);
		if (error) {
			if (error == ENOENT)
				goto retry;
			vp0 = NULL;
			goto out;
		}
		goto out;
	}

	vp0 = vp;
	membar_producer();
	tn->tn_vnode = vp0;
	mutex_exit(&tn->tn_vlock);

	error = 0;

out:	*vpp = vp0;
	return error;
}

int
tmpfs_vnode_remove(struct mount *mp, struct tmpfs_node *tn)
{
	struct tmpfs_mount *tmp = VFS_TO_TMPFS(mp);

	mutex_enter(&tn->tn_vlock);
	tn->tn_vnode = NULL;
	pserialize_perform(tmp->tmp_psz);
	mutex_exit(&tn->tn_vlock);
}