 @@ -1,579 +1,581 @@
-/*	$NetBSD: union_vfsops.c,v 1.76 2017/02/17 08:31:25 hannken Exp $	*/
+/*	$NetBSD: union_vfsops.c,v 1.77 2017/03/06 10:10:07 hannken Exp $	*/
 /*
  * Copyright (c) 1994 The Regents of the University of California.
  * All rights reserved.
+ *
  * This code is derived from software donated to Berkeley by
  * Jan-Simon Pendry.
+ *
  * 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.
+ *
  *	@(#)union_vfsops.c	8.20 (Berkeley) 5/20/95
  */
 /*
  * Copyright (c) 1994 Jan-Simon Pendry.
  * All rights reserved.
+ *
  * This code is derived from software donated to Berkeley by
  * Jan-Simon Pendry.
+ *
  * 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. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by the University of
  *	California, Berkeley and its contributors.
  * 4. 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.
+ *
  *	@(#)union_vfsops.c	8.20 (Berkeley) 5/20/95
  */
 /*
  * Union Layer
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: union_vfsops.c,v 1.76 2017/02/17 08:31:25 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: union_vfsops.c,v 1.77 2017/03/06 10:10:07 hannken Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/sysctl.h>
 #include <sys/time.h>
 #include <sys/proc.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 #include <sys/namei.h>
 #include <sys/malloc.h>
 #include <sys/filedesc.h>
 #include <sys/queue.h>
 #include <sys/stat.h>
 #include <sys/kauth.h>
 #include <sys/module.h>
 #include <miscfs/genfs/genfs.h>
 #include <fs/union/union.h>
 MODULE(MODULE_CLASS_VFS, union, NULL);
 static struct sysctllog *union_sysctl_log;
 /*
  * Mount union filesystem
  */
 int
 union_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
+{
 	struct lwp *l = curlwp;
 	int error = 0;
 	struct union_args *args = data;
 	struct vnode *lowerrootvp = NULLVP;
 	struct vnode *upperrootvp = NULLVP;
 	struct union_mount *um = 0;
 	const char *cp;
 	char *xp;
 	int len;
 	size_t size;
 	if (args == NULL)
 		return EINVAL;
 	if (*data_len < sizeof *args)
 		return EINVAL;
 #ifdef UNION_DIAGNOSTIC
 	printf("union_mount(mp = %p)\n", mp);
 #endif
 	if (mp->mnt_flag & MNT_GETARGS) {
 		um = MOUNTTOUNIONMOUNT(mp);
 		if (um == NULL)
 			return EIO;
 		args->target = NULL;
 		args->mntflags = um->um_op;
 		*data_len = sizeof *args;
 		return 0;
+	}
 	/*
 	 * Update is a no-op
 	 */
 	if (mp->mnt_flag & MNT_UPDATE) {
 		/*
 		 * Need to provide.
 		 * 1. a way to convert between rdonly and rdwr mounts.
 		 * 2. support for nfs exports.
 		 */
 		error = EOPNOTSUPP;
 		goto bad;
+	}
 	lowerrootvp = mp->mnt_vnodecovered;
 	vref(lowerrootvp);
 	/*
 	 * Find upper node.
 	 */
 	error = namei_simple_user(args->target,
 				NSM_FOLLOW_NOEMULROOT, &upperrootvp);
 	if (error != 0)
 		goto bad;
 	if (upperrootvp->v_type != VDIR) {
 		error = EINVAL;
 		goto bad;
+	}
 	um = kmem_zalloc(sizeof(struct union_mount), KM_SLEEP);
 	/*
 	 * Keep a held reference to the target vnodes.
 	 * They are vrele'd in union_unmount.
+	 *
 	 * Depending on the _BELOW flag, the filesystems are
 	 * viewed in a different order.  In effect, this is the
 	 * same as providing a mount under option to the mount syscall.
 	 */
 	um->um_op = args->mntflags & UNMNT_OPMASK;
 	switch (um->um_op) {
 	case UNMNT_ABOVE:
 		um->um_lowervp = lowerrootvp;
 		um->um_uppervp = upperrootvp;
 		break;
 	case UNMNT_BELOW:
 		um->um_lowervp = upperrootvp;
 		um->um_uppervp = lowerrootvp;
 		break;
 	case UNMNT_REPLACE:
 		vrele(lowerrootvp);
 		lowerrootvp = NULLVP;
 		um->um_uppervp = upperrootvp;
 		um->um_lowervp = lowerrootvp;
 		break;
 	default:
 		error = EINVAL;
 		goto bad;
+	}
 	mp->mnt_iflag |= IMNT_MPSAFE;
 	/*
 	 * Unless the mount is readonly, ensure that the top layer
 	 * supports whiteout operations
 	 */
 	if ((mp->mnt_flag & MNT_RDONLY) == 0) {
 		vn_lock(um->um_uppervp, LK_EXCLUSIVE | LK_RETRY);
 		error = VOP_WHITEOUT(um->um_uppervp,
 		    (struct componentname *) 0, LOOKUP);
 		VOP_UNLOCK(um->um_uppervp);
 		if (error)
 			goto bad;
+	}
 	um->um_cred = l->l_cred;
 	kauth_cred_hold(um->um_cred);
 	um->um_cmode = UN_DIRMODE &~ l->l_proc->p_cwdi->cwdi_cmask;
 	/*
 	 * Depending on what you think the MNT_LOCAL flag might mean,
 	 * you may want the && to be || on the conditional below.
 	 * At the moment it has been defined that the filesystem is
 	 * only local if it is all local, ie the MNT_LOCAL flag implies
 	 * that the entire namespace is local.  If you think the MNT_LOCAL
 	 * flag implies that some of the files might be stored locally
 	 * then you will want to change the conditional.
 	 */
 	if (um->um_op == UNMNT_ABOVE) {
 		if (((um->um_lowervp == NULLVP) ||
 		     (um->um_lowervp->v_mount->mnt_flag & MNT_LOCAL)) &&
 		    (um->um_uppervp->v_mount->mnt_flag & MNT_LOCAL))
 			mp->mnt_flag |= MNT_LOCAL;
+	}
 	/*
 	 * Copy in the upper layer's RDONLY flag.  This is for the benefit
 	 * of lookup() which explicitly checks the flag, rather than asking
 	 * the filesystem for its own opinion.  This means, that an update
 	 * mount of the underlying filesystem to go from rdonly to rdwr
 	 * will leave the unioned view as read-only.
 	 */
 	mp->mnt_flag |= (um->um_uppervp->v_mount->mnt_flag & MNT_RDONLY);
 	mp->mnt_data = um;
 	vfs_getnewfsid(mp);
 	error = set_statvfs_info( path, UIO_USERSPACE, NULL, UIO_USERSPACE,
 	    mp->mnt_op->vfs_name, mp, l);
 	if (error)
 		goto bad;
 	mp->mnt_lower = um->um_uppervp->v_mount;
 	switch (um->um_op) {
 	case UNMNT_ABOVE:
 		cp = "<above>:";
 		break;
 	case UNMNT_BELOW:
 		cp = "<below>:";
 		break;
 	case UNMNT_REPLACE:
 		cp = "";
 		break;
 	default:
 		cp = "<invalid>:";
 #ifdef DIAGNOSTIC
 		panic("union_mount: bad um_op");
 #endif
 		break;
+	}
 	len = strlen(cp);
 	memcpy(mp->mnt_stat.f_mntfromname, cp, len);
 	xp = mp->mnt_stat.f_mntfromname + len;
 	len = MNAMELEN - len;
 	(void) copyinstr(args->target, xp, len - 1, &size);
 	memset(xp + size, 0, len - size);
 #ifdef UNION_DIAGNOSTIC
 	printf("union_mount: from %s, on %s\n",
 	    mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname);
 #endif
 	/* Setup the readdir hook if it's not set already */
 	if (!vn_union_readdir_hook)
 		vn_union_readdir_hook = union_readdirhook;
 	return (0);
 bad:
 	if (um)
 		kmem_free(um, sizeof(struct union_mount));
 	if (upperrootvp)
 		vrele(upperrootvp);
 	if (lowerrootvp)
 		vrele(lowerrootvp);
 	return (error);
+}
 /*
  * VFS start.  Nothing needed here - the start routine
  * on the underlying filesystem(s) will have been called
  * when that filesystem was mounted.
  */
  /*ARGSUSED*/
 int
 union_start(struct mount *mp, int flags)
+{
 	return (0);
+}
 /*
  * Free reference to union layer
  */
 static bool
 union_unmount_selector(void *cl, struct vnode *vp)
+{
 	int *count = cl;
 	*count += 1;
 	return false;
+}
 int
 union_unmount(struct mount *mp, int mntflags)
+{
 	struct union_mount *um = MOUNTTOUNIONMOUNT(mp);
 	int freeing;
 	int error;
 #ifdef UNION_DIAGNOSTIC
 	printf("union_unmount(mp = %p)\n", mp);
 #endif
 	/*
 	 * Keep flushing vnodes from the mount list.
 	 * This is needed because of the un_pvp held
 	 * reference to the parent vnode.
 	 * If more vnodes have been freed on a given pass,
 	 * the try again.  The loop will iterate at most
 	 * (d) times, where (d) is the maximum tree depth
 	 * in the filesystem.
 	 */
 	for (freeing = 0; (error = vflush(mp, NULL, 0)) != 0;) {
 		struct vnode_iterator *marker;
 		int n;
 		/* count #vnodes held on mount list */
 		n = 0;
 		vfs_vnode_iterator_init(mp, &marker);
 		vfs_vnode_iterator_next(marker, union_unmount_selector, &n);
 		vfs_vnode_iterator_destroy(marker);
 		/* if this is unchanged then stop */
 		if (n == freeing)
 			break;
 		/* otherwise try once more time */
 		freeing = n;
+	}
 	/*
 	 * Ok, now that we've tried doing it gently, get out the hammer.
 	 */
 	if (mntflags & MNT_FORCE)
 		error = vflush(mp, NULL, FORCECLOSE);
 	if (error)
 		return error;
 	/*
 	 * Discard references to upper and lower target vnodes.
 	 */
 	if (um->um_lowervp)
 		vrele(um->um_lowervp);
 	vrele(um->um_uppervp);
 	kauth_cred_free(um->um_cred);
 	/*
 	 * Finally, throw away the union_mount structure
 	 */
 	kmem_free(um, sizeof(struct union_mount));
 	mp->mnt_data = NULL;
 	return 0;
+}
 int
 union_root(struct mount *mp, struct vnode **vpp)
+{
 	struct union_mount *um = MOUNTTOUNIONMOUNT(mp);
 	int error;
 	/*
 	 * Return locked reference to root.
 	 */
 	vref(um->um_uppervp);
 	if (um->um_lowervp)
 		vref(um->um_lowervp);
 	error = union_allocvp(vpp, mp, NULL, NULL, NULL,
 			      um->um_uppervp, um->um_lowervp, 1);
 	if (error) {
 		vrele(um->um_uppervp);
 		if (um->um_lowervp)
 			vrele(um->um_lowervp);
 		return error;
+	}
 	vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY);
 	return 0;
+}
 int
 union_statvfs(struct mount *mp, struct statvfs *sbp)
