 @@ -1,2349 +1,2348 @@
-/*	$NetBSD: kern_sig.c,v 1.289.4.8 2012/03/17 19:14:08 bouyer Exp $	*/
+/*	$NetBSD: kern_sig.c,v 1.289.4.9 2015/11/07 20:45:19 snj 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.
  * 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_sig.c	8.14 (Berkeley) 5/14/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_sig.c,v 1.289.4.8 2012/03/17 19:14:08 bouyer Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_sig.c,v 1.289.4.9 2015/11/07 20:45:19 snj Exp $");
 #include "opt_ptrace.h"
 #include "opt_compat_sunos.h"
 #include "opt_compat_netbsd.h"
 #include "opt_compat_netbsd32.h"
 #include "opt_pax.h"
 #include "opt_sa.h"
 #define	SIGPROP		/* include signal properties table */
 #include <sys/param.h>
 #include <sys/signalvar.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/wait.h>
 #include <sys/ktrace.h>
 #include <sys/syslog.h>
 #include <sys/filedesc.h>
 #include <sys/file.h>
 #include <sys/malloc.h>
 #include <sys/pool.h>
 #include <sys/ucontext.h>
 #include <sys/sa.h>
 #include <sys/savar.h>
 #include <sys/exec.h>
 #include <sys/kauth.h>
 #include <sys/acct.h>
 #include <sys/callout.h>
 #include <sys/atomic.h>
 #include <sys/cpu.h>
 #ifdef PAX_SEGVGUARD
 #include <sys/pax.h>
 #endif /* PAX_SEGVGUARD */
 #include <uvm/uvm.h>
 #include <uvm/uvm_extern.h>
 static void	ksiginfo_exechook(struct proc *, void *);
 static void	proc_stop_callout(void *);
 static int	sigchecktrace(void);
 static int	sigpost(struct lwp *, sig_t, int, int, int);
 static void	sigput(sigpend_t *, struct proc *, ksiginfo_t *);
 static int	sigunwait(struct proc *, const ksiginfo_t *);
 static void	sigswitch(bool, int, int);
 sigset_t	contsigmask, stopsigmask, sigcantmask;
 static pool_cache_t sigacts_cache; /* memory pool for sigacts structures */
 static void	sigacts_poolpage_free(struct pool *, void *);
 static void	*sigacts_poolpage_alloc(struct pool *, int);
 static callout_t proc_stop_ch;
 static pool_cache_t siginfo_cache;
 static pool_cache_t ksiginfo_cache;
 static struct pool_allocator sigactspool_allocator = {
         .pa_alloc = sigacts_poolpage_alloc,
 	.pa_free = sigacts_poolpage_free,
 };
 #ifdef DEBUG
 int	kern_logsigexit = 1;
 #else
 int	kern_logsigexit = 0;
 #endif
 static	const char logcoredump[] =
     "pid %d (%s), uid %d: exited on signal %d (core dumped)\n";
 static	const char lognocoredump[] =
     "pid %d (%s), uid %d: exited on signal %d (core not dumped, err = %d)\n";
 /*
  * signal_init:
+ *
  * 	Initialize global signal-related data structures.
  */
 void
 signal_init(void)
+{
 	sigactspool_allocator.pa_pagesz = (PAGE_SIZE)*2;
 	sigacts_cache = pool_cache_init(sizeof(struct sigacts), 0, 0, 0,
 	    "sigacts", sizeof(struct sigacts) > PAGE_SIZE ?
 	    &sigactspool_allocator : NULL, IPL_NONE, NULL, NULL, NULL);
 	siginfo_cache = pool_cache_init(sizeof(siginfo_t), 0, 0, 0,
 	    "siginfo", NULL, IPL_NONE, NULL, NULL, NULL);
 	ksiginfo_cache = pool_cache_init(sizeof(ksiginfo_t), 0, 0, 0,
 	    "ksiginfo", NULL, IPL_VM, NULL, NULL, NULL);
 	exechook_establish(ksiginfo_exechook, NULL);
 	callout_init(&proc_stop_ch, CALLOUT_MPSAFE);
 	callout_setfunc(&proc_stop_ch, proc_stop_callout, NULL);
+}
 /*
  * sigacts_poolpage_alloc:
+ *
  *	 Allocate a page for the sigacts memory pool.
  */
 static void *
 sigacts_poolpage_alloc(struct pool *pp, int flags)
+{
 	return (void *)uvm_km_alloc(kernel_map,
 	    (PAGE_SIZE)*2, (PAGE_SIZE)*2,
 	    ((flags & PR_WAITOK) ? 0 : UVM_KMF_NOWAIT | UVM_KMF_TRYLOCK)
 	    | UVM_KMF_WIRED);
+}
 /*
  * sigacts_poolpage_free:
+ *
  *	 Free a page on behalf of the sigacts memory pool.
  */
 static void
 sigacts_poolpage_free(struct pool *pp, void *v)
+{
         uvm_km_free(kernel_map, (vaddr_t)v, (PAGE_SIZE)*2, UVM_KMF_WIRED);
+}
 /*
  * sigactsinit:
+ *
  *	 Create an initial sigctx structure, using the same signal state as
  *	 p.  If 'share' is set, share the sigctx_proc part, otherwise just
  *	 copy it from parent.
  */
 struct sigacts *
 sigactsinit(struct proc *pp, int share)
+{
 	struct sigacts *ps = pp->p_sigacts, *ps2;
 	if (__predict_false(share)) {
 		atomic_inc_uint(&ps->sa_refcnt);
 		return ps;
+	}
 	ps2 = pool_cache_get(sigacts_cache, PR_WAITOK);
 	mutex_init(&ps2->sa_mutex, MUTEX_DEFAULT, IPL_SCHED);
 	ps2->sa_refcnt = 1;
 	mutex_enter(&ps->sa_mutex);
 	memcpy(ps2->sa_sigdesc, ps->sa_sigdesc, sizeof(ps2->sa_sigdesc));
 	mutex_exit(&ps->sa_mutex);
 	return ps2;
+}
 /*
  * sigactsunshare:
+ *
  *	Make this process not share its sigctx, maintaining all
  *	signal state.
  */
 void
 sigactsunshare(struct proc *p)
+{
 	struct sigacts *ps, *oldps = p->p_sigacts;
 	if (__predict_true(oldps->sa_refcnt == 1))
 		return;
 	ps = pool_cache_get(sigacts_cache, PR_WAITOK);
 	mutex_init(&ps->sa_mutex, MUTEX_DEFAULT, IPL_SCHED);
 	memset(ps->sa_sigdesc, 0, sizeof(ps->sa_sigdesc));
 	ps->sa_refcnt = 1;
 	p->p_sigacts = ps;
 	sigactsfree(oldps);
+}
 /*
  * sigactsfree;
+ *
  *	Release a sigctx structure.
  */
 void
 sigactsfree(struct sigacts *ps)
+{
 	if (atomic_dec_uint_nv(&ps->sa_refcnt) == 0) {
 		mutex_destroy(&ps->sa_mutex);
 		pool_cache_put(sigacts_cache, ps);
+	}
+}
 /*
  * siginit:
+ *
  *	Initialize signal state for process 0; set to ignore signals that
  *	are ignored by default and disable the signal stack.  Locking not
  *	required as the system is still cold.
  */
 void
 siginit(struct proc *p)
+{
 	struct lwp *l;
 	struct sigacts *ps;
 	int signo, prop;
 	ps = p->p_sigacts;
 	sigemptyset(&contsigmask);
 	sigemptyset(&stopsigmask);
 	sigemptyset(&sigcantmask);
 	for (signo = 1; signo < NSIG; signo++) {
 		prop = sigprop[signo];
 		if (prop & SA_CONT)
 			sigaddset(&contsigmask, signo);
 		if (prop & SA_STOP)
 			sigaddset(&stopsigmask, signo);
 		if (prop & SA_CANTMASK)
 			sigaddset(&sigcantmask, signo);
 		if (prop & SA_IGNORE && signo != SIGCONT)
 			sigaddset(&p->p_sigctx.ps_sigignore, signo);
 		sigemptyset(&SIGACTION_PS(ps, signo).sa_mask);
 		SIGACTION_PS(ps, signo).sa_flags = SA_RESTART;
+	}
 	sigemptyset(&p->p_sigctx.ps_sigcatch);
 	p->p_sflag &= ~PS_NOCLDSTOP;
 	ksiginfo_queue_init(&p->p_sigpend.sp_info);
 	sigemptyset(&p->p_sigpend.sp_set);
 	/*
 	 * Reset per LWP state.
 	 */
 	l = LIST_FIRST(&p->p_lwps);
 	l->l_sigwaited = NULL;
 	l->l_sigstk.ss_flags = SS_DISABLE;
 	l->l_sigstk.ss_size = 0;
 	l->l_sigstk.ss_sp = 0;
 	ksiginfo_queue_init(&l->l_sigpend.sp_info);
 	sigemptyset(&l->l_sigpend.sp_set);
 	/* One reference. */
 	ps->sa_refcnt = 1;
+}
 /*
  * execsigs:
+ *
  *	Reset signals for an exec of the specified process.
  */
 void
 execsigs(struct proc *p)
