 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_exec.c,v 1.484 2019/11/23 19:42:52 ad Exp $	*/
+/*	$NetBSD: kern_exec.c,v 1.485 2019/12/06 21:36:10 ad Exp $	*/
 /*-
  * Copyright (c) 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.
 @@ -52,27 +52,27 @@
  * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``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 TOOLS GMBH 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_exec.c,v 1.484 2019/11/23 19:42:52 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_exec.c,v 1.485 2019/12/06 21:36:10 ad Exp $");
 #include "opt_exec.h"
 #include "opt_execfmt.h"
 #include "opt_ktrace.h"
 #include "opt_modular.h"
 #include "opt_syscall_debug.h"
 #include "veriexec.h"
 #include "opt_pax.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/filedesc.h>
 #include <sys/kernel.h>
 @@ -1353,26 +1353,27 @@ execve_runproc(struct lwp *l, struct exe
 		p->p_pptr->p_nstopchild++;
 		p->p_waited = 0;
 		mutex_enter(p->p_lock);
 		ksiginfo_queue_init(&kq);
 		sigclearall(p, &contsigmask, &kq);
 		lwp_lock(l);
 		l->l_stat = LSSTOP;
 		p->p_stat = SSTOP;
 		p->p_nrlwps--;
 		lwp_unlock(l);
 		mutex_exit(p->p_lock);
 		mutex_exit(proc_lock);
 		lwp_lock(l);
 		spc_lock(l->l_cpu);
 		mi_switch(l);
 		ksiginfo_queue_drain(&kq);
 		KERNEL_LOCK(l->l_biglocks, l);
 	} else {
 		mutex_exit(proc_lock);
+	}
 	exec_path_free(data);
 #ifdef TRACE_EXEC
 	DPRINTF(("%s finished\n", __func__));
 #endif
 	return EJUSTRETURN;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_exit.c,v 1.277 2019/10/03 22:48:44 kamil Exp $	*/
+/*	$NetBSD: kern_exit.c,v 1.278 2019/12/06 21:36:10 ad Exp $	*/
 /*-
  * Copyright (c) 1998, 1999, 2006, 2007, 2008 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
 @@ -57,27 +57,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_exit.c	8.10 (Berkeley) 2/23/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_exit.c,v 1.277 2019/10/03 22:48:44 kamil Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_exit.c,v 1.278 2019/12/06 21:36:10 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>
 @@ -235,26 +235,27 @@ exit1(struct lwp *l, int exitcode, int s
 			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);
 		KERNEL_LOCK(l->l_biglocks, 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);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_idle.c,v 1.27 2019/12/01 15:34:46 ad Exp $	*/
+/*	$NetBSD: kern_idle.c,v 1.28 2019/12/06 21:36:10 ad Exp $	*/
 /*-
  * Copyright (c)2002, 2006, 2007 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.
 @@ -18,27 +18,27 @@
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_idle.c,v 1.27 2019/12/01 15:34:46 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_idle.c,v 1.28 2019/12/06 21:36:10 ad Exp $");
 #include <sys/param.h>
 #include <sys/cpu.h>
 #include <sys/idle.h>
 #include <sys/kthread.h>
 #include <sys/lockdebug.h>
 #include <sys/kmem.h>
 #include <sys/proc.h>
 #include <sys/atomic.h>
 #include <uvm/uvm.h>	/* uvm_pageidlezero */
 #include <uvm/uvm_extern.h>
 @@ -83,26 +83,28 @@ idle_loop(void *dummy)
 			if ((spc->spc_flags & SPCF_OFFLINE) == 0) {
 				uvm_pageidlezero();
+			}
 			if (!sched_curcpu_runnable_p()) {
 				cpu_idle();
 				if (!sched_curcpu_runnable_p() &&
 				    !ci->ci_want_resched) {
 					continue;
+				}
+			}
+		}
 		KASSERT(l->l_mutex == l->l_cpu->ci_schedstate.spc_lwplock);
 		lwp_lock(l);
 		l->l_stat = LSIDL;
 		spc_lock(l->l_cpu);
 		mi_switch(l);
 		KASSERT(curlwp == l);
 		KASSERT(l->l_stat == LSONPROC);
+	}
+}
 int
 create_idle_lwp(struct cpu_info *ci)
