 @@ -1,1213 +1,1213 @@
-/*	$NetBSD: kern_exit.c,v 1.284 2020/02/22 21:07:46 ad Exp $	*/
+/*	$NetBSD: kern_exit.c,v 1.285 2020/03/08 15:05:18 ad Exp $	*/
 /*-
  * Copyright (c) 1998, 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1982, 1986, 1989, 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:
  * 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.
+ *
  *	@(#)kern_exit.c	8.10 (Berkeley) 2/23/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_exit.c,v 1.284 2020/02/22 21:07:46 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_exit.c,v 1.285 2020/03/08 15:05:18 ad Exp $");
 #include "opt_ktrace.h"
 #include "opt_dtrace.h"
 #include "opt_sysv.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/ioctl.h>
 #include <sys/tty.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/buf.h>
 #include <sys/wait.h>
 #include <sys/file.h>
 #include <sys/fstrans.h>
 #include <sys/vnode.h>
 #include <sys/syslog.h>
 #include <sys/pool.h>
 #include <sys/uidinfo.h>
 #include <sys/ptrace.h>
 #include <sys/acct.h>
 #include <sys/filedesc.h>
 #include <sys/ras.h>
 #include <sys/signalvar.h>
 #include <sys/sched.h>
 #include <sys/mount.h>
 #include <sys/syscallargs.h>
 #include <sys/kauth.h>
 #include <sys/sleepq.h>
 #include <sys/lock.h>
 #include <sys/lockdebug.h>
 #include <sys/ktrace.h>
 #include <sys/cpu.h>
 #include <sys/lwpctl.h>
 #include <sys/atomic.h>
 #include <sys/sdt.h>
 #include <sys/psref.h>
 #include <uvm/uvm_extern.h>
 #ifdef DEBUG_EXIT
 int debug_exit = 0;
 #define DPRINTF(x) if (debug_exit) printf x
 #else
 #define DPRINTF(x)
 #endif
 static int find_stopped_child(struct proc *, idtype_t, id_t, int,
     struct proc **, struct wrusage *, siginfo_t *);
 static void proc_free(struct proc *, struct wrusage *);
 /*
  * DTrace SDT provider definitions
  */
 SDT_PROVIDER_DECLARE(proc);
 SDT_PROBE_DEFINE1(proc, kernel, , exit, "int");
 /*
  * Fill in the appropriate signal information, and signal the parent.
  */
 /* XXX noclone works around a gcc 4.5 bug on arm */
 static void __noclone
 exit_psignal(struct proc *p, struct proc *pp, ksiginfo_t *ksi)
+{
 	KSI_INIT(ksi);
 	if ((ksi->ksi_signo = P_EXITSIG(p)) == SIGCHLD) {
 		if (p->p_xsig) {
 			if (p->p_sflag & PS_COREDUMP)
 				ksi->ksi_code = CLD_DUMPED;
 			else
 				ksi->ksi_code = CLD_KILLED;
 			ksi->ksi_status = p->p_xsig;
 		} else {
 			ksi->ksi_code = CLD_EXITED;
 			ksi->ksi_status = p->p_xexit;
+		}
 	} else {
 		ksi->ksi_code = SI_USER;
 		ksi->ksi_status = p->p_xsig;
+	}
 	/*
 	 * We fill those in, even for non-SIGCHLD.
 	 * It's safe to access p->p_cred unlocked here.
 	 */
 	ksi->ksi_pid = p->p_pid;
 	ksi->ksi_uid = kauth_cred_geteuid(p->p_cred);
 	/* XXX: is this still valid? */
 	ksi->ksi_utime = p->p_stats->p_ru.ru_utime.tv_sec;
 	ksi->ksi_stime = p->p_stats->p_ru.ru_stime.tv_sec;
+}
 /*
  * exit --
  *	Death of process.
  */
 int
 sys_exit(struct lwp *l, const struct sys_exit_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)	rval;
 	} */
 	struct proc *p = l->l_proc;
 	/* Don't call exit1() multiple times in the same process. */
 	mutex_enter(p->p_lock);
 	if (p->p_sflag & PS_WEXIT) {
 		mutex_exit(p->p_lock);
 		lwp_exit(l);
+	}
 	/* exit1() will release the mutex. */
 	exit1(l, SCARG(uap, rval), 0);
 	/* NOTREACHED */
 	return (0);
+}
 /*
  * Exit: deallocate address space and other resources, change proc state
  * to zombie, and unlink proc from allproc and parent's lists.  Save exit
  * status and rusage for wait().  Check for child processes and orphan them.
+ *
  * Must be called with p->p_lock held.  Does not return.
  */
 void
 exit1(struct lwp *l, int exitcode, int signo)
