 @@ -1,952 +1,937 @@
-/*	$NetBSD: cd9660_vnops.c,v 1.60 2021/07/18 23:56:13 dholland Exp $	*/
+/*	$NetBSD: cd9660_vnops.c,v 1.61 2021/07/19 01:30:24 dholland Exp $	*/
 /*-
  * Copyright (c) 1994
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley
  * by Pace Willisson (pace@blitz.com).  The Rock Ridge Extension
  * Support code is derived from software contributed to Berkeley
  * by Atsushi Murai (amurai@spec.co.jp).
+ *
  * 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
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 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.
+ *
  *	@(#)cd9660_vnops.c	8.15 (Berkeley) 5/27/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: cd9660_vnops.c,v 1.60 2021/07/18 23:56:13 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: cd9660_vnops.c,v 1.61 2021/07/19 01:30:24 dholland Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/resourcevar.h>
 #include <sys/kernel.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/buf.h>
 #include <sys/proc.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
 #include <sys/malloc.h>
 #include <sys/dirent.h>
 #include <sys/kauth.h>
 #include <miscfs/fifofs/fifo.h>
 #include <miscfs/genfs/genfs.h>
 #include <miscfs/specfs/specdev.h>
 #include <fs/cd9660/iso.h>
 #include <fs/cd9660/cd9660_extern.h>
 #include <fs/cd9660/cd9660_node.h>
 #include <fs/cd9660/iso_rrip.h>
 #include <fs/cd9660/cd9660_mount.h>
 /*
  * Structure for reading directories
  */
 struct isoreaddir {
 	struct dirent saveent;
 	struct dirent assocent;
 	struct dirent current;
 	off_t saveoff;
 	off_t assocoff;
 	off_t curroff;
 	struct uio *uio;
 	off_t uio_off;
 	int eofflag;
 	off_t *cookies;
 	int ncookies;
 };
 int	iso_uiodir(struct isoreaddir *, struct dirent *, off_t);
 int	iso_shipdir(struct isoreaddir *);
 static int
 cd9660_check_possible(struct vnode *vp, struct iso_node *ip, accmode_t accmode)
+{
 	/*
 	 * Disallow write attempts unless the file is a socket,
 	 * fifo, or a block or character device resident on the
 	 * file system.
 	 */
 	if (accmode & VWRITE) {
 		switch (vp->v_type) {
 		case VDIR:
 		case VLNK:
 		case VREG:
 			return (EROFS);
 		default:
 			break;
+		}
+	}
 	return 0;
+}
 /*
  * Check mode permission on inode pointer. Mode is READ, WRITE or EXEC.
  * The mode is shifted to select the owner/group/other fields. The
  * super user is granted all permissions.
  */
 static int
 cd9660_check_permitted(struct vnode *vp, struct iso_node *ip, accmode_t accmode,
     kauth_cred_t cred)
+{
 	return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(accmode,
 	    vp->v_type, ip->inode.iso_mode & ALLPERMS), vp, NULL,
 	    genfs_can_access(vp, cred, ip->inode.iso_uid, ip->inode.iso_gid,
 	    ip->inode.iso_mode & ALLPERMS, NULL, accmode));
+}
 int
 cd9660_access(void *v)
