 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_sig.c,v 1.369 2019/10/12 19:57:09 kamil Exp $	*/
+/*	$NetBSD: kern_sig.c,v 1.370 2019/10/13 03:10:22 kamil Exp $	*/
 /*-
  * Copyright (c) 2006, 2007, 2008 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.369 2019/10/12 19:57:09 kamil Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_sig.c,v 1.370 2019/10/13 03:10:22 kamil 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>
 @@ -116,26 +116,27 @@ sigset_t		contsigmask	__cacheline_aligne
 sigset_t		stopsigmask	__cacheline_aligned;
 static sigset_t		vforksigmask	__cacheline_aligned;
 sigset_t		sigcantmask	__cacheline_aligned;
 static void	ksiginfo_exechook(struct proc *, void *);
 static void	proc_stop(struct proc *, int);
 static void	proc_stop_done(struct proc *, int);
 static void	proc_stop_callout(void *);
 static int	sigchecktrace(void);
 static int	sigpost(struct lwp *, sig_t, int, int);
 static int	sigput(sigpend_t *, struct proc *, ksiginfo_t *);
 static int	sigunwait(struct proc *, const ksiginfo_t *);
 static void	sigswitch(int, int, bool);
 static void	sigswitch_unlock_and_switch_away(struct lwp *);
 static void	sigacts_poolpage_free(struct pool *, void *);
 static void	*sigacts_poolpage_alloc(struct pool *, int);
 void (*sendsig_sigcontext_vec)(const struct ksiginfo *, const sigset_t *);
 int (*coredump_vec)(struct lwp *, const char *) =
     (int (*)(struct lwp *, const char *))enosys;
 /*
  * DTrace SDT provider definitions
  */
 SDT_PROVIDER_DECLARE(proc);
 SDT_PROBE_DEFINE3(proc, kernel, , signal__send,
 @@ -922,30 +923,31 @@ repeat:
 	 */
 	if (__predict_false(ISSET(p->p_sflag, PS_WEXIT))) {
 		mutex_exit(p->p_lock);
 		mutex_exit(proc_lock);
 		lwp_exit(l);
 		panic("trapsignal");
 		/* NOTREACHED */
+	}
 	/*
 	 * The process is already stopping.
 	 */
 	if ((p->p_sflag & PS_STOPPING) != 0) {
-		sigswitch(0, p->p_xsig, true);
+		mutex_exit(proc_lock);
 		sigswitch_unlock_and_switch_away(l);
 		mutex_enter(proc_lock);
 		mutex_enter(p->p_lock);
-		goto repeat; /* XXX */
+		goto repeat;
+	}
 	mask = &l->l_sigmask;
 	ps = p->p_sigacts;
 	action = SIGACTION_PS(ps, signo).sa_handler;
 	if (ISSET(p->p_slflag, PSL_TRACED) &&
 	    !(p->p_pptr == p->p_opptr && ISSET(p->p_lflag, PL_PPWAIT)) &&
 	    p->p_xsig != SIGKILL &&
 	    !sigismember(&p->p_sigpend.sp_set, SIGKILL)) {
 		p->p_xsig = signo;
 		p->p_sigctx.ps_faked = true;
 		p->p_sigctx.ps_lwp = ksi->ksi_lid;
 @@ -1632,30 +1634,31 @@ repeat:
 	 * If there's a pending SIGKILL process it immediately.
 	 */
 	if (p->p_xsig == SIGKILL ||
 	    sigismember(&p->p_sigpend.sp_set, SIGKILL)) {
 		mutex_exit(p->p_lock);
 		mutex_exit(proc_lock);
 		return;
+	}
 	/*
 	 * The process is already stopping.
 	 */
 	if ((p->p_sflag & PS_STOPPING) != 0) {
-		sigswitch(0, p->p_xsig, true);
+		mutex_exit(proc_lock);
 		sigswitch_unlock_and_switch_away(l);
 		mutex_enter(proc_lock);
 		mutex_enter(p->p_lock);
-		goto repeat; /* XXX */
+		goto repeat;
+	}
 	KSI_INIT_TRAP(&ksi);
 	ksi.ksi_lid = l->l_lid;
 	ksi.ksi_signo = signo;
 	ksi.ksi_code = code;
 	ksi.ksi_pe_report_event = pe_report_event;
 	CTASSERT(sizeof(ksi.ksi_pe_other_pid) == sizeof(ksi.ksi_pe_lwp));
 	ksi.ksi_pe_other_pid = entity;
 	/* Needed for ktrace */
 	ps = p->p_sigacts;
 @@ -1682,27 +1685,26 @@ repeat:
 		else
 			ktrpsig(signo, action, mask, &ksi);
+	}
+}
 /*
  * Stop the current process and switch away when being stopped or traced.
  */
 static void
 sigswitch(int ppmask, int signo, bool proc_lock_held)