+{
 	struct sigacts *ps;
 	struct lwp *l;
 	int signo, prop;
 	sigset_t tset;
 	ksiginfoq_t kq;
 	KASSERT(p->p_nlwps == 1);
 	sigactsunshare(p);
 	ps = p->p_sigacts;
 	/*
 	 * Reset caught signals.  Held signals remain held through
 	 * l->l_sigmask (unless they were caught, and are now ignored
 	 * by default).
+	 *
 	 * No need to lock yet, the process has only one LWP and
 	 * at this point the sigacts are private to the process.
 	 */
 	sigemptyset(&tset);
 	for (signo = 1; signo < NSIG; signo++) {
 		if (sigismember(&p->p_sigctx.ps_sigcatch, signo)) {
 			prop = sigprop[signo];
 			if (prop & SA_IGNORE) {
 				if ((prop & SA_CONT) == 0)
 					sigaddset(&p->p_sigctx.ps_sigignore,
 					    signo);
 				sigaddset(&tset, signo);
+			}
 			SIGACTION_PS(ps, signo).sa_handler = SIG_DFL;
+		}
 		sigemptyset(&SIGACTION_PS(ps, signo).sa_mask);
 		SIGACTION_PS(ps, signo).sa_flags = SA_RESTART;
+	}
 	ksiginfo_queue_init(&kq);
 	mutex_enter(p->p_lock);
 	sigclearall(p, &tset, &kq);
 	sigemptyset(&p->p_sigctx.ps_sigcatch);
 	/*
 	 * Reset no zombies if child dies flag as Solaris does.
 	 */
 	p->p_flag &= ~(PK_NOCLDWAIT | PK_CLDSIGIGN);
 	if (SIGACTION_PS(ps, SIGCHLD).sa_handler == SIG_IGN)
 		SIGACTION_PS(ps, SIGCHLD).sa_handler = SIG_DFL;
 	/*
 	 * Reset per-LWP state.
 	 */
 	l = LIST_FIRST(&p->p_lwps);
 	l->l_sigwaited = NULL;
 	l->l_sigstk.ss_flags = SS_DISABLE;
 	l->l_sigstk.ss_size = 0;
 	l->l_sigstk.ss_sp = 0;
 	ksiginfo_queue_init(&l->l_sigpend.sp_info);
 	sigemptyset(&l->l_sigpend.sp_set);
 	mutex_exit(p->p_lock);
 	ksiginfo_queue_drain(&kq);
+}
 /*
  * ksiginfo_exechook:
+ *
  *	Free all pending ksiginfo entries from a process on exec.
  *	Additionally, drain any unused ksiginfo structures in the
  *	system back to the pool.
+ *
  *	XXX This should not be a hook, every process has signals.
  */
 static void
 ksiginfo_exechook(struct proc *p, void *v)
+{
 	ksiginfoq_t kq;
 	ksiginfo_queue_init(&kq);
 	mutex_enter(p->p_lock);
 	sigclearall(p, NULL, &kq);
 	mutex_exit(p->p_lock);
 	ksiginfo_queue_drain(&kq);
+}
 /*
  * ksiginfo_alloc:
+ *
  *	Allocate a new ksiginfo structure from the pool, and optionally copy
  *	an existing one.  If the existing ksiginfo_t is from the pool, and
  *	has not been queued somewhere, then just return it.  Additionally,
  *	if the existing ksiginfo_t does not contain any information beyond
  *	the signal number, then just return it.
  */
 ksiginfo_t *
 ksiginfo_alloc(struct proc *p, ksiginfo_t *ok, int flags)
+{
 	ksiginfo_t *kp;
 	if (ok != NULL) {
 		if ((ok->ksi_flags & (KSI_QUEUED | KSI_FROMPOOL)) ==
 		    KSI_FROMPOOL)
 		    	return ok;
 		if (KSI_EMPTY_P(ok))
 			return ok;
+	}
 	kp = pool_cache_get(ksiginfo_cache, flags);
 	if (kp == NULL) {
 #ifdef DIAGNOSTIC
 		printf("Out of memory allocating ksiginfo for pid %d\n",
 		    p->p_pid);
 #endif
 		return NULL;
+	}
 	if (ok != NULL) {
 		memcpy(kp, ok, sizeof(*kp));
 		kp->ksi_flags &= ~KSI_QUEUED;
 	} else
 		KSI_INIT_EMPTY(kp);
 	kp->ksi_flags |= KSI_FROMPOOL;
 	return kp;
+}
 /*
  * ksiginfo_free:
+ *
  *	If the given ksiginfo_t is from the pool and has not been queued,
  *	then free it.
  */
 void
 ksiginfo_free(ksiginfo_t *kp)
+{
 	if ((kp->ksi_flags & (KSI_QUEUED | KSI_FROMPOOL)) != KSI_FROMPOOL)
 		return;
 	pool_cache_put(ksiginfo_cache, kp);
+}
 /*
  * ksiginfo_queue_drain:
+ *
  *	Drain a non-empty ksiginfo_t queue.
  */
 void
 ksiginfo_queue_drain0(ksiginfoq_t *kq)
+{
 	ksiginfo_t *ksi;
 	KASSERT(!CIRCLEQ_EMPTY(kq));
 	while (!CIRCLEQ_EMPTY(kq)) {
 		ksi = CIRCLEQ_FIRST(kq);
 		CIRCLEQ_REMOVE(kq, ksi, ksi_list);
 		pool_cache_put(ksiginfo_cache, ksi);
+	}
+}
 static bool
 siggetinfo(sigpend_t *sp, ksiginfo_t *out, int signo)
+{
 	ksiginfo_t *ksi;
 	if (sp == NULL)
 		goto out;
 	/* Find siginfo and copy it out. */
 	CIRCLEQ_FOREACH(ksi, &sp->sp_info, ksi_list) {
 		if (ksi->ksi_signo != signo)
 			continue;
 		CIRCLEQ_REMOVE(&sp->sp_info, ksi, ksi_list);
 		KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0);
 		KASSERT((ksi->ksi_flags & KSI_QUEUED) != 0);
 		ksi->ksi_flags &= ~KSI_QUEUED;
 		if (out != NULL) {
 			memcpy(out, ksi, sizeof(*out));
 			out->ksi_flags &= ~(KSI_FROMPOOL | KSI_QUEUED);
+		}
 		ksiginfo_free(ksi);	/* XXXSMP */
 		return true;
+	}
 out:
 	/* If there is no siginfo, then manufacture it. */
 	if (out != NULL) {
 		KSI_INIT(out);
 		out->ksi_info._signo = signo;
 		out->ksi_info._code = SI_NOINFO;
+	}
 	return false;
+}
 /*
  * sigget:
+ *
  *	Fetch the first pending signal from a set.  Optionally, also fetch
  *	or manufacture a ksiginfo element.  Returns the number of the first
  *	pending signal, or zero.
  */
 int
 sigget(sigpend_t *sp, ksiginfo_t *out, int signo, const sigset_t *mask)
+{
 	sigset_t tset;
 	/* If there's no pending set, the signal is from the debugger. */
 	if (sp == NULL)
 		goto out;
 	/* Construct mask from signo, and 'mask'. */
 	if (signo == 0) {
 		if (mask != NULL) {
 			tset = *mask;
 			__sigandset(&sp->sp_set, &tset);
 		} else
 			tset = sp->sp_set;
 		/* If there are no signals pending, that's it. */
 		if ((signo = firstsig(&tset)) == 0)
 			goto out;
 	} else {
 		KASSERT(sigismember(&sp->sp_set, signo));
+	}
 	sigdelset(&sp->sp_set, signo);
 out:
 	(void)siggetinfo(sp, out, signo);
 	return signo;
+}
 /*
  * sigput:
+ *
  *	Append a new ksiginfo element to the list of pending ksiginfo's.
  */
 static void
 sigput(sigpend_t *sp, struct proc *p, ksiginfo_t *ksi)
+{
 	ksiginfo_t *kp;
 	KASSERT(mutex_owned(p->p_lock));
 	KASSERT((ksi->ksi_flags & KSI_QUEUED) == 0);
 	sigaddset(&sp->sp_set, ksi->ksi_signo);
 	/*
 	 * If there is no siginfo, we are done.
 	 */
 	if (KSI_EMPTY_P(ksi))
 		return;
 	KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0);
 #ifdef notyet	/* XXX: QUEUING */
 	if (ksi->ksi_signo < SIGRTMIN)
 #endif
+	{
 		CIRCLEQ_FOREACH(kp, &sp->sp_info, ksi_list) {
 			if (kp->ksi_signo == ksi->ksi_signo) {
 				KSI_COPY(ksi, kp);
 				kp->ksi_flags |= KSI_QUEUED;
 				return;
+			}
+		}
+	}
 	ksi->ksi_flags |= KSI_QUEUED;
 	CIRCLEQ_INSERT_TAIL(&sp->sp_info, ksi, ksi_list);
+}
 /*
  * sigclear:
+ *
  *	Clear all pending signals in the specified set.
  */
 void
 sigclear(sigpend_t *sp, const sigset_t *mask, ksiginfoq_t *kq)