+{
 	int error;
 	struct union_mount *um = MOUNTTOUNIONMOUNT(mp);
 	struct statvfs *sbuf = malloc(sizeof(*sbuf), M_TEMP, M_WAITOK | M_ZERO);
 	unsigned long lbsize;
 #ifdef UNION_DIAGNOSTIC
 	printf("union_statvfs(mp = %p, lvp = %p, uvp = %p)\n", mp,
 	    um->um_lowervp, um->um_uppervp);
 #endif
 	if (um->um_lowervp) {
 		error = VFS_STATVFS(um->um_lowervp->v_mount, sbuf);
 		if (error)
 			goto done;
+	}
 	/* now copy across the "interesting" information and fake the rest */
 	lbsize = sbuf->f_bsize;
 	sbp->f_blocks = sbuf->f_blocks - sbuf->f_bfree;
 	sbp->f_files = sbuf->f_files - sbuf->f_ffree;
 	error = VFS_STATVFS(um->um_uppervp->v_mount, sbuf);
 	if (error)
 		goto done;
 	sbp->f_flag = sbuf->f_flag;
 	sbp->f_bsize = sbuf->f_bsize;
 	sbp->f_frsize = sbuf->f_frsize;
 	sbp->f_iosize = sbuf->f_iosize;
 	/*
 	 * The "total" fields count total resources in all layers,
 	 * the "free" fields count only those resources which are
 	 * free in the upper layer (since only the upper layer
 	 * is writable).
 	 */
 	if (sbuf->f_bsize != lbsize)
 		sbp->f_blocks = sbp->f_blocks * lbsize / sbuf->f_bsize;
 	sbp->f_blocks += sbuf->f_blocks;
 	sbp->f_bfree = sbuf->f_bfree;
 	sbp->f_bavail = sbuf->f_bavail;
 	sbp->f_bresvd = sbuf->f_bresvd;
 	sbp->f_files += sbuf->f_files;
 	sbp->f_ffree = sbuf->f_ffree;
 	sbp->f_favail = sbuf->f_favail;
 	sbp->f_fresvd = sbuf->f_fresvd;
 	copy_statvfs_info(sbp, mp);
 done:
 	free(sbuf, M_TEMP);
 	return error;
+}
 /*ARGSUSED*/
 int
 union_sync(struct mount *mp, int waitfor,
     kauth_cred_t cred)
+{
 	/*
 	 * XXX - Assumes no data cached at union layer.
 	 */
 	return (0);
+}
 /*ARGSUSED*/
 int
 union_vget(struct mount *mp, ino_t ino,
     struct vnode **vpp)
+{
 	return (EOPNOTSUPP);
+}
 static int
 union_renamelock_enter(struct mount *mp)
+{
 	struct union_mount *um = MOUNTTOUNIONMOUNT(mp);
 	/* Lock just the upper fs, where the action happens. */
 	return VFS_RENAMELOCK_ENTER(um->um_uppervp->v_mount);
+}
 static void
 union_renamelock_exit(struct mount *mp)
+{
 	struct union_mount *um = MOUNTTOUNIONMOUNT(mp);
 	VFS_RENAMELOCK_EXIT(um->um_uppervp->v_mount);
+}
 extern const struct vnodeopv_desc union_vnodeop_opv_desc;
 const struct vnodeopv_desc * const union_vnodeopv_descs[] = {
 	&union_vnodeop_opv_desc,
 	NULL,
 };
 struct vfsops union_vfsops = {
 	.vfs_name = MOUNT_UNION,
 	.vfs_min_mount_data = sizeof (struct union_args),
 	.vfs_mount = union_mount,
 	.vfs_start = union_start,
 	.vfs_unmount = union_unmount,
 	.vfs_root = union_root,
 	.vfs_quotactl = (void *)eopnotsupp,
 	.vfs_statvfs = union_statvfs,
 	.vfs_sync = union_sync,
 	.vfs_vget = union_vget,
 	.vfs_loadvnode = union_loadvnode,
 	.vfs_fhtovp = (void *)eopnotsupp,
 	.vfs_vptofh = (void *)eopnotsupp,
 	.vfs_init = union_init,
 	.vfs_reinit = union_reinit,
 	.vfs_done = union_done,
 	.vfs_snapshot = (void *)eopnotsupp,
 	.vfs_extattrctl = vfs_stdextattrctl,
 	.vfs_suspendctl = genfs_suspendctl,
 	.vfs_renamelock_enter = union_renamelock_enter,
 	.vfs_renamelock_exit = union_renamelock_exit,
 	.vfs_fsync = (void *)eopnotsupp,
 	.vfs_opv_descs = union_vnodeopv_descs
 };
 static int
 union_modcmd(modcmd_t cmd, void *arg)
+{
 	int error;
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 		error = vfs_attach(&union_vfsops);
 		if (error != 0)
 			break;
 		sysctl_createv(&union_sysctl_log, 0, NULL, NULL,
 			       CTLFLAG_PERMANENT,
 			       CTLTYPE_NODE, "union",
 			       SYSCTL_DESCR("Union file system"),
 			       NULL, 0, NULL, 0,
 			       CTL_VFS, 15, CTL_EOL);
 		/*
 		 * XXX the "15" above could be dynamic, thereby eliminating
 		 * one more instance of the "number to vfs" mapping problem,
 		 * but "15" is the order as taken from sys/mount.h
 		 */
 		break;
 	case MODULE_CMD_FINI:
 		error = vfs_detach(&union_vfsops);
 		if (error != 0)
 			break;
 		sysctl_teardown(&union_sysctl_log);
 		break;
 	default:
 		error = ENOTTY;
 		break;
+	}
 	return (error);
+}

 @@ -1,271 +1,272 @@
-/*	$NetBSD: null_vfsops.c,v 1.91 2017/02/17 08:31:25 hannken Exp $	*/
+/*	$NetBSD: null_vfsops.c,v 1.92 2017/03/06 10:10:07 hannken Exp $	*/
 /*
  * Copyright (c) 1999 National Aeronautics & Space Administration
  * All rights reserved.
+ *
  * This software was written by William Studenmund of the
  * Numerical Aerospace Simulation Facility, NASA Ames Research Center.
+ *
  * 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 National Aeronautics & Space Administration
  *    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 NATIONAL AERONAUTICS & SPACE ADMINISTRATION
  * ``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 ADMINISTRATION OR CONTRIB-
  * UTORS 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.
  */
 /*
  * Copyright (c) 1992, 1993, 1995
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software donated to Berkeley by
  * Jan-Simon Pendry.
+ *
  * 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.
+ *
  *	from: Id: lofs_vfsops.c,v 1.9 1992/05/30 10:26:24 jsp Exp
  *	from: @(#)lofs_vfsops.c	1.2 (Berkeley) 6/18/92
  *	@(#)null_vfsops.c	8.7 (Berkeley) 5/14/95
  */
 /*
  * Null file-system: VFS operations.
+ *
  * See null_vnops.c for a description.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: null_vfsops.c,v 1.91 2017/02/17 08:31:25 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: null_vfsops.c,v 1.92 2017/03/06 10:10:07 hannken Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/sysctl.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 #include <sys/namei.h>
 #include <sys/module.h>
 #include <miscfs/nullfs/null.h>
 #include <miscfs/genfs/layer_extern.h>
 MODULE(MODULE_CLASS_VFS, null, "layerfs");
 VFS_PROTOS(nullfs);
 static struct sysctllog *nullfs_sysctl_log;
 int
 nullfs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
+{
 	struct vnode *lowerrootvp, *vp;
 	struct null_args *args = data;
 	struct null_mount *nmp;
 	struct layer_mount *lmp;
 	struct pathbuf *pb;
 	struct nameidata nd;
 	int error;
 	if (args == NULL)
 		return EINVAL;
 	if (*data_len < sizeof(*args))
 		return EINVAL;
 	if (mp->mnt_flag & MNT_GETARGS) {
 		lmp = MOUNTTOLAYERMOUNT(mp);
 		if (lmp == NULL)
 			return EIO;
 		args->la.target = NULL;
 		*data_len = sizeof(*args);
 		return 0;
+	}
 	/* Update is not supported. */
 	if (mp->mnt_flag & MNT_UPDATE)
 		return EOPNOTSUPP;
 	/* Find the lower vnode and lock it. */
 	error = pathbuf_copyin(args->la.target, &pb);
 	if (error) {
 		return error;
+	}
 	NDINIT(&nd, LOOKUP, FOLLOW|LOCKLEAF, pb);
 	if ((error = namei(&nd)) != 0) {
 		pathbuf_destroy(pb);
 		return error;
+	}
 	lowerrootvp = nd.ni_vp;
 	pathbuf_destroy(pb);
 	/* Create the mount point. */
 	nmp = kmem_zalloc(sizeof(struct null_mount), KM_SLEEP);
 	mp->mnt_data = nmp;
 	nmp->nullm_vfs = lowerrootvp->v_mount;
 	if (nmp->nullm_vfs->mnt_flag & MNT_LOCAL)
 		mp->mnt_flag |= MNT_LOCAL;
 	/*
 	 * Make sure that the mount point is sufficiently initialized
 	 * that the node create call will work.
 	 */
 	vfs_getnewfsid(mp);
 	nmp->nullm_size = sizeof(struct null_node);
 	nmp->nullm_tag = VT_NULL;
 	nmp->nullm_bypass = layer_bypass;
 	nmp->nullm_vnodeop_p = null_vnodeop_p;
 	/* Setup a null node for root vnode. */
 	VOP_UNLOCK(lowerrootvp);
 	error = layer_node_create(mp, lowerrootvp, &vp);
 	if (error) {
 		vrele(lowerrootvp);
 		kmem_free(nmp, sizeof(struct null_mount));
 		return error;
+	}
 	/*
 	 * Keep a held reference to the root vnode.  It will be released on
 	 * umount.  Note: nullfs is MP-safe.
 	 */
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 	vp->v_vflag |= VV_ROOT;
 	nmp->nullm_rootvp = vp;
 	mp->mnt_lower = nmp->nullm_vfs;
 	mp->mnt_iflag |= IMNT_MPSAFE;
 	VOP_UNLOCK(vp);
 	error = set_statvfs_info(path, UIO_USERSPACE, args->la.target,
 	    UIO_USERSPACE, mp->mnt_op->vfs_name, mp, curlwp);
 	return error;
+}
 int
 nullfs_unmount(struct mount *mp, int mntflags)
