 @@ -1,14 +1,14 @@
-/*	$NetBSD: exec_subr.c,v 1.84 2020/04/13 19:23:18 ad Exp $	*/
+/*	$NetBSD: exec_subr.c,v 1.85 2023/04/09 09:18:09 riastradh Exp $	*/
 /*
  * Copyright (c) 1993, 1994, 1996 Christopher G. Demetriou
  * 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.
 @@ -21,27 +21,27 @@
  * 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 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: exec_subr.c,v 1.84 2020/04/13 19:23:18 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: exec_subr.c,v 1.85 2023/04/09 09:18:09 riastradh Exp $");
 #include "opt_pax.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/kmem.h>
 #include <sys/vnode.h>
 #include <sys/filedesc.h>
 #include <sys/exec.h>
 #include <sys/mman.h>
 #include <sys/resourcevar.h>
 #include <sys/device.h>
 @@ -450,20 +450,21 @@ exec_setup_stack(struct lwp *l, struct e
 		vsize_t guard_size = MIN(VM_MAXUSER_ADDRESS - epp->ep_maxsaddr, user_stack_guard_size);
 		if (guard_size > 0)
 			NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, guard_size,
 			    epp->ep_maxsaddr, NULL, 0, VM_PROT_NONE);
 #else
 		NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, user_stack_guard_size,
 		    epp->ep_maxsaddr - user_stack_guard_size, NULL, 0, VM_PROT_NONE);
 #endif
+	}
 	if (noaccess_size > 0 && noaccess_size <= MAXSSIZ) {
 		NEW_VMCMD2(&epp->ep_vmcmds, vmcmd_map_zero, noaccess_size,
 		    noaccess_linear_min, NULL, 0, VM_PROT_NONE, VMCMD_STACK);
+	}
-	KASSERT(access_size > 0 && access_size <= MAXSSIZ);
+	KASSERT(access_size > 0);
 	KASSERT(access_size <= MAXSSIZ);
 	NEW_VMCMD2(&epp->ep_vmcmds, vmcmd_map_zero, access_size,
 	    access_linear_min, NULL, 0, VM_PROT_READ | VM_PROT_WRITE,
 	    VMCMD_STACK);
 	return 0;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_event.c,v 1.146 2022/07/24 19:23:44 riastradh Exp $	*/
+/*	$NetBSD: kern_event.c,v 1.147 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2008, 2009, 2021 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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.
 @@ -53,27 +53,27 @@
  * 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.
+ *
  * FreeBSD: src/sys/kern/kern_event.c,v 1.27 2001/07/05 17:10:44 rwatson Exp
  */
 #ifdef _KERNEL_OPT
 #include "opt_ddb.h"
 #endif /* _KERNEL_OPT */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_event.c,v 1.146 2022/07/24 19:23:44 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_event.c,v 1.147 2023/04/09 09:18:09 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/wait.h>
 #include <sys/proc.h>
 #include <sys/file.h>
 #include <sys/select.h>
 #include <sys/queue.h>
 #include <sys/event.h>
 #include <sys/eventvar.h>
 #include <sys/poll.h>
 #include <sys/kmem.h>
 @@ -1390,27 +1390,28 @@ filt_timercompute(struct kevent *kev, ui
 	return 0;
+}
 static void
 filt_timerexpire(void *knx)
+{
 	struct knote *kn = knx;
 	struct kqueue *kq = kn->kn_kq;
 	mutex_spin_enter(&kq->kq_lock);
 	kn->kn_data++;
 	knote_activate_locked(kn);
 	if (kn->kn_sdata != FILT_TIMER_NOSCHED) {
-		KASSERT(kn->kn_sdata > 0 && kn->kn_sdata <= INT_MAX);
+		KASSERT(kn->kn_sdata > 0);
 		KASSERT(kn->kn_sdata <= INT_MAX);
 		callout_schedule((callout_t *)kn->kn_hook,
 		    (int)kn->kn_sdata);
+	}
 	mutex_spin_exit(&kq->kq_lock);
+}
 static inline void
 filt_timerstart(struct knote *kn, uintptr_t tticks)