+{
 	struct proc	*p, *child, *next_child, *old_parent, *new_parent;
 	struct pgrp	*pgrp;
 	ksiginfo_t	ksi;
 	ksiginfoq_t	kq;
 	int		wakeinit;
 	struct lwp	*l2 __diagused;
 	p = l->l_proc;
 	/* XXX Temporary. */
 	kernel_lock_plug_leak();
 	/* Verify that we hold no locks other than p->p_lock. */
 	LOCKDEBUG_BARRIER(p->p_lock, 0);
 	KASSERTMSG(curcpu()->ci_biglock_count == 0, "kernel_lock leaked");
 	/* XXX Temporary: something is leaking kernel_lock. */
 	KERNEL_UNLOCK_ALL(l, NULL);
 	KASSERT(mutex_owned(p->p_lock));
 	KASSERT(p->p_vmspace != NULL);
 	if (__predict_false(p == initproc)) {
 		panic("init died (signal %d, exit %d)", signo, exitcode);
+	}
 	p->p_sflag |= PS_WEXIT;
 	/*
 	 * Force all other LWPs to exit before we do.  Only then can we
 	 * begin to tear down the rest of the process state.
 	 */
 	if (p->p_nlwps > 1) {
 		exit_lwps(l);
+	}
 	ksiginfo_queue_init(&kq);
 	/*
 	 * If we have been asked to stop on exit, do so now.
 	 */
 	if (__predict_false(p->p_sflag & PS_STOPEXIT)) {
 		KERNEL_UNLOCK_ALL(l, &l->l_biglocks);
 		sigclearall(p, &contsigmask, &kq);
 		if (!mutex_tryenter(proc_lock)) {
 			mutex_exit(p->p_lock);
 			mutex_enter(proc_lock);
 			mutex_enter(p->p_lock);
+		}
 		p->p_waited = 0;
 		p->p_pptr->p_nstopchild++;
 		p->p_stat = SSTOP;
 		mutex_exit(proc_lock);
 		lwp_lock(l);
 		p->p_nrlwps--;
 		l->l_stat = LSSTOP;
 		lwp_unlock(l);
 		mutex_exit(p->p_lock);
 		lwp_lock(l);
 		spc_lock(l->l_cpu);
 		mi_switch(l);
 		mutex_enter(p->p_lock);
+	}
 	/*
 	 * Bin any remaining signals and mark the process as dying so it will
 	 * not be found for, e.g. signals.
 	 */
 	sigfillset(&p->p_sigctx.ps_sigignore);
 	sigclearall(p, NULL, &kq);
 	p->p_stat = SDYING;
 	mutex_exit(p->p_lock);
 	ksiginfo_queue_drain(&kq);
 	/* Destroy any lwpctl info. */
 	if (p->p_lwpctl != NULL)
 		lwp_ctl_exit();
 	/*
 	 * Drain all remaining references that procfs, ptrace and others may
 	 * have on the process.
 	 */
 	rw_enter(&p->p_reflock, RW_WRITER);
 	DPRINTF(("%s: %d.%d exiting.\n", __func__, p->p_pid, l->l_lid));
 	timers_free(p, TIMERS_ALL);
 #if defined(__HAVE_RAS)
 	ras_purgeall();
 #endif
 	/*
 	 * Close open files, release open-file table and free signal
 	 * actions.  This may block!
 	 */
 	fd_free();
 	cwdfree(p->p_cwdi);
 	p->p_cwdi = NULL;
 	doexithooks(p);
 	sigactsfree(p->p_sigacts);
 	/*
 	 * Write out accounting data.
 	 */
 	(void)acct_process(l);
 #ifdef KTRACE
 	/*
 	 * Release trace file.
 	 */
 	if (p->p_tracep != NULL) {
 		mutex_enter(&ktrace_lock);
 		ktrderef(p);
 		mutex_exit(&ktrace_lock);
+	}
 #endif
 	p->p_xexit = exitcode;
 	p->p_xsig = signo;
 	/*
 	 * If emulation has process exit hook, call it now.
 	 * Set the exit status now so that the exit hook has
 	 * an opportunity to tweak it (COMPAT_LINUX requires
 	 * this for thread group emulation)
 	 */
 	if (p->p_emul->e_proc_exit)
 		(*p->p_emul->e_proc_exit)(p);
 	/*
 	 * Free the VM resources we're still holding on to.
 	 * We must do this from a valid thread because doing
 	 * so may block. This frees vmspace, which we don't
 	 * need anymore. The only remaining lwp is the one
 	 * we run at this moment, nothing runs in userland
 	 * anymore.
 	 */
 	ruspace(p);	/* Update our vm resource use */
 	uvm_proc_exit(p);
 	/*
 	 * Stop profiling.
 	 */
 	if (__predict_false((p->p_stflag & PST_PROFIL) != 0)) {
 		mutex_spin_enter(&p->p_stmutex);
 		stopprofclock(p);
 		mutex_spin_exit(&p->p_stmutex);
+	}
 	/*
 	 * If parent is waiting for us to exit or exec, PL_PPWAIT is set; we
 	 * wake up the parent early to avoid deadlock.  We can do this once
 	 * the VM resources are released.
 	 */
 	mutex_enter(proc_lock);
 	if (p->p_lflag & PL_PPWAIT) {
 		lwp_t *lp;
 		l->l_lwpctl = NULL; /* was on loan from blocked parent */
 		p->p_lflag &= ~PL_PPWAIT;
 		lp = p->p_vforklwp;
 		p->p_vforklwp = NULL;
 		lp->l_vforkwaiting = false;
 		cv_broadcast(&lp->l_waitcv);
+	}
 	if (SESS_LEADER(p)) {
 		struct vnode *vprele = NULL, *vprevoke = NULL;
 		struct session *sp = p->p_session;
 		struct tty *tp;
 		if (sp->s_ttyvp) {
 			/*
 			 * Controlling process.
 			 * Signal foreground pgrp,
 			 * drain controlling terminal
 			 * and revoke access to controlling terminal.
 			 */
 			tp = sp->s_ttyp;
 			mutex_spin_enter(&tty_lock);
 			if (tp->t_session == sp) {
 				/* we can't guarantee the revoke will do this */
 				pgrp = tp->t_pgrp;
 				tp->t_pgrp = NULL;
 				tp->t_session = NULL;
 				mutex_spin_exit(&tty_lock);
 				if (pgrp != NULL) {
 					pgsignal(pgrp, SIGHUP, 1);
+				}
 				mutex_exit(proc_lock);
 				(void) ttywait(tp);
 				mutex_enter(proc_lock);
 				/* The tty could have been revoked. */
 				vprevoke = sp->s_ttyvp;
 			} else
 				mutex_spin_exit(&tty_lock);
 			vprele = sp->s_ttyvp;
 			sp->s_ttyvp = NULL;
 			/*
 			 * s_ttyp is not zero'd; we use this to indicate
 			 * that the session once had a controlling terminal.
 			 * (for logging and informational purposes)
 			 */
+		}
 		sp->s_leader = NULL;
 		if (vprevoke != NULL || vprele != NULL) {
 			if (vprevoke != NULL) {
 				/* Releases proc_lock. */
 				proc_sessrele(sp);
 				VOP_REVOKE(vprevoke, REVOKEALL);
 			} else
 				mutex_exit(proc_lock);
 			if (vprele != NULL)
 				vrele(vprele);
 			mutex_enter(proc_lock);
+		}
+	}
 	fixjobc(p, p->p_pgrp, 0);
 	/* Release fstrans private data. */
 	fstrans_lwp_dtor(l);
 	/*
 	 * Finalize the last LWP's specificdata, as well as the
 	 * specificdata for the proc itself.
 	 */
 	lwp_finispecific(l);
 	proc_finispecific(p);
 	/*
 	 * Notify interested parties of our demise.
 	 */
 	KNOTE(&p->p_klist, NOTE_EXIT);
 	SDT_PROBE(proc, kernel, , exit,
 		((p->p_sflag & PS_COREDUMP) ? CLD_DUMPED :
 		 (p->p_xsig ? CLD_KILLED : CLD_EXITED)),
 ,0,0,0);
 	/*
 	 * Reset p_opptr pointer of all former children which got
 	 * traced by another process and were reparented. We reset
 	 * it to NULL here; the trace detach code then reparents
 	 * the child to initproc. We only check allproc list, since
 	 * eventual former children on zombproc list won't reference
 	 * p_opptr anymore.
 	 */
 	if (__predict_false(p->p_slflag & PSL_CHTRACED)) {
 		struct proc *q;
 		PROCLIST_FOREACH(q, &allproc) {
 			if (q->p_opptr == p)
 				q->p_opptr = NULL;
+		}
 		PROCLIST_FOREACH(q, &zombproc) {
 			if (q->p_opptr == p)
 				q->p_opptr = NULL;
+		}
+	}
 	/*
 	 * Give orphaned children to init(8).
 	 */
 	child = LIST_FIRST(&p->p_children);
 	wakeinit = (child != NULL);
 	for (; child != NULL; child = next_child) {
 		next_child = LIST_NEXT(child, p_sibling);
 		/*
 		 * Traced processes are killed since their existence
 		 * means someone is screwing up. Since we reset the
 		 * trace flags, the logic in sys_wait4() would not be
 		 * triggered to reparent the process to its
 		 * original parent, so we must do this here.
 		 */
 		if (__predict_false(child->p_slflag & PSL_TRACED)) {
 			mutex_enter(p->p_lock);
 			child->p_slflag &=
 			    ~(PSL_TRACED|PSL_SYSCALL);
 			mutex_exit(p->p_lock);
 			if (child->p_opptr != child->p_pptr) {
 				struct proc *t = child->p_opptr;
 				proc_reparent(child, t ? t : initproc);
 				child->p_opptr = NULL;
 			} else
 				proc_reparent(child, initproc);
 			killproc(child, "orphaned traced process");
 		} else
 			proc_reparent(child, initproc);
+	}
 	/*
 	 * Move proc from allproc to zombproc, it's now nearly ready to be
 	 * collected by parent.
 	 */
 	LIST_REMOVE(l, l_list);
 	LIST_REMOVE(p, p_list);
 	LIST_INSERT_HEAD(&zombproc, p, p_list);
 	/*
 	 * Mark the process as dead.  We must do this before we signal
 	 * the parent.
 	 */
 	p->p_stat = SDEAD;
 	/* Put in front of parent's sibling list for parent to collect it */
 	old_parent = p->p_pptr;
 	old_parent->p_nstopchild++;
 	if (LIST_FIRST(&old_parent->p_children) != p) {
 		/* Put child where it can be found quickly */
 		LIST_REMOVE(p, p_sibling);
 		LIST_INSERT_HEAD(&old_parent->p_children, p, p_sibling);
+	}
 	/*
 	 * Notify parent that we're gone.  If parent has the P_NOCLDWAIT
 	 * flag set, notify init instead (and hope it will handle
 	 * this situation).
 	 */
 	if (old_parent->p_flag & (PK_NOCLDWAIT|PK_CLDSIGIGN)) {
 		proc_reparent(p, initproc);
 		wakeinit = 1;
 		/*
 		 * If this was the last child of our parent, notify
 		 * parent, so in case he was wait(2)ing, he will
 		 * continue.
 		 */
 		if (LIST_FIRST(&old_parent->p_children) == NULL)
 			cv_broadcast(&old_parent->p_waitcv);
+	}
 	/* Reload parent pointer, since p may have been reparented above */
 	new_parent = p->p_pptr;
 	if (__predict_false(p->p_exitsig != 0)) {
 		exit_psignal(p, new_parent, &ksi);
 		kpsignal(new_parent, &ksi, NULL);
+	}
 	/* Calculate the final rusage info.  */
 	calcru(p, &p->p_stats->p_ru.ru_utime, &p->p_stats->p_ru.ru_stime,
 	    NULL, NULL);
 	if (wakeinit)
 		cv_broadcast(&initproc->p_waitcv);
 	callout_destroy(&l->l_timeout_ch);
 	/*
 	 * Release any PCU resources before becoming a zombie.
 	 */
 	pcu_discard_all(l);
 	mutex_enter(p->p_lock);
 	/* Don't bother with p_treelock as no other LWPs remain. */
 	l2 = radix_tree_remove_node(&p->p_lwptree, (uint64_t)(l->l_lid - 1));
 	KASSERT(l2 == l);
 	KASSERT(radix_tree_empty_tree_p(&p->p_lwptree));
 	radix_tree_fini_tree(&p->p_lwptree);
 	/* Free the linux lwp id */
 	if ((l->l_pflag & LP_PIDLID) != 0 && l->l_lid != p->p_pid)
 		proc_free_pid(l->l_lid);
 	lwp_drainrefs(l);
 	lwp_lock(l);
 	l->l_prflag &= ~LPR_DETACHED;
 	l->l_stat = LSZOMB;
 	lwp_unlock(l);
 	KASSERT(curlwp == l);
 	KASSERT(p->p_nrlwps == 1);
 	KASSERT(p->p_nlwps == 1);
 	p->p_stat = SZOMB;
 	p->p_nrlwps--;
 	p->p_nzlwps++;
 	p->p_ndlwps = 0;
 	mutex_exit(p->p_lock);
 	/*
 	 * Signal the parent to collect us, and drop the proclist lock.
 	 * Drop debugger/procfs lock; no new references can be gained.
 	 */
 	cv_broadcast(&p->p_pptr->p_waitcv);
 	rw_exit(&p->p_reflock);
 	mutex_exit(proc_lock);
 	/*
 	 * NOTE: WE ARE NO LONGER ALLOWED TO SLEEP!
 	 */
 	/*
 	 * Give machine-dependent code a chance to free any MD LWP
 	 * resources.  This must be done before uvm_lwp_exit(), in
 	 * case these resources are in the PCB.
 	 */
 	cpu_lwp_free(l, 1);
 	/* Switch away into oblivion. */
 	lwp_lock(l);
 	spc_lock(l->l_cpu);
 	mi_switch(l);
 	panic("exit1");
+}
 void
 exit_lwps(struct lwp *l)
+{
 	proc_t *p = l->l_proc;
 	lwp_t *l2;
 retry:
 	KASSERT(mutex_owned(p->p_lock));
 	/*
 	 * Interrupt LWPs in interruptable sleep, unsuspend suspended
 	 * LWPs and then wait for everyone else to finish.
 	 */
 	LIST_FOREACH(l2, &p->p_lwps, l_sibling) {
 		if (l2 == l)
 			continue;
 		lwp_lock(l2);
 		l2->l_flag |= LW_WEXIT;
 		if ((l2->l_stat == LSSLEEP && (l2->l_flag & LW_SINTR)) ||
 		    l2->l_stat == LSSUSPENDED || l2->l_stat == LSSTOP) {
 			l2->l_flag &= ~LW_DBGSUSPEND;
 		    	/* setrunnable() will release the lock. */
 			setrunnable(l2);
 			continue;
+		}
 		lwp_need_userret(l2);
 		lwp_unlock(l2);
+	}
 	/*
 	 * Wait for every LWP to exit.  Note: LWPs can get suspended/slept
 	 * behind us or there may even be new LWPs created.  Therefore, a
 	 * full retry is required on error.
 	 */
 	while (p->p_nlwps > 1) {
 		if (lwp_wait(l, 0, NULL, true)) {
 			goto retry;
+		}
+	}
 	KASSERT(p->p_nlwps == 1);
+}
 int
 do_sys_waitid(idtype_t idtype, id_t id, int *pid, int *status, int options,
     struct wrusage *wru, siginfo_t *si)