+{
 	struct null_mount *nmp = MOUNTTONULLMOUNT(mp);
 	struct vnode *null_rootvp = nmp->nullm_rootvp;
 	int error, flags = 0;
 	if (mntflags & MNT_FORCE)
 		flags |= FORCECLOSE;
 	if (null_rootvp->v_usecount > 1 && (mntflags & MNT_FORCE) == 0)
 		return EBUSY;
 	if ((error = vflush(mp, null_rootvp, flags)) != 0)
 		return error;
 	/* Eliminate all activity and release the vnode. */
 	vgone(null_rootvp);
 	/* Finally, destroy the mount point structures. */
 	kmem_free(mp->mnt_data, sizeof(struct null_mount));
 	mp->mnt_data = NULL;
 	return 0;
+}
 extern const struct vnodeopv_desc null_vnodeop_opv_desc;
 const struct vnodeopv_desc * const nullfs_vnodeopv_descs[] = {
 	&null_vnodeop_opv_desc,
 	NULL,
 };
 struct vfsops nullfs_vfsops = {
 	.vfs_name = MOUNT_NULL,
 	.vfs_min_mount_data = sizeof (struct null_args),
 	.vfs_mount = nullfs_mount,
 	.vfs_start = layerfs_start,
 	.vfs_unmount = nullfs_unmount,
 	.vfs_root = layerfs_root,
 	.vfs_quotactl = layerfs_quotactl,
 	.vfs_statvfs = layerfs_statvfs,
 	.vfs_sync = layerfs_sync,
 	.vfs_loadvnode = layerfs_loadvnode,
 	.vfs_vget = layerfs_vget,
 	.vfs_fhtovp = layerfs_fhtovp,
 	.vfs_vptofh = layerfs_vptofh,
 	.vfs_init = layerfs_init,
 	.vfs_done = layerfs_done,
 	.vfs_snapshot = layerfs_snapshot,
 	.vfs_extattrctl = vfs_stdextattrctl,
 	.vfs_suspendctl = layerfs_suspendctl,
 	.vfs_renamelock_enter = layerfs_renamelock_enter,
 	.vfs_renamelock_exit = layerfs_renamelock_exit,
 	.vfs_fsync = (void *)eopnotsupp,
 	.vfs_opv_descs = nullfs_vnodeopv_descs
 };
 static int
 null_modcmd(modcmd_t cmd, void *arg)
+{
 	int error;
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 		error = vfs_attach(&nullfs_vfsops);
 		if (error != 0)
 			break;
 		sysctl_createv(&nullfs_sysctl_log, 0, NULL, NULL,
 		    CTLFLAG_PERMANENT,
 		    CTLTYPE_NODE, "null",
 		    SYSCTL_DESCR("Loopback file system"),
 		    NULL, 0, NULL, 0,
 		    CTL_VFS, 9, CTL_EOL);
 		/*
 		 * XXX the "9" above could be dynamic, thereby eliminating
 		 * one more instance of the "number to vfs" mapping problem,
 		 * but "9" is the order as taken from sys/mount.h
 		 */
 		break;
 	case MODULE_CMD_FINI:
 		error = vfs_detach(&nullfs_vfsops);
 		if (error != 0)
 			break;
 		sysctl_teardown(&nullfs_sysctl_log);
 		break;
 	default:
 		error = ENOTTY;
 		break;
+	}
 	return error;
+}

 @@ -1,298 +1,299 @@
-/*	$NetBSD: overlay_vfsops.c,v 1.64 2017/02/17 08:31:25 hannken Exp $	*/
+/*	$NetBSD: overlay_vfsops.c,v 1.65 2017/03/06 10:10:07 hannken Exp $	*/
 /*
  * Copyright (c) 1999, 2000 National Aeronautics & Space Administration
  * All rights reserved.
+ *
  * This software was written by William Studenmund of the
  * Numerical Aerospace Simulation Facility, NASA Ames Research Center.
+ *
  * 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 National Aeronautics & Space Administration
  *    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 NATIONAL AERONAUTICS & SPACE ADMINISTRATION
  * ``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 ADMINISTRATION OR CONTRIB-
  * UTORS 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.
  */
 /*
  * Copyright (c) 1992, 1993, 1995
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software donated to Berkeley by
  * Jan-Simon Pendry.
+ *
  * 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.
+ *
  *	from: Id: lofs_vfsops.c,v 1.9 1992/05/30 10:26:24 jsp Exp
  *	from: @(#)lofs_vfsops.c	1.2 (Berkeley) 6/18/92
  *	@(#)null_vfsops.c	8.7 (Berkeley) 5/14/95
  */
 /*
  * Overlay Layer
  * (See overlay_vnops.c for a description of what this does.)
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: overlay_vfsops.c,v 1.64 2017/02/17 08:31:25 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: overlay_vfsops.c,v 1.65 2017/03/06 10:10:07 hannken Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/sysctl.h>
 #include <sys/time.h>
 #include <sys/proc.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 #include <sys/namei.h>
 #include <sys/module.h>
 #include <miscfs/overlay/overlay.h>
 #include <miscfs/genfs/layer_extern.h>
 MODULE(MODULE_CLASS_VFS, overlay, "layerfs");
 VFS_PROTOS(ov);
 static struct sysctllog *overlay_sysctl_log;
 #define	NOVERLAYNODECACHE	16
 /*
  * Mount overlay layer
  */
 int
 ov_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
+{
 	struct lwp *l = curlwp;
 	int error = 0;
 	struct overlay_args *args = data;
 	struct vnode *lowerrootvp, *vp;
 	struct overlay_mount *nmp;
 	struct layer_mount *lmp;
 #ifdef OVERLAYFS_DIAGNOSTIC
 	printf("ov_mount(mp = %p)\n", mp);
 #endif
 	if (args == NULL)
 		return EINVAL;
 	if (*data_len < sizeof *args)
 		return EINVAL;
 	if (mp->mnt_flag & MNT_GETARGS) {
 		lmp = MOUNTTOLAYERMOUNT(mp);
 		if (lmp == NULL)
 			return EIO;
 		args->la.target = NULL;
 		*data_len = sizeof *args;
 		return 0;
+	}
 	/*
 	 * Update is not supported
 	 */
 	if (mp->mnt_flag & MNT_UPDATE)
 		return EOPNOTSUPP;
 	/*
 	 * Find lower node
 	 */
 	lowerrootvp = mp->mnt_vnodecovered;
 	vref(lowerrootvp);
 	if ((error = vn_lock(lowerrootvp, LK_EXCLUSIVE | LK_RETRY))) {
 		vrele(lowerrootvp);
 		return (error);
+	}
 	/*
 	 * First cut at fixing up upper mount point
 	 */
 	nmp = kmem_zalloc(sizeof(struct overlay_mount), KM_SLEEP);
 	mp->mnt_data = nmp;
 	nmp->ovm_vfs = lowerrootvp->v_mount;
 	if (nmp->ovm_vfs->mnt_flag & MNT_LOCAL)
 		mp->mnt_flag |= MNT_LOCAL;
 	/*
 	 * Make sure that the mount point is sufficiently initialized
 	 * that the node create call will work.
 	 */
 	vfs_getnewfsid(mp);
 	nmp->ovm_size = sizeof (struct overlay_node);
 	nmp->ovm_tag = VT_OVERLAY;
 	nmp->ovm_bypass = layer_bypass;
 	nmp->ovm_vnodeop_p = overlay_vnodeop_p;
 	/*
 	 * Fix up overlay node for root vnode
 	 */
 	VOP_UNLOCK(lowerrootvp);
 	error = layer_node_create(mp, lowerrootvp, &vp);
 	/*
 	 * Make sure the fixup worked
 	 */
 	if (error) {
 		vrele(lowerrootvp);
 		kmem_free(nmp, sizeof(struct overlay_mount));
 		return error;
+	}
 	/*
 	 * Keep a held reference to the root vnode.
 	 * It is vrele'd in ov_unmount.
 	 */
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 	vp->v_vflag |= VV_ROOT;
 	nmp->ovm_rootvp = vp;
 	mp->mnt_lower = nmp->ovm_vfs;
 	VOP_UNLOCK(vp);
 	error = set_statvfs_info(path, UIO_USERSPACE, args->la.target,
 	    UIO_USERSPACE, mp->mnt_op->vfs_name, mp, l);
 #ifdef OVERLAYFS_DIAGNOSTIC
 	printf("ov_mount: lower %s, alias at %s\n",
 	    mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname);
 #endif
 	return error;
+}
 /*
  * Free reference to overlay layer
  */
 int
 ov_unmount(struct mount *mp, int mntflags)
+{
 	struct vnode *overlay_rootvp = MOUNTTOOVERLAYMOUNT(mp)->ovm_rootvp;
 	struct overlay_mount *omp;
 	int error;
 	int flags = 0;
 #ifdef OVERLAYFS_DIAGNOSTIC
 	printf("ov_unmount(mp = %p)\n", mp);
 #endif
 	if (mntflags & MNT_FORCE)
 		flags |= FORCECLOSE;
 	if (overlay_rootvp->v_usecount > 1 && (mntflags & MNT_FORCE) == 0)
 		return (EBUSY);
 	if ((error = vflush(mp, overlay_rootvp, flags)) != 0)
 		return (error);
 #ifdef OVERLAYFS_DIAGNOSTIC
 	vprint("alias root of lower", overlay_rootvp);
 #endif
 	/*
 	 * Blow it away for future re-use
 	 */
 	vgone(overlay_rootvp);
 	/*
 	 * Finally, throw away the overlay_mount structure
 	 */
 	omp = mp->mnt_data;
 	kmem_free(omp, sizeof(struct overlay_mount));
 	mp->mnt_data = NULL;
 	return 0;
+}
 extern const struct vnodeopv_desc overlay_vnodeop_opv_desc;
 const struct vnodeopv_desc * const ov_vnodeopv_descs[] = {
 	&overlay_vnodeop_opv_desc,
 	NULL,
 };
 struct vfsops overlay_vfsops = {
 	.vfs_name = MOUNT_OVERLAY,
 	.vfs_min_mount_data = sizeof (struct overlay_args),
 	.vfs_mount = ov_mount,
 	.vfs_start = layerfs_start,
 	.vfs_unmount = ov_unmount,
 	.vfs_root = layerfs_root,
 	.vfs_quotactl = layerfs_quotactl,
 	.vfs_statvfs = layerfs_statvfs,
 	.vfs_sync = layerfs_sync,
 	.vfs_loadvnode = layerfs_loadvnode,
 	.vfs_vget = layerfs_vget,
 	.vfs_fhtovp = layerfs_fhtovp,
 	.vfs_vptofh = layerfs_vptofh,
 	.vfs_init = layerfs_init,
 	.vfs_done = layerfs_done,
 	.vfs_snapshot = layerfs_snapshot,
 	.vfs_extattrctl = vfs_stdextattrctl,
 	.vfs_suspendctl = layerfs_suspendctl,
 	.vfs_renamelock_enter = layerfs_renamelock_enter,
 	.vfs_renamelock_exit = layerfs_renamelock_exit,
 	.vfs_fsync = (void *)eopnotsupp,
 	.vfs_opv_descs = ov_vnodeopv_descs
 };
 static int
 overlay_modcmd(modcmd_t cmd, void *arg)
+{
 	int error;
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 		error = vfs_attach(&overlay_vfsops);
 		if (error != 0)
 			break;
 		sysctl_createv(&overlay_sysctl_log, 0, NULL, NULL,
 			       CTLFLAG_PERMANENT, CTLTYPE_NODE, "overlay",
 			       SYSCTL_DESCR("Overlay file system"),
 			       NULL, 0, NULL, 0,
 			       CTL_VFS, CTL_CREATE, CTL_EOL);
 		break;
 	case MODULE_CMD_FINI:
 		error = vfs_detach(&overlay_vfsops);
 		if (error != 0)
 			break;
 		sysctl_teardown(&overlay_sysctl_log);
 		break;
 	default:
 		error = ENOTTY;
 		break;
+	}
 	return (error);
+}

 @@ -1,338 +1,339 @@