+{
 	callout_t *calloutp = kn->kn_hook;
 	KASSERT(mutex_owned(&kn->kn_kq->kq_lock));
 	KASSERT(!callout_pending(calloutp));
 @@ -2438,28 +2439,28 @@ relock:
 			(void)filter_touch(kn, kevp, EVENT_PROCESS);
 		} else {
 			*kevp = kn->kn_kevent;
+		}
 		kevp++;
 		nkev++;
 		influx = 1;
 		if (kn->kn_flags & EV_ONESHOT) {
 			/* delete ONESHOT events after retrieval */
 			KNOTE_WILLDETACH(kn);
 			kn->kn_status &= ~KN_BUSY;
 			kq->kq_count--;
 			KASSERT(kn_in_flux(kn) == false);
-			KASSERT((kn->kn_status & KN_WILLDETACH) != 0 &&
+			KASSERT((kn->kn_status & KN_WILLDETACH) != 0);
-				kn->kn_kevent.udata == curlwp);
+			KASSERT(kn->kn_kevent.udata == curlwp);
 			mutex_spin_exit(&kq->kq_lock);
 			knote_detach(kn, fdp, true);
 			mutex_enter(&fdp->fd_lock);
 			mutex_spin_enter(&kq->kq_lock);
 		} else if (kn->kn_flags & EV_CLEAR) {
 			/* clear state after retrieval */
 			kn->kn_data = 0;
 			kn->kn_fflags = 0;
 			/*
 			 * Manually clear knotes who weren't
 			 * 'touch'ed.
 			 */
 			if (touch == 0) {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_lwp.c,v 1.251 2022/07/01 01:06:04 riastradh Exp $	*/
+/*	$NetBSD: kern_lwp.c,v 1.252 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2001, 2006, 2007, 2008, 2009, 2019, 2020
  *     The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Nathan J. Williams, and Andrew Doran.
+ *
  * 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
 @@ -207,27 +207,27 @@
  *	(But not always for kernel threads.  There are some special cases
  *	as mentioned above: soft interrupts, and the idle loops.)
+ *
  *	Note that an LWP is considered running or likely to run soon if in
  *	one of the following states.  This affects the value of p_nrlwps:
+ *
  *		LSRUN, LSONPROC, LSSLEEP
+ *
  *	p_lock does not need to be held when transitioning among these
  *	three states, hence p_lock is rarely taken for state transitions.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_lwp.c,v 1.251 2022/07/01 01:06:04 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_lwp.c,v 1.252 2023/04/09 09:18:09 riastradh Exp $");
 #include "opt_ddb.h"
 #include "opt_lockdebug.h"
 #include "opt_dtrace.h"
 #define _LWP_API_PRIVATE
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/cpu.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/syscallargs.h>
 @@ -1065,27 +1065,28 @@ lwp_startup(struct lwp *prev, struct lwp
  * Exit an LWP.
+ *
  * *** WARNING *** This can be called with (l != curlwp) in error paths.
  */
 void
 lwp_exit(struct lwp *l)
+{
 	struct proc *p = l->l_proc;
 	struct lwp *l2;
 	bool current;
 	current = (l == curlwp);
-	KASSERT(current || (l->l_stat == LSIDL && l->l_target_cpu == NULL));
+	KASSERT(current || l->l_stat == LSIDL);
 	KASSERT(current || l->l_target_cpu == NULL);
 	KASSERT(p == curproc);
 	SDT_PROBE(proc, kernel, , lwp__exit, l, 0, 0, 0, 0);
 	/* Verify that we hold no locks; for DIAGNOSTIC check kernel_lock. */
 	LOCKDEBUG_BARRIER(NULL, 0);
 	KASSERTMSG(curcpu()->ci_biglock_count == 0, "kernel_lock leaked");
 	/*
 	 * If we are the last live LWP in a process, we need to exit the
 	 * entire process.  We do so with an exit status of zero, because
 	 * it's a "controlled" exit, and because that's what Solaris does.
+	 *

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_proc.c,v 1.269 2022/10/26 23:20:36 riastradh Exp $	*/
+/*	$NetBSD: kern_proc.c,v 1.270 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 1999, 2006, 2007, 2008, 2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, and by Andrew Doran.
+ *
  * 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
 @@ -52,27 +52,27 @@
  * 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.
+ *
  *	@(#)kern_proc.c	8.7 (Berkeley) 2/14/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_proc.c,v 1.269 2022/10/26 23:20:36 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_proc.c,v 1.270 2023/04/09 09:18:09 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_kstack.h"
 #include "opt_maxuprc.h"
 #include "opt_dtrace.h"
 #include "opt_compat_netbsd32.h"
 #include "opt_kaslr.h"
 #endif
 #if defined(__HAVE_COMPAT_NETBSD32) && !defined(COMPAT_NETBSD32) \
     && !defined(_RUMPKERNEL)
 #define COMPAT_NETBSD32
 #endif
 @@ -2034,27 +2034,28 @@ proc_active_lwp(struct proc *p)
 ,
 ,	/* LSIDL */
 ,	/* LSRUN */
 ,	/* LSSLEEP */
 ,	/* LSSTOP */
 ,	/* LSZOMB */
 ,	/* LSDEAD */
 ,	/* LSONPROC */
 	/* LSSUSPENDED */
 	};
 	struct lwp *l, *lp = NULL;
 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {
-		KASSERT(l->l_stat >= 0 && l->l_stat < __arraycount(ostat));
+		KASSERT(l->l_stat >= 0);
 		KASSERT(l->l_stat < __arraycount(ostat));
 		if (lp == NULL ||
 		    ostat[l->l_stat] > ostat[lp->l_stat] ||
 		    (ostat[l->l_stat] == ostat[lp->l_stat] &&
 		    l->l_cpticks > lp->l_cpticks)) {
 			lp = l;
 			continue;
+		}
+	}
 	return lp;
+}
 static int
 sysctl_doeproc(SYSCTLFN_ARGS)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_sig.c,v 1.404 2022/04/09 23:38:33 riastradh Exp $	*/
+/*	$NetBSD: kern_sig.c,v 1.405 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2006, 2007, 2008, 2019 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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.
 @@ -60,27 +60,27 @@
  * 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.
+ *
  *	@(#)kern_sig.c	8.14 (Berkeley) 5/14/95
  */
 /*
  * Signal subsystem.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_sig.c,v 1.404 2022/04/09 23:38:33 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_sig.c,v 1.405 2023/04/09 09:18:09 riastradh Exp $");
 #include "opt_execfmt.h"
 #include "opt_ptrace.h"
 #include "opt_dtrace.h"
 #include "opt_compat_sunos.h"
 #include "opt_compat_netbsd.h"
 #include "opt_compat_netbsd32.h"
 #include "opt_pax.h"
 #define	SIGPROP		/* include signal properties table */
 #include <sys/param.h>
 #include <sys/signalvar.h>
 #include <sys/proc.h>
 @@ -1306,27 +1306,28 @@ kpsignal2(struct proc *p, ksiginfo_t *ks
 	int prop, signo = ksi->ksi_signo;
 	struct lwp *l = NULL;
 	ksiginfo_t *kp;
 	lwpid_t lid;
 	sig_t action;
 	bool toall;
 	bool traced;
 	int error = 0;
 	KASSERT(!cpu_intr_p());
 	KASSERT(mutex_owned(&proc_lock));
 	KASSERT(mutex_owned(p->p_lock));
 	KASSERT((ksi->ksi_flags & KSI_QUEUED) == 0);
-	KASSERT(signo > 0 && signo < NSIG);
+	KASSERT(signo > 0);
 	KASSERT(signo < NSIG);
 	/*
 	 * If the process is being created by fork, is a zombie or is
 	 * exiting, then just drop the signal here and bail out.
 	 */
 	if (p->p_stat != SACTIVE && p->p_stat != SSTOP)
 		return 0;
 	/*
 	 * Notify any interested parties of the signal.
 	 */
 	KNOTE(&p->p_klist, NOTE_SIGNAL | signo);
 @@ -1561,27 +1562,28 @@ proc_stop_lwps(struct proc *p)
 /*
  * Finish stopping of a process.  Mark it stopped and notify the parent.
+ *
  * Drop p_lock briefly if ppsig is true.
  */
 static void
 proc_stop_done(struct proc *p, int ppmask)
+{
 	KASSERT(mutex_owned(&proc_lock));
 	KASSERT(mutex_owned(p->p_lock));
 	KASSERT((p->p_sflag & PS_STOPPING) != 0);
-	KASSERT(p->p_nrlwps == 0 || (p->p_nrlwps == 1 && p == curproc));
+	KASSERT(p->p_nrlwps == 0 || p->p_nrlwps == 1);
 	KASSERT(p->p_nrlwps == 0 || p == curproc);
 	p->p_sflag &= ~PS_STOPPING;
 	p->p_stat = SSTOP;
 	p->p_waited = 0;
 	p->p_pptr->p_nstopchild++;
 	/* child_psignal drops p_lock briefly. */
 	child_psignal(p, ppmask);
 	cv_broadcast(&p->p_pptr->p_waitcv);
+}
 /*
  * Stop the current process and switch away to the debugger notifying

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_sleepq.c,v 1.73 2022/06/29 22:27:01 riastradh Exp $	*/
+/*	$NetBSD: kern_sleepq.c,v 1.74 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2006, 2007, 2008, 2009, 2019, 2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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.
 @@ -25,27 +25,27 @@
  * 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.
  */
 /*
  * Sleep queue implementation, used by turnstiles and general sleep/wakeup
  * interfaces.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_sleepq.c,v 1.73 2022/06/29 22:27:01 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_sleepq.c,v 1.74 2023/04/09 09:18:09 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/cpu.h>
 #include <sys/intr.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/resourcevar.h>
 #include <sys/sched.h>
 #include <sys/systm.h>
 #include <sys/sleepq.h>
 #include <sys/ktrace.h>
 @@ -215,27 +215,28 @@ sleepq_insert(sleepq_t *sq, lwp_t *l, sy
+ *
  *	Enter an LWP into the sleep queue and prepare for sleep.  The sleep
  *	queue must already be locked, and any interlock (such as the kernel
  *	lock) must have be released (see sleeptab_lookup(), sleepq_enter()).
  */
 void
 sleepq_enqueue(sleepq_t *sq, wchan_t wchan, const char *wmesg, syncobj_t *sobj,
     bool catch_p)
+{
 	lwp_t *l = curlwp;
 	KASSERT(lwp_locked(l, NULL));
 	KASSERT(l->l_stat == LSONPROC);
-	KASSERT(l->l_wchan == NULL && l->l_sleepq == NULL);
+	KASSERT(l->l_wchan == NULL);
 	KASSERT(l->l_sleepq == NULL);
 	KASSERT((l->l_flag & LW_SINTR) == 0);
 	l->l_syncobj = sobj;
 	l->l_wchan = wchan;
 	l->l_sleepq = sq;
 	l->l_wmesg = wmesg;
 	l->l_slptime = 0;
 	l->l_stat = LSSLEEP;
 	if (catch_p)
 		l->l_flag |= LW_SINTR;
 	sleepq_insert(sq, l, sobj);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_softint.c,v 1.72 2022/10/28 21:52:02 riastradh Exp $	*/
+/*	$NetBSD: kern_softint.c,v 1.73 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2007, 2008, 2019, 2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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.
 @@ -160,27 +160,27 @@
  *		    interrupt;
  *	}
+ *
  *	Once the soft interrupt has fired (and even if it has blocked),
  *	no further soft interrupts at that level will be triggered by
  *	MI code until the soft interrupt handler has ceased execution.
  *	If a soft interrupt handler blocks and is resumed, it resumes
  *	execution as a normal LWP (kthread) and gains VM context.  Only
  *	when it has completed and is ready to fire again will it
  *	interrupt other threads.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_softint.c,v 1.72 2022/10/28 21:52:02 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_softint.c,v 1.73 2023/04/09 09:18:09 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/intr.h>
 #include <sys/ipi.h>
 #include <sys/lock.h>
 #include <sys/mutex.h>
 #include <sys/kernel.h>
 #include <sys/kthread.h>
 #include <sys/evcnt.h>
 #include <sys/cpu.h>
 #include <sys/xcall.h>
 #include <sys/psref.h>
 @@ -423,27 +423,28 @@ softint_establish(u_int flags, void (*fu
  *	because we will wait for the softint to complete if it's still
  *	running.
  */
 void
 softint_disestablish(void *arg)
+{
 	CPU_INFO_ITERATOR cii;
 	struct cpu_info *ci;
 	softcpu_t *sc;
 	softhand_t *sh;
 	uintptr_t offset;
 	offset = (uintptr_t)arg;
-	KASSERTMSG(offset != 0 && offset < softint_bytes, "%"PRIuPTR" %u",
+	KASSERT(offset != 0);
 	KASSERTMSG(offset < softint_bytes, "%"PRIuPTR" %u",
 	    offset, softint_bytes);
 	/*
 	 * Unregister IPI handler if there is any.  Note: there is no need
 	 * to disable preemption here - ID is stable.
 	 */
 	sc = curcpu()->ci_data.cpu_softcpu;
 	sh = (softhand_t *)((uint8_t *)sc + offset);
 	if (sh->sh_ipi_id) {
 		ipi_unregister(sh->sh_ipi_id);
+	}
 	/*
 @@ -486,27 +487,28 @@ softint_schedule(void *arg)
 	int s;
 	SDT_PROBE2(sdt, kernel, softint, schedule,  arg, /*ci*/NULL);
 	/*
 	 * If this assert fires, rather than disabling preemption explicitly
 	 * to make it stop, consider that you are probably using a softint
 	 * when you don't need to.
 	 */
 	KASSERT(kpreempt_disabled());
 	/* Find the handler record for this CPU. */
 	offset = (uintptr_t)arg;
-	KASSERTMSG(offset != 0 && offset < softint_bytes, "%"PRIuPTR" %u",
+	KASSERT(offset != 0);
 	KASSERTMSG(offset < softint_bytes, "%"PRIuPTR" %u",
 	    offset, softint_bytes);
 	sh = (softhand_t *)((uint8_t *)curcpu()->ci_data.cpu_softcpu + offset);
 	/* If it's already pending there's nothing to do. */
 	if ((sh->sh_flags & SOFTINT_PENDING) != 0) {
 		return;
+	}
 	/*
 	 * Enqueue the handler into the LWP's pending list.
 	 * If the LWP is completely idle, then make it run.
 	 */
 	s = splhigh();

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_sysctl.c,v 1.268 2023/02/17 06:20:31 skrll Exp $	*/
+/*	$NetBSD: kern_sysctl.c,v 1.269 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2003, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Brown.
+ *
  * 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.
 @@ -60,27 +60,27 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)kern_sysctl.c	8.9 (Berkeley) 5/20/95
  */
 /*
  * sysctl system call.
  */
 #define __COMPAT_SYSCTL
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_sysctl.c,v 1.268 2023/02/17 06:20:31 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_sysctl.c,v 1.269 2023/04/09 09:18:09 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_defcorename.h"
 #endif
 #include "ksyms.h"
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/buf.h>
 #include <sys/cprng.h>
 #include <sys/kauth.h>
 @@ -2507,29 +2507,29 @@ sysctl_teardown(struct sysctllog **logp)
 	struct sysctllog *log;
 	uint namelen;
 	int *name, t, v, error, ni;
 	size_t sz;
 	if (logp == NULL || *logp == NULL)
 		return;
 	log = *logp;
 	rw_enter(&sysctl_treelock, RW_WRITER);
 	memset(&node, 0, sizeof(node));
 	while (log->log_left < log->log_size) {
-		KASSERT((log->log_left + 3 < log->log_size) &&
+		KASSERT(log->log_left + 3 < log->log_size);
-			(log->log_left + log->log_num[log->log_left + 2] <=
+		KASSERT(log->log_left + log->log_num[log->log_left + 2] <=
-			 log->log_size));
+		    log->log_size);
 		v = log->log_num[log->log_left++];
 		t = log->log_num[log->log_left++];
 		namelen = log->log_num[log->log_left++];
 		name = &log->log_num[log->log_left];
 		node.sysctl_num = name[namelen - 1];
 		node.sysctl_flags = SYSCTL_VERSION|t;
 		node.sysctl_ver = v;
 		rnode = log->log_root;
 		error = sysctl_locate(NULL, &name[0], namelen, &rnode, &ni);
 		if (error == 0) {
 			name[namelen - 1] = CTL_DESTROY;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_turnstile.c,v 1.45 2022/10/26 23:27:16 riastradh Exp $	*/
+/*	$NetBSD: kern_turnstile.c,v 1.46 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2002, 2006, 2007, 2009, 2019, 2020
  *     The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe and Andrew Doran.
+ *
  * 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
 @@ -51,27 +51,27 @@
  * queue.  If a thread decides it doesn't need to block after all, then this
  * interlock must be released by explicitly aborting the turnstile
  * operation.
+ *
  * When a thread is awakened, it needs to get its turnstile back.  If there
  * are still other threads waiting in the active turnstile, the thread
  * grabs a free turnstile off the free list.  Otherwise, it can take back
  * the active turnstile from the lock (thus deactivating the turnstile).
+ *
  * Turnstiles are where we do priority inheritence.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_turnstile.c,v 1.45 2022/10/26 23:27:16 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_turnstile.c,v 1.46 2023/04/09 09:18:09 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/lockdebug.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/sleepq.h>
 #include <sys/sleeptab.h>
 #include <sys/systm.h>
 /*
  * Shift of 6 aligns to typical cache line size of 64 bytes;  there's no
  * point having two turnstile locks to back two lock objects that share one
  * cache line.
 @@ -375,37 +375,38 @@ turnstile_block(turnstile_t *ts, int q,
 	turnstile_t *ots;
 	tschain_t *tc;
 	kmutex_t *lock;
 	sleepq_t *sq;
 	pri_t obase;
 	u_int hash;
 	hash = TS_HASH(obj);
 	tc = &turnstile_chains[hash];
 	lock = &turnstile_locks[hash].lock;
 	KASSERT(q == TS_READER_Q || q == TS_WRITER_Q);
 	KASSERT(mutex_owned(lock));
-	KASSERT(l != NULL && l->l_ts != NULL);
+	KASSERT(l != NULL);
 	KASSERT(l->l_ts != NULL);
 	if (ts == NULL) {
 		/*
 		 * We are the first thread to wait for this object;
 		 * lend our turnstile to it.
 		 */
 		ts = l->l_ts;
 		KASSERT(TS_ALL_WAITERS(ts) == 0);
-		KASSERT(LIST_EMPTY(&ts->ts_sleepq[TS_READER_Q]) &&
+		KASSERT(LIST_EMPTY(&ts->ts_sleepq[TS_READER_Q]));
-			LIST_EMPTY(&ts->ts_sleepq[TS_WRITER_Q]));
+		KASSERT(LIST_EMPTY(&ts->ts_sleepq[TS_WRITER_Q]));
 		ts->ts_obj = obj;
 		ts->ts_inheritor = NULL;
 		LIST_INSERT_HEAD(tc, ts, ts_chain);
 	} else {
 		/*
 		 * Object already has a turnstile.  Put our turnstile
 		 * onto the free list, and reference the existing
 		 * turnstile instead.
 		 */
 		ots = l->l_ts;
 		KASSERT(ots->ts_free == NULL);
 		ots->ts_free = ts->ts_free;
 		ts->ts_free = ots;
 @@ -449,27 +450,28 @@ turnstile_block(turnstile_t *ts, int q,
 void
 turnstile_wakeup(turnstile_t *ts, int q, int count, lwp_t *nl)
+{
 	sleepq_t *sq;
 	kmutex_t *lock;
 	u_int hash;
 	lwp_t *l;
 	hash = TS_HASH(ts->ts_obj);
 	lock = &turnstile_locks[hash].lock;
 	sq = &ts->ts_sleepq[q];
 	KASSERT(q == TS_READER_Q || q == TS_WRITER_Q);
-	KASSERT(count > 0 && count <= TS_WAITERS(ts, q));
+	KASSERT(count > 0);
 	KASSERT(count <= TS_WAITERS(ts, q));
 	KASSERT(mutex_owned(lock));
 	KASSERT(ts->ts_inheritor == curlwp || ts->ts_inheritor == NULL);
 	/*
 	 * restore inherited priority if necessary.
 	 */
 	if (ts->ts_inheritor != NULL) {
 		turnstile_unlendpri(ts);
+	}
 	if (nl != NULL) {
 #if defined(DEBUG) || defined(LOCKDEBUG)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: tty_ptm.c,v 1.45 2022/09/29 12:18:27 christos Exp $	*/
+/*	$NetBSD: tty_ptm.c,v 1.46 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2004, 2020 The NetBSD Foundation, Inc.
  * 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.
 @@ -17,27 +17,27 @@
  * ``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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: tty_ptm.c,v 1.45 2022/09/29 12:18:27 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: tty_ptm.c,v 1.46 2023/04/09 09:18:09 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_compat_netbsd.h"
 #include "opt_ptm.h"
 #endif
 /* pty multiplexor driver /dev/ptm{,x} */
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/ioctl.h>
 #include <sys/proc.h>
 #include <sys/tty.h>
 @@ -132,27 +132,28 @@ int
 pty_vn_open(struct vnode *vp, struct lwp *l)
+{
 	int error;
 	if (vp->v_type != VCHR) {
 		vput(vp);
 		return EINVAL;
+	}
 	error = VOP_OPEN(vp, FREAD|FWRITE, lwp0.l_cred);
 	if (error) {
 		/* only ptys mean we can't get these */
-		KASSERT(error != EDUPFD && error != EMOVEFD);
+		KASSERT(error != EDUPFD);
 		KASSERT(error != EMOVEFD);
 		vput(vp);
 		return error;
+	}
 	mutex_enter(vp->v_interlock);
 	vp->v_writecount++;
 	mutex_exit(vp->v_interlock);
 	return 0;
+}
 static int
 pty_alloc_master(struct lwp *l, int *fd, dev_t *dev, struct mount *mp,

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_veriexec.c,v 1.26 2020/06/11 02:30:21 thorpej Exp $	*/
+/*	$NetBSD: kern_veriexec.c,v 1.27 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2005, 2006 Elad Efrat <elad@NetBSD.org>
  * Copyright (c) 2005, 2006 Brett Lymn <blymn@NetBSD.org>
  * 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
 @@ -19,27 +19,27 @@
  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHORS 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: kern_veriexec.c,v 1.26 2020/06/11 02:30:21 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_veriexec.c,v 1.27 2023/04/09 09:18:09 riastradh Exp $");
 #include "opt_veriexec.h"
 #include <sys/param.h>
 #include <sys/mount.h>
 #include <sys/kmem.h>
 #include <sys/vnode.h>
 #include <sys/namei.h>
 #include <sys/once.h>
 #include <sys/proc.h>
 #include <sys/rwlock.h>
 #include <sys/syslog.h>
 #include <sys/sysctl.h>
 @@ -220,28 +220,31 @@ SYSCTL_SETUP(sysctl_kern_veriexec_setup,
 		       CTL_CREATE, CTL_EOL);
+}
 /*
  * Add ops to the fingerprint ops vector list.
  */
 int
 veriexec_fpops_add(const char *fp_type, size_t hash_len, size_t ctx_size,
     veriexec_fpop_init_t init, veriexec_fpop_update_t update,
     veriexec_fpop_final_t final)
+{
 	struct veriexec_fpops *ops;
-	KASSERT((init != NULL) && (update != NULL) && (final != NULL));
+	KASSERT(init != NULL);
-	KASSERT((hash_len != 0) && (ctx_size != 0));
+	KASSERT(update != NULL);
 	KASSERT(final != NULL);
 	KASSERT(hash_len != 0);
 	KASSERT(ctx_size != 0);
 	KASSERT(fp_type != NULL);
 	if (veriexec_fpops_lookup(fp_type) != NULL)
 		return (EEXIST);
 	ops = kmem_alloc(sizeof(*ops), KM_SLEEP);
 	ops->type = fp_type;
 	ops->hash_len = hash_len;
 	ops->context_size = ctx_size;
 	ops->init = init;
 	ops->update = update;
 	ops->final = final;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_asan.c,v 1.27 2020/12/18 15:33:34 martin Exp $	*/
+/*	$NetBSD: subr_asan.c,v 1.28 2023/04/09 09:18:09 riastradh Exp $	*/
 /*
  * Copyright (c) 2018-2020 Maxime Villard, m00nbsd.net
  * All rights reserved.
+ *
  * This code is part of the KASAN subsystem of the NetBSD kernel.
+ *
  * 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
 @@ -19,27 +19,27 @@
  * 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 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: subr_asan.c,v 1.27 2020/12/18 15:33:34 martin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_asan.c,v 1.28 2023/04/09 09:18:09 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/param.h>
 #include <sys/conf.h>
 #include <sys/systm.h>
 #include <sys/types.h>
 #include <sys/asan.h>
 #include <uvm/uvm_extern.h>
 #ifdef DDB
 @@ -105,27 +105,28 @@ kasan_shadow_map(void *addr, size_t size
 	KASSERT((vaddr_t)addr % KASAN_SHADOW_SCALE_SIZE == 0);
 	sz = roundup(size, KASAN_SHADOW_SCALE_SIZE) / KASAN_SHADOW_SCALE_SIZE;
 	sva = (vaddr_t)kasan_md_addr_to_shad(addr);
 	eva = (vaddr_t)kasan_md_addr_to_shad(addr) + sz;
 	sva = rounddown(sva, PAGE_SIZE);
 	eva = roundup(eva, PAGE_SIZE);
 	npages = (eva - sva) / PAGE_SIZE;
-	KASSERT(sva >= KASAN_MD_SHADOW_START && eva < KASAN_MD_SHADOW_END);
+	KASSERT(sva >= KASAN_MD_SHADOW_START);
 	KASSERT(eva < KASAN_MD_SHADOW_END);
 	for (i = 0; i < npages; i++) {
 		kasan_md_shadow_map_page(sva + i * PAGE_SIZE);
+	}
+}
 static void
 kasan_ctors(void)
+{
 	extern Elf_Addr __CTOR_LIST__, __CTOR_END__;
 	size_t nentries, i;
 	Elf_Addr *ptr;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_pcu.c,v 1.27 2022/10/26 23:38:57 riastradh Exp $	*/
+/*	$NetBSD: subr_pcu.c,v 1.28 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2011, 2014 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Mindaugas Rasiukevicius.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -42,27 +42,27 @@
  *	for a PCU release can be from a) the owner LWP (regardless whether
  *	the PCU state is on the current CPU or remote CPU) b) any other LWP
  *	running on that CPU (in such case, the owner LWP is on a remote CPU
  *	or sleeping).
+ *
  *	In any case, the PCU state can *only* be changed from the current
  *	CPU.  If said PCU state is on the remote CPU, a cross-call will be
  *	sent by the owner LWP.  Therefore struct cpu_info::ci_pcu_curlwp[id]
  *	may only be changed by the current CPU and lwp_t::l_pcu_cpu[id] may
  *	only be cleared by the CPU which has the PCU state loaded.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_pcu.c,v 1.27 2022/10/26 23:38:57 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_pcu.c,v 1.28 2023/04/09 09:18:09 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/cpu.h>
 #include <sys/lwp.h>
 #include <sys/pcu.h>
 #include <sys/ipi.h>
 #if PCU_UNIT_COUNT > 0
 static inline void pcu_do_op(const pcu_ops_t *, lwp_t * const, const int);
 static void pcu_lwp_op(const pcu_ops_t *, lwp_t *, const int);
 /*
 @@ -298,27 +298,28 @@ pcu_lwp_op(const pcu_ops_t *pcu, lwp_t *
+}
 /*
  * pcu_load: load/initialize the PCU state of current LWP on current CPU.
  */
 void
 pcu_load(const pcu_ops_t *pcu)
+{
 	lwp_t *oncpu_lwp, * const l = curlwp;
 	const u_int id = pcu->pcu_id;
 	struct cpu_info *ci, *curci;
 	int s;
-	KASSERT(!cpu_intr_p() && !cpu_softintr_p());
+	KASSERT(!cpu_intr_p());
 	KASSERT(!cpu_softintr_p());
 	s = splpcu();
 	curci = curcpu();
 	ci = l->l_pcu_cpu[id];
 	/* Does this CPU already have our PCU state loaded? */
 	if (ci == curci) {
 		/*
 		 * Fault reoccurred while the PCU state is loaded and
 		 * therefore PCU should be re‐enabled.  This happens
 		 * if LWP is context switched to another CPU and then
 		 * switched back to the original CPU while the state
 		 * on that CPU has not been changed by other LWPs.
 @@ -368,48 +369,50 @@ pcu_load(const pcu_ops_t *pcu)
 	l->l_pcu_valid |= (1U << id);
 	splx(s);
+}
 /*
  * pcu_discard: discard the PCU state of the given LWP.  If "valid"
  * parameter is true, then keep considering the PCU state as valid.
  */
 void
 pcu_discard(const pcu_ops_t *pcu, lwp_t *l, bool valid)
+{
 	const u_int id = pcu->pcu_id;
-	KASSERT(!cpu_intr_p() && !cpu_softintr_p());
+	KASSERT(!cpu_intr_p());
 	KASSERT(!cpu_softintr_p());
 	if (__predict_false(valid)) {
 		l->l_pcu_valid |= (1U << id);
 	} else {
 		l->l_pcu_valid &= ~(1U << id);
+	}
 	if (__predict_true(l->l_pcu_cpu[id] == NULL)) {
 		return;
+	}
 	pcu_lwp_op(pcu, l, PCU_CMD_RELEASE);
+}
 /*
  * pcu_save_lwp: save PCU state to the given LWP.
  */
 void
 pcu_save(const pcu_ops_t *pcu, lwp_t *l)
+{
 	const u_int id = pcu->pcu_id;
-	KASSERT(!cpu_intr_p() && !cpu_softintr_p());
+	KASSERT(!cpu_intr_p());
 	KASSERT(!cpu_softintr_p());
 	if (__predict_true(l->l_pcu_cpu[id] == NULL)) {
 		return;
+	}
 	pcu_lwp_op(pcu, l, PCU_CMD_SAVE | PCU_CMD_RELEASE);
+}
 /*
  * pcu_save_all_on_cpu: save all PCU states on the current CPU.
  */
 void
 pcu_save_all_on_cpu(void)
+{

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_cpufreq.c,v 1.9 2014/02/12 20:20:15 martin Exp $ */
+/*	$NetBSD: subr_cpufreq.c,v 1.10 2023/04/09 09:18:09 riastradh Exp $ */
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jukka Ruohonen.
+ *
  * 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
 @@ -20,27 +20,27 @@
  * 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_cpufreq.c,v 1.9 2014/02/12 20:20:15 martin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_cpufreq.c,v 1.10 2023/04/09 09:18:09 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/cpu.h>
 #include <sys/cpufreq.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/mutex.h>
 #include <sys/time.h>
 #include <sys/xcall.h>
 static int	 cpufreq_latency(void);
 static uint32_t	 cpufreq_get_max(void);
 static uint32_t	 cpufreq_get_min(void);
 @@ -368,27 +368,28 @@ cpufreq_get_state_index(uint32_t index,
 	memcpy(cfs, &cf->cf_state[index], sizeof(*cfs));
 	mutex_exit(&cpufreq_lock);
 	return 0;
+}
 static void
 cpufreq_get_state_raw(uint32_t freq, struct cpufreq_state *cfs)
+{
 	struct cpufreq *cf = cf_backend;
 	uint32_t f, hi, i = 0, lo = 0;
 	KASSERT(mutex_owned(&cpufreq_lock) != 0);
-	KASSERT(cf->cf_init != false && cfs != NULL);
+	KASSERT(cf->cf_init != false);
 	KASSERT(cfs != NULL);
 	hi = cf->cf_state_count;
 	while (lo < hi) {
 		i = (lo + hi) >> 1;
 		f = cf->cf_state[i].cfs_freq;
 		if (freq == f)
 			break;
 		else if (freq > f)
 			hi = i;
 		else {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_kcpuset.c,v 1.14 2022/04/09 23:38:33 riastradh Exp $	*/
+/*	$NetBSD: subr_kcpuset.c,v 1.15 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Mindaugas Rasiukevicius.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -31,27 +31,27 @@
 /*
  * Kernel CPU set implementation.
+ *
  * Interface can be used by kernel subsystems as a unified dynamic CPU
  * bitset implementation handling many CPUs.  Facility also supports early
  * use by MD code on boot, as it fixups bitsets on further boot.
+ *
  * TODO:
  * - Handle "reverse" bitset on fixup/grow.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_kcpuset.c,v 1.14 2022/04/09 23:38:33 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_kcpuset.c,v 1.15 2023/04/09 09:18:09 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/atomic.h>
 #include <sys/sched.h>
 #include <sys/kcpuset.h>
 #include <sys/pool.h>
 /* Number of CPUs to support. */
 #define	KC_MAXCPUS		roundup2(MAXCPUS, 32)
 /*
 @@ -104,27 +104,28 @@ static kcpuset_t *		kcpuset_create_raw(b
 /*
  * kcpuset_sysinit: initialize the subsystem, transfer early boot cases
  * to dynamically allocated sets.
  */
 void
 kcpuset_sysinit(void)
+{
 	kcpuset_t *kc_dynamic[KC_SAVE_NITEMS], *kcp;
 	int i, s;
 	/* Set a kcpuset_t sizes. */
 	kc_nfields = (KC_MAXCPUS >> KC_SHIFT);
 	kc_bitsize = sizeof(uint32_t) * kc_nfields;
-	KASSERT(kc_nfields != 0 && kc_bitsize != 0);
+	KASSERT(kc_nfields != 0);
 	KASSERT(kc_bitsize != 0);
 	kc_cache = pool_cache_init(sizeof(kcpuset_impl_t) + kc_bitsize,
 	    coherency_unit, 0, 0, "kcpuset", NULL, IPL_NONE, NULL, NULL, NULL);
 	/* First, pre-allocate kcpuset entries. */
 	for (i = 0; i < kc_last_idx; i++) {
 		kcp = kcpuset_create_raw(true);
 		kc_dynamic[i] = kcp;
+	}
 	/*
 	 * Prepare to convert all early noted kcpuset uses to dynamic sets.
 	 * All processors, except the one we are currently running (primary),

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_pool.c,v 1.287 2023/02/24 11:02:27 riastradh Exp $	*/
+/*	$NetBSD: subr_pool.c,v 1.288 2023/04/09 09:18:09 riastradh Exp $	*/
 /*
  * Copyright (c) 1997, 1999, 2000, 2002, 2007, 2008, 2010, 2014, 2015, 2018,
  *     2020, 2021 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Paul Kranenburg; by Jason R. Thorpe of the Numerical Aerospace
  * Simulation Facility, NASA Ames Research Center; by Andrew Doran, and by
  * Maxime Villard.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 @@ -23,27 +23,27 @@
  * ``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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_pool.c,v 1.287 2023/02/24 11:02:27 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_pool.c,v 1.288 2023/04/09 09:18:09 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_ddb.h"
 #include "opt_lockdebug.h"
 #include "opt_pool.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/sysctl.h>
 #include <sys/bitops.h>
 #include <sys/proc.h>
 #include <sys/errno.h>
 @@ -1643,27 +1643,28 @@ pool_nput(struct pool *pp)
+ *
  * Must not be called from interrupt context.
  */
 int
 pool_reclaim(struct pool *pp)
+{
 	struct pool_item_header *ph, *phnext;
 	struct pool_pagelist pq;
 	struct pool_cache *pc;
 	uint32_t curtime;
 	bool klock;
 	int rv;
-	KASSERT(!cpu_intr_p() && !cpu_softintr_p());
+	KASSERT(!cpu_intr_p());
 	KASSERT(!cpu_softintr_p());
 	if (pp->pr_drain_hook != NULL) {
 		/*
 		 * The drain hook must be called with the pool unlocked.
 		 */
 		(*pp->pr_drain_hook)(pp->pr_drain_hook_arg, PR_NOWAIT);
+	}
 	/*
 	 * XXXSMP Because we do not want to cause non-MPSAFE code
 	 * to block.
 	 */
 	if (pp->pr_ipl == IPL_SOFTNET || pp->pr_ipl == IPL_SOFTCLOCK ||
 @@ -2397,27 +2398,28 @@ pool_cache_invalidate_groups(pool_cache_
  *	is an assumption that another level of synchronization is occurring
  *	between the input to the constructor and the cache invalidation.
+ *
  *	Invalidation is a costly process and should not be called from
  *	interrupt context.
  */
 void
 pool_cache_invalidate(pool_cache_t pc)
+{
 	uint64_t where;
 	pcg_t *pcg;
 	int n, s;
-	KASSERT(!cpu_intr_p() && !cpu_softintr_p());
+	KASSERT(!cpu_intr_p());
 	KASSERT(!cpu_softintr_p());
 	if (ncpu < 2 || !mp_online) {
 		/*
 		 * We might be called early enough in the boot process
 		 * for the CPU data structures to not be fully initialized.
 		 * In this case, transfer the content of the local CPU's
 		 * cache back into global cache as only this CPU is currently
 		 * running.
 		 */
 		pool_cache_transfer(pc);
 	} else {
 		/*
 		 * Signal all CPUs that they must transfer their local

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_prf.c,v 1.198 2023/02/07 09:25:51 macallan Exp $	*/
+/*	$NetBSD: subr_prf.c,v 1.199 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 1986, 1988, 1991, 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:
 @@ -27,27 +27,27 @@
  * 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.
+ *
  *	@(#)subr_prf.c	8.4 (Berkeley) 5/4/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_prf.c,v 1.198 2023/02/07 09:25:51 macallan Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_prf.c,v 1.199 2023/04/09 09:18:09 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_ddb.h"
 #include "opt_kgdb.h"
 #include "opt_dump.h"
 #include "opt_rnd_printf.h"
 #endif
 #include <sys/param.h>
 #include <sys/stdint.h>
 #include <sys/systm.h>
 #include <sys/buf.h>
 #include <sys/device.h>
 @@ -136,27 +136,28 @@ const char HEXDIGITS[] = "0123456789ABCD
 /*
  * functions
  */
 /*
  * Locking is inited fairly early in MI bootstrap.  Before that
  * prints are done unlocked.  But that doesn't really matter,
  * since nothing can preempt us before interrupts are enabled.
  */
 void
 kprintf_init(void)
+{
-	KASSERT(!kprintf_inited && cold); /* not foolproof, but ... */
+	KASSERT(!kprintf_inited); /* not foolproof, but ... */
 	KASSERT(cold);
 	mutex_init(&kprintf_mtx, MUTEX_DEFAULT, IPL_HIGH);
 #ifdef RND_PRINTF
 	rnd_attach_source(&rnd_printf_source, "printf", RND_TYPE_UNKNOWN,
 	    RND_FLAG_COLLECT_TIME|RND_FLAG_COLLECT_VALUE);
 #endif
 	kprintf_inited = true;
+}
 void
 kprintf_lock(void)
+{
 	if (__predict_true(kprintf_inited))

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_time.c,v 1.35 2022/06/28 02:04:51 riastradh Exp $	*/
+/*	$NetBSD: subr_time.c,v 1.36 2023/04/09 09:18:09 riastradh Exp $	*/
 /*
  * Copyright (c) 1982, 1986, 1989, 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.
 @@ -23,27 +23,27 @@
  * 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.
+ *
  *	@(#)kern_clock.c	8.5 (Berkeley) 1/21/94
  *	@(#)kern_time.c 8.4 (Berkeley) 5/26/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_time.c,v 1.35 2022/06/28 02:04:51 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_time.c,v 1.36 2023/04/09 09:18:09 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/kauth.h>
 #include <sys/lwp.h>
 #include <sys/timex.h>
 #include <sys/time.h>
 #include <sys/timetc.h>
 #include <sys/intr.h>
 #ifdef DEBUG_STICKS
 #define DPRINTF(a) uprintf a
 @@ -88,27 +88,28 @@ tvtohz(const struct timeval *tv)
 	 * ticks separately and add, using similar rounding methods and
 	 * overflow avoidance.  This method would work in the previous
 	 * case, but it is slightly slower and assumes that hz is integral.
+	 *
 	 * Otherwise, round the time difference down to the maximum
 	 * representable value.
+	 *
 	 * If ints are 32-bit, then the maximum value for any timeout in
 	 * 10ms ticks is 248 days.
 	 */
 	sec = tv->tv_sec;
 	usec = tv->tv_usec;
-	KASSERT(usec >= 0 && usec < 1000000);
+	KASSERT(usec >= 0);
 	KASSERT(usec < 1000000);
 	/* catch overflows in conversion time_t->int */
 	if (tv->tv_sec > INT_MAX)
 		return INT_MAX;
 	if (tv->tv_sec < 0)
 		return 0;
 	if (sec < 0 || (sec == 0 && usec == 0)) {
 		/*
 		 * Would expire now or in the past.  Return 0 ticks.
 		 * This is different from the legacy tvhzto() interface,
 		 * and callers need to check for it.
 		 */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_vmem.c,v 1.108 2022/05/31 08:43:16 andvar Exp $	*/
+/*	$NetBSD: subr_vmem.c,v 1.109 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c)2006,2007,2008,2009 YAMAMOTO Takashi,
  * 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.
 @@ -36,27 +36,27 @@
  * - 	A pool(9) is used for vmem boundary tags
  * - 	During a pool get call the global vmem_btag_refill_lock is taken,
  *	to serialize access to the allocation reserve, but no other
  *	vmem arena locks.
  * -	During pool_put calls no vmem mutexes are locked.
  * - 	pool_drain doesn't hold the pool's mutex while releasing memory to
  * 	its backing therefore no interference with any vmem mutexes.
  * -	The boundary tag pool is forced to put page headers into pool pages
  *  	(PR_PHINPAGE) and not off page to avoid pool recursion.
  *  	(due to sizeof(bt_t) it should be the case anyway)
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_vmem.c,v 1.108 2022/05/31 08:43:16 andvar Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_vmem.c,v 1.109 2023/04/09 09:18:09 riastradh Exp $");
 #if defined(_KERNEL) && defined(_KERNEL_OPT)
 #include "opt_ddb.h"
 #endif /* defined(_KERNEL) && defined(_KERNEL_OPT) */
 #include <sys/param.h>
 #include <sys/hash.h>
 #include <sys/queue.h>
 #include <sys/bitops.h>
 #if defined(_KERNEL)
 #include <sys/systm.h>
 #include <sys/kernel.h>	/* hz */
 @@ -381,50 +381,52 @@ bt_freetrim(vmem_t *vm, int freelimit)
  * freelist[2] ... [4, 7]
  * freelist[3] ... [8, 15]
  *  :
  * freelist[n] ... [(1 << n), (1 << (n + 1)) - 1]
  *  :
  */
 static struct vmem_freelist *
 bt_freehead_tofree(vmem_t *vm, vmem_size_t size)
+{
 	const vmem_size_t qsize = size >> vm->vm_quantum_shift;
 	const int idx = SIZE2ORDER(qsize);
-	KASSERT(size != 0 && qsize != 0);
+	KASSERT(size != 0);
 	KASSERT(qsize != 0);
 	KASSERT((size & vm->vm_quantum_mask) == 0);
 	KASSERT(idx >= 0);
 	KASSERT(idx < VMEM_MAXORDER);
 	return &vm->vm_freelist[idx];
+}
 /*
  * bt_freehead_toalloc: return the freelist for the given size and allocation
  * strategy.
+ *
  * for VM_INSTANTFIT, return the list in which any blocks are large enough
  * for the requested size.  otherwise, return the list which can have blocks
  * large enough for the requested size.
  */
 static struct vmem_freelist *
 bt_freehead_toalloc(vmem_t *vm, vmem_size_t size, vm_flag_t strat)
+{
 	const vmem_size_t qsize = size >> vm->vm_quantum_shift;
 	int idx = SIZE2ORDER(qsize);
-	KASSERT(size != 0 && qsize != 0);
+	KASSERT(size != 0);
 	KASSERT(qsize != 0);
 	KASSERT((size & vm->vm_quantum_mask) == 0);
 	if (strat == VM_INSTANTFIT && ORDER2SIZE(idx) != qsize) {
 		idx++;
 		/* check too large request? */
+	}
 	KASSERT(idx >= 0);
 	KASSERT(idx < VMEM_MAXORDER);
 	return &vm->vm_freelist[idx];
+}
 /* ---- boundary tag hash */
 @@ -1121,27 +1123,28 @@ vmem_xalloc(vmem_t *vm, const vmem_size_
 	int rc;
 	KASSERT(size0 > 0);
 	KASSERT(size > 0);
 	KASSERT(strat == VM_BESTFIT || strat == VM_INSTANTFIT);
 	if ((flags & VM_SLEEP) != 0) {
 		ASSERT_SLEEPABLE();
+	}
 	KASSERT((align & vm->vm_quantum_mask) == 0);
 	KASSERT((align & (align - 1)) == 0);
 	KASSERT((phase & vm->vm_quantum_mask) == 0);
 	KASSERT((nocross & vm->vm_quantum_mask) == 0);
 	KASSERT((nocross & (nocross - 1)) == 0);
-	KASSERT((align == 0 && phase == 0) || phase < align);
+	KASSERT(align == 0 || phase < align);
 	KASSERT(phase == 0 || phase < align);
 	KASSERT(nocross == 0 || nocross >= size);
 	KASSERT(minaddr <= maxaddr);
 	KASSERT(!VMEM_CROSS_P(phase, phase + size - 1, nocross));
 	if (align == 0) {
 		align = vm->vm_quantum_mask + 1;
+	}
 	/*
 	 * allocate boundary tags before acquiring the vmem lock.
 	 */
 	VMEM_LOCK(vm);
 	btnew = bt_alloc(vm, flags);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_xcall.c,v 1.34 2020/12/22 01:57:29 ad Exp $	*/
+/*	$NetBSD: subr_xcall.c,v 1.35 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2007-2010, 2019 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran and Mindaugas Rasiukevicius.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -64,27 +64,27 @@
  *	CPU, and so has exclusive access to the CPU.  Since this facility
  *	is heavyweight, it's expected that it will not be used often.
+ *
  *	Cross calls must not allocate memory, as the pagedaemon uses cross
  *	calls (and memory allocation may need to wait on the pagedaemon).
+ *
  *	A low-overhead mechanism for high priority calls (XC_HIGHPRI) is
  *	also provided.  The function to be executed runs in software
  *	interrupt context at IPL_SOFTSERIAL level, and is expected to
  *	be very lightweight, e.g. avoid blocking.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_xcall.c,v 1.34 2020/12/22 01:57:29 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_xcall.c,v 1.35 2023/04/09 09:18:09 riastradh Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/xcall.h>
 #include <sys/mutex.h>
 #include <sys/condvar.h>
 #include <sys/evcnt.h>
 #include <sys/kthread.h>
 #include <sys/cpu.h>
 #include <sys/atomic.h>
 #ifdef _RUMPKERNEL
 #include "rump_private.h"
 @@ -247,27 +247,28 @@ xc_init_cpu(struct cpu_info *ci)
 	    NULL, NULL, "xcall/%u", ci->ci_index);
 	KASSERT(error == 0);
+}
 /*
  * xc_broadcast:
+ *
  *	Trigger a call on all CPUs in the system.
  */
 uint64_t
 xc_broadcast(unsigned int flags, xcfunc_t func, void *arg1, void *arg2)
+{
-	KASSERT(!cpu_intr_p() && !cpu_softintr_p());
+	KASSERT(!cpu_intr_p());
 	KASSERT(!cpu_softintr_p());
 	ASSERT_SLEEPABLE();
 	if (__predict_false(!mp_online)) {
 		(*func)(arg1, arg2);
 		return 0;
+	}
 	if ((flags & XC_HIGHPRI) != 0) {
 		int ipl = xc_extract_ipl(flags);
 		return xc_highpri(func, arg1, arg2, NULL, ipl);
 	} else {
 		return xc_lowpri(func, arg1, arg2, NULL);
+	}
 @@ -296,27 +297,28 @@ xc_barrier(unsigned int flags)
 /*
  * xc_unicast:
+ *
  *	Trigger a call on one CPU.
  */
 uint64_t
 xc_unicast(unsigned int flags, xcfunc_t func, void *arg1, void *arg2,
 	   struct cpu_info *ci)
+{
 	int s;
 	KASSERT(ci != NULL);
-	KASSERT(!cpu_intr_p() && !cpu_softintr_p());
+	KASSERT(!cpu_intr_p());
 	KASSERT(!cpu_softintr_p());
 	ASSERT_SLEEPABLE();
 	if (__predict_false(!mp_online)) {
 		KASSERT(ci == curcpu());
 		s = splsoftserial();
 		(*func)(arg1, arg2);
 		splx(s);
 		return 0;
+	}
 	if ((flags & XC_HIGHPRI) != 0) {
 		int ipl = xc_extract_ipl(flags);
 		return xc_highpri(func, arg1, arg2, ci, ipl);
 @@ -325,27 +327,28 @@ xc_unicast(unsigned int flags, xcfunc_t
+	}
+}
 /*
  * xc_wait:
+ *
  *	Wait for a cross call to complete.
  */
 void
 xc_wait(uint64_t where)
+{
 	xc_state_t *xc;
-	KASSERT(!cpu_intr_p() && !cpu_softintr_p());
+	KASSERT(!cpu_intr_p());
 	KASSERT(!cpu_softintr_p());
 	ASSERT_SLEEPABLE();
 	if (__predict_false(!mp_online)) {
 		return;
+	}
 	/* Determine whether it is high or low priority cross-call. */
 	if ((where & XC_PRI_BIT) != 0) {
 		xc = &xc_high_pri;
 		where &= ~XC_PRI_BIT;
 	} else {
 		xc = &xc_low_pri;
+	}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sys_sched.c,v 1.49 2020/05/23 23:42:43 ad Exp $	*/
+/*	$NetBSD: sys_sched.c,v 1.50 2023/04/09 09:18:09 riastradh Exp $	*/
 /*
  * Copyright (c) 2008, 2011 Mindaugas Rasiukevicius <rmind at NetBSD org>
  * 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.
 @@ -31,27 +31,27 @@
+ *
  * Lock order:
+ *
  *	cpu_lock ->
  *	    proc_lock ->
  *		proc_t::p_lock ->
  *		    lwp_t::lwp_lock
+ *
  * TODO:
  *  - Handle pthread_setschedprio() as defined by POSIX;
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sys_sched.c,v 1.49 2020/05/23 23:42:43 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sys_sched.c,v 1.50 2023/04/09 09:18:09 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/cpu.h>
 #include <sys/kauth.h>
 #include <sys/kmem.h>
 #include <sys/lwp.h>
 #include <sys/mutex.h>
 #include <sys/proc.h>
 #include <sys/pset.h>
 #include <sys/sched.h>
 #include <sys/syscallargs.h>
 #include <sys/sysctl.h>
 @@ -63,27 +63,28 @@ static struct sysctllog *sched_sysctl_lo
 static kauth_listener_t sched_listener;
 /*
  * Convert user priority or the in-kernel priority or convert the current
  * priority to the appropriate range according to the policy change.
  */
 static pri_t
 convert_pri(lwp_t *l, int policy, pri_t pri)
+{
 	/* Convert user priority to the in-kernel */
 	if (pri != PRI_NONE) {
 		/* Only for real-time threads */
-		KASSERT(pri >= SCHED_PRI_MIN && pri <= SCHED_PRI_MAX);
+		KASSERT(pri >= SCHED_PRI_MIN);
 		KASSERT(pri <= SCHED_PRI_MAX);
 		KASSERT(policy != SCHED_OTHER);
 		return PRI_USER_RT + pri;
+	}
 	/* Neither policy, nor priority change */
 	if (l->l_class == policy)
 		return l->l_priority;
 	/* Time-sharing -> real-time */
 	if (l->l_class == SCHED_OTHER) {
 		KASSERT(policy == SCHED_FIFO || policy == SCHED_RR);
 		return PRI_USER_RT;
+	}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: vfs_cache.c,v 1.152 2021/11/01 21:28:03 andvar Exp $	*/
+/*	$NetBSD: vfs_cache.c,v 1.153 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2008, 2019, 2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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.
 @@ -162,27 +162,27 @@
+ *
  *	1) vi->vi_nc_lock	(tree or parent -> child direction,
  *				 used during forward lookup)
+ *
  *	2) vi->vi_nc_listlock	(list or child -> parent direction,
  *				 used during reverse lookup)
+ *
  *	3) cache_lru_lock	(LRU list direction, used during reclaim)
+ *
  *	4) vp->v_interlock	(what the cache entry points to)
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_cache.c,v 1.152 2021/11/01 21:28:03 andvar Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_cache.c,v 1.153 2023/04/09 09:18:09 riastradh Exp $");
 #define __NAMECACHE_PRIVATE
 #ifdef _KERNEL_OPT
 #include "opt_ddb.h"
 #include "opt_dtrace.h"
 #endif
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/atomic.h>
 #include <sys/callout.h>
 #include <sys/cpu.h>
 #include <sys/errno.h>
 @@ -690,27 +690,28 @@ cache_lookup_linked(struct vnode *dvp, c
+	}
 	/*
 	 * First up check if the user is allowed to look up files in this
 	 * directory.
 	 */
 	if (cred != FSCRED) {
 		if (dvi->vi_nc_mode == VNOVAL) {
 			if (newlock != NULL) {
 				rw_exit(newlock);
+			}
 			return false;
+		}
-		KASSERT(dvi->vi_nc_uid != VNOVAL && dvi->vi_nc_gid != VNOVAL);
+		KASSERT(dvi->vi_nc_uid != VNOVAL);
 		KASSERT(dvi->vi_nc_gid != VNOVAL);
 		error = kauth_authorize_vnode(cred,
 		    KAUTH_ACCESS_ACTION(VEXEC,
 		    dvp->v_type, dvi->vi_nc_mode & ALLPERMS), dvp, NULL,
 		    genfs_can_access(dvp, cred, dvi->vi_nc_uid, dvi->vi_nc_gid,
 		    dvi->vi_nc_mode & ALLPERMS, NULL, VEXEC));
 		if (error != 0) {
 			if (newlock != NULL) {
 				rw_exit(newlock);
+			}
 			COUNT(ncs_denied);
 			return false;
+		}
+	}
 @@ -720,27 +721,28 @@ cache_lookup_linked(struct vnode *dvp, c
 	 */
 	ncp = cache_lookup_entry(dvp, name, namelen, key);
 	if (__predict_false(ncp == NULL)) {
 		if (newlock != NULL) {
 			rw_exit(newlock);
+		}
 		COUNT(ncs_miss);
 		SDT_PROBE(vfs, namecache, lookup, miss, dvp,
 		    name, namelen, 0, 0);
 		return false;
+	}
 	if (ncp->nc_vp == NULL) {
 		/* found negative entry; vn is already null from above */
-		KASSERT(namelen != cache_mp_nlen && name != cache_mp_name);
+		KASSERT(namelen != cache_mp_nlen);
 		KASSERT(name != cache_mp_name);
 		COUNT(ncs_neghits);
 	} else {
 		COUNT(ncs_goodhits); /* XXX can be "badhits" */
+	}
 	SDT_PROBE(vfs, namecache, lookup, hit, dvp, name, namelen, 0, 0);
 	/*
 	 * Return with the directory lock still held.  It will either be
 	 * returned to us with another call to cache_lookup_linked() when
 	 * looking up the next component, or the caller will release it
 	 * manually when finished.
 	 */
 	if (oldlock) {
 @@ -786,27 +788,28 @@ cache_revlookup(struct vnode *vp, struct
 		/*
 		 * Check if the user is allowed to see.  NOTE: this is
 		 * checking for access on the "wrong" directory.  getcwd()
 		 * wants to see that there is access on every component
 		 * along the way, not that there is access to any individual
 		 * component.  Don't use this to check you can look in vp.
+		 *
 		 * I don't like it, I didn't come up with it, don't blame me!
 		 */
 		if (vi->vi_nc_mode == VNOVAL) {
 			rw_exit(&vi->vi_nc_listlock);
 			return -1;
+		}
-		KASSERT(vi->vi_nc_uid != VNOVAL && vi->vi_nc_gid != VNOVAL);
+		KASSERT(vi->vi_nc_uid != VNOVAL);
 		KASSERT(vi->vi_nc_gid != VNOVAL);
 		error = kauth_authorize_vnode(kauth_cred_get(),
 		    KAUTH_ACCESS_ACTION(VEXEC, vp->v_type, vi->vi_nc_mode &
 		    ALLPERMS), vp, NULL, genfs_can_access(vp, curlwp->l_cred,
 		    vi->vi_nc_uid, vi->vi_nc_gid, vi->vi_nc_mode & ALLPERMS,
 		    NULL, accmode));
 		    if (error != 0) {
 		    	rw_exit(&vi->vi_nc_listlock);
 			COUNT(ncs_denied);
 			return EACCES;
+		}
+	}
 	TAILQ_FOREACH(ncp, &vi->vi_nc_list, nc_list) {
 		KASSERT(ncp->nc_vp == vp);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: vfs_lookup.c,v 1.232 2022/08/22 09:14:59 hannken Exp $	*/
+/*	$NetBSD: vfs_lookup.c,v 1.233 2023/04/09 09:18:09 riastradh 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:
 @@ -27,27 +27,27 @@
  * 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.
+ *
  *	@(#)vfs_lookup.c	8.10 (Berkeley) 5/27/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_lookup.c,v 1.232 2022/08/22 09:14:59 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_lookup.c,v 1.233 2023/04/09 09:18:09 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_magiclinks.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/syslimits.h>
 #include <sys/time.h>
 #include <sys/namei.h>
 #include <sys/vnode.h>
 #include <sys/vnode_impl.h>
 @@ -1318,27 +1318,28 @@ lookup_fastforward(struct namei_state *s
+		}
 		/*
 		 * Good, now look for it in cache.  cache_lookup_linked()
 		 * will fail if there's nothing there, or if there's no
 		 * ownership info for the directory, or if the user doesn't
 		 * have permission to look up files in this directory.
 		 */
 		if (!cache_lookup_linked(searchdir, cnp->cn_nameptr,
 		    cnp->cn_namelen, &foundobj, &plock, cnp->cn_cred)) {
 			error = EOPNOTSUPP;
 			break;
+		}
-		KASSERT(plock != NULL && rw_lock_held(plock));
+		KASSERT(plock != NULL);
 		KASSERT(rw_lock_held(plock));
 		/*
 		 * Scored a hit.  Negative is good too (ENOENT).  If there's
 		 * a '-o union' mount here, punt and let lookup_once() deal
 		 * with it.
 		 */
 		if (foundobj == NULL) {
 			if ((searchdir->v_vflag & VV_ROOT) != 0 &&
 			    (searchdir->v_mount->mnt_flag & MNT_UNION) != 0) {
 			    	error = EOPNOTSUPP;
 			} else {
 				error = ENOENT;
 				terminal = ((cnp->cn_flags & ISLASTCN) != 0);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: vfs_syscalls.c,v 1.557 2023/03/05 14:40:32 riastradh Exp $	*/
+/*	$NetBSD: vfs_syscalls.c,v 1.558 2023/04/09 09:18:09 riastradh Exp $	*/
 /*-
  * Copyright (c) 2008, 2009, 2019, 2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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.
 @@ -60,27 +60,27 @@
  * 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.
+ *
  *	@(#)vfs_syscalls.c	8.42 (Berkeley) 7/31/95
  */
 /*
  * Virtual File System System Calls
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_syscalls.c,v 1.557 2023/03/05 14:40:32 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_syscalls.c,v 1.558 2023/04/09 09:18:09 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_fileassoc.h"
 #include "veriexec.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/filedesc.h>
 #include <sys/kernel.h>
 #include <sys/file.h>
 #include <sys/fcntl.h>
 @@ -1937,28 +1937,28 @@ vfs_composefh_alloc(struct vnode *vp, fh
 	mp = vp->v_mount;
 	fidsize = 0;
 	error = VFS_VPTOFH(vp, NULL, &fidsize);
 	KASSERT(error != 0);
 	if (error != E2BIG) {
 		goto out;
+	}
 	fhsize = FHANDLE_SIZE_FROM_FILEID_SIZE(fidsize);
 	fhp = kmem_zalloc(fhsize, KM_SLEEP);
 	fhp->fh_fsid = mp->mnt_stat.f_fsidx;
 	error = VFS_VPTOFH(vp, &fhp->fh_fid, &fidsize);
 	if (error == 0) {
-		KASSERT((FHANDLE_SIZE(fhp) == fhsize &&
+		KASSERT(FHANDLE_SIZE(fhp) == fhsize);
-		    FHANDLE_FILEID(fhp)->fid_len == fidsize));
+		KASSERT(FHANDLE_FILEID(fhp)->fid_len == fidsize);
 		*fhpp = fhp;
 	} else {
 		kmem_free(fhp, fhsize);
+	}
 out:
 	return error;
+}
 void
 vfs_composefh_free(fhandle_t *fhp)
+{
 	vfs__fhfree(fhp);
 @@ -4364,27 +4364,28 @@ do_sys_rename(const char *from, const ch
+}
 static int
 do_sys_renameat(struct lwp *l, int fromfd, const char *from, int tofd,
     const char *to, enum uio_seg seg, int retain)
+{
 	struct pathbuf *fpb, *tpb;
 	struct nameidata fnd, tnd;
 	struct vnode *fdvp, *fvp;
 	struct vnode *tdvp, *tvp;
 	struct mount *mp, *tmp;
 	int error;
-	KASSERT(l != NULL || (fromfd == AT_FDCWD && tofd == AT_FDCWD));
+	KASSERT(l != NULL || fromfd == AT_FDCWD);
 	KASSERT(l != NULL || tofd == AT_FDCWD);
 	error = pathbuf_maybe_copyin(from, seg, &fpb);
 	if (error)
 		goto out0;
 	KASSERT(fpb != NULL);
 	error = pathbuf_maybe_copyin(to, seg, &tpb);
 	if (error)
 		goto out1;
 	KASSERT(tpb != NULL);
 	/*
 	 * Lookup from.