+{
 	proc_t *child;
 	int error;
 	if (wru != NULL)
 		memset(wru, 0, sizeof(*wru));
 	if (si != NULL)
 		memset(si, 0, sizeof(*si));
 	mutex_enter(proc_lock);
 	error = find_stopped_child(curproc, idtype, id, options, &child,
 	    wru, si);
 	if (child == NULL) {
 		mutex_exit(proc_lock);
 		*pid = 0;
 		*status = 0;
 		return error;
+	}
 	*pid = child->p_pid;
 	if (child->p_stat == SZOMB) {
 		/* Child is exiting */
 		*status = P_WAITSTATUS(child);
 		/* proc_free() will release the proc_lock. */
 		if (options & WNOWAIT) {
 			mutex_exit(proc_lock);
 		} else {
 			proc_free(child, wru);
+		}
 	} else {
 		/* Don't mark SIGCONT if we are being stopped */
 		*status = (child->p_xsig == SIGCONT && child->p_stat != SSTOP) ?
 		    W_CONTCODE() : W_STOPCODE(child->p_xsig);
 		mutex_exit(proc_lock);
+	}
 	return 0;
+}
 int
 do_sys_wait(int *pid, int *status, int options, struct rusage *ru)
+{
 	idtype_t idtype;
 	id_t id;
 	int ret;
 	struct wrusage wru;
 	/*
 	 * Translate the special pid values into the (idtype, pid)
 	 * pair for wait6. The WAIT_MYPGRP case is handled by
 	 * find_stopped_child() on its own.
 	 */
 	if (*pid == WAIT_ANY) {
 		idtype = P_ALL;
 		id = 0;
 	} else if (*pid < 0) {
 		idtype = P_PGID;
 		id = (id_t)-*pid;
 	} else {
 		idtype = P_PID;
 		id = (id_t)*pid;
+	}
 	options |= WEXITED | WTRAPPED;
 	ret = do_sys_waitid(idtype, id, pid, status, options, ru ? &wru : NULL,
 	    NULL);
 	if (ru)
 		*ru = wru.wru_self;
 	return ret;
+}
 int
 sys___wait450(struct lwp *l, const struct sys___wait450_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(int)			pid;
 		syscallarg(int *)		status;
 		syscallarg(int)			options;
 		syscallarg(struct rusage *)	rusage;
 	} */
 	int error, status, pid = SCARG(uap, pid);
 	struct rusage ru;
 	error = do_sys_wait(&pid, &status, SCARG(uap, options),
 	    SCARG(uap, rusage) != NULL ? &ru : NULL);
 	retval[0] = pid;
 	if (pid == 0) {
 		return error;
+	}
 	if (SCARG(uap, status)) {
 		error = copyout(&status, SCARG(uap, status), sizeof(status));
+	}
 	if (SCARG(uap, rusage) && error == 0) {
 		error = copyout(&ru, SCARG(uap, rusage), sizeof(ru));
+	}
 	return error;
+}
 int
 sys_wait6(struct lwp *l, const struct sys_wait6_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(idtype_t)		idtype;
 		syscallarg(id_t)		id;
 		syscallarg(int *)		status;
 		syscallarg(int)			options;
 		syscallarg(struct wrusage *)	wru;
 		syscallarg(siginfo_t *)		si;
 	} */
 	struct wrusage wru, *wrup;
 	siginfo_t si, *sip;
 	idtype_t idtype;
 	int pid;
 	id_t id;
 	int error, status;
 	idtype = SCARG(uap, idtype);
 	id = SCARG(uap, id);
 	if (SCARG(uap, wru) != NULL)
 		wrup = &wru;
 	else
 		wrup = NULL;
 	if (SCARG(uap, info) != NULL)
 		sip = &si;
 	else
 		sip = NULL;
 	/*
 	 *  We expect all callers of wait6() to know about WEXITED and
 	 *  WTRAPPED.
 	 */
 	error = do_sys_waitid(idtype, id, &pid, &status, SCARG(uap, options),
 	    wrup, sip);
 	retval[0] = pid; 	/* tell userland who it was */
 #if 0
 	/*
 	 * should we copyout if there was no process, hence no useful data?
 	 * We don't for an old sytle wait4() (etc) but I believe
 	 * FreeBSD does for wait6(), so a tossup...  Go with FreeBSD for now.
 	 */
 	if (pid == 0)
 		return error;
 #endif
 	if (SCARG(uap, status) != NULL && error == 0)
 		error = copyout(&status, SCARG(uap, status), sizeof(status));
 	if (SCARG(uap, wru) != NULL && error == 0)
 		error = copyout(&wru, SCARG(uap, wru), sizeof(wru));
 	if (SCARG(uap, info) != NULL && error == 0)
 		error = copyout(&si, SCARG(uap, info), sizeof(si));
 	return error;
+}
 /*
  * Find a process that matches the provided criteria, and fill siginfo
  * and resources if found.
  * Returns:
  *	-1: 	Not found, abort early
  *	 0:	Not matched
  *	 1:	Matched, there might be more matches
  *	 2:	This is the only match
  */
 static int
 match_process(const struct proc *pp, struct proc **q, idtype_t idtype, id_t id,
     int options, struct wrusage *wrusage, siginfo_t *siginfo)
+{
 	struct rusage *rup;
 	struct proc *p = *q;
 	int rv = 1;
 	mutex_enter(p->p_lock);
 	switch (idtype) {
 	case P_ALL:
 		break;
 	case P_PID:
 		if (p->p_pid != (pid_t)id) {
 			mutex_exit(p->p_lock);
 			p = *q = proc_find_raw((pid_t)id);
 			if (p == NULL || p->p_stat == SIDL || p->p_pptr != pp) {
 				*q = NULL;
 				return -1;
+			}
 			mutex_enter(p->p_lock);
+		}
 		rv++;
 		break;
 	case P_PGID:
 		if (p->p_pgid != (pid_t)id)
 			goto out;
 		break;
 	case P_SID:
 		if (p->p_session->s_sid != (pid_t)id)
 			goto out;
 		break;
 	case P_UID:
 		if (kauth_cred_geteuid(p->p_cred) != (uid_t)id)
 			goto out;
 		break;
 	case P_GID:
 		if (kauth_cred_getegid(p->p_cred) != (gid_t)id)
 			goto out;
 		break;
 	case P_CID:
 	case P_PSETID:
 	case P_CPUID:
 		/* XXX: Implement me */
 	default:
 	out:
 		mutex_exit(p->p_lock);
 		return 0;
+	}
 	if ((options & WEXITED) == 0 && p->p_stat == SZOMB)
 		goto out;
 	if (siginfo != NULL) {
 		siginfo->si_errno = 0;
 		/*
 		 * SUSv4 requires that the si_signo value is always
 		 * SIGCHLD. Obey it despite the rfork(2) interface
 		 * allows to request other signal for child exit
 		 * notification.
 		 */
 		siginfo->si_signo = SIGCHLD;
 		/*
 		 *  This is still a rough estimate.  We will fix the
 		 *  cases TRAPPED, STOPPED, and CONTINUED later.
 		 */
 		if (p->p_sflag & PS_COREDUMP) {
 			siginfo->si_code = CLD_DUMPED;
 			siginfo->si_status = p->p_xsig;
 		} else if (p->p_xsig) {
 			siginfo->si_code = CLD_KILLED;
 			siginfo->si_status = p->p_xsig;
 		} else {
 			siginfo->si_code = CLD_EXITED;
 			siginfo->si_status = p->p_xexit;
+		}
 		siginfo->si_pid = p->p_pid;
 		siginfo->si_uid = kauth_cred_geteuid(p->p_cred);
 		siginfo->si_utime = p->p_stats->p_ru.ru_utime.tv_sec;
 		siginfo->si_stime = p->p_stats->p_ru.ru_stime.tv_sec;
+	}
 	/*
 	 * There should be no reason to limit resources usage info to
 	 * exited processes only.  A snapshot about any resources used
 	 * by a stopped process may be exactly what is needed.
 	 */
 	if (wrusage != NULL) {
 		rup = &wrusage->wru_self;
 		*rup = p->p_stats->p_ru;
 		calcru(p, &rup->ru_utime, &rup->ru_stime, NULL, NULL);
 		rup = &wrusage->wru_children;
 		*rup = p->p_stats->p_cru;
 		calcru(p, &rup->ru_utime, &rup->ru_stime, NULL, NULL);
+	}
 	mutex_exit(p->p_lock);
 	return rv;
+}
 /*
  * Determine if there are existing processes being debugged
  * that used to be (and sometime later will be again) children
  * of a specific parent (while matching wait criteria)
  */
 static bool
 debugged_child_exists(idtype_t idtype, id_t id, int options, siginfo_t *si,
     const struct proc *parent)