-/*	$NetBSD: umap_vfsops.c,v 1.96 2017/02/17 08:31:25 hannken Exp $	*/
+/*	$NetBSD: umap_vfsops.c,v 1.97 2017/03/06 10:10:07 hannken Exp $	*/
 /*
  * Copyright (c) 1992, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software donated to Berkeley by
  * the UCLA Ficus project.
+ *
  * 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.
+ *
  *	from: @(#)null_vfsops.c       1.5 (Berkeley) 7/10/92
  *	@(#)umap_vfsops.c	8.8 (Berkeley) 5/14/95
  */
 /*
  * Umap Layer
  * (See mount_umap(8) for a description of this layer.)
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: umap_vfsops.c,v 1.96 2017/02/17 08:31:25 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: umap_vfsops.c,v 1.97 2017/03/06 10:10:07 hannken Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/sysctl.h>
 #include <sys/proc.h>
 #include <sys/time.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 #include <sys/namei.h>
 #include <sys/kauth.h>
 #include <sys/module.h>
 #include <miscfs/umapfs/umap.h>
 #include <miscfs/genfs/layer_extern.h>
 MODULE(MODULE_CLASS_VFS, umap, "layerfs");
 VFS_PROTOS(umapfs);
 static struct sysctllog *umapfs_sysctl_log;
 /*
  * Mount umap layer
  */
 int
 umapfs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
+{
 	struct lwp *l = curlwp;
 	struct pathbuf *pb;
 	struct nameidata nd;
 	struct umap_args *args = data;
 	struct vnode *lowerrootvp, *vp;
 	struct umap_mount *amp;
 	int error;
 #ifdef UMAPFS_DIAGNOSTIC
 	int i;
 #endif
 	if (args == NULL)
 		return EINVAL;
 	if (*data_len < sizeof *args)
 		return EINVAL;
 	if (mp->mnt_flag & MNT_GETARGS) {
 		amp = MOUNTTOUMAPMOUNT(mp);
 		if (amp == NULL)
 			return EIO;
 		args->la.target = NULL;
 		args->nentries = amp->info_nentries;
 		args->gnentries = amp->info_gnentries;
 		*data_len = sizeof *args;
 		return 0;
+	}
 	/* only for root */
 	error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MOUNT,
 	    KAUTH_REQ_SYSTEM_MOUNT_UMAP, NULL, NULL, NULL);
 	if (error)
 		return error;
 #ifdef UMAPFS_DIAGNOSTIC
 	printf("umapfs_mount(mp = %p)\n", mp);
 #endif
 	/*
 	 * Update is not supported
 	 */
 	if (mp->mnt_flag & MNT_UPDATE)
 		return EOPNOTSUPP;
 	/*
 	 * Find lower node
 	 */
 	error = pathbuf_copyin(args->umap_target, &pb);
 	if (error) {
 		return error;
+	}
 	NDINIT(&nd, LOOKUP, FOLLOW|LOCKLEAF, pb);
 	if ((error = namei(&nd)) != 0) {
 		pathbuf_destroy(pb);
 		return error;
+	}
 	/*
 	 * Sanity check on lower vnode
 	 */
 	lowerrootvp = nd.ni_vp;
 	pathbuf_destroy(pb);
 #ifdef UMAPFS_DIAGNOSTIC
 	printf("vp = %p, check for VDIR...\n", lowerrootvp);
 #endif
 	if (lowerrootvp->v_type != VDIR) {
 		vput(lowerrootvp);
 		return (EINVAL);
+	}
 #ifdef UMAPFS_DIAGNOSTIC
 	printf("mp = %p\n", mp);
 #endif
 	amp = kmem_zalloc(sizeof(struct umap_mount), KM_SLEEP);
 	mp->mnt_data = amp;
 	amp->umapm_vfs = lowerrootvp->v_mount;
 	if (amp->umapm_vfs->mnt_flag & MNT_LOCAL)
 		mp->mnt_flag |= MNT_LOCAL;
 	/*
 	 * Now copy in the number of entries and maps for umap mapping.
 	 */
 	if (args->nentries < 0 || args->nentries > MAPFILEENTRIES ||
 	    args->gnentries < 0 || args->gnentries > GMAPFILEENTRIES) {
 		vput(lowerrootvp);
 		return (EINVAL);
+	}
 	amp->info_nentries = args->nentries;
 	amp->info_gnentries = args->gnentries;
 	error = copyin(args->mapdata, amp->info_mapdata,
 *sizeof(u_long)*args->nentries);
 	if (error) {
 		vput(lowerrootvp);
 		return (error);
+	}
 #ifdef UMAPFS_DIAGNOSTIC
 	printf("umap_mount:nentries %d\n",args->nentries);
 	for (i = 0; i < args->nentries; i++)
 		printf("   %ld maps to %ld\n", amp->info_mapdata[i][0],
 	 	    amp->info_mapdata[i][1]);
 #endif
 	error = copyin(args->gmapdata, amp->info_gmapdata,
 *sizeof(u_long)*args->gnentries);
 	if (error) {
 		vput(lowerrootvp);
 		return (error);
+	}
 #ifdef UMAPFS_DIAGNOSTIC
 	printf("umap_mount:gnentries %d\n",args->gnentries);
 	for (i = 0; i < args->gnentries; i++)
 		printf("\tgroup %ld maps to %ld\n",
 		    amp->info_gmapdata[i][0],
 	 	    amp->info_gmapdata[i][1]);
 #endif
 	/*
 	 * Make sure the mount point's sufficiently initialized
 	 * that the node create call will work.
 	 */
 	vfs_getnewfsid(mp);
 	amp->umapm_size = sizeof(struct umap_node);
 	amp->umapm_tag = VT_UMAP;
 	amp->umapm_bypass = umap_bypass;
 	amp->umapm_vnodeop_p = umap_vnodeop_p;
 	/*
 	 * fix up umap node for root vnode.
 	 */
 	VOP_UNLOCK(lowerrootvp);
 	error = layer_node_create(mp, lowerrootvp, &vp);
 	/*
 	 * Make sure the node alias worked
 	 */
 	if (error) {
 		vrele(lowerrootvp);
 		kmem_free(amp, sizeof(struct umap_mount));
 		return error;
+	}
 	/*
 	 * Keep a held reference to the root vnode.
 	 * It is vrele'd in umapfs_unmount.
 	 */
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 	vp->v_vflag |= VV_ROOT;
 	amp->umapm_rootvp = vp;
 	mp->mnt_lower = amp->umapm_vfs;
 	VOP_UNLOCK(vp);
 	error = set_statvfs_info(path, UIO_USERSPACE, args->umap_target,
 	    UIO_USERSPACE, mp->mnt_op->vfs_name, mp, l);
 #ifdef UMAPFS_DIAGNOSTIC
 	printf("umapfs_mount: lower %s, alias at %s\n",
 		mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname);
 #endif
 	return error;
+}
 /*
  * Free reference to umap layer
  */
 int
 umapfs_unmount(struct mount *mp, int mntflags)
+{
 	struct umap_mount *amp = MOUNTTOUMAPMOUNT(mp);
 	struct vnode *rtvp = amp->umapm_rootvp;
 	int error;
 	int flags = 0;
 #ifdef UMAPFS_DIAGNOSTIC
 	printf("umapfs_unmount(mp = %p)\n", mp);
 #endif
 	if (mntflags & MNT_FORCE)
 		flags |= FORCECLOSE;
 	if (rtvp->v_usecount > 1 && (mntflags & MNT_FORCE) == 0)
 		return (EBUSY);
 	if ((error = vflush(mp, rtvp, flags)) != 0)
 		return (error);
 #ifdef UMAPFS_DIAGNOSTIC
 	vprint("alias root of lower", rtvp);
 #endif
 	/*
 	 * Blow it away for future re-use
 	 */
 	vgone(rtvp);
 	/*
 	 * Finally, throw away the umap_mount structure
 	 */
 	kmem_free(amp, sizeof(struct umap_mount));
 	mp->mnt_data = NULL;
 	return 0;
+}
 extern const struct vnodeopv_desc umapfs_vnodeop_opv_desc;
 const struct vnodeopv_desc * const umapfs_vnodeopv_descs[] = {
 	&umapfs_vnodeop_opv_desc,
 	NULL,
 };
 struct vfsops umapfs_vfsops = {
 	.vfs_name = MOUNT_UMAP,
 	.vfs_min_mount_data = sizeof (struct umap_args),
 	.vfs_mount = umapfs_mount,
 	.vfs_start = layerfs_start,
 	.vfs_unmount = umapfs_unmount,
 	.vfs_root = layerfs_root,
 	.vfs_quotactl = layerfs_quotactl,
 	.vfs_statvfs = layerfs_statvfs,
 	.vfs_sync = layerfs_sync,
 	.vfs_loadvnode = layerfs_loadvnode,
 	.vfs_vget = layerfs_vget,
 	.vfs_fhtovp = layerfs_fhtovp,
 	.vfs_vptofh = layerfs_vptofh,
 	.vfs_init = layerfs_init,
 	.vfs_done = layerfs_done,
 	.vfs_snapshot = layerfs_snapshot,
 	.vfs_extattrctl = vfs_stdextattrctl,
 	.vfs_suspendctl = layerfs_suspendctl,
 	.vfs_renamelock_enter = layerfs_renamelock_enter,
 	.vfs_renamelock_exit = layerfs_renamelock_exit,
 	.vfs_fsync = (void *)eopnotsupp,
 	.vfs_opv_descs = umapfs_vnodeopv_descs
 };
 static int
 umap_modcmd(modcmd_t cmd, void *arg)
+{
 	int error;
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 		error = vfs_attach(&umapfs_vfsops);
 		if (error != 0)
 			break;
 		sysctl_createv(&umapfs_sysctl_log, 0, NULL, NULL,
 			       CTLFLAG_PERMANENT,
 			       CTLTYPE_NODE, "umap",
 			       SYSCTL_DESCR("UID/GID remapping file system"),
 			       NULL, 0, NULL, 0,
 			       CTL_VFS, 10, CTL_EOL);
 		/*
 		 * XXX the "10" above could be dynamic, thereby eliminating
 		 * one more instance of the "number to vfs" mapping problem,
 		 * but "10" is the order as taken from sys/mount.h
 		 */
 		break;
 	case MODULE_CMD_FINI:
 		error = vfs_detach(&umapfs_vfsops);
 		if (error != 0)
 			break;
 		sysctl_teardown(&umapfs_sysctl_log);
 		break;
 	default:
 		error = ENOTTY;
 		break;
+	}
 	return (error);
+}

 @@ -1,524 +1,525 @@