+{
 	ksiginfo_t *ksi, *next;
 	if (mask == NULL)
 		sigemptyset(&sp->sp_set);
 	else
 		sigminusset(mask, &sp->sp_set);
 	ksi = CIRCLEQ_FIRST(&sp->sp_info);
 	for (; ksi != (void *)&sp->sp_info; ksi = next) {
 		next = CIRCLEQ_NEXT(ksi, ksi_list);
 		if (mask == NULL || sigismember(mask, ksi->ksi_signo)) {
 			CIRCLEQ_REMOVE(&sp->sp_info, ksi, ksi_list);
 			KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0);
 			KASSERT((ksi->ksi_flags & KSI_QUEUED) != 0);
 			CIRCLEQ_INSERT_TAIL(kq, ksi, ksi_list);
+		}
+	}
+}
 /*
  * sigclearall:
+ *
  *	Clear all pending signals in the specified set from a process and
  *	its LWPs.
  */
 void
 sigclearall(struct proc *p, const sigset_t *mask, ksiginfoq_t *kq)
+{
 	struct lwp *l;
 	KASSERT(mutex_owned(p->p_lock));
 	sigclear(&p->p_sigpend, mask, kq);
 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {
 		sigclear(&l->l_sigpend, mask, kq);
+	}
+}
 /*
  * sigispending:
+ *
  *	Return the first signal number if there are pending signals for the
  *	current LWP.  May be called unlocked provided that LW_PENDSIG is set,
  *	and that the signal has been posted to the appopriate queue before
  *	LW_PENDSIG is set.
  */
 int
 sigispending(struct lwp *l, int signo)
+{
 	struct proc *p = l->l_proc;
 	sigset_t tset;
 	membar_consumer();
 	tset = l->l_sigpend.sp_set;
 	sigplusset(&p->p_sigpend.sp_set, &tset);
 	sigminusset(&p->p_sigctx.ps_sigignore, &tset);
 	sigminusset(&l->l_sigmask, &tset);
 	if (signo == 0) {
 		if ((signo = firstsig(&tset)) != 0)
 			return signo;
 	} else if (sigismember(&tset, signo))
 		return signo;
 	return 0;
+}
 /*
  * siginfo_alloc:
+ *
  *	 Allocate a new siginfo_t structure from the pool.
  */
 siginfo_t *
 siginfo_alloc(int flags)
+{
 	return pool_cache_get(siginfo_cache, flags);
+}
 /*
  * siginfo_free:
+ *
  *	 Return a siginfo_t structure to the pool.
  */
 void
 siginfo_free(void *arg)
+{
 	pool_cache_put(siginfo_cache, arg);
+}
 void
 getucontext(struct lwp *l, ucontext_t *ucp)
+{
 	struct proc *p = l->l_proc;
 	KASSERT(mutex_owned(p->p_lock));
 	ucp->uc_flags = 0;
 	ucp->uc_link = l->l_ctxlink;
 #if KERN_SA
 	if (p->p_sa != NULL)
 		ucp->uc_sigmask = p->p_sa->sa_sigmask;
 	else
 #endif /* KERN_SA */
 		ucp->uc_sigmask = l->l_sigmask;
 	ucp->uc_flags |= _UC_SIGMASK;
 	/*
 	 * The (unsupplied) definition of the `current execution stack'
 	 * in the System V Interface Definition appears to allow returning
 	 * the main context stack.
 	 */
 	if ((l->l_sigstk.ss_flags & SS_ONSTACK) == 0) {
 		ucp->uc_stack.ss_sp = (void *)l->l_proc->p_stackbase;
 		ucp->uc_stack.ss_size = ctob(l->l_proc->p_vmspace->vm_ssize);
 		ucp->uc_stack.ss_flags = 0;	/* XXX, def. is Very Fishy */
 	} else {
 		/* Simply copy alternate signal execution stack. */
 		ucp->uc_stack = l->l_sigstk;
+	}
 	ucp->uc_flags |= _UC_STACK;
 	mutex_exit(p->p_lock);
 	cpu_getmcontext(l, &ucp->uc_mcontext, &ucp->uc_flags);
 	mutex_enter(p->p_lock);
+}
 /*
  * getucontext_sa:
  *      Get a ucontext_t for use in SA upcall generation.
  * Teweaked version of getucontext(). We 1) do not take p_lock, 2)
  * fudge things with uc_link (which is usually NULL for libpthread
  * code), and 3) we report an empty signal mask.
  */
 void
 getucontext_sa(struct lwp *l, ucontext_t *ucp)
+{
 	ucp->uc_flags = 0;
 	ucp->uc_link = l->l_ctxlink;
 	sigemptyset(&ucp->uc_sigmask);
 	ucp->uc_flags |= _UC_SIGMASK;
 	/*
 	 * The (unsupplied) definition of the `current execution stack'
 	 * in the System V Interface Definition appears to allow returning
 	 * the main context stack.
 	 */
 	if ((l->l_sigstk.ss_flags & SS_ONSTACK) == 0) {
 		ucp->uc_stack.ss_sp = (void *)l->l_proc->p_stackbase;
 		ucp->uc_stack.ss_size = ctob(l->l_proc->p_vmspace->vm_ssize);
 		ucp->uc_stack.ss_flags = 0;	/* XXX, def. is Very Fishy */
 	} else {
 		/* Simply copy alternate signal execution stack. */
 		ucp->uc_stack = l->l_sigstk;
+	}
 	ucp->uc_flags |= _UC_STACK;
 	cpu_getmcontext(l, &ucp->uc_mcontext, &ucp->uc_flags);
+}
 int
 setucontext(struct lwp *l, const ucontext_t *ucp)
+{
 	struct proc *p = l->l_proc;
 	int error;
 	KASSERT(mutex_owned(p->p_lock));
 	if ((ucp->uc_flags & _UC_SIGMASK) != 0) {
 		error = sigprocmask1(l, SIG_SETMASK, &ucp->uc_sigmask, NULL);
 		if (error != 0)
 			return error;
+	}
 	mutex_exit(p->p_lock);
 	error = cpu_setmcontext(l, &ucp->uc_mcontext, ucp->uc_flags);
 	mutex_enter(p->p_lock);
 	if (error != 0)
 		return (error);
 	l->l_ctxlink = ucp->uc_link;
 	/*
 	 * If there was stack information, update whether or not we are
 	 * still running on an alternate signal stack.
 	 */
 	if ((ucp->uc_flags & _UC_STACK) != 0) {
 		if (ucp->uc_stack.ss_flags & SS_ONSTACK)
 			l->l_sigstk.ss_flags |= SS_ONSTACK;
 		else
 			l->l_sigstk.ss_flags &= ~SS_ONSTACK;
+	}
 	return 0;
+}
 /*
  * Common code for kill process group/broadcast kill.  cp is calling
  * process.
  */
 int
 killpg1(struct lwp *l, ksiginfo_t *ksi, int pgid, int all)
+{
 	struct proc	*p, *cp;
 	kauth_cred_t	pc;
 	struct pgrp	*pgrp;
 	int		nfound;
 	int		signo = ksi->ksi_signo;
 	cp = l->l_proc;
 	pc = l->l_cred;
 	nfound = 0;
 	mutex_enter(proc_lock);
 	if (all) {
 		/*
 		 * broadcast
 		 */
 		PROCLIST_FOREACH(p, &allproc) {
 			if (p->p_pid <= 1 || p == cp ||
 			    p->p_flag & (PK_SYSTEM|PK_MARKER))
 				continue;
 			mutex_enter(p->p_lock);
 			if (kauth_authorize_process(pc,
 			    KAUTH_PROCESS_SIGNAL, p, KAUTH_ARG(signo), NULL,
 			    NULL) == 0) {
 				nfound++;
 				if (signo)
 					kpsignal2(p, ksi);
+			}
 			mutex_exit(p->p_lock);
+		}
 	} else {
 		if (pgid == 0)
 			/*
 			 * zero pgid means send to my process group.
 			 */
 			pgrp = cp->p_pgrp;
 		else {
 			pgrp = pg_find(pgid, PFIND_LOCKED);
 			if (pgrp == NULL)
 				goto out;
+		}
 		LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
 			if (p->p_pid <= 1 || p->p_flag & PK_SYSTEM)
 				continue;
 			mutex_enter(p->p_lock);
 			if (kauth_authorize_process(pc, KAUTH_PROCESS_SIGNAL,
 			    p, KAUTH_ARG(signo), NULL, NULL) == 0) {
 				nfound++;
 				if (signo && P_ZOMBIE(p) == 0)
 					kpsignal2(p, ksi);
+			}
 			mutex_exit(p->p_lock);
+		}
+	}
   out:
 	mutex_exit(proc_lock);
 	return (nfound ? 0 : ESRCH);
+}
 /*
  * Send a signal to a process group. If checktty is 1, limit to members
  * which have a controlling terminal.
  */
 void
 pgsignal(struct pgrp *pgrp, int sig, int checkctty)
+{
 	ksiginfo_t ksi;
 	KASSERT(!cpu_intr_p());
 	KASSERT(mutex_owned(proc_lock));
 	KSI_INIT_EMPTY(&ksi);
 	ksi.ksi_signo = sig;
 	kpgsignal(pgrp, &ksi, NULL, checkctty);
+}
 void
 kpgsignal(struct pgrp *pgrp, ksiginfo_t *ksi, void *data, int checkctty)