+{
 	struct proc *pp;
 	/*
 	 * If we are searching for a specific pid, we can optimise a little
 	 */
 	if (idtype == P_PID) {
 		/*
 		 * Check the specific process to see if its real parent is us
 		 */
 		pp = proc_find_raw((pid_t)id);
 		if (pp != NULL && pp->p_stat != SIDL && pp->p_opptr == parent) {
 			/*
 			 * using P_ALL here avoids match_process() doing the
 			 * same work that we just did, but incorrectly for
 			 * this scenario.
 			 */
 			if (match_process(parent, &pp, P_ALL, id, options,
 			    NULL, si))
 				return true;
+		}
 		return false;
+	}
 	/*
 	 * For the hard cases, just look everywhere to see if some
 	 * stolen (reparented) process is really our lost child.
 	 * Then check if that process could satisfy the wait conditions.
 	 */
 	/*
 	 * XXX inefficient, but hopefully fairly rare.
 	 * XXX should really use a list of reparented processes.
 	 */
 	PROCLIST_FOREACH(pp, &allproc) {
 		if (pp->p_stat == SIDL)		/* XXX impossible ?? */
 			continue;
 		if (pp->p_opptr == parent &&
 		    match_process(parent, &pp, idtype, id, options, NULL, si))
 			return true;
+	}
 	PROCLIST_FOREACH(pp, &zombproc) {
 		if (pp->p_stat == SIDL)		/* XXX impossible ?? */
 			continue;
 		if (pp->p_opptr == parent &&
 		    match_process(parent, &pp, idtype, id, options, NULL, si))
 			return true;
+	}
 	return false;
+}
 /*
  * Scan list of child processes for a child process that has stopped or
  * exited.  Used by sys_wait4 and 'compat' equivalents.
+ *
  * Must be called with the proc_lock held, and may release while waiting.
  */
 static int
 find_stopped_child(struct proc *parent, idtype_t idtype, id_t id, int options,
     struct proc **child_p, struct wrusage *wru, siginfo_t *si)
+{
 	struct proc *child, *dead;
 	int error;
 	KASSERT(mutex_owned(proc_lock));
 	if (options & ~WALLOPTS) {
 		*child_p = NULL;
 		return EINVAL;
+	}
 	if ((options & WSELECTOPTS) == 0) {
 		/*
 		 * We will be unable to find any matching processes,
 		 * because there are no known events to look for.
 		 * Prefer to return error instead of blocking
 		 * indefinitely.
 		 */
 		*child_p = NULL;
 		return EINVAL;
+	}
 	if ((pid_t)id == WAIT_MYPGRP && (idtype == P_PID || idtype == P_PGID)) {
 		mutex_enter(parent->p_lock);
 		id = (id_t)parent->p_pgid;
 		mutex_exit(parent->p_lock);
 		idtype = P_PGID;
+	}
 	for (;;) {
 		error = ECHILD;
 		dead = NULL;
 		LIST_FOREACH(child, &parent->p_children, p_sibling) {
 			int rv = match_process(parent, &child, idtype, id,
 			    options, wru, si);
 			if (rv == -1)
 				break;
 			if (rv == 0)
 				continue;
 			/*
 			 * Wait for processes with p_exitsig != SIGCHLD
 			 * processes only if WALTSIG is set; wait for
 			 * processes with p_exitsig == SIGCHLD only
 			 * if WALTSIG is clear.
 			 */
 			if (((options & WALLSIG) == 0) &&
 			    (options & WALTSIG ? child->p_exitsig == SIGCHLD
 						: P_EXITSIG(child) != SIGCHLD)){
 				if (rv == 2) {
 					child = NULL;
 					break;
+				}
 				continue;
+			}
 			error = 0;
 			if ((options & WNOZOMBIE) == 0) {
 				if (child->p_stat == SZOMB)
 					break;
 				if (child->p_stat == SDEAD) {
 					/*
 					 * We may occasionally arrive here
 					 * after receiving a signal, but
 					 * immediately before the child
 					 * process is zombified.  The wait
 					 * will be short, so avoid returning
 					 * to userspace.
 					 */
 					dead = child;
+				}
+			}
 			if ((options & WCONTINUED) != 0 &&
 			    child->p_xsig == SIGCONT &&
 			    (child->p_sflag & PS_CONTINUED)) {
 				if ((options & WNOWAIT) == 0) {
 					child->p_sflag &= ~PS_CONTINUED;
 					child->p_waited = 1;
 					parent->p_nstopchild--;
+				}
 				if (si) {
 					si->si_status = child->p_xsig;
 					si->si_code = CLD_CONTINUED;
+				}
 				break;
+			}
 			if ((options & (WTRAPPED|WSTOPPED)) != 0 &&
 			    child->p_stat == SSTOP &&
 			    child->p_waited == 0 &&
 			    ((child->p_slflag & PSL_TRACED) ||
 			    options & (WUNTRACED|WSTOPPED))) {
 				if ((options & WNOWAIT) == 0) {
 					child->p_waited = 1;
 					parent->p_nstopchild--;
+				}
 				if (si) {
 					si->si_status = child->p_xsig;
 					si->si_code =
 					    (child->p_slflag & PSL_TRACED) ?
 					    CLD_TRAPPED : CLD_STOPPED;
+				}
 				break;
+			}
 			if (parent->p_nstopchild == 0 || rv == 2) {
 				child = NULL;
 				break;
+			}
+		}
 		/*
 		 * If we found nothing, but we are the bereaved parent
 		 * of a stolen child, look and see if that child (or
 		 * one of them) meets our search criteria.   If so, then
 		 * we cannot succeed, but we can hang (wait...),
 		 * or if WNOHANG, return 0 instead of ECHILD
 		 */
 		if (child == NULL && error == ECHILD &&
 		    (parent->p_slflag & PSL_CHTRACED) &&
 		    debugged_child_exists(idtype, id, options, si, parent))
 			error = 0;
 		if (child != NULL || error != 0 ||
 		    ((options & WNOHANG) != 0 && dead == NULL)) {
 			*child_p = child;
 			return error;
+		}
 		/*
 		 * Wait for another child process to stop.
 		 */
 		error = cv_wait_sig(&parent->p_waitcv, proc_lock);
 		if (error != 0) {
 			*child_p = NULL;
 			return error;
+		}
+	}
+}
 /*
  * Free a process after parent has taken all the state info.  Must be called
  * with the proclist lock held, and will release before returning.
+ *
  * *ru is returned to the caller, and must be freed by the caller.
  */
 static void
 proc_free(struct proc *p, struct wrusage *wru)