-/*	$NetBSD: mount.h,v 1.220 2017/01/11 09:07:57 hannken Exp $	*/
+/*	$NetBSD: mount.h,v 1.221 2017/03/06 10:10:07 hannken Exp $	*/
 /*
  * Copyright (c) 1989, 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * 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.
+ *
  *	@(#)mount.h	8.21 (Berkeley) 5/20/95
  */
 #ifndef _SYS_MOUNT_H_
 #define _SYS_MOUNT_H_
 #ifndef _KERNEL
 #include <sys/featuretest.h>
 #if defined(_NETBSD_SOURCE)
 #include <sys/stat.h>
 #endif /* _NETBSD_SOURCE */
 #endif
 #ifndef _STANDALONE
 #include <sys/param.h> /* precautionary upon removal from ucred.h */
 #include <sys/time.h>
 #include <sys/uio.h>
 #include <sys/ucred.h>
 #include <sys/fstypes.h>
 #include <sys/queue.h>
 #include <sys/rwlock.h>
 #include <sys/statvfs.h>
 #include <sys/specificdata.h>
 #include <sys/condvar.h>
 #endif	/* !_STANDALONE */
 /*
  * file system statistics
  */
 #define	MNAMELEN	90	/* length of buffer for returned name */
 /*
  * File system types.
  */
 #define	MOUNT_FFS	"ffs"		/* UNIX "Fast" Filesystem */
 #define	MOUNT_UFS	MOUNT_FFS	/* for compatibility */
 #define	MOUNT_NFS	"nfs"		/* Network Filesystem */
 #define	MOUNT_MFS	"mfs"		/* Memory Filesystem */
 #define	MOUNT_MSDOS	"msdos"		/* MSDOS Filesystem */
 #define	MOUNT_LFS	"lfs"		/* Log-based Filesystem */
 #define	MOUNT_FDESC	"fdesc"		/* File Descriptor Filesystem */
 #define	MOUNT_NULL	"null"		/* Minimal Filesystem Layer */
 #define	MOUNT_OVERLAY	"overlay"	/* Minimal Overlay Filesystem Layer */
 #define	MOUNT_UMAP	"umap"	/* User/Group Identifier Remapping Filesystem */
 #define	MOUNT_KERNFS	"kernfs"	/* Kernel Information Filesystem */
 #define	MOUNT_PROCFS	"procfs"	/* /proc Filesystem */
 #define	MOUNT_AFS	"afs"		/* Andrew Filesystem */
 #define	MOUNT_CD9660	"cd9660"	/* ISO9660 (aka CDROM) Filesystem */
 #define	MOUNT_UNION	"union"		/* Union (translucent) Filesystem */
 #define	MOUNT_ADOSFS	"adosfs"	/* AmigaDOS Filesystem */
 #define	MOUNT_EXT2FS	"ext2fs"	/* Second Extended Filesystem */
 #define	MOUNT_CFS	"coda"		/* Coda Filesystem */
 #define	MOUNT_CODA	MOUNT_CFS	/* Coda Filesystem */
 #define	MOUNT_FILECORE	"filecore"	/* Acorn Filecore Filesystem */
 #define	MOUNT_NTFS	"ntfs"		/* Windows/NT Filesystem */
 #define	MOUNT_SMBFS	"smbfs"		/* CIFS (SMB) */
 #define	MOUNT_PTYFS	"ptyfs"		/* Pseudo tty filesystem */
 #define	MOUNT_TMPFS	"tmpfs"		/* Efficient memory file-system */
 #define MOUNT_UDF	"udf"		/* UDF CD/DVD filesystem */
 #define	MOUNT_SYSVBFS	"sysvbfs"	/* System V Boot Filesystem */
 #define MOUNT_PUFFS	"puffs"		/* Pass-to-Userspace filesystem */
 #define MOUNT_HFS	"hfs"		/* Apple HFS+ Filesystem */
 #define MOUNT_EFS	"efs"		/* SGI's Extent Filesystem */
 #define MOUNT_ZFS	"zfs"		/* Sun ZFS */
 #define MOUNT_NILFS	"nilfs"		/* NTT's NiLFS(2) logging file system */
 #define MOUNT_RUMPFS	"rumpfs"	/* rump virtual file system */
 #define	MOUNT_V7FS	"v7fs"		/* 7th Edition of Unix Filesystem */
 #ifndef _STANDALONE
 struct vnode;
 struct vnode_impl;
 struct vattr;
 /*
  * Structure per mounted file system.  Each mounted file system has an
  * array of operations and an instance record.  The file systems are
  * put on a doubly linked list.
  */
 struct mount {
 	TAILQ_ENTRY(mount) mnt_list;		/* mount list */
 	TAILQ_HEAD(, vnode_impl) mnt_vnodelist;	/* list of vnodes this mount */
 	struct vfsops	*mnt_op;		/* operations on fs */
 	struct vnode	*mnt_vnodecovered;	/* vnode we mounted on */
 	struct mount	*mnt_lower;		/* fs mounted on */
 	int		mnt_synclist_slot;	/* synclist slot index */
 	void		*mnt_transinfo;		/* for FS-internal use */
 	void		*mnt_data;		/* private data */
 	kmutex_t	mnt_unmounting;		/* to prevent new activity */
 	kmutex_t	mnt_renamelock;		/* per-fs rename lock */
 	int		mnt_refcnt;		/* ref count on this structure */
 	unsigned int	mnt_busynest;		/* vfs_busy nestings */
 	int		mnt_flag;		/* flags */
 	int		mnt_iflag;		/* internal flags */
 	int		mnt_fs_bshift;		/* offset shift for lblkno */
 	int		mnt_dev_bshift;		/* shift for device sectors */
 	struct statvfs	mnt_stat;		/* cache of filesystem stats */
 	specificdata_reference
 			mnt_specdataref;	/* subsystem specific data */
 	kmutex_t	mnt_updating;		/* to serialize updates */
 	struct wapbl_ops
 			*mnt_wapbl_op;		/* logging ops */
 	struct wapbl	*mnt_wapbl;		/* log info */
 	struct wapbl_replay
 			*mnt_wapbl_replay;	/* replay support XXX: what? */
 	uint64_t	mnt_gen;
 };
 /*
  * Sysctl CTL_VFS definitions.
+ *
  * Second level identifier specifies which filesystem. Second level
  * identifier VFS_GENERIC returns information about all filesystems.
+ *
  * Note the slightly non-flat nature of these sysctl numbers.  Oh for
  * a better sysctl interface.
  */
 #define VFS_GENERIC	0		/* generic filesystem information */
 #define VFS_MAXTYPENUM	1		/* int: highest defined fs type */
 #define VFS_CONF	2		/* struct: vfsconf for filesystem given
 					   as next argument */
 #define VFS_USERMOUNT	3		/* enable/disable fs mnt by non-root */
 #define	VFS_MAGICLINKS  4		/* expand 'magic' symlinks */
 #define	VFSGEN_MAXID	5		/* number of valid vfs.generic ids */
 /*
  * USE THE SAME NAMES AS MOUNT_*!
+ *
  * Only need to add new entry here if the filesystem actually supports
  * sysctl(2).
  */
 #define	CTL_VFS_NAMES { \
 	{ "generic", CTLTYPE_NODE }, \
 	{ MOUNT_FFS, CTLTYPE_NODE }, \
 	{ MOUNT_NFS, CTLTYPE_NODE }, \
 	{ MOUNT_MFS, CTLTYPE_NODE }, \
 	{ MOUNT_MSDOS, CTLTYPE_NODE }, \
 	{ MOUNT_LFS, CTLTYPE_NODE }, \
 	{ 0, 0 }, 			/* MOUNT_LOFS */ \
 	{ MOUNT_FDESC, CTLTYPE_NODE }, \
 	{ MOUNT_NULL, CTLTYPE_NODE }, \
 	{ MOUNT_UMAP, CTLTYPE_NODE }, \
 	{ MOUNT_KERNFS, CTLTYPE_NODE }, \
 	{ MOUNT_PROCFS, CTLTYPE_NODE }, \
 	{ MOUNT_AFS, CTLTYPE_NODE }, \
 	{ MOUNT_CD9660, CTLTYPE_NODE }, \
 	{ MOUNT_UNION, CTLTYPE_NODE }, \
 	{ MOUNT_ADOSFS, CTLTYPE_NODE }, \
 	{ MOUNT_EXT2FS, CTLTYPE_NODE }, \
 	{ MOUNT_CODA, CTLTYPE_NODE }, \
 	{ MOUNT_FILECORE, CTLTYPE_NODE }, \
 	{ MOUNT_NTFS, CTLTYPE_NODE }, \
+}
 #define	VFS_MAXID	20		/* number of valid vfs ids */
 #define	CTL_VFSGENCTL_NAMES { \
 	{ 0, 0 }, \
 	{ "maxtypenum", CTLTYPE_INT }, \
 	{ "conf", CTLTYPE_NODE }, 	/* Special */ \
 	{ "usermount", CTLTYPE_INT }, \
 	{ "magiclinks", CTLTYPE_INT }, \