+{
 	struct proc *p;
 	KASSERT(!cpu_intr_p());
 	KASSERT(mutex_owned(proc_lock));
 	if (__predict_false(pgrp == 0))
 		return;
 	LIST_FOREACH(p, &pgrp->pg_members, p_pglist)
 		if (checkctty == 0 || p->p_lflag & PL_CONTROLT)
 			kpsignal(p, ksi, data);
+}
 /*
  * Send a signal caused by a trap to the current LWP.  If it will be caught
  * immediately, deliver it with correct code.  Otherwise, post it normally.
  */
 void
 trapsignal(struct lwp *l, ksiginfo_t *ksi)
+{
 	struct proc	*p;
 	struct sigacts	*ps;
 	int signo = ksi->ksi_signo;
 	sigset_t *mask;
 	KASSERT(KSI_TRAP_P(ksi));
 	ksi->ksi_lid = l->l_lid;
 	p = l->l_proc;
 	KASSERT(!cpu_intr_p());
 	mutex_enter(proc_lock);
 	mutex_enter(p->p_lock);
 	mask = (p->p_sa != NULL) ? &p->p_sa->sa_sigmask : &l->l_sigmask;
 	ps = p->p_sigacts;
 	if ((p->p_slflag & PSL_TRACED) == 0 &&
 	    sigismember(&p->p_sigctx.ps_sigcatch, signo) &&
 	    !sigismember(mask, signo)) {
 		mutex_exit(proc_lock);
 		l->l_ru.ru_nsignals++;
 		kpsendsig(l, ksi, mask);
 		mutex_exit(p->p_lock);
 		ktrpsig(signo, SIGACTION_PS(ps, signo).sa_handler,
 		    mask, ksi);
 	} else {
 		/* XXX for core dump/debugger */
 		p->p_sigctx.ps_lwp = l->l_lid;
 		p->p_sigctx.ps_signo = ksi->ksi_signo;
 		p->p_sigctx.ps_code = ksi->ksi_trap;
 		kpsignal2(p, ksi);
 		mutex_exit(p->p_lock);
 		mutex_exit(proc_lock);
+	}
+}
 /*
  * Fill in signal information and signal the parent for a child status change.
  */
 void
 child_psignal(struct proc *p, int mask)
+{
 	ksiginfo_t ksi;
 	struct proc *q;
 	int xstat;
 	KASSERT(mutex_owned(proc_lock));
 	KASSERT(mutex_owned(p->p_lock));
 	xstat = p->p_xstat;
 	KSI_INIT(&ksi);
 	ksi.ksi_signo = SIGCHLD;
 	ksi.ksi_code = (xstat == SIGCONT ? CLD_CONTINUED : CLD_STOPPED);
 	ksi.ksi_pid = p->p_pid;
 	ksi.ksi_uid = kauth_cred_geteuid(p->p_cred);
 	ksi.ksi_status = xstat;
 	ksi.ksi_utime = p->p_stats->p_ru.ru_utime.tv_sec;
 	ksi.ksi_stime = p->p_stats->p_ru.ru_stime.tv_sec;
 	q = p->p_pptr;
 	mutex_exit(p->p_lock);
 	mutex_enter(q->p_lock);
 	if ((q->p_sflag & mask) == 0)
 		kpsignal2(q, &ksi);
 	mutex_exit(q->p_lock);
 	mutex_enter(p->p_lock);
+}
 void
 psignal(struct proc *p, int signo)
+{
 	ksiginfo_t ksi;
 	KASSERT(!cpu_intr_p());
 	KASSERT(mutex_owned(proc_lock));
 	KSI_INIT_EMPTY(&ksi);
 	ksi.ksi_signo = signo;
 	mutex_enter(p->p_lock);
 	kpsignal2(p, &ksi);
 	mutex_exit(p->p_lock);
+}
 void
 kpsignal(struct proc *p, ksiginfo_t *ksi, void *data)
+{
 	fdfile_t *ff;
 	file_t *fp;
 	KASSERT(!cpu_intr_p());
 	KASSERT(mutex_owned(proc_lock));
 	if ((p->p_sflag & PS_WEXIT) == 0 && data) {
 		size_t fd;
 		filedesc_t *fdp = p->p_fd;
 		/* XXXSMP locking */
 		ksi->ksi_fd = -1;
 		for (fd = 0; fd < fdp->fd_nfiles; fd++) {
 			if ((ff = fdp->fd_ofiles[fd]) == NULL)
 				continue;
 			if ((fp = ff->ff_file) == NULL)
 				continue;
 			if (fp->f_data == data) {
 				ksi->ksi_fd = fd;
 				break;
+			}
+		}
+	}
 	mutex_enter(p->p_lock);
 	kpsignal2(p, ksi);
 	mutex_exit(p->p_lock);
+}
 /*
  * sigismasked:
+ *
  *	 Returns true if signal is ignored or masked for the specified LWP.
  */
 int
 sigismasked(struct lwp *l, int sig)
+{
 	struct proc *p = l->l_proc;
 	return (sigismember(&p->p_sigctx.ps_sigignore, sig) ||
 	    sigismember(&l->l_sigmask, sig)
 #if KERN_SA
 	    || ((p->p_sa != NULL) && sigismember(&p->p_sa->sa_sigmask, sig))
 #endif /* KERN_SA */
 	    );
+}
 /*
  * sigpost:
+ *
  *	 Post a pending signal to an LWP.  Returns non-zero if the LWP may
  *	 be able to take the signal.
  */
 static int
 sigpost(struct lwp *l, sig_t action, int prop, int sig, int idlecheck)
+{
 	int rv, masked;
 	struct proc *p = l->l_proc;
 	KASSERT(mutex_owned(p->p_lock));
 	/*
 	 * If the LWP is on the way out, sigclear() will be busy draining all
 	 * pending signals.  Don't give it more.
 	 */
 	if (l->l_refcnt == 0)
 		return 0;
 	/*
 	 * Have the LWP check for signals.  This ensures that even if no LWP
 	 * is found to take the signal immediately, it should be taken soon.
 	 */
 	lwp_lock(l);
 	l->l_flag |= LW_PENDSIG;
 	/*
 	 * When sending signals to SA processes, we first try to find an
 	 * idle VP to take it.
 	 */
 	if (idlecheck && (l->l_flag & (LW_SA_IDLE | LW_SA_YIELD)) == 0) {
 		lwp_unlock(l);
 		return 0;
+	}
 	/*
 	 * SIGCONT can be masked, but if LWP is stopped, it needs restart.
 	 * Note: SIGKILL and SIGSTOP cannot be masked.
 	 */
 #if KERN_SA
 	if (p->p_sa != NULL)
 		masked = sigismember(&p->p_sa->sa_sigmask, sig);
 	else
 #endif
 		masked = sigismember(&l->l_sigmask, sig);
 	if (masked && ((prop & SA_CONT) == 0 || l->l_stat != LSSTOP)) {
 		lwp_unlock(l);
 		return 0;
+	}
 	/*
 	 * If killing the process, make it run fast.
 	 */
 	if (__predict_false((prop & SA_KILL) != 0) &&
 	    action == SIG_DFL && l->l_priority < MAXPRI_USER) {
 		KASSERT(l->l_class == SCHED_OTHER);
 		lwp_changepri(l, MAXPRI_USER);
+	}
 	/*
 	 * If the LWP is running or on a run queue, then we win.  If it's
 	 * sleeping interruptably, wake it and make it take the signal.  If
 	 * the sleep isn't interruptable, then the chances are it will get
 	 * to see the signal soon anyhow.  If suspended, it can't take the
 	 * signal right now.  If it's LWP private or for all LWPs, save it
 	 * for later; otherwise punt.
 	 */
 	rv = 0;
 	switch (l->l_stat) {
 	case LSRUN:
 	case LSONPROC:
 		lwp_need_userret(l);
 		rv = 1;
 		break;
 	case LSSLEEP:
 		if ((l->l_flag & LW_SINTR) != 0) {
 			/* setrunnable() will release the lock. */
 			setrunnable(l);
 			return 1;
+		}
 		break;
 	case LSSUSPENDED:
 		if ((prop & SA_KILL) != 0) {
 			/* lwp_continue() will release the lock. */
 			lwp_continue(l);
 			return 1;
+		}
 		break;
 	case LSSTOP:
 		if ((prop & SA_STOP) != 0)
 			break;
 		/*
 		 * If the LWP is stopped and we are sending a continue
 		 * signal, then start it again.
 		 */
 		if ((prop & SA_CONT) != 0) {
 			if (l->l_wchan != NULL) {
 				l->l_stat = LSSLEEP;
 				p->p_nrlwps++;
 				rv = 1;
 				break;
+			}
 			/* setrunnable() will release the lock. */
 			setrunnable(l);
 			return 1;
 		} else if (l->l_wchan == NULL || (l->l_flag & LW_SINTR) != 0) {
 			/* setrunnable() will release the lock. */
 			setrunnable(l);
 			return 1;
+		}
 		break;
 	default:
 		break;
+	}
 	lwp_unlock(l);
 	return rv;
+}
 /*
  * Notify an LWP that it has a pending signal.
  */
 void
 signotify(struct lwp *l)