+{
 	struct vop_access_args /* {
 		struct vnode *a_vp;
 		accmode_t  a_accmode;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	struct iso_node *ip = VTOI(vp);
 	int error;
 	error = cd9660_check_possible(vp, ip, ap->a_accmode);
 	if (error)
 		return error;
 	error = cd9660_check_permitted(vp, ip, ap->a_accmode, ap->a_cred);
 	return error;
+}
 int
 cd9660_getattr(void *v)
+{
 	struct vop_getattr_args /* {
 		struct vnode *a_vp;
 		struct vattr *a_vap;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	struct iso_node *ip = VTOI(vp);
 	struct vattr *vap = ap->a_vap;
 	vap->va_fsid	= ip->i_dev;
 	vap->va_fileid	= ip->i_number;
 	vap->va_mode	= ip->inode.iso_mode & ALLPERMS;
 	vap->va_nlink	= ip->inode.iso_links;
 	vap->va_uid	= ip->inode.iso_uid;
 	vap->va_gid	= ip->inode.iso_gid;
 	vap->va_atime	= ip->inode.iso_atime;
 	vap->va_mtime	= ip->inode.iso_mtime;
 	vap->va_ctime	= ip->inode.iso_ctime;
 	vap->va_rdev	= ip->inode.iso_rdev;
 	vap->va_size	= (u_quad_t) ip->i_size;
 	if (ip->i_size == 0 && vp->v_type == VLNK) {
 		struct vop_readlink_args rdlnk;
 		struct iovec aiov;
 		struct uio auio;
 		char *cp;
 		cp = (char *)malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 		aiov.iov_base = cp;
 		aiov.iov_len = MAXPATHLEN;
 		auio.uio_iov = &aiov;
 		auio.uio_iovcnt = 1;
 		auio.uio_offset = 0;
 		auio.uio_rw = UIO_READ;
 		auio.uio_resid = MAXPATHLEN;
 		UIO_SETUP_SYSSPACE(&auio);
 		rdlnk.a_uio = &auio;
 		rdlnk.a_vp = ap->a_vp;
 		rdlnk.a_cred = ap->a_cred;
 		if (cd9660_readlink(&rdlnk) == 0)
 			vap->va_size = MAXPATHLEN - auio.uio_resid;
 		free(cp, M_TEMP);
+	}
 	vap->va_flags	= 0;
 	vap->va_gen = 1;
 	vap->va_blocksize = ip->i_mnt->logical_block_size;
 	vap->va_bytes	= (u_quad_t) ip->i_size;
 	vap->va_type	= vp->v_type;
 	return (0);
+}
 /*
  * Vnode op for reading.
  */
 int
 cd9660_read(void *v)
+{
 	struct vop_read_args /* {
 		struct vnode *a_vp;
 		struct uio *a_uio;
 		int a_ioflag;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	struct uio *uio = ap->a_uio;
 	struct iso_node *ip = VTOI(vp);
 	struct iso_mnt *imp;
 	struct buf *bp;
 	daddr_t lbn, rablock;
 	off_t diff;
 	int rasize, error = 0;
 	long size, n, on;
 	if (uio->uio_resid == 0)
 		return (0);
 	if (uio->uio_offset < 0)
 		return (EINVAL);
 	if (uio->uio_offset >= ip->i_size)
 		return 0;
 	ip->i_flag |= IN_ACCESS;
 	imp = ip->i_mnt;
 	if (vp->v_type == VREG) {
 		const int advice = IO_ADV_DECODE(ap->a_ioflag);
 		error = 0;
 		while (uio->uio_resid > 0) {
 			vsize_t bytelen = MIN(ip->i_size - uio->uio_offset,
 					      uio->uio_resid);
 			if (bytelen == 0)
 				break;
 			error = ubc_uiomove(&vp->v_uobj, uio, bytelen, advice,
 			    UBC_READ | UBC_PARTIALOK | UBC_VNODE_FLAGS(vp));
 			if (error)
 				break;
+		}
 		goto out;
+	}
 	do {
 		lbn = cd9660_lblkno(imp, uio->uio_offset);
 		on = cd9660_blkoff(imp, uio->uio_offset);
 		n = MIN(imp->logical_block_size - on, uio->uio_resid);
 		diff = (off_t)ip->i_size - uio->uio_offset;
 		if (diff <= 0)
 			return (0);
 		if (diff < n)
 			n = diff;
 		size = cd9660_blksize(imp, ip, lbn);
 		rablock = lbn + 1;
 		if (cd9660_lblktosize(imp, rablock) < ip->i_size) {
 			rasize = cd9660_blksize(imp, ip, rablock);
 			error = breadn(vp, lbn, size, &rablock,
 				       &rasize, 1, 0, &bp);
 		} else {
 			error = bread(vp, lbn, size, 0, &bp);
+		}
 		if (error) {
 			return (error);
+		}
 		n = MIN(n, size - bp->b_resid);
 		error = uiomove((char *)bp->b_data + on, (int)n, uio);
 		brelse(bp, 0);
 	} while (error == 0 && uio->uio_resid > 0 && n != 0);
 out:
 	return (error);
+}
 int
 iso_uiodir(struct isoreaddir *idp, struct dirent *dp, off_t off)
+{
 	int error;
 	dp->d_name[dp->d_namlen] = 0;
 	dp->d_reclen = _DIRENT_SIZE(dp);
 	if (idp->uio->uio_resid < dp->d_reclen) {
 		idp->eofflag = 0;
 		return (-1);
+	}
 	if (idp->cookies) {
 		if (idp->ncookies <= 0) {
 			idp->eofflag = 0;
 			return (-1);
+		}
 		*idp->cookies++ = off;
 		--idp->ncookies;
+	}
 	if ((error = uiomove(dp, dp->d_reclen, idp->uio)) != 0)
 		return (error);
 	idp->uio_off = off;
 	return (0);
+}
 int
 iso_shipdir(struct isoreaddir *idp)
+{
 	struct dirent *dp;
 	int cl, sl, assoc;
 	int error;
 	char *cname, *sname;
 	cl = idp->current.d_namlen;
 	cname = idp->current.d_name;
 	assoc = (cl > 1) && (*cname == ASSOCCHAR);
 	if (assoc) {
 		cl--;
 		cname++;
+	}
 	dp = &idp->saveent;
 	sname = dp->d_name;
 	if (!(sl = dp->d_namlen)) {
 		dp = &idp->assocent;
 		sname = dp->d_name + 1;
 		sl = dp->d_namlen - 1;
+	}
 	if (sl > 0) {
 		if (sl != cl
 		    || memcmp(sname, cname, sl)) {
 			if (idp->assocent.d_namlen) {
 				error = iso_uiodir(idp, &idp->assocent,
 						   idp->assocoff);
 				if (error)
 					return (error);
 				idp->assocent.d_namlen = 0;
+			}
 			if (idp->saveent.d_namlen) {
 				error = iso_uiodir(idp, &idp->saveent,
 						   idp->saveoff);
 				if (error)
 					return (error);
 				idp->saveent.d_namlen = 0;
+			}
+		}
+	}
 	idp->current.d_reclen = _DIRENT_SIZE(&idp->current);
 	if (assoc) {
 		idp->assocoff = idp->curroff;
 		memcpy(&idp->assocent, &idp->current, idp->current.d_reclen);
 	} else {
 		idp->saveoff = idp->curroff;
 		memcpy(&idp->saveent, &idp->current, idp->current.d_reclen);
+	}
 	return (0);
+}
 /*
  * Vnode op for readdir
  */
 int
 cd9660_readdir(void *v)
+{
 	struct vop_readdir_args /* {
 		struct vnode *a_vp;
 		struct uio *a_uio;
 		kauth_cred_t a_cred;
 		int *a_eofflag;
 		off_t **a_cookies;
 		int *a_ncookies;
 	} */ *ap = v;
 	struct uio *uio = ap->a_uio;
 	struct isoreaddir *idp;
 	struct vnode *vdp = ap->a_vp;
 	struct iso_node *dp;
 	struct iso_mnt *imp;
 	struct buf *bp = NULL;
 	struct iso_directory_record *ep;
 	int entryoffsetinblock;
 	doff_t endsearch;
 	u_long bmask;
 	int error = 0;
 	int reclen;
 	u_short namelen;
 	off_t *cookies = NULL;
 	int ncookies = 0;
 	if (vdp->v_type != VDIR)
 		return (ENOTDIR);
 	dp = VTOI(vdp);
 	imp = dp->i_mnt;
 	bmask = imp->im_bmask;
 	idp = malloc(sizeof(*idp), M_TEMP, M_WAITOK | M_ZERO);
 	idp->saveent.d_namlen = idp->assocent.d_namlen = 0;
 	/*
 	 * XXX
 	 * Is it worth trying to figure out the type?
 	 */
 	idp->saveent.d_type = idp->assocent.d_type = idp->current.d_type =
 	    DT_UNKNOWN;
 	idp->uio = uio;
 	if (ap->a_ncookies == NULL)
 		idp->cookies = NULL;
 	else {
 		ncookies = uio->uio_resid / _DIRENT_MINSIZE((struct dirent *)0);
 		cookies = malloc(ncookies * sizeof(off_t), M_TEMP, M_WAITOK);
 		idp->cookies = cookies;
 		idp->ncookies = ncookies;
+	}
 	idp->eofflag = 1;
 	idp->curroff = uio->uio_offset;
 	if ((entryoffsetinblock = idp->curroff & bmask) &&
 	    (error = cd9660_blkatoff(vdp, (off_t)idp->curroff, NULL, &bp))) {
 		free(idp, M_TEMP);
 		return (error);
+	}
 	endsearch = dp->i_size;
 	while (idp->curroff < endsearch) {
 		/*
 		 * If offset is on a block boundary,
 		 * read the next directory block.
 		 * Release previous if it exists.
 		 */
 		if ((idp->curroff & bmask) == 0) {
 			if (bp != NULL)
 				brelse(bp, 0);
 			error = cd9660_blkatoff(vdp, (off_t)idp->curroff,
 					     NULL, &bp);
 			if (error)
 				break;
 			entryoffsetinblock = 0;
+		}
 		/*
 		 * Get pointer to next entry.
 		 */
 		KASSERT(bp != NULL);
 		ep = (struct iso_directory_record *)
 			((char *)bp->b_data + entryoffsetinblock);
 		reclen = isonum_711(ep->length);
 		if (reclen == 0) {
 			/* skip to next block, if any */
 			idp->curroff =
 			    (idp->curroff & ~bmask) + imp->logical_block_size;
 			continue;
+		}
 		if (reclen < ISO_DIRECTORY_RECORD_SIZE) {
 			error = EINVAL;
 			/* illegal entry, stop */
 			break;
+		}
 		if (entryoffsetinblock + reclen > imp->logical_block_size) {
 			error = EINVAL;
 			/* illegal directory, so stop looking */
 			break;
+		}
 		idp->current.d_namlen = isonum_711(ep->name_len);
 		if (reclen < ISO_DIRECTORY_RECORD_SIZE + idp->current.d_namlen) {
 			error = EINVAL;
 			/* illegal entry, stop */
 			break;
+		}
 		if (isonum_711(ep->flags)&2)
 			idp->current.d_fileno = isodirino(ep, imp);
 		else
 			idp->current.d_fileno = dbtob(bp->b_blkno) +
 				entryoffsetinblock;
 		idp->curroff += reclen;
 		switch (imp->iso_ftype) {
 		case ISO_FTYPE_RRIP:
 			cd9660_rrip_getname(ep, idp->current.d_name, &namelen,
 			    &idp->current.d_fileno, imp);
 			idp->current.d_namlen = (u_char)namelen;
 			if (idp->current.d_namlen)
 				error = iso_uiodir(idp, &idp->current,
 				    idp->curroff);
 			break;
 		default:	/* ISO_FTYPE_DEFAULT || ISO_FTYPE_9660 */
 			isofntrans(ep->name, idp->current.d_namlen,
 				   idp->current.d_name, &namelen,
 				   imp->iso_ftype == ISO_FTYPE_9660,
 				   (imp->im_flags & ISOFSMNT_NOCASETRANS) == 0,
 				   isonum_711(ep->flags)&4,
 				   imp->im_joliet_level);
 			switch (idp->current.d_name[0]) {
 			case 0:
 				idp->current.d_name[0] = '.';
 				idp->current.d_namlen = 1;
 				error = iso_uiodir(idp, &idp->current,
 				    idp->curroff);
 				break;
 			case 1:
 				strlcpy(idp->current.d_name, "..",
 				    sizeof(idp->current.d_name));
 				idp->current.d_namlen = 2;
 				error = iso_uiodir(idp, &idp->current,
 				    idp->curroff);
 				break;
 			default:
 				idp->current.d_namlen = (u_char)namelen;
 				if (imp->iso_ftype == ISO_FTYPE_DEFAULT)
 					error = iso_shipdir(idp);
 				else
 					error = iso_uiodir(idp, &idp->current,
 					    idp->curroff);
 				break;
+			}
+		}
 		if (error)
 			break;
 		entryoffsetinblock += reclen;
+	}
 	if (!error && imp->iso_ftype == ISO_FTYPE_DEFAULT) {
 		idp->current.d_namlen = 0;
 		error = iso_shipdir(idp);
+	}
 	if (error < 0)
 		error = 0;
 	if (ap->a_ncookies != NULL) {
 		if (error)
 			free(cookies, M_TEMP);
 		else {
 			/*
 			 * Work out the number of cookies actually used.
 			 */
 			*ap->a_ncookies = ncookies - idp->ncookies;
 			*ap->a_cookies = cookies;
+		}
+	}
 	if (bp)
 		brelse(bp, 0);
 	uio->uio_offset = idp->uio_off;
 	*ap->a_eofflag = idp->eofflag;
 	free(idp, M_TEMP);
 	return (error);
+}
 /*
  * Return target name of a symbolic link
  * Shouldn't we get the parent vnode and read the data from there?
  * This could eventually result in deadlocks in cd9660_lookup.
  * But otherwise the block read here is in the block buffer two times.
  */
 typedef struct iso_directory_record ISODIR;
 typedef struct iso_node             ISONODE;
 typedef struct iso_mnt              ISOMNT;
 int
 cd9660_readlink(void *v)
+{
 	struct vop_readlink_args /* {
 		struct vnode *a_vp;
 		struct uio *a_uio;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	ISONODE	*ip;
 	ISODIR	*dirp;
 	ISOMNT	*imp;
 	struct	buf *bp;
 	struct	uio *uio;
 	u_short	symlen;
 	int	error;
 	char	*symname;
 	bool use_pnbuf;
 	ip  = VTOI(ap->a_vp);
 	imp = ip->i_mnt;
 	uio = ap->a_uio;
 	if (imp->iso_ftype != ISO_FTYPE_RRIP)
 		return (EINVAL);
 	/*
 	 * Get parents directory record block that this inode included.
 	 */
 	error = bread(imp->im_devvp,
 		      (ip->i_number >> imp->im_bshift) <<
 		      (imp->im_bshift - DEV_BSHIFT),
 		      imp->logical_block_size, 0, &bp);
 	if (error) {
 		return (EINVAL);
+	}
 	/*
 	 * Setup the directory pointer for this inode
 	 */
 	dirp = (ISODIR *)((char *)bp->b_data + (ip->i_number & imp->im_bmask));
 	/*
 	 * Just make sure, we have a right one....
 	 *   1: Check not cross boundary on block
 	 */
 	if ((ip->i_number & imp->im_bmask) + isonum_711(dirp->length)
 	    > imp->logical_block_size) {
 		brelse(bp, 0);
 		return (EINVAL);
+	}
 	/*
 	 * Now get a buffer
 	 * Abuse a namei buffer for now.
 	 */
 	use_pnbuf = !VMSPACE_IS_KERNEL_P(uio->uio_vmspace) ||
 	    uio->uio_iov->iov_len < MAXPATHLEN;
 	if (use_pnbuf) {
 		symname = PNBUF_GET();
 	} else {
 		symname = uio->uio_iov->iov_base;
+	}
 	/*
 	 * Ok, we just gathering a symbolic name in SL record.
 	 */
 	if (cd9660_rrip_getsymname(dirp, symname, &symlen, imp) == 0) {
 		if (use_pnbuf) {
 			PNBUF_PUT(symname);
+		}
 		brelse(bp, 0);
 		return (EINVAL);
+	}
 	/*
 	 * Don't forget before you leave from home ;-)
 	 */
 	brelse(bp, 0);
 	/*
 	 * return with the symbolic name to caller's.
 	 */
 	if (use_pnbuf) {
 		error = uiomove(symname, symlen, uio);
 		PNBUF_PUT(symname);
 		return (error);
+	}
 	uio->uio_resid -= symlen;
 	uio->uio_iov->iov_base = (char *)uio->uio_iov->iov_base + symlen;
 	uio->uio_iov->iov_len -= symlen;
 	return (0);
+}
 int
 cd9660_link(void *v)
+{
 	struct vop_link_v2_args /* {
 		struct vnode *a_dvp;
 		struct vnode *a_vp;
 		struct componentname *a_cnp;
 	} */ *ap = v;
 	VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
 	return (EROFS);
+}
 int
 cd9660_symlink(void *v)
+{
 	struct vop_symlink_v3_args /* {
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
 		struct vattr *a_vap;
 		char *a_target;
 	} */ *ap = v;
 	VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
 	return (EROFS);
+}
 /*
  * Calculate the logical to physical mapping if not done already,
  * then call the device strategy routine.
  */
 int
 cd9660_strategy(void *v)
+{
 	struct vop_strategy_args /* {
 		struct vnode *a_vp;
 		struct buf *a_bp;
 	} */ *ap = v;
 	struct buf *bp = ap->a_bp;
 	struct vnode *vp = ap->a_vp;
 	struct iso_node *ip;
 	int error;
 	ip = VTOI(vp);
 	if (vp->v_type == VBLK || vp->v_type == VCHR)
 		panic("cd9660_strategy: spec");
 	if (bp->b_blkno == bp->b_lblkno) {
 		error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL);
 		if (error) {
 			bp->b_error = error;
 			biodone(bp);
 			return (error);
+		}
 		if ((long)bp->b_blkno == -1)
 			clrbuf(bp);
+	}
 	if ((long)bp->b_blkno == -1) {
 		biodone(bp);
 		return (0);
+	}
 	vp = ip->i_mnt->im_devvp;
 	return (VOP_STRATEGY(vp, bp));
+}
 /*
  * Print out the contents of an inode.
  */
 /*ARGSUSED*/
 int
 cd9660_print(void *v)
+{
 	printf("tag VT_ISOFS, isofs vnode\n");
 	return (0);
+}
 /*
  * Return POSIX pathconf information applicable to cd9660 filesystems.
  */
 int
 cd9660_pathconf(void *v)
+{
 	struct vop_pathconf_args /* {
 		struct vnode *a_vp;
 		int a_name;
 		register_t *a_retval;
 	} */ *ap = v;
 	switch (ap->a_name) {
 	case _PC_LINK_MAX:
 		*ap->a_retval = 1;
 		return (0);
 	case _PC_NAME_MAX:
 		if (VTOI(ap->a_vp)->i_mnt->iso_ftype == ISO_FTYPE_RRIP)
 			*ap->a_retval = ISO_MAXNAMLEN;
 		else
 			*ap->a_retval = 37;
 		return (0);
 	case _PC_PATH_MAX:
 		*ap->a_retval = PATH_MAX;
 		return (0);
 	case _PC_PIPE_BUF:
 		*ap->a_retval = PIPE_BUF;
 		return (0);
 	case _PC_CHOWN_RESTRICTED:
 		*ap->a_retval = 1;
 		return (0);
 	case _PC_NO_TRUNC:
 		*ap->a_retval = 1;
 		return (0);
 	case _PC_SYNC_IO:
 		*ap->a_retval = 1;
 		return (0);
 	case _PC_FILESIZEBITS:
 		*ap->a_retval = 32;
 		return (0);
 	default:
 		return genfs_pathconf(ap);
+	}
 	/* NOTREACHED */
+}
 /*
  * Allow changing the size for special files (and fifos).
  */
 int
 cd9660_setattr(void *v)
+{
 	struct vop_setattr_args /* {
 		struct vnodeop_desc *a_desc;
 		struct vnode *a_vp;
 		struct vattr *a_vap;
 		kauth_cred_t a_cred;
 		struct proc *a_p;
 	} */ *ap = v;
 	struct vattr *vap = ap->a_vap;
 	struct vnode *vp = ap->a_vp;
 	/*
 	 * Only size is changeable.
 	 */
 	if (vap->va_type != VNON
 	    || vap->va_nlink != (nlink_t)VNOVAL
 	    || vap->va_fsid != VNOVAL
 	    || vap->va_fileid != VNOVAL
 	    || vap->va_blocksize != VNOVAL
 	    || vap->va_rdev != (dev_t)VNOVAL
 	    || (int)vap->va_bytes != VNOVAL
 	    || vap->va_gen != VNOVAL
 	    || vap->va_flags != VNOVAL
 	    || vap->va_uid != (uid_t)VNOVAL
 	    || vap->va_gid != (gid_t)VNOVAL
 	    || vap->va_atime.tv_sec != VNOVAL
 	    || vap->va_mtime.tv_sec != VNOVAL
 	    || vap->va_mode != (mode_t)VNOVAL)
 		return EOPNOTSUPP;
 	if (vap->va_size != VNOVAL
 	    && vp->v_type != VCHR
 	    && vp->v_type != VBLK
 	    && vp->v_type != VFIFO)
 		return EOPNOTSUPP;
 	return 0;
+}
 /*
  * Global vfs data structures for isofs
  */
 #define	cd9660_create	genfs_eopnotsupp
 #define	cd9660_mknod	genfs_eopnotsupp
 #define	cd9660_write	genfs_eopnotsupp
 #define	cd9660_fsync	genfs_nullop
 #define	cd9660_remove	genfs_eopnotsupp
 #define	cd9660_rename	genfs_eopnotsupp
 #define	cd9660_mkdir	genfs_eopnotsupp
 #define	cd9660_rmdir	genfs_eopnotsupp
 #define	cd9660_advlock	genfs_einval
 #define	cd9660_bwrite	genfs_eopnotsupp
 #define cd9660_revoke	genfs_revoke
 /*
  * Global vfs data structures for cd9660
  */
 int (**cd9660_vnodeop_p)(void *);
 const struct vnodeopv_entry_desc cd9660_vnodeop_entries[] = {
 	{ &vop_default_desc, vn_default_error },
 	{ &vop_parsepath_desc, genfs_parsepath },	/* parsepath */
 	{ &vop_lookup_desc, cd9660_lookup },		/* lookup */
-	{ &vop_create_desc, cd9660_create },		/* create */
+	{ &vop_create_desc, genfs_eopnotsupp },		/* create */
-	{ &vop_mknod_desc, cd9660_mknod },		/* mknod */
+	{ &vop_mknod_desc, genfs_eopnotsupp },		/* mknod */
-	{ &vop_open_desc, cd9660_open },		/* open */
+	{ &vop_open_desc, genfs_nullop },		/* open */
-	{ &vop_close_desc, cd9660_close },		/* close */
+	{ &vop_close_desc, genfs_nullop },		/* close */
 	{ &vop_access_desc, cd9660_access },		/* access */
 	{ &vop_accessx_desc, genfs_accessx },		/* accessx */
 	{ &vop_getattr_desc, cd9660_getattr },		/* getattr */
 	{ &vop_setattr_desc, cd9660_setattr },		/* setattr */
 	{ &vop_read_desc, cd9660_read },		/* read */
-	{ &vop_write_desc, cd9660_write },		/* write */
+	{ &vop_write_desc, genfs_eopnotsupp },		/* write */
 	{ &vop_fallocate_desc, genfs_eopnotsupp },	/* fallocate */
 	{ &vop_fdiscard_desc, genfs_eopnotsupp },	/* fdiscard */
 	{ &vop_fcntl_desc, genfs_fcntl },		/* fcntl */
-	{ &vop_ioctl_desc, cd9660_ioctl },		/* ioctl */
+	{ &vop_ioctl_desc, genfs_enoioctl },		/* ioctl */
-	{ &vop_poll_desc, cd9660_poll },		/* poll */
+	{ &vop_poll_desc, genfs_poll },			/* poll */
-	{ &vop_revoke_desc, cd9660_revoke },		/* revoke */
+	{ &vop_revoke_desc, genfs_revoke },		/* revoke */
-	{ &vop_mmap_desc, cd9660_mmap },		/* mmap */
+	{ &vop_mmap_desc, genfs_mmap },			/* mmap */
-	{ &vop_fsync_desc, cd9660_fsync },		/* fsync */
+	{ &vop_fsync_desc, genfs_nullop },		/* fsync */
-	{ &vop_seek_desc, cd9660_seek },		/* seek */
+	{ &vop_seek_desc, genfs_seek },			/* seek */
-	{ &vop_remove_desc, cd9660_remove },		/* remove */
+	{ &vop_remove_desc, genfs_eopnotsupp },		/* remove */
 	{ &vop_link_desc, cd9660_link },		/* link */
-	{ &vop_rename_desc, cd9660_rename },		/* rename */
+	{ &vop_rename_desc, genfs_eopnotsupp },		/* rename */
-	{ &vop_mkdir_desc, cd9660_mkdir },		/* mkdir */
+	{ &vop_mkdir_desc, genfs_eopnotsupp },		/* mkdir */
-	{ &vop_rmdir_desc, cd9660_rmdir },		/* rmdir */
+	{ &vop_rmdir_desc, genfs_eopnotsupp },		/* rmdir */
 	{ &vop_symlink_desc, cd9660_symlink },		/* symlink */
 	{ &vop_readdir_desc, cd9660_readdir },		/* readdir */
 	{ &vop_readlink_desc, cd9660_readlink },	/* readlink */
-	{ &vop_abortop_desc, cd9660_abortop },		/* abortop */
+	{ &vop_abortop_desc, genfs_abortop },		/* abortop */
 	{ &vop_inactive_desc, cd9660_inactive },	/* inactive */
 	{ &vop_reclaim_desc, cd9660_reclaim },		/* reclaim */
 	{ &vop_lock_desc, genfs_lock },			/* lock */
 	{ &vop_unlock_desc, genfs_unlock },		/* unlock */
 	{ &vop_bmap_desc, cd9660_bmap },		/* bmap */
 	{ &vop_strategy_desc, cd9660_strategy },	/* strategy */
 	{ &vop_print_desc, cd9660_print },		/* print */
 	{ &vop_islocked_desc, genfs_islocked },		/* islocked */
 	{ &vop_pathconf_desc, cd9660_pathconf },	/* pathconf */
-	{ &vop_advlock_desc, cd9660_advlock },		/* advlock */
+	{ &vop_advlock_desc, genfs_einval },		/* advlock */
 	{ &vop_bwrite_desc, vn_bwrite },		/* bwrite */
 	{ &vop_getpages_desc, genfs_getpages },		/* getpages */
 	{ &vop_putpages_desc, genfs_putpages },		/* putpages */
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc cd9660_vnodeop_opv_desc =
 	{ &cd9660_vnodeop_p, cd9660_vnodeop_entries };
 /*
  * Special device vnode ops
  */
 int (**cd9660_specop_p)(void *);
 const struct vnodeopv_entry_desc cd9660_specop_entries[] = {
 	{ &vop_default_desc, vn_default_error },
 	GENFS_SPECOP_ENTRIES,
 	{ &vop_close_desc, spec_close },		/* close */
 	{ &vop_access_desc, cd9660_access },		/* access */
 	{ &vop_accessx_desc, genfs_accessx },		/* accessx */
 	{ &vop_getattr_desc, cd9660_getattr },		/* getattr */
 	{ &vop_setattr_desc, cd9660_setattr },		/* setattr */
 	{ &vop_read_desc, spec_read },			/* read */
 	{ &vop_write_desc, spec_write },		/* write */
 	{ &vop_fcntl_desc, genfs_fcntl },		/* fcntl */
 	{ &vop_fsync_desc, spec_fsync },		/* fsync */
 	{ &vop_inactive_desc, cd9660_inactive },	/* inactive */
 	{ &vop_reclaim_desc, cd9660_reclaim },		/* reclaim */
 	{ &vop_lock_desc, genfs_lock },			/* lock */
 	{ &vop_unlock_desc, genfs_unlock },		/* unlock */
 	{ &vop_print_desc, cd9660_print },		/* print */
 	{ &vop_islocked_desc, genfs_islocked },		/* islocked */
 	{ &vop_bwrite_desc, vn_bwrite },		/* bwrite */
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc cd9660_specop_opv_desc =
 	{ &cd9660_specop_p, cd9660_specop_entries };
 int (**cd9660_fifoop_p)(void *);
 const struct vnodeopv_entry_desc cd9660_fifoop_entries[] = {
 	{ &vop_default_desc, vn_default_error },
 	GENFS_FIFOOP_ENTRIES,
 	{ &vop_close_desc, vn_fifo_bypass },		/* close */
 	{ &vop_access_desc, cd9660_access },		/* access */
 	{ &vop_accessx_desc, genfs_accessx },		/* accessx */
 	{ &vop_getattr_desc, cd9660_getattr },		/* getattr */
 	{ &vop_setattr_desc, cd9660_setattr },		/* setattr */
 	{ &vop_read_desc, vn_fifo_bypass },		/* read */
 	{ &vop_write_desc, vn_fifo_bypass },		/* write */
 	{ &vop_fcntl_desc, genfs_fcntl },		/* fcntl */
 	{ &vop_fsync_desc, vn_fifo_bypass },		/* fsync */
 	{ &vop_inactive_desc, cd9660_inactive },	/* inactive */
 	{ &vop_reclaim_desc, cd9660_reclaim },		/* reclaim */
 	{ &vop_lock_desc, genfs_lock },			/* lock */
 	{ &vop_unlock_desc, genfs_unlock },		/* unlock */
 	{ &vop_strategy_desc, vn_fifo_bypass },		/* strategy */
 	{ &vop_print_desc, cd9660_print },		/* print */
 	{ &vop_islocked_desc, genfs_islocked },		/* islocked */
 	{ &vop_bwrite_desc, vn_bwrite },		/* bwrite */
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc cd9660_fifoop_opv_desc =
 	{ &cd9660_fifoop_p, cd9660_fifoop_entries };

 @@ -1,1257 +1,1253 @@
-/*	$NetBSD: puffs_vnops.c,v 1.220 2021/07/18 23:56:13 dholland Exp $	*/
+/*	$NetBSD: puffs_vnops.c,v 1.221 2021/07/19 01:30:24 dholland Exp $	*/
 /*
  * Copyright (c) 2005, 2006, 2007  Antti Kantee.  All Rights Reserved.
+ *
  * Development of this software was supported by the
  * Google Summer of Code program and the Ulla Tuominen Foundation.
  * The Google SoC project was mentored by Bill Studenmund.
+ *
  * 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
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: puffs_vnops.c,v 1.220 2021/07/18 23:56:13 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: puffs_vnops.c,v 1.221 2021/07/19 01:30:24 dholland Exp $");
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/lockf.h>
 #include <sys/malloc.h>
 #include <sys/mount.h>
 #include <sys/namei.h>
 #include <sys/vnode.h>
 #include <sys/proc.h>
 #include <sys/kernel.h> /* For hz, getticks() */
 #include <uvm/uvm.h>
 #include <fs/puffs/puffs_msgif.h>
 #include <fs/puffs/puffs_sys.h>
 #include <miscfs/fifofs/fifo.h>
 #include <miscfs/genfs/genfs.h>
 #include <miscfs/specfs/specdev.h>
 int	puffs_vnop_lookup(void *);
 int	puffs_vnop_create(void *);
 int	puffs_vnop_access(void *);
 int	puffs_vnop_mknod(void *);
 int	puffs_vnop_open(void *);
 int	puffs_vnop_close(void *);
 int	puffs_vnop_getattr(void *);
 int	puffs_vnop_setattr(void *);
 int	puffs_vnop_reclaim(void *);
 int	puffs_vnop_readdir(void *);
 int	puffs_vnop_poll(void *);
 int	puffs_vnop_fsync(void *);
 int	puffs_vnop_seek(void *);
 int	puffs_vnop_remove(void *);
 int	puffs_vnop_mkdir(void *);
 int	puffs_vnop_rmdir(void *);
 int	puffs_vnop_link(void *);
 int	puffs_vnop_readlink(void *);
 int	puffs_vnop_symlink(void *);
 int	puffs_vnop_rename(void *);
 int	puffs_vnop_read(void *);
 int	puffs_vnop_write(void *);
 int	puffs_vnop_fallocate(void *);
 int	puffs_vnop_fdiscard(void *);
 int	puffs_vnop_fcntl(void *);
 int	puffs_vnop_ioctl(void *);
 int	puffs_vnop_inactive(void *);
 int	puffs_vnop_print(void *);
 int	puffs_vnop_pathconf(void *);
 int	puffs_vnop_advlock(void *);
 int	puffs_vnop_strategy(void *);
 int	puffs_vnop_bmap(void *);
 int	puffs_vnop_mmap(void *);
 int	puffs_vnop_getpages(void *);
 int	puffs_vnop_abortop(void *);
 int	puffs_vnop_getextattr(void *);
 int	puffs_vnop_setextattr(void *);
 int	puffs_vnop_listextattr(void *);
 int	puffs_vnop_deleteextattr(void *);
 int	puffs_vnop_spec_read(void *);
 int	puffs_vnop_spec_write(void *);
 int	puffs_vnop_fifo_read(void *);
 int	puffs_vnop_fifo_write(void *);
 int	puffs_vnop_checkop(void *);
 #define puffs_vnop_lock genfs_lock
 #define puffs_vnop_unlock genfs_unlock
 #define puffs_vnop_islocked genfs_islocked
 int (**puffs_vnodeop_p)(void *);
 const struct vnodeopv_entry_desc puffs_vnodeop_entries[] = {
 	{ &vop_default_desc, vn_default_error },
 	{ &vop_parsepath_desc, genfs_parsepath },	/* parsepath */
 	{ &vop_lookup_desc, puffs_vnop_lookup },	/* REAL lookup */
 	{ &vop_create_desc, puffs_vnop_checkop },	/* create */
         { &vop_mknod_desc, puffs_vnop_checkop },	/* mknod */
         { &vop_open_desc, puffs_vnop_open },		/* REAL open */
         { &vop_close_desc, puffs_vnop_checkop },	/* close */
         { &vop_access_desc, puffs_vnop_access },	/* REAL access */
         { &vop_accessx_desc, genfs_accessx },		/* accessx */
         { &vop_getattr_desc, puffs_vnop_checkop },	/* getattr */
         { &vop_setattr_desc, puffs_vnop_checkop },	/* setattr */
         { &vop_read_desc, puffs_vnop_checkop },		/* read */
         { &vop_write_desc, puffs_vnop_checkop },	/* write */
 	{ &vop_fallocate_desc, puffs_vnop_fallocate },	/* fallocate */
 	{ &vop_fdiscard_desc, puffs_vnop_fdiscard },	/* fdiscard */
         { &vop_fsync_desc, puffs_vnop_fsync },		/* REAL fsync */
         { &vop_seek_desc, puffs_vnop_checkop },		/* seek */
         { &vop_remove_desc, puffs_vnop_checkop },	/* remove */
         { &vop_link_desc, puffs_vnop_checkop },		/* link */
         { &vop_rename_desc, puffs_vnop_checkop },	/* rename */
         { &vop_mkdir_desc, puffs_vnop_checkop },	/* mkdir */
         { &vop_rmdir_desc, puffs_vnop_checkop },	/* rmdir */
         { &vop_symlink_desc, puffs_vnop_checkop },	/* symlink */
         { &vop_readdir_desc, puffs_vnop_checkop },	/* readdir */
         { &vop_readlink_desc, puffs_vnop_checkop },	/* readlink */
         { &vop_getpages_desc, puffs_vnop_checkop },	/* getpages */
         { &vop_putpages_desc, genfs_putpages },		/* REAL putpages */
         { &vop_pathconf_desc, puffs_vnop_checkop },	/* pathconf */
         { &vop_advlock_desc, puffs_vnop_advlock },	/* advlock */
         { &vop_strategy_desc, puffs_vnop_strategy },	/* REAL strategy */
         { &vop_revoke_desc, genfs_revoke },		/* REAL revoke */
         { &vop_abortop_desc, puffs_vnop_abortop },	/* REAL abortop */
         { &vop_inactive_desc, puffs_vnop_inactive },	/* REAL inactive */
         { &vop_reclaim_desc, puffs_vnop_reclaim },	/* REAL reclaim */
-        { &vop_lock_desc, puffs_vnop_lock },		/* REAL lock */
+        { &vop_lock_desc, genfs_lock },			/* REAL lock */
-        { &vop_unlock_desc, puffs_vnop_unlock },	/* REAL unlock */
+        { &vop_unlock_desc, genfs_unlock },		/* REAL unlock */
         { &vop_bmap_desc, puffs_vnop_bmap },		/* REAL bmap */
         { &vop_print_desc, puffs_vnop_print },		/* REAL print */
-        { &vop_islocked_desc, puffs_vnop_islocked },	/* REAL islocked */
+        { &vop_islocked_desc, genfs_islocked },		/* REAL islocked */
         { &vop_bwrite_desc, genfs_nullop },		/* REAL bwrite */
         { &vop_mmap_desc, puffs_vnop_mmap },		/* REAL mmap */
         { &vop_poll_desc, puffs_vnop_poll },		/* REAL poll */
 	{ &vop_getextattr_desc, puffs_vnop_getextattr },	/* getextattr */
 	{ &vop_setextattr_desc, puffs_vnop_setextattr },	/* setextattr */
 	{ &vop_listextattr_desc, puffs_vnop_listextattr },	/* listextattr */
 	{ &vop_deleteextattr_desc, puffs_vnop_deleteextattr },/* deleteextattr */
 #if 0
 	{ &vop_openextattr_desc, puffs_vnop_checkop },	/* openextattr */
 	{ &vop_closeextattr_desc, puffs_vnop_checkop },	/* closeextattr */
 #endif
         { &vop_kqfilter_desc, genfs_eopnotsupp },	/* kqfilter XXX */
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc puffs_vnodeop_opv_desc =
 	{ &puffs_vnodeop_p, puffs_vnodeop_entries };
 int (**puffs_specop_p)(void *);
 const struct vnodeopv_entry_desc puffs_specop_entries[] = {
 	{ &vop_default_desc, vn_default_error },
 	GENFS_SPECOP_ENTRIES,
 	{ &vop_close_desc, spec_close },		/* spec_close */
 	{ &vop_access_desc, puffs_vnop_checkop },	/* access */
 	{ &vop_accessx_desc, genfs_accessx },		/* accessx */
 	{ &vop_getattr_desc, puffs_vnop_checkop },	/* getattr */
 	{ &vop_setattr_desc, puffs_vnop_checkop },	/* setattr */
 	{ &vop_read_desc, puffs_vnop_spec_read },	/* update, read */
 	{ &vop_write_desc, puffs_vnop_spec_write },	/* update, write */
 	{ &vop_fcntl_desc, genfs_fcntl },		/* dummy */
 	{ &vop_fsync_desc, spec_fsync },		/* vflushbuf */
 	{ &vop_inactive_desc, puffs_vnop_inactive },	/* REAL inactive */
 	{ &vop_reclaim_desc, puffs_vnop_reclaim },	/* REAL reclaim */
-	{ &vop_lock_desc, puffs_vnop_lock },		/* REAL lock */
+	{ &vop_lock_desc, genfs_lock },			/* REAL lock */
-	{ &vop_unlock_desc, puffs_vnop_unlock },	/* REAL unlock */
+	{ &vop_unlock_desc, genfs_unlock },		/* REAL unlock */
 	{ &vop_print_desc, puffs_vnop_print },		/* REAL print */
-	{ &vop_islocked_desc, puffs_vnop_islocked },	/* REAL islocked */
+	{ &vop_islocked_desc, genfs_islocked },		/* REAL islocked */
 	{ &vop_bwrite_desc, vn_bwrite },		/* bwrite */
 	{ &vop_getextattr_desc, puffs_vnop_checkop },	/* getextattr */
 	{ &vop_setextattr_desc, puffs_vnop_checkop },	/* setextattr */
 	{ &vop_listextattr_desc, puffs_vnop_checkop },	/* listextattr */
 	{ &vop_deleteextattr_desc, puffs_vnop_checkop },/* deleteextattr */
 #if 0
 	{ &vop_openextattr_desc, _openextattr },	/* openextattr */
 	{ &vop_closeextattr_desc, _closeextattr },	/* closeextattr */
 #endif
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc puffs_specop_opv_desc =
 	{ &puffs_specop_p, puffs_specop_entries };
 int (**puffs_fifoop_p)(void *);
 const struct vnodeopv_entry_desc puffs_fifoop_entries[] = {
 	{ &vop_default_desc, vn_default_error },
 	GENFS_FIFOOP_ENTRIES,
 	{ &vop_close_desc, vn_fifo_bypass },		/* close */
 	{ &vop_access_desc, puffs_vnop_checkop },	/* access */
 	{ &vop_accessx_desc, genfs_accessx },		/* accessx */
 	{ &vop_getattr_desc, puffs_vnop_checkop },	/* getattr */
 	{ &vop_setattr_desc, puffs_vnop_checkop },	/* setattr */
 	{ &vop_read_desc, puffs_vnop_fifo_read },	/* read, update */
 	{ &vop_write_desc, puffs_vnop_fifo_write },	/* write, update */
 	{ &vop_fcntl_desc, genfs_fcntl },		/* dummy */
 	{ &vop_fsync_desc, vn_fifo_bypass },		/* genfs_nullop*/
 	{ &vop_inactive_desc, puffs_vnop_inactive },	/* REAL inactive */
 	{ &vop_reclaim_desc, puffs_vnop_reclaim },	/* REAL reclaim */
-	{ &vop_lock_desc, puffs_vnop_lock },		/* REAL lock */
+	{ &vop_lock_desc, genfs_lock },			/* REAL lock */
-	{ &vop_unlock_desc, puffs_vnop_unlock },	/* REAL unlock */
+	{ &vop_unlock_desc, genfs_unlock },		/* REAL unlock */
 	{ &vop_strategy_desc, vn_fifo_bypass },		/* genfs_badop */
 	{ &vop_print_desc, puffs_vnop_print },		/* REAL print */
-	{ &vop_islocked_desc, puffs_vnop_islocked },	/* REAL islocked */
+	{ &vop_islocked_desc, genfs_islocked },		/* REAL islocked */
 	{ &vop_bwrite_desc, vn_bwrite },		/* bwrite */
 #if 0
 	{ &vop_openextattr_desc, _openextattr },	/* openextattr */
 	{ &vop_closeextattr_desc, _closeextattr },	/* closeextattr */
 #endif
 	{ &vop_getextattr_desc, puffs_vnop_checkop },		/* getextattr */
 	{ &vop_setextattr_desc, puffs_vnop_checkop },		/* setextattr */
 	{ &vop_listextattr_desc, puffs_vnop_checkop },	/* listextattr */
 	{ &vop_deleteextattr_desc, puffs_vnop_checkop },	/* deleteextattr */
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc puffs_fifoop_opv_desc =
 	{ &puffs_fifoop_p, puffs_fifoop_entries };
 /* "real" vnode operations */
 int (**puffs_msgop_p)(void *);
 const struct vnodeopv_entry_desc puffs_msgop_entries[] = {
 	{ &vop_default_desc, vn_default_error },
 	{ &vop_parsepath_desc, genfs_parsepath },
 	{ &vop_create_desc, puffs_vnop_create },	/* create */
         { &vop_mknod_desc, puffs_vnop_mknod },		/* mknod */
         { &vop_open_desc, puffs_vnop_open },		/* open */
         { &vop_close_desc, puffs_vnop_close },		/* close */
         { &vop_access_desc, puffs_vnop_access },	/* access */
         { &vop_accessx_desc, genfs_accessx },		/* accessx */
         { &vop_getattr_desc, puffs_vnop_getattr },	/* getattr */
         { &vop_setattr_desc, puffs_vnop_setattr },	/* setattr */
         { &vop_read_desc, puffs_vnop_read },		/* read */
         { &vop_write_desc, puffs_vnop_write },		/* write */
         { &vop_seek_desc, puffs_vnop_seek },		/* seek */
         { &vop_remove_desc, puffs_vnop_remove },	/* remove */
         { &vop_link_desc, puffs_vnop_link },		/* link */
         { &vop_rename_desc, puffs_vnop_rename },	/* rename */
         { &vop_mkdir_desc, puffs_vnop_mkdir },		/* mkdir */
         { &vop_rmdir_desc, puffs_vnop_rmdir },		/* rmdir */
         { &vop_symlink_desc, puffs_vnop_symlink },	/* symlink */
         { &vop_readdir_desc, puffs_vnop_readdir },	/* readdir */
         { &vop_readlink_desc, puffs_vnop_readlink },	/* readlink */
         { &vop_print_desc, puffs_vnop_print },		/* print */
-        { &vop_islocked_desc, puffs_vnop_islocked },	/* islocked */
+        { &vop_islocked_desc, genfs_islocked },		/* islocked */
         { &vop_pathconf_desc, puffs_vnop_pathconf },	/* pathconf */
         { &vop_getpages_desc, puffs_vnop_getpages },	/* getpages */
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc puffs_msgop_opv_desc =
 	{ &puffs_msgop_p, puffs_msgop_entries };
 /*
  * for dosetattr / update_va
  */
 #define SETATTR_CHSIZE	0x01
 #define SETATTR_ASYNC	0x02
 #define ERROUT(err)							\
 do {									\
 	error = err;							\
 	goto out;							\
 } while (/*CONSTCOND*/0)
 /*
  * This is a generic vnode operation handler.  It checks if the necessary
  * operations for the called vnode operation are implemented by userspace
  * and either returns a dummy return value or proceeds to call the real
  * vnode operation from puffs_msgop_v.
+ *
  * XXX: this should described elsewhere and autogenerated, the complexity
  * of the vnode operations vectors and their interrelationships is also
  * getting a bit out of hand.  Another problem is that we need this same
  * information in the fs server code, so keeping the two in sync manually
  * is not a viable (long term) plan.
  */
 /* not supported, handle locking protocol */
 #define CHECKOP_NOTSUPP(op)						\
 case VOP_##op##_DESCOFFSET:						\
 	if (pmp->pmp_vnopmask[PUFFS_VN_##op] == 0)			\
 		return genfs_eopnotsupp(v);				\
 	break
 /* always succeed, no locking */
 #define CHECKOP_SUCCESS(op)						\
 case VOP_##op##_DESCOFFSET:						\
 	if (pmp->pmp_vnopmask[PUFFS_VN_##op] == 0)			\
 		return 0;						\
 	break
 int
 puffs_vnop_checkop(void *v)
+{
 	struct vop_generic_args /* {
 		struct vnodeop_desc *a_desc;
 		spooky mystery contents;
 	} */ *ap = v;
 	struct vnodeop_desc *desc = ap->a_desc;
 	struct puffs_mount *pmp;
 	struct vnode *vp;
 	int offset, rv;
 	offset = ap->a_desc->vdesc_vp_offsets[0];
 #ifdef DIAGNOSTIC
 	if (offset == VDESC_NO_OFFSET)
 		panic("puffs_checkop: no vnode, why did you call me?");
 #endif
 	vp = *VOPARG_OFFSETTO(struct vnode **, offset, ap);
 	pmp = MPTOPUFFSMP(vp->v_mount);
 	DPRINTF_VERBOSE(("checkop call %s (%d), vp %p\n",
 	    ap->a_desc->vdesc_name, ap->a_desc->vdesc_offset, vp));
 	if (!ALLOPS(pmp)) {
 		switch (desc->vdesc_offset) {
 			CHECKOP_NOTSUPP(CREATE);
 			CHECKOP_NOTSUPP(MKNOD);
 			CHECKOP_NOTSUPP(GETATTR);
 			CHECKOP_NOTSUPP(SETATTR);
 			CHECKOP_NOTSUPP(READ);
 			CHECKOP_NOTSUPP(WRITE);
 			CHECKOP_NOTSUPP(FCNTL);
 			CHECKOP_NOTSUPP(IOCTL);
 			CHECKOP_NOTSUPP(REMOVE);
 			CHECKOP_NOTSUPP(LINK);
 			CHECKOP_NOTSUPP(RENAME);
 			CHECKOP_NOTSUPP(MKDIR);
 			CHECKOP_NOTSUPP(RMDIR);
 			CHECKOP_NOTSUPP(SYMLINK);
 			CHECKOP_NOTSUPP(READDIR);
 			CHECKOP_NOTSUPP(READLINK);
 			CHECKOP_NOTSUPP(PRINT);
 			CHECKOP_NOTSUPP(PATHCONF);
 			CHECKOP_NOTSUPP(GETEXTATTR);
 			CHECKOP_NOTSUPP(SETEXTATTR);
 			CHECKOP_NOTSUPP(LISTEXTATTR);
 			CHECKOP_NOTSUPP(DELETEEXTATTR);
 			CHECKOP_SUCCESS(ACCESS);
 			CHECKOP_SUCCESS(CLOSE);
 			CHECKOP_SUCCESS(SEEK);
 		case VOP_GETPAGES_DESCOFFSET:
 			if (!EXISTSOP(pmp, READ))
 				return genfs_eopnotsupp(v);
 			break;
 		default:
 			panic("puffs_checkop: unhandled vnop %d",
 			    desc->vdesc_offset);
+		}
+	}
 	rv = VOCALL(puffs_msgop_p, ap->a_desc->vdesc_offset, v);
 	DPRINTF_VERBOSE(("checkop return %s (%d), vp %p: %d\n",
 	    ap->a_desc->vdesc_name, ap->a_desc->vdesc_offset, vp, rv));
 	return rv;
+}
 static int callremove(struct puffs_mount *, puffs_cookie_t, puffs_cookie_t,
 			    struct componentname *);
 static int callrmdir(struct puffs_mount *, puffs_cookie_t, puffs_cookie_t,
 			   struct componentname *);
 static void callinactive(struct puffs_mount *, puffs_cookie_t, int);
 static void callreclaim(struct puffs_mount *, puffs_cookie_t, int);
 static int  flushvncache(struct vnode *, off_t, off_t, bool);
 static void update_va(struct vnode *, struct vattr *, struct vattr *,
 		      struct timespec *, struct timespec *, int);
 static void update_parent(struct vnode *, struct vnode *);
 #define PUFFS_ABORT_LOOKUP	1
 #define PUFFS_ABORT_CREATE	2
 #define PUFFS_ABORT_MKNOD	3
 #define PUFFS_ABORT_MKDIR	4
 #define PUFFS_ABORT_SYMLINK	5
 /*
  * Press the pani^Wabort button!  Kernel resource allocation failed.
  */
 static void
 puffs_abortbutton(struct puffs_mount *pmp, int what,
 	puffs_cookie_t dck, puffs_cookie_t ck, struct componentname *cnp)
+{
 	switch (what) {
 	case PUFFS_ABORT_CREATE:
 	case PUFFS_ABORT_MKNOD:
 	case PUFFS_ABORT_SYMLINK:
 		callremove(pmp, dck, ck, cnp);
 		break;
 	case PUFFS_ABORT_MKDIR:
 		callrmdir(pmp, dck, ck, cnp);
 		break;
+	}
 	callinactive(pmp, ck, 0);
 	callreclaim(pmp, ck, 1);
+}
 /*
  * Begin vnode operations.
+ *
  * A word from the keymaster about locks: generally we don't want
  * to use the vnode locks at all: it creates an ugly dependency between
  * the userlandia file server and the kernel.  But we'll play along with
  * the kernel vnode locks for now.  However, even currently we attempt
  * to release locks as early as possible.  This is possible for some
  * operations which a) don't need a locked vnode after the userspace op
  * and b) return with the vnode unlocked.  Theoretically we could
  * unlock-do op-lock for others and order the graph in userspace, but I
  * don't want to think of the consequences for the time being.
  */
 #define TTL_TO_TIMEOUT(ts) \
     (getticks() + (ts->tv_sec * hz) + (ts->tv_nsec * hz / 1000000000))
 #define TTL_VALID(ts) \
     ((ts != NULL) && !((ts->tv_sec == 0) && (ts->tv_nsec == 0)))
 #define TIMED_OUT(expire) \
     ((int)((unsigned int)getticks() - (unsigned int)expire) > 0)
 int
 puffs_vnop_lookup(void *v)
+{
         struct vop_lookup_v2_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
         } */ *ap = v;
 	PUFFS_MSG_VARS(vn, lookup);
 	struct puffs_mount *pmp;
 	struct componentname *cnp;
 	struct vnode *vp, *dvp, *cvp;
 	struct puffs_node *dpn, *cpn;
 	int isdot;
 	int error;
 	pmp = MPTOPUFFSMP(ap->a_dvp->v_mount);
 	cnp = ap->a_cnp;
 	dvp = ap->a_dvp;
 	cvp = NULL;
 	cpn = NULL;
 	*ap->a_vpp = NULL;
 	/* r/o fs?  we check create later to handle EEXIST */
 	if ((cnp->cn_flags & ISLASTCN)
 	    && (dvp->v_mount->mnt_flag & MNT_RDONLY)
 	    && (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
 		return EROFS;
 	isdot = cnp->cn_namelen == 1 && *cnp->cn_nameptr == '.';
 	DPRINTF(("puffs_lookup: \"%s\", parent vnode %p, op: %x\n",
 	    cnp->cn_nameptr, dvp, cnp->cn_nameiop));
 	/*
 	 * If dotdot cache is enabled, add reference to .. and return.
 	 */
 	if (PUFFS_USE_DOTDOTCACHE(pmp) && (cnp->cn_flags & ISDOTDOT)) {
 		vp = VPTOPP(ap->a_dvp)->pn_parent;
 		vref(vp);
 		*ap->a_vpp = vp;
 		return 0;
+	}
 	/*
 	 * Check if someone fed it into the cache
 	 */
 	if (!isdot && PUFFS_USE_NAMECACHE(pmp)) {
 		int found, iswhiteout;
 		found = cache_lookup(dvp, cnp->cn_nameptr, cnp->cn_namelen,
 				     cnp->cn_nameiop, cnp->cn_flags,
 				     &iswhiteout, ap->a_vpp);
 		if (iswhiteout) {
 			cnp->cn_flags |= ISWHITEOUT;
+		}
 		if (found && *ap->a_vpp != NULLVP && PUFFS_USE_FS_TTL(pmp)) {
 			cvp = *ap->a_vpp;
 			cpn = VPTOPP(cvp);
 			if (TIMED_OUT(cpn->pn_cn_timeout)) {
 				cache_purge(cvp);
 				/*
 				 * cached vnode (cvp) is still referenced
 				 * so that we can reuse it upon a new
 				 * successful lookup.
 				 */
 				*ap->a_vpp = NULL;
 				found = 0;
+			}
+		}
 		/*
 		 * Do not use negative caching, since the filesystem
 		 * provides no TTL for it.
 		 */
 		if (found && *ap->a_vpp == NULLVP && PUFFS_USE_FS_TTL(pmp))
 			found = 0;
 		if (found) {
 			return *ap->a_vpp == NULLVP ? ENOENT : 0;
+		}
 		/*
 		 * This is what would have been left in ERROR before
 		 * the rearrangement of cache_lookup(). What with all
 		 * the macros, I am not sure if this is a dead value
 		 * below or not.
 		 */
 		error = -1;
+	}
 	if (isdot) {
 		/* deal with rename lookup semantics */
 		if (cnp->cn_nameiop == RENAME && (cnp->cn_flags & ISLASTCN))
 			return EISDIR;
 		vp = ap->a_dvp;
 		vref(vp);
 		*ap->a_vpp = vp;
 		return 0;
+	}
 	if (cvp != NULL) {
 		if (vn_lock(cvp, LK_EXCLUSIVE) != 0) {
 			vrele(cvp);
 			cvp = NULL;
 		} else
 			mutex_enter(&cpn->pn_sizemtx);
+	}
 	PUFFS_MSG_ALLOC(vn, lookup);
 	puffs_makecn(&lookup_msg->pvnr_cn, &lookup_msg->pvnr_cn_cred,
 	    cnp, PUFFS_USE_FULLPNBUF(pmp));
 	if (cnp->cn_flags & ISDOTDOT)
 		VOP_UNLOCK(dvp);
 	puffs_msg_setinfo(park_lookup, PUFFSOP_VN,
 	    PUFFS_VN_LOOKUP, VPTOPNC(dvp));
 	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_lookup, dvp->v_data, NULL, error);
 	DPRINTF(("puffs_lookup: return of the userspace, part %d\n", error));
 	/*
 	 * In case of error, there is no new vnode to play with, so be
 	 * happy with the NULL value given to vpp in the beginning.
 	 * Also, check if this really was an error or the target was not
 	 * present.  Either treat it as a non-error for CREATE/RENAME or
 	 * enter the component into the negative name cache (if desired).
 	 */
 	if (error) {
 		error = checkerr(pmp, error, __func__);
 		if (error == ENOENT) {
 			/* don't allow to create files on r/o fs */
 			if ((dvp->v_mount->mnt_flag & MNT_RDONLY)
 			    && cnp->cn_nameiop == CREATE) {
 				error = EROFS;
 			/* adjust values if we are creating */
 			} else if ((cnp->cn_flags & ISLASTCN)
 			    && (cnp->cn_nameiop == CREATE
 			      || cnp->cn_nameiop == RENAME)) {
 				error = EJUSTRETURN;
 			/* save negative cache entry */
 			} else {
 				if (PUFFS_USE_NAMECACHE(pmp) &&
 				    !PUFFS_USE_FS_TTL(pmp))
 					cache_enter(dvp, NULL, cnp->cn_nameptr,
 						cnp->cn_namelen, cnp->cn_flags);
+			}
+		}
 		goto out;
+	}
 	/*
 	 * Check that we don't get our parent node back, that would cause
 	 * a pretty obvious deadlock.
 	 */
 	dpn = dvp->v_data;
 	if (lookup_msg->pvnr_newnode == dpn->pn_cookie) {
 		puffs_senderr(pmp, PUFFS_ERR_LOOKUP, EINVAL,
 		    "lookup produced parent cookie", lookup_msg->pvnr_newnode);
 		error = EPROTO;
 		goto out;
+	}
 	/*
 	 * Check if we looked up the cached vnode
 	 */
 	vp = NULL;
 	if (cvp && (VPTOPP(cvp)->pn_cookie == lookup_msg->pvnr_newnode)) {
 		int grace;
 		/*
 		 * Bump grace time of this node so that it does not get
 		 * reclaimed too fast. We try to increase a bit more the
 		 * lifetime of busiest * nodes - with some limits.
 		 */
 		grace = 10 * puffs_sopreq_expire_timeout;
 		cpn->pn_cn_grace = getticks() + grace;
 		vp = cvp;
+	}
 	/*
 	 * No cached vnode available, or the cached vnode does not
 	 * match the userland cookie anymore: is the node known?
 	 */
 	if (vp == NULL) {
 		error = puffs_getvnode(dvp->v_mount,
 		    lookup_msg->pvnr_newnode, lookup_msg->pvnr_vtype,
 		    lookup_msg->pvnr_size, lookup_msg->pvnr_rdev, &vp);
 		if (error) {
 			puffs_abortbutton(pmp, PUFFS_ABORT_LOOKUP,
 			    VPTOPNC(dvp), lookup_msg->pvnr_newnode,
 			    ap->a_cnp);
 			goto out;
+		}
 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
+	}
 	/*
 	 * Update cache and TTL
 	 */
 	if (PUFFS_USE_FS_TTL(pmp)) {
 		struct timespec *va_ttl = &lookup_msg->pvnr_va_ttl;
 		struct timespec *cn_ttl = &lookup_msg->pvnr_cn_ttl;
 		update_va(vp, NULL, &lookup_msg->pvnr_va,
 			  va_ttl, cn_ttl, SETATTR_CHSIZE);
+	}
 	KASSERT(lookup_msg->pvnr_newnode == VPTOPP(vp)->pn_cookie);
 	*ap->a_vpp = vp;
 	if (PUFFS_USE_NAMECACHE(pmp))
 		cache_enter(dvp, vp, cnp->cn_nameptr, cnp->cn_namelen,
 			    cnp->cn_flags);
 	/* XXX */
 	if ((lookup_msg->pvnr_cn.pkcn_flags & REQUIREDIR) == 0)
 		cnp->cn_flags &= ~REQUIREDIR;
 	if (lookup_msg->pvnr_cn.pkcn_consume) {
 		printf("puffs: warning: ignoring cn_consume of %zu chars\n",
 		    lookup_msg->pvnr_cn.pkcn_consume);
+	}
 	VPTOPP(vp)->pn_nlookup++;
 	if (PUFFS_USE_DOTDOTCACHE(pmp) &&
 	    (VPTOPP(vp)->pn_parent != dvp))
 		update_parent(vp, dvp);
  out:
 	if (cvp != NULL) {
 		mutex_exit(&cpn->pn_sizemtx);
 		if (error || (cvp != vp))
 			vput(cvp);
+	}
 	if (error == 0)
 		VOP_UNLOCK(*ap->a_vpp);
 	if (cnp->cn_flags & ISDOTDOT)
 		vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
 	DPRINTF(("puffs_lookup: returning %d %p\n", error, *ap->a_vpp));
 	PUFFS_MSG_RELEASE(lookup);
 	return error;
+}
 #define REFPN_AND_UNLOCKVP(a, b)					\
 do {									\
 	mutex_enter(&b->pn_mtx);					\
 	puffs_referencenode(b);						\
 	mutex_exit(&b->pn_mtx);						\
 	VOP_UNLOCK(a);						\
 } while (/*CONSTCOND*/0)
 #define REFPN(b)							\
 do {									\
 	mutex_enter(&b->pn_mtx);					\
 	puffs_referencenode(b);						\
 	mutex_exit(&b->pn_mtx);						\
 } while (/*CONSTCOND*/0)
 #define RELEPN_AND_VP(a, b)						\
 do {									\
 	puffs_releasenode(b);						\
 	vrele(a);							\
 } while (/*CONSTCOND*/0)
 int
 puffs_vnop_create(void *v)
+{
 	struct vop_create_v3_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
 		struct vattr *a_vap;
 	} */ *ap = v;
 	PUFFS_MSG_VARS(vn, create);
 	struct vnode *dvp = ap->a_dvp;
 	struct puffs_node *dpn = VPTOPP(dvp);
 	struct componentname *cnp = ap->a_cnp;
 	struct mount *mp = dvp->v_mount;
 	struct puffs_mount *pmp = MPTOPUFFSMP(mp);
 	int error;
 	DPRINTF(("puffs_create: dvp %p, cnp: %s\n",
 	    dvp, ap->a_cnp->cn_nameptr));
 	PUFFS_MSG_ALLOC(vn, create);
 	puffs_makecn(&create_msg->pvnr_cn, &create_msg->pvnr_cn_cred,
 	    cnp, PUFFS_USE_FULLPNBUF(pmp));
 	create_msg->pvnr_va = *ap->a_vap;
 	puffs_msg_setinfo(park_create, PUFFSOP_VN,
 	    PUFFS_VN_CREATE, VPTOPNC(dvp));
 	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_create, dvp->v_data, NULL, error);
 	error = checkerr(pmp, error, __func__);
 	if (error)
 		goto out;
 	error = puffs_newnode(mp, dvp, ap->a_vpp,
 	    create_msg->pvnr_newnode, cnp, ap->a_vap->va_type, 0);
 	if (error) {
 		puffs_abortbutton(pmp, PUFFS_ABORT_CREATE, dpn->pn_cookie,
 		    create_msg->pvnr_newnode, cnp);
 		goto out;
+	}
 	if (PUFFS_USE_FS_TTL(pmp)) {
 		struct timespec *va_ttl = &create_msg->pvnr_va_ttl;
 		struct timespec *cn_ttl = &create_msg->pvnr_cn_ttl;
 		struct vattr *rvap = &create_msg->pvnr_va;
 		update_va(*ap->a_vpp, NULL, rvap,
 			  va_ttl, cn_ttl, SETATTR_CHSIZE);
+	}
 	VPTOPP(*ap->a_vpp)->pn_nlookup++;
 	if (PUFFS_USE_DOTDOTCACHE(pmp) &&
 	    (VPTOPP(*ap->a_vpp)->pn_parent != dvp))
 		update_parent(*ap->a_vpp, dvp);
  out:
 	DPRINTF(("puffs_create: return %d\n", error));
 	PUFFS_MSG_RELEASE(create);
 	return error;
+}
 int
 puffs_vnop_mknod(void *v)
+{
 	struct vop_mknod_v3_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
 		struct vattr *a_vap;
 	} */ *ap = v;
 	PUFFS_MSG_VARS(vn, mknod);
 	struct vnode *dvp = ap->a_dvp;
 	struct puffs_node *dpn = VPTOPP(dvp);
 	struct componentname *cnp = ap->a_cnp;
 	struct mount *mp = dvp->v_mount;
 	struct puffs_mount *pmp = MPTOPUFFSMP(mp);
 	int error;
 	PUFFS_MSG_ALLOC(vn, mknod);
 	puffs_makecn(&mknod_msg->pvnr_cn, &mknod_msg->pvnr_cn_cred,
 	    cnp, PUFFS_USE_FULLPNBUF(pmp));
 	mknod_msg->pvnr_va = *ap->a_vap;
 	puffs_msg_setinfo(park_mknod, PUFFSOP_VN,
 	    PUFFS_VN_MKNOD, VPTOPNC(dvp));
 	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_mknod, dvp->v_data, NULL, error);
 	error = checkerr(pmp, error, __func__);
 	if (error)
 		goto out;
 	error = puffs_newnode(mp, dvp, ap->a_vpp,
 	    mknod_msg->pvnr_newnode, cnp, ap->a_vap->va_type,
 	    ap->a_vap->va_rdev);
 	if (error) {
 		puffs_abortbutton(pmp, PUFFS_ABORT_MKNOD, dpn->pn_cookie,
 		    mknod_msg->pvnr_newnode, cnp);
 		goto out;
+	}
 	if (PUFFS_USE_FS_TTL(pmp)) {
 		struct timespec *va_ttl = &mknod_msg->pvnr_va_ttl;
 		struct timespec *cn_ttl = &mknod_msg->pvnr_cn_ttl;
 		struct vattr *rvap = &mknod_msg->pvnr_va;
 		update_va(*ap->a_vpp, NULL, rvap,
 			   va_ttl, cn_ttl, SETATTR_CHSIZE);
+	}
 	VPTOPP(*ap->a_vpp)->pn_nlookup++;
 	if (PUFFS_USE_DOTDOTCACHE(pmp) &&
 	    (VPTOPP(*ap->a_vpp)->pn_parent != dvp))
 		update_parent(*ap->a_vpp, dvp);
  out:
 	PUFFS_MSG_RELEASE(mknod);
 	return error;
+}
 int
 puffs_vnop_open(void *v)
+{
 	struct vop_open_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_vp;
 		int a_mode;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	PUFFS_MSG_VARS(vn, open);
 	struct vnode *vp = ap->a_vp;
 	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
 	struct puffs_node *pn = VPTOPP(vp);
 	int mode = ap->a_mode;
 	int error;
 	DPRINTF(("puffs_open: vp %p, mode 0x%x\n", vp, mode));
 	if (vp->v_type == VREG && mode & FWRITE && !EXISTSOP(pmp, WRITE))
 		ERROUT(EROFS);
 	if (!EXISTSOP(pmp, OPEN))
 		ERROUT(0);
 	PUFFS_MSG_ALLOC(vn, open);
 	open_msg->pvnr_mode = mode;
 	puffs_credcvt(&open_msg->pvnr_cred, ap->a_cred);
 	puffs_msg_setinfo(park_open, PUFFSOP_VN,
 	    PUFFS_VN_OPEN, VPTOPNC(vp));
 	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_open, vp->v_data, NULL, error);
 	error = checkerr(pmp, error, __func__);
 	if (open_msg->pvnr_oflags & PUFFS_OPEN_IO_DIRECT) {
 		/*
 		 * Flush cache:
 		 * - we do not want to discard cached write by direct write
 		 * - read cache is now useless and should be freed
 		 */
 		mutex_enter(&pn->pn_sizemtx);
 		flushvncache(vp, 0, 0, true);
 		mutex_exit(&pn->pn_sizemtx);
 		if (mode & FREAD)
 			pn->pn_stat |= PNODE_RDIRECT;
 		if (mode & FWRITE)
 			pn->pn_stat |= PNODE_WDIRECT;
+	}
  out:
 	DPRINTF(("puffs_open: returning %d\n", error));
 	PUFFS_MSG_RELEASE(open);
 	return error;
+}
 int
 puffs_vnop_close(void *v)
+{
 	struct vop_close_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_vp;
 		int a_fflag;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	PUFFS_MSG_VARS(vn, close);
 	struct vnode *vp = ap->a_vp;
 	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
 	PUFFS_MSG_ALLOC(vn, close);
 	puffs_msg_setfaf(park_close);
 	close_msg->pvnr_fflag = ap->a_fflag;
 	puffs_credcvt(&close_msg->pvnr_cred, ap->a_cred);
 	puffs_msg_setinfo(park_close, PUFFSOP_VN,
 	    PUFFS_VN_CLOSE, VPTOPNC(vp));
 	puffs_msg_enqueue(pmp, park_close);
 	PUFFS_MSG_RELEASE(close);
 	return 0;
+}
 int
 puffs_vnop_access(void *v)
+{
 	struct vop_access_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_vp;
 		accmode_t a_accmode;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	PUFFS_MSG_VARS(vn, access);
 	struct vnode *vp = ap->a_vp;
 	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
 	accmode_t accmode = ap->a_accmode;
 	int error;
 	if (accmode & VWRITE) {
 		switch (vp->v_type) {
 		case VDIR:
 		case VLNK:
 		case VREG:
 			if ((vp->v_mount->mnt_flag & MNT_RDONLY)
 			    || !EXISTSOP(pmp, WRITE))
 				return EROFS;
 			break;
 		default:
 			break;
+		}
+	}
 	if (!EXISTSOP(pmp, ACCESS))
 		return 0;
 	PUFFS_MSG_ALLOC(vn, access);
 	access_msg->pvnr_mode = ap->a_accmode;
 	puffs_credcvt(&access_msg->pvnr_cred, ap->a_cred);
 	puffs_msg_setinfo(park_access, PUFFSOP_VN,
 	    PUFFS_VN_ACCESS, VPTOPNC(vp));
 	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_access, vp->v_data, NULL, error);
 	error = checkerr(pmp, error, __func__);
 	PUFFS_MSG_RELEASE(access);
 	return error;
+}
 static void
 update_va(struct vnode *vp, struct vattr *vap, struct vattr *rvap,
 	  struct timespec *va_ttl, struct timespec *cn_ttl, int flags)
+{
 	struct puffs_node *pn = VPTOPP(vp);
 	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
 	int use_metacache;
 	if (TTL_VALID(cn_ttl)) {
 		pn->pn_cn_timeout = TTL_TO_TIMEOUT(cn_ttl);
 		pn->pn_cn_grace = MAX(pn->pn_cn_timeout, pn->pn_cn_grace);
+	}
 	/*
 	 * Don't listen to the file server regarding special device
 	 * size info, the file server doesn't know anything about them.
 	 */
 	if (vp->v_type == VBLK || vp->v_type == VCHR)
 		rvap->va_size = vp->v_size;
 	/* Ditto for blocksize (ufs comment: this doesn't belong here) */
 	if (vp->v_type == VBLK)
 		rvap->va_blocksize = BLKDEV_IOSIZE;
 	else if (vp->v_type == VCHR)
 		rvap->va_blocksize = MAXBSIZE;
 	if (vap != NULL) {
 		(void) memcpy(vap, rvap, sizeof(struct vattr));
 		vap->va_fsid = vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0];
 		if (PUFFS_USE_METAFLUSH(pmp)) {
 			if (pn->pn_stat & PNODE_METACACHE_ATIME)
 				vap->va_atime = pn->pn_mc_atime;
 			if (pn->pn_stat & PNODE_METACACHE_CTIME)
 				vap->va_ctime = pn->pn_mc_ctime;
 			if (pn->pn_stat & PNODE_METACACHE_MTIME)
 				vap->va_mtime = pn->pn_mc_mtime;
 			if (pn->pn_stat & PNODE_METACACHE_SIZE)
 				vap->va_size = pn->pn_mc_size;
+		}
+	}
 	use_metacache = PUFFS_USE_METAFLUSH(pmp) &&
 			(pn->pn_stat & PNODE_METACACHE_SIZE);
 	if (!use_metacache && (flags & SETATTR_CHSIZE)) {
 		if (rvap->va_size != VNOVAL
 		    && vp->v_type != VBLK && vp->v_type != VCHR) {
 			uvm_vnp_setsize(vp, rvap->va_size);
 			pn->pn_serversize = rvap->va_size;
+		}
+	}
 	if ((va_ttl != NULL) && TTL_VALID(va_ttl)) {
 		if (pn->pn_va_cache == NULL)
 			pn->pn_va_cache = pool_get(&puffs_vapool, PR_WAITOK);
 		(void)memcpy(pn->pn_va_cache, rvap, sizeof(*rvap));
 		pn->pn_va_timeout = TTL_TO_TIMEOUT(va_ttl);
+	}
+}
 static void
 update_parent(struct vnode *vp, struct vnode *dvp)
+{
 	struct puffs_node *pn = VPTOPP(vp);
 	if (pn->pn_parent != NULL) {
 		KASSERT(pn->pn_parent != dvp);
 		vrele(pn->pn_parent);
+	}
 	vref(dvp);
 	pn->pn_parent = dvp;
+}
 int
 puffs_vnop_getattr(void *v)
+{
 	struct vop_getattr_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_vp;
 		struct vattr *a_vap;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	PUFFS_MSG_VARS(vn, getattr);
 	struct vnode *vp = ap->a_vp;
 	struct mount *mp = vp->v_mount;
 	struct puffs_mount *pmp = MPTOPUFFSMP(mp);
 	struct vattr *vap, *rvap;
 	struct puffs_node *pn = VPTOPP(vp);
 	struct timespec *va_ttl = NULL;
 	int error = 0;
 	/*
 	 * A lock is required so that we do not race with
 	 * setattr, write and fsync when changing vp->v_size.
 	 * This is critical, since setting a stall smaler value
 	 * triggers a file truncate in uvm_vnp_setsize(), which
 	 * most of the time means data corruption (a chunk of
 	 * data is replaced by zeroes). This can be removed if
 	 * we decide one day that VOP_GETATTR must operate on
 	 * a locked vnode.
+	 *
 	 * XXX Should be useless now that VOP_GETATTR has been
 	 *     fixed to always require a shared lock at least.
 	 */
 	mutex_enter(&pn->pn_sizemtx);
 	REFPN(pn);
 	vap = ap->a_vap;
 	if (PUFFS_USE_FS_TTL(pmp)) {
 		if (!TIMED_OUT(pn->pn_va_timeout)) {
 			update_va(vp, vap, pn->pn_va_cache,
 				  NULL, NULL, SETATTR_CHSIZE);
 			goto out2;
+		}
+	}
 	PUFFS_MSG_ALLOC(vn, getattr);
 	vattr_null(&getattr_msg->pvnr_va);
 	puffs_credcvt(&getattr_msg->pvnr_cred, ap->a_cred);
 	puffs_msg_setinfo(park_getattr, PUFFSOP_VN,
 	    PUFFS_VN_GETATTR, VPTOPNC(vp));
 	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_getattr, vp->v_data, NULL, error);
 	error = checkerr(pmp, error, __func__);
 	if (error)
 		goto out;
 	rvap = &getattr_msg->pvnr_va;
 	if (PUFFS_USE_FS_TTL(pmp))
 		va_ttl = &getattr_msg->pvnr_va_ttl;
 	update_va(vp, vap, rvap, va_ttl, NULL, SETATTR_CHSIZE);
  out:
 	PUFFS_MSG_RELEASE(getattr);
  out2:
 	puffs_releasenode(pn);
 	mutex_exit(&pn->pn_sizemtx);
 	return error;
+}
 static void
 zerofill_lastpage(struct vnode *vp, voff_t off)
+{
 	if (trunc_page(off) == off)
 		return;
 	if (vp->v_writecount == 0)
 		return;
 	vsize_t len = round_page(off) - off;
 	ubc_zerorange(&vp->v_uobj, off, len, UBC_WRITE|UBC_VNODE_FLAGS(vp));
+}
 static int
 dosetattr(struct vnode *vp, struct vattr *vap, kauth_cred_t cred, int flags)
+{
 	PUFFS_MSG_VARS(vn, setattr);
 	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
 	struct puffs_node *pn = vp->v_data;
 	vsize_t oldsize = vp->v_size;
 	int error = 0;
 	KASSERT(!(flags & SETATTR_CHSIZE) || mutex_owned(&pn->pn_sizemtx));
 	if ((vp->v_mount->mnt_flag & MNT_RDONLY) &&
 	    (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL
 	    || vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL
 	    || vap->va_mode != (mode_t)VNOVAL))
 		return EROFS;
 	if ((vp->v_mount->mnt_flag & MNT_RDONLY)
 	    && vp->v_type == VREG && vap->va_size != VNOVAL)
 		return EROFS;
 	/*
 	 * Flush metacache first.  If we are called with some explicit
 	 * parameters, treat them as information overriding metacache
 	 * information.
 	 */
 	if (PUFFS_USE_METAFLUSH(pmp) && pn->pn_stat & PNODE_METACACHE_MASK) {
 		if ((pn->pn_stat & PNODE_METACACHE_ATIME)
 		    && vap->va_atime.tv_sec == VNOVAL)
 			vap->va_atime = pn->pn_mc_atime;
 		if ((pn->pn_stat & PNODE_METACACHE_CTIME)
 		    && vap->va_ctime.tv_sec == VNOVAL)
 			vap->va_ctime = pn->pn_mc_ctime;
 		if ((pn->pn_stat & PNODE_METACACHE_MTIME)
 		    && vap->va_mtime.tv_sec == VNOVAL)
 			vap->va_mtime = pn->pn_mc_mtime;
 		if ((pn->pn_stat & PNODE_METACACHE_SIZE)
 		    && vap->va_size == VNOVAL)
 			vap->va_size = pn->pn_mc_size;
 		pn->pn_stat &= ~PNODE_METACACHE_MASK;
+	}
 	/*
 	 * Flush attribute cache so that another thread do
 	 * not get a stale value during the operation.
 	 */
 	if (PUFFS_USE_FS_TTL(pmp))
 		pn->pn_va_timeout = 0;
 	PUFFS_MSG_ALLOC(vn, setattr);
 	(void)memcpy(&setattr_msg->pvnr_va, vap, sizeof(struct vattr));
 	puffs_credcvt(&setattr_msg->pvnr_cred, cred);
 	puffs_msg_setinfo(park_setattr, PUFFSOP_VN,
 	    PUFFS_VN_SETATTR, VPTOPNC(vp));
 	if (flags & SETATTR_ASYNC)
 		puffs_msg_setfaf(park_setattr);
 	puffs_msg_enqueue(pmp, park_setattr);
 	if ((flags & SETATTR_ASYNC) == 0) {
 		error = puffs_msg_wait2(pmp, park_setattr, vp->v_data, NULL);
 		if ((error == 0) && PUFFS_USE_FS_TTL(pmp)) {
 			struct timespec *va_ttl = &setattr_msg->pvnr_va_ttl;
 			struct vattr *rvap = &setattr_msg->pvnr_va;
 			update_va(vp, NULL, rvap, va_ttl, NULL, flags);
+		}
+	}
 	PUFFS_MSG_RELEASE(setattr);
 	if ((flags & SETATTR_ASYNC) == 0) {
 		error = checkerr(pmp, error, __func__);
 		if (error)
 			return error;
 	} else {
 		error = 0;
+	}
 	if (vap->va_size != VNOVAL) {
 		/*
 		 * If we truncated the file, make sure the data beyond
 		 * EOF in last page does not remain in cache, otherwise
 		 * if the file is later truncated to a larger size (creating
 		 * a hole), that area will not return zeroes as it
 		 * should.
 		 */
 		if ((flags & SETATTR_CHSIZE) && PUFFS_USE_PAGECACHE(pmp) &&
 		    (vap->va_size < oldsize))
 			zerofill_lastpage(vp, vap->va_size);
 		pn->pn_serversize = vap->va_size;
 		if (flags & SETATTR_CHSIZE)
 			uvm_vnp_setsize(vp, vap->va_size);
 		puffs_updatenode(pn, PUFFS_UPDATECTIME | PUFFS_UPDATEMTIME, 0);
+	}
 	return 0;
+}
 int
 puffs_vnop_setattr(void *v)
+{
 	struct vop_getattr_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_vp;
 		struct vattr *a_vap;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	struct puffs_node *pn = ap->a_vp->v_data;
 	int error;
 	mutex_enter(&pn->pn_sizemtx);
 	error = dosetattr(ap->a_vp, ap->a_vap, ap->a_cred, SETATTR_CHSIZE);
 	mutex_exit(&pn->pn_sizemtx);
 	return error;
+}
 static __inline int
 doinact(struct puffs_mount *pmp, int iaflag)
+{
 	if (EXISTSOP(pmp, INACTIVE))
 		if (pmp->pmp_flags & PUFFS_KFLAG_IAONDEMAND)
 			if (iaflag || ALLOPS(pmp))
 				return 1;
 			else
 				return 0;
 		else
 			return 1;
 	else
 		return 0;
+}
 static void
 callinactive(struct puffs_mount *pmp, puffs_cookie_t ck, int iaflag)

 @@ -1,117 +1,117 @@
-/*	$NetBSD: tmpfs_fifoops.c,v 1.14 2021/07/18 23:56:13 dholland Exp $	*/
+/*	$NetBSD: tmpfs_fifoops.c,v 1.15 2021/07/19 01:30:25 dholland Exp $	*/
 /*
  * Copyright (c) 2005 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
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * 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 for named pipes.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: tmpfs_fifoops.c,v 1.14 2021/07/18 23:56:13 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: tmpfs_fifoops.c,v 1.15 2021/07/19 01:30:25 dholland Exp $");
 #include <sys/param.h>
 #include <sys/vnode.h>
 #include <fs/tmpfs/tmpfs.h>
 #include <fs/tmpfs/tmpfs_fifoops.h>
 /*
  * vnode operations vector used for fifos stored in a tmpfs file system.
  */
 int (**tmpfs_fifoop_p)(void *);
 const struct vnodeopv_entry_desc tmpfs_fifoop_entries[] = {
 	{ &vop_default_desc,		vn_default_error },
 	GENFS_FIFOOP_ENTRIES,
 	{ &vop_close_desc,		tmpfs_fifo_close },
-	{ &vop_access_desc,		tmpfs_fifo_access },
+	{ &vop_access_desc,		tmpfs_access },
 	{ &vop_accessx_desc,		genfs_accessx },
-	{ &vop_getattr_desc,		tmpfs_fifo_getattr },
+	{ &vop_getattr_desc,		tmpfs_getattr },
-	{ &vop_setattr_desc,		tmpfs_fifo_setattr },
+	{ &vop_setattr_desc,		tmpfs_setattr },
 	{ &vop_read_desc,		tmpfs_fifo_read },
 	{ &vop_write_desc,		tmpfs_fifo_write },
-	{ &vop_fcntl_desc,		tmpfs_fifo_fcntl },
+	{ &vop_fcntl_desc,		genfs_fcntl },
-	{ &vop_fsync_desc,		tmpfs_fifo_fsync },
+	{ &vop_fsync_desc,		vn_fifo_bypass },
-	{ &vop_inactive_desc,		tmpfs_fifo_inactive },
+	{ &vop_inactive_desc,		tmpfs_inactive },
-	{ &vop_reclaim_desc,		tmpfs_fifo_reclaim },
+	{ &vop_reclaim_desc,		tmpfs_reclaim },
-	{ &vop_lock_desc,		tmpfs_fifo_lock },
+	{ &vop_lock_desc,		genfs_lock },
-	{ &vop_unlock_desc,		tmpfs_fifo_unlock },
+	{ &vop_unlock_desc,		genfs_unlock },
-	{ &vop_strategy_desc,		tmpfs_fifo_strategy },
+	{ &vop_strategy_desc,		vn_fifo_bypass },
-	{ &vop_print_desc,		tmpfs_fifo_print },
+	{ &vop_print_desc,		tmpfs_print },
-	{ &vop_islocked_desc,		tmpfs_fifo_islocked },
+	{ &vop_islocked_desc,		genfs_islocked },
-	{ &vop_bwrite_desc,		tmpfs_fifo_bwrite },
+	{ &vop_bwrite_desc,		genfs_nullop },
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc tmpfs_fifoop_opv_desc = {
 	&tmpfs_fifoop_p, tmpfs_fifoop_entries
 };
 int
 tmpfs_fifo_close(void *v)
+{
 	struct vop_close_args /* {
 		struct vnode	*a_vp;
 		int		a_fflag;
 		kauth_cred_t	a_cred;
 	} */ *ap __unused = v;
 	return VOCALL(fifo_vnodeop_p, VOFFSET(vop_close), v);
+}
 int
 tmpfs_fifo_read(void *v)
+{
 	struct vop_read_args /* {
 		struct vnode *a_vp;
 		struct uio *a_uio;
 		int a_ioflag;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	vnode_t *vp = ap->a_vp;
 	tmpfs_update(vp, TMPFS_UPDATE_ATIME);
 	return VOCALL(fifo_vnodeop_p, VOFFSET(vop_read), v);
+}
 int
 tmpfs_fifo_write(void *v)
+{
 	struct vop_write_args /* {
 		struct vnode *a_vp;
 		struct uio *a_uio;
 		int a_ioflag;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	vnode_t *vp = ap->a_vp;
 	tmpfs_update(vp, TMPFS_UPDATE_MTIME);
 	return VOCALL(fifo_vnodeop_p, VOFFSET(vop_write), v);
+}

 @@ -1,119 +1,119 @@
-/*	$NetBSD: tmpfs_specops.c,v 1.15 2021/07/18 23:56:13 dholland Exp $	*/
+/*	$NetBSD: tmpfs_specops.c,v 1.16 2021/07/19 01:30:25 dholland Exp $	*/
 /*
  * Copyright (c) 2005 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
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * 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 for special devices.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: tmpfs_specops.c,v 1.15 2021/07/18 23:56:13 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: tmpfs_specops.c,v 1.16 2021/07/19 01:30:25 dholland Exp $");
 #include <sys/param.h>
 #include <sys/vnode.h>
 #include <fs/tmpfs/tmpfs.h>
 #include <fs/tmpfs/tmpfs_specops.h>
 /*
  * vnode operations vector used for special devices stored in a tmpfs
  * file system.
  */
 int (**tmpfs_specop_p)(void *);
 const struct vnodeopv_entry_desc tmpfs_specop_entries[] = {
 	{ &vop_default_desc,		vn_default_error },
 	GENFS_SPECOP_ENTRIES,
 	{ &vop_close_desc,		tmpfs_spec_close },
-	{ &vop_access_desc,		tmpfs_spec_access },
+	{ &vop_access_desc,		tmpfs_access },
 	{ &vop_accessx_desc,		genfs_accessx },
-	{ &vop_getattr_desc,		tmpfs_spec_getattr },
+	{ &vop_getattr_desc,		tmpfs_getattr },
-	{ &vop_setattr_desc,		tmpfs_spec_setattr },
+	{ &vop_setattr_desc,		tmpfs_setattr },
 	{ &vop_read_desc,		tmpfs_spec_read },
 	{ &vop_write_desc,		tmpfs_spec_write },
-	{ &vop_fcntl_desc,		tmpfs_spec_fcntl },
+	{ &vop_fcntl_desc,		genfs_fcntl },
-	{ &vop_fsync_desc,		tmpfs_spec_fsync },
+	{ &vop_fsync_desc,		spec_fsync },
-	{ &vop_inactive_desc,		tmpfs_spec_inactive },
+	{ &vop_inactive_desc,		tmpfs_inactive },
-	{ &vop_reclaim_desc,		tmpfs_spec_reclaim },
+	{ &vop_reclaim_desc,		tmpfs_reclaim },
-	{ &vop_lock_desc,		tmpfs_spec_lock },
+	{ &vop_lock_desc,		genfs_lock },
-	{ &vop_unlock_desc,		tmpfs_spec_unlock },
+	{ &vop_unlock_desc,		genfs_unlock },
-	{ &vop_print_desc,		tmpfs_spec_print },
+	{ &vop_print_desc,		tmpfs_print },
-	{ &vop_islocked_desc,		tmpfs_spec_islocked },
+	{ &vop_islocked_desc,		genfs_islocked },
-	{ &vop_bwrite_desc,		tmpfs_spec_bwrite },
+	{ &vop_bwrite_desc,		vn_bwrite },
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc tmpfs_specop_opv_desc = {
 	&tmpfs_specop_p, tmpfs_specop_entries
 };
 int
 tmpfs_spec_close(void *v)
+{
 	struct vop_close_args /* {
 		struct vnode	*a_vp;
 		int		a_fflag;
 		kauth_cred_t	a_cred;
 	} */ *ap __unused = v;
 	return VOCALL(spec_vnodeop_p, VOFFSET(vop_close), v);
+}
 int
 tmpfs_spec_read(void *v)
+{
 	struct vop_read_args /* {
 		struct vnode *a_vp;
 		struct uio *a_uio;
 		int a_ioflag;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	vnode_t *vp = ap->a_vp;
 	tmpfs_update(vp, TMPFS_UPDATE_ATIME);
 	return VOCALL(spec_vnodeop_p, VOFFSET(vop_read), v);
+}
 int
 tmpfs_spec_write(void *v)
+{
 	struct vop_write_args /* {
 		struct vnode *a_vp;
 		struct uio *a_uio;
 		int a_ioflag;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	vnode_t *vp = ap->a_vp;
 	tmpfs_update(vp, TMPFS_UPDATE_MTIME);
 	return VOCALL(spec_vnodeop_p, VOFFSET(vop_write), v);
+}