+}
 #if defined(_KERNEL)
 struct quotactl_args;		/* in sys/quotactl.h */
 struct quotastat;		/* in sys/quotactl.h */
 struct quotaidtypestat;		/* in sys/quotactl.h */
 struct quotaobjtypestat;	/* in sys/quotactl.h */
 struct quotakcursor;		/* in sys/quotactl.h */
 struct quotakey;		/* in sys/quota.h */
 struct quotaval;		/* in sys/quota.h */
 #if __STDC__
 struct nameidata;
 #endif
 /*
  * Operations supported on mounted file system.
  */
 struct vfsops {
 	const char *vfs_name;
 	size_t	vfs_min_mount_data;
 	int	(*vfs_mount)	(struct mount *, const char *, void *,
 				    size_t *);
 	int	(*vfs_start)	(struct mount *, int);
 	int	(*vfs_unmount)	(struct mount *, int);
 	int	(*vfs_root)	(struct mount *, struct vnode **);
 	int	(*vfs_quotactl)	(struct mount *, struct quotactl_args *);
 	int	(*vfs_statvfs)	(struct mount *, struct statvfs *);
 	int	(*vfs_sync)	(struct mount *, int, struct kauth_cred *);
 	int	(*vfs_vget)	(struct mount *, ino_t, struct vnode **);
 	int	(*vfs_loadvnode) (struct mount *, struct vnode *,
 				    const void *, size_t, const void **);
 	int	(*vfs_newvnode) (struct mount *, struct vnode *, struct vnode *,
 				    struct vattr *, kauth_cred_t,
 				    size_t *, const void **);
 	int	(*vfs_fhtovp)	(struct mount *, struct fid *,
 				    struct vnode **);
 	int	(*vfs_vptofh)	(struct vnode *, struct fid *, size_t *);
 	void	(*vfs_init)	(void);
 	void	(*vfs_reinit)	(void);
 	void	(*vfs_done)	(void);
 	int	(*vfs_mountroot)(void);
 	int	(*vfs_snapshot)	(struct mount *, struct vnode *,
 				    struct timespec *);
 	int	(*vfs_extattrctl) (struct mount *, int,
 				    struct vnode *, int, const char *);
 	int	(*vfs_suspendctl) (struct mount *, int);
 	int	(*vfs_renamelock_enter)(struct mount *);
 	void	(*vfs_renamelock_exit)(struct mount *);
 	int	(*vfs_fsync)	(struct vnode *, int);
 	const struct vnodeopv_desc * const *vfs_opv_descs;
 	int	vfs_refcount;
 	LIST_ENTRY(vfsops) vfs_list;
 };
 /* XXX vget is actually file system internal. */
 #define VFS_VGET(MP, INO, VPP)    (*(MP)->mnt_op->vfs_vget)(MP, INO, VPP)
 #define VFS_LOADVNODE(MP, VP, KEY, KEY_LEN, NEW_KEY) \
 	(*(MP)->mnt_op->vfs_loadvnode)(MP, VP, KEY, KEY_LEN, NEW_KEY)
 #define VFS_NEWVNODE(MP, DVP, VP, VAP, CRED, NEW_LEN, NEW_KEY) \
 	(*(MP)->mnt_op->vfs_newvnode)(MP, DVP, VP, VAP, CRED, NEW_LEN, NEW_KEY)
 #define VFS_RENAMELOCK_ENTER(MP)  (*(MP)->mnt_op->vfs_renamelock_enter)(MP)
 #define VFS_RENAMELOCK_EXIT(MP)   (*(MP)->mnt_op->vfs_renamelock_exit)(MP)
 #define VFS_FSYNC(MP, VP, FLG)	  (*(MP)->mnt_op->vfs_fsync)(VP, FLG)
 int	VFS_MOUNT(struct mount *, const char *, void *, size_t *);
 int	VFS_START(struct mount *, int);
 int	VFS_UNMOUNT(struct mount *, int);
 int	VFS_ROOT(struct mount *, struct vnode **);
 int	VFS_QUOTACTL(struct mount *, struct quotactl_args *);
 int	VFS_STATVFS(struct mount *, struct statvfs *);
 int	VFS_SYNC(struct mount *, int, struct kauth_cred *);
 int	VFS_FHTOVP(struct mount *, struct fid *, struct vnode **);
 int	VFS_VPTOFH(struct vnode *, struct fid *, size_t *);
 int	VFS_SNAPSHOT(struct mount *, struct vnode *, struct timespec *);
 int	VFS_EXTATTRCTL(struct mount *, int, struct vnode *, int, const char *);
 int	VFS_SUSPENDCTL(struct mount *, int);
 #endif /* _KERNEL */
 #ifdef _KERNEL
 #if __STDC__
 struct mbuf;
 struct vnodeopv_desc;
 struct kauth_cred;
 #endif
 #define	VFS_MAX_MOUNT_DATA	8192
 #define VFS_PROTOS(fsname)						\
 int	fsname##_mount(struct mount *, const char *, void *,		\
 		size_t *);						\
 int	fsname##_start(struct mount *, int);				\
 int	fsname##_unmount(struct mount *, int);				\
 int	fsname##_root(struct mount *, struct vnode **);			\
 int	fsname##_quotactl(struct mount *, struct quotactl_args *);	\
 int	fsname##_statvfs(struct mount *, struct statvfs *);		\
 int	fsname##_sync(struct mount *, int, struct kauth_cred *);	\
 int	fsname##_vget(struct mount *, ino_t, struct vnode **);		\
 int	fsname##_loadvnode(struct mount *, struct vnode *,		\
 		const void *, size_t, const void **);			\
 int	fsname##_newvnode(struct mount *, struct vnode *,		\
 		struct vnode *, struct vattr *, kauth_cred_t,		\
 		size_t *, const void **);				\
 int	fsname##_fhtovp(struct mount *, struct fid *, struct vnode **);	\
 int	fsname##_vptofh(struct vnode *, struct fid *, size_t *);	\
 void	fsname##_init(void);						\
 void	fsname##_reinit(void);						\
 void	fsname##_done(void);						\
 int	fsname##_mountroot(void);					\
 int	fsname##_snapshot(struct mount *, struct vnode *,		\
 		struct timespec *);					\
 int	fsname##_extattrctl(struct mount *, int, struct vnode *, int,	\
 		const char *);						\
 int	fsname##_suspendctl(struct mount *, int)
 /*
  * This operations vector is so wapbl can be wrapped into a filesystem lkm.
  * XXX Eventually, we want to move this functionality
  * down into the filesystems themselves so that this isn't needed.
  */
 struct wapbl_ops {
 	void (*wo_wapbl_discard)(struct wapbl *);
 	int (*wo_wapbl_replay_isopen)(struct wapbl_replay *);
 	int (*wo_wapbl_replay_can_read)(struct wapbl_replay *, daddr_t, long);
 	int (*wo_wapbl_replay_read)(struct wapbl_replay *, void *, daddr_t, long);
 	void (*wo_wapbl_add_buf)(struct wapbl *, struct buf *);
 	void (*wo_wapbl_remove_buf)(struct wapbl *, struct buf *);
 	void (*wo_wapbl_resize_buf)(struct wapbl *, struct buf *, long, long);
 	int (*wo_wapbl_begin)(struct wapbl *, const char *, int);
 	void (*wo_wapbl_end)(struct wapbl *);
 	void (*wo_wapbl_junlock_assert)(struct wapbl *);
 	void (*wo_wapbl_biodone)(struct buf *);
 };
 #define WAPBL_DISCARD(MP)						\
     (*(MP)->mnt_wapbl_op->wo_wapbl_discard)((MP)->mnt_wapbl)
 #define WAPBL_REPLAY_ISOPEN(MP)						\
     (*(MP)->mnt_wapbl_op->wo_wapbl_replay_isopen)((MP)->mnt_wapbl_replay)
 #define WAPBL_REPLAY_CAN_READ(MP, BLK, LEN)				\
     (*(MP)->mnt_wapbl_op->wo_wapbl_replay_can_read)((MP)->mnt_wapbl_replay, \
     (BLK), (LEN))
 #define WAPBL_REPLAY_READ(MP, DATA, BLK, LEN)				\
     (*(MP)->mnt_wapbl_op->wo_wapbl_replay_read)((MP)->mnt_wapbl_replay,	\
     (DATA), (BLK), (LEN))
 #define WAPBL_ADD_BUF(MP, BP)						\
     (*(MP)->mnt_wapbl_op->wo_wapbl_add_buf)((MP)->mnt_wapbl, (BP))
 #define WAPBL_REMOVE_BUF(MP, BP)					\
     (*(MP)->mnt_wapbl_op->wo_wapbl_remove_buf)((MP)->mnt_wapbl, (BP))
 #define WAPBL_RESIZE_BUF(MP, BP, OLDSZ, OLDCNT)				\
     (*(MP)->mnt_wapbl_op->wo_wapbl_resize_buf)((MP)->mnt_wapbl, (BP),	\
     (OLDSZ), (OLDCNT))
 #define WAPBL_BEGIN(MP)							\
     (*(MP)->mnt_wapbl_op->wo_wapbl_begin)((MP)->mnt_wapbl,		\
     __FILE__, __LINE__)
 #define WAPBL_END(MP)							\
     (*(MP)->mnt_wapbl_op->wo_wapbl_end)((MP)->mnt_wapbl)
 #define WAPBL_JUNLOCK_ASSERT(MP)					\
     (*(MP)->mnt_wapbl_op->wo_wapbl_junlock_assert)((MP)->mnt_wapbl)
 struct vfs_hooks {
 	LIST_ENTRY(vfs_hooks) vfs_hooks_list;
 	void	(*vh_unmount)(struct mount *);
 	int	(*vh_reexport)(struct mount *, const char *, void *);
 	void	(*vh_future_expansion_1)(void);
 	void	(*vh_future_expansion_2)(void);
 	void	(*vh_future_expansion_3)(void);
 	void	(*vh_future_expansion_4)(void);
 	void	(*vh_future_expansion_5)(void);
 };
 void	vfs_hooks_init(void);
 int	vfs_hooks_attach(struct vfs_hooks *);
 int	vfs_hooks_detach(struct vfs_hooks *);
 void	vfs_hooks_unmount(struct mount *);
 int	vfs_hooks_reexport(struct mount *, const char *, void *);
 #endif /* _KERNEL */
 /*
  * Export arguments for local filesystem mount calls.
+ *
  * This structure is deprecated and is only provided for compatibility
  * reasons with old binary utilities; several file systems expose an
  * instance of this structure in their mount arguments structure, thus
  * needing a padding in place of the old values.  This definition cannot
  * change in the future due to this reason.
  * XXX: This should be moved to the compat subtree but cannot be done
  * until we can move the mount args structures themselves.
+ *
  * The current export_args structure can be found in nfs/nfs.h.
  */
 struct export_args30 {
 	int	ex_flags;		/* export related flags */
 	uid_t	ex_root;		/* mapping for root uid */
 	struct	uucred ex_anon;		/* mapping for anonymous user */
 	struct	sockaddr *ex_addr;	/* net address to which exported */
 	int	ex_addrlen;		/* and the net address length */
 	struct	sockaddr *ex_mask;	/* mask of valid bits in saddr */
 	int	ex_masklen;		/* and the smask length */
 	char	*ex_indexfile;		/* index file for WebNFS URLs */
 };
 struct mnt_export_args30 {
 	const char *fspec;		/* Always NULL */
 	struct export_args30 eargs;
 };
 #ifdef _KERNEL
 /*
  * exported VFS interface (see vfssubr(9))
  */
 struct	mount *vfs_getvfs(fsid_t *);    /* return vfs given fsid */
 int	vfs_composefh(struct vnode *, fhandle_t *, size_t *);
 int	vfs_composefh_alloc(struct vnode *, fhandle_t **);
 void	vfs_composefh_free(fhandle_t *);
 int	vfs_fhtovp(fhandle_t *, struct vnode **);
 int	vfs_mountedon(struct vnode *);/* is a vfs mounted on vp */
 int	vfs_mountroot(void);
 void	vfs_shutdown(void);	    /* unmount and sync file systems */
 void	vfs_sync_all(struct lwp *);
 bool	vfs_unmountall(struct lwp *);	    /* unmount file systems */
 bool	vfs_unmountall1(struct lwp *, bool, bool);
 bool	vfs_unmount_forceone(struct lwp *);
 int 	vfs_busy(struct mount *, struct mount **);
 int	vfs_rootmountalloc(const char *, const char *, struct mount **);
 void	vfs_unbusy(struct mount *, bool, struct mount **);
 int	vfs_attach(struct vfsops *);
 int	vfs_detach(struct vfsops *);
 void	vfs_reinit(void);
 struct vfsops *vfs_getopsbyname(const char *);
 void	vfs_delref(struct vfsops *);
 void	vfs_destroy(struct mount *);
 struct mount *vfs_mountalloc(struct vfsops *, struct vnode *);
 int	vfs_stdextattrctl(struct mount *, int, struct vnode *,
 	    int, const char *);
 void	vfs_insmntque(struct vnode *, struct mount *);
 int	vfs_quotactl_stat(struct mount *, struct quotastat *);
 int	vfs_quotactl_idtypestat(struct mount *, int, struct quotaidtypestat *);
 int	vfs_quotactl_objtypestat(struct mount *,int,struct quotaobjtypestat *);
 int	vfs_quotactl_get(struct mount *, const struct quotakey *,
 	    struct quotaval *);
 int	vfs_quotactl_put(struct mount *, const struct quotakey *,
 	    const struct quotaval *);
 int	vfs_quotactl_del(struct mount *, const struct quotakey *);
 int	vfs_quotactl_cursoropen(struct mount *, struct quotakcursor *);
 int	vfs_quotactl_cursorclose(struct mount *, struct quotakcursor *);
 int	vfs_quotactl_cursorskipidtype(struct mount *, struct quotakcursor *,
             int);
 int	vfs_quotactl_cursorget(struct mount *, struct quotakcursor *,
             struct quotakey *, struct quotaval *, unsigned, unsigned *);
 int	vfs_quotactl_cursoratend(struct mount *, struct quotakcursor *, int *);
 int	vfs_quotactl_cursorrewind(struct mount *, struct quotakcursor *);
 int	vfs_quotactl_quotaon(struct mount *, int, const char *);
 int	vfs_quotactl_quotaoff(struct mount *, int);
 struct vnode_iterator; /* Opaque. */
 void	vfs_vnode_iterator_init(struct mount *, struct vnode_iterator **);
 void	vfs_vnode_iterator_destroy(struct vnode_iterator *);
 struct vnode *vfs_vnode_iterator_next(struct vnode_iterator *,
     bool (*)(void *, struct vnode *), void *);
 /* Syncer */
 extern int	syncer_maxdelay;
 extern kmutex_t	syncer_mutex;
 extern time_t	syncdelay;
 extern time_t	filedelay;
 extern time_t	dirdelay;
 extern time_t	metadelay;
 void	vfs_syncer_add_to_worklist(struct mount *);
 void	vfs_syncer_remove_from_worklist(struct mount *);
 extern	TAILQ_HEAD(mntlist, mount) mountlist;	/* mounted filesystem list */
 extern	struct vfsops *vfssw[];			/* filesystem type table */
 extern	int nvfssw;
 extern  kmutex_t mountlist_lock;
 extern	kmutex_t vfs_list_lock;
 void	vfs_mount_sysinit(void);
 long	makefstype(const char *);
 int	mount_domount(struct lwp *, struct vnode **, struct vfsops *,
 	    const char *, int, void *, size_t *);
 int	dounmount(struct mount *, int, struct lwp *);
 int	do_sys_mount(struct lwp *, const char *, enum uio_seg, const char *,
 	    int, void *, enum uio_seg, size_t, register_t *);
 void	vfsinit(void);
 void	vfs_opv_init(const struct vnodeopv_desc * const *);
 void	vfs_opv_free(const struct vnodeopv_desc * const *);
 #ifdef DEBUG
 void	vfs_bufstats(void);
 #endif
 int	mount_specific_key_create(specificdata_key_t *, specificdata_dtor_t);
 void	mount_specific_key_delete(specificdata_key_t);
 void 	mount_initspecific(struct mount *);
 void 	mount_finispecific(struct mount *);
 void *	mount_getspecific(struct mount *, specificdata_key_t);
 void	mount_setspecific(struct mount *, specificdata_key_t, void *);
 int	usermount_common_policy(struct mount *, u_long);
 void	mountlist_append(struct mount *);
 LIST_HEAD(vfs_list_head, vfsops);
 extern struct vfs_list_head vfs_list;
 #else /* _KERNEL */
 #include <sys/cdefs.h>
 __BEGIN_DECLS
 #if !defined(__LIBC12_SOURCE__) && !defined(_STANDALONE)
 int	getfh(const char *, void *, size_t *)
 	__RENAME(__getfh30);
 #endif
 int	unmount(const char *, int);
 #if defined(_NETBSD_SOURCE)
 #ifndef __LIBC12_SOURCE__
 int mount(const char *, const char *, int, void *, size_t) __RENAME(__mount50);
 int	fhopen(const void *, size_t, int) __RENAME(__fhopen40);
 int	fhstat(const void *, size_t, struct stat *) __RENAME(__fhstat50);
 #endif
 #endif /* _NETBSD_SOURCE */
 __END_DECLS
 #endif /* _KERNEL */
 #endif /* !_STANDALONE */
 #endif /* !_SYS_MOUNT_H_ */

 @@ -1,496 +1,496 @@