+{
 	KASSERT(lwp_locked(l, NULL));
 	l->l_flag |= LW_PENDSIG;
 	lwp_need_userret(l);
+}
 /*
  * Find an LWP within process p that is waiting on signal ksi, and hand
  * it on.
  */
 static int
 sigunwait(struct proc *p, const ksiginfo_t *ksi)
+{
 	struct lwp *l;
 	int signo;
 	KASSERT(mutex_owned(p->p_lock));
 	signo = ksi->ksi_signo;
 	if (ksi->ksi_lid != 0) {
 		/*
 		 * Signal came via _lwp_kill().  Find the LWP and see if
 		 * it's interested.
 		 */
 		if ((l = lwp_find(p, ksi->ksi_lid)) == NULL)
 			return 0;
 		if (l->l_sigwaited == NULL ||
 		    !sigismember(&l->l_sigwaitset, signo))
 			return 0;
 	} else {
 		/*
 		 * Look for any LWP that may be interested.
 		 */
 		LIST_FOREACH(l, &p->p_sigwaiters, l_sigwaiter) {
 			KASSERT(l->l_sigwaited != NULL);
 			if (sigismember(&l->l_sigwaitset, signo))
 				break;
+		}
+	}
 	if (l != NULL) {
 		l->l_sigwaited->ksi_info = ksi->ksi_info;
 		l->l_sigwaited = NULL;
 		LIST_REMOVE(l, l_sigwaiter);
 		cv_signal(&l->l_sigcv);
 		return 1;
+	}
 	return 0;
+}
 /*
  * Send the signal to the process.  If the signal has an action, the action
  * is usually performed by the target process rather than the caller; we add
  * the signal to the set of pending signals for the process.
+ *
  * Exceptions:
  *   o When a stop signal is sent to a sleeping process that takes the
  *     default action, the process is stopped without awakening it.
  *   o SIGCONT restarts stopped processes (or puts them back to sleep)
  *     regardless of the signal action (eg, blocked or ignored).
+ *
  * Other ignored signals are discarded immediately.
  */
 void
 kpsignal2(struct proc *p, ksiginfo_t *ksi)
+{
 	int prop, lid, toall, signo = ksi->ksi_signo;
 	struct sigacts *sa;
 	struct lwp *l;
 	ksiginfo_t *kp;
 	ksiginfoq_t kq;
 	sig_t action;
 #ifdef KERN_SA
 	struct sadata_vp *vp;
 #endif
 	KASSERT(!cpu_intr_p());
 	KASSERT(mutex_owned(proc_lock));
 	KASSERT(mutex_owned(p->p_lock));
 	KASSERT((ksi->ksi_flags & KSI_QUEUED) == 0);
 	KASSERT(signo > 0 && signo < NSIG);
 	/*
 	 * If the process is being created by fork, is a zombie or is
 	 * exiting, then just drop the signal here and bail out.
 	 */
 	if (p->p_stat != SACTIVE && p->p_stat != SSTOP)
 		return;
 	/*
 	 * Notify any interested parties of the signal.
 	 */
 	KNOTE(&p->p_klist, NOTE_SIGNAL | signo);
 	/*
 	 * Some signals including SIGKILL must act on the entire process.
 	 */
 	kp = NULL;
 	prop = sigprop[signo];
 	toall = ((prop & SA_TOALL) != 0);
 	if (toall)
 		lid = 0;
 	else
 		lid = ksi->ksi_lid;
 	/*
 	 * If proc is traced, always give parent a chance.
 	 */
 	if (p->p_slflag & PSL_TRACED) {
 		action = SIG_DFL;
 		if (lid == 0) {
 			/*
 			 * If the process is being traced and the signal
 			 * is being caught, make sure to save any ksiginfo.
 			 */
 			if ((kp = ksiginfo_alloc(p, ksi, PR_NOWAIT)) == NULL)
 				return;
 			sigput(&p->p_sigpend, p, kp);
+		}
 	} else {
 		/*
 		 * If the signal was the result of a trap and is not being
 		 * caught, then reset it to default action so that the
 		 * process dumps core immediately.
 		 */
 		if (KSI_TRAP_P(ksi)) {
 			sa = p->p_sigacts;
 			mutex_enter(&sa->sa_mutex);
 			if (!sigismember(&p->p_sigctx.ps_sigcatch, signo)) {
 				sigdelset(&p->p_sigctx.ps_sigignore, signo);
 				SIGACTION(p, signo).sa_handler = SIG_DFL;
+			}
 			mutex_exit(&sa->sa_mutex);
+		}
 		/*
 		 * If the signal is being ignored, then drop it.  Note: we
 		 * don't set SIGCONT in ps_sigignore, and if it is set to
 		 * SIG_IGN, action will be SIG_DFL here.
 		 */
 		if (sigismember(&p->p_sigctx.ps_sigignore, signo))
 			return;
 		else if (sigismember(&p->p_sigctx.ps_sigcatch, signo))
 			action = SIG_CATCH;
 		else {
 			action = SIG_DFL;
 			/*
 			 * If sending a tty stop signal to a member of an
 			 * orphaned process group, discard the signal here if
 			 * the action is default; don't stop the process below
 			 * if sleeping, and don't clear any pending SIGCONT.
 			 */
 			if (prop & SA_TTYSTOP && p->p_pgrp->pg_jobc == 0)
 				return;
 			if (prop & SA_KILL && p->p_nice > NZERO)
 				p->p_nice = NZERO;
+		}
+	}
 	/*
 	 * If stopping or continuing a process, discard any pending
 	 * signals that would do the inverse.
 	 */
 	if ((prop & (SA_CONT | SA_STOP)) != 0) {
 		ksiginfo_queue_init(&kq);
 		if ((prop & SA_CONT) != 0)
 			sigclear(&p->p_sigpend, &stopsigmask, &kq);
 		if ((prop & SA_STOP) != 0)
 			sigclear(&p->p_sigpend, &contsigmask, &kq);
 		ksiginfo_queue_drain(&kq);	/* XXXSMP */
+	}
 	/*
 	 * If the signal doesn't have SA_CANTMASK (no override for SIGKILL,
 	 * please!), check if any LWPs are waiting on it.  If yes, pass on
 	 * the signal info.  The signal won't be processed further here.
 	 */
 	if ((prop & SA_CANTMASK) == 0 && !LIST_EMPTY(&p->p_sigwaiters) &&
 	    p->p_stat == SACTIVE && (p->p_sflag & PS_STOPPING) == 0 &&
 	    sigunwait(p, ksi))
 		return;
 	/*
 	 * XXXSMP Should be allocated by the caller, we're holding locks
 	 * here.
 	 */
 	if (kp == NULL && (kp = ksiginfo_alloc(p, ksi, PR_NOWAIT)) == NULL)
 		return;
 	/*
 	 * LWP private signals are easy - just find the LWP and post
 	 * the signal to it.
 	 */
 	if (lid != 0) {
 		l = lwp_find(p, lid);
 		if (l != NULL) {
 			sigput(&l->l_sigpend, p, kp);
 			membar_producer();
 			(void)sigpost(l, action, prop, kp->ksi_signo, 0);
+		}
 		goto out;
+	}
 	/*
 	 * Some signals go to all LWPs, even if posted with _lwp_kill()
 	 * or for an SA process.
 	 */
 	if (p->p_stat == SACTIVE && (p->p_sflag & PS_STOPPING) == 0) {
 		if ((p->p_slflag & PSL_TRACED) != 0)
 			goto deliver;
 		/*
 		 * If SIGCONT is default (or ignored) and process is
 		 * asleep, we are finished; the process should not
 		 * be awakened.
 		 */
 		if ((prop & SA_CONT) != 0 && action == SIG_DFL)
 			goto out;
 	} else {
 		/*
 		 * Process is stopped or stopping.
 		 * - If traced, then no action is needed, unless killing.
 		 * - Run the process only if sending SIGCONT or SIGKILL.
 		 */
 		if ((p->p_slflag & PSL_TRACED) != 0 && signo != SIGKILL) {
 			goto out;
+		}
 		if ((prop & SA_CONT) != 0 || signo == SIGKILL) {
 			/*
-			 * Re-adjust p_nstopchild if the process wasn't
+			 * Re-adjust p_nstopchild if the process was
-			 * collected by its parent.
+			 * stopped but not yet collected by its parent.
 			 */
 			if (p->p_stat == SSTOP && !p->p_waited)
 				p->p_pptr->p_nstopchild--;
 			p->p_stat = SACTIVE;
 			p->p_sflag &= ~PS_STOPPING;
 			if (!p->p_waited) {
 				p->p_pptr->p_nstopchild--;
 			if (p->p_slflag & PSL_TRACED) {
 				KASSERT(signo == SIGKILL);
 				goto deliver;
+			}
 			/*
 			 * Do not make signal pending if SIGCONT is default.
+			 *
 			 * If the process catches SIGCONT, let it handle the
 			 * signal itself (if waiting on event - process runs,
 			 * otherwise continues sleeping).
 			 */
 			if ((prop & SA_CONT) != 0 && action == SIG_DFL) {
 				KASSERT(signo != SIGKILL);
 				goto deliver;
+			}
 		} else if ((prop & SA_STOP) != 0) {
 			/*
 			 * Already stopped, don't need to stop again.
 			 * (If we did the shell could get confused.)
 			 */
 			goto out;
+		}
+	}
 	/*
 	 * Make signal pending.
 	 */
 	KASSERT((p->p_slflag & PSL_TRACED) == 0);
 	sigput(&p->p_sigpend, p, kp);
  deliver:
 	/*
 	 * Before we set LW_PENDSIG on any LWP, ensure that the signal is
 	 * visible on the per process list (for sigispending()).  This
 	 * is unlikely to be needed in practice, but...
 	 */
 	membar_producer();
 	/*
 	 * Try to find an LWP that can take the signal.
 	 */
 #if KERN_SA
 	if ((p->p_sa != NULL) && !toall) {
 		/*
 		 * If we're in this delivery path, we are delivering a
 		 * signal that needs to go to one thread in the process.
+		 *
 		 * In the SA case, we try to find an idle LWP that can take
 		 * the signal.  If that fails, only then do we consider
 		 * interrupting active LWPs. Since the signal's going to
 		 * just one thread, we need only look at "blessed" lwps,
 		 * so scan the vps for them.
 		 */
 		l = NULL;
 		SLIST_FOREACH(vp, &p->p_sa->sa_vps, savp_next) {
 			l = vp->savp_lwp;
 			if (sigpost(l, action, prop, kp->ksi_signo, 1))
 				break;
+		}
 		if (l == NULL) {
 			SLIST_FOREACH(vp, &p->p_sa->sa_vps, savp_next) {
 				l = vp->savp_lwp;
 				if (sigpost(l, action, prop, kp->ksi_signo, 0))
 					break;
+			}
+		}
 	} else	/* Catch the brace below if we're defined */
 #endif /* KERN_SA */
+	    {
 		LIST_FOREACH(l, &p->p_lwps, l_sibling)
 			if (sigpost(l, action, prop, kp->ksi_signo, 0) && !toall)
 				break;
+	}
  out:
  	/*
  	 * If the ksiginfo wasn't used, then bin it.  XXXSMP freeing memory
  	 * with locks held.  The caller should take care of this.
  	 */
  	ksiginfo_free(kp);
+}
 void
 kpsendsig(struct lwp *l, const ksiginfo_t *ksi, const sigset_t *mask)
+{
 	struct proc *p = l->l_proc;
 #ifdef KERN_SA
 	struct lwp *le, *li;
 	siginfo_t *si;
 	int f;
 #endif /* KERN_SA */
 	KASSERT(mutex_owned(p->p_lock));
 #ifdef KERN_SA
 	if (p->p_sflag & PS_SA) {
 		/* f indicates if we should clear LP_SA_NOBLOCK */
 		f = ~l->l_pflag & LP_SA_NOBLOCK;
 		l->l_pflag |= LP_SA_NOBLOCK;
 		mutex_exit(p->p_lock);
 		/* XXXUPSXXX What if not on sa_vp? */
 		/*
 		 * WRS: I think it won't matter, beyond the
 		 * question of what exactly we do with a signal
 		 * to a blocked user thread. Also, we try hard to always
 		 * send signals to blessed lwps, so we would only send
 		 * to a non-blessed lwp under special circumstances.
 		 */
 		si = siginfo_alloc(PR_WAITOK);
 		si->_info = ksi->ksi_info;
 		/*
 		 * Figure out if we're the innocent victim or the main
 		 * perpitrator.
 		 */
 		le = li = NULL;
 		if (KSI_TRAP_P(ksi))
 			le = l;
 		else
 			li = l;
 		if (sa_upcall(l, SA_UPCALL_SIGNAL | SA_UPCALL_DEFER, le, li,
 		    sizeof(*si), si, siginfo_free) != 0) {
 			siginfo_free(si);
 #if 0
 			if (KSI_TRAP_P(ksi))
 				/* XXX What dowe do here? The signal
 				 * didn't make it
 				 */;
 #endif
+		}
 		l->l_pflag ^= f;
 		mutex_enter(p->p_lock);
 		return;
+	}
 #endif /* KERN_SA */
 	(*p->p_emul->e_sendsig)(ksi, mask);
+}
 /*
  * Stop any LWPs sleeping interruptably.
  */
 static void
 proc_stop_lwps(struct proc *p)
+{
 	struct lwp *l;
 	KASSERT(mutex_owned(p->p_lock));
 	KASSERT((p->p_sflag & PS_STOPPING) != 0);
 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {
 		lwp_lock(l);
 		if (l->l_stat == LSSLEEP && (l->l_flag & LW_SINTR) != 0) {
 			l->l_stat = LSSTOP;
 			p->p_nrlwps--;
+		}
 		lwp_unlock(l);
+	}
+}
 /*
  * Finish stopping of a process.  Mark it stopped and notify the parent.
+ *
  * Drop p_lock briefly if PS_NOTIFYSTOP is set and ppsig is true.
  */
 static void
 proc_stop_done(struct proc *p, bool ppsig, int ppmask)
+{
 	KASSERT(mutex_owned(proc_lock));
 	KASSERT(mutex_owned(p->p_lock));
 	KASSERT((p->p_sflag & PS_STOPPING) != 0);
 	KASSERT(p->p_nrlwps == 0 || (p->p_nrlwps == 1 && p == curproc));
 	p->p_sflag &= ~PS_STOPPING;
 	p->p_stat = SSTOP;
 	p->p_waited = 0;
 	p->p_pptr->p_nstopchild++;
 	if ((p->p_sflag & PS_NOTIFYSTOP) != 0) {
 		if (ppsig) {
 			/* child_psignal drops p_lock briefly. */
 			child_psignal(p, ppmask);
+		}
 		cv_broadcast(&p->p_pptr->p_waitcv);
+	}
+}
 /*
  * Stop the current process and switch away when being stopped or traced.
  */
 static void
 sigswitch(bool ppsig, int ppmask, int signo)
+{
 	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);
 	/*
 	 * On entry we know that the process needs to stop.  If it's
 	 * the result of a 'sideways' stop signal that has been sourced
 	 * through issignal(), then stop other LWPs in the process too.
 	 */
 	if (p->p_stat == SACTIVE && (p->p_sflag & PS_STOPPING) == 0) {
 		KASSERT(signo != 0);
 		proc_stop(p, 1, signo);
 		KASSERT(p->p_nrlwps > 0);
+	}
 	/*
 	 * If we are the last live LWP, and the stop was a result of
 	 * a new signal, then signal the parent.
 	 */
 	if ((p->p_sflag & PS_STOPPING) != 0) {
 		if (!mutex_tryenter(proc_lock)) {
 			mutex_exit(p->p_lock);
 			mutex_enter(proc_lock);
 			mutex_enter(p->p_lock);
+		}
 		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, ppsig, ppmask);
+		}
 		mutex_exit(proc_lock);