+{
 	lwp_t *l;
 	int error;
 	KASSERT(ci->ci_data.cpu_idlelwp == NULL);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_lwp.c,v 1.216 2019/12/03 05:07:48 riastradh Exp $	*/
+/*	$NetBSD: kern_lwp.c,v 1.217 2019/12/06 21:36:10 ad Exp $	*/
 /*-
  * Copyright (c) 2001, 2006, 2007, 2008, 2009, 2019 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
  *    notice, this list of conditions and the following disclaimer.
 @@ -199,27 +199,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.216 2019/12/03 05:07:48 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_lwp.c,v 1.217 2019/12/06 21:36:10 ad 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>
 @@ -1592,26 +1592,27 @@ lwp_userret(struct lwp *l)
 		 * p->p_lwpcv so that sigexit() will write the core file out
 		 * once all other LWPs are suspended.
 		 */
 		if ((l->l_flag & LW_WSUSPEND) != 0) {
 			pcu_save_all(l);
 			mutex_enter(p->p_lock);
 			p->p_nrlwps--;
 			cv_broadcast(&p->p_lwpcv);
 			lwp_lock(l);
 			l->l_stat = LSSUSPENDED;
 			lwp_unlock(l);
 			mutex_exit(p->p_lock);
 			lwp_lock(l);
 			spc_lock(l->l_cpu);
 			mi_switch(l);
+		}
 		/* Process is exiting. */
 		if ((l->l_flag & LW_WEXIT) != 0) {
 			lwp_exit(l);
 			KASSERT(0);
 			/* NOTREACHED */
+		}
 		/* update lwpctl processor (for vfork child_return) */
 		if (l->l_flag & LW_LWPCTL) {
 			lwp_lock(l);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_sig.c,v 1.380 2019/11/21 18:17:36 ad Exp $	*/
+/*	$NetBSD: kern_sig.c,v 1.381 2019/12/06 21:36:10 ad 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.380 2019/11/21 18:17:36 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_sig.c,v 1.381 2019/12/06 21:36:10 ad Exp $");
 #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>
 #include <sys/ptrace.h>
 @@ -1761,26 +1761,27 @@ sigswitch_unlock_and_switch_away(struct
 	KASSERT(p->p_nrlwps > 0);
 	KERNEL_UNLOCK_ALL(l, &biglocks);
 	if (p->p_stat == SSTOP || (p->p_sflag & PS_STOPPING) != 0) {
 		p->p_nrlwps--;
 		lwp_lock(l);
 		KASSERT(l->l_stat == LSONPROC || l->l_stat == LSSLEEP);
 		l->l_stat = LSSTOP;
 		lwp_unlock(l);
+	}
 	mutex_exit(p->p_lock);
 	lwp_lock(l);
 	spc_lock(l->l_cpu);
 	mi_switch(l);
 	KERNEL_LOCK(biglocks, l);
+}
 /*
  * Check for a signal from the debugger.
  */
 static int
 sigchecktrace(void)
+{
 	struct lwp *l = curlwp;
 	struct proc *p = l->l_proc;
 	int signo;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_sleepq.c,v 1.53 2019/11/23 19:42:52 ad Exp $	*/
+/*	$NetBSD: kern_sleepq.c,v 1.54 2019/12/06 21:36:10 ad Exp $	*/
 /*-
  * Copyright (c) 2006, 2007, 2008, 2009, 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.
 @@ -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.53 2019/11/23 19:42:52 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_sleepq.c,v 1.54 2019/12/06 21:36:10 ad 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>
 @@ -250,26 +250,27 @@ sleepq_block(int timo, bool catch_p)
 			error = EINTR;
 			early = true;
 		} else if ((l->l_flag & LW_PENDSIG) != 0 && sigispending(l, 0))
 			early = true;
+	}
 	if (early) {
 		/* lwp_unsleep() will release the lock */
 		lwp_unsleep(l, true);
 	} else {
 		if (timo) {
 			callout_schedule(&l->l_timeout_ch, timo);
+		}
 		spc_lock(l->l_cpu);
 		mi_switch(l);
 		/* The LWP and sleep queue are now unlocked. */
 		if (timo) {
 			/*
 			 * Even if the callout appears to have fired, we
 			 * need to stop it in order to synchronise with
 			 * other CPUs.  It's important that we do this in
 			 * this LWP's context, and not during wakeup, in
 			 * order to keep the callout & its cache lines
 			 * co-located on the CPU with the LWP.
 			 */
 			if (callout_halt(&l->l_timeout_ch, NULL))

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_softint.c,v 1.54 2019/12/06 18:15:57 ad Exp $	*/
+/*	$NetBSD: kern_softint.c,v 1.55 2019/12/06 21:36:10 ad Exp $	*/
 /*-
  * Copyright (c) 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.
 @@ -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.54 2019/12/06 18:15:57 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_softint.c,v 1.55 2019/12/06 21:36:10 ad Exp $");
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/intr.h>
 #include <sys/ipi.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>
 @@ -719,26 +719,27 @@ softint_thread(void *cookie)
 		/*
 		 * 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)
+{

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_synch.c,v 1.328 2019/12/03 05:07:48 riastradh Exp $	*/
+/*	$NetBSD: kern_synch.c,v 1.329 2019/12/06 21:36:10 ad Exp $	*/
 /*-
  * Copyright (c) 1999, 2000, 2004, 2006, 2007, 2008, 2009, 2019
  *    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, by Charles M. Hannum, Andrew Doran and
  * Daniel Sieger.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 @@ -59,27 +59,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_synch.c	8.9 (Berkeley) 5/19/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_synch.c,v 1.328 2019/12/03 05:07:48 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_synch.c,v 1.329 2019/12/06 21:36:10 ad Exp $");
 #include "opt_kstack.h"
 #include "opt_dtrace.h"
 #define	__MUTEX_PRIVATE
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/kernel.h>
 #include <sys/cpu.h>
 #include <sys/pserialize.h>
 #include <sys/resourcevar.h>
 @@ -259,50 +259,56 @@ wakeup(wchan_t ident)
 /*
  * General yield call.  Puts the current LWP back on its run queue and
  * performs a voluntary context switch.  Should only be called when the
  * current LWP explicitly requests it (eg sched_yield(2)).
  */
 void
 yield(void)
+{
 	struct lwp *l = curlwp;
 	KERNEL_UNLOCK_ALL(l, &l->l_biglocks);
 	lwp_lock(l);
 	KASSERT(lwp_locked(l, l->l_cpu->ci_schedstate.spc_lwplock));
 	KASSERT(l->l_stat == LSONPROC);
 	/* Voluntary - ditch kpriority boost. */
 	l->l_kpriority = false;
-	(void)mi_switch(l);
+	spc_lock(l->l_cpu);
 	mi_switch(l);
 	KERNEL_LOCK(l->l_biglocks, l);
+}
 /*
  * General preemption call.  Puts the current LWP back on its run queue
  * and performs an involuntary context switch.
  */
 void
 preempt(void)
+{
 	struct lwp *l = curlwp;
 	KERNEL_UNLOCK_ALL(l, &l->l_biglocks);
 	lwp_lock(l);
 	KASSERT(lwp_locked(l, l->l_cpu->ci_schedstate.spc_lwplock));
 	KASSERT(l->l_stat == LSONPROC);
 	/* Involuntary - keep kpriority boost. */
 	l->l_pflag |= LP_PREEMPTING;
-	(void)mi_switch(l);
+	spc_lock(l->l_cpu);
 	mi_switch(l);
 	KERNEL_LOCK(l->l_biglocks, l);
+}
 /*
  * Handle a request made by another agent to preempt the current LWP
  * in-kernel.  Usually called when l_dopreempt may be non-zero.
+ *
  * Character addresses for lockstat only.
  */
 static char	kpreempt_is_disabled;
 static char	kernel_lock_held;
 static char	is_softint_lwp;
 static char	spl_is_raised;
 @@ -362,27 +368,29 @@ kpreempt(uintptr_t where)
 			 * It may be that the IPL is too high.
 			 * kpreempt_enter() can schedule an
 			 * interrupt to retry later.
 			 */
 			splx(s);
 			failed = (uintptr_t)&spl_is_raised;
 			break;
+		}
 		/* Do it! */
 		if (__predict_true((dop & DOPREEMPT_COUNTED) == 0)) {
 			kpreempt_ev_immed.ev_count++;
+		}
 		lwp_lock(l);
 		/* Involuntary - keep kpriority boost. */
 		l->l_pflag |= LP_PREEMPTING;
 		spc_lock(l->l_cpu);
 		mi_switch(l);
 		l->l_nopreempt++;
 		splx(s);
 		/* Take care of any MD cleanup. */
 		cpu_kpreempt_exit(where);
 		l->l_nopreempt--;
+	}
 	if (__predict_true(!failed)) {
 		return false;
+	}
 @@ -491,50 +499,52 @@ nextlwp(struct cpu_info *ci, struct sche
 	 * the update to ci_want_resched will become globally visible before
 	 * the release of spc_mutex becomes globally visible.
 	 */
 	ci->ci_want_resched = ci->ci_data.cpu_softints;
 	spc->spc_flags &= ~SPCF_SWITCHCLEAR;
 	spc->spc_curpriority = lwp_eprio(newl);
 	return newl;
+}
 /*
  * The machine independent parts of context switch.
+ *
- * Returns 1 if another LWP was actually run.
+ * NOTE: do not use l->l_cpu in this routine.  The caller may have enqueued
  * itself onto another CPU's run queue, so l->l_cpu may point elsewhere.
  */
-int
+void
 mi_switch(lwp_t *l)
+{
 	struct cpu_info *ci;
 	struct schedstate_percpu *spc;
 	struct lwp *newl;
-	int retval, oldspl;
+	int oldspl;
 	struct bintime bt;
 	bool returning;
 	KASSERT(lwp_locked(l, NULL));
 	KASSERT(kpreempt_disabled());
 	KASSERT(mutex_owned(curcpu()->ci_schedstate.spc_mutex));
 	LOCKDEBUG_BARRIER(l->l_mutex, 1);
 	kstack_check_magic(l);
 	binuptime(&bt);
 	KASSERTMSG(l == curlwp, "l %p curlwp %p", l, curlwp);
 	KASSERT((l->l_pflag & LP_RUNNING) != 0);
-	KASSERT(l->l_cpu == curcpu());
+	KASSERT(l->l_cpu == curcpu() || l->l_stat == LSRUN);
-	ci = l->l_cpu;
+	ci = curcpu();
 	spc = &ci->ci_schedstate;
 	returning = false;
 	newl = NULL;
 	/*
 	 * If we have been asked to switch to a specific LWP, then there
 	 * is no need to inspect the run queues.  If a soft interrupt is
 	 * blocking, then return to the interrupted thread without adjusting
 	 * VM context or its start time: neither have been changed in order
 	 * to take the interrupt.
 	 */
 	if (l->l_switchto != NULL) {
 		if ((l->l_pflag & LP_INTR) != 0) {
 @@ -545,51 +555,44 @@ mi_switch(lwp_t *l)
+		}
 		newl = l->l_switchto;
 		l->l_switchto = NULL;
+	}
 #ifndef __HAVE_FAST_SOFTINTS
 	else if (ci->ci_data.cpu_softints != 0) {
 		/* There are pending soft interrupts, so pick one. */
 		newl = softint_picklwp();
 		newl->l_stat = LSONPROC;
 		newl->l_pflag |= LP_RUNNING;
+	}
 #endif	/* !__HAVE_FAST_SOFTINTS */
 	/* Lock the runqueue */
 	KASSERT(l->l_stat != LSRUN);
 	mutex_spin_enter(spc->spc_mutex);
 	/*
 	 * If on the CPU and we have gotten this far, then we must yield.
 	 */
 	if (l->l_stat == LSONPROC && l != newl) {
 		KASSERT(lwp_locked(l, spc->spc_lwplock));
-		if ((l->l_flag & LW_IDLE) == 0) {
+		KASSERT((l->l_flag & LW_IDLE) == 0);
-			l->l_stat = LSRUN;
+		l->l_stat = LSRUN;
-			lwp_setlock(l, spc->spc_mutex);
+		lwp_setlock(l, spc->spc_mutex);
-			sched_enqueue(l);
+		sched_enqueue(l);
-			/*
+		/*
-			 * Handle migration.  Note that "migrating LWP" may
+		 * Handle migration.  Note that "migrating LWP" may
-			 * be reset here, if interrupt/preemption happens
+		 * be reset here, if interrupt/preemption happens
-			 * early in idle LWP.
+		 * early in idle LWP.
-			 */
+		 */
-			if (l->l_target_cpu != NULL &&
+		if (l->l_target_cpu != NULL && (l->l_pflag & LP_BOUND) == 0) {
-			    (l->l_pflag & LP_BOUND) == 0) {
+			KASSERT((l->l_pflag & LP_INTR) == 0);
-				KASSERT((l->l_pflag & LP_INTR) == 0);
+			spc->spc_migrating = l;
 				spc->spc_migrating = l;
 		} else
 			l->l_stat = LSIDL;
+	}
 	/* Pick new LWP to run. */
 	if (newl == NULL) {
 		newl = nextlwp(ci, spc);
+	}
 	/* Items that must be updated with the CPU locked. */
 	if (!returning) {
 		/* Count time spent in current system call */
 		SYSCALL_TIME_SLEEP(l);
 		updatertime(l, &bt);
 @@ -684,26 +687,27 @@ mi_switch(lwp_t *l)
 		if (!returning)
 			pmap_deactivate(l);
 		/*
 		 * We may need to spin-wait if 'newl' is still
 		 * context switching on another CPU.
 		 */
 		if (__predict_false(newl->l_ctxswtch != 0)) {
 			u_int count;
 			count = SPINLOCK_BACKOFF_MIN;
 			while (newl->l_ctxswtch)
 				SPINLOCK_BACKOFF(count);
+		}
 		membar_enter();
 		/*
 		 * If DTrace has set the active vtime enum to anything
 		 * other than INACTIVE (0), then it should have set the
 		 * function to call.
 		 */
 		if (__predict_false(dtrace_vtime_active)) {
 			(*dtrace_vtime_switch_func)(newl);
+		}
 		/*
 		 * We must ensure not to come here from inside a read section.
 		 */
 @@ -733,48 +737,45 @@ mi_switch(lwp_t *l)
 			/* Normalize the count of the spin-mutexes */
 			ci->ci_mtx_count++;
 			/* Unmark the state of context switch */
 			membar_exit();
 			prevlwp->l_ctxswtch = 0;
+		}
 		/* Update status for lwpctl, if present. */
 		if (l->l_lwpctl != NULL) {
 			l->l_lwpctl->lc_curcpu = (int)cpu_index(ci);
 			l->l_lwpctl->lc_pctr++;
+		}
 		KASSERT(l->l_cpu == ci);
 		splx(oldspl);
 		/*
-		 * note that, unless the caller disabled preemption,
+		 * Note that, unless the caller disabled preemption, we can
-		 * we can be preempted at any time after the above splx() call.
+		 * be preempted at any time after this splx().
 		 */
-		retval = 1;
+		splx(oldspl);
 	} else {
 		/* Nothing to do - just unlock and return. */
 		mutex_spin_exit(spc->spc_mutex);
 		l->l_pflag &= ~LP_PREEMPTING;
 		lwp_unlock(l);
 		retval = 0;
+	}
 	/* Only now is it safe to consider l_cpu again. */
 	KASSERT(l == curlwp);
 	KASSERT(l->l_cpu == ci);
 	KASSERT(l->l_stat == LSONPROC);
 	SYSCALL_TIME_WAKEUP(l);
 	LOCKDEBUG_BARRIER(NULL, 1);
 	return retval;
+}
 /*
  * The machine independent parts of context switch to oblivion.
  * Does not return.  Call with the LWP unlocked.
  */
 void
 lwp_exit_switchaway(lwp_t *l)
+{
 	struct cpu_info *ci;
 	struct lwp *newl;
 	struct bintime bt;
 @@ -838,26 +839,27 @@ lwp_exit_switchaway(lwp_t *l)
 	if (l->l_lwpctl != NULL)
 		l->l_lwpctl->lc_curcpu = LWPCTL_CPU_EXITED;
 	/*
 	 * We may need to spin-wait if 'newl' is still
 	 * context switching on another CPU.
 	 */
 	if (__predict_false(newl->l_ctxswtch != 0)) {
 		u_int count;
 		count = SPINLOCK_BACKOFF_MIN;
 		while (newl->l_ctxswtch)
 			SPINLOCK_BACKOFF(count);
+	}
 	membar_enter();
 	/*
 	 * If DTrace has set the active vtime enum to anything
 	 * other than INACTIVE (0), then it should have set the
 	 * function to call.
 	 */
 	if (__predict_false(dtrace_vtime_active)) {
 		(*dtrace_vtime_switch_func)(newl);
+	}
 	/* Switch to the new LWP.. */
 	(void)cpu_switchto(NULL, newl, false);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sched.h,v 1.79 2019/12/03 22:28:41 ad Exp $	*/
+/*	$NetBSD: sched.h,v 1.80 2019/12/06 21:36:10 ad Exp $	*/
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2007, 2008, 2019
  *    The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Ross Harvey, Jason R. Thorpe, Nathan J. Williams, Andrew Doran and
  * Daniel Sieger.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -256,23 +256,23 @@ void		sched_slept(struct lwp *);
 void		sched_wakeup(struct lwp *);
 void		setrunnable(struct lwp *);
 void		sched_setrunnable(struct lwp *);
 struct cpu_info *sched_takecpu(struct lwp *);
 void		sched_print_runqueue(void (*pr)(const char *, ...)
     __printflike(1, 2));
 /* Dispatching */
 bool		kpreempt(uintptr_t);
 void		preempt(void);
 void		yield(void);
-int		mi_switch(struct lwp *);
+void		mi_switch(struct lwp *);
 void		updatertime(lwp_t *, const struct bintime *);
 void		sched_idle(void);
 void		suspendsched(void);
 int		do_sched_setparam(pid_t, lwpid_t, int, const struct sched_param *);
 int		do_sched_getparam(pid_t, lwpid_t, int *, struct sched_param *);
 #endif	/* _KERNEL */
 #endif	/* _SYS_SCHED_H_ */