-/*	$NetBSD: param.h,v 1.531 2017/03/01 10:44:47 hannken Exp $	*/
+/*	$NetBSD: param.h,v 1.532 2017/03/06 10:10:07 hannken Exp $	*/
 /*-
  * Copyright (c) 1982, 1986, 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
+ *
  * 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.
+ *
  *	@(#)param.h	8.3 (Berkeley) 4/4/95
  */
 #ifndef _SYS_PARAM_H_
 #define	_SYS_PARAM_H_
 #ifdef _KERNEL_OPT
 #include "opt_param.h"
 #endif
 /*
  * Historic BSD #defines -- probably will remain untouched for all time.
  */
 #define	BSD	199506		/* System version (year & month). */
 #define	BSD4_3	1
 #define	BSD4_4	1
 /*
  *	#define __NetBSD_Version__ MMmmrrpp00
+ *
  *	M = major version
  *	m = minor version; a minor number of 99 indicates current.
  *	r = 0 (*)
  *	p = patchlevel
+ *
  * When new releases are made, src/gnu/usr.bin/groff/tmac/mdoc.local
  * needs to be updated and the changes sent back to the groff maintainers.
+ *
  * (*)	Up to 2.0I "release" used to be "",A-Z,Z[A-Z] but numeric
  *	    	e.g. NetBSD-1.2D  = 102040000 ('D' == 4)
  *	NetBSD-2.0H 	(200080000) was changed on 20041001 to:
  *	2.99.9		(299000900)
  */