+	}
 	/*
 	 * Unlock and switch away.
 	 */
 	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);
 	mutex_enter(p->p_lock);
+}
 /*
  * Check for a signal from the debugger.
  */
 static int
 sigchecktrace(void)
+{
 	struct lwp *l = curlwp;
 	struct proc *p = l->l_proc;
 	sigset_t *mask;
 	int signo;
 	KASSERT(mutex_owned(p->p_lock));
 	/* If there's a pending SIGKILL, process it immediately. */
 	if (sigismember(&p->p_sigpend.sp_set, SIGKILL))
 		return 0;
 	/*
 	 * If we are no longer being traced, or the parent didn't
 	 * give us a signal, look for more signals.
 	 */
 	if ((p->p_slflag & PSL_TRACED) == 0 || p->p_xstat == 0)
 		return 0;
 	/*
 	 * If the new signal is being masked, look for other signals.
 	 * `p->p_sigctx.ps_siglist |= mask' is done in setrunnable().
 	 */
 	signo = p->p_xstat;
 	p->p_xstat = 0;
 	mask = (p->p_sa != NULL) ? &p->p_sa->sa_sigmask : &l->l_sigmask;
 	if (sigismember(mask, signo))
 		signo = 0;
 	return signo;
+}
 /*
  * If the current process has received a signal (should be caught or cause
  * termination, should interrupt current syscall), return the signal number.
+ *
  * Stop signals with default action are processed immediately, then cleared;
  * they aren't returned.  This is checked after each entry to the system for
  * a syscall or trap.
+ *
  * We will also return -1 if the process is exiting and the current LWP must
  * follow suit.
  */
 int
 issignal(struct lwp *l)