+{
 	struct proc *parent = p->p_pptr;
 	struct lwp *l;
 	ksiginfo_t ksi;
 	kauth_cred_t cred1, cred2;
 	uid_t uid;
 	KASSERT(mutex_owned(proc_lock));
 	KASSERT(p->p_nlwps == 1);
 	KASSERT(p->p_nzlwps == 1);
 	KASSERT(p->p_nrlwps == 0);
 	KASSERT(p->p_stat == SZOMB);
 	/*
 	 * If we got the child via ptrace(2) or procfs, and
 	 * the parent is different (meaning the process was
 	 * attached, rather than run as a child), then we need
 	 * to give it back to the old parent, and send the
 	 * parent the exit signal.  The rest of the cleanup
 	 * will be done when the old parent waits on the child.
 	 */
 	if ((p->p_slflag & PSL_TRACED) != 0 && p->p_opptr != parent) {
 		mutex_enter(p->p_lock);
 		p->p_slflag &= ~(PSL_TRACED|PSL_SYSCALL);
 		mutex_exit(p->p_lock);
 		parent = (p->p_opptr == NULL) ? initproc : p->p_opptr;
 		proc_reparent(p, parent);
 		p->p_opptr = NULL;
 		if (p->p_exitsig != 0) {
 			exit_psignal(p, parent, &ksi);
 			kpsignal(parent, &ksi, NULL);
+		}
 		cv_broadcast(&parent->p_waitcv);
 		mutex_exit(proc_lock);
 		return;
+	}
 	sched_proc_exit(parent, p);
 	/*
 	 * Add child times of exiting process onto its own times.
 	 * This cannot be done any earlier else it might get done twice.
 	 */
 	l = LIST_FIRST(&p->p_lwps);
 	p->p_stats->p_ru.ru_nvcsw += (l->l_ncsw - l->l_nivcsw);
 	p->p_stats->p_ru.ru_nivcsw += l->l_nivcsw;
 	ruadd(&p->p_stats->p_ru, &l->l_ru);
 	ruadd(&p->p_stats->p_ru, &p->p_stats->p_cru);
 	ruadd(&parent->p_stats->p_cru, &p->p_stats->p_ru);
 	if (wru != NULL) {
 		wru->wru_self = p->p_stats->p_ru;
 		wru->wru_children = p->p_stats->p_cru;
+	}
 	p->p_xsig = 0;
 	p->p_xexit = 0;
 	/*
 	 * At this point we are going to start freeing the final resources.
 	 * If anyone tries to access the proc structure after here they will
 	 * get a shock - bits are missing.  Attempt to make it hard!  We
 	 * don't bother with any further locking past this point.
 	 */
 	p->p_stat = SIDL;		/* not even a zombie any more */
 	LIST_REMOVE(p, p_list);	/* off zombproc */
 	parent->p_nstopchild--;
 	LIST_REMOVE(p, p_sibling);
 	/*
 	 * Let pid be reallocated.
 	 */
 	proc_free_pid(p->p_pid);
 	/*
 	 * Unlink process from its process group.
 	 * Releases the proc_lock.

 @@ -1,365 +1,345 @@
-/*	$NetBSD: kern_lock.c,v 1.169 2020/02/10 22:11:09 christos Exp $	*/
+/*	$NetBSD: kern_lock.c,v 1.170 2020/03/08 15:05:18 ad Exp $	*/
 /*-
  * Copyright (c) 2002, 2006, 2007, 2008, 2009, 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_lock.c,v 1.169 2020/02/10 22:11:09 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_lock.c,v 1.170 2020/03/08 15:05:18 ad Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_lockdebug.h"
 #endif
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/lock.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/lockdebug.h>
 #include <sys/cpu.h>
 #include <sys/syslog.h>
 #include <sys/atomic.h>
 #include <sys/lwp.h>
 #include <sys/pserialize.h>
 #if defined(DIAGNOSTIC) && !defined(LOCKDEBUG)
 #include <sys/ksyms.h>
 #endif
 #include <machine/lock.h>
 #include <dev/lockstat.h>
 #define	RETURN_ADDRESS	(uintptr_t)__builtin_return_address(0)
 bool	kernel_lock_dodebug;
 __cpu_simple_lock_t kernel_lock[CACHE_LINE_SIZE / sizeof(__cpu_simple_lock_t)]
     __cacheline_aligned;
 void
 assert_sleepable(void)
+{
 	const char *reason;
 	uint64_t pctr;
 	bool idle;
 	if (panicstr != NULL) {
 		return;
+	}
 	LOCKDEBUG_BARRIER(kernel_lock, 1);
 	/*
 	 * Avoid disabling/re-enabling preemption here since this
 	 * routine may be called in delicate situations.
 	 */
 	do {
 		pctr = lwp_pctr();
 		__insn_barrier();
 		idle = CURCPU_IDLE_P();
 		__insn_barrier();
 	} while (pctr != lwp_pctr());
 	reason = NULL;
 	if (idle && !cold &&
 	    kcpuset_isset(kcpuset_running, cpu_index(curcpu()))) {
 		reason = "idle";
+	}
 	if (cpu_intr_p()) {
 		reason = "interrupt";
+	}
 	if (cpu_softintr_p()) {
 		reason = "softint";
+	}
 	if (!pserialize_not_in_read_section()) {
 		reason = "pserialize";
+	}
 	if (reason) {
 		panic("%s: %s caller=%p", __func__, reason,
 		    (void *)RETURN_ADDRESS);
+	}
+}
 /*
  * Functions for manipulating the kernel_lock.  We put them here
  * so that they show up in profiles.
  */
 #define	_KERNEL_LOCK_ABORT(msg)						\
     LOCKDEBUG_ABORT(__func__, __LINE__, kernel_lock, &_kernel_lock_ops, msg)
 #ifdef LOCKDEBUG
 #define	_KERNEL_LOCK_ASSERT(cond)					\
 do {									\
 	if (!(cond))							\
 		_KERNEL_LOCK_ABORT("assertion failed: " #cond);		\
 } while (/* CONSTCOND */ 0)
 #else
 #define	_KERNEL_LOCK_ASSERT(cond)	/* nothing */
 #endif
 static void	_kernel_lock_dump(const volatile void *, lockop_printer_t);
 lockops_t _kernel_lock_ops = {
 	.lo_name = "Kernel lock",
 	.lo_type = LOCKOPS_SPIN,
 	.lo_dump = _kernel_lock_dump,
 };
 /*
  * Initialize the kernel lock.
  */
 void
 kernel_lock_init(void)
+{
 	__cpu_simple_lock_init(kernel_lock);
 	kernel_lock_dodebug = LOCKDEBUG_ALLOC(kernel_lock, &_kernel_lock_ops,
 	    RETURN_ADDRESS);
+}
 CTASSERT(CACHE_LINE_SIZE >= sizeof(__cpu_simple_lock_t));
 /*
  * Print debugging information about the kernel lock.
  */
 static void
 _kernel_lock_dump(const volatile void *junk, lockop_printer_t pr)
+{
 	struct cpu_info *ci = curcpu();
 	(void)junk;
 	pr("curcpu holds : %18d wanted by: %#018lx\n",
 	    ci->ci_biglock_count, (long)ci->ci_biglock_wanted);
+}
 /*
  * Acquire 'nlocks' holds on the kernel lock.
+ *
  * Although it may not look it, this is one of the most central, intricate
  * routines in the kernel, and tons of code elsewhere depends on its exact
  * behaviour.  If you change something in here, expect it to bite you in the
  * rear.
  */
 void
 _kernel_lock(int nlocks)
+{
 	struct cpu_info *ci;
 	LOCKSTAT_TIMER(spintime);
 	LOCKSTAT_FLAG(lsflag);
 	struct lwp *owant;
 #ifdef LOCKDEBUG
 	u_int spins = 0;
 #endif
 	int s;
 	struct lwp *l = curlwp;
 	_KERNEL_LOCK_ASSERT(nlocks > 0);
 	s = splvm();
 	ci = curcpu();
 	if (ci->ci_biglock_count != 0) {
 		_KERNEL_LOCK_ASSERT(__SIMPLELOCK_LOCKED_P(kernel_lock));
 		ci->ci_biglock_count += nlocks;
 		l->l_blcnt += nlocks;
 		splx(s);
 		return;
+	}
 	_KERNEL_LOCK_ASSERT(l->l_blcnt == 0);
 	LOCKDEBUG_WANTLOCK(kernel_lock_dodebug, kernel_lock, RETURN_ADDRESS,
 );
 	if (__predict_true(__cpu_simple_lock_try(kernel_lock))) {
 		ci->ci_biglock_count = nlocks;
 		l->l_blcnt = nlocks;
 		LOCKDEBUG_LOCKED(kernel_lock_dodebug, kernel_lock, NULL,
 		    RETURN_ADDRESS, 0);
 		splx(s);
 		return;
+	}
 	/*
 	 * To remove the ordering constraint between adaptive mutexes
 	 * and kernel_lock we must make it appear as if this thread is
 	 * blocking.  For non-interlocked mutex release, a store fence
 	 * is required to ensure that the result of any mutex_exit()
 	 * by the current LWP becomes visible on the bus before the set
 	 * of ci->ci_biglock_wanted becomes visible.
+	 *
 	 * However, we won't set ci_biglock_wanted until we've spun for
 	 * a bit, as we don't want to make any lock waiters in rw_oncpu()
 	 * or mutex_oncpu() block prematurely.
 	 */
 	membar_producer();
 	owant = ci->ci_biglock_wanted;
 	ci->ci_biglock_wanted = l;
 #if defined(DIAGNOSTIC) && !defined(LOCKDEBUG)
 	l->l_ld_wanted = __builtin_return_address(0);
 #endif
 	/*
 	 * Spin until we acquire the lock.  Once we have it, record the
 	 * time spent with lockstat.
 	 */
 	LOCKSTAT_ENTER(lsflag);
 	LOCKSTAT_START_TIMER(lsflag, spintime);
 	do {
 		splx(s);
 		while (__SIMPLELOCK_LOCKED_P(kernel_lock)) {
 #ifdef LOCKDEBUG
 			if (SPINLOCK_SPINOUT(spins)) {
 				extern int start_init_exec;
 				if (!start_init_exec)
 					_KERNEL_LOCK_ABORT("spinout");
+			}
 			SPINLOCK_BACKOFF_HOOK;
 			SPINLOCK_SPIN_HOOK;
 #endif
+		}
 		s = splvm();
 	} while (!__cpu_simple_lock_try(kernel_lock));
 	ci->ci_biglock_count = nlocks;
 	l->l_blcnt = nlocks;
 	LOCKSTAT_STOP_TIMER(lsflag, spintime);
 	LOCKDEBUG_LOCKED(kernel_lock_dodebug, kernel_lock, NULL,
 	    RETURN_ADDRESS, 0);
 	if (owant == NULL) {
 		LOCKSTAT_EVENT_RA(lsflag, kernel_lock,
 		    LB_KERNEL_LOCK | LB_SPIN, 1, spintime, RETURN_ADDRESS);
+	}
 	LOCKSTAT_EXIT(lsflag);
 	splx(s);
 	/*
 	 * Now that we have kernel_lock, reset ci_biglock_wanted.  This
 	 * store must be unbuffered (immediately visible on the bus) in
 	 * order for non-interlocked mutex release to work correctly.
 	 * It must be visible before a mutex_exit() can execute on this
 	 * processor.
+	 *
 	 * Note: only where CAS is available in hardware will this be
 	 * an unbuffered write, but non-interlocked release cannot be
 	 * done on CPUs without CAS in hardware.
 	 */
 	(void)atomic_swap_ptr(&ci->ci_biglock_wanted, owant);
 	/*
 	 * Issue a memory barrier as we have acquired a lock.  This also
 	 * prevents stores from a following mutex_exit() being reordered
 	 * to occur before our store to ci_biglock_wanted above.
 	 */
 #ifndef __HAVE_ATOMIC_AS_MEMBAR
 	membar_enter();
 #endif
+}
 /*
  * Release 'nlocks' holds on the kernel lock.  If 'nlocks' is zero, release
  * all holds.
  */
 void
 _kernel_unlock(int nlocks, int *countp)
+{
 	struct cpu_info *ci;
 	u_int olocks;
 	int s;
 	struct lwp *l = curlwp;
 	_KERNEL_LOCK_ASSERT(nlocks < 2);
 	olocks = l->l_blcnt;
 	if (olocks == 0) {
 		_KERNEL_LOCK_ASSERT(nlocks <= 0);
 		if (countp != NULL)
 			*countp = 0;
 		return;
+	}
 	_KERNEL_LOCK_ASSERT(__SIMPLELOCK_LOCKED_P(kernel_lock));
 	if (nlocks == 0)
 		nlocks = olocks;
 	else if (nlocks == -1) {
 		nlocks = 1;
 		_KERNEL_LOCK_ASSERT(olocks == 1);
+	}
 	s = splvm();
 	ci = curcpu();
 	_KERNEL_LOCK_ASSERT(ci->ci_biglock_count >= l->l_blcnt);
 	if (ci->ci_biglock_count == nlocks) {
 		LOCKDEBUG_UNLOCKED(kernel_lock_dodebug, kernel_lock,
 		    RETURN_ADDRESS, 0);
 		ci->ci_biglock_count = 0;
 		__cpu_simple_unlock(kernel_lock);
 		l->l_blcnt -= nlocks;
 		splx(s);
 		if (l->l_dopreempt)
 			kpreempt(0);
 	} else {
 		ci->ci_biglock_count -= nlocks;
 		l->l_blcnt -= nlocks;
 		splx(s);
+	}
 	if (countp != NULL)
 		*countp = olocks;
+}
 bool
 _kernel_locked_p(void)
+{
 	return __SIMPLELOCK_LOCKED_P(kernel_lock);
+}
 void
 kernel_lock_plug_leak(void)
 #ifndef LOCKDEBUG
 # ifdef DIAGNOSTIC
 	int biglocks = 0;
 	KERNEL_UNLOCK_ALL(curlwp, &biglocks);
 	if (biglocks != 0) {
 		const char *sym = "(unknown)";
 		ksyms_getname(NULL, &sym, (vaddr_t)curlwp->l_ld_wanted,
 		    KSYMS_CLOSEST|KSYMS_PROC|KSYMS_ANY);
 		printf("kernel_lock leak detected. last acquired: %s / %p\n",
 		    sym, curlwp->l_ld_wanted);
 # else
 	KERNEL_UNLOCK_ALL(curlwp, NULL);
 # endif
 #endif

 @@ -1,921 +1,918 @@
-/*	$NetBSD: kern_softint.c,v 1.61 2020/02/17 21:44:42 ad Exp $	*/
+/*	$NetBSD: kern_softint.c,v 1.62 2020/03/08 15:05:18 ad 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Generic software interrupt framework.
+ *
  * Overview
+ *
  *	The soft interrupt framework provides a mechanism to schedule a
  *	low priority callback that runs with thread context.  It allows
  *	for dynamic registration of software interrupts, and for fair
  *	queueing and prioritization of those interrupts.  The callbacks
  *	can be scheduled to run from nearly any point in the kernel: by
  *	code running with thread context, by code running from a
  *	hardware interrupt handler, and at any interrupt priority
  *	level.
+ *
  * Priority levels
+ *
  *	Since soft interrupt dispatch can be tied to the underlying
  *	architecture's interrupt dispatch code, it can be limited
  *	both by the capabilities of the hardware and the capabilities
  *	of the interrupt dispatch code itself.  The number of priority
  *	levels is restricted to four.  In order of priority (lowest to
  *	highest) the levels are: clock, bio, net, serial.
+ *
  *	The names are symbolic and in isolation do not have any direct
  *	connection with a particular kind of device activity: they are
  *	only meant as a guide.
+ *
  *	The four priority levels map directly to scheduler priority
  *	levels, and where the architecture implements 'fast' software
  *	interrupts, they also map onto interrupt priorities.  The
  *	interrupt priorities are intended to be hidden from machine
  *	independent code, which should use thread-safe mechanisms to
  *	synchronize with software interrupts (for example: mutexes).
+ *
  * Capabilities
+ *
  *	Software interrupts run with limited machine context.  In
  *	particular, they do not posess any address space context.  They
  *	should not try to operate on user space addresses, or to use
  *	virtual memory facilities other than those noted as interrupt
  *	safe.
+ *
  *	Unlike hardware interrupts, software interrupts do have thread
  *	context.  They may block on synchronization objects, sleep, and
  *	resume execution at a later time.
+ *
  *	Since software interrupts are a limited resource and run with
  *	higher priority than most other LWPs in the system, all
  *	block-and-resume activity by a software interrupt must be kept
  *	short to allow futher processing at that level to continue.  By
  *	extension, code running with process context must take care to
  *	ensure that any lock that may be taken from a software interrupt
  *	can not be held for more than a short period of time.
+ *
  *	The kernel does not allow software interrupts to use facilities
  *	or perform actions that may block for a significant amount of
  *	time.  This means that it's not valid for a software interrupt
  *	to sleep on condition variables	or wait for resources to become
  *	available (for example,	memory).
+ *
  * Per-CPU operation
+ *
  *	If a soft interrupt is triggered on a CPU, it can only be
  *	dispatched on the same CPU.  Each LWP dedicated to handling a
  *	soft interrupt is bound to its home CPU, so if the LWP blocks
  *	and needs to run again, it can only run there.  Nearly all data
  *	structures used to manage software interrupts are per-CPU.
+ *
  *	The per-CPU requirement is intended to reduce "ping-pong" of
  *	cache lines between CPUs: lines occupied by data structures
  *	used to manage the soft interrupts, and lines occupied by data
  *	items being passed down to the soft interrupt.  As a positive
  *	side effect, this also means that the soft interrupt dispatch
  *	code does not need to to use spinlocks to synchronize.
+ *
  * Generic implementation
+ *
  *	A generic, low performance implementation is provided that
  *	works across all architectures, with no machine-dependent
  *	modifications needed.  This implementation uses the scheduler,
  *	and so has a number of restrictions:
+ *
  *	1) The software interrupts are not currently preemptive, so
  *	must wait for the currently executing LWP to yield the CPU.
  *	This can introduce latency.
+ *
  *	2) An expensive context switch is required for a software
  *	interrupt to be handled.
+ *
  * 'Fast' software interrupts
+ *
  *	If an architectures defines __HAVE_FAST_SOFTINTS, it implements
  *	the fast mechanism.  Threads running either in the kernel or in
  *	userspace will be interrupted, but will not be preempted.  When
  *	the soft interrupt completes execution, the interrupted LWP
  *	is resumed.  Interrupt dispatch code must provide the minimum
  *	level of context necessary for the soft interrupt to block and
  *	be resumed at a later time.  The machine-dependent dispatch
  *	path looks something like the following:
+ *
  *	softintr()
  *	{
  *		go to IPL_HIGH if necessary for switch;
  *		save any necessary registers in a format that can be
  *		    restored by cpu_switchto if the softint blocks;
  *		arrange for cpu_switchto() to restore into the
  *		    trampoline function;
  *		identify LWP to handle this interrupt;
  *		switch to the LWP's stack;
  *		switch register stacks, if necessary;
  *		assign new value of curlwp;
  *		call MI softint_dispatch, passing old curlwp and IPL
  *		    to execute interrupt at;
  *		switch back to old stack;
  *		switch back to old register stack, if necessary;
  *		restore curlwp;
  *		return to interrupted LWP;
  *	}
+ *
  *	If the soft interrupt blocks, a trampoline function is returned
  *	to in the context of the interrupted LWP, as arranged for by
  *	softint():
+ *
  *	softint_ret()
  *	{
  *		unlock soft interrupt LWP;
  *		resume interrupt processing, likely returning to
  *		    interrupted LWP or dispatching another, different
  *		    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.61 2020/02/17 21:44:42 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_softint.c,v 1.62 2020/03/08 15:05:18 ad 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 <net/netisr.h>
 #include <uvm/uvm_extern.h>
 /* This could overlap with signal info in struct lwp. */
 typedef struct softint {
 	SIMPLEQ_HEAD(, softhand) si_q;
 	struct lwp		*si_lwp;
 	struct cpu_info		*si_cpu;
 	uintptr_t		si_machdep;
 	struct evcnt		si_evcnt;
 	struct evcnt		si_evcnt_block;
 	int			si_active;
 	char			si_name[8];
 	char			si_name_block[8+6];
 } softint_t;
 typedef struct softhand {
 	SIMPLEQ_ENTRY(softhand)	sh_q;
 	void			(*sh_func)(void *);
 	void			*sh_arg;
 	softint_t		*sh_isr;
 	u_int			sh_flags;
 	u_int			sh_ipi_id;
 } softhand_t;
 typedef struct softcpu {
 	struct cpu_info		*sc_cpu;
 	softint_t		sc_int[SOFTINT_COUNT];
 	softhand_t		sc_hand[1];
 } softcpu_t;
 static void	softint_thread(void *);
 u_int		softint_bytes = 32768;
 u_int		softint_timing;
 static u_int	softint_max;
 static kmutex_t	softint_lock;
 static void	*softint_netisrs[NETISR_MAX];
 /*
  * softint_init_isr:
+ *
  *	Initialize a single interrupt level for a single CPU.
  */
 static void
 softint_init_isr(softcpu_t *sc, const char *desc, pri_t pri, u_int level)
+{
 	struct cpu_info *ci;
 	softint_t *si;
 	int error;
 	si = &sc->sc_int[level];
 	ci = sc->sc_cpu;
 	si->si_cpu = ci;
 	SIMPLEQ_INIT(&si->si_q);
 	error = kthread_create(pri, KTHREAD_MPSAFE | KTHREAD_INTR |
 	    KTHREAD_IDLE, ci, softint_thread, si, &si->si_lwp,
 	    "soft%s/%u", desc, ci->ci_index);
 	if (error != 0)
 		panic("softint_init_isr: error %d", error);
 	snprintf(si->si_name, sizeof(si->si_name), "%s/%u", desc,
 	    ci->ci_index);
 	evcnt_attach_dynamic(&si->si_evcnt, EVCNT_TYPE_MISC, NULL,
 	   "softint", si->si_name);
 	snprintf(si->si_name_block, sizeof(si->si_name_block), "%s block/%u",
 	    desc, ci->ci_index);
 	evcnt_attach_dynamic(&si->si_evcnt_block, EVCNT_TYPE_MISC, NULL,
 	   "softint", si->si_name_block);
 	si->si_lwp->l_private = si;
 	softint_init_md(si->si_lwp, level, &si->si_machdep);
+}
 /*
  * softint_init:
+ *
  *	Initialize per-CPU data structures.  Called from mi_cpu_attach().
  */
 void
 softint_init(struct cpu_info *ci)
+{
 	static struct cpu_info *first;
 	softcpu_t *sc, *scfirst;
 	softhand_t *sh, *shmax;
 	if (first == NULL) {
 		/* Boot CPU. */
 		first = ci;
 		mutex_init(&softint_lock, MUTEX_DEFAULT, IPL_NONE);
 		softint_bytes = round_page(softint_bytes);
 		softint_max = (softint_bytes - sizeof(softcpu_t)) /
 		    sizeof(softhand_t);
+	}
 	/* Use uvm_km(9) for persistent, page-aligned allocation. */
 	sc = (softcpu_t *)uvm_km_alloc(kernel_map, softint_bytes, 0,
 	    UVM_KMF_WIRED | UVM_KMF_ZERO);
 	if (sc == NULL)
 		panic("softint_init_cpu: cannot allocate memory");
 	ci->ci_data.cpu_softcpu = sc;
 	ci->ci_data.cpu_softints = 0;
 	sc->sc_cpu = ci;
 	softint_init_isr(sc, "net", PRI_SOFTNET, SOFTINT_NET);
 	softint_init_isr(sc, "bio", PRI_SOFTBIO, SOFTINT_BIO);
 	softint_init_isr(sc, "clk", PRI_SOFTCLOCK, SOFTINT_CLOCK);
 	softint_init_isr(sc, "ser", PRI_SOFTSERIAL, SOFTINT_SERIAL);
 	if (first != ci) {
 		mutex_enter(&softint_lock);
 		scfirst = first->ci_data.cpu_softcpu;
 		sh = sc->sc_hand;
 		memcpy(sh, scfirst->sc_hand, sizeof(*sh) * softint_max);
 		/* Update pointers for this CPU. */
 		for (shmax = sh + softint_max; sh < shmax; sh++) {
 			if (sh->sh_func == NULL)
 				continue;
 			sh->sh_isr =
 			    &sc->sc_int[sh->sh_flags & SOFTINT_LVLMASK];
+		}
 		mutex_exit(&softint_lock);
 	} else {
 		/*
 		 * Establish handlers for legacy net interrupts.
 		 * XXX Needs to go away.
 		 */
 #define DONETISR(n, f)							\
     softint_netisrs[(n)] = softint_establish(SOFTINT_NET|SOFTINT_MPSAFE,\
         (void (*)(void *))(f), NULL)
 #include <net/netisr_dispatch.h>
+	}
+}
 /*
  * softint_establish:
+ *
  *	Register a software interrupt handler.
  */
 void *
 softint_establish(u_int flags, void (*func)(void *), void *arg)
+{
 	CPU_INFO_ITERATOR cii;
 	struct cpu_info *ci;
 	softcpu_t *sc;
 	softhand_t *sh;
 	u_int level, index;
 	u_int ipi_id = 0;
 	void *sih;
 	level = (flags & SOFTINT_LVLMASK);
 	KASSERT(level < SOFTINT_COUNT);
 	KASSERT((flags & SOFTINT_IMPMASK) == 0);
 	mutex_enter(&softint_lock);
 	/* Find a free slot. */
 	sc = curcpu()->ci_data.cpu_softcpu;
 	for (index = 1; index < softint_max; index++) {
 		if (sc->sc_hand[index].sh_func == NULL)
 			break;
+	}
 	if (index == softint_max) {
 		mutex_exit(&softint_lock);
 		printf("WARNING: softint_establish: table full, "
 		    "increase softint_bytes\n");
 		return NULL;
+	}
 	sih = (void *)((uint8_t *)&sc->sc_hand[index] - (uint8_t *)sc);
 	if (flags & SOFTINT_RCPU) {
 		if ((ipi_id = ipi_register(softint_schedule, sih)) == 0) {
 			mutex_exit(&softint_lock);
 			return NULL;
+		}
+	}
 	/* Set up the handler on each CPU. */
 	if (ncpu < 2) {
 		/* XXX hack for machines with no CPU_INFO_FOREACH() early on */
 		sc = curcpu()->ci_data.cpu_softcpu;
 		sh = &sc->sc_hand[index];
 		sh->sh_isr = &sc->sc_int[level];
 		sh->sh_func = func;
 		sh->sh_arg = arg;
 		sh->sh_flags = flags;
 		sh->sh_ipi_id = ipi_id;
 	} else for (CPU_INFO_FOREACH(cii, ci)) {
 		sc = ci->ci_data.cpu_softcpu;
 		sh = &sc->sc_hand[index];
 		sh->sh_isr = &sc->sc_int[level];
 		sh->sh_func = func;
 		sh->sh_arg = arg;
 		sh->sh_flags = flags;
 		sh->sh_ipi_id = ipi_id;
+	}
 	mutex_exit(&softint_lock);
 	return sih;
+}
 /*
  * softint_disestablish:
+ *
  *	Unregister a software interrupt handler.  The soft interrupt could
  *	still be active at this point, but the caller commits not to try
  *	and trigger it again once this call is made.  The caller must not
  *	hold any locks that could be taken from soft interrupt context,
  *	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;
 	u_int flags;
 	offset = (uintptr_t)arg;
 	KASSERTMSG(offset != 0 && offset < softint_bytes, "%"PRIuPTR" %u",
 	    offset, softint_bytes);
 	/*
 	 * Unregister an 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);
+	}
 	/*
 	 * Run a cross call so we see up to date values of sh_flags from
 	 * all CPUs.  Once softint_disestablish() is called, the caller
 	 * commits to not trigger the interrupt and set SOFTINT_ACTIVE on
 	 * it again.  So, we are only looking for handler records with
 	 * SOFTINT_ACTIVE already set.
 	 */
 	if (__predict_true(mp_online)) {
 		xc_barrier(0);
+	}
 	for (;;) {
 		/* Collect flag values from each CPU. */
 		flags = 0;
 		for (CPU_INFO_FOREACH(cii, ci)) {
 			sc = ci->ci_data.cpu_softcpu;
 			sh = (softhand_t *)((uint8_t *)sc + offset);
 			KASSERT(sh->sh_func != NULL);
 			flags |= sh->sh_flags;
+		}
 		/* Inactive on all CPUs? */
 		if ((flags & SOFTINT_ACTIVE) == 0) {
 			break;
+		}
 		/* Oops, still active.  Wait for it to clear. */
 		(void)kpause("softdis", false, 1, NULL);
+	}
 	/* Clear the handler on each CPU. */
 	mutex_enter(&softint_lock);
 	for (CPU_INFO_FOREACH(cii, ci)) {
 		sc = ci->ci_data.cpu_softcpu;
 		sh = (softhand_t *)((uint8_t *)sc + offset);
 		KASSERT(sh->sh_func != NULL);
 		sh->sh_func = NULL;
+	}
 	mutex_exit(&softint_lock);
+}
 /*
  * softint_schedule:
+ *
  *	Trigger a software interrupt.  Must be called from a hardware
  *	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;
 	KASSERT(kpreempt_disabled());
 	/* Find the handler record for this CPU. */
 	offset = (uintptr_t)arg;
 	KASSERTMSG(offset != 0 && 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();
 	if ((sh->sh_flags & SOFTINT_PENDING) == 0) {
 		si = sh->sh_isr;
 		sh->sh_flags |= SOFTINT_PENDING;
 		SIMPLEQ_INSERT_TAIL(&si->si_q, sh, sh_q);
 		if (si->si_active == 0) {
 			si->si_active = 1;
 			softint_trigger(si->si_machdep);
+		}
+	}
 	splx(s);
+}
 /*
  * softint_schedule_cpu:
+ *
  *	Trigger a software interrupt on a target CPU.  This invokes
  *	softint_schedule() for the local CPU or send an IPI to invoke
  *	this routine on the remote CPU.  Preemption must be disabled.
  */
 void
 softint_schedule_cpu(void *arg, struct cpu_info *ci)
+{
 	KASSERT(kpreempt_disabled());
 	if (curcpu() != ci) {
 		const softcpu_t *sc = ci->ci_data.cpu_softcpu;
 		const uintptr_t offset = (uintptr_t)arg;
 		const softhand_t *sh;
 		sh = (const softhand_t *)((const uint8_t *)sc + offset);
 		KASSERT((sh->sh_flags & SOFTINT_RCPU) != 0);
 		ipi_trigger(sh->sh_ipi_id, ci);
 		return;
+	}
 	/* Just a local CPU. */
 	softint_schedule(arg);
+}
 /*
  * softint_execute:
+ *
  *	Invoke handlers for the specified soft interrupt.
  *	Must be entered at splhigh.  Will drop the priority
  *	to the level specified, but returns back at splhigh.
  */
 static inline void
 softint_execute(softint_t *si, lwp_t *l, int s)
+{
 	softhand_t *sh;
 #ifdef __HAVE_FAST_SOFTINTS
 	KASSERT(si->si_lwp == curlwp);
 #else
 	/* May be running in user context. */
 #endif
 	KASSERT(si->si_cpu == curcpu());
 	KASSERT(si->si_lwp->l_wchan == NULL);
 	KASSERT(si->si_active);
 	/*
 	 * 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.
 		 */
 		sh = SIMPLEQ_FIRST(&si->si_q);
 		SIMPLEQ_REMOVE_HEAD(&si->si_q, sh_q);
 		KASSERT((sh->sh_flags & SOFTINT_PENDING) != 0);
 		KASSERT((sh->sh_flags & SOFTINT_ACTIVE) == 0);
 		sh->sh_flags ^= (SOFTINT_PENDING | SOFTINT_ACTIVE);
 		splx(s);
 		/* Run the handler. */
 		if (__predict_true((sh->sh_flags & SOFTINT_MPSAFE) != 0)) {
 			(*sh->sh_func)(sh->sh_arg);
 		} else {
 			KERNEL_LOCK(1, l);
 			(*sh->sh_func)(sh->sh_arg);
 			KERNEL_UNLOCK_ONE(l);
+		}
 		/* Diagnostic: check that spin-locks have not leaked. */
 		KASSERTMSG(curcpu()->ci_mtx_count == 0,
 		    "%s: ci_mtx_count (%d) != 0, sh_func %p\n",
 		    __func__, curcpu()->ci_mtx_count, sh->sh_func);
 		/* Diagnostic: check that psrefs have not leaked. */
 		KASSERTMSG(l->l_psrefs == 0, "%s: l_psrefs=%d, sh_func=%p\n",
 		    __func__, l->l_psrefs, sh->sh_func);
 		(void)splhigh();
 		KASSERT((sh->sh_flags & SOFTINT_ACTIVE) != 0);
 		sh->sh_flags ^= SOFTINT_ACTIVE;
+	}
 	PSREF_DEBUG_BARRIER();
 	CPU_COUNT(CPU_COUNT_NSOFT, 1);
 	KASSERT(si->si_cpu == curcpu());
 	KASSERT(si->si_lwp->l_wchan == NULL);
 	KASSERT(si->si_active);
 	si->si_evcnt.ev_count++;
 	si->si_active = 0;
+}
 /*
  * softint_block:
+ *
  *	Update statistics when the soft interrupt blocks.
  */
 void
 softint_block(lwp_t *l)