+{
 	struct lwp *l = curlwp;
 	struct proc *p = l->l_proc;
 	int biglocks;
 	KASSERT(mutex_owned(p->p_lock));
 	KASSERT(l->l_stat == LSONPROC);
 	KASSERT(p->p_nrlwps > 0);
 	if (proc_lock_held) {
 		KASSERT(mutex_owned(proc_lock));
 	} else {
 		KASSERT(!mutex_owned(proc_lock));
+	}
 	/*
 	 * If we are exiting, demise now.
 @@ -1742,30 +1744,46 @@ sigswitch(int ppmask, int signo, bool pr
+		}
 		if (p->p_nrlwps == 1 && (p->p_sflag & PS_STOPPING) != 0) {
 			/*
 			 * Note that proc_stop_done() can drop
 			 * p->p_lock briefly.
 			 */
 			proc_stop_done(p, ppmask);
+		}
 		mutex_exit(proc_lock);
+	}
-	/*
+	sigswitch_unlock_and_switch_away(l);
 	 * Unlock and switch away.
 	 */
 /*
  * Unlock and switch away.
  */
 static void
 sigswitch_unlock_and_switch_away(struct lwp *l)
+{
 	struct proc *p;
 	int biglocks;
 	p = l->l_proc;
 	KASSERT(mutex_owned(p->p_lock));
 	KASSERT(!mutex_owned(proc_lock));
 	KASSERT(l->l_stat == LSONPROC);
 	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);
 	mi_switch(l);
 	KERNEL_LOCK(biglocks, l);
 @@ -1835,27 +1853,27 @@ issignal(struct lwp *l)
 	for (;;) {
 		/* Discard any signals that we have decided not to take. */
 		if (signo != 0) {
 			(void)sigget(sp, NULL, signo, NULL);
+		}
 		/*
 		 * If the process is stopped/stopping, then stop ourselves
 		 * now that we're on the kernel/userspace boundary.  When
 		 * we awaken, check for a signal from the debugger.
 		 */
 		if (p->p_stat == SSTOP || (p->p_sflag & PS_STOPPING) != 0) {
-			sigswitch(PS_NOCLDSTOP, 0, false);
+			sigswitch_unlock_and_switch_away(l);
 			mutex_enter(p->p_lock);
 			signo = sigchecktrace();
 		} else if (p->p_stat == SACTIVE)
 			signo = sigchecktrace();
 		else
 			signo = 0;
 		/* Signals from the debugger are "out of band". */
 		sp = NULL;
 		/*
 		 * If the debugger didn't provide a signal, find a pending
 		 * signal from our set.  Check per-LWP signals first, and
 @@ -2517,29 +2535,29 @@ repeat:
 	 * If we are no longer traced, abandon this event signal.
+	 *
 	 * This avoids killing a process after detaching the debugger.
 	 */
 	if (__predict_false(!ISSET(p->p_slflag, PSL_TRACED))) {
 		mutex_exit(p->p_lock);
 		return;
+	}
 	/*
 	 * The process is already stopping.
 	 */
 	if ((p->p_sflag & PS_STOPPING) != 0) {
-		sigswitch(0, p->p_xsig, false);
+		sigswitch_unlock_and_switch_away(l);
 		mutex_enter(p->p_lock);
-		goto repeat; /* XXX */
+		goto repeat;
+	}
 	/* Needed for ktrace */
 	ps = p->p_sigacts;
 	action = SIGACTION_PS(ps, signo).sa_handler;
 	mask = &l->l_sigmask;
 	p->p_xsig = signo;
 	p->p_sigctx.ps_lwp = ksi.ksi_lid;
 	p->p_sigctx.ps_info = ksi.ksi_info;
 	sigswitch(0, signo, false);
 	if (ktrpoint(KTR_PSIG)) {