+{
 	struct proc *p;
 	int signo, prop;
 	sigpend_t *sp;
 	sigset_t ss;
 	p = l->l_proc;
 	sp = NULL;
 	signo = 0;
 	KASSERT(p == curproc);
 	KASSERT(mutex_owned(p->p_lock));
 	for (;;) {
 		/* Discard any signals that we have decided not to take. */
 		if (signo != 0) {
 			(void)sigget(sp, NULL, signo, NULL);
+		}
 		/* Bail out if we do not own the virtual processor */
 		if (l->l_flag & LW_SA && l->l_savp->savp_lwp != l)
 			break;
 		/*
 		 * 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(true, PS_NOCLDSTOP, 0);
 			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
 		 * then per-process.
 		 */
 		if (signo == 0) {
 			sp = &l->l_sigpend;
 			ss = sp->sp_set;
 			if ((p->p_lflag & PL_PPWAIT) != 0)
 				sigminusset(&stopsigmask, &ss);
 			sigminusset(&l->l_sigmask, &ss);
 			if ((signo = firstsig(&ss)) == 0) {
 				sp = &p->p_sigpend;
 				ss = sp->sp_set;
 				if ((p->p_lflag & PL_PPWAIT) != 0)
 					sigminusset(&stopsigmask, &ss);
 				sigminusset(&l->l_sigmask, &ss);
 				if ((signo = firstsig(&ss)) == 0) {
 					/*
 					 * No signal pending - clear the
 					 * indicator and bail out.
 					 */
 					lwp_lock(l);
 					l->l_flag &= ~LW_PENDSIG;
 					lwp_unlock(l);
 					sp = NULL;
 					break;
+				}
+			}
+		}
 		/*
 		 * We should see pending but ignored signals only if
 		 * we are being traced.
 		 */
 		if (sigismember(&p->p_sigctx.ps_sigignore, signo) &&
 		    (p->p_slflag & PSL_TRACED) == 0) {
 			/* Discard the signal. */
 			continue;
+		}
 		/*
 		 * If traced, always stop, and stay stopped until released
 		 * by the debugger.  If the our parent process is waiting
 		 * for us, don't hang as we could deadlock.
 		 */
 		if ((p->p_slflag & PSL_TRACED) != 0 &&
 		    (p->p_lflag & PL_PPWAIT) == 0 && signo != SIGKILL) {
 			/*
 			 * Take the signal, but don't remove it from the
 			 * siginfo queue, because the debugger can send
 			 * it later.
 			 */
 			if (sp)
 				sigdelset(&sp->sp_set, signo);
 			p->p_xstat = signo;
 			/* Emulation-specific handling of signal trace */
 			if (p->p_emul->e_tracesig == NULL ||
 			    (*p->p_emul->e_tracesig)(p, signo) == 0)
 				sigswitch(!(p->p_slflag & PSL_FSTRACE), 0,
 				    signo);
 			/* Check for a signal from the debugger. */
 			if ((signo = sigchecktrace()) == 0)
 				continue;
 			/* Signals from the debugger are "out of band". */
 			sp = NULL;
+		}
 		prop = sigprop[signo];
 		/*
 		 * Decide whether the signal should be returned.
 		 */
 		switch ((long)SIGACTION(p, signo).sa_handler) {
 		case (long)SIG_DFL:
 			/*
 			 * Don't take default actions on system processes.
 			 */
 			if (p->p_pid <= 1) {
 #ifdef DIAGNOSTIC
 				/*
 				 * Are you sure you want to ignore SIGSEGV
 				 * in init? XXX
 				 */
 				printf_nolog("Process (pid %d) got sig %d\n",
 				    p->p_pid, signo);
 #endif
 				continue;
+			}
 			/*
 			 * If there is a pending stop signal to process with
 			 * default action, stop here, then clear the signal.
 			 * However, if process is member of an orphaned
 			 * process group, ignore tty stop signals.
 			 */
 			if (prop & SA_STOP) {
 				/*
 				 * XXX Don't hold proc_lock for p_lflag,
 				 * but it's not a big deal.
 				 */
 				if (p->p_slflag & PSL_TRACED ||
 		    		    ((p->p_lflag & PL_ORPHANPG) != 0 &&
 				    prop & SA_TTYSTOP)) {
 				    	/* Ignore the signal. */
 					continue;
+				}
 				/* Take the signal. */
 				(void)sigget(sp, NULL, signo, NULL);
 				p->p_xstat = signo;
 				signo = 0;
 				sigswitch(true, PS_NOCLDSTOP, p->p_xstat);
 			} else if (prop & SA_IGNORE) {
 				/*
 				 * Except for SIGCONT, shouldn't get here.
 				 * Default action is to ignore; drop it.
 				 */
 				continue;
+			}
 			break;
 		case (long)SIG_IGN:
 #ifdef DEBUG_ISSIGNAL
 			/*
 			 * Masking above should prevent us ever trying
 			 * to take action on an ignored signal other
 			 * than SIGCONT, unless process is traced.
 			 */
 			if ((prop & SA_CONT) == 0 &&
 			    (p->p_slflag & PSL_TRACED) == 0)
 				printf_nolog("issignal\n");
 #endif
 			continue;
 		default:
 			/*
 			 * This signal has an action, let postsig() process
 			 * it.
 			 */
 			break;
+		}
 		break;
+	}
 	l->l_sigpendset = sp;
 	return signo;
+}
 /*
  * Take the action for the specified signal
  * from the current set of pending signals.
  */
 void
 postsig(int signo)
+{
 	struct lwp	*l;
 	struct proc	*p;
 	struct sigacts	*ps;
 	sig_t		action;
 	sigset_t	*returnmask;
 	ksiginfo_t	ksi;
 	l = curlwp;
 	p = l->l_proc;
 	ps = p->p_sigacts;
 	KASSERT(mutex_owned(p->p_lock));
 	KASSERT(signo > 0);
 	/*
 	 * Set the new mask value and also defer further occurrences of this
 	 * signal.
+	 *
 	 * Special case: user has done a sigsuspend.  Here the current mask is
 	 * not of interest, but rather the mask from before the sigsuspend is
 	 * what we want restored after the signal processing is completed.
 	 */
 	if (l->l_sigrestore) {
 		returnmask = &l->l_sigoldmask;
 		l->l_sigrestore = 0;
 	} else
 		returnmask = &l->l_sigmask;
 	/*
 	 * Commit to taking the signal before releasing the mutex.
 	 */
 	action = SIGACTION_PS(ps, signo).sa_handler;
 	l->l_ru.ru_nsignals++;
 	if (l->l_sigpendset == NULL) {
 		/* From the debugger */
 		if (!siggetinfo(&l->l_sigpend, &ksi, signo))
 			(void)siggetinfo(&p->p_sigpend, &ksi, signo);
 	} else
 		sigget(l->l_sigpendset, &ksi, signo, NULL);
 	if (ktrpoint(KTR_PSIG)) {
 		mutex_exit(p->p_lock);
 		ktrpsig(signo, action, returnmask, &ksi);
 		mutex_enter(p->p_lock);
+	}
 	if (action == SIG_DFL) {
 		/*
 		 * Default action, where the default is to kill
 		 * the process.  (Other cases were ignored above.)
 		 */
 		sigexit(l, signo);
 		return;
+	}
 	/*
 	 * If we get here, the signal must be caught.
 	 */
 #ifdef DIAGNOSTIC
 	if (action == SIG_IGN || sigismember(&l->l_sigmask, signo))
 		panic("postsig action");
 #endif
 	kpsendsig(l, &ksi, returnmask);
+}
 /*
  * sendsig_reset:
+ *
  *	Reset the signal action.  Called from emulation specific sendsig()
  *	before unlocking to deliver the signal.
  */
 void
 sendsig_reset(struct lwp *l, int signo)
+{
 	struct proc *p = l->l_proc;
 	struct sigacts *ps = p->p_sigacts;
 	sigset_t *mask;
 	KASSERT(mutex_owned(p->p_lock));
 	p->p_sigctx.ps_lwp = 0;
 	p->p_sigctx.ps_code = 0;
 	p->p_sigctx.ps_signo = 0;
 	mask = (p->p_sa != NULL) ? &p->p_sa->sa_sigmask : &l->l_sigmask;
 	mutex_enter(&ps->sa_mutex);
 	sigplusset(&SIGACTION_PS(ps, signo).sa_mask, mask);
 	if (SIGACTION_PS(ps, signo).sa_flags & SA_RESETHAND) {
 		sigdelset(&p->p_sigctx.ps_sigcatch, signo);
 		if (signo != SIGCONT && sigprop[signo] & SA_IGNORE)
 			sigaddset(&p->p_sigctx.ps_sigignore, signo);
 		SIGACTION_PS(ps, signo).sa_handler = SIG_DFL;
+	}
 	mutex_exit(&ps->sa_mutex);
+}
 /*
  * Kill the current process for stated reason.
  */
 void
 killproc(struct proc *p, const char *why)
+{
 	KASSERT(mutex_owned(proc_lock));
 	log(LOG_ERR, "pid %d was killed: %s\n", p->p_pid, why);
 	uprintf_locked("sorry, pid %d was killed: %s\n", p->p_pid, why);
 	psignal(p, SIGKILL);
+}
 /*
  * Force the current process to exit with the specified signal, dumping core
  * if appropriate.  We bypass the normal tests for masked and caught
  * signals, allowing unrecoverable failures to terminate the process without
  * changing signal state.  Mark the accounting record with the signal
  * termination.  If dumping core, save the signal number for the debugger.
  * Calls exit and does not return.
  */
 void
 sigexit(struct lwp *l, int signo)