+{
 	softint_t *si = l->l_private;
 	KASSERT((l->l_pflag & LP_INTR) != 0);
 	si->si_evcnt_block.ev_count++;
+}
 /*
  * schednetisr:
+ *
  *	Trigger a legacy network interrupt.  XXX Needs to go away.
  */
 void
 schednetisr(int isr)
+{
 	softint_schedule(softint_netisrs[isr]);
+}
 #ifndef __HAVE_FAST_SOFTINTS
 #ifdef __HAVE_PREEMPTION
 #error __HAVE_PREEMPTION requires __HAVE_FAST_SOFTINTS
 #endif
 /*
  * softint_init_md:
+ *
  *	Slow path: perform machine-dependent initialization.
  */
 void
 softint_init_md(lwp_t *l, u_int level, uintptr_t *machdep)
+{
 	struct proc *p;
 	softint_t *si;
 	*machdep = (1 << level);
 	si = l->l_private;
 	p = l->l_proc;
 	mutex_enter(p->p_lock);
 	lwp_lock(l);
 	/* Cheat and make the KASSERT in softint_thread() happy. */
 	si->si_active = 1;
 	setrunnable(l);
 	/* LWP now unlocked */
 	mutex_exit(p->p_lock);
+}
 /*
  * softint_trigger:
+ *
  *	Slow path: cause a soft interrupt handler to begin executing.
  *	Called at IPL_HIGH.
  */
 void
 softint_trigger(uintptr_t machdep)