-#define	__NetBSD_Version__	799006400	/* NetBSD 7.99.64 */
+#define	__NetBSD_Version__	799006500	/* NetBSD 7.99.65 */
 #define __NetBSD_Prereq__(M,m,p) (((((M) * 100000000) + \
     (m) * 1000000) + (p) * 100) <= __NetBSD_Version__)
 /*
  * Historical NetBSD #define
+ *
  * NetBSD 1.4 was the last release for which this value was incremented.
  * The value is now permanently fixed at 199905. It will never be
  * changed again.
+ *
  * New code must use __NetBSD_Version__ instead, and should not even
  * count on NetBSD being defined.
+ *
  */
 #define	NetBSD	199905		/* NetBSD version (year & month). */
 /*
  * There macros determine if we are running in protected mode or not.
  *   _HARDKERNEL: code uses kernel namespace and runs in hw priviledged mode
  *   _SOFTKERNEL: code uses kernel namespace but runs without hw priviledges
  */
 #if defined(_KERNEL) && !defined(_RUMPKERNEL)
 #define _HARDKERNEL
 #endif
 #if defined(_KERNEL) && defined(_RUMPKERNEL)
 #define _SOFTKERNEL
 #endif
 #include <sys/null.h>
 #ifndef __ASSEMBLER__
 #include <sys/inttypes.h>
 #include <sys/types.h>
 /*
  * Machine-independent constants (some used in following include files).
  * Redefined constants are from POSIX 1003.1 limits file.
+ *
  * MAXCOMLEN should be >= sizeof(ac_comm) (see <acct.h>)
  * MAXHOSTNAMELEN should be >= (_POSIX_HOST_NAME_MAX + 1) (see <limits.h>)
  * MAXLOGNAME should be >= UT_NAMESIZE (see <utmp.h>)
  */
 #include <sys/syslimits.h>
 #define	MAXCOMLEN	16		/* max command name remembered */
 #define	MAXINTERP	PATH_MAX	/* max interpreter file name length */
 /* DEPRECATED: use LOGIN_NAME_MAX instead. */
 #define	MAXLOGNAME	(LOGIN_NAME_MAX - 1) /* max login name length */
 #define	NCARGS		ARG_MAX		/* max bytes for an exec function */
 #define	NGROUPS		NGROUPS_MAX	/* max number groups */
 #define	NOGROUP		65535		/* marker for empty group set member */
 #define	MAXHOSTNAMELEN	256		/* max hostname size */
 #ifndef NOFILE
 #define	NOFILE		OPEN_MAX	/* max open files per process */
 #endif
 #ifndef MAXUPRC				/* max simultaneous processes */
 #define	MAXUPRC		CHILD_MAX	/* POSIX 1003.1-compliant default */
 #else
 #if (MAXUPRC - 0) < CHILD_MAX
 #error MAXUPRC less than CHILD_MAX.  See options(4) for details.
 #endif /* (MAXUPRC - 0) < CHILD_MAX */
 #endif /* !defined(MAXUPRC) */
 /* Macros for min/max. */
 #define	MIN(a,b)	((/*CONSTCOND*/(a)<(b))?(a):(b))
 #define	MAX(a,b)	((/*CONSTCOND*/(a)>(b))?(a):(b))
 /* More types and definitions used throughout the kernel. */
 #ifdef _KERNEL
 #include <sys/cdefs.h>
 #include <sys/errno.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/ucred.h>
 #include <sys/uio.h>
 #include <uvm/uvm_param.h>
 #ifndef NPROC
 #define	NPROC	(20 + 16 * MAXUSERS)
 #endif
 #ifndef NTEXT
 #define	NTEXT	(80 + NPROC / 8)		/* actually the object cache */
 #endif
 #ifndef NVNODE
 #define	NVNODE	(NPROC + NTEXT + 100)
 #define	NVNODE_IMPLICIT
 #endif
 #ifndef VNODE_KMEM_MAXPCT
 #define	VNODE_KMEM_MAXPCT	60
 #endif
 #ifndef BUFCACHE_VA_MAXPCT
 #define	BUFCACHE_VA_MAXPCT	20
 #endif
 #define	VNODE_COST	2048			/* assumed space in bytes */
 #endif /* _KERNEL */
 /* Signals. */
 #include <sys/signal.h>
 /* Machine type dependent parameters. */
 #include <machine/param.h>
 #include <machine/limits.h>
 /* pages ("clicks") to disk blocks */
 #define	ctod(x)		((x) << (PGSHIFT - DEV_BSHIFT))
 #define	dtoc(x)		((x) >> (PGSHIFT - DEV_BSHIFT))
 /* bytes to pages */
 #define	ctob(x)		((x) << PGSHIFT)
 #define	btoc(x)		(((x) + PGOFSET) >> PGSHIFT)
 /* bytes to disk blocks */
 #define	dbtob(x)	((x) << DEV_BSHIFT)
 #define	btodb(x)	((x) >> DEV_BSHIFT)
 #ifndef COHERENCY_UNIT
 #define	COHERENCY_UNIT		64
 #endif
 #ifndef CACHE_LINE_SIZE
 #define	CACHE_LINE_SIZE		64
 #endif
 #ifndef MAXCPUS
 #define	MAXCPUS			32
 #endif
 #ifndef MAX_LWP_PER_PROC
 #define	MAX_LWP_PER_PROC	8000
 #endif
 /*
  * Stack macros.  On most architectures, the stack grows down,
  * towards lower addresses; it is the rare architecture where
  * it grows up, towards higher addresses.
+ *
  * STACK_GROW and STACK_SHRINK adjust a stack pointer by some
  * size, no questions asked.  STACK_ALIGN aligns a stack pointer.
+ *
  * STACK_ALLOC returns a pointer to allocated stack space of
  * some size; given such a pointer and a size, STACK_MAX gives
  * the maximum (in the "maxsaddr" sense) stack address of the
  * allocated memory.
  */
 #if defined(_KERNEL) || defined(__EXPOSE_STACK)
 #ifndef STACK_ALIGNBYTES
 #define STACK_ALIGNBYTES	__ALIGNBYTES
 #endif
 #ifdef __MACHINE_STACK_GROWS_UP
 #define	STACK_GROW(sp, _size)		(((char *)(void *)(sp)) + (_size))
 #define	STACK_SHRINK(sp, _size)		(((char *)(void *)(sp)) - (_size))
 #define	STACK_ALIGN(sp, bytes)	\
 	((char *)((((unsigned long)(sp)) + (bytes)) & ~(bytes)))
 #define	STACK_ALLOC(sp, _size)		((char *)(void *)(sp))
 #define	STACK_MAX(p, _size)		(((char *)(void *)(p)) + (_size))
 #else
 #define	STACK_GROW(sp, _size)		(((char *)(void *)(sp)) - (_size))
 #define	STACK_SHRINK(sp, _size)		(((char *)(void *)(sp)) + (_size))
 #define	STACK_ALIGN(sp, bytes)	\
 	((char *)(((unsigned long)(sp)) & ~(bytes)))
 #define	STACK_ALLOC(sp, _size)		(((char *)(void *)(sp)) - (_size))
 #define	STACK_MAX(p, _size)		((char *)(void *)(p))
 #endif
 #define	STACK_LEN_ALIGN(len, bytes)	(((len) + (bytes)) & ~(bytes))
 #endif /* defined(_KERNEL) || defined(__EXPOSE_STACK) */
 /*
  * Round p (pointer or byte index) up to a correctly-aligned value for all
  * data types (int, long, ...).   The result is u_int and must be cast to
  * any desired pointer type.
+ *
  * ALIGNED_POINTER is a boolean macro that checks whether an address
  * is valid to fetch data elements of type t from on this architecture.
  * This does not reflect the optimal alignment, just the possibility
  * (within reasonable limits).
+ *
  */
 #define ALIGNBYTES	__ALIGNBYTES
 #ifndef ALIGN
 #define	ALIGN(p)		(((uintptr_t)(p) + ALIGNBYTES) & ~ALIGNBYTES)
 #endif
 #ifndef ALIGNED_POINTER
 #define	ALIGNED_POINTER(p,t)	((((uintptr_t)(p)) & (sizeof(t) - 1)) == 0)
 #endif
 /*
  * Historic priority levels.  These are meaningless and remain only
  * for source compatibility.  Do not use in new code.
  */
 #define	PSWP	0
 #define	PVM	4
 #define	PINOD	8
 #define	PRIBIO	16
 #define	PVFS	20
 #define	PZERO	22
 #define	PSOCK	24
 #define	PWAIT	32
 #define	PLOCK	36
 #define	PPAUSE	40
 #define	PUSER	50
 #define	MAXPRI	127
 #define	PCATCH		0x100	/* OR'd with pri for tsleep to check signals */
 #define	PNORELOCK	0x200	/* OR'd with pri for tsleep to not relock */
 /*
  * New priority levels.
  */
 #define	PRI_COUNT		224
 #define	PRI_NONE		(-1)
 #define	PRI_KERNEL_RT		192
 #define	NPRI_KERNEL_RT		32
 #define	MAXPRI_KERNEL_RT	(PRI_KERNEL_RT + NPRI_KERNEL_RT - 1)
 #define	PRI_USER_RT		128
 #define	NPRI_USER_RT		64
 #define	MAXPRI_USER_RT		(PRI_USER_RT + NPRI_USER_RT - 1)
 #define	PRI_KTHREAD		96
 #define	NPRI_KTHREAD		32
 #define	MAXPRI_KTHREAD		(PRI_KTHREAD + NPRI_KTHREAD - 1)
 #define	PRI_KERNEL		64
 #define	NPRI_KERNEL		32
 #define	MAXPRI_KERNEL		(PRI_KERNEL + NPRI_KERNEL - 1)
 #define	PRI_USER		0
 #define	NPRI_USER		64
 #define	MAXPRI_USER		(PRI_USER + NPRI_USER - 1)
 /* Priority range used by POSIX real-time features */
 #define	SCHED_PRI_MIN		0
 #define	SCHED_PRI_MAX		63
 /*
  * Kernel thread priorities.
  */
 #define	PRI_SOFTSERIAL	MAXPRI_KERNEL_RT
 #define	PRI_SOFTNET	(MAXPRI_KERNEL_RT - schedppq * 1)
 #define	PRI_SOFTBIO	(MAXPRI_KERNEL_RT - schedppq * 2)
 #define	PRI_SOFTCLOCK	(MAXPRI_KERNEL_RT - schedppq * 3)
 #define	PRI_XCALL	MAXPRI_KTHREAD
 #define	PRI_PGDAEMON	(MAXPRI_KTHREAD - schedppq * 1)
 #define	PRI_VM		(MAXPRI_KTHREAD - schedppq * 2)
 #define	PRI_IOFLUSH	(MAXPRI_KTHREAD - schedppq * 3)
 #define	PRI_BIO		(MAXPRI_KTHREAD - schedppq * 4)
 #define	PRI_IDLE	PRI_USER
 /*
  * Miscellaneous.
  */
 #define	NBPW	sizeof(int)	/* number of bytes per word (integer) */
 #define	CMASK	022		/* default file mask: S_IWGRP|S_IWOTH */
 #define	NODEV	(dev_t)(-1)	/* non-existent device */
 /*
  * File system parameters and macros.
+ *
  * The file system is made out of blocks of at most MAXBSIZE units, with
  * smaller units (fragments) only in the last direct block.  MAXBSIZE
  * primarily determines the size of buffers in the buffer pool.  It may be
  * made larger without any effect on existing file systems; however making
  * it smaller may make some file systems unmountable.
  */
 #ifndef MAXBSIZE				/* XXX */
 #define	MAXBSIZE	MAXPHYS
 #endif
 #define	MAXFRAG 	8
 /*
  * MAXPATHLEN defines the longest permissible path length after expanding
  * symbolic links. It is used to allocate a temporary buffer from the buffer
  * pool in which to do the name expansion, hence should be a power of two,
  * and must be less than or equal to MAXBSIZE.  MAXSYMLINKS defines the
  * maximum number of symbolic links that may be expanded in a path name.
  * It should be set high enough to allow all legitimate uses, but halt
  * infinite loops reasonably quickly.
+ *
  * MAXSYMLINKS should be >= _POSIX_SYMLOOP_MAX (see <limits.h>)
  */
 #define	MAXPATHLEN	PATH_MAX
 #define	MAXSYMLINKS	32
 /*
  * This is the maximum individual filename component length enforced by
  * namei. Filesystems cannot exceed this limit. The upper bound for that
  * limit is NAME_MAX. We don't bump it for now, for compatibility with
  * old binaries during the time where MAXPATHLEN was 511 and NAME_MAX was
  * 255
  */
 #define	KERNEL_NAME_MAX	255
 /* Bit map related macros. */
 #define	setbit(a,i)	((a)[(i)/NBBY] |= 1<<((i)%NBBY))
 #define	clrbit(a,i)	((a)[(i)/NBBY] &= ~(1<<((i)%NBBY)))
 #define	isset(a,i)	((a)[(i)/NBBY] & (1<<((i)%NBBY)))
 #define	isclr(a,i)	(((a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
 /* Macros for counting and rounding. */
 #ifndef howmany
 #define	howmany(x, y)	(((x)+((y)-1))/(y))
 #endif
 #define	roundup(x, y)	((((x)+((y)-1))/(y))*(y))
 #define	rounddown(x,y)	(((x)/(y))*(y))
 /*
  * Rounding to powers of two.  The naive definitions of roundup2 and
  * rounddown2,
+ *
  *	#define	roundup2(x,m)	(((x) + ((m) - 1)) & ~((m) - 1))
  *	#define	rounddown2(x,m)	((x) & ~((m) - 1)),
+ *
  * exhibit a quirk of integer arithmetic in C because the complement
  * happens in the type of m, not in the type of x.  So if unsigned int
  * is 32-bit, and m is an unsigned int while x is a uint64_t, then
  * roundup2 and rounddown2 would have the unintended effect of clearing
  * the upper 32 bits of the result(!).  These definitions avoid the
  * pitfalls of C arithmetic depending on the types of x and m, and
  * additionally avoid multiply evaluating their arguments.
  */
 #define	roundup2(x,m)	((((x) - 1) | ((m) - 1)) + 1)
 #define	rounddown2(x,m)	((x) & ~((__typeof__(x))((m) - 1)))
 #define	powerof2(x)	((((x)-1)&(x))==0)
 /*
  * Constants for setting the parameters of the kernel memory allocator.
+ *
  * 2 ** MINBUCKET is the smallest unit of memory that will be
  * allocated. It must be at least large enough to hold a pointer.
+ *
  * Units of memory less or equal to MAXALLOCSAVE will permanently
  * allocate physical memory; requests for these size pieces of
  * memory are quite fast. Allocations greater than MAXALLOCSAVE must
  * always allocate and free physical memory; requests for these
  * size allocations should be done infrequently as they will be slow.
+ *
  * Constraints: NBPG <= MAXALLOCSAVE <= 2 ** (MINBUCKET + 14), and
  * MAXALLOCSAVE must be a power of two.
  */
 #ifdef _LP64
 #define	MINBUCKET	5		/* 5 => min allocation of 32 bytes */
 #else
 #define	MINBUCKET	4		/* 4 => min allocation of 16 bytes */
 #endif
 #define	MAXALLOCSAVE	(2 * NBPG)
 /*
  * Scale factor for scaled integers used to count %cpu time and load avgs.
+ *
  * The number of CPU `tick's that map to a unique `%age' can be expressed
  * by the formula (1 / (2 ^ (FSHIFT - 11))).  The maximum load average that
  * can be calculated (assuming 32 bits) can be closely approximated using
  * the formula (2 ^ (2 * (16 - FSHIFT))) for (FSHIFT < 15).
+ *
  * For the scheduler to maintain a 1:1 mapping of CPU `tick' to `%age',
  * FSHIFT must be at least 11; this gives us a maximum load avg of ~1024.
  */
 #define	FSHIFT	11		/* bits to right of fixed binary point */
 #define	FSCALE	(1<<FSHIFT)
 /*
  * The time for a process to be blocked before being very swappable.
  * This is a number of seconds which the system takes as being a non-trivial
  * amount of real time.  You probably shouldn't change this;
  * it is used in subtle ways (fractions and multiples of it are, that is, like
  * half of a ``long time'', almost a long time, etc.)
  * It is related to human patience and other factors which don't really
  * change over time.
  */
 #define        MAXSLP          20
 /*
  * Defaults for Unified Buffer Cache parameters.
  * These may be overridden in <machine/param.h>.
  */
 #ifndef UBC_WINSHIFT
 #define	UBC_WINSHIFT	13
 #endif
 #ifndef UBC_NWINS
 #define	UBC_NWINS	1024
 #endif
 #ifdef _KERNEL
 /*
  * macro to convert from milliseconds to hz without integer overflow
  * Default version using only 32bits arithmetics.
  * 64bit port can define 64bit version in their <machine/param.h>
  * 0x20000 is safe for hz < 20000
  */
 #ifndef mstohz
 #define mstohz(ms) \
 	(__predict_false((ms) >= 0x20000) ? \
 	    ((ms +0u) / 1000u) * hz : \
 	    ((ms +0u) * hz) / 1000u)
 #endif
 #ifndef hztoms
 #define hztoms(t) \
 	(__predict_false((t) >= 0x20000) ? \
 	    ((t +0u) / hz) * 1000u : \
 	    ((t +0u) * 1000u) / hz)
 #endif
 extern const int schedppq;
 extern size_t coherency_unit;
 #endif /* _KERNEL */
 /*
  * Minimum alignment of "struct lwp" needed by the architecture.
  * This counts when packing a lock byte into a word alongside a
  * pointer to an LWP.
  */
 #ifndef MIN_LWP_ALIGNMENT
 #define	MIN_LWP_ALIGNMENT	32
 #endif
 #endif /* !__ASSEMBLER__ */
 #endif /* !_SYS_PARAM_H_ */