+{
 	int exitsig, error, docore;
 	struct proc *p;
 	struct lwp *t;
 	p = l->l_proc;
 	KASSERT(mutex_owned(p->p_lock));
 	KERNEL_UNLOCK_ALL(l, NULL);
 	/*
 	 * Don't permit coredump() multiple times in the same process.
 	 * Call back into sigexit, where we will be suspended until
 	 * the deed is done.  Note that this is a recursive call, but
 	 * LW_WCORE will prevent us from coming back this way.
 	 */
 	if ((p->p_sflag & PS_WCORE) != 0) {
 		lwp_lock(l);
 		l->l_flag |= (LW_WCORE | LW_WEXIT | LW_WSUSPEND);
 		lwp_unlock(l);
 		mutex_exit(p->p_lock);
 		lwp_userret(l);
 		panic("sigexit 1");
 		/* NOTREACHED */
+	}
 	/* If process is already on the way out, then bail now. */
 	if ((p->p_sflag & PS_WEXIT) != 0) {
 		mutex_exit(p->p_lock);
 		lwp_exit(l);
 		panic("sigexit 2");
 		/* NOTREACHED */
+	}
 	/*
 	 * Prepare all other LWPs for exit.  If dumping core, suspend them
 	 * so that their registers are available long enough to be dumped.
  	 */
 	if ((docore = (sigprop[signo] & SA_CORE)) != 0) {
 		p->p_sflag |= PS_WCORE;
 		for (;;) {
 			LIST_FOREACH(t, &p->p_lwps, l_sibling) {
 				lwp_lock(t);
 				if (t == l) {
 					t->l_flag &= ~LW_WSUSPEND;
 					lwp_unlock(t);
 					continue;
+				}
 				t->l_flag |= (LW_WCORE | LW_WEXIT);
 				lwp_suspend(l, t);
+			}
 			if (p->p_nrlwps == 1)
 				break;
 			/*
 			 * Kick any LWPs sitting in lwp_wait1(), and wait
 			 * for everyone else to stop before proceeding.
 			 */
 			p->p_nlwpwait++;
 			cv_broadcast(&p->p_lwpcv);
 			cv_wait(&p->p_lwpcv, p->p_lock);
 			p->p_nlwpwait--;
+		}
+	}
 	exitsig = signo;
 	p->p_acflag |= AXSIG;
 	p->p_sigctx.ps_signo = signo;
 	if (docore) {
 		mutex_exit(p->p_lock);
 		if ((error = coredump(l, NULL)) == 0)
 			exitsig |= WCOREFLAG;
 		if (kern_logsigexit) {
 			int uid = l->l_cred ?
 			    (int)kauth_cred_geteuid(l->l_cred) : -1;
 			if (error)
 				log(LOG_INFO, lognocoredump, p->p_pid,
 				    p->p_comm, uid, signo, error);
 			else
 				log(LOG_INFO, logcoredump, p->p_pid,
 				    p->p_comm, uid, signo);
+		}
 #ifdef PAX_SEGVGUARD
 		pax_segvguard(l, p->p_textvp, p->p_comm, true);
 #endif /* PAX_SEGVGUARD */
 		/* Acquire the sched state mutex.  exit1() will release it. */
 		mutex_enter(p->p_lock);
+	}
 	/* No longer dumping core. */
 	p->p_sflag &= ~PS_WCORE;
 	exit1(l, W_EXITCODE(0, exitsig));
 	/* NOTREACHED */
+}
 /*
  * Put process 'p' into the stopped state and optionally, notify the parent.
  */
 void
 proc_stop(struct proc *p, int notify, int signo)
+{
 	struct lwp *l;
 	KASSERT(mutex_owned(p->p_lock));
 	/*
 	 * First off, set the stopping indicator and bring all sleeping
 	 * LWPs to a halt so they are included in p->p_nrlwps.  We musn't
 	 * unlock between here and the p->p_nrlwps check below.
 	 */
 	p->p_sflag |= PS_STOPPING;
 	if (notify)
 		p->p_sflag |= PS_NOTIFYSTOP;
 	else
 		p->p_sflag &= ~PS_NOTIFYSTOP;
 	membar_producer();
 	proc_stop_lwps(p);
 	/*
 	 * If there are no LWPs available to take the signal, then we
 	 * signal the parent process immediately.  Otherwise, the last
 	 * LWP to stop will take care of it.
 	 */
 	if (p->p_nrlwps == 0) {
 		proc_stop_done(p, true, PS_NOCLDSTOP);
 	} else {
 		/*
 		 * Have the remaining LWPs come to a halt, and trigger
 		 * proc_stop_callout() to ensure that they do.
 		 */
 		LIST_FOREACH(l, &p->p_lwps, l_sibling)
 			sigpost(l, SIG_DFL, SA_STOP, signo, 0);
 		callout_schedule(&proc_stop_ch, 1);
+	}
+}
 /*
  * When stopping a process, we do not immediatly set sleeping LWPs stopped,
  * but wait for them to come to a halt at the kernel-user boundary.  This is
  * to allow LWPs to release any locks that they may hold before stopping.
+ *
  * Non-interruptable sleeps can be long, and there is the potential for an
  * LWP to begin sleeping interruptably soon after the process has been set
  * stopping (PS_STOPPING).  These LWPs will not notice that the process is
  * stopping, and so complete halt of the process and the return of status
  * information to the parent could be delayed indefinitely.
+ *
  * To handle this race, proc_stop_callout() runs once per tick while there
  * are stopping processes in the system.  It sets LWPs that are sleeping
  * interruptably into the LSSTOP state.
+ *
  * Note that we are not concerned about keeping all LWPs stopped while the
  * process is stopped: stopped LWPs can awaken briefly to handle signals.
  * What we do need to ensure is that all LWPs in a stopping process have
  * stopped at least once, so that notification can be sent to the parent
  * process.
  */
 static void
 proc_stop_callout(void *cookie)
+{
 	bool more, restart;
 	struct proc *p;
 	(void)cookie;
 	do {
 		restart = false;
 		more = false;
 		mutex_enter(proc_lock);
 		PROCLIST_FOREACH(p, &allproc) {
 			if ((p->p_flag & PK_MARKER) != 0)
 				continue;
 			mutex_enter(p->p_lock);
 			if ((p->p_sflag & PS_STOPPING) == 0) {
 				mutex_exit(p->p_lock);
 				continue;
+			}
 			/* Stop any LWPs sleeping interruptably. */
 			proc_stop_lwps(p);
 			if (p->p_nrlwps == 0) {
 				/*
 				 * We brought the process to a halt.
 				 * Mark it as stopped and notify the
 				 * parent.
 				 */
 				if ((p->p_sflag & PS_NOTIFYSTOP) != 0) {
 					/*
 					 * Note that proc_stop_done() will
 					 * drop p->p_lock briefly.
 					 * Arrange to restart and check
 					 * all processes again.
 					 */
 					restart = true;
+				}
 				proc_stop_done(p, true, PS_NOCLDSTOP);
 			} else
 				more = true;
 			mutex_exit(p->p_lock);
 			if (restart)
 				break;
+		}
 		mutex_exit(proc_lock);
 	} while (restart);
 	/*
 	 * If we noted processes that are stopping but still have
 	 * running LWPs, then arrange to check again in 1 tick.
 	 */
 	if (more)
 		callout_schedule(&proc_stop_ch, 1);
+}
 /*
  * Given a process in state SSTOP, set the state back to SACTIVE and
  * move LSSTOP'd LWPs to LSSLEEP or make them runnable.
  */
 void
 proc_unstop(struct proc *p)
+{
 	struct lwp *l;
 	int sig;
 	KASSERT(mutex_owned(proc_lock));
 	KASSERT(mutex_owned(p->p_lock));
 	p->p_stat = SACTIVE;
 	p->p_sflag &= ~PS_STOPPING;
 	sig = p->p_xstat;
 	if (!p->p_waited)
 		p->p_pptr->p_nstopchild--;
 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {
 		lwp_lock(l);
 		if (l->l_stat != LSSTOP) {
 			lwp_unlock(l);
 			continue;
+		}
 		if (l->l_wchan == NULL) {
 			setrunnable(l);
 			continue;
+		}
 		if (sig && (l->l_flag & LW_SINTR) != 0) {
 		        setrunnable(l);
 		        sig = 0;
 		} else {
 			l->l_stat = LSSLEEP;
 			p->p_nrlwps++;
 			lwp_unlock(l);
+		}
+	}
+}
 static int
 filt_sigattach(struct knote *kn)
+{
 	struct proc *p = curproc;
 	kn->kn_obj = p;
 	kn->kn_flags |= EV_CLEAR;               /* automatically set */
 	mutex_enter(p->p_lock);
 	SLIST_INSERT_HEAD(&p->p_klist, kn, kn_selnext);
 	mutex_exit(p->p_lock);
 	return (0);
+}
 static void
 filt_sigdetach(struct knote *kn)
+{
 	struct proc *p = kn->kn_obj;
 	mutex_enter(p->p_lock);
 	SLIST_REMOVE(&p->p_klist, kn, knote, kn_selnext);
 	mutex_exit(p->p_lock);
+}
 /*
  * signal knotes are shared with proc knotes, so we apply a mask to
  * the hint in order to differentiate them from process hints.  This
  * could be avoided by using a signal-specific knote list, but probably
  * isn't worth the trouble.
  */
 static int
 filt_signal(struct knote *kn, long hint)
+{
 	if (hint & NOTE_SIGNAL) {
 		hint &= ~NOTE_SIGNAL;
 		if (kn->kn_id == hint)
 			kn->kn_data++;
+	}
 	return (kn->kn_data != 0);
+}
 const struct filterops sig_filtops = {
 , filt_sigattach, filt_sigdetach, filt_signal
 };