 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_softint.c,v 1.74 2023/08/04 07:40:30 riastradh Exp $	*/
+/*	$NetBSD: kern_softint.c,v 1.75 2023/08/04 12:24:36 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.74 2023/08/04 07:40:30 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_softint.c,v 1.75 2023/08/04 12:24:36 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>
 @@ -478,28 +478,26 @@ softint_disestablish(void *arg)
  *	interrupt handler, or with preemption disabled (since we are
  *	using the value of curcpu()).
  */
 void
 softint_schedule(void *arg)
+{
 	softhand_t *sh;
 	softint_t *si;
 	uintptr_t offset;
 	int s;
 	SDT_PROBE2(sdt, kernel, softint, schedule,  arg, /*ci*/NULL);
 	KASSERT(!cold);
 	/*
 	 * 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;
 	KASSERT(offset != 0);
 	KASSERTMSG(offset < softint_bytes, "%"PRIuPTR" %u",
 	    offset, softint_bytes);
 	sh = (softhand_t *)((uint8_t *)curcpu()->ci_data.cpu_softcpu + offset);
 @@ -561,27 +559,26 @@ softint_schedule_cpu(void *arg, struct c
  *	Must be entered at splhigh.  Will drop the priority
  *	to the level specified, but returns back at splhigh.
  */
 static inline void
 softint_execute(lwp_t *l, int s)
+{
 	softint_t *si = l->l_private;
 	softhand_t *sh;
 	KASSERT(si->si_lwp == curlwp);
 	KASSERT(si->si_cpu == curcpu());
 	KASSERT(si->si_lwp->l_wchan == NULL);
 	KASSERT(si->si_active);
 	KASSERT(!cold);
 	/*
 	 * Note: due to priority inheritance we may have interrupted a
 	 * higher priority LWP.  Since the soft interrupt must be quick
 	 * and is non-preemptable, we don't bother yielding.
 	 */
 	while (!SIMPLEQ_EMPTY(&si->si_q)) {
 		/*
 		 * Pick the longest waiting handler to run.  We block
 		 * interrupts but do not lock in order to do this, as
 		 * we are protecting against the local CPU only.
 		 */
 @@ -714,28 +711,26 @@ softint_trigger(uintptr_t machdep)
 /*
  * softint_thread:
+ *
  *	Slow path: MI software interrupt dispatch.
  */
 void
 softint_thread(void *cookie)
+{
 	softint_t *si;
 	lwp_t *l;
 	int s;
 	KASSERT(!cold);
 	l = curlwp;
 	si = l->l_private;
 	for (;;) {
 		/* Clear pending status and run it. */
 		s = splhigh();
 		l->l_cpu->ci_data.cpu_softints &= ~si->si_machdep;
 		softint_execute(l, s);
 		splx(s);
 		/* Interrupts allowed to run again before switching. */
 		lwp_lock(l);
 		l->l_stat = LSIDL;
 @@ -795,28 +790,26 @@ softint_thread(void *cookie)
 /*
  * softint_dispatch:
+ *
  *	Fast path: entry point from machine-dependent code.
  */
 void
 softint_dispatch(lwp_t *pinned, int s)
+{
 	struct bintime now;
 	u_int timing;
 	lwp_t *l;
 	KASSERT(!cold);
 #ifdef DIAGNOSTIC
 	if ((pinned->l_pflag & LP_RUNNING) == 0 || curlwp->l_stat != LSIDL) {
 		struct lwp *onproc = curcpu()->ci_onproc;
 		int s2 = splhigh();
 		printf("curcpu=%d, spl=%d curspl=%d\n"
 			"onproc=%p => l_stat=%d l_flag=%08x l_cpu=%d\n"
 			"curlwp=%p => l_stat=%d l_flag=%08x l_cpu=%d\n"
 			"pinned=%p => l_stat=%d l_flag=%08x l_cpu=%d\n",
 			cpu_index(curcpu()), s, s2, onproc, onproc->l_stat,
 			onproc->l_flag, cpu_index(onproc->l_cpu), curlwp,
 			curlwp->l_stat, curlwp->l_flag,
 			cpu_index(curlwp->l_cpu), pinned, pinned->l_stat,
 			pinned->l_flag, cpu_index(pinned->l_cpu));