+{
 	struct cpu_info *ci;
 	lwp_t *l;
 	ci = curcpu();
 	ci->ci_data.cpu_softints |= machdep;
 	l = ci->ci_onproc;
 	if (l == ci->ci_data.cpu_idlelwp) {
 		atomic_or_uint(&ci->ci_want_resched,
 		    RESCHED_IDLE | RESCHED_UPREEMPT);
 	} else {
 		/* MI equivalent of aston() */
 		cpu_signotify(l);
+	}
+}
 /*
  * softint_thread:
+ *
  *	Slow path: MI software interrupt dispatch.
  */
 void
 softint_thread(void *cookie)
+{
 	softint_t *si;
 	lwp_t *l;
 	int s;
 	l = curlwp;
 	si = l->l_private;
 	for (;;) {
 		/*
 		 * Clear pending status and run it.  We must drop the
 		 * spl before mi_switch(), since IPL_HIGH may be higher
 		 * than IPL_SCHED (and it is not safe to switch at a
 		 * higher level).
 		 */
 		s = splhigh();
 		l->l_cpu->ci_data.cpu_softints &= ~si->si_machdep;
 		softint_execute(si, l, s);
 		splx(s);
 		lwp_lock(l);
 		l->l_stat = LSIDL;
 		spc_lock(l->l_cpu);
 		mi_switch(l);
+	}
+}
 /*
  * softint_picklwp:
+ *
  *	Slow path: called from mi_switch() to pick the highest priority
  *	soft interrupt LWP that needs to run.
  */
 lwp_t *
 softint_picklwp(void)
+{
 	struct cpu_info *ci;
 	u_int mask;
 	softint_t *si;
 	lwp_t *l;
 	ci = curcpu();
 	si = ((softcpu_t *)ci->ci_data.cpu_softcpu)->sc_int;
 	mask = ci->ci_data.cpu_softints;
 	if ((mask & (1 << SOFTINT_SERIAL)) != 0) {
 		l = si[SOFTINT_SERIAL].si_lwp;
 	} else if ((mask & (1 << SOFTINT_NET)) != 0) {
 		l = si[SOFTINT_NET].si_lwp;
 	} else if ((mask & (1 << SOFTINT_BIO)) != 0) {
 		l = si[SOFTINT_BIO].si_lwp;
 	} else if ((mask & (1 << SOFTINT_CLOCK)) != 0) {
 		l = si[SOFTINT_CLOCK].si_lwp;
 	} else {
 		panic("softint_picklwp");
+	}
 	return l;
+}
 /*
  * softint_overlay:
+ *
  *	Slow path: called from lwp_userret() to run a soft interrupt
  *	within the context of a user thread.
  */
 void
 softint_overlay(void)
+{
 	struct cpu_info *ci;
 	u_int softints, oflag;
 	softint_t *si;
 	pri_t obase;
 	lwp_t *l;
 	int s;
 	l = curlwp;
 	KASSERT((l->l_pflag & LP_INTR) == 0);
 	/*
 	 * Arrange to elevate priority if the LWP blocks.  Also, bind LWP
 	 * to the CPU.  Note: disable kernel preemption before doing that.
 	 */
 	s = splhigh();
 	ci = l->l_cpu;
 	si = ((softcpu_t *)ci->ci_data.cpu_softcpu)->sc_int;
 	obase = l->l_kpribase;
 	l->l_kpribase = PRI_KERNEL_RT;
 	oflag = l->l_pflag;
 	l->l_pflag = oflag | LP_INTR | LP_BOUND;
 	while ((softints = ci->ci_data.cpu_softints) != 0) {
 		if ((softints & (1 << SOFTINT_SERIAL)) != 0) {
 			ci->ci_data.cpu_softints &= ~(1 << SOFTINT_SERIAL);
 			softint_execute(&si[SOFTINT_SERIAL], l, s);
 			continue;
+		}
 		if ((softints & (1 << SOFTINT_NET)) != 0) {
 			ci->ci_data.cpu_softints &= ~(1 << SOFTINT_NET);
 			softint_execute(&si[SOFTINT_NET], l, s);
 			continue;
+		}
 		if ((softints & (1 << SOFTINT_BIO)) != 0) {
 			ci->ci_data.cpu_softints &= ~(1 << SOFTINT_BIO);
 			softint_execute(&si[SOFTINT_BIO], l, s);
 			continue;
+		}
 		if ((softints & (1 << SOFTINT_CLOCK)) != 0) {
 			ci->ci_data.cpu_softints &= ~(1 << SOFTINT_CLOCK);
 			softint_execute(&si[SOFTINT_CLOCK], l, s);
 			continue;
+		}
+	}
 	l->l_pflag = oflag;
 	l->l_kpribase = obase;
 	splx(s);
+}
 #else	/*  !__HAVE_FAST_SOFTINTS */
 /*
  * softint_thread:
+ *
  *	Fast path: the LWP is switched to without restoring any state,
  *	so we should not arrive here - there is a direct handoff between
  *	the interrupt stub and softint_dispatch().
  */
 void
 softint_thread(void *cookie)
+{
 	panic("softint_thread");
+}
 /*
  * softint_dispatch:
+ *
  *	Fast path: entry point from machine-dependent code.
  */
 void
 softint_dispatch(lwp_t *pinned, int s)
+{
 	struct bintime now;
 	softint_t *si;
 	u_int timing;
 	lwp_t *l;
 #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));
 		splx(s2);
 		panic("softint screwup");
+	}
 #endif
 	l = curlwp;
 	si = l->l_private;
 	/*
 	 * Note the interrupted LWP, and mark the current LWP as running
 	 * before proceeding.  Although this must as a rule be done with
 	 * the LWP locked, at this point no external agents will want to
 	 * modify the interrupt LWP's state.
 	 */
 	timing = softint_timing;
 	l->l_switchto = pinned;
 	l->l_stat = LSONPROC;
 	/*
 	 * Dispatch the interrupt.  If softints are being timed, charge
 	 * for it.
 	 */
 	if (timing) {
 		binuptime(&l->l_stime);
 		membar_producer();	/* for calcru */
 		l->l_pflag |= LP_TIMEINTR;
+	}
 	l->l_pflag |= LP_RUNNING;
 	softint_execute(si, l, s);
 	if (timing) {
 		binuptime(&now);
 		updatertime(l, &now);
 		l->l_pflag &= ~LP_TIMEINTR;
+	}
 	/* XXX temporary */
 	kernel_lock_plug_leak();
 	/*
 	 * If we blocked while handling the interrupt, the pinned LWP is
 	 * gone so switch to the idle LWP.  It will select a new LWP to
 	 * run.
+	 *
 	 * We must drop the priority level as switching at IPL_HIGH could
 	 * deadlock the system.  We have already set si->si_active = 0,
 	 * which means another interrupt at this level can be triggered.
 	 * That's not be a problem: we are lowering to level 's' which will
 	 * prevent softint_dispatch() from being reentered at level 's',
 	 * until the priority is finally dropped to IPL_NONE on entry to
 	 * the LWP chosen by mi_switch().
 	 */
 	l->l_stat = LSIDL;
 	if (l->l_switchto == NULL) {
 		splx(s);
 		lwp_lock(l);
 		spc_lock(l->l_cpu);
 		mi_switch(l);
 		/* NOTREACHED */
+	}
 	l->l_switchto = NULL;
 	l->l_pflag &= ~LP_RUNNING;
+}
 #endif	/* !__HAVE_FAST_SOFTINTS */