xref: /freebsd/sys/kern/kern_sig.c (revision 873fbcd776b5c6e0b7caa1f1f87cc91a12d339db)
19454b2d8SWarner Losh /*-
2df8bae1dSRodney W. Grimes  * Copyright (c) 1982, 1986, 1989, 1991, 1993
3df8bae1dSRodney W. Grimes  *	The Regents of the University of California.  All rights reserved.
4df8bae1dSRodney W. Grimes  * (c) UNIX System Laboratories, Inc.
5df8bae1dSRodney W. Grimes  * All or some portions of this file are derived from material licensed
6df8bae1dSRodney W. Grimes  * to the University of California by American Telephone and Telegraph
7df8bae1dSRodney W. Grimes  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8df8bae1dSRodney W. Grimes  * the permission of UNIX System Laboratories, Inc.
9df8bae1dSRodney W. Grimes  *
10df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
11df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
12df8bae1dSRodney W. Grimes  * are met:
13df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
14df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
15df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
16df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
17df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
18df8bae1dSRodney W. Grimes  * 4. Neither the name of the University nor the names of its contributors
19df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
20df8bae1dSRodney W. Grimes  *    without specific prior written permission.
21df8bae1dSRodney W. Grimes  *
22df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
33df8bae1dSRodney W. Grimes  *
34df8bae1dSRodney W. Grimes  *	@(#)kern_sig.c	8.7 (Berkeley) 4/18/94
35df8bae1dSRodney W. Grimes  */
36df8bae1dSRodney W. Grimes 
37677b542eSDavid E. O'Brien #include <sys/cdefs.h>
38677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$");
39677b542eSDavid E. O'Brien 
405591b823SEivind Eklund #include "opt_compat.h"
41db6a20e2SGarrett Wollman #include "opt_ktrace.h"
42db6a20e2SGarrett Wollman 
43df8bae1dSRodney W. Grimes #include <sys/param.h>
4436240ea5SDoug Rabson #include <sys/systm.h>
45df8bae1dSRodney W. Grimes #include <sys/signalvar.h>
46df8bae1dSRodney W. Grimes #include <sys/vnode.h>
47df8bae1dSRodney W. Grimes #include <sys/acct.h>
48238510fcSJason Evans #include <sys/condvar.h>
49854dc8c2SJohn Baldwin #include <sys/event.h>
50854dc8c2SJohn Baldwin #include <sys/fcntl.h>
51854dc8c2SJohn Baldwin #include <sys/kernel.h>
529dde3bc9SDavid Xu #include <sys/kse.h>
530384fff8SJason Evans #include <sys/ktr.h>
54df8bae1dSRodney W. Grimes #include <sys/ktrace.h>
55854dc8c2SJohn Baldwin #include <sys/lock.h>
56854dc8c2SJohn Baldwin #include <sys/malloc.h>
57854dc8c2SJohn Baldwin #include <sys/mutex.h>
58854dc8c2SJohn Baldwin #include <sys/namei.h>
59854dc8c2SJohn Baldwin #include <sys/proc.h>
606aeb05d7STom Rhodes #include <sys/posix4.h>
61854dc8c2SJohn Baldwin #include <sys/pioctl.h>
62c31146a1SJohn Baldwin #include <sys/resourcevar.h>
6344f3b092SJohn Baldwin #include <sys/sleepqueue.h>
646caa8a15SJohn Baldwin #include <sys/smp.h>
65df8bae1dSRodney W. Grimes #include <sys/stat.h>
661005a129SJohn Baldwin #include <sys/sx.h>
678f19eb88SIan Dowse #include <sys/syscallsubr.h>
68c87e2930SDavid Greenman #include <sys/sysctl.h>
69854dc8c2SJohn Baldwin #include <sys/sysent.h>
70854dc8c2SJohn Baldwin #include <sys/syslog.h>
71854dc8c2SJohn Baldwin #include <sys/sysproto.h>
7256c06c4bSDavid Xu #include <sys/timers.h>
7306ae1e91SMatthew Dillon #include <sys/unistd.h>
74854dc8c2SJohn Baldwin #include <sys/wait.h>
759104847fSDavid Xu #include <vm/vm.h>
769104847fSDavid Xu #include <vm/vm_extern.h>
779104847fSDavid Xu #include <vm/uma.h>
78df8bae1dSRodney W. Grimes 
79df8bae1dSRodney W. Grimes #include <machine/cpu.h>
80df8bae1dSRodney W. Grimes 
81bfd7575aSWayne Salamon #include <security/audit/audit.h>
82bfd7575aSWayne Salamon 
836f841fb7SMarcel Moolenaar #define	ONSIG	32		/* NSIG for osig* syscalls.  XXX. */
846f841fb7SMarcel Moolenaar 
854d77a549SAlfred Perlstein static int	coredump(struct thread *);
864d77a549SAlfred Perlstein static char	*expand_name(const char *, uid_t, pid_t);
871a88a252SMaxim Sobolev static int	killpg1(struct thread *td, int sig, int pgid, int all);
886711f10fSJohn Baldwin static int	issignal(struct thread *p);
894d77a549SAlfred Perlstein static int	sigprop(int sig);
9094f0972bSDavid Xu static void	tdsigwakeup(struct thread *, int, sig_t, int);
91d8267df7SDavid Xu static void	sig_suspend_threads(struct thread *, struct proc *, int);
92cb679c38SJonathan Lemon static int	filt_sigattach(struct knote *kn);
93cb679c38SJonathan Lemon static void	filt_sigdetach(struct knote *kn);
94cb679c38SJonathan Lemon static int	filt_signal(struct knote *kn, long hint);
954093529dSJeff Roberson static struct thread *sigtd(struct proc *p, int sig, int prop);
968460a577SJohn Birrell #ifdef KSE
976d7b314bSDavid Xu static int	do_tdsignal(struct proc *, struct thread *, int, ksiginfo_t *);
988460a577SJohn Birrell #endif
999104847fSDavid Xu static void	sigqueue_start(void);
100cb679c38SJonathan Lemon 
1019104847fSDavid Xu static uma_zone_t	ksiginfo_zone = NULL;
102cb679c38SJonathan Lemon struct filterops sig_filtops =
103cb679c38SJonathan Lemon 	{ 0, filt_sigattach, filt_sigdetach, filt_signal };
104cb679c38SJonathan Lemon 
10557308494SJoerg Wunsch static int	kern_logsigexit = 1;
1063d177f46SBill Fumerola SYSCTL_INT(_kern, KERN_LOGSIGEXIT, logsigexit, CTLFLAG_RW,
1073d177f46SBill Fumerola     &kern_logsigexit, 0,
1083d177f46SBill Fumerola     "Log processes quitting on abnormal signals to syslog(3)");
10957308494SJoerg Wunsch 
110f71a882fSDavid Xu static int	kern_forcesigexit = 1;
111f71a882fSDavid Xu SYSCTL_INT(_kern, OID_AUTO, forcesigexit, CTLFLAG_RW,
112f71a882fSDavid Xu     &kern_forcesigexit, 0, "Force trap signal to be handled");
113f71a882fSDavid Xu 
1149104847fSDavid Xu SYSCTL_NODE(_kern, OID_AUTO, sigqueue, CTLFLAG_RW, 0, "POSIX real time signal");
1159104847fSDavid Xu 
1169104847fSDavid Xu static int	max_pending_per_proc = 128;
1179104847fSDavid Xu SYSCTL_INT(_kern_sigqueue, OID_AUTO, max_pending_per_proc, CTLFLAG_RW,
1189104847fSDavid Xu     &max_pending_per_proc, 0, "Max pending signals per proc");
1199104847fSDavid Xu 
1209104847fSDavid Xu static int	preallocate_siginfo = 1024;
1219104847fSDavid Xu TUNABLE_INT("kern.sigqueue.preallocate", &preallocate_siginfo);
1229104847fSDavid Xu SYSCTL_INT(_kern_sigqueue, OID_AUTO, preallocate, CTLFLAG_RD,
1239104847fSDavid Xu     &preallocate_siginfo, 0, "Preallocated signal memory size");
1249104847fSDavid Xu 
1259104847fSDavid Xu static int	signal_overflow = 0;
126761a4d94SDavid Xu SYSCTL_INT(_kern_sigqueue, OID_AUTO, overflow, CTLFLAG_RD,
1279104847fSDavid Xu     &signal_overflow, 0, "Number of signals overflew");
1289104847fSDavid Xu 
1299104847fSDavid Xu static int	signal_alloc_fail = 0;
130761a4d94SDavid Xu SYSCTL_INT(_kern_sigqueue, OID_AUTO, alloc_fail, CTLFLAG_RD,
1319104847fSDavid Xu     &signal_alloc_fail, 0, "signals failed to be allocated");
1329104847fSDavid Xu 
1339104847fSDavid Xu SYSINIT(signal, SI_SUB_P1003_1B, SI_ORDER_FIRST+3, sigqueue_start, NULL);
1349104847fSDavid Xu 
1352b87b6d4SRobert Watson /*
1362b87b6d4SRobert Watson  * Policy -- Can ucred cr1 send SIGIO to process cr2?
1372b87b6d4SRobert Watson  * Should use cr_cansignal() once cr_cansignal() allows SIGIO and SIGURG
1382b87b6d4SRobert Watson  * in the right situations.
1392b87b6d4SRobert Watson  */
1402b87b6d4SRobert Watson #define CANSIGIO(cr1, cr2) \
1412b87b6d4SRobert Watson 	((cr1)->cr_uid == 0 || \
1422b87b6d4SRobert Watson 	    (cr1)->cr_ruid == (cr2)->cr_ruid || \
1432b87b6d4SRobert Watson 	    (cr1)->cr_uid == (cr2)->cr_ruid || \
1442b87b6d4SRobert Watson 	    (cr1)->cr_ruid == (cr2)->cr_uid || \
1452b87b6d4SRobert Watson 	    (cr1)->cr_uid == (cr2)->cr_uid)
1462b87b6d4SRobert Watson 
14722d4b0fbSJohn Polstra int sugid_coredump;
1483d177f46SBill Fumerola SYSCTL_INT(_kern, OID_AUTO, sugid_coredump, CTLFLAG_RW,
1493d177f46SBill Fumerola     &sugid_coredump, 0, "Enable coredumping set user/group ID processes");
150c87e2930SDavid Greenman 
151e5a28db9SPaul Saab static int	do_coredump = 1;
152e5a28db9SPaul Saab SYSCTL_INT(_kern, OID_AUTO, coredump, CTLFLAG_RW,
153e5a28db9SPaul Saab 	&do_coredump, 0, "Enable/Disable coredumps");
154e5a28db9SPaul Saab 
1556141e04aSJohn-Mark Gurney static int	set_core_nodump_flag = 0;
1566141e04aSJohn-Mark Gurney SYSCTL_INT(_kern, OID_AUTO, nodump_coredump, CTLFLAG_RW, &set_core_nodump_flag,
1576141e04aSJohn-Mark Gurney 	0, "Enable setting the NODUMP flag on coredump files");
1586141e04aSJohn-Mark Gurney 
1592c42a146SMarcel Moolenaar /*
1602c42a146SMarcel Moolenaar  * Signal properties and actions.
1612c42a146SMarcel Moolenaar  * The array below categorizes the signals and their default actions
1622c42a146SMarcel Moolenaar  * according to the following properties:
1632c42a146SMarcel Moolenaar  */
1642c42a146SMarcel Moolenaar #define	SA_KILL		0x01		/* terminates process by default */
1652c42a146SMarcel Moolenaar #define	SA_CORE		0x02		/* ditto and coredumps */
1662c42a146SMarcel Moolenaar #define	SA_STOP		0x04		/* suspend process */
1672c42a146SMarcel Moolenaar #define	SA_TTYSTOP	0x08		/* ditto, from tty */
1682c42a146SMarcel Moolenaar #define	SA_IGNORE	0x10		/* ignore by default */
1692c42a146SMarcel Moolenaar #define	SA_CONT		0x20		/* continue if suspended */
1702c42a146SMarcel Moolenaar #define	SA_CANTMASK	0x40		/* non-maskable, catchable */
171da33176fSJeff Roberson #define	SA_PROC		0x80		/* deliverable to any thread */
172df8bae1dSRodney W. Grimes 
1732c42a146SMarcel Moolenaar static int sigproptbl[NSIG] = {
174da33176fSJeff Roberson         SA_KILL|SA_PROC,		/* SIGHUP */
175da33176fSJeff Roberson         SA_KILL|SA_PROC,		/* SIGINT */
176da33176fSJeff Roberson         SA_KILL|SA_CORE|SA_PROC,	/* SIGQUIT */
1772c42a146SMarcel Moolenaar         SA_KILL|SA_CORE,		/* SIGILL */
1782c42a146SMarcel Moolenaar         SA_KILL|SA_CORE,		/* SIGTRAP */
1792c42a146SMarcel Moolenaar         SA_KILL|SA_CORE,		/* SIGABRT */
180da33176fSJeff Roberson         SA_KILL|SA_CORE|SA_PROC,	/* SIGEMT */
1812c42a146SMarcel Moolenaar         SA_KILL|SA_CORE,		/* SIGFPE */
182da33176fSJeff Roberson         SA_KILL|SA_PROC,		/* SIGKILL */
1832c42a146SMarcel Moolenaar         SA_KILL|SA_CORE,		/* SIGBUS */
1842c42a146SMarcel Moolenaar         SA_KILL|SA_CORE,		/* SIGSEGV */
1852c42a146SMarcel Moolenaar         SA_KILL|SA_CORE,		/* SIGSYS */
186da33176fSJeff Roberson         SA_KILL|SA_PROC,		/* SIGPIPE */
187da33176fSJeff Roberson         SA_KILL|SA_PROC,		/* SIGALRM */
188da33176fSJeff Roberson         SA_KILL|SA_PROC,		/* SIGTERM */
189da33176fSJeff Roberson         SA_IGNORE|SA_PROC,		/* SIGURG */
190da33176fSJeff Roberson         SA_STOP|SA_PROC,		/* SIGSTOP */
191da33176fSJeff Roberson         SA_STOP|SA_TTYSTOP|SA_PROC,	/* SIGTSTP */
192da33176fSJeff Roberson         SA_IGNORE|SA_CONT|SA_PROC,	/* SIGCONT */
193da33176fSJeff Roberson         SA_IGNORE|SA_PROC,		/* SIGCHLD */
194da33176fSJeff Roberson         SA_STOP|SA_TTYSTOP|SA_PROC,	/* SIGTTIN */
195da33176fSJeff Roberson         SA_STOP|SA_TTYSTOP|SA_PROC,	/* SIGTTOU */
196da33176fSJeff Roberson         SA_IGNORE|SA_PROC,		/* SIGIO */
1972c42a146SMarcel Moolenaar         SA_KILL,			/* SIGXCPU */
1982c42a146SMarcel Moolenaar         SA_KILL,			/* SIGXFSZ */
199da33176fSJeff Roberson         SA_KILL|SA_PROC,		/* SIGVTALRM */
200da33176fSJeff Roberson         SA_KILL|SA_PROC,		/* SIGPROF */
201da33176fSJeff Roberson         SA_IGNORE|SA_PROC,		/* SIGWINCH  */
202da33176fSJeff Roberson         SA_IGNORE|SA_PROC,		/* SIGINFO */
203da33176fSJeff Roberson         SA_KILL|SA_PROC,		/* SIGUSR1 */
204da33176fSJeff Roberson         SA_KILL|SA_PROC,		/* SIGUSR2 */
2052c42a146SMarcel Moolenaar };
2062c42a146SMarcel Moolenaar 
2079104847fSDavid Xu static void
2089104847fSDavid Xu sigqueue_start(void)
2099104847fSDavid Xu {
2109104847fSDavid Xu 	ksiginfo_zone = uma_zcreate("ksiginfo", sizeof(ksiginfo_t),
2119104847fSDavid Xu 		NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
2129104847fSDavid Xu 	uma_prealloc(ksiginfo_zone, preallocate_siginfo);
213b51d237aSDavid Xu 	p31b_setcfg(CTL_P1003_1B_REALTIME_SIGNALS, _POSIX_REALTIME_SIGNALS);
214b51d237aSDavid Xu 	p31b_setcfg(CTL_P1003_1B_RTSIG_MAX, SIGRTMAX - SIGRTMIN + 1);
215b51d237aSDavid Xu 	p31b_setcfg(CTL_P1003_1B_SIGQUEUE_MAX, max_pending_per_proc);
2169104847fSDavid Xu }
2179104847fSDavid Xu 
2185da49fcbSDavid Xu ksiginfo_t *
219ebceaf6dSDavid Xu ksiginfo_alloc(int wait)
2209104847fSDavid Xu {
221ebceaf6dSDavid Xu 	int flags;
222ebceaf6dSDavid Xu 
223ebceaf6dSDavid Xu 	flags = M_ZERO;
224ebceaf6dSDavid Xu 	if (! wait)
225ebceaf6dSDavid Xu 		flags |= M_NOWAIT;
2269104847fSDavid Xu 	if (ksiginfo_zone != NULL)
227ebceaf6dSDavid Xu 		return ((ksiginfo_t *)uma_zalloc(ksiginfo_zone, flags));
2289104847fSDavid Xu 	return (NULL);
2299104847fSDavid Xu }
2309104847fSDavid Xu 
2315da49fcbSDavid Xu void
2329104847fSDavid Xu ksiginfo_free(ksiginfo_t *ksi)
2339104847fSDavid Xu {
2349104847fSDavid Xu 	uma_zfree(ksiginfo_zone, ksi);
2359104847fSDavid Xu }
2369104847fSDavid Xu 
2375da49fcbSDavid Xu static __inline int
2385da49fcbSDavid Xu ksiginfo_tryfree(ksiginfo_t *ksi)
2395da49fcbSDavid Xu {
2405da49fcbSDavid Xu 	if (!(ksi->ksi_flags & KSI_EXT)) {
2415da49fcbSDavid Xu 		uma_zfree(ksiginfo_zone, ksi);
2425da49fcbSDavid Xu 		return (1);
2435da49fcbSDavid Xu 	}
2445da49fcbSDavid Xu 	return (0);
2455da49fcbSDavid Xu }
2465da49fcbSDavid Xu 
2479104847fSDavid Xu void
2489104847fSDavid Xu sigqueue_init(sigqueue_t *list, struct proc *p)
2499104847fSDavid Xu {
2509104847fSDavid Xu 	SIGEMPTYSET(list->sq_signals);
2513dfcaad6SDavid Xu 	SIGEMPTYSET(list->sq_kill);
2529104847fSDavid Xu 	TAILQ_INIT(&list->sq_list);
2539104847fSDavid Xu 	list->sq_proc = p;
2549104847fSDavid Xu 	list->sq_flags = SQ_INIT;
2559104847fSDavid Xu }
2569104847fSDavid Xu 
2579104847fSDavid Xu /*
2589104847fSDavid Xu  * Get a signal's ksiginfo.
2599104847fSDavid Xu  * Return:
2609104847fSDavid Xu  * 	0	-	signal not found
2619104847fSDavid Xu  *	others	-	signal number
2629104847fSDavid Xu  */
2639104847fSDavid Xu int
2649104847fSDavid Xu sigqueue_get(sigqueue_t *sq, int signo, ksiginfo_t *si)
2659104847fSDavid Xu {
2669104847fSDavid Xu 	struct proc *p = sq->sq_proc;
2679104847fSDavid Xu 	struct ksiginfo *ksi, *next;
2689104847fSDavid Xu 	int count = 0;
2699104847fSDavid Xu 
2709104847fSDavid Xu 	KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited"));
2719104847fSDavid Xu 
2729104847fSDavid Xu 	if (!SIGISMEMBER(sq->sq_signals, signo))
2739104847fSDavid Xu 		return (0);
2749104847fSDavid Xu 
2753dfcaad6SDavid Xu 	if (SIGISMEMBER(sq->sq_kill, signo)) {
2763dfcaad6SDavid Xu 		count++;
2773dfcaad6SDavid Xu 		SIGDELSET(sq->sq_kill, signo);
2783dfcaad6SDavid Xu 	}
2793dfcaad6SDavid Xu 
2805c28a8d4SDavid Xu 	TAILQ_FOREACH_SAFE(ksi, &sq->sq_list, ksi_link, next) {
2819104847fSDavid Xu 		if (ksi->ksi_signo == signo) {
2829104847fSDavid Xu 			if (count == 0) {
2839104847fSDavid Xu 				TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link);
2845da49fcbSDavid Xu 				ksi->ksi_sigq = NULL;
2859104847fSDavid Xu 				ksiginfo_copy(ksi, si);
2865da49fcbSDavid Xu 				if (ksiginfo_tryfree(ksi) && p != NULL)
2879104847fSDavid Xu 					p->p_pendingcnt--;
2889104847fSDavid Xu 			}
289016fa302SDavid Xu 			if (++count > 1)
290016fa302SDavid Xu 				break;
2919104847fSDavid Xu 		}
2929104847fSDavid Xu 	}
2939104847fSDavid Xu 
2949104847fSDavid Xu 	if (count <= 1)
2959104847fSDavid Xu 		SIGDELSET(sq->sq_signals, signo);
2969104847fSDavid Xu 	si->ksi_signo = signo;
2979104847fSDavid Xu 	return (signo);
2989104847fSDavid Xu }
2999104847fSDavid Xu 
3005da49fcbSDavid Xu void
3015da49fcbSDavid Xu sigqueue_take(ksiginfo_t *ksi)
3025da49fcbSDavid Xu {
3035da49fcbSDavid Xu 	struct ksiginfo *kp;
3045da49fcbSDavid Xu 	struct proc	*p;
3055da49fcbSDavid Xu 	sigqueue_t	*sq;
3065da49fcbSDavid Xu 
307ebceaf6dSDavid Xu 	if (ksi == NULL || (sq = ksi->ksi_sigq) == NULL)
3085da49fcbSDavid Xu 		return;
3095da49fcbSDavid Xu 
3105da49fcbSDavid Xu 	p = sq->sq_proc;
3115da49fcbSDavid Xu 	TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link);
3125da49fcbSDavid Xu 	ksi->ksi_sigq = NULL;
3135da49fcbSDavid Xu 	if (!(ksi->ksi_flags & KSI_EXT) && p != NULL)
3145da49fcbSDavid Xu 		p->p_pendingcnt--;
3155da49fcbSDavid Xu 
3165da49fcbSDavid Xu 	for (kp = TAILQ_FIRST(&sq->sq_list); kp != NULL;
3175da49fcbSDavid Xu 	     kp = TAILQ_NEXT(kp, ksi_link)) {
3185da49fcbSDavid Xu 		if (kp->ksi_signo == ksi->ksi_signo)
3195da49fcbSDavid Xu 			break;
3205da49fcbSDavid Xu 	}
3213dfcaad6SDavid Xu 	if (kp == NULL && !SIGISMEMBER(sq->sq_kill, ksi->ksi_signo))
3225da49fcbSDavid Xu 		SIGDELSET(sq->sq_signals, ksi->ksi_signo);
3235da49fcbSDavid Xu }
3245da49fcbSDavid Xu 
3259104847fSDavid Xu int
3269104847fSDavid Xu sigqueue_add(sigqueue_t *sq, int signo, ksiginfo_t *si)
3279104847fSDavid Xu {
3289104847fSDavid Xu 	struct proc *p = sq->sq_proc;
3299104847fSDavid Xu 	struct ksiginfo *ksi;
3309104847fSDavid Xu 	int ret = 0;
3319104847fSDavid Xu 
3329104847fSDavid Xu 	KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited"));
3339104847fSDavid Xu 
3343dfcaad6SDavid Xu 	if (signo == SIGKILL || signo == SIGSTOP || si == NULL) {
3353dfcaad6SDavid Xu 		SIGADDSET(sq->sq_kill, signo);
3369104847fSDavid Xu 		goto out_set_bit;
3373dfcaad6SDavid Xu 	}
3389104847fSDavid Xu 
3395da49fcbSDavid Xu 	/* directly insert the ksi, don't copy it */
3405da49fcbSDavid Xu 	if (si->ksi_flags & KSI_INS) {
3415da49fcbSDavid Xu 		TAILQ_INSERT_TAIL(&sq->sq_list, si, ksi_link);
3425da49fcbSDavid Xu 		si->ksi_sigq = sq;
3435da49fcbSDavid Xu 		goto out_set_bit;
3445da49fcbSDavid Xu 	}
3455da49fcbSDavid Xu 
3463dfcaad6SDavid Xu 	if (__predict_false(ksiginfo_zone == NULL)) {
3473dfcaad6SDavid Xu 		SIGADDSET(sq->sq_kill, signo);
3489104847fSDavid Xu 		goto out_set_bit;
3493dfcaad6SDavid Xu 	}
3509104847fSDavid Xu 
351ebceaf6dSDavid Xu 	if (p != NULL && p->p_pendingcnt >= max_pending_per_proc) {
3529104847fSDavid Xu 		signal_overflow++;
3539104847fSDavid Xu 		ret = EAGAIN;
354ebceaf6dSDavid Xu 	} else if ((ksi = ksiginfo_alloc(0)) == NULL) {
3559104847fSDavid Xu 		signal_alloc_fail++;
3569104847fSDavid Xu 		ret = EAGAIN;
3579104847fSDavid Xu 	} else {
3589104847fSDavid Xu 		if (p != NULL)
3599104847fSDavid Xu 			p->p_pendingcnt++;
3609104847fSDavid Xu 		ksiginfo_copy(si, ksi);
3619104847fSDavid Xu 		ksi->ksi_signo = signo;
3629104847fSDavid Xu 		TAILQ_INSERT_TAIL(&sq->sq_list, ksi, ksi_link);
3635da49fcbSDavid Xu 		ksi->ksi_sigq = sq;
3649104847fSDavid Xu 	}
3659104847fSDavid Xu 
3669104847fSDavid Xu 	if ((si->ksi_flags & KSI_TRAP) != 0) {
3673dfcaad6SDavid Xu 		if (ret != 0)
3683dfcaad6SDavid Xu 			SIGADDSET(sq->sq_kill, signo);
3699104847fSDavid Xu 		ret = 0;
3709104847fSDavid Xu 		goto out_set_bit;
3719104847fSDavid Xu 	}
3729104847fSDavid Xu 
3739104847fSDavid Xu 	if (ret != 0)
3749104847fSDavid Xu 		return (ret);
3759104847fSDavid Xu 
3769104847fSDavid Xu out_set_bit:
3779104847fSDavid Xu 	SIGADDSET(sq->sq_signals, signo);
3789104847fSDavid Xu 	return (ret);
3799104847fSDavid Xu }
3809104847fSDavid Xu 
3819104847fSDavid Xu void
3829104847fSDavid Xu sigqueue_flush(sigqueue_t *sq)
3839104847fSDavid Xu {
3849104847fSDavid Xu 	struct proc *p = sq->sq_proc;
3859104847fSDavid Xu 	ksiginfo_t *ksi;
3869104847fSDavid Xu 
3879104847fSDavid Xu 	KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited"));
3889104847fSDavid Xu 
3895da49fcbSDavid Xu 	if (p != NULL)
3905da49fcbSDavid Xu 		PROC_LOCK_ASSERT(p, MA_OWNED);
3915da49fcbSDavid Xu 
3929104847fSDavid Xu 	while ((ksi = TAILQ_FIRST(&sq->sq_list)) != NULL) {
3939104847fSDavid Xu 		TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link);
3945da49fcbSDavid Xu 		ksi->ksi_sigq = NULL;
3955da49fcbSDavid Xu 		if (ksiginfo_tryfree(ksi) && p != NULL)
3969104847fSDavid Xu 			p->p_pendingcnt--;
3979104847fSDavid Xu 	}
3989104847fSDavid Xu 
3999104847fSDavid Xu 	SIGEMPTYSET(sq->sq_signals);
4003dfcaad6SDavid Xu 	SIGEMPTYSET(sq->sq_kill);
4019104847fSDavid Xu }
4029104847fSDavid Xu 
4039104847fSDavid Xu void
4049104847fSDavid Xu sigqueue_collect_set(sigqueue_t *sq, sigset_t *set)
4059104847fSDavid Xu {
4069104847fSDavid Xu 	ksiginfo_t *ksi;
4079104847fSDavid Xu 
4089104847fSDavid Xu 	KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited"));
4099104847fSDavid Xu 
4109104847fSDavid Xu 	TAILQ_FOREACH(ksi, &sq->sq_list, ksi_link)
4119104847fSDavid Xu 		SIGADDSET(*set, ksi->ksi_signo);
4123dfcaad6SDavid Xu 	SIGSETOR(*set, sq->sq_kill);
4139104847fSDavid Xu }
4149104847fSDavid Xu 
4159104847fSDavid Xu void
4169104847fSDavid Xu sigqueue_move_set(sigqueue_t *src, sigqueue_t *dst, sigset_t *setp)
4179104847fSDavid Xu {
4189104847fSDavid Xu 	sigset_t tmp, set;
4199104847fSDavid Xu 	struct proc *p1, *p2;
4209104847fSDavid Xu 	ksiginfo_t *ksi, *next;
4219104847fSDavid Xu 
4229104847fSDavid Xu 	KASSERT(src->sq_flags & SQ_INIT, ("src sigqueue not inited"));
4239104847fSDavid Xu 	KASSERT(dst->sq_flags & SQ_INIT, ("dst sigqueue not inited"));
4249104847fSDavid Xu 	/*
4259104847fSDavid Xu 	 * make a copy, this allows setp to point to src or dst
4269104847fSDavid Xu 	 * sq_signals without trouble.
4279104847fSDavid Xu 	 */
4289104847fSDavid Xu 	set = *setp;
4299104847fSDavid Xu 	p1 = src->sq_proc;
4309104847fSDavid Xu 	p2 = dst->sq_proc;
4319104847fSDavid Xu 	/* Move siginfo to target list */
4325c28a8d4SDavid Xu 	TAILQ_FOREACH_SAFE(ksi, &src->sq_list, ksi_link, next) {
4339104847fSDavid Xu 		if (SIGISMEMBER(set, ksi->ksi_signo)) {
4349104847fSDavid Xu 			TAILQ_REMOVE(&src->sq_list, ksi, ksi_link);
4359104847fSDavid Xu 			if (p1 != NULL)
4369104847fSDavid Xu 				p1->p_pendingcnt--;
4379104847fSDavid Xu 			TAILQ_INSERT_TAIL(&dst->sq_list, ksi, ksi_link);
4385da49fcbSDavid Xu 			ksi->ksi_sigq = dst;
4399104847fSDavid Xu 			if (p2 != NULL)
4409104847fSDavid Xu 				p2->p_pendingcnt++;
4419104847fSDavid Xu 		}
4429104847fSDavid Xu 	}
4439104847fSDavid Xu 
4449104847fSDavid Xu 	/* Move pending bits to target list */
4453dfcaad6SDavid Xu 	tmp = src->sq_kill;
4463dfcaad6SDavid Xu 	SIGSETAND(tmp, set);
4473dfcaad6SDavid Xu 	SIGSETOR(dst->sq_kill, tmp);
4483dfcaad6SDavid Xu 	SIGSETNAND(src->sq_kill, tmp);
4493dfcaad6SDavid Xu 
4509104847fSDavid Xu 	tmp = src->sq_signals;
4519104847fSDavid Xu 	SIGSETAND(tmp, set);
4529104847fSDavid Xu 	SIGSETOR(dst->sq_signals, tmp);
4539104847fSDavid Xu 	SIGSETNAND(src->sq_signals, tmp);
4549104847fSDavid Xu 
4559104847fSDavid Xu 	/* Finally, rescan src queue and set pending bits for it */
4569104847fSDavid Xu 	sigqueue_collect_set(src, &src->sq_signals);
4579104847fSDavid Xu }
4589104847fSDavid Xu 
4599104847fSDavid Xu void
4609104847fSDavid Xu sigqueue_move(sigqueue_t *src, sigqueue_t *dst, int signo)
4619104847fSDavid Xu {
4629104847fSDavid Xu 	sigset_t set;
4639104847fSDavid Xu 
4649104847fSDavid Xu 	SIGEMPTYSET(set);
4659104847fSDavid Xu 	SIGADDSET(set, signo);
4669104847fSDavid Xu 	sigqueue_move_set(src, dst, &set);
4679104847fSDavid Xu }
4689104847fSDavid Xu 
4699104847fSDavid Xu void
4709104847fSDavid Xu sigqueue_delete_set(sigqueue_t *sq, sigset_t *set)
4719104847fSDavid Xu {
4729104847fSDavid Xu 	struct proc *p = sq->sq_proc;
4739104847fSDavid Xu 	ksiginfo_t *ksi, *next;
4749104847fSDavid Xu 
4759104847fSDavid Xu 	KASSERT(sq->sq_flags & SQ_INIT, ("src sigqueue not inited"));
4769104847fSDavid Xu 
4779104847fSDavid Xu 	/* Remove siginfo queue */
4785c28a8d4SDavid Xu 	TAILQ_FOREACH_SAFE(ksi, &sq->sq_list, ksi_link, next) {
4799104847fSDavid Xu 		if (SIGISMEMBER(*set, ksi->ksi_signo)) {
4809104847fSDavid Xu 			TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link);
4815da49fcbSDavid Xu 			ksi->ksi_sigq = NULL;
4825da49fcbSDavid Xu 			if (ksiginfo_tryfree(ksi) && p != NULL)
4839104847fSDavid Xu 				p->p_pendingcnt--;
4849104847fSDavid Xu 		}
4859104847fSDavid Xu 	}
4863dfcaad6SDavid Xu 	SIGSETNAND(sq->sq_kill, *set);
4879104847fSDavid Xu 	SIGSETNAND(sq->sq_signals, *set);
4889104847fSDavid Xu 	/* Finally, rescan queue and set pending bits for it */
4899104847fSDavid Xu 	sigqueue_collect_set(sq, &sq->sq_signals);
4909104847fSDavid Xu }
4919104847fSDavid Xu 
4929104847fSDavid Xu void
4939104847fSDavid Xu sigqueue_delete(sigqueue_t *sq, int signo)
4949104847fSDavid Xu {
4959104847fSDavid Xu 	sigset_t set;
4969104847fSDavid Xu 
4979104847fSDavid Xu 	SIGEMPTYSET(set);
4989104847fSDavid Xu 	SIGADDSET(set, signo);
4999104847fSDavid Xu 	sigqueue_delete_set(sq, &set);
5009104847fSDavid Xu }
5019104847fSDavid Xu 
5029104847fSDavid Xu /* Remove a set of signals for a process */
5039104847fSDavid Xu void
5049104847fSDavid Xu sigqueue_delete_set_proc(struct proc *p, sigset_t *set)
5059104847fSDavid Xu {
5069104847fSDavid Xu 	sigqueue_t worklist;
5079104847fSDavid Xu 	struct thread *td0;
5089104847fSDavid Xu 
5099104847fSDavid Xu 	PROC_LOCK_ASSERT(p, MA_OWNED);
5109104847fSDavid Xu 
5119104847fSDavid Xu 	sigqueue_init(&worklist, NULL);
5129104847fSDavid Xu 	sigqueue_move_set(&p->p_sigqueue, &worklist, set);
5139104847fSDavid Xu 
5149104847fSDavid Xu 	mtx_lock_spin(&sched_lock);
5159104847fSDavid Xu 	FOREACH_THREAD_IN_PROC(p, td0)
5169104847fSDavid Xu 		sigqueue_move_set(&td0->td_sigqueue, &worklist, set);
5179104847fSDavid Xu 	mtx_unlock_spin(&sched_lock);
5189104847fSDavid Xu 
5199104847fSDavid Xu 	sigqueue_flush(&worklist);
5209104847fSDavid Xu }
5219104847fSDavid Xu 
5229104847fSDavid Xu void
5239104847fSDavid Xu sigqueue_delete_proc(struct proc *p, int signo)
5249104847fSDavid Xu {
5259104847fSDavid Xu 	sigset_t set;
5269104847fSDavid Xu 
5279104847fSDavid Xu 	SIGEMPTYSET(set);
5289104847fSDavid Xu 	SIGADDSET(set, signo);
5299104847fSDavid Xu 	sigqueue_delete_set_proc(p, &set);
5309104847fSDavid Xu }
5319104847fSDavid Xu 
5329104847fSDavid Xu void
5339104847fSDavid Xu sigqueue_delete_stopmask_proc(struct proc *p)
5349104847fSDavid Xu {
5359104847fSDavid Xu 	sigset_t set;
5369104847fSDavid Xu 
5379104847fSDavid Xu 	SIGEMPTYSET(set);
5389104847fSDavid Xu 	SIGADDSET(set, SIGSTOP);
5399104847fSDavid Xu 	SIGADDSET(set, SIGTSTP);
5409104847fSDavid Xu 	SIGADDSET(set, SIGTTIN);
5419104847fSDavid Xu 	SIGADDSET(set, SIGTTOU);
5429104847fSDavid Xu 	sigqueue_delete_set_proc(p, &set);
5439104847fSDavid Xu }
5449104847fSDavid Xu 
545fbbeeb6cSBruce Evans /*
546fbbeeb6cSBruce Evans  * Determine signal that should be delivered to process p, the current
547fbbeeb6cSBruce Evans  * process, 0 if none.  If there is a pending stop signal with default
548fbbeeb6cSBruce Evans  * action, the process stops in issignal().
549fbbeeb6cSBruce Evans  */
550fbbeeb6cSBruce Evans int
551e602ba25SJulian Elischer cursig(struct thread *td)
552fbbeeb6cSBruce Evans {
553c9dfa2e0SJeff Roberson 	PROC_LOCK_ASSERT(td->td_proc, MA_OWNED);
55490af4afaSJohn Baldwin 	mtx_assert(&td->td_proc->p_sigacts->ps_mtx, MA_OWNED);
555179235b3SBruce Evans 	mtx_assert(&sched_lock, MA_NOTOWNED);
5564093529dSJeff Roberson 	return (SIGPENDING(td) ? issignal(td) : 0);
557fbbeeb6cSBruce Evans }
558fbbeeb6cSBruce Evans 
55979065dbaSBruce Evans /*
56079065dbaSBruce Evans  * Arrange for ast() to handle unmasked pending signals on return to user
5619104847fSDavid Xu  * mode.  This must be called whenever a signal is added to td_sigqueue or
5624093529dSJeff Roberson  * unmasked in td_sigmask.
56379065dbaSBruce Evans  */
56479065dbaSBruce Evans void
5654093529dSJeff Roberson signotify(struct thread *td)
56679065dbaSBruce Evans {
5674093529dSJeff Roberson 	struct proc *p;
5688460a577SJohn Birrell #ifdef KSE
5699dde3bc9SDavid Xu 	sigset_t set, saved;
5708460a577SJohn Birrell #else
5718460a577SJohn Birrell 	sigset_t set;
5728460a577SJohn Birrell #endif
5734093529dSJeff Roberson 
5744093529dSJeff Roberson 	p = td->td_proc;
57579065dbaSBruce Evans 
57679065dbaSBruce Evans 	PROC_LOCK_ASSERT(p, MA_OWNED);
5774093529dSJeff Roberson 
5784093529dSJeff Roberson 	/*
5794093529dSJeff Roberson 	 * If our mask changed we may have to move signal that were
5809104847fSDavid Xu 	 * previously masked by all threads to our sigqueue.
5814093529dSJeff Roberson 	 */
5829104847fSDavid Xu 	set = p->p_sigqueue.sq_signals;
5838460a577SJohn Birrell #ifdef KSE
5849dde3bc9SDavid Xu 	if (p->p_flag & P_SA)
5859104847fSDavid Xu 		saved = p->p_sigqueue.sq_signals;
5868460a577SJohn Birrell #endif
5874093529dSJeff Roberson 	SIGSETNAND(set, td->td_sigmask);
5889104847fSDavid Xu 	if (! SIGISEMPTY(set))
5899104847fSDavid Xu 		sigqueue_move_set(&p->p_sigqueue, &td->td_sigqueue, &set);
5908b94a061SJohn Baldwin 	if (SIGPENDING(td)) {
59179065dbaSBruce Evans 		mtx_lock_spin(&sched_lock);
5924093529dSJeff Roberson 		td->td_flags |= TDF_NEEDSIGCHK | TDF_ASTPENDING;
59379065dbaSBruce Evans 		mtx_unlock_spin(&sched_lock);
59479065dbaSBruce Evans 	}
5958460a577SJohn Birrell #ifdef KSE
5969dde3bc9SDavid Xu 	if ((p->p_flag & P_SA) && !(p->p_flag & P_SIGEVENT)) {
5979104847fSDavid Xu 		if (!SIGSETEQ(saved, p->p_sigqueue.sq_signals)) {
5989dde3bc9SDavid Xu 			/* pending set changed */
5999dde3bc9SDavid Xu 			p->p_flag |= P_SIGEVENT;
6009dde3bc9SDavid Xu 			wakeup(&p->p_siglist);
6019dde3bc9SDavid Xu 		}
6029dde3bc9SDavid Xu 	}
6038460a577SJohn Birrell #endif
6048b94a061SJohn Baldwin }
6058b94a061SJohn Baldwin 
6068b94a061SJohn Baldwin int
6078b94a061SJohn Baldwin sigonstack(size_t sp)
6088b94a061SJohn Baldwin {
609a30ec4b9SDavid Xu 	struct thread *td = curthread;
6108b94a061SJohn Baldwin 
611a30ec4b9SDavid Xu 	return ((td->td_pflags & TDP_ALTSTACK) ?
6121930e303SPoul-Henning Kamp #if defined(COMPAT_43)
613a30ec4b9SDavid Xu 	    ((td->td_sigstk.ss_size == 0) ?
614a30ec4b9SDavid Xu 		(td->td_sigstk.ss_flags & SS_ONSTACK) :
615a30ec4b9SDavid Xu 		((sp - (size_t)td->td_sigstk.ss_sp) < td->td_sigstk.ss_size))
6168b94a061SJohn Baldwin #else
617a30ec4b9SDavid Xu 	    ((sp - (size_t)td->td_sigstk.ss_sp) < td->td_sigstk.ss_size)
6188b94a061SJohn Baldwin #endif
6198b94a061SJohn Baldwin 	    : 0);
6208b94a061SJohn Baldwin }
62179065dbaSBruce Evans 
6226f841fb7SMarcel Moolenaar static __inline int
6236f841fb7SMarcel Moolenaar sigprop(int sig)
6242c42a146SMarcel Moolenaar {
6256f841fb7SMarcel Moolenaar 
6262c42a146SMarcel Moolenaar 	if (sig > 0 && sig < NSIG)
6272c42a146SMarcel Moolenaar 		return (sigproptbl[_SIG_IDX(sig)]);
6282c42a146SMarcel Moolenaar 	return (0);
629df8bae1dSRodney W. Grimes }
6302c42a146SMarcel Moolenaar 
6314093529dSJeff Roberson int
6326f841fb7SMarcel Moolenaar sig_ffs(sigset_t *set)
6332c42a146SMarcel Moolenaar {
6342c42a146SMarcel Moolenaar 	int i;
6352c42a146SMarcel Moolenaar 
6366f841fb7SMarcel Moolenaar 	for (i = 0; i < _SIG_WORDS; i++)
6372c42a146SMarcel Moolenaar 		if (set->__bits[i])
6382c42a146SMarcel Moolenaar 			return (ffs(set->__bits[i]) + (i * 32));
639df8bae1dSRodney W. Grimes 	return (0);
640df8bae1dSRodney W. Grimes }
641df8bae1dSRodney W. Grimes 
6422c42a146SMarcel Moolenaar /*
6438f19eb88SIan Dowse  * kern_sigaction
6442c42a146SMarcel Moolenaar  * sigaction
64523eeeff7SPeter Wemm  * freebsd4_sigaction
6462c42a146SMarcel Moolenaar  * osigaction
6472c42a146SMarcel Moolenaar  */
6488f19eb88SIan Dowse int
64923eeeff7SPeter Wemm kern_sigaction(td, sig, act, oact, flags)
6508f19eb88SIan Dowse 	struct thread *td;
6512c42a146SMarcel Moolenaar 	register int sig;
6522c42a146SMarcel Moolenaar 	struct sigaction *act, *oact;
65323eeeff7SPeter Wemm 	int flags;
654df8bae1dSRodney W. Grimes {
65590af4afaSJohn Baldwin 	struct sigacts *ps;
6568f19eb88SIan Dowse 	struct proc *p = td->td_proc;
657df8bae1dSRodney W. Grimes 
6582899d606SDag-Erling Smørgrav 	if (!_SIG_VALID(sig))
6592c42a146SMarcel Moolenaar 		return (EINVAL);
6602c42a146SMarcel Moolenaar 
661628d2653SJohn Baldwin 	PROC_LOCK(p);
662628d2653SJohn Baldwin 	ps = p->p_sigacts;
66390af4afaSJohn Baldwin 	mtx_lock(&ps->ps_mtx);
6642c42a146SMarcel Moolenaar 	if (oact) {
6652c42a146SMarcel Moolenaar 		oact->sa_handler = ps->ps_sigact[_SIG_IDX(sig)];
6662c42a146SMarcel Moolenaar 		oact->sa_mask = ps->ps_catchmask[_SIG_IDX(sig)];
6672c42a146SMarcel Moolenaar 		oact->sa_flags = 0;
6682c42a146SMarcel Moolenaar 		if (SIGISMEMBER(ps->ps_sigonstack, sig))
6692c42a146SMarcel Moolenaar 			oact->sa_flags |= SA_ONSTACK;
6702c42a146SMarcel Moolenaar 		if (!SIGISMEMBER(ps->ps_sigintr, sig))
6712c42a146SMarcel Moolenaar 			oact->sa_flags |= SA_RESTART;
6722c42a146SMarcel Moolenaar 		if (SIGISMEMBER(ps->ps_sigreset, sig))
6732c42a146SMarcel Moolenaar 			oact->sa_flags |= SA_RESETHAND;
6742c42a146SMarcel Moolenaar 		if (SIGISMEMBER(ps->ps_signodefer, sig))
6752c42a146SMarcel Moolenaar 			oact->sa_flags |= SA_NODEFER;
6762c42a146SMarcel Moolenaar 		if (SIGISMEMBER(ps->ps_siginfo, sig))
6772c42a146SMarcel Moolenaar 			oact->sa_flags |= SA_SIGINFO;
67890af4afaSJohn Baldwin 		if (sig == SIGCHLD && ps->ps_flag & PS_NOCLDSTOP)
6792c42a146SMarcel Moolenaar 			oact->sa_flags |= SA_NOCLDSTOP;
68090af4afaSJohn Baldwin 		if (sig == SIGCHLD && ps->ps_flag & PS_NOCLDWAIT)
6812c42a146SMarcel Moolenaar 			oact->sa_flags |= SA_NOCLDWAIT;
6822c42a146SMarcel Moolenaar 	}
6832c42a146SMarcel Moolenaar 	if (act) {
6842c42a146SMarcel Moolenaar 		if ((sig == SIGKILL || sig == SIGSTOP) &&
685628d2653SJohn Baldwin 		    act->sa_handler != SIG_DFL) {
68690af4afaSJohn Baldwin 			mtx_unlock(&ps->ps_mtx);
687628d2653SJohn Baldwin 			PROC_UNLOCK(p);
6882c42a146SMarcel Moolenaar 			return (EINVAL);
689628d2653SJohn Baldwin 		}
6902c42a146SMarcel Moolenaar 
691df8bae1dSRodney W. Grimes 		/*
692df8bae1dSRodney W. Grimes 		 * Change setting atomically.
693df8bae1dSRodney W. Grimes 		 */
6942c42a146SMarcel Moolenaar 
6952c42a146SMarcel Moolenaar 		ps->ps_catchmask[_SIG_IDX(sig)] = act->sa_mask;
6962c42a146SMarcel Moolenaar 		SIG_CANTMASK(ps->ps_catchmask[_SIG_IDX(sig)]);
6972c42a146SMarcel Moolenaar 		if (act->sa_flags & SA_SIGINFO) {
698aa7a4daeSPeter Wemm 			ps->ps_sigact[_SIG_IDX(sig)] =
699aa7a4daeSPeter Wemm 			    (__sighandler_t *)act->sa_sigaction;
70080f42b55SIan Dowse 			SIGADDSET(ps->ps_siginfo, sig);
70180f42b55SIan Dowse 		} else {
70280f42b55SIan Dowse 			ps->ps_sigact[_SIG_IDX(sig)] = act->sa_handler;
7032c42a146SMarcel Moolenaar 			SIGDELSET(ps->ps_siginfo, sig);
7042c42a146SMarcel Moolenaar 		}
7052c42a146SMarcel Moolenaar 		if (!(act->sa_flags & SA_RESTART))
7062c42a146SMarcel Moolenaar 			SIGADDSET(ps->ps_sigintr, sig);
707df8bae1dSRodney W. Grimes 		else
7082c42a146SMarcel Moolenaar 			SIGDELSET(ps->ps_sigintr, sig);
7092c42a146SMarcel Moolenaar 		if (act->sa_flags & SA_ONSTACK)
7102c42a146SMarcel Moolenaar 			SIGADDSET(ps->ps_sigonstack, sig);
711df8bae1dSRodney W. Grimes 		else
7122c42a146SMarcel Moolenaar 			SIGDELSET(ps->ps_sigonstack, sig);
7132c42a146SMarcel Moolenaar 		if (act->sa_flags & SA_RESETHAND)
7142c42a146SMarcel Moolenaar 			SIGADDSET(ps->ps_sigreset, sig);
7151e41c1b5SSteven Wallace 		else
7162c42a146SMarcel Moolenaar 			SIGDELSET(ps->ps_sigreset, sig);
7172c42a146SMarcel Moolenaar 		if (act->sa_flags & SA_NODEFER)
7182c42a146SMarcel Moolenaar 			SIGADDSET(ps->ps_signodefer, sig);
719289ccde0SPeter Wemm 		else
7202c42a146SMarcel Moolenaar 			SIGDELSET(ps->ps_signodefer, sig);
7212c42a146SMarcel Moolenaar 		if (sig == SIGCHLD) {
7222c42a146SMarcel Moolenaar 			if (act->sa_flags & SA_NOCLDSTOP)
72390af4afaSJohn Baldwin 				ps->ps_flag |= PS_NOCLDSTOP;
7246626c604SJulian Elischer 			else
72590af4afaSJohn Baldwin 				ps->ps_flag &= ~PS_NOCLDSTOP;
726ba1551caSIan Dowse 			if (act->sa_flags & SA_NOCLDWAIT) {
727245f17d4SJoerg Wunsch 				/*
7282c42a146SMarcel Moolenaar 				 * Paranoia: since SA_NOCLDWAIT is implemented
7292c42a146SMarcel Moolenaar 				 * by reparenting the dying child to PID 1 (and
7302c42a146SMarcel Moolenaar 				 * trust it to reap the zombie), PID 1 itself
7312c42a146SMarcel Moolenaar 				 * is forbidden to set SA_NOCLDWAIT.
732245f17d4SJoerg Wunsch 				 */
733245f17d4SJoerg Wunsch 				if (p->p_pid == 1)
73490af4afaSJohn Baldwin 					ps->ps_flag &= ~PS_NOCLDWAIT;
7356626c604SJulian Elischer 				else
73690af4afaSJohn Baldwin 					ps->ps_flag |= PS_NOCLDWAIT;
737245f17d4SJoerg Wunsch 			} else
73890af4afaSJohn Baldwin 				ps->ps_flag &= ~PS_NOCLDWAIT;
739ba1551caSIan Dowse 			if (ps->ps_sigact[_SIG_IDX(SIGCHLD)] == SIG_IGN)
74090af4afaSJohn Baldwin 				ps->ps_flag |= PS_CLDSIGIGN;
741ba1551caSIan Dowse 			else
74290af4afaSJohn Baldwin 				ps->ps_flag &= ~PS_CLDSIGIGN;
743df8bae1dSRodney W. Grimes 		}
744df8bae1dSRodney W. Grimes 		/*
74590af4afaSJohn Baldwin 		 * Set bit in ps_sigignore for signals that are set to SIG_IGN,
7462c42a146SMarcel Moolenaar 		 * and for signals set to SIG_DFL where the default is to
74790af4afaSJohn Baldwin 		 * ignore. However, don't put SIGCONT in ps_sigignore, as we
7482c42a146SMarcel Moolenaar 		 * have to restart the process.
749df8bae1dSRodney W. Grimes 		 */
7502c42a146SMarcel Moolenaar 		if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN ||
7512c42a146SMarcel Moolenaar 		    (sigprop(sig) & SA_IGNORE &&
7522c42a146SMarcel Moolenaar 		     ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL)) {
7538460a577SJohn Birrell #ifdef KSE
7549dde3bc9SDavid Xu 			if ((p->p_flag & P_SA) &&
7559104847fSDavid Xu 			     SIGISMEMBER(p->p_sigqueue.sq_signals, sig)) {
7569dde3bc9SDavid Xu 				p->p_flag |= P_SIGEVENT;
7579dde3bc9SDavid Xu 				wakeup(&p->p_siglist);
7589dde3bc9SDavid Xu 			}
7598460a577SJohn Birrell #endif
7602c42a146SMarcel Moolenaar 			/* never to be seen again */
7619104847fSDavid Xu 			sigqueue_delete_proc(p, sig);
7622c42a146SMarcel Moolenaar 			if (sig != SIGCONT)
7632c42a146SMarcel Moolenaar 				/* easier in psignal */
76490af4afaSJohn Baldwin 				SIGADDSET(ps->ps_sigignore, sig);
76590af4afaSJohn Baldwin 			SIGDELSET(ps->ps_sigcatch, sig);
766645682fdSLuoqi Chen 		} else {
76790af4afaSJohn Baldwin 			SIGDELSET(ps->ps_sigignore, sig);
7682c42a146SMarcel Moolenaar 			if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL)
76990af4afaSJohn Baldwin 				SIGDELSET(ps->ps_sigcatch, sig);
7702c42a146SMarcel Moolenaar 			else
77190af4afaSJohn Baldwin 				SIGADDSET(ps->ps_sigcatch, sig);
7722c42a146SMarcel Moolenaar 		}
77323eeeff7SPeter Wemm #ifdef COMPAT_FREEBSD4
77423eeeff7SPeter Wemm 		if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN ||
77523eeeff7SPeter Wemm 		    ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL ||
77623eeeff7SPeter Wemm 		    (flags & KSA_FREEBSD4) == 0)
77723eeeff7SPeter Wemm 			SIGDELSET(ps->ps_freebsd4, sig);
77823eeeff7SPeter Wemm 		else
77923eeeff7SPeter Wemm 			SIGADDSET(ps->ps_freebsd4, sig);
78023eeeff7SPeter Wemm #endif
781e8ebc08fSPeter Wemm #ifdef COMPAT_43
782645682fdSLuoqi Chen 		if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN ||
78323eeeff7SPeter Wemm 		    ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL ||
78423eeeff7SPeter Wemm 		    (flags & KSA_OSIGSET) == 0)
785645682fdSLuoqi Chen 			SIGDELSET(ps->ps_osigset, sig);
786645682fdSLuoqi Chen 		else
787645682fdSLuoqi Chen 			SIGADDSET(ps->ps_osigset, sig);
788e8ebc08fSPeter Wemm #endif
789df8bae1dSRodney W. Grimes 	}
79090af4afaSJohn Baldwin 	mtx_unlock(&ps->ps_mtx);
791628d2653SJohn Baldwin 	PROC_UNLOCK(p);
7922c42a146SMarcel Moolenaar 	return (0);
7932c42a146SMarcel Moolenaar }
7942c42a146SMarcel Moolenaar 
7952c42a146SMarcel Moolenaar #ifndef _SYS_SYSPROTO_H_
7962c42a146SMarcel Moolenaar struct sigaction_args {
7972c42a146SMarcel Moolenaar 	int	sig;
7982c42a146SMarcel Moolenaar 	struct	sigaction *act;
7992c42a146SMarcel Moolenaar 	struct	sigaction *oact;
8002c42a146SMarcel Moolenaar };
8012c42a146SMarcel Moolenaar #endif
8022c42a146SMarcel Moolenaar int
803b40ce416SJulian Elischer sigaction(td, uap)
804b40ce416SJulian Elischer 	struct thread *td;
8052c42a146SMarcel Moolenaar 	register struct sigaction_args *uap;
8062c42a146SMarcel Moolenaar {
8072c42a146SMarcel Moolenaar 	struct sigaction act, oact;
8082c42a146SMarcel Moolenaar 	register struct sigaction *actp, *oactp;
8092c42a146SMarcel Moolenaar 	int error;
8102c42a146SMarcel Moolenaar 
8116f841fb7SMarcel Moolenaar 	actp = (uap->act != NULL) ? &act : NULL;
8126f841fb7SMarcel Moolenaar 	oactp = (uap->oact != NULL) ? &oact : NULL;
8132c42a146SMarcel Moolenaar 	if (actp) {
8146f841fb7SMarcel Moolenaar 		error = copyin(uap->act, actp, sizeof(act));
8152c42a146SMarcel Moolenaar 		if (error)
81644443757STim J. Robbins 			return (error);
8172c42a146SMarcel Moolenaar 	}
8188f19eb88SIan Dowse 	error = kern_sigaction(td, uap->sig, actp, oactp, 0);
81925d6dc06SJohn Baldwin 	if (oactp && !error)
8206f841fb7SMarcel Moolenaar 		error = copyout(oactp, uap->oact, sizeof(oact));
8212c42a146SMarcel Moolenaar 	return (error);
8222c42a146SMarcel Moolenaar }
8232c42a146SMarcel Moolenaar 
82423eeeff7SPeter Wemm #ifdef COMPAT_FREEBSD4
82523eeeff7SPeter Wemm #ifndef _SYS_SYSPROTO_H_
82623eeeff7SPeter Wemm struct freebsd4_sigaction_args {
82723eeeff7SPeter Wemm 	int	sig;
82823eeeff7SPeter Wemm 	struct	sigaction *act;
82923eeeff7SPeter Wemm 	struct	sigaction *oact;
83023eeeff7SPeter Wemm };
83123eeeff7SPeter Wemm #endif
83223eeeff7SPeter Wemm int
83323eeeff7SPeter Wemm freebsd4_sigaction(td, uap)
83423eeeff7SPeter Wemm 	struct thread *td;
83523eeeff7SPeter Wemm 	register struct freebsd4_sigaction_args *uap;
83623eeeff7SPeter Wemm {
83723eeeff7SPeter Wemm 	struct sigaction act, oact;
83823eeeff7SPeter Wemm 	register struct sigaction *actp, *oactp;
83923eeeff7SPeter Wemm 	int error;
84023eeeff7SPeter Wemm 
84123eeeff7SPeter Wemm 
84223eeeff7SPeter Wemm 	actp = (uap->act != NULL) ? &act : NULL;
84323eeeff7SPeter Wemm 	oactp = (uap->oact != NULL) ? &oact : NULL;
84423eeeff7SPeter Wemm 	if (actp) {
84523eeeff7SPeter Wemm 		error = copyin(uap->act, actp, sizeof(act));
84623eeeff7SPeter Wemm 		if (error)
84744443757STim J. Robbins 			return (error);
84823eeeff7SPeter Wemm 	}
84923eeeff7SPeter Wemm 	error = kern_sigaction(td, uap->sig, actp, oactp, KSA_FREEBSD4);
850a14e1189SJohn Baldwin 	if (oactp && !error)
85123eeeff7SPeter Wemm 		error = copyout(oactp, uap->oact, sizeof(oact));
85223eeeff7SPeter Wemm 	return (error);
85323eeeff7SPeter Wemm }
85423eeeff7SPeter Wemm #endif	/* COMAPT_FREEBSD4 */
85523eeeff7SPeter Wemm 
85631c8f3f0SMarcel Moolenaar #ifdef COMPAT_43	/* XXX - COMPAT_FBSD3 */
8572c42a146SMarcel Moolenaar #ifndef _SYS_SYSPROTO_H_
8582c42a146SMarcel Moolenaar struct osigaction_args {
8592c42a146SMarcel Moolenaar 	int	signum;
8602c42a146SMarcel Moolenaar 	struct	osigaction *nsa;
8612c42a146SMarcel Moolenaar 	struct	osigaction *osa;
8622c42a146SMarcel Moolenaar };
8632c42a146SMarcel Moolenaar #endif
8642c42a146SMarcel Moolenaar int
865b40ce416SJulian Elischer osigaction(td, uap)
866b40ce416SJulian Elischer 	struct thread *td;
8672c42a146SMarcel Moolenaar 	register struct osigaction_args *uap;
8682c42a146SMarcel Moolenaar {
8692c42a146SMarcel Moolenaar 	struct osigaction sa;
8702c42a146SMarcel Moolenaar 	struct sigaction nsa, osa;
8712c42a146SMarcel Moolenaar 	register struct sigaction *nsap, *osap;
8722c42a146SMarcel Moolenaar 	int error;
8732c42a146SMarcel Moolenaar 
8746f841fb7SMarcel Moolenaar 	if (uap->signum <= 0 || uap->signum >= ONSIG)
8756f841fb7SMarcel Moolenaar 		return (EINVAL);
876fb99ab88SMatthew Dillon 
8776f841fb7SMarcel Moolenaar 	nsap = (uap->nsa != NULL) ? &nsa : NULL;
8786f841fb7SMarcel Moolenaar 	osap = (uap->osa != NULL) ? &osa : NULL;
879fb99ab88SMatthew Dillon 
8802c42a146SMarcel Moolenaar 	if (nsap) {
8816f841fb7SMarcel Moolenaar 		error = copyin(uap->nsa, &sa, sizeof(sa));
8822c42a146SMarcel Moolenaar 		if (error)
88344443757STim J. Robbins 			return (error);
8842c42a146SMarcel Moolenaar 		nsap->sa_handler = sa.sa_handler;
8852c42a146SMarcel Moolenaar 		nsap->sa_flags = sa.sa_flags;
8862c42a146SMarcel Moolenaar 		OSIG2SIG(sa.sa_mask, nsap->sa_mask);
8872c42a146SMarcel Moolenaar 	}
88823eeeff7SPeter Wemm 	error = kern_sigaction(td, uap->signum, nsap, osap, KSA_OSIGSET);
8892c42a146SMarcel Moolenaar 	if (osap && !error) {
8902c42a146SMarcel Moolenaar 		sa.sa_handler = osap->sa_handler;
8912c42a146SMarcel Moolenaar 		sa.sa_flags = osap->sa_flags;
8922c42a146SMarcel Moolenaar 		SIG2OSIG(osap->sa_mask, sa.sa_mask);
8936f841fb7SMarcel Moolenaar 		error = copyout(&sa, uap->osa, sizeof(sa));
8942c42a146SMarcel Moolenaar 	}
8952c42a146SMarcel Moolenaar 	return (error);
8962c42a146SMarcel Moolenaar }
89723eeeff7SPeter Wemm 
89873dbd3daSJohn Baldwin #if !defined(__i386__)
89923eeeff7SPeter Wemm /* Avoid replicating the same stub everywhere */
90023eeeff7SPeter Wemm int
90123eeeff7SPeter Wemm osigreturn(td, uap)
90223eeeff7SPeter Wemm 	struct thread *td;
90323eeeff7SPeter Wemm 	struct osigreturn_args *uap;
90423eeeff7SPeter Wemm {
90523eeeff7SPeter Wemm 
90623eeeff7SPeter Wemm 	return (nosys(td, (struct nosys_args *)uap));
90723eeeff7SPeter Wemm }
90823eeeff7SPeter Wemm #endif
90931c8f3f0SMarcel Moolenaar #endif /* COMPAT_43 */
910df8bae1dSRodney W. Grimes 
911df8bae1dSRodney W. Grimes /*
912df8bae1dSRodney W. Grimes  * Initialize signal state for process 0;
913df8bae1dSRodney W. Grimes  * set to ignore signals that are ignored by default.
914df8bae1dSRodney W. Grimes  */
915df8bae1dSRodney W. Grimes void
916df8bae1dSRodney W. Grimes siginit(p)
917df8bae1dSRodney W. Grimes 	struct proc *p;
918df8bae1dSRodney W. Grimes {
919df8bae1dSRodney W. Grimes 	register int i;
92090af4afaSJohn Baldwin 	struct sigacts *ps;
921df8bae1dSRodney W. Grimes 
922628d2653SJohn Baldwin 	PROC_LOCK(p);
92390af4afaSJohn Baldwin 	ps = p->p_sigacts;
92490af4afaSJohn Baldwin 	mtx_lock(&ps->ps_mtx);
9252c42a146SMarcel Moolenaar 	for (i = 1; i <= NSIG; i++)
9262c42a146SMarcel Moolenaar 		if (sigprop(i) & SA_IGNORE && i != SIGCONT)
92790af4afaSJohn Baldwin 			SIGADDSET(ps->ps_sigignore, i);
92890af4afaSJohn Baldwin 	mtx_unlock(&ps->ps_mtx);
929628d2653SJohn Baldwin 	PROC_UNLOCK(p);
930df8bae1dSRodney W. Grimes }
931df8bae1dSRodney W. Grimes 
932df8bae1dSRodney W. Grimes /*
933df8bae1dSRodney W. Grimes  * Reset signals for an exec of the specified process.
934df8bae1dSRodney W. Grimes  */
935df8bae1dSRodney W. Grimes void
936a30ec4b9SDavid Xu execsigs(struct proc *p)
937df8bae1dSRodney W. Grimes {
938a30ec4b9SDavid Xu 	struct sigacts *ps;
939a30ec4b9SDavid Xu 	int sig;
940a30ec4b9SDavid Xu 	struct thread *td;
941df8bae1dSRodney W. Grimes 
942df8bae1dSRodney W. Grimes 	/*
943df8bae1dSRodney W. Grimes 	 * Reset caught signals.  Held signals remain held
9444093529dSJeff Roberson 	 * through td_sigmask (unless they were caught,
945df8bae1dSRodney W. Grimes 	 * and are now ignored by default).
946df8bae1dSRodney W. Grimes 	 */
9479b3b1c5fSJohn Baldwin 	PROC_LOCK_ASSERT(p, MA_OWNED);
948a30ec4b9SDavid Xu 	td = FIRST_THREAD_IN_PROC(p);
949628d2653SJohn Baldwin 	ps = p->p_sigacts;
95090af4afaSJohn Baldwin 	mtx_lock(&ps->ps_mtx);
95190af4afaSJohn Baldwin 	while (SIGNOTEMPTY(ps->ps_sigcatch)) {
95290af4afaSJohn Baldwin 		sig = sig_ffs(&ps->ps_sigcatch);
95390af4afaSJohn Baldwin 		SIGDELSET(ps->ps_sigcatch, sig);
9542c42a146SMarcel Moolenaar 		if (sigprop(sig) & SA_IGNORE) {
9552c42a146SMarcel Moolenaar 			if (sig != SIGCONT)
95690af4afaSJohn Baldwin 				SIGADDSET(ps->ps_sigignore, sig);
9579104847fSDavid Xu 			sigqueue_delete_proc(p, sig);
958df8bae1dSRodney W. Grimes 		}
9592c42a146SMarcel Moolenaar 		ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL;
960df8bae1dSRodney W. Grimes 	}
961df8bae1dSRodney W. Grimes 	/*
962df8bae1dSRodney W. Grimes 	 * Reset stack state to the user stack.
963df8bae1dSRodney W. Grimes 	 * Clear set of signals caught on the signal stack.
964df8bae1dSRodney W. Grimes 	 */
965a30ec4b9SDavid Xu 	td->td_sigstk.ss_flags = SS_DISABLE;
966a30ec4b9SDavid Xu 	td->td_sigstk.ss_size = 0;
967a30ec4b9SDavid Xu 	td->td_sigstk.ss_sp = 0;
968a30ec4b9SDavid Xu 	td->td_pflags &= ~TDP_ALTSTACK;
96980e907a1SPeter Wemm 	/*
97080e907a1SPeter Wemm 	 * Reset no zombies if child dies flag as Solaris does.
97180e907a1SPeter Wemm 	 */
97290af4afaSJohn Baldwin 	ps->ps_flag &= ~(PS_NOCLDWAIT | PS_CLDSIGIGN);
973c7fd62daSDavid Malone 	if (ps->ps_sigact[_SIG_IDX(SIGCHLD)] == SIG_IGN)
974c7fd62daSDavid Malone 		ps->ps_sigact[_SIG_IDX(SIGCHLD)] = SIG_DFL;
97590af4afaSJohn Baldwin 	mtx_unlock(&ps->ps_mtx);
976df8bae1dSRodney W. Grimes }
977df8bae1dSRodney W. Grimes 
978df8bae1dSRodney W. Grimes /*
979e77daab1SJohn Baldwin  * kern_sigprocmask()
9807c8fdcbdSMatthew Dillon  *
981628d2653SJohn Baldwin  *	Manipulate signal mask.
982df8bae1dSRodney W. Grimes  */
983e77daab1SJohn Baldwin int
984e77daab1SJohn Baldwin kern_sigprocmask(td, how, set, oset, old)
9854093529dSJeff Roberson 	struct thread *td;
9862c42a146SMarcel Moolenaar 	int how;
9872c42a146SMarcel Moolenaar 	sigset_t *set, *oset;
988645682fdSLuoqi Chen 	int old;
9892c42a146SMarcel Moolenaar {
9902c42a146SMarcel Moolenaar 	int error;
9912c42a146SMarcel Moolenaar 
9924093529dSJeff Roberson 	PROC_LOCK(td->td_proc);
9932c42a146SMarcel Moolenaar 	if (oset != NULL)
9944093529dSJeff Roberson 		*oset = td->td_sigmask;
9952c42a146SMarcel Moolenaar 
9962c42a146SMarcel Moolenaar 	error = 0;
9972c42a146SMarcel Moolenaar 	if (set != NULL) {
9982c42a146SMarcel Moolenaar 		switch (how) {
9992c42a146SMarcel Moolenaar 		case SIG_BLOCK:
1000645682fdSLuoqi Chen 			SIG_CANTMASK(*set);
10014093529dSJeff Roberson 			SIGSETOR(td->td_sigmask, *set);
10022c42a146SMarcel Moolenaar 			break;
10032c42a146SMarcel Moolenaar 		case SIG_UNBLOCK:
10044093529dSJeff Roberson 			SIGSETNAND(td->td_sigmask, *set);
10054093529dSJeff Roberson 			signotify(td);
10062c42a146SMarcel Moolenaar 			break;
10072c42a146SMarcel Moolenaar 		case SIG_SETMASK:
1008645682fdSLuoqi Chen 			SIG_CANTMASK(*set);
1009645682fdSLuoqi Chen 			if (old)
10104093529dSJeff Roberson 				SIGSETLO(td->td_sigmask, *set);
1011645682fdSLuoqi Chen 			else
10124093529dSJeff Roberson 				td->td_sigmask = *set;
10134093529dSJeff Roberson 			signotify(td);
10142c42a146SMarcel Moolenaar 			break;
10152c42a146SMarcel Moolenaar 		default:
10162c42a146SMarcel Moolenaar 			error = EINVAL;
10172c42a146SMarcel Moolenaar 			break;
10182c42a146SMarcel Moolenaar 		}
10192c42a146SMarcel Moolenaar 	}
10204093529dSJeff Roberson 	PROC_UNLOCK(td->td_proc);
10212c42a146SMarcel Moolenaar 	return (error);
10222c42a146SMarcel Moolenaar }
10232c42a146SMarcel Moolenaar 
1024d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_
1025df8bae1dSRodney W. Grimes struct sigprocmask_args {
1026df8bae1dSRodney W. Grimes 	int	how;
10272c42a146SMarcel Moolenaar 	const sigset_t *set;
10282c42a146SMarcel Moolenaar 	sigset_t *oset;
1029df8bae1dSRodney W. Grimes };
1030d2d3e875SBruce Evans #endif
103126f9a767SRodney W. Grimes int
1032b40ce416SJulian Elischer sigprocmask(td, uap)
1033b40ce416SJulian Elischer 	register struct thread *td;
1034df8bae1dSRodney W. Grimes 	struct sigprocmask_args *uap;
1035df8bae1dSRodney W. Grimes {
10362c42a146SMarcel Moolenaar 	sigset_t set, oset;
10372c42a146SMarcel Moolenaar 	sigset_t *setp, *osetp;
10382c42a146SMarcel Moolenaar 	int error;
1039df8bae1dSRodney W. Grimes 
10406f841fb7SMarcel Moolenaar 	setp = (uap->set != NULL) ? &set : NULL;
10416f841fb7SMarcel Moolenaar 	osetp = (uap->oset != NULL) ? &oset : NULL;
10422c42a146SMarcel Moolenaar 	if (setp) {
10436f841fb7SMarcel Moolenaar 		error = copyin(uap->set, setp, sizeof(set));
10442c42a146SMarcel Moolenaar 		if (error)
10452c42a146SMarcel Moolenaar 			return (error);
1046df8bae1dSRodney W. Grimes 	}
1047e77daab1SJohn Baldwin 	error = kern_sigprocmask(td, uap->how, setp, osetp, 0);
10482c42a146SMarcel Moolenaar 	if (osetp && !error) {
10496f841fb7SMarcel Moolenaar 		error = copyout(osetp, uap->oset, sizeof(oset));
10502c42a146SMarcel Moolenaar 	}
10512c42a146SMarcel Moolenaar 	return (error);
10522c42a146SMarcel Moolenaar }
10532c42a146SMarcel Moolenaar 
105431c8f3f0SMarcel Moolenaar #ifdef COMPAT_43	/* XXX - COMPAT_FBSD3 */
10552c42a146SMarcel Moolenaar #ifndef _SYS_SYSPROTO_H_
10562c42a146SMarcel Moolenaar struct osigprocmask_args {
10572c42a146SMarcel Moolenaar 	int	how;
10582c42a146SMarcel Moolenaar 	osigset_t mask;
10592c42a146SMarcel Moolenaar };
10602c42a146SMarcel Moolenaar #endif
10612c42a146SMarcel Moolenaar int
1062b40ce416SJulian Elischer osigprocmask(td, uap)
1063b40ce416SJulian Elischer 	register struct thread *td;
10642c42a146SMarcel Moolenaar 	struct osigprocmask_args *uap;
10652c42a146SMarcel Moolenaar {
10662c42a146SMarcel Moolenaar 	sigset_t set, oset;
10672c42a146SMarcel Moolenaar 	int error;
10682c42a146SMarcel Moolenaar 
10692c42a146SMarcel Moolenaar 	OSIG2SIG(uap->mask, set);
1070e77daab1SJohn Baldwin 	error = kern_sigprocmask(td, uap->how, &set, &oset, 1);
1071b40ce416SJulian Elischer 	SIG2OSIG(oset, td->td_retval[0]);
1072df8bae1dSRodney W. Grimes 	return (error);
1073df8bae1dSRodney W. Grimes }
107431c8f3f0SMarcel Moolenaar #endif /* COMPAT_43 */
1075df8bae1dSRodney W. Grimes 
107626f9a767SRodney W. Grimes int
1077a447cd8bSJeff Roberson sigwait(struct thread *td, struct sigwait_args *uap)
1078a447cd8bSJeff Roberson {
10799104847fSDavid Xu 	ksiginfo_t ksi;
1080a447cd8bSJeff Roberson 	sigset_t set;
1081a447cd8bSJeff Roberson 	int error;
1082a447cd8bSJeff Roberson 
1083a447cd8bSJeff Roberson 	error = copyin(uap->set, &set, sizeof(set));
108436939a0aSDavid Xu 	if (error) {
108536939a0aSDavid Xu 		td->td_retval[0] = error;
108636939a0aSDavid Xu 		return (0);
108736939a0aSDavid Xu 	}
1088a447cd8bSJeff Roberson 
10899104847fSDavid Xu 	error = kern_sigtimedwait(td, set, &ksi, NULL);
109036939a0aSDavid Xu 	if (error) {
109136939a0aSDavid Xu 		if (error == ERESTART)
1092a447cd8bSJeff Roberson 			return (error);
109336939a0aSDavid Xu 		td->td_retval[0] = error;
109436939a0aSDavid Xu 		return (0);
109536939a0aSDavid Xu 	}
1096a447cd8bSJeff Roberson 
10979104847fSDavid Xu 	error = copyout(&ksi.ksi_signo, uap->sig, sizeof(ksi.ksi_signo));
109836939a0aSDavid Xu 	td->td_retval[0] = error;
109936939a0aSDavid Xu 	return (0);
1100a447cd8bSJeff Roberson }
11010c14ff0eSRobert Watson 
1102a447cd8bSJeff Roberson int
1103a447cd8bSJeff Roberson sigtimedwait(struct thread *td, struct sigtimedwait_args *uap)
1104a447cd8bSJeff Roberson {
1105a447cd8bSJeff Roberson 	struct timespec ts;
1106a447cd8bSJeff Roberson 	struct timespec *timeout;
1107a447cd8bSJeff Roberson 	sigset_t set;
11089104847fSDavid Xu 	ksiginfo_t ksi;
1109a447cd8bSJeff Roberson 	int error;
1110a447cd8bSJeff Roberson 
1111a447cd8bSJeff Roberson 	if (uap->timeout) {
1112a447cd8bSJeff Roberson 		error = copyin(uap->timeout, &ts, sizeof(ts));
1113a447cd8bSJeff Roberson 		if (error)
1114a447cd8bSJeff Roberson 			return (error);
1115a447cd8bSJeff Roberson 
1116a447cd8bSJeff Roberson 		timeout = &ts;
1117a447cd8bSJeff Roberson 	} else
1118a447cd8bSJeff Roberson 		timeout = NULL;
1119a447cd8bSJeff Roberson 
1120a447cd8bSJeff Roberson 	error = copyin(uap->set, &set, sizeof(set));
1121a447cd8bSJeff Roberson 	if (error)
1122a447cd8bSJeff Roberson 		return (error);
1123a447cd8bSJeff Roberson 
11249104847fSDavid Xu 	error = kern_sigtimedwait(td, set, &ksi, timeout);
1125a447cd8bSJeff Roberson 	if (error)
1126a447cd8bSJeff Roberson 		return (error);
11279dde3bc9SDavid Xu 
1128418228dfSDavid Xu 	if (uap->info)
11299104847fSDavid Xu 		error = copyout(&ksi.ksi_info, uap->info, sizeof(siginfo_t));
11309104847fSDavid Xu 
11319104847fSDavid Xu 	if (error == 0)
11329104847fSDavid Xu 		td->td_retval[0] = ksi.ksi_signo;
1133a447cd8bSJeff Roberson 	return (error);
1134a447cd8bSJeff Roberson }
1135a447cd8bSJeff Roberson 
1136a447cd8bSJeff Roberson int
1137a447cd8bSJeff Roberson sigwaitinfo(struct thread *td, struct sigwaitinfo_args *uap)
1138a447cd8bSJeff Roberson {
11399104847fSDavid Xu 	ksiginfo_t ksi;
1140a447cd8bSJeff Roberson 	sigset_t set;
1141a447cd8bSJeff Roberson 	int error;
1142a447cd8bSJeff Roberson 
1143a447cd8bSJeff Roberson 	error = copyin(uap->set, &set, sizeof(set));
1144a447cd8bSJeff Roberson 	if (error)
1145a447cd8bSJeff Roberson 		return (error);
1146a447cd8bSJeff Roberson 
11479104847fSDavid Xu 	error = kern_sigtimedwait(td, set, &ksi, NULL);
1148a447cd8bSJeff Roberson 	if (error)
1149a447cd8bSJeff Roberson 		return (error);
1150a447cd8bSJeff Roberson 
1151418228dfSDavid Xu 	if (uap->info)
11529104847fSDavid Xu 		error = copyout(&ksi.ksi_info, uap->info, sizeof(siginfo_t));
11539104847fSDavid Xu 
11549104847fSDavid Xu 	if (error == 0)
11559104847fSDavid Xu 		td->td_retval[0] = ksi.ksi_signo;
1156a447cd8bSJeff Roberson 	return (error);
1157a447cd8bSJeff Roberson }
1158a447cd8bSJeff Roberson 
1159c6511aeaSDavid Xu int
11609104847fSDavid Xu kern_sigtimedwait(struct thread *td, sigset_t waitset, ksiginfo_t *ksi,
1161a447cd8bSJeff Roberson 	struct timespec *timeout)
1162a447cd8bSJeff Roberson {
11633074d1b4SDavid Xu 	struct sigacts *ps;
11646675b36eSDavid Xu 	sigset_t savedmask;
1165a447cd8bSJeff Roberson 	struct proc *p;
11661089f031SDavid Xu 	int error, sig, hz, i, timevalid = 0;
11671089f031SDavid Xu 	struct timespec rts, ets, ts;
11681089f031SDavid Xu 	struct timeval tv;
1169a447cd8bSJeff Roberson 
1170a447cd8bSJeff Roberson 	p = td->td_proc;
1171a447cd8bSJeff Roberson 	error = 0;
1172a447cd8bSJeff Roberson 	sig = 0;
11733074d1b4SDavid Xu 	SIG_CANTMASK(waitset);
1174a447cd8bSJeff Roberson 
1175a447cd8bSJeff Roberson 	PROC_LOCK(p);
1176a447cd8bSJeff Roberson 	ps = p->p_sigacts;
11773074d1b4SDavid Xu 	savedmask = td->td_sigmask;
11781089f031SDavid Xu 	if (timeout) {
11791089f031SDavid Xu 		if (timeout->tv_nsec >= 0 && timeout->tv_nsec < 1000000000) {
11801089f031SDavid Xu 			timevalid = 1;
11811089f031SDavid Xu 			getnanouptime(&rts);
11821089f031SDavid Xu 		 	ets = rts;
11831089f031SDavid Xu 			timespecadd(&ets, timeout);
11841089f031SDavid Xu 		}
11851089f031SDavid Xu 	}
11863074d1b4SDavid Xu 
11877e0221a2SDavid Xu restart:
11883074d1b4SDavid Xu 	for (i = 1; i <= _SIG_MAXSIG; ++i) {
11893074d1b4SDavid Xu 		if (!SIGISMEMBER(waitset, i))
11903074d1b4SDavid Xu 			continue;
11917e0221a2SDavid Xu 		if (!SIGISMEMBER(td->td_sigqueue.sq_signals, i)) {
11927e0221a2SDavid Xu 			if (SIGISMEMBER(p->p_sigqueue.sq_signals, i)) {
11938460a577SJohn Birrell #ifdef KSE
11943074d1b4SDavid Xu 				if (p->p_flag & P_SA) {
11953074d1b4SDavid Xu 					p->p_flag |= P_SIGEVENT;
11963074d1b4SDavid Xu 					wakeup(&p->p_siglist);
11973074d1b4SDavid Xu 				}
11988460a577SJohn Birrell #endif
11997e0221a2SDavid Xu 				sigqueue_move(&p->p_sigqueue,
12007e0221a2SDavid Xu 					&td->td_sigqueue, i);
12017e0221a2SDavid Xu 			} else
12027e0221a2SDavid Xu 				continue;
12037e0221a2SDavid Xu 		}
12047e0221a2SDavid Xu 
12053074d1b4SDavid Xu 		SIGFILLSET(td->td_sigmask);
12063074d1b4SDavid Xu 		SIG_CANTMASK(td->td_sigmask);
12073074d1b4SDavid Xu 		SIGDELSET(td->td_sigmask, i);
12083074d1b4SDavid Xu 		mtx_lock(&ps->ps_mtx);
12093074d1b4SDavid Xu 		sig = cursig(td);
12103074d1b4SDavid Xu 		mtx_unlock(&ps->ps_mtx);
12116675b36eSDavid Xu 		if (sig)
1212a447cd8bSJeff Roberson 			goto out;
12137e0221a2SDavid Xu 		else {
12147e0221a2SDavid Xu 			/*
12157e0221a2SDavid Xu 			 * Because cursig() may have stopped current thread,
12167e0221a2SDavid Xu 			 * after it is resumed, things may have already been
12177e0221a2SDavid Xu 			 * changed, it should rescan any pending signals.
12187e0221a2SDavid Xu 			 */
12197e0221a2SDavid Xu 			goto restart;
12203074d1b4SDavid Xu 		}
12217e0221a2SDavid Xu 	}
12227e0221a2SDavid Xu 
12233074d1b4SDavid Xu 	if (error)
12243074d1b4SDavid Xu 		goto out;
12253074d1b4SDavid Xu 
1226a447cd8bSJeff Roberson 	/*
1227a447cd8bSJeff Roberson 	 * POSIX says this must be checked after looking for pending
1228a447cd8bSJeff Roberson 	 * signals.
1229a447cd8bSJeff Roberson 	 */
1230a447cd8bSJeff Roberson 	if (timeout) {
12311089f031SDavid Xu 		if (!timevalid) {
1232a447cd8bSJeff Roberson 			error = EINVAL;
1233a447cd8bSJeff Roberson 			goto out;
1234a447cd8bSJeff Roberson 		}
12351089f031SDavid Xu 		getnanouptime(&rts);
12361089f031SDavid Xu 		if (timespeccmp(&rts, &ets, >=)) {
12373074d1b4SDavid Xu 			error = EAGAIN;
12383074d1b4SDavid Xu 			goto out;
12393074d1b4SDavid Xu 		}
12401089f031SDavid Xu 		ts = ets;
12411089f031SDavid Xu 		timespecsub(&ts, &rts);
12421089f031SDavid Xu 		TIMESPEC_TO_TIMEVAL(&tv, &ts);
1243a447cd8bSJeff Roberson 		hz = tvtohz(&tv);
1244a447cd8bSJeff Roberson 	} else
1245a447cd8bSJeff Roberson 		hz = 0;
1246a447cd8bSJeff Roberson 
12476675b36eSDavid Xu 	td->td_sigmask = savedmask;
12486675b36eSDavid Xu 	SIGSETNAND(td->td_sigmask, waitset);
12496675b36eSDavid Xu 	signotify(td);
125086b5e563SDag-Erling Smørgrav 	error = msleep(&ps, &p->p_mtx, PPAUSE|PCATCH, "sigwait", hz);
12511089f031SDavid Xu 	if (timeout) {
12521089f031SDavid Xu 		if (error == ERESTART) {
12531089f031SDavid Xu 			/* timeout can not be restarted. */
12543074d1b4SDavid Xu 			error = EINTR;
12551089f031SDavid Xu 		} else if (error == EAGAIN) {
12561089f031SDavid Xu 			/* will calculate timeout by ourself. */
12571089f031SDavid Xu 			error = 0;
12581089f031SDavid Xu 		}
12591089f031SDavid Xu 	}
12607e0221a2SDavid Xu 	goto restart;
12619dde3bc9SDavid Xu 
1262a447cd8bSJeff Roberson out:
12637e0221a2SDavid Xu 	td->td_sigmask = savedmask;
12647e0221a2SDavid Xu 	signotify(td);
1265a447cd8bSJeff Roberson 	if (sig) {
12665da49fcbSDavid Xu 		ksiginfo_init(ksi);
12679104847fSDavid Xu 		sigqueue_get(&td->td_sigqueue, sig, ksi);
12689104847fSDavid Xu 		ksi->ksi_signo = sig;
126956c06c4bSDavid Xu 		if (ksi->ksi_code == SI_TIMER)
127056c06c4bSDavid Xu 			itimer_accept(p, ksi->ksi_timerid, ksi);
12713074d1b4SDavid Xu 		error = 0;
12727e0221a2SDavid Xu 
12737e0221a2SDavid Xu #ifdef KTRACE
12747e0221a2SDavid Xu 		if (KTRPOINT(td, KTR_PSIG)) {
12757e0221a2SDavid Xu 			sig_t action;
12767e0221a2SDavid Xu 
12773074d1b4SDavid Xu 			mtx_lock(&ps->ps_mtx);
1278a447cd8bSJeff Roberson 			action = ps->ps_sigact[_SIG_IDX(sig)];
127990af4afaSJohn Baldwin 			mtx_unlock(&ps->ps_mtx);
12803074d1b4SDavid Xu 			ktrpsig(sig, action, &td->td_sigmask, 0);
12817e0221a2SDavid Xu 		}
1282a447cd8bSJeff Roberson #endif
12837b8d5e48SDavid Xu 		if (sig == SIGKILL)
12847e0221a2SDavid Xu 			sigexit(td, sig);
12853074d1b4SDavid Xu 	}
1286a447cd8bSJeff Roberson 	PROC_UNLOCK(p);
1287a447cd8bSJeff Roberson 	return (error);
1288a447cd8bSJeff Roberson }
1289a447cd8bSJeff Roberson 
12909104847fSDavid Xu #ifndef _SYS_SYSPROTO_H_
12919104847fSDavid Xu struct sigpending_args {
12929104847fSDavid Xu 	sigset_t	*set;
12939104847fSDavid Xu };
12949104847fSDavid Xu #endif
1295a447cd8bSJeff Roberson int
1296b40ce416SJulian Elischer sigpending(td, uap)
1297b40ce416SJulian Elischer 	struct thread *td;
1298df8bae1dSRodney W. Grimes 	struct sigpending_args *uap;
1299df8bae1dSRodney W. Grimes {
1300b40ce416SJulian Elischer 	struct proc *p = td->td_proc;
13019104847fSDavid Xu 	sigset_t pending;
1302df8bae1dSRodney W. Grimes 
1303628d2653SJohn Baldwin 	PROC_LOCK(p);
13049104847fSDavid Xu 	pending = p->p_sigqueue.sq_signals;
13059104847fSDavid Xu 	SIGSETOR(pending, td->td_sigqueue.sq_signals);
1306628d2653SJohn Baldwin 	PROC_UNLOCK(p);
13079104847fSDavid Xu 	return (copyout(&pending, uap->set, sizeof(sigset_t)));
13082c42a146SMarcel Moolenaar }
13092c42a146SMarcel Moolenaar 
131031c8f3f0SMarcel Moolenaar #ifdef COMPAT_43	/* XXX - COMPAT_FBSD3 */
13112c42a146SMarcel Moolenaar #ifndef _SYS_SYSPROTO_H_
13122c42a146SMarcel Moolenaar struct osigpending_args {
13132c42a146SMarcel Moolenaar 	int	dummy;
13142c42a146SMarcel Moolenaar };
13152c42a146SMarcel Moolenaar #endif
13162c42a146SMarcel Moolenaar int
1317b40ce416SJulian Elischer osigpending(td, uap)
1318b40ce416SJulian Elischer 	struct thread *td;
13192c42a146SMarcel Moolenaar 	struct osigpending_args *uap;
13202c42a146SMarcel Moolenaar {
1321b40ce416SJulian Elischer 	struct proc *p = td->td_proc;
13229104847fSDavid Xu 	sigset_t pending;
1323b40ce416SJulian Elischer 
1324628d2653SJohn Baldwin 	PROC_LOCK(p);
13259104847fSDavid Xu 	pending = p->p_sigqueue.sq_signals;
13269104847fSDavid Xu 	SIGSETOR(pending, td->td_sigqueue.sq_signals);
1327628d2653SJohn Baldwin 	PROC_UNLOCK(p);
13289104847fSDavid Xu 	SIG2OSIG(pending, td->td_retval[0]);
1329df8bae1dSRodney W. Grimes 	return (0);
1330df8bae1dSRodney W. Grimes }
133131c8f3f0SMarcel Moolenaar #endif /* COMPAT_43 */
1332df8bae1dSRodney W. Grimes 
13331930e303SPoul-Henning Kamp #if defined(COMPAT_43)
1334df8bae1dSRodney W. Grimes /*
1335df8bae1dSRodney W. Grimes  * Generalized interface signal handler, 4.3-compatible.
1336df8bae1dSRodney W. Grimes  */
1337d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_
1338df8bae1dSRodney W. Grimes struct osigvec_args {
1339df8bae1dSRodney W. Grimes 	int	signum;
1340df8bae1dSRodney W. Grimes 	struct	sigvec *nsv;
1341df8bae1dSRodney W. Grimes 	struct	sigvec *osv;
1342df8bae1dSRodney W. Grimes };
1343d2d3e875SBruce Evans #endif
1344df8bae1dSRodney W. Grimes /* ARGSUSED */
134526f9a767SRodney W. Grimes int
1346b40ce416SJulian Elischer osigvec(td, uap)
1347b40ce416SJulian Elischer 	struct thread *td;
1348df8bae1dSRodney W. Grimes 	register struct osigvec_args *uap;
1349df8bae1dSRodney W. Grimes {
1350df8bae1dSRodney W. Grimes 	struct sigvec vec;
13512c42a146SMarcel Moolenaar 	struct sigaction nsa, osa;
13522c42a146SMarcel Moolenaar 	register struct sigaction *nsap, *osap;
13532c42a146SMarcel Moolenaar 	int error;
1354df8bae1dSRodney W. Grimes 
13556f841fb7SMarcel Moolenaar 	if (uap->signum <= 0 || uap->signum >= ONSIG)
13566f841fb7SMarcel Moolenaar 		return (EINVAL);
13576f841fb7SMarcel Moolenaar 	nsap = (uap->nsv != NULL) ? &nsa : NULL;
13586f841fb7SMarcel Moolenaar 	osap = (uap->osv != NULL) ? &osa : NULL;
13592c42a146SMarcel Moolenaar 	if (nsap) {
13606f841fb7SMarcel Moolenaar 		error = copyin(uap->nsv, &vec, sizeof(vec));
13612c42a146SMarcel Moolenaar 		if (error)
1362df8bae1dSRodney W. Grimes 			return (error);
13632c42a146SMarcel Moolenaar 		nsap->sa_handler = vec.sv_handler;
13642c42a146SMarcel Moolenaar 		OSIG2SIG(vec.sv_mask, nsap->sa_mask);
13652c42a146SMarcel Moolenaar 		nsap->sa_flags = vec.sv_flags;
13662c42a146SMarcel Moolenaar 		nsap->sa_flags ^= SA_RESTART;	/* opposite of SV_INTERRUPT */
1367df8bae1dSRodney W. Grimes 	}
13685edadff9SJohn Baldwin 	error = kern_sigaction(td, uap->signum, nsap, osap, KSA_OSIGSET);
13692c42a146SMarcel Moolenaar 	if (osap && !error) {
13702c42a146SMarcel Moolenaar 		vec.sv_handler = osap->sa_handler;
13712c42a146SMarcel Moolenaar 		SIG2OSIG(osap->sa_mask, vec.sv_mask);
13722c42a146SMarcel Moolenaar 		vec.sv_flags = osap->sa_flags;
13732c42a146SMarcel Moolenaar 		vec.sv_flags &= ~SA_NOCLDWAIT;
13742c42a146SMarcel Moolenaar 		vec.sv_flags ^= SA_RESTART;
13756f841fb7SMarcel Moolenaar 		error = copyout(&vec, uap->osv, sizeof(vec));
13762c42a146SMarcel Moolenaar 	}
13772c42a146SMarcel Moolenaar 	return (error);
1378df8bae1dSRodney W. Grimes }
1379df8bae1dSRodney W. Grimes 
1380d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_
1381df8bae1dSRodney W. Grimes struct osigblock_args {
1382df8bae1dSRodney W. Grimes 	int	mask;
1383df8bae1dSRodney W. Grimes };
1384d2d3e875SBruce Evans #endif
138526f9a767SRodney W. Grimes int
1386b40ce416SJulian Elischer osigblock(td, uap)
1387b40ce416SJulian Elischer 	register struct thread *td;
1388df8bae1dSRodney W. Grimes 	struct osigblock_args *uap;
1389df8bae1dSRodney W. Grimes {
1390b40ce416SJulian Elischer 	struct proc *p = td->td_proc;
13912c42a146SMarcel Moolenaar 	sigset_t set;
1392df8bae1dSRodney W. Grimes 
13932c42a146SMarcel Moolenaar 	OSIG2SIG(uap->mask, set);
13942c42a146SMarcel Moolenaar 	SIG_CANTMASK(set);
1395628d2653SJohn Baldwin 	PROC_LOCK(p);
13964093529dSJeff Roberson 	SIG2OSIG(td->td_sigmask, td->td_retval[0]);
13974093529dSJeff Roberson 	SIGSETOR(td->td_sigmask, set);
1398628d2653SJohn Baldwin 	PROC_UNLOCK(p);
1399df8bae1dSRodney W. Grimes 	return (0);
1400df8bae1dSRodney W. Grimes }
1401df8bae1dSRodney W. Grimes 
1402d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_
1403df8bae1dSRodney W. Grimes struct osigsetmask_args {
1404df8bae1dSRodney W. Grimes 	int	mask;
1405df8bae1dSRodney W. Grimes };
1406d2d3e875SBruce Evans #endif
140726f9a767SRodney W. Grimes int
1408b40ce416SJulian Elischer osigsetmask(td, uap)
1409b40ce416SJulian Elischer 	struct thread *td;
1410df8bae1dSRodney W. Grimes 	struct osigsetmask_args *uap;
1411df8bae1dSRodney W. Grimes {
1412b40ce416SJulian Elischer 	struct proc *p = td->td_proc;
14132c42a146SMarcel Moolenaar 	sigset_t set;
1414df8bae1dSRodney W. Grimes 
14152c42a146SMarcel Moolenaar 	OSIG2SIG(uap->mask, set);
14162c42a146SMarcel Moolenaar 	SIG_CANTMASK(set);
1417628d2653SJohn Baldwin 	PROC_LOCK(p);
14184093529dSJeff Roberson 	SIG2OSIG(td->td_sigmask, td->td_retval[0]);
14194093529dSJeff Roberson 	SIGSETLO(td->td_sigmask, set);
14204093529dSJeff Roberson 	signotify(td);
1421628d2653SJohn Baldwin 	PROC_UNLOCK(p);
1422df8bae1dSRodney W. Grimes 	return (0);
1423df8bae1dSRodney W. Grimes }
14241930e303SPoul-Henning Kamp #endif /* COMPAT_43 */
1425df8bae1dSRodney W. Grimes 
1426df8bae1dSRodney W. Grimes /*
1427873fbcd7SRobert Watson  * Suspend calling thread until signal, providing mask to be set in the
1428873fbcd7SRobert Watson  * meantime.
1429df8bae1dSRodney W. Grimes  */
1430d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_
1431df8bae1dSRodney W. Grimes struct sigsuspend_args {
14322c42a146SMarcel Moolenaar 	const sigset_t *sigmask;
1433df8bae1dSRodney W. Grimes };
1434d2d3e875SBruce Evans #endif
1435df8bae1dSRodney W. Grimes /* ARGSUSED */
143626f9a767SRodney W. Grimes int
1437b40ce416SJulian Elischer sigsuspend(td, uap)
1438b40ce416SJulian Elischer 	struct thread *td;
1439df8bae1dSRodney W. Grimes 	struct sigsuspend_args *uap;
1440df8bae1dSRodney W. Grimes {
14412c42a146SMarcel Moolenaar 	sigset_t mask;
14422c42a146SMarcel Moolenaar 	int error;
14432c42a146SMarcel Moolenaar 
14446f841fb7SMarcel Moolenaar 	error = copyin(uap->sigmask, &mask, sizeof(mask));
14452c42a146SMarcel Moolenaar 	if (error)
14462c42a146SMarcel Moolenaar 		return (error);
14478f19eb88SIan Dowse 	return (kern_sigsuspend(td, mask));
14488f19eb88SIan Dowse }
14498f19eb88SIan Dowse 
14508f19eb88SIan Dowse int
14518f19eb88SIan Dowse kern_sigsuspend(struct thread *td, sigset_t mask)
14528f19eb88SIan Dowse {
14538f19eb88SIan Dowse 	struct proc *p = td->td_proc;
1454df8bae1dSRodney W. Grimes 
1455df8bae1dSRodney W. Grimes 	/*
1456645682fdSLuoqi Chen 	 * When returning from sigsuspend, we want
1457df8bae1dSRodney W. Grimes 	 * the old mask to be restored after the
1458df8bae1dSRodney W. Grimes 	 * signal handler has finished.  Thus, we
1459df8bae1dSRodney W. Grimes 	 * save it here and mark the sigacts structure
1460df8bae1dSRodney W. Grimes 	 * to indicate this.
1461df8bae1dSRodney W. Grimes 	 */
1462628d2653SJohn Baldwin 	PROC_LOCK(p);
14634093529dSJeff Roberson 	td->td_oldsigmask = td->td_sigmask;
14645e26dcb5SJohn Baldwin 	td->td_pflags |= TDP_OLDMASK;
1465645682fdSLuoqi Chen 	SIG_CANTMASK(mask);
14664093529dSJeff Roberson 	td->td_sigmask = mask;
14674093529dSJeff Roberson 	signotify(td);
146886b5e563SDag-Erling Smørgrav 	while (msleep(&p->p_sigacts, &p->p_mtx, PPAUSE|PCATCH, "pause", 0) == 0)
14692c42a146SMarcel Moolenaar 		/* void */;
1470628d2653SJohn Baldwin 	PROC_UNLOCK(p);
14712c42a146SMarcel Moolenaar 	/* always return EINTR rather than ERESTART... */
14722c42a146SMarcel Moolenaar 	return (EINTR);
14732c42a146SMarcel Moolenaar }
14742c42a146SMarcel Moolenaar 
147531c8f3f0SMarcel Moolenaar #ifdef COMPAT_43	/* XXX - COMPAT_FBSD3 */
147697563428SAlexander Kabaev /*
147797563428SAlexander Kabaev  * Compatibility sigsuspend call for old binaries.  Note nonstandard calling
147897563428SAlexander Kabaev  * convention: libc stub passes mask, not pointer, to save a copyin.
147997563428SAlexander Kabaev  */
14802c42a146SMarcel Moolenaar #ifndef _SYS_SYSPROTO_H_
14812c42a146SMarcel Moolenaar struct osigsuspend_args {
14822c42a146SMarcel Moolenaar 	osigset_t mask;
14832c42a146SMarcel Moolenaar };
14842c42a146SMarcel Moolenaar #endif
14852c42a146SMarcel Moolenaar /* ARGSUSED */
14862c42a146SMarcel Moolenaar int
1487b40ce416SJulian Elischer osigsuspend(td, uap)
1488b40ce416SJulian Elischer 	struct thread *td;
14892c42a146SMarcel Moolenaar 	struct osigsuspend_args *uap;
14902c42a146SMarcel Moolenaar {
1491b40ce416SJulian Elischer 	struct proc *p = td->td_proc;
1492645682fdSLuoqi Chen 	sigset_t mask;
14932c42a146SMarcel Moolenaar 
1494628d2653SJohn Baldwin 	PROC_LOCK(p);
14954093529dSJeff Roberson 	td->td_oldsigmask = td->td_sigmask;
14965e26dcb5SJohn Baldwin 	td->td_pflags |= TDP_OLDMASK;
1497645682fdSLuoqi Chen 	OSIG2SIG(uap->mask, mask);
1498645682fdSLuoqi Chen 	SIG_CANTMASK(mask);
14994093529dSJeff Roberson 	SIGSETLO(td->td_sigmask, mask);
15004093529dSJeff Roberson 	signotify(td);
150186b5e563SDag-Erling Smørgrav 	while (msleep(&p->p_sigacts, &p->p_mtx, PPAUSE|PCATCH, "opause", 0) == 0)
1502df8bae1dSRodney W. Grimes 		/* void */;
1503628d2653SJohn Baldwin 	PROC_UNLOCK(p);
1504df8bae1dSRodney W. Grimes 	/* always return EINTR rather than ERESTART... */
1505df8bae1dSRodney W. Grimes 	return (EINTR);
1506df8bae1dSRodney W. Grimes }
150731c8f3f0SMarcel Moolenaar #endif /* COMPAT_43 */
1508df8bae1dSRodney W. Grimes 
15091930e303SPoul-Henning Kamp #if defined(COMPAT_43)
1510d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_
1511df8bae1dSRodney W. Grimes struct osigstack_args {
1512df8bae1dSRodney W. Grimes 	struct	sigstack *nss;
1513df8bae1dSRodney W. Grimes 	struct	sigstack *oss;
1514df8bae1dSRodney W. Grimes };
1515d2d3e875SBruce Evans #endif
1516df8bae1dSRodney W. Grimes /* ARGSUSED */
151726f9a767SRodney W. Grimes int
1518b40ce416SJulian Elischer osigstack(td, uap)
1519b40ce416SJulian Elischer 	struct thread *td;
1520df8bae1dSRodney W. Grimes 	register struct osigstack_args *uap;
1521df8bae1dSRodney W. Grimes {
15225afe0c99SJohn Baldwin 	struct sigstack nss, oss;
1523fb99ab88SMatthew Dillon 	int error = 0;
1524fb99ab88SMatthew Dillon 
1525d034d459SMarcel Moolenaar 	if (uap->nss != NULL) {
15265afe0c99SJohn Baldwin 		error = copyin(uap->nss, &nss, sizeof(nss));
15275afe0c99SJohn Baldwin 		if (error)
15285afe0c99SJohn Baldwin 			return (error);
1529df8bae1dSRodney W. Grimes 	}
1530a30ec4b9SDavid Xu 	oss.ss_sp = td->td_sigstk.ss_sp;
15315afe0c99SJohn Baldwin 	oss.ss_onstack = sigonstack(cpu_getstack(td));
15325afe0c99SJohn Baldwin 	if (uap->nss != NULL) {
1533a30ec4b9SDavid Xu 		td->td_sigstk.ss_sp = nss.ss_sp;
1534a30ec4b9SDavid Xu 		td->td_sigstk.ss_size = 0;
1535a30ec4b9SDavid Xu 		td->td_sigstk.ss_flags |= nss.ss_onstack & SS_ONSTACK;
1536a30ec4b9SDavid Xu 		td->td_pflags |= TDP_ALTSTACK;
15375afe0c99SJohn Baldwin 	}
15385afe0c99SJohn Baldwin 	if (uap->oss != NULL)
15395afe0c99SJohn Baldwin 		error = copyout(&oss, uap->oss, sizeof(oss));
15405afe0c99SJohn Baldwin 
1541fb99ab88SMatthew Dillon 	return (error);
1542df8bae1dSRodney W. Grimes }
15431930e303SPoul-Henning Kamp #endif /* COMPAT_43 */
1544df8bae1dSRodney W. Grimes 
1545d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_
1546df8bae1dSRodney W. Grimes struct sigaltstack_args {
15472c42a146SMarcel Moolenaar 	stack_t	*ss;
15482c42a146SMarcel Moolenaar 	stack_t	*oss;
1549df8bae1dSRodney W. Grimes };
1550d2d3e875SBruce Evans #endif
1551df8bae1dSRodney W. Grimes /* ARGSUSED */
155226f9a767SRodney W. Grimes int
1553b40ce416SJulian Elischer sigaltstack(td, uap)
1554b40ce416SJulian Elischer 	struct thread *td;
1555df8bae1dSRodney W. Grimes 	register struct sigaltstack_args *uap;
1556df8bae1dSRodney W. Grimes {
15578f19eb88SIan Dowse 	stack_t ss, oss;
15588f19eb88SIan Dowse 	int error;
15598f19eb88SIan Dowse 
15608f19eb88SIan Dowse 	if (uap->ss != NULL) {
15618f19eb88SIan Dowse 		error = copyin(uap->ss, &ss, sizeof(ss));
15628f19eb88SIan Dowse 		if (error)
15638f19eb88SIan Dowse 			return (error);
15648f19eb88SIan Dowse 	}
15658f19eb88SIan Dowse 	error = kern_sigaltstack(td, (uap->ss != NULL) ? &ss : NULL,
15668f19eb88SIan Dowse 	    (uap->oss != NULL) ? &oss : NULL);
15678f19eb88SIan Dowse 	if (error)
15688f19eb88SIan Dowse 		return (error);
15698f19eb88SIan Dowse 	if (uap->oss != NULL)
15708f19eb88SIan Dowse 		error = copyout(&oss, uap->oss, sizeof(stack_t));
15718f19eb88SIan Dowse 	return (error);
15728f19eb88SIan Dowse }
15738f19eb88SIan Dowse 
15748f19eb88SIan Dowse int
15758f19eb88SIan Dowse kern_sigaltstack(struct thread *td, stack_t *ss, stack_t *oss)
15768f19eb88SIan Dowse {
1577b40ce416SJulian Elischer 	struct proc *p = td->td_proc;
1578fb99ab88SMatthew Dillon 	int oonstack;
1579fb99ab88SMatthew Dillon 
1580b40ce416SJulian Elischer 	oonstack = sigonstack(cpu_getstack(td));
1581d034d459SMarcel Moolenaar 
15828f19eb88SIan Dowse 	if (oss != NULL) {
1583a30ec4b9SDavid Xu 		*oss = td->td_sigstk;
1584a30ec4b9SDavid Xu 		oss->ss_flags = (td->td_pflags & TDP_ALTSTACK)
1585d034d459SMarcel Moolenaar 		    ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE;
1586df8bae1dSRodney W. Grimes 	}
1587d034d459SMarcel Moolenaar 
15888f19eb88SIan Dowse 	if (ss != NULL) {
1589a30ec4b9SDavid Xu 		if (oonstack)
1590cf60731bSJohn Baldwin 			return (EPERM);
1591a30ec4b9SDavid Xu 		if ((ss->ss_flags & ~SS_DISABLE) != 0)
1592cf60731bSJohn Baldwin 			return (EINVAL);
15938f19eb88SIan Dowse 		if (!(ss->ss_flags & SS_DISABLE)) {
15949104847fSDavid Xu 			if (ss->ss_size < p->p_sysent->sv_minsigstksz)
1595cf60731bSJohn Baldwin 				return (ENOMEM);
15969104847fSDavid Xu 
1597a30ec4b9SDavid Xu 			td->td_sigstk = *ss;
1598a30ec4b9SDavid Xu 			td->td_pflags |= TDP_ALTSTACK;
1599628d2653SJohn Baldwin 		} else {
1600a30ec4b9SDavid Xu 			td->td_pflags &= ~TDP_ALTSTACK;
1601628d2653SJohn Baldwin 		}
1602d034d459SMarcel Moolenaar 	}
1603cf60731bSJohn Baldwin 	return (0);
1604df8bae1dSRodney W. Grimes }
1605df8bae1dSRodney W. Grimes 
1606d93f860cSPoul-Henning Kamp /*
1607d93f860cSPoul-Henning Kamp  * Common code for kill process group/broadcast kill.
1608d93f860cSPoul-Henning Kamp  * cp is calling process.
1609d93f860cSPoul-Henning Kamp  */
161037c84183SPoul-Henning Kamp static int
16111a88a252SMaxim Sobolev killpg1(td, sig, pgid, all)
16129c1ab3e0SJohn Baldwin 	register struct thread *td;
16131a88a252SMaxim Sobolev 	int sig, pgid, all;
1614d93f860cSPoul-Henning Kamp {
1615d93f860cSPoul-Henning Kamp 	register struct proc *p;
1616d93f860cSPoul-Henning Kamp 	struct pgrp *pgrp;
1617d93f860cSPoul-Henning Kamp 	int nfound = 0;
1618d93f860cSPoul-Henning Kamp 
1619553629ebSJake Burkholder 	if (all) {
1620d93f860cSPoul-Henning Kamp 		/*
1621d93f860cSPoul-Henning Kamp 		 * broadcast
1622d93f860cSPoul-Henning Kamp 		 */
16231005a129SJohn Baldwin 		sx_slock(&allproc_lock);
16244f506694SXin LI 		FOREACH_PROC_IN_SYSTEM(p) {
1625628d2653SJohn Baldwin 			PROC_LOCK(p);
16269c1ab3e0SJohn Baldwin 			if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
162795f16c1eSPaul Saab 			    p == td->td_proc || p->p_state == PRS_NEW) {
1628628d2653SJohn Baldwin 				PROC_UNLOCK(p);
1629628d2653SJohn Baldwin 				continue;
1630628d2653SJohn Baldwin 			}
16311a88a252SMaxim Sobolev 			if (p_cansignal(td, p, sig) == 0) {
1632d93f860cSPoul-Henning Kamp 				nfound++;
163333a9ed9dSJohn Baldwin 				if (sig)
16342c42a146SMarcel Moolenaar 					psignal(p, sig);
1635628d2653SJohn Baldwin 			}
163633a9ed9dSJohn Baldwin 			PROC_UNLOCK(p);
1637d93f860cSPoul-Henning Kamp 		}
16381005a129SJohn Baldwin 		sx_sunlock(&allproc_lock);
1639553629ebSJake Burkholder 	} else {
1640ba626c1dSJohn Baldwin 		sx_slock(&proctree_lock);
1641f591779bSSeigo Tanimura 		if (pgid == 0) {
1642d93f860cSPoul-Henning Kamp 			/*
1643d93f860cSPoul-Henning Kamp 			 * zero pgid means send to my process group.
1644d93f860cSPoul-Henning Kamp 			 */
16459c1ab3e0SJohn Baldwin 			pgrp = td->td_proc->p_pgrp;
1646f591779bSSeigo Tanimura 			PGRP_LOCK(pgrp);
1647f591779bSSeigo Tanimura 		} else {
1648d93f860cSPoul-Henning Kamp 			pgrp = pgfind(pgid);
1649f591779bSSeigo Tanimura 			if (pgrp == NULL) {
1650ba626c1dSJohn Baldwin 				sx_sunlock(&proctree_lock);
1651d93f860cSPoul-Henning Kamp 				return (ESRCH);
1652d93f860cSPoul-Henning Kamp 			}
1653f591779bSSeigo Tanimura 		}
1654ba626c1dSJohn Baldwin 		sx_sunlock(&proctree_lock);
16552e3c8fcbSPoul-Henning Kamp 		LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
1656628d2653SJohn Baldwin 			PROC_LOCK(p);
165795f16c1eSPaul Saab 			if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
165895f16c1eSPaul Saab 				p->p_state == PRS_NEW ) {
1659628d2653SJohn Baldwin 				PROC_UNLOCK(p);
1660628d2653SJohn Baldwin 				continue;
1661628d2653SJohn Baldwin 			}
16621a88a252SMaxim Sobolev 			if (p_cansignal(td, p, sig) == 0) {
1663d93f860cSPoul-Henning Kamp 				nfound++;
166433a9ed9dSJohn Baldwin 				if (sig)
16652c42a146SMarcel Moolenaar 					psignal(p, sig);
1666628d2653SJohn Baldwin 			}
166733a9ed9dSJohn Baldwin 			PROC_UNLOCK(p);
1668d93f860cSPoul-Henning Kamp 		}
1669f591779bSSeigo Tanimura 		PGRP_UNLOCK(pgrp);
1670d93f860cSPoul-Henning Kamp 	}
1671d93f860cSPoul-Henning Kamp 	return (nfound ? 0 : ESRCH);
1672d93f860cSPoul-Henning Kamp }
1673d93f860cSPoul-Henning Kamp 
1674d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_
1675df8bae1dSRodney W. Grimes struct kill_args {
1676df8bae1dSRodney W. Grimes 	int	pid;
1677df8bae1dSRodney W. Grimes 	int	signum;
1678df8bae1dSRodney W. Grimes };
1679d2d3e875SBruce Evans #endif
1680df8bae1dSRodney W. Grimes /* ARGSUSED */
168126f9a767SRodney W. Grimes int
1682b40ce416SJulian Elischer kill(td, uap)
1683b40ce416SJulian Elischer 	register struct thread *td;
1684df8bae1dSRodney W. Grimes 	register struct kill_args *uap;
1685df8bae1dSRodney W. Grimes {
1686df8bae1dSRodney W. Grimes 	register struct proc *p;
168790af4afaSJohn Baldwin 	int error;
1688df8bae1dSRodney W. Grimes 
1689bfd7575aSWayne Salamon 	AUDIT_ARG(signum, uap->signum);
16906c1534a7SPeter Wemm 	if ((u_int)uap->signum > _SIG_MAXSIG)
1691df8bae1dSRodney W. Grimes 		return (EINVAL);
1692fb99ab88SMatthew Dillon 
1693df8bae1dSRodney W. Grimes 	if (uap->pid > 0) {
1694df8bae1dSRodney W. Grimes 		/* kill single process */
16950b011ea3SPawel Jakub Dawidek 		if ((p = pfind(uap->pid)) == NULL) {
169624b2151fSPawel Jakub Dawidek 			if ((p = zpfind(uap->pid)) == NULL)
169790af4afaSJohn Baldwin 				return (ESRCH);
16980b011ea3SPawel Jakub Dawidek 		}
1699bfd7575aSWayne Salamon 		AUDIT_ARG(process, p);
17001a88a252SMaxim Sobolev 		error = p_cansignal(td, p, uap->signum);
170190af4afaSJohn Baldwin 		if (error == 0 && uap->signum)
1702df8bae1dSRodney W. Grimes 			psignal(p, uap->signum);
1703628d2653SJohn Baldwin 		PROC_UNLOCK(p);
170490af4afaSJohn Baldwin 		return (error);
1705df8bae1dSRodney W. Grimes 	}
1706bfd7575aSWayne Salamon 	AUDIT_ARG(pid, uap->pid);
1707df8bae1dSRodney W. Grimes 	switch (uap->pid) {
1708df8bae1dSRodney W. Grimes 	case -1:		/* broadcast signal */
17091a88a252SMaxim Sobolev 		return (killpg1(td, uap->signum, 0, 1));
1710df8bae1dSRodney W. Grimes 	case 0:			/* signal own process group */
17111a88a252SMaxim Sobolev 		return (killpg1(td, uap->signum, 0, 0));
1712df8bae1dSRodney W. Grimes 	default:		/* negative explicit process group */
17131a88a252SMaxim Sobolev 		return (killpg1(td, uap->signum, -uap->pid, 0));
1714df8bae1dSRodney W. Grimes 	}
171590af4afaSJohn Baldwin 	/* NOTREACHED */
1716df8bae1dSRodney W. Grimes }
1717df8bae1dSRodney W. Grimes 
17181930e303SPoul-Henning Kamp #if defined(COMPAT_43)
1719d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_
1720df8bae1dSRodney W. Grimes struct okillpg_args {
1721df8bae1dSRodney W. Grimes 	int	pgid;
1722df8bae1dSRodney W. Grimes 	int	signum;
1723df8bae1dSRodney W. Grimes };
1724d2d3e875SBruce Evans #endif
1725df8bae1dSRodney W. Grimes /* ARGSUSED */
172626f9a767SRodney W. Grimes int
1727b40ce416SJulian Elischer okillpg(td, uap)
1728b40ce416SJulian Elischer 	struct thread *td;
1729df8bae1dSRodney W. Grimes 	register struct okillpg_args *uap;
1730df8bae1dSRodney W. Grimes {
1731df8bae1dSRodney W. Grimes 
1732bfd7575aSWayne Salamon 	AUDIT_ARG(signum, uap->signum);
1733bfd7575aSWayne Salamon 	AUDIT_ARG(pid, uap->pgid);
17346c1534a7SPeter Wemm 	if ((u_int)uap->signum > _SIG_MAXSIG)
1735df8bae1dSRodney W. Grimes 		return (EINVAL);
17369104847fSDavid Xu 
17371a88a252SMaxim Sobolev 	return (killpg1(td, uap->signum, uap->pgid, 0));
1738df8bae1dSRodney W. Grimes }
17391930e303SPoul-Henning Kamp #endif /* COMPAT_43 */
1740df8bae1dSRodney W. Grimes 
17419104847fSDavid Xu #ifndef _SYS_SYSPROTO_H_
17429104847fSDavid Xu struct sigqueue_args {
17439104847fSDavid Xu 	pid_t pid;
17449104847fSDavid Xu 	int signum;
17459104847fSDavid Xu 	/* union sigval */ void *value;
17469104847fSDavid Xu };
17479104847fSDavid Xu #endif
17489104847fSDavid Xu int
17499104847fSDavid Xu sigqueue(struct thread *td, struct sigqueue_args *uap)
17509104847fSDavid Xu {
17519104847fSDavid Xu 	ksiginfo_t ksi;
17529104847fSDavid Xu 	struct proc *p;
17539104847fSDavid Xu 	int error;
17549104847fSDavid Xu 
17559104847fSDavid Xu 	if ((u_int)uap->signum > _SIG_MAXSIG)
17569104847fSDavid Xu 		return (EINVAL);
17579104847fSDavid Xu 
17589104847fSDavid Xu 	/*
17599104847fSDavid Xu 	 * Specification says sigqueue can only send signal to
17609104847fSDavid Xu 	 * single process.
17619104847fSDavid Xu 	 */
17629104847fSDavid Xu 	if (uap->pid <= 0)
17639104847fSDavid Xu 		return (EINVAL);
17649104847fSDavid Xu 
17659104847fSDavid Xu 	if ((p = pfind(uap->pid)) == NULL) {
17669104847fSDavid Xu 		if ((p = zpfind(uap->pid)) == NULL)
17679104847fSDavid Xu 			return (ESRCH);
17689104847fSDavid Xu 	}
17699104847fSDavid Xu 	error = p_cansignal(td, p, uap->signum);
17709104847fSDavid Xu 	if (error == 0 && uap->signum != 0) {
17719104847fSDavid Xu 		ksiginfo_init(&ksi);
17729104847fSDavid Xu 		ksi.ksi_signo = uap->signum;
17739104847fSDavid Xu 		ksi.ksi_code = SI_QUEUE;
17749104847fSDavid Xu 		ksi.ksi_pid = td->td_proc->p_pid;
17759104847fSDavid Xu 		ksi.ksi_uid = td->td_ucred->cr_ruid;
17768f0371f1SDavid Xu 		ksi.ksi_value.sival_ptr = uap->value;
17776d7b314bSDavid Xu 		error = tdsignal(p, NULL, ksi.ksi_signo, &ksi);
17789104847fSDavid Xu 	}
17799104847fSDavid Xu 	PROC_UNLOCK(p);
17809104847fSDavid Xu 	return (error);
17819104847fSDavid Xu }
17829104847fSDavid Xu 
1783df8bae1dSRodney W. Grimes /*
1784df8bae1dSRodney W. Grimes  * Send a signal to a process group.
1785df8bae1dSRodney W. Grimes  */
1786df8bae1dSRodney W. Grimes void
17872c42a146SMarcel Moolenaar gsignal(pgid, sig)
17882c42a146SMarcel Moolenaar 	int pgid, sig;
1789df8bae1dSRodney W. Grimes {
1790df8bae1dSRodney W. Grimes 	struct pgrp *pgrp;
1791df8bae1dSRodney W. Grimes 
1792f591779bSSeigo Tanimura 	if (pgid != 0) {
1793ba626c1dSJohn Baldwin 		sx_slock(&proctree_lock);
1794f591779bSSeigo Tanimura 		pgrp = pgfind(pgid);
1795ba626c1dSJohn Baldwin 		sx_sunlock(&proctree_lock);
1796f591779bSSeigo Tanimura 		if (pgrp != NULL) {
17972c42a146SMarcel Moolenaar 			pgsignal(pgrp, sig, 0);
1798f591779bSSeigo Tanimura 			PGRP_UNLOCK(pgrp);
1799f591779bSSeigo Tanimura 		}
1800f591779bSSeigo Tanimura 	}
1801df8bae1dSRodney W. Grimes }
1802df8bae1dSRodney W. Grimes 
1803df8bae1dSRodney W. Grimes /*
1804df8bae1dSRodney W. Grimes  * Send a signal to a process group.  If checktty is 1,
1805df8bae1dSRodney W. Grimes  * limit to members which have a controlling terminal.
1806df8bae1dSRodney W. Grimes  */
1807df8bae1dSRodney W. Grimes void
18082c42a146SMarcel Moolenaar pgsignal(pgrp, sig, checkctty)
1809df8bae1dSRodney W. Grimes 	struct pgrp *pgrp;
18102c42a146SMarcel Moolenaar 	int sig, checkctty;
1811df8bae1dSRodney W. Grimes {
1812df8bae1dSRodney W. Grimes 	register struct proc *p;
1813df8bae1dSRodney W. Grimes 
1814628d2653SJohn Baldwin 	if (pgrp) {
1815f591779bSSeigo Tanimura 		PGRP_LOCK_ASSERT(pgrp, MA_OWNED);
1816628d2653SJohn Baldwin 		LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
1817628d2653SJohn Baldwin 			PROC_LOCK(p);
1818df8bae1dSRodney W. Grimes 			if (checkctty == 0 || p->p_flag & P_CONTROLT)
18192c42a146SMarcel Moolenaar 				psignal(p, sig);
1820628d2653SJohn Baldwin 			PROC_UNLOCK(p);
1821628d2653SJohn Baldwin 		}
1822628d2653SJohn Baldwin 	}
1823df8bae1dSRodney W. Grimes }
1824df8bae1dSRodney W. Grimes 
1825df8bae1dSRodney W. Grimes /*
18260c14ff0eSRobert Watson  * Send a signal caused by a trap to the current thread.  If it will be
18270c14ff0eSRobert Watson  * caught immediately, deliver it with correct code.  Otherwise, post it
18280c14ff0eSRobert Watson  * normally.
1829df8bae1dSRodney W. Grimes  */
1830df8bae1dSRodney W. Grimes void
18319104847fSDavid Xu trapsignal(struct thread *td, ksiginfo_t *ksi)
1832df8bae1dSRodney W. Grimes {
18331bf4700bSJeff Roberson 	struct sigacts *ps;
18341bf4700bSJeff Roberson 	struct proc *p;
18358460a577SJohn Birrell #ifdef KSE
18369dde3bc9SDavid Xu 	int error;
18378460a577SJohn Birrell #endif
18389104847fSDavid Xu 	int sig;
18399104847fSDavid Xu 	int code;
18401bf4700bSJeff Roberson 
18411bf4700bSJeff Roberson 	p = td->td_proc;
18429104847fSDavid Xu 	sig = ksi->ksi_signo;
18439104847fSDavid Xu 	code = ksi->ksi_code;
18449104847fSDavid Xu 	KASSERT(_SIG_VALID(sig), ("invalid signal"));
18459104847fSDavid Xu 
18468460a577SJohn Birrell #ifdef KSE
1847aa0aa7a1STim J. Robbins 	if (td->td_pflags & TDP_SA) {
18487eeaaf9bSDavid Xu 		if (td->td_mailbox == NULL)
18495995adc2SJulian Elischer 			thread_user_enter(td);
1850628d2653SJohn Baldwin 		PROC_LOCK(p);
18519dde3bc9SDavid Xu 		SIGDELSET(td->td_sigmask, sig);
18529dde3bc9SDavid Xu 		mtx_lock_spin(&sched_lock);
18539dde3bc9SDavid Xu 		/*
18549dde3bc9SDavid Xu 		 * Force scheduling an upcall, so UTS has chance to
18559dde3bc9SDavid Xu 		 * process the signal before thread runs again in
18569dde3bc9SDavid Xu 		 * userland.
18579dde3bc9SDavid Xu 		 */
18589dde3bc9SDavid Xu 		if (td->td_upcall)
18599dde3bc9SDavid Xu 			td->td_upcall->ku_flags |= KUF_DOUPCALL;
18609dde3bc9SDavid Xu 		mtx_unlock_spin(&sched_lock);
1861432b45deSDavid Xu 	} else {
18629dde3bc9SDavid Xu 		PROC_LOCK(p);
18639dde3bc9SDavid Xu 	}
18648460a577SJohn Birrell #else
18658460a577SJohn Birrell 	PROC_LOCK(p);
18668460a577SJohn Birrell #endif
1867ef3dab76STim J. Robbins 	ps = p->p_sigacts;
186890af4afaSJohn Baldwin 	mtx_lock(&ps->ps_mtx);
186990af4afaSJohn Baldwin 	if ((p->p_flag & P_TRACED) == 0 && SIGISMEMBER(ps->ps_sigcatch, sig) &&
18704093529dSJeff Roberson 	    !SIGISMEMBER(td->td_sigmask, sig)) {
1871df8bae1dSRodney W. Grimes 		p->p_stats->p_ru.ru_nsignals++;
1872df8bae1dSRodney W. Grimes #ifdef KTRACE
1873374a15aaSJohn Baldwin 		if (KTRPOINT(curthread, KTR_PSIG))
1874374a15aaSJohn Baldwin 			ktrpsig(sig, ps->ps_sigact[_SIG_IDX(sig)],
18754093529dSJeff Roberson 			    &td->td_sigmask, code);
1876df8bae1dSRodney W. Grimes #endif
18778460a577SJohn Birrell #ifdef KSE
1878aa0aa7a1STim J. Robbins 		if (!(td->td_pflags & TDP_SA))
18799104847fSDavid Xu 			(*p->p_sysent->sv_sendsig)(ps->ps_sigact[_SIG_IDX(sig)],
18809104847fSDavid Xu 				ksi, &td->td_sigmask);
18818460a577SJohn Birrell #else
18828460a577SJohn Birrell 		(*p->p_sysent->sv_sendsig)(ps->ps_sigact[_SIG_IDX(sig)],
18838460a577SJohn Birrell 				ksi, &td->td_sigmask);
18848460a577SJohn Birrell #endif
18858460a577SJohn Birrell #ifdef KSE
1886cbf4e354SDavid Xu 		else if (td->td_mailbox == NULL) {
1887cbf4e354SDavid Xu 			mtx_unlock(&ps->ps_mtx);
1888cbf4e354SDavid Xu 			/* UTS caused a sync signal */
1889cbf4e354SDavid Xu 			p->p_code = code;	/* XXX for core dump/debugger */
1890cbf4e354SDavid Xu 			p->p_sig = sig;		/* XXX to verify code */
1891cbf4e354SDavid Xu 			sigexit(td, sig);
1892cbf4e354SDavid Xu 		} else {
18939dde3bc9SDavid Xu 			mtx_unlock(&ps->ps_mtx);
1894cbf4e354SDavid Xu 			SIGADDSET(td->td_sigmask, sig);
18959dde3bc9SDavid Xu 			PROC_UNLOCK(p);
18969104847fSDavid Xu 			error = copyout(&ksi->ksi_info, &td->td_mailbox->tm_syncsig,
18979104847fSDavid Xu 			    sizeof(siginfo_t));
18989dde3bc9SDavid Xu 			PROC_LOCK(p);
1899432b45deSDavid Xu 			/* UTS memory corrupted */
19009dde3bc9SDavid Xu 			if (error)
1901cbf4e354SDavid Xu 				sigexit(td, SIGSEGV);
19029dde3bc9SDavid Xu 			mtx_lock(&ps->ps_mtx);
19039dde3bc9SDavid Xu 		}
19048460a577SJohn Birrell #endif
19054093529dSJeff Roberson 		SIGSETOR(td->td_sigmask, ps->ps_catchmask[_SIG_IDX(sig)]);
19062c42a146SMarcel Moolenaar 		if (!SIGISMEMBER(ps->ps_signodefer, sig))
19074093529dSJeff Roberson 			SIGADDSET(td->td_sigmask, sig);
19082c42a146SMarcel Moolenaar 		if (SIGISMEMBER(ps->ps_sigreset, sig)) {
1909289ccde0SPeter Wemm 			/*
19108f19eb88SIan Dowse 			 * See kern_sigaction() for origin of this code.
1911289ccde0SPeter Wemm 			 */
191290af4afaSJohn Baldwin 			SIGDELSET(ps->ps_sigcatch, sig);
19132c42a146SMarcel Moolenaar 			if (sig != SIGCONT &&
19142c42a146SMarcel Moolenaar 			    sigprop(sig) & SA_IGNORE)
191590af4afaSJohn Baldwin 				SIGADDSET(ps->ps_sigignore, sig);
19162c42a146SMarcel Moolenaar 			ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL;
1917dedc04feSPeter Wemm 		}
191890af4afaSJohn Baldwin 		mtx_unlock(&ps->ps_mtx);
19196f841fb7SMarcel Moolenaar 	} else {
1920f71a882fSDavid Xu 		/*
1921f71a882fSDavid Xu 		 * Avoid a possible infinite loop if the thread
1922f71a882fSDavid Xu 		 * masking the signal or process is ignoring the
1923f71a882fSDavid Xu 		 * signal.
1924f71a882fSDavid Xu 		 */
1925f71a882fSDavid Xu 		if (kern_forcesigexit &&
1926f71a882fSDavid Xu 		    (SIGISMEMBER(td->td_sigmask, sig) ||
1927f71a882fSDavid Xu 		     ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN)) {
1928f71a882fSDavid Xu 			SIGDELSET(td->td_sigmask, sig);
1929f71a882fSDavid Xu 			SIGDELSET(ps->ps_sigcatch, sig);
1930f71a882fSDavid Xu 			SIGDELSET(ps->ps_sigignore, sig);
1931f71a882fSDavid Xu 			ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL;
1932f71a882fSDavid Xu 		}
193390af4afaSJohn Baldwin 		mtx_unlock(&ps->ps_mtx);
19346626c604SJulian Elischer 		p->p_code = code;	/* XXX for core dump/debugger */
19352c42a146SMarcel Moolenaar 		p->p_sig = sig;		/* XXX to verify code */
19366d7b314bSDavid Xu 		tdsignal(p, td, sig, ksi);
1937df8bae1dSRodney W. Grimes 	}
1938628d2653SJohn Baldwin 	PROC_UNLOCK(p);
1939df8bae1dSRodney W. Grimes }
1940df8bae1dSRodney W. Grimes 
19414093529dSJeff Roberson static struct thread *
19424093529dSJeff Roberson sigtd(struct proc *p, int sig, int prop)
19434093529dSJeff Roberson {
19443074d1b4SDavid Xu 	struct thread *td, *signal_td;
19454093529dSJeff Roberson 
19464093529dSJeff Roberson 	PROC_LOCK_ASSERT(p, MA_OWNED);
19474093529dSJeff Roberson 
19484093529dSJeff Roberson 	/*
1949627451c1SDavid Xu 	 * Check if current thread can handle the signal without
1950627451c1SDavid Xu 	 * switching conetxt to another thread.
19514093529dSJeff Roberson 	 */
1952627451c1SDavid Xu 	if (curproc == p && !SIGISMEMBER(curthread->td_sigmask, sig))
1953627451c1SDavid Xu 		return (curthread);
19543074d1b4SDavid Xu 	signal_td = NULL;
1955a9a48d68SDavid Xu 	mtx_lock_spin(&sched_lock);
19563074d1b4SDavid Xu 	FOREACH_THREAD_IN_PROC(p, td) {
19573074d1b4SDavid Xu 		if (!SIGISMEMBER(td->td_sigmask, sig)) {
19583074d1b4SDavid Xu 			signal_td = td;
1959627451c1SDavid Xu 			break;
19603074d1b4SDavid Xu 		}
19613074d1b4SDavid Xu 	}
19623074d1b4SDavid Xu 	if (signal_td == NULL)
19633074d1b4SDavid Xu 		signal_td = FIRST_THREAD_IN_PROC(p);
1964a9a48d68SDavid Xu 	mtx_unlock_spin(&sched_lock);
19653074d1b4SDavid Xu 	return (signal_td);
19664093529dSJeff Roberson }
19674093529dSJeff Roberson 
1968df8bae1dSRodney W. Grimes /*
1969df8bae1dSRodney W. Grimes  * Send the signal to the process.  If the signal has an action, the action
1970df8bae1dSRodney W. Grimes  * is usually performed by the target process rather than the caller; we add
1971df8bae1dSRodney W. Grimes  * the signal to the set of pending signals for the process.
1972df8bae1dSRodney W. Grimes  *
1973df8bae1dSRodney W. Grimes  * Exceptions:
1974df8bae1dSRodney W. Grimes  *   o When a stop signal is sent to a sleeping process that takes the
1975df8bae1dSRodney W. Grimes  *     default action, the process is stopped without awakening it.
1976df8bae1dSRodney W. Grimes  *   o SIGCONT restarts stopped processes (or puts them back to sleep)
1977df8bae1dSRodney W. Grimes  *     regardless of the signal action (eg, blocked or ignored).
1978df8bae1dSRodney W. Grimes  *
1979df8bae1dSRodney W. Grimes  * Other ignored signals are discarded immediately.
1980df8bae1dSRodney W. Grimes  */
1981df8bae1dSRodney W. Grimes void
19824093529dSJeff Roberson psignal(struct proc *p, int sig)
1983df8bae1dSRodney W. Grimes {
19846d7b314bSDavid Xu 	(void) tdsignal(p, NULL, sig, NULL);
19859104847fSDavid Xu }
19869104847fSDavid Xu 
19879104847fSDavid Xu int
19886d7b314bSDavid Xu psignal_event(struct proc *p, struct sigevent *sigev, ksiginfo_t *ksi)
19899104847fSDavid Xu {
19906d7b314bSDavid Xu 	struct thread *td = NULL;
199141b3077aSJacques Vidrine 
19924093529dSJeff Roberson 	PROC_LOCK_ASSERT(p, MA_OWNED);
19936d7b314bSDavid Xu 
19946d7b314bSDavid Xu 	KASSERT(!KSI_ONQ(ksi), ("psignal_event: ksi on queue"));
19954093529dSJeff Roberson 
19964093529dSJeff Roberson 	/*
19976d7b314bSDavid Xu 	 * ksi_code and other fields should be set before
19986d7b314bSDavid Xu 	 * calling this function.
19994093529dSJeff Roberson 	 */
20006d7b314bSDavid Xu 	ksi->ksi_signo = sigev->sigev_signo;
20016d7b314bSDavid Xu 	ksi->ksi_value = sigev->sigev_value;
20026d7b314bSDavid Xu 	if (sigev->sigev_notify == SIGEV_THREAD_ID) {
20036d7b314bSDavid Xu 		td = thread_find(p, sigev->sigev_notify_thread_id);
20046d7b314bSDavid Xu 		if (td == NULL)
20056d7b314bSDavid Xu 			return (ESRCH);
20066d7b314bSDavid Xu 	}
20076d7b314bSDavid Xu 	return (tdsignal(p, td, ksi->ksi_signo, ksi));
20084093529dSJeff Roberson }
20094093529dSJeff Roberson 
20109104847fSDavid Xu int
20116d7b314bSDavid Xu tdsignal(struct proc *p, struct thread *td, int sig, ksiginfo_t *ksi)
20124093529dSJeff Roberson {
20138460a577SJohn Birrell #ifdef KSE
20149dde3bc9SDavid Xu 	sigset_t saved;
20159104847fSDavid Xu 	int ret;
20169dde3bc9SDavid Xu 
20179dde3bc9SDavid Xu 	if (p->p_flag & P_SA)
20189104847fSDavid Xu 		saved = p->p_sigqueue.sq_signals;
20196d7b314bSDavid Xu 	ret = do_tdsignal(p, td, sig, ksi);
20209dde3bc9SDavid Xu 	if ((p->p_flag & P_SA) && !(p->p_flag & P_SIGEVENT)) {
20219104847fSDavid Xu 		if (!SIGSETEQ(saved, p->p_sigqueue.sq_signals)) {
20229dde3bc9SDavid Xu 			/* pending set changed */
20239dde3bc9SDavid Xu 			p->p_flag |= P_SIGEVENT;
20249dde3bc9SDavid Xu 			wakeup(&p->p_siglist);
20259dde3bc9SDavid Xu 		}
20269dde3bc9SDavid Xu 	}
20279104847fSDavid Xu 	return (ret);
20289dde3bc9SDavid Xu }
20299dde3bc9SDavid Xu 
20309104847fSDavid Xu static int
20316d7b314bSDavid Xu do_tdsignal(struct proc *p, struct thread *td, int sig, ksiginfo_t *ksi)
20329dde3bc9SDavid Xu {
20338460a577SJohn Birrell #endif
20349104847fSDavid Xu 	sig_t action;
20359104847fSDavid Xu 	sigqueue_t *sigqueue;
20369104847fSDavid Xu 	int prop;
203790af4afaSJohn Baldwin 	struct sigacts *ps;
203894f0972bSDavid Xu 	int intrval;
20399104847fSDavid Xu 	int ret = 0;
2040df8bae1dSRodney W. Grimes 
20416d7b314bSDavid Xu 	PROC_LOCK_ASSERT(p, MA_OWNED);
20426d7b314bSDavid Xu 
204341b3077aSJacques Vidrine 	if (!_SIG_VALID(sig))
20448460a577SJohn Birrell #ifdef KSE
2045d60226bdSXin LI 		panic("do_tdsignal(): invalid signal %d", sig);
20468460a577SJohn Birrell #else
2047d60226bdSXin LI 		panic("tdsignal(): invalid signal %d", sig);
20488460a577SJohn Birrell #endif
20494093529dSJeff Roberson 
20508460a577SJohn Birrell #ifdef KSE
20516d7b314bSDavid Xu 	KASSERT(ksi == NULL || !KSI_ONQ(ksi), ("do_tdsignal: ksi on queue"));
20528460a577SJohn Birrell #else
20538460a577SJohn Birrell 	KASSERT(ksi == NULL || !KSI_ONQ(ksi), ("tdsignal: ksi on queue"));
20548460a577SJohn Birrell #endif
20556d7b314bSDavid Xu 
20566d7b314bSDavid Xu 	/*
20576d7b314bSDavid Xu 	 * IEEE Std 1003.1-2001: return success when killing a zombie.
20586d7b314bSDavid Xu 	 */
20596d7b314bSDavid Xu 	if (p->p_state == PRS_ZOMBIE) {
20606d7b314bSDavid Xu 		if (ksi && (ksi->ksi_flags & KSI_INS))
20616d7b314bSDavid Xu 			ksiginfo_tryfree(ksi);
20626d7b314bSDavid Xu 		return (ret);
20636d7b314bSDavid Xu 	}
20646d7b314bSDavid Xu 
206590af4afaSJohn Baldwin 	ps = p->p_sigacts;
2066ad3b9257SJohn-Mark Gurney 	KNOTE_LOCKED(&p->p_klist, NOTE_SIGNAL | sig);
20672c42a146SMarcel Moolenaar 	prop = sigprop(sig);
20684093529dSJeff Roberson 
20694093529dSJeff Roberson 	/*
207014b5ae1aSMike Makonnen 	 * If the signal is blocked and not destined for this thread, then
207114b5ae1aSMike Makonnen 	 * assign it to the process so that we can find it later in the first
207214b5ae1aSMike Makonnen 	 * thread that unblocks it.  Otherwise, assign it to this thread now.
20734093529dSJeff Roberson 	 */
20746d7b314bSDavid Xu 	if (td == NULL) {
20756d7b314bSDavid Xu 		td = sigtd(p, sig, prop);
20766d7b314bSDavid Xu 		if (SIGISMEMBER(td->td_sigmask, sig))
20776d7b314bSDavid Xu 			sigqueue = &p->p_sigqueue;
20786d7b314bSDavid Xu 		else
20799104847fSDavid Xu 			sigqueue = &td->td_sigqueue;
20803074d1b4SDavid Xu 	} else {
20816d7b314bSDavid Xu 		KASSERT(td->td_proc == p, ("invalid thread"));
20829104847fSDavid Xu 		sigqueue = &td->td_sigqueue;
20833074d1b4SDavid Xu 	}
20844093529dSJeff Roberson 
2085df8bae1dSRodney W. Grimes 	/*
2086df8bae1dSRodney W. Grimes 	 * If the signal is being ignored,
2087df8bae1dSRodney W. Grimes 	 * then we forget about it immediately.
208890af4afaSJohn Baldwin 	 * (Note: we don't set SIGCONT in ps_sigignore,
2089df8bae1dSRodney W. Grimes 	 * and if it is set to SIG_IGN,
2090df8bae1dSRodney W. Grimes 	 * action will be SIG_DFL here.)
2091df8bae1dSRodney W. Grimes 	 */
209290af4afaSJohn Baldwin 	mtx_lock(&ps->ps_mtx);
20930fc32899SJohn Baldwin 	if (SIGISMEMBER(ps->ps_sigignore, sig)) {
209490af4afaSJohn Baldwin 		mtx_unlock(&ps->ps_mtx);
20956d7b314bSDavid Xu 		if (ksi && (ksi->ksi_flags & KSI_INS))
20966d7b314bSDavid Xu 			ksiginfo_tryfree(ksi);
20979104847fSDavid Xu 		return (ret);
209890af4afaSJohn Baldwin 	}
20996675b36eSDavid Xu 	if (SIGISMEMBER(td->td_sigmask, sig))
2100df8bae1dSRodney W. Grimes 		action = SIG_HOLD;
210190af4afaSJohn Baldwin 	else if (SIGISMEMBER(ps->ps_sigcatch, sig))
2102df8bae1dSRodney W. Grimes 		action = SIG_CATCH;
2103df8bae1dSRodney W. Grimes 	else
2104df8bae1dSRodney W. Grimes 		action = SIG_DFL;
210594f0972bSDavid Xu 	if (SIGISMEMBER(ps->ps_sigintr, sig))
210694f0972bSDavid Xu 		intrval = EINTR;
210794f0972bSDavid Xu 	else
210894f0972bSDavid Xu 		intrval = ERESTART;
210990af4afaSJohn Baldwin 	mtx_unlock(&ps->ps_mtx);
2110df8bae1dSRodney W. Grimes 
21119104847fSDavid Xu 	if (prop & SA_CONT)
21129104847fSDavid Xu 		sigqueue_delete_stopmask_proc(p);
21139104847fSDavid Xu 	else if (prop & SA_STOP) {
2114df8bae1dSRodney W. Grimes 		/*
2115df8bae1dSRodney W. Grimes 		 * If sending a tty stop signal to a member of an orphaned
2116df8bae1dSRodney W. Grimes 		 * process group, discard the signal here if the action
2117df8bae1dSRodney W. Grimes 		 * is default; don't stop the process below if sleeping,
2118df8bae1dSRodney W. Grimes 		 * and don't clear any pending SIGCONT.
2119df8bae1dSRodney W. Grimes 		 */
2120e602ba25SJulian Elischer 		if ((prop & SA_TTYSTOP) &&
2121e602ba25SJulian Elischer 		    (p->p_pgrp->pg_jobc == 0) &&
21226d7b314bSDavid Xu 		    (action == SIG_DFL)) {
21236d7b314bSDavid Xu 			if (ksi && (ksi->ksi_flags & KSI_INS))
21246d7b314bSDavid Xu 				ksiginfo_tryfree(ksi);
21259104847fSDavid Xu 			return (ret);
21266d7b314bSDavid Xu 		}
21279104847fSDavid Xu 		sigqueue_delete_proc(p, SIGCONT);
2128ebceaf6dSDavid Xu 		if (p->p_flag & P_CONTINUED) {
21296933e3c1SJulian Elischer 			p->p_flag &= ~P_CONTINUED;
2130ebceaf6dSDavid Xu 			PROC_LOCK(p->p_pptr);
2131ebceaf6dSDavid Xu 			sigqueue_take(p->p_ksi);
2132ebceaf6dSDavid Xu 			PROC_UNLOCK(p->p_pptr);
2133ebceaf6dSDavid Xu 		}
2134df8bae1dSRodney W. Grimes 	}
21353074d1b4SDavid Xu 
21369104847fSDavid Xu 	ret = sigqueue_add(sigqueue, sig, ksi);
21379104847fSDavid Xu 	if (ret != 0)
21389104847fSDavid Xu 		return (ret);
21396d7b314bSDavid Xu 	signotify(td);
21405312b1c7SDavid Xu 	/*
21415312b1c7SDavid Xu 	 * Defer further processing for signals which are held,
21425312b1c7SDavid Xu 	 * except that stopped processes must be continued by SIGCONT.
21435312b1c7SDavid Xu 	 */
21445312b1c7SDavid Xu 	if (action == SIG_HOLD &&
21455312b1c7SDavid Xu 	    !((prop & SA_CONT) && (p->p_flag & P_STOPPED_SIG)))
21469104847fSDavid Xu 		return (ret);
2147df8bae1dSRodney W. Grimes 	/*
214890d75f78SAlfred Perlstein 	 * SIGKILL: Remove procfs STOPEVENTs.
214990d75f78SAlfred Perlstein 	 */
215090d75f78SAlfred Perlstein 	if (sig == SIGKILL) {
215190d75f78SAlfred Perlstein 		/* from procfs_ioctl.c: PIOCBIC */
215290d75f78SAlfred Perlstein 		p->p_stops = 0;
215390d75f78SAlfred Perlstein 		/* from procfs_ioctl.c: PIOCCONT */
215490d75f78SAlfred Perlstein 		p->p_step = 0;
215590d75f78SAlfred Perlstein 		wakeup(&p->p_step);
215690d75f78SAlfred Perlstein 	}
215790d75f78SAlfred Perlstein 	/*
2158e602ba25SJulian Elischer 	 * Some signals have a process-wide effect and a per-thread
2159e602ba25SJulian Elischer 	 * component.  Most processing occurs when the process next
2160e602ba25SJulian Elischer 	 * tries to cross the user boundary, however there are some
2161e602ba25SJulian Elischer 	 * times when processing needs to be done immediatly, such as
2162e602ba25SJulian Elischer 	 * waking up threads so that they can cross the user boundary.
2163e602ba25SJulian Elischer 	 * We try do the per-process part here.
2164df8bae1dSRodney W. Grimes 	 */
2165e602ba25SJulian Elischer 	if (P_SHOULDSTOP(p)) {
2166e602ba25SJulian Elischer 		/*
2167e602ba25SJulian Elischer 		 * The process is in stopped mode. All the threads should be
2168e602ba25SJulian Elischer 		 * either winding down or already on the suspended queue.
2169e602ba25SJulian Elischer 		 */
2170e602ba25SJulian Elischer 		if (p->p_flag & P_TRACED) {
2171e602ba25SJulian Elischer 			/*
2172e602ba25SJulian Elischer 			 * The traced process is already stopped,
2173e602ba25SJulian Elischer 			 * so no further action is necessary.
2174e602ba25SJulian Elischer 			 * No signal can restart us.
2175e602ba25SJulian Elischer 			 */
2176e602ba25SJulian Elischer 			goto out;
21771c32c37cSJohn Baldwin 		}
2178b40ce416SJulian Elischer 
2179e602ba25SJulian Elischer 		if (sig == SIGKILL) {
2180df8bae1dSRodney W. Grimes 			/*
2181e602ba25SJulian Elischer 			 * SIGKILL sets process running.
2182e602ba25SJulian Elischer 			 * It will die elsewhere.
2183e602ba25SJulian Elischer 			 * All threads must be restarted.
2184df8bae1dSRodney W. Grimes 			 */
2185482d099cSDavid Xu 			p->p_flag &= ~P_STOPPED_SIG;
2186e602ba25SJulian Elischer 			goto runfast;
2187e602ba25SJulian Elischer 		}
2188e602ba25SJulian Elischer 
2189e602ba25SJulian Elischer 		if (prop & SA_CONT) {
2190e602ba25SJulian Elischer 			/*
2191e602ba25SJulian Elischer 			 * If SIGCONT is default (or ignored), we continue the
21929104847fSDavid Xu 			 * process but don't leave the signal in sigqueue as
21931d9c5696SJuli Mallett 			 * it has no further action.  If SIGCONT is held, we
2194e602ba25SJulian Elischer 			 * continue the process and leave the signal in
21959104847fSDavid Xu 			 * sigqueue.  If the process catches SIGCONT, let it
2196e602ba25SJulian Elischer 			 * handle the signal itself.  If it isn't waiting on
2197e602ba25SJulian Elischer 			 * an event, it goes back to run state.
2198e602ba25SJulian Elischer 			 * Otherwise, process goes back to sleep state.
2199e602ba25SJulian Elischer 			 */
22001279572aSDavid Xu 			p->p_flag &= ~P_STOPPED_SIG;
2201ebceaf6dSDavid Xu 			if (p->p_numthreads == p->p_suspcount) {
22026933e3c1SJulian Elischer 				p->p_flag |= P_CONTINUED;
22037f96995eSDavid Xu 				p->p_xstat = SIGCONT;
22047f96995eSDavid Xu 				PROC_LOCK(p->p_pptr);
2205ebceaf6dSDavid Xu 				childproc_continued(p);
22067f96995eSDavid Xu 				PROC_UNLOCK(p->p_pptr);
2207ebceaf6dSDavid Xu 			}
2208e602ba25SJulian Elischer 			if (action == SIG_DFL) {
22099104847fSDavid Xu 				sigqueue_delete(sigqueue, sig);
2210e602ba25SJulian Elischer 			} else if (action == SIG_CATCH) {
22118460a577SJohn Birrell #ifdef KSE
2212e602ba25SJulian Elischer 				/*
2213e602ba25SJulian Elischer 				 * The process wants to catch it so it needs
2214e602ba25SJulian Elischer 				 * to run at least one thread, but which one?
2215e602ba25SJulian Elischer 				 * It would seem that the answer would be to
2216e602ba25SJulian Elischer 				 * run an upcall in the next KSE to run, and
2217e602ba25SJulian Elischer 				 * deliver the signal that way. In a NON KSE
2218e602ba25SJulian Elischer 				 * process, we need to make sure that the
2219e602ba25SJulian Elischer 				 * single thread is runnable asap.
2220e602ba25SJulian Elischer 				 * XXXKSE for now however, make them all run.
2221e602ba25SJulian Elischer 				 */
22228460a577SJohn Birrell #else
22238460a577SJohn Birrell 				/*
22248460a577SJohn Birrell 				 * The process wants to catch it so it needs
22258460a577SJohn Birrell 				 * to run at least one thread, but which one?
22268460a577SJohn Birrell 				 */
22278460a577SJohn Birrell #endif
2228e602ba25SJulian Elischer 				goto runfast;
2229e602ba25SJulian Elischer 			}
2230e602ba25SJulian Elischer 			/*
2231e602ba25SJulian Elischer 			 * The signal is not ignored or caught.
2232e602ba25SJulian Elischer 			 */
2233e602ba25SJulian Elischer 			mtx_lock_spin(&sched_lock);
223404774f23SJulian Elischer 			thread_unsuspend(p);
2235e602ba25SJulian Elischer 			mtx_unlock_spin(&sched_lock);
2236e602ba25SJulian Elischer 			goto out;
2237e602ba25SJulian Elischer 		}
2238e602ba25SJulian Elischer 
2239e602ba25SJulian Elischer 		if (prop & SA_STOP) {
2240e602ba25SJulian Elischer 			/*
2241e602ba25SJulian Elischer 			 * Already stopped, don't need to stop again
2242e602ba25SJulian Elischer 			 * (If we did the shell could get confused).
224304774f23SJulian Elischer 			 * Just make sure the signal STOP bit set.
2244e602ba25SJulian Elischer 			 */
22451279572aSDavid Xu 			p->p_flag |= P_STOPPED_SIG;
22469104847fSDavid Xu 			sigqueue_delete(sigqueue, sig);
2247e602ba25SJulian Elischer 			goto out;
2248e602ba25SJulian Elischer 		}
2249e602ba25SJulian Elischer 
2250e602ba25SJulian Elischer 		/*
2251e602ba25SJulian Elischer 		 * All other kinds of signals:
2252e602ba25SJulian Elischer 		 * If a thread is sleeping interruptibly, simulate a
2253e602ba25SJulian Elischer 		 * wakeup so that when it is continued it will be made
2254e602ba25SJulian Elischer 		 * runnable and can look at the signal.  However, don't make
225504774f23SJulian Elischer 		 * the PROCESS runnable, leave it stopped.
2256e602ba25SJulian Elischer 		 * It may run a bit until it hits a thread_suspend_check().
2257e602ba25SJulian Elischer 		 */
2258e602ba25SJulian Elischer 		mtx_lock_spin(&sched_lock);
225944f3b092SJohn Baldwin 		if (TD_ON_SLEEPQ(td) && (td->td_flags & TDF_SINTR))
226094f0972bSDavid Xu 			sleepq_abort(td, intrval);
2261e602ba25SJulian Elischer 		mtx_unlock_spin(&sched_lock);
2262df8bae1dSRodney W. Grimes 		goto out;
2263df8bae1dSRodney W. Grimes 		/*
22649a6a4cb5SPeter Wemm 		 * Mutexes are short lived. Threads waiting on them will
22659a6a4cb5SPeter Wemm 		 * hit thread_suspend_check() soon.
2266df8bae1dSRodney W. Grimes 		 */
2267e602ba25SJulian Elischer 	} else if (p->p_state == PRS_NORMAL) {
2268ec8297bdSDavid Xu 		if (p->p_flag & P_TRACED || action == SIG_CATCH) {
2269721e5910SJulian Elischer 			mtx_lock_spin(&sched_lock);
227094f0972bSDavid Xu 			tdsigwakeup(td, sig, action, intrval);
2271721e5910SJulian Elischer 			mtx_unlock_spin(&sched_lock);
2272df8bae1dSRodney W. Grimes 			goto out;
227304774f23SJulian Elischer 		}
2274ec8297bdSDavid Xu 
2275ec8297bdSDavid Xu 		MPASS(action == SIG_DFL);
2276ec8297bdSDavid Xu 
227735c32a76SDavid Xu 		if (prop & SA_STOP) {
227835c32a76SDavid Xu 			if (p->p_flag & P_PPWAIT)
227935c32a76SDavid Xu 				goto out;
2280e574e444SDavid Xu 			p->p_flag |= P_STOPPED_SIG;
2281e574e444SDavid Xu 			p->p_xstat = sig;
228235c32a76SDavid Xu 			mtx_lock_spin(&sched_lock);
2283d8267df7SDavid Xu 			sig_suspend_threads(td, p, 1);
22844093529dSJeff Roberson 			if (p->p_numthreads == p->p_suspcount) {
2285ebceaf6dSDavid Xu 				/*
2286ebceaf6dSDavid Xu 				 * only thread sending signal to another
2287ebceaf6dSDavid Xu 				 * process can reach here, if thread is sending
2288ebceaf6dSDavid Xu 				 * signal to its process, because thread does
2289ebceaf6dSDavid Xu 				 * not suspend itself here, p_numthreads
2290ebceaf6dSDavid Xu 				 * should never be equal to p_suspcount.
2291ebceaf6dSDavid Xu 				 */
2292ebceaf6dSDavid Xu 				thread_stopped(p);
22939104847fSDavid Xu 				mtx_unlock_spin(&sched_lock);
22949104847fSDavid Xu 				sigqueue_delete_proc(p, p->p_xstat);
22959104847fSDavid Xu 			} else
229635c32a76SDavid Xu 				mtx_unlock_spin(&sched_lock);
229735c32a76SDavid Xu 			goto out;
229835c32a76SDavid Xu 		}
2299721e5910SJulian Elischer 		else
2300df8bae1dSRodney W. Grimes 			goto runfast;
2301df8bae1dSRodney W. Grimes 		/* NOTREACHED */
2302e602ba25SJulian Elischer 	} else {
2303e602ba25SJulian Elischer 		/* Not in "NORMAL" state. discard the signal. */
23049104847fSDavid Xu 		sigqueue_delete(sigqueue, sig);
2305e602ba25SJulian Elischer 		goto out;
2306e602ba25SJulian Elischer 	}
2307e602ba25SJulian Elischer 
2308b40ce416SJulian Elischer 	/*
2309e602ba25SJulian Elischer 	 * The process is not stopped so we need to apply the signal to all the
2310e602ba25SJulian Elischer 	 * running threads.
2311b40ce416SJulian Elischer 	 */
2312e602ba25SJulian Elischer 
2313e602ba25SJulian Elischer runfast:
2314aa0fa334SJulian Elischer 	mtx_lock_spin(&sched_lock);
231594f0972bSDavid Xu 	tdsigwakeup(td, sig, action, intrval);
2316e602ba25SJulian Elischer 	thread_unsuspend(p);
2317e602ba25SJulian Elischer 	mtx_unlock_spin(&sched_lock);
2318e602ba25SJulian Elischer out:
2319e602ba25SJulian Elischer 	/* If we jump here, sched_lock should not be owned. */
2320e602ba25SJulian Elischer 	mtx_assert(&sched_lock, MA_NOTOWNED);
23219104847fSDavid Xu 	return (ret);
2322e602ba25SJulian Elischer }
2323e602ba25SJulian Elischer 
2324e602ba25SJulian Elischer /*
2325e602ba25SJulian Elischer  * The force of a signal has been directed against a single
2326e602ba25SJulian Elischer  * thread.  We need to see what we can do about knocking it
2327e602ba25SJulian Elischer  * out of any sleep it may be in etc.
2328e602ba25SJulian Elischer  */
2329e602ba25SJulian Elischer static void
233094f0972bSDavid Xu tdsigwakeup(struct thread *td, int sig, sig_t action, int intrval)
2331e602ba25SJulian Elischer {
2332e602ba25SJulian Elischer 	struct proc *p = td->td_proc;
2333e602ba25SJulian Elischer 	register int prop;
2334e602ba25SJulian Elischer 
23358b94a061SJohn Baldwin 	PROC_LOCK_ASSERT(p, MA_OWNED);
2336aa0fa334SJulian Elischer 	mtx_assert(&sched_lock, MA_OWNED);
2337e602ba25SJulian Elischer 	prop = sigprop(sig);
2338a4c2da15SBruce Evans 
2339e602ba25SJulian Elischer 	/*
2340aa0fa334SJulian Elischer 	 * Bring the priority of a thread up if we want it to get
2341e602ba25SJulian Elischer 	 * killed in this lifetime.
2342e602ba25SJulian Elischer 	 */
2343a4c2da15SBruce Evans 	if (action == SIG_DFL && (prop & SA_KILL)) {
23443ef6ac33SJeff Roberson 		if (p->p_nice > 0)
23453ef6ac33SJeff Roberson 			sched_nice(td->td_proc, 0);
2346a4c2da15SBruce Evans 		if (td->td_priority > PUSER)
2347b3a4fb14SDavid Xu 			sched_prio(td, PUSER);
2348b40ce416SJulian Elischer 	}
2349a4c2da15SBruce Evans 
235080c4433cSJohn Baldwin 	if (TD_ON_SLEEPQ(td)) {
2351e602ba25SJulian Elischer 		/*
2352e602ba25SJulian Elischer 		 * If thread is sleeping uninterruptibly
2353e602ba25SJulian Elischer 		 * we can't interrupt the sleep... the signal will
2354e602ba25SJulian Elischer 		 * be noticed when the process returns through
2355e602ba25SJulian Elischer 		 * trap() or syscall().
2356e602ba25SJulian Elischer 		 */
235744f3b092SJohn Baldwin 		if ((td->td_flags & TDF_SINTR) == 0)
2358aa0fa334SJulian Elischer 			return;
2359e602ba25SJulian Elischer 		/*
2360e602ba25SJulian Elischer 		 * If SIGCONT is default (or ignored) and process is
2361e602ba25SJulian Elischer 		 * asleep, we are finished; the process should not
2362e602ba25SJulian Elischer 		 * be awakened.
2363df8bae1dSRodney W. Grimes 		 */
2364e602ba25SJulian Elischer 		if ((prop & SA_CONT) && action == SIG_DFL) {
23659104847fSDavid Xu 			mtx_unlock_spin(&sched_lock);
23669104847fSDavid Xu 			sigqueue_delete(&p->p_sigqueue, sig);
23674093529dSJeff Roberson 			/*
23684093529dSJeff Roberson 			 * It may be on either list in this state.
23694093529dSJeff Roberson 			 * Remove from both for now.
23704093529dSJeff Roberson 			 */
23719104847fSDavid Xu 			sigqueue_delete(&td->td_sigqueue, sig);
23729104847fSDavid Xu 			mtx_lock_spin(&sched_lock);
2373aa0fa334SJulian Elischer 			return;
2374df8bae1dSRodney W. Grimes 		}
2375df8bae1dSRodney W. Grimes 
2376aa0fa334SJulian Elischer 		/*
2377a4c2da15SBruce Evans 		 * Give low priority threads a better chance to run.
2378aa0fa334SJulian Elischer 		 */
237944f3b092SJohn Baldwin 		if (td->td_priority > PUSER)
2380b3a4fb14SDavid Xu 			sched_prio(td, PUSER);
2381ec8297bdSDavid Xu 
238294f0972bSDavid Xu 		sleepq_abort(td, intrval);
2383a4c2da15SBruce Evans 	} else {
2384df8bae1dSRodney W. Grimes 		/*
2385a4c2da15SBruce Evans 		 * Other states do nothing with the signal immediately,
2386df8bae1dSRodney W. Grimes 		 * other than kicking ourselves if we are running.
2387df8bae1dSRodney W. Grimes 		 * It will either never be noticed, or noticed very soon.
2388df8bae1dSRodney W. Grimes 		 */
2389a4c2da15SBruce Evans #ifdef SMP
239044f3b092SJohn Baldwin 		if (TD_IS_RUNNING(td) && td != curthread)
2391e602ba25SJulian Elischer 			forward_signal(td);
23923163861cSTor Egge #endif
23936caa8a15SJohn Baldwin 	}
2394a4c2da15SBruce Evans }
2395df8bae1dSRodney W. Grimes 
2396d8267df7SDavid Xu static void
2397d8267df7SDavid Xu sig_suspend_threads(struct thread *td, struct proc *p, int sending)
2398d8267df7SDavid Xu {
2399d8267df7SDavid Xu 	struct thread *td2;
2400d8267df7SDavid Xu 
2401d8267df7SDavid Xu 	PROC_LOCK_ASSERT(p, MA_OWNED);
2402d8267df7SDavid Xu 	mtx_assert(&sched_lock, MA_OWNED);
2403d8267df7SDavid Xu 
2404d8267df7SDavid Xu 	FOREACH_THREAD_IN_PROC(p, td2) {
2405d8267df7SDavid Xu 		if ((TD_IS_SLEEPING(td2) || TD_IS_SWAPPED(td2)) &&
2406d8267df7SDavid Xu 		    (td2->td_flags & TDF_SINTR) &&
2407d8267df7SDavid Xu 		    !TD_IS_SUSPENDED(td2)) {
2408d8267df7SDavid Xu 			thread_suspend_one(td2);
2409d8267df7SDavid Xu 		} else {
2410d8267df7SDavid Xu 			if (sending || td != td2)
2411d8267df7SDavid Xu 				td2->td_flags |= TDF_ASTPENDING;
2412d8267df7SDavid Xu #ifdef SMP
2413d8267df7SDavid Xu 			if (TD_IS_RUNNING(td2) && td2 != td)
2414d8267df7SDavid Xu 				forward_signal(td2);
2415d8267df7SDavid Xu #endif
2416d8267df7SDavid Xu 		}
2417d8267df7SDavid Xu 	}
2418d8267df7SDavid Xu }
2419d8267df7SDavid Xu 
2420cbf4e354SDavid Xu int
24214cc9f52fSRobert Drehmel ptracestop(struct thread *td, int sig)
24224cc9f52fSRobert Drehmel {
24234cc9f52fSRobert Drehmel 	struct proc *p = td->td_proc;
24244cc9f52fSRobert Drehmel 
242530a9f26dSRobert Watson 	PROC_LOCK_ASSERT(p, MA_OWNED);
24264cc9f52fSRobert Drehmel 	WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK,
24274cc9f52fSRobert Drehmel 	    &p->p_mtx.mtx_object, "Stopping for traced signal");
24284cc9f52fSRobert Drehmel 
24294cc9f52fSRobert Drehmel 	mtx_lock_spin(&sched_lock);
2430cbf4e354SDavid Xu 	td->td_flags |= TDF_XSIG;
2431cbf4e354SDavid Xu 	mtx_unlock_spin(&sched_lock);
2432cbf4e354SDavid Xu 	td->td_xsig = sig;
2433cbf4e354SDavid Xu 	while ((p->p_flag & P_TRACED) && (td->td_flags & TDF_XSIG)) {
2434cbf4e354SDavid Xu 		if (p->p_flag & P_SINGLE_EXIT) {
2435cbf4e354SDavid Xu 			mtx_lock_spin(&sched_lock);
2436cbf4e354SDavid Xu 			td->td_flags &= ~TDF_XSIG;
2437cbf4e354SDavid Xu 			mtx_unlock_spin(&sched_lock);
2438cbf4e354SDavid Xu 			return (sig);
2439cbf4e354SDavid Xu 		}
2440cbf4e354SDavid Xu 		/*
2441cbf4e354SDavid Xu 		 * Just make wait() to work, the last stopped thread
2442cbf4e354SDavid Xu 		 * will win.
2443cbf4e354SDavid Xu 		 */
2444cbf4e354SDavid Xu 		p->p_xstat = sig;
2445cbf4e354SDavid Xu 		p->p_xthread = td;
2446cbf4e354SDavid Xu 		p->p_flag |= (P_STOPPED_SIG|P_STOPPED_TRACE);
2447cbf4e354SDavid Xu 		mtx_lock_spin(&sched_lock);
2448d8267df7SDavid Xu 		sig_suspend_threads(td, p, 0);
2449cbf4e354SDavid Xu stopme:
2450cbf4e354SDavid Xu 		thread_stopped(p);
24514cc9f52fSRobert Drehmel 		thread_suspend_one(td);
24524cc9f52fSRobert Drehmel 		PROC_UNLOCK(p);
24534cc9f52fSRobert Drehmel 		DROP_GIANT();
2454cbf4e354SDavid Xu 		mi_switch(SW_VOL, NULL);
24554cc9f52fSRobert Drehmel 		mtx_unlock_spin(&sched_lock);
24564cc9f52fSRobert Drehmel 		PICKUP_GIANT();
2457cbf4e354SDavid Xu 		PROC_LOCK(p);
2458cbf4e354SDavid Xu 		if (!(p->p_flag & P_TRACED))
2459cbf4e354SDavid Xu 			break;
2460cbf4e354SDavid Xu 		if (td->td_flags & TDF_DBSUSPEND) {
2461cbf4e354SDavid Xu 			if (p->p_flag & P_SINGLE_EXIT)
2462cbf4e354SDavid Xu 				break;
2463cbf4e354SDavid Xu 			mtx_lock_spin(&sched_lock);
2464cbf4e354SDavid Xu 			goto stopme;
2465cbf4e354SDavid Xu 		}
2466cbf4e354SDavid Xu 	}
2467cbf4e354SDavid Xu 	return (td->td_xsig);
24684cc9f52fSRobert Drehmel }
24694cc9f52fSRobert Drehmel 
2470df8bae1dSRodney W. Grimes /*
2471df8bae1dSRodney W. Grimes  * If the current process has received a signal (should be caught or cause
2472df8bae1dSRodney W. Grimes  * termination, should interrupt current syscall), return the signal number.
2473df8bae1dSRodney W. Grimes  * Stop signals with default action are processed immediately, then cleared;
2474df8bae1dSRodney W. Grimes  * they aren't returned.  This is checked after each entry to the system for
2475df8bae1dSRodney W. Grimes  * a syscall or trap (though this can usually be done without calling issignal
2476628855e7SJulian Elischer  * by checking the pending signal masks in cursig.) The normal call
2477df8bae1dSRodney W. Grimes  * sequence is
2478df8bae1dSRodney W. Grimes  *
2479e602ba25SJulian Elischer  *	while (sig = cursig(curthread))
24802c42a146SMarcel Moolenaar  *		postsig(sig);
2481df8bae1dSRodney W. Grimes  */
24826711f10fSJohn Baldwin static int
2483e602ba25SJulian Elischer issignal(td)
2484e602ba25SJulian Elischer 	struct thread *td;
2485df8bae1dSRodney W. Grimes {
2486e602ba25SJulian Elischer 	struct proc *p;
248790af4afaSJohn Baldwin 	struct sigacts *ps;
24884093529dSJeff Roberson 	sigset_t sigpending;
2489cbf4e354SDavid Xu 	int sig, prop, newsig;
2490df8bae1dSRodney W. Grimes 
2491e602ba25SJulian Elischer 	p = td->td_proc;
249290af4afaSJohn Baldwin 	ps = p->p_sigacts;
249390af4afaSJohn Baldwin 	mtx_assert(&ps->ps_mtx, MA_OWNED);
2494628d2653SJohn Baldwin 	PROC_LOCK_ASSERT(p, MA_OWNED);
2495df8bae1dSRodney W. Grimes 	for (;;) {
24962a024a2bSSean Eric Fagan 		int traced = (p->p_flag & P_TRACED) || (p->p_stops & S_SIG);
24972a024a2bSSean Eric Fagan 
24989104847fSDavid Xu 		sigpending = td->td_sigqueue.sq_signals;
24994093529dSJeff Roberson 		SIGSETNAND(sigpending, td->td_sigmask);
25004093529dSJeff Roberson 
2501df8bae1dSRodney W. Grimes 		if (p->p_flag & P_PPWAIT)
25024093529dSJeff Roberson 			SIG_STOPSIGMASK(sigpending);
25034093529dSJeff Roberson 		if (SIGISEMPTY(sigpending))	/* no signal to send */
2504df8bae1dSRodney W. Grimes 			return (0);
25054093529dSJeff Roberson 		sig = sig_ffs(&sigpending);
25062a024a2bSSean Eric Fagan 
2507047aa39bSRobert Watson 		if (p->p_stops & S_SIG) {
2508047aa39bSRobert Watson 			mtx_unlock(&ps->ps_mtx);
2509047aa39bSRobert Watson 			stopevent(p, S_SIG, sig);
2510047aa39bSRobert Watson 			mtx_lock(&ps->ps_mtx);
2511047aa39bSRobert Watson 		}
25122a024a2bSSean Eric Fagan 
2513df8bae1dSRodney W. Grimes 		/*
2514df8bae1dSRodney W. Grimes 		 * We should see pending but ignored signals
2515df8bae1dSRodney W. Grimes 		 * only if P_TRACED was on when they were posted.
2516df8bae1dSRodney W. Grimes 		 */
251790af4afaSJohn Baldwin 		if (SIGISMEMBER(ps->ps_sigignore, sig) && (traced == 0)) {
25189104847fSDavid Xu 			sigqueue_delete(&td->td_sigqueue, sig);
25198460a577SJohn Birrell #ifdef KSE
2520cbf4e354SDavid Xu 			if (td->td_pflags & TDP_SA)
2521cbf4e354SDavid Xu 				SIGADDSET(td->td_sigmask, sig);
25228460a577SJohn Birrell #endif
2523df8bae1dSRodney W. Grimes 			continue;
2524df8bae1dSRodney W. Grimes 		}
2525df8bae1dSRodney W. Grimes 		if (p->p_flag & P_TRACED && (p->p_flag & P_PPWAIT) == 0) {
2526df8bae1dSRodney W. Grimes 			/*
2527d8f4f6a4SJonathan Mini 			 * If traced, always stop.
2528df8bae1dSRodney W. Grimes 			 */
252990af4afaSJohn Baldwin 			mtx_unlock(&ps->ps_mtx);
2530cbf4e354SDavid Xu 			newsig = ptracestop(td, sig);
253190af4afaSJohn Baldwin 			mtx_lock(&ps->ps_mtx);
2532df8bae1dSRodney W. Grimes 
25338460a577SJohn Birrell #ifdef KSE
25349104847fSDavid Xu 			if (td->td_pflags & TDP_SA)
25359104847fSDavid Xu 				SIGADDSET(td->td_sigmask, sig);
25369104847fSDavid Xu 
25378460a577SJohn Birrell #endif
25389104847fSDavid Xu 			if (sig != newsig) {
2539413cf3bbSDavid Xu 				ksiginfo_t ksi;
25409104847fSDavid Xu 				/*
25419104847fSDavid Xu 				 * clear old signal.
25429104847fSDavid Xu 				 * XXX shrug off debugger, it causes siginfo to
25439104847fSDavid Xu 				 * be thrown away.
25449104847fSDavid Xu 				 */
2545413cf3bbSDavid Xu 				sigqueue_get(&td->td_sigqueue, sig, &ksi);
25469104847fSDavid Xu 
2547df8bae1dSRodney W. Grimes 				/*
2548df8bae1dSRodney W. Grimes 				 * If parent wants us to take the signal,
2549df8bae1dSRodney W. Grimes 				 * then it will leave it in p->p_xstat;
2550df8bae1dSRodney W. Grimes 				 * otherwise we just look for signals again.
2551df8bae1dSRodney W. Grimes 			 	*/
2552cbf4e354SDavid Xu 				if (newsig == 0)
2553df8bae1dSRodney W. Grimes 					continue;
2554cbf4e354SDavid Xu 				sig = newsig;
25559104847fSDavid Xu 
25569104847fSDavid Xu 				/*
25579104847fSDavid Xu 				 * Put the new signal into td_sigqueue. If the
25589104847fSDavid Xu 				 * signal is being masked, look for other signals.
25599104847fSDavid Xu 				 */
25609104847fSDavid Xu 				SIGADDSET(td->td_sigqueue.sq_signals, sig);
25618460a577SJohn Birrell #ifdef KSE
25629104847fSDavid Xu 				if (td->td_pflags & TDP_SA)
25639104847fSDavid Xu 					SIGDELSET(td->td_sigmask, sig);
25648460a577SJohn Birrell #endif
25659104847fSDavid Xu 				if (SIGISMEMBER(td->td_sigmask, sig))
25669104847fSDavid Xu 					continue;
25679104847fSDavid Xu 				signotify(td);
25689104847fSDavid Xu 			}
25699104847fSDavid Xu 
2570df8bae1dSRodney W. Grimes 			/*
25718d542cb5SDavid E. O'Brien 			 * If the traced bit got turned off, go back up
25728d542cb5SDavid E. O'Brien 			 * to the top to rescan signals.  This ensures
25738d542cb5SDavid E. O'Brien 			 * that p_sig* and p_sigact are consistent.
25748d542cb5SDavid E. O'Brien 			 */
25758d542cb5SDavid E. O'Brien 			if ((p->p_flag & P_TRACED) == 0)
25768d542cb5SDavid E. O'Brien 				continue;
2577df8bae1dSRodney W. Grimes 		}
2578df8bae1dSRodney W. Grimes 
25798d542cb5SDavid E. O'Brien 		prop = sigprop(sig);
25808d542cb5SDavid E. O'Brien 
2581df8bae1dSRodney W. Grimes 		/*
2582df8bae1dSRodney W. Grimes 		 * Decide whether the signal should be returned.
2583df8bae1dSRodney W. Grimes 		 * Return the signal's number, or fall through
2584df8bae1dSRodney W. Grimes 		 * to clear it from the pending mask.
2585df8bae1dSRodney W. Grimes 		 */
2586d321df47SPoul-Henning Kamp 		switch ((intptr_t)p->p_sigacts->ps_sigact[_SIG_IDX(sig)]) {
2587df8bae1dSRodney W. Grimes 
2588d321df47SPoul-Henning Kamp 		case (intptr_t)SIG_DFL:
2589df8bae1dSRodney W. Grimes 			/*
2590df8bae1dSRodney W. Grimes 			 * Don't take default actions on system processes.
2591df8bae1dSRodney W. Grimes 			 */
2592df8bae1dSRodney W. Grimes 			if (p->p_pid <= 1) {
2593df8bae1dSRodney W. Grimes #ifdef DIAGNOSTIC
2594df8bae1dSRodney W. Grimes 				/*
2595df8bae1dSRodney W. Grimes 				 * Are you sure you want to ignore SIGSEGV
2596df8bae1dSRodney W. Grimes 				 * in init? XXX
2597df8bae1dSRodney W. Grimes 				 */
2598d93f860cSPoul-Henning Kamp 				printf("Process (pid %lu) got signal %d\n",
25992c42a146SMarcel Moolenaar 					(u_long)p->p_pid, sig);
2600df8bae1dSRodney W. Grimes #endif
2601df8bae1dSRodney W. Grimes 				break;		/* == ignore */
2602df8bae1dSRodney W. Grimes 			}
2603df8bae1dSRodney W. Grimes 			/*
2604df8bae1dSRodney W. Grimes 			 * If there is a pending stop signal to process
2605df8bae1dSRodney W. Grimes 			 * with default action, stop here,
2606df8bae1dSRodney W. Grimes 			 * then clear the signal.  However,
2607df8bae1dSRodney W. Grimes 			 * if process is member of an orphaned
2608df8bae1dSRodney W. Grimes 			 * process group, ignore tty stop signals.
2609df8bae1dSRodney W. Grimes 			 */
2610df8bae1dSRodney W. Grimes 			if (prop & SA_STOP) {
2611df8bae1dSRodney W. Grimes 				if (p->p_flag & P_TRACED ||
2612df8bae1dSRodney W. Grimes 		    		    (p->p_pgrp->pg_jobc == 0 &&
2613df8bae1dSRodney W. Grimes 				     prop & SA_TTYSTOP))
2614df8bae1dSRodney W. Grimes 					break;	/* == ignore */
261590af4afaSJohn Baldwin 				mtx_unlock(&ps->ps_mtx);
261690af4afaSJohn Baldwin 				WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK,
261790af4afaSJohn Baldwin 				    &p->p_mtx.mtx_object, "Catching SIGSTOP");
2618e574e444SDavid Xu 				p->p_flag |= P_STOPPED_SIG;
26192c42a146SMarcel Moolenaar 				p->p_xstat = sig;
2620721e5910SJulian Elischer 				mtx_lock_spin(&sched_lock);
2621d8267df7SDavid Xu 				sig_suspend_threads(td, p, 0);
2622e574e444SDavid Xu 				thread_stopped(p);
262371fad9fdSJulian Elischer 				thread_suspend_one(td);
2624721e5910SJulian Elischer 				PROC_UNLOCK(p);
2625721e5910SJulian Elischer 				DROP_GIANT();
2626bf0acc27SJohn Baldwin 				mi_switch(SW_INVOL, NULL);
2627721e5910SJulian Elischer 				mtx_unlock_spin(&sched_lock);
2628721e5910SJulian Elischer 				PICKUP_GIANT();
2629721e5910SJulian Elischer 				PROC_LOCK(p);
263090af4afaSJohn Baldwin 				mtx_lock(&ps->ps_mtx);
2631df8bae1dSRodney W. Grimes 				break;
263221b68415SDavid E. O'Brien 			} else if (prop & SA_IGNORE) {
2633df8bae1dSRodney W. Grimes 				/*
2634df8bae1dSRodney W. Grimes 				 * Except for SIGCONT, shouldn't get here.
2635df8bae1dSRodney W. Grimes 				 * Default action is to ignore; drop it.
2636df8bae1dSRodney W. Grimes 				 */
2637df8bae1dSRodney W. Grimes 				break;		/* == ignore */
2638df8bae1dSRodney W. Grimes 			} else
26392c42a146SMarcel Moolenaar 				return (sig);
2640df8bae1dSRodney W. Grimes 			/*NOTREACHED*/
2641df8bae1dSRodney W. Grimes 
2642d321df47SPoul-Henning Kamp 		case (intptr_t)SIG_IGN:
2643df8bae1dSRodney W. Grimes 			/*
2644df8bae1dSRodney W. Grimes 			 * Masking above should prevent us ever trying
2645df8bae1dSRodney W. Grimes 			 * to take action on an ignored signal other
2646df8bae1dSRodney W. Grimes 			 * than SIGCONT, unless process is traced.
2647df8bae1dSRodney W. Grimes 			 */
2648df8bae1dSRodney W. Grimes 			if ((prop & SA_CONT) == 0 &&
2649df8bae1dSRodney W. Grimes 			    (p->p_flag & P_TRACED) == 0)
2650df8bae1dSRodney W. Grimes 				printf("issignal\n");
2651df8bae1dSRodney W. Grimes 			break;		/* == ignore */
2652df8bae1dSRodney W. Grimes 
2653df8bae1dSRodney W. Grimes 		default:
2654df8bae1dSRodney W. Grimes 			/*
2655df8bae1dSRodney W. Grimes 			 * This signal has an action, let
2656df8bae1dSRodney W. Grimes 			 * postsig() process it.
2657df8bae1dSRodney W. Grimes 			 */
26582c42a146SMarcel Moolenaar 			return (sig);
2659df8bae1dSRodney W. Grimes 		}
26609104847fSDavid Xu 		sigqueue_delete(&td->td_sigqueue, sig);		/* take the signal! */
2661df8bae1dSRodney W. Grimes 	}
2662df8bae1dSRodney W. Grimes 	/* NOTREACHED */
2663df8bae1dSRodney W. Grimes }
2664df8bae1dSRodney W. Grimes 
2665e574e444SDavid Xu void
2666e574e444SDavid Xu thread_stopped(struct proc *p)
2667e574e444SDavid Xu {
2668e574e444SDavid Xu 	int n;
2669e574e444SDavid Xu 
2670e574e444SDavid Xu 	PROC_LOCK_ASSERT(p, MA_OWNED);
2671e574e444SDavid Xu 	mtx_assert(&sched_lock, MA_OWNED);
2672e574e444SDavid Xu 	n = p->p_suspcount;
26737c9a98f1SDavid Xu 	if (p == curproc)
2674e574e444SDavid Xu 		n++;
2675e574e444SDavid Xu 	if ((p->p_flag & P_STOPPED_SIG) && (n == p->p_numthreads)) {
2676e574e444SDavid Xu 		mtx_unlock_spin(&sched_lock);
2677407948a5SDavid Xu 		p->p_flag &= ~P_WAITED;
2678e574e444SDavid Xu 		PROC_LOCK(p->p_pptr);
26797f96995eSDavid Xu 		childproc_stopped(p, (p->p_flag & P_TRACED) ?
2680ebceaf6dSDavid Xu 			CLD_TRAPPED : CLD_STOPPED);
2681e574e444SDavid Xu 		PROC_UNLOCK(p->p_pptr);
2682e574e444SDavid Xu 		mtx_lock_spin(&sched_lock);
2683e574e444SDavid Xu 	}
2684e574e444SDavid Xu }
2685e574e444SDavid Xu 
2686df8bae1dSRodney W. Grimes /*
2687df8bae1dSRodney W. Grimes  * Take the action for the specified signal
2688df8bae1dSRodney W. Grimes  * from the current set of pending signals.
2689df8bae1dSRodney W. Grimes  */
2690df8bae1dSRodney W. Grimes void
26912c42a146SMarcel Moolenaar postsig(sig)
26922c42a146SMarcel Moolenaar 	register int sig;
2693df8bae1dSRodney W. Grimes {
2694b40ce416SJulian Elischer 	struct thread *td = curthread;
2695b40ce416SJulian Elischer 	register struct proc *p = td->td_proc;
2696628d2653SJohn Baldwin 	struct sigacts *ps;
26972c42a146SMarcel Moolenaar 	sig_t action;
26989104847fSDavid Xu 	ksiginfo_t ksi;
26992c42a146SMarcel Moolenaar 	sigset_t returnmask;
27002c42a146SMarcel Moolenaar 	int code;
2701df8bae1dSRodney W. Grimes 
27022c42a146SMarcel Moolenaar 	KASSERT(sig != 0, ("postsig"));
27035526d2d9SEivind Eklund 
27042ad7d304SJohn Baldwin 	PROC_LOCK_ASSERT(p, MA_OWNED);
2705628d2653SJohn Baldwin 	ps = p->p_sigacts;
270690af4afaSJohn Baldwin 	mtx_assert(&ps->ps_mtx, MA_OWNED);
27075da49fcbSDavid Xu 	ksiginfo_init(&ksi);
27089104847fSDavid Xu 	sigqueue_get(&td->td_sigqueue, sig, &ksi);
27099104847fSDavid Xu 	ksi.ksi_signo = sig;
271056c06c4bSDavid Xu 	if (ksi.ksi_code == SI_TIMER)
271156c06c4bSDavid Xu 		itimer_accept(p, ksi.ksi_timerid, &ksi);
27122c42a146SMarcel Moolenaar 	action = ps->ps_sigact[_SIG_IDX(sig)];
2713df8bae1dSRodney W. Grimes #ifdef KTRACE
2714374a15aaSJohn Baldwin 	if (KTRPOINT(td, KTR_PSIG))
27155e26dcb5SJohn Baldwin 		ktrpsig(sig, action, td->td_pflags & TDP_OLDMASK ?
27164093529dSJeff Roberson 		    &td->td_oldsigmask : &td->td_sigmask, 0);
2717df8bae1dSRodney W. Grimes #endif
2718047aa39bSRobert Watson 	if (p->p_stops & S_SIG) {
2719047aa39bSRobert Watson 		mtx_unlock(&ps->ps_mtx);
2720047aa39bSRobert Watson 		stopevent(p, S_SIG, sig);
2721047aa39bSRobert Watson 		mtx_lock(&ps->ps_mtx);
2722047aa39bSRobert Watson 	}
27232a024a2bSSean Eric Fagan 
27248460a577SJohn Birrell #ifdef KSE
2725cbf4e354SDavid Xu 	if (!(td->td_pflags & TDP_SA) && action == SIG_DFL) {
27268460a577SJohn Birrell #else
27278460a577SJohn Birrell 	if (action == SIG_DFL) {
27288460a577SJohn Birrell #endif
2729df8bae1dSRodney W. Grimes 		/*
2730df8bae1dSRodney W. Grimes 		 * Default action, where the default is to kill
2731df8bae1dSRodney W. Grimes 		 * the process.  (Other cases were ignored above.)
2732df8bae1dSRodney W. Grimes 		 */
273390af4afaSJohn Baldwin 		mtx_unlock(&ps->ps_mtx);
2734b40ce416SJulian Elischer 		sigexit(td, sig);
2735df8bae1dSRodney W. Grimes 		/* NOTREACHED */
2736df8bae1dSRodney W. Grimes 	} else {
27378460a577SJohn Birrell #ifdef KSE
2738cbf4e354SDavid Xu 		if (td->td_pflags & TDP_SA) {
2739432b45deSDavid Xu 			if (sig == SIGKILL) {
2740432b45deSDavid Xu 				mtx_unlock(&ps->ps_mtx);
2741432b45deSDavid Xu 				sigexit(td, sig);
2742432b45deSDavid Xu 			}
2743432b45deSDavid Xu 		}
2744432b45deSDavid Xu 
27458460a577SJohn Birrell #endif
2746df8bae1dSRodney W. Grimes 		/*
2747df8bae1dSRodney W. Grimes 		 * If we get here, the signal must be caught.
2748df8bae1dSRodney W. Grimes 		 */
27494093529dSJeff Roberson 		KASSERT(action != SIG_IGN && !SIGISMEMBER(td->td_sigmask, sig),
27505526d2d9SEivind Eklund 		    ("postsig action"));
2751df8bae1dSRodney W. Grimes 		/*
2752df8bae1dSRodney W. Grimes 		 * Set the new mask value and also defer further
2753645682fdSLuoqi Chen 		 * occurrences of this signal.
2754df8bae1dSRodney W. Grimes 		 *
2755645682fdSLuoqi Chen 		 * Special case: user has done a sigsuspend.  Here the
2756df8bae1dSRodney W. Grimes 		 * current mask is not of interest, but rather the
2757645682fdSLuoqi Chen 		 * mask from before the sigsuspend is what we want
2758df8bae1dSRodney W. Grimes 		 * restored after the signal processing is completed.
2759df8bae1dSRodney W. Grimes 		 */
27605e26dcb5SJohn Baldwin 		if (td->td_pflags & TDP_OLDMASK) {
27614093529dSJeff Roberson 			returnmask = td->td_oldsigmask;
27625e26dcb5SJohn Baldwin 			td->td_pflags &= ~TDP_OLDMASK;
2763df8bae1dSRodney W. Grimes 		} else
27644093529dSJeff Roberson 			returnmask = td->td_sigmask;
27652c42a146SMarcel Moolenaar 
27664093529dSJeff Roberson 		SIGSETOR(td->td_sigmask, ps->ps_catchmask[_SIG_IDX(sig)]);
27672c42a146SMarcel Moolenaar 		if (!SIGISMEMBER(ps->ps_signodefer, sig))
27684093529dSJeff Roberson 			SIGADDSET(td->td_sigmask, sig);
27692c42a146SMarcel Moolenaar 
27702c42a146SMarcel Moolenaar 		if (SIGISMEMBER(ps->ps_sigreset, sig)) {
2771289ccde0SPeter Wemm 			/*
27728f19eb88SIan Dowse 			 * See kern_sigaction() for origin of this code.
2773289ccde0SPeter Wemm 			 */
277490af4afaSJohn Baldwin 			SIGDELSET(ps->ps_sigcatch, sig);
27752c42a146SMarcel Moolenaar 			if (sig != SIGCONT &&
27762c42a146SMarcel Moolenaar 			    sigprop(sig) & SA_IGNORE)
277790af4afaSJohn Baldwin 				SIGADDSET(ps->ps_sigignore, sig);
27782c42a146SMarcel Moolenaar 			ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL;
2779dedc04feSPeter Wemm 		}
2780df8bae1dSRodney W. Grimes 		p->p_stats->p_ru.ru_nsignals++;
27812c42a146SMarcel Moolenaar 		if (p->p_sig != sig) {
2782df8bae1dSRodney W. Grimes 			code = 0;
2783df8bae1dSRodney W. Grimes 		} else {
27846626c604SJulian Elischer 			code = p->p_code;
27856626c604SJulian Elischer 			p->p_code = 0;
27866626c604SJulian Elischer 			p->p_sig = 0;
2787df8bae1dSRodney W. Grimes 		}
27888460a577SJohn Birrell #ifdef KSE
2789cbf4e354SDavid Xu 		if (td->td_pflags & TDP_SA)
27909104847fSDavid Xu 			thread_signal_add(curthread, &ksi);
279158a3c273SJeff Roberson 		else
27929104847fSDavid Xu 			(*p->p_sysent->sv_sendsig)(action, &ksi, &returnmask);
27938460a577SJohn Birrell #else
27948460a577SJohn Birrell 		(*p->p_sysent->sv_sendsig)(action, &ksi, &returnmask);
27958460a577SJohn Birrell #endif
2796df8bae1dSRodney W. Grimes 	}
2797df8bae1dSRodney W. Grimes }
2798df8bae1dSRodney W. Grimes 
2799df8bae1dSRodney W. Grimes /*
2800df8bae1dSRodney W. Grimes  * Kill the current process for stated reason.
2801df8bae1dSRodney W. Grimes  */
280226f9a767SRodney W. Grimes void
2803df8bae1dSRodney W. Grimes killproc(p, why)
2804df8bae1dSRodney W. Grimes 	struct proc *p;
2805df8bae1dSRodney W. Grimes 	char *why;
2806df8bae1dSRodney W. Grimes {
28079081e5e8SJohn Baldwin 
28089081e5e8SJohn Baldwin 	PROC_LOCK_ASSERT(p, MA_OWNED);
28090384fff8SJason Evans 	CTR3(KTR_PROC, "killproc: proc %p (pid %d, %s)",
28100384fff8SJason Evans 		p, p->p_pid, p->p_comm);
2811729b1e51SDavid Greenman 	log(LOG_ERR, "pid %d (%s), uid %d, was killed: %s\n", p->p_pid, p->p_comm,
2812b1fc0ec1SRobert Watson 		p->p_ucred ? p->p_ucred->cr_uid : -1, why);
2813df8bae1dSRodney W. Grimes 	psignal(p, SIGKILL);
2814df8bae1dSRodney W. Grimes }
2815df8bae1dSRodney W. Grimes 
2816df8bae1dSRodney W. Grimes /*
2817df8bae1dSRodney W. Grimes  * Force the current process to exit with the specified signal, dumping core
2818df8bae1dSRodney W. Grimes  * if appropriate.  We bypass the normal tests for masked and caught signals,
2819df8bae1dSRodney W. Grimes  * allowing unrecoverable failures to terminate the process without changing
2820df8bae1dSRodney W. Grimes  * signal state.  Mark the accounting record with the signal termination.
2821df8bae1dSRodney W. Grimes  * If dumping core, save the signal number for the debugger.  Calls exit and
2822df8bae1dSRodney W. Grimes  * does not return.
2823df8bae1dSRodney W. Grimes  */
282426f9a767SRodney W. Grimes void
2825b40ce416SJulian Elischer sigexit(td, sig)
2826b40ce416SJulian Elischer 	struct thread *td;
28272c42a146SMarcel Moolenaar 	int sig;
2828df8bae1dSRodney W. Grimes {
2829b40ce416SJulian Elischer 	struct proc *p = td->td_proc;
2830df8bae1dSRodney W. Grimes 
2831628d2653SJohn Baldwin 	PROC_LOCK_ASSERT(p, MA_OWNED);
2832df8bae1dSRodney W. Grimes 	p->p_acflag |= AXSIG;
2833f97c3df1SDavid Schultz 	/*
2834f97c3df1SDavid Schultz 	 * We must be single-threading to generate a core dump.  This
2835f97c3df1SDavid Schultz 	 * ensures that the registers in the core file are up-to-date.
2836f97c3df1SDavid Schultz 	 * Also, the ELF dump handler assumes that the thread list doesn't
2837f97c3df1SDavid Schultz 	 * change out from under it.
2838f97c3df1SDavid Schultz 	 *
2839f97c3df1SDavid Schultz 	 * XXX If another thread attempts to single-thread before us
2840f97c3df1SDavid Schultz 	 *     (e.g. via fork()), we won't get a dump at all.
2841f97c3df1SDavid Schultz 	 */
2842f97c3df1SDavid Schultz 	if ((sigprop(sig) & SA_CORE) && (thread_single(SINGLE_NO_EXIT) == 0)) {
28432c42a146SMarcel Moolenaar 		p->p_sig = sig;
2844c364e17eSAndrey A. Chernov 		/*
2845c364e17eSAndrey A. Chernov 		 * Log signals which would cause core dumps
2846c364e17eSAndrey A. Chernov 		 * (Log as LOG_INFO to appease those who don't want
2847c364e17eSAndrey A. Chernov 		 * these messages.)
2848c364e17eSAndrey A. Chernov 		 * XXX : Todo, as well as euid, write out ruid too
28494ae89b95SJohn Baldwin 		 * Note that coredump() drops proc lock.
2850c364e17eSAndrey A. Chernov 		 */
2851b40ce416SJulian Elischer 		if (coredump(td) == 0)
28522c42a146SMarcel Moolenaar 			sig |= WCOREFLAG;
285357308494SJoerg Wunsch 		if (kern_logsigexit)
285457308494SJoerg Wunsch 			log(LOG_INFO,
285557308494SJoerg Wunsch 			    "pid %d (%s), uid %d: exited on signal %d%s\n",
28563d1b21c6SAndrey A. Chernov 			    p->p_pid, p->p_comm,
28579c1ab3e0SJohn Baldwin 			    td->td_ucred ? td->td_ucred->cr_uid : -1,
28582c42a146SMarcel Moolenaar 			    sig &~ WCOREFLAG,
28592c42a146SMarcel Moolenaar 			    sig & WCOREFLAG ? " (core dumped)" : "");
28604ae89b95SJohn Baldwin 	} else
2861628d2653SJohn Baldwin 		PROC_UNLOCK(p);
2862b40ce416SJulian Elischer 	exit1(td, W_EXITCODE(0, sig));
2863df8bae1dSRodney W. Grimes 	/* NOTREACHED */
2864df8bae1dSRodney W. Grimes }
2865df8bae1dSRodney W. Grimes 
2866ebceaf6dSDavid Xu /*
28677f96995eSDavid Xu  * Send queued SIGCHLD to parent when child process's state
28687f96995eSDavid Xu  * is changed.
2869ebceaf6dSDavid Xu  */
28707f96995eSDavid Xu static void
28717f96995eSDavid Xu sigparent(struct proc *p, int reason, int status)
2872ebceaf6dSDavid Xu {
2873ebceaf6dSDavid Xu 	PROC_LOCK_ASSERT(p, MA_OWNED);
2874ebceaf6dSDavid Xu 	PROC_LOCK_ASSERT(p->p_pptr, MA_OWNED);
2875ebceaf6dSDavid Xu 
2876ebceaf6dSDavid Xu 	if (p->p_ksi != NULL) {
2877ebceaf6dSDavid Xu 		p->p_ksi->ksi_signo  = SIGCHLD;
2878ebceaf6dSDavid Xu 		p->p_ksi->ksi_code   = reason;
28797f96995eSDavid Xu 		p->p_ksi->ksi_status = status;
2880ebceaf6dSDavid Xu 		p->p_ksi->ksi_pid    = p->p_pid;
2881ebceaf6dSDavid Xu 		p->p_ksi->ksi_uid    = p->p_ucred->cr_ruid;
2882ebceaf6dSDavid Xu 		if (KSI_ONQ(p->p_ksi))
2883ebceaf6dSDavid Xu 			return;
2884ebceaf6dSDavid Xu 	}
2885ebceaf6dSDavid Xu 	tdsignal(p->p_pptr, NULL, SIGCHLD, p->p_ksi);
2886ebceaf6dSDavid Xu }
2887ebceaf6dSDavid Xu 
28887f96995eSDavid Xu static void
28897f96995eSDavid Xu childproc_jobstate(struct proc *p, int reason, int status)
28907f96995eSDavid Xu {
28917f96995eSDavid Xu 	struct sigacts *ps;
28927f96995eSDavid Xu 
28937f96995eSDavid Xu 	PROC_LOCK_ASSERT(p, MA_OWNED);
28947f96995eSDavid Xu 	PROC_LOCK_ASSERT(p->p_pptr, MA_OWNED);
28957f96995eSDavid Xu 
28967f96995eSDavid Xu 	/*
28977f96995eSDavid Xu 	 * Wake up parent sleeping in kern_wait(), also send
28987f96995eSDavid Xu 	 * SIGCHLD to parent, but SIGCHLD does not guarantee
28997f96995eSDavid Xu 	 * that parent will awake, because parent may masked
29007f96995eSDavid Xu 	 * the signal.
29017f96995eSDavid Xu 	 */
29027f96995eSDavid Xu 	p->p_pptr->p_flag |= P_STATCHILD;
29037f96995eSDavid Xu 	wakeup(p->p_pptr);
29047f96995eSDavid Xu 
29057f96995eSDavid Xu 	ps = p->p_pptr->p_sigacts;
29067f96995eSDavid Xu 	mtx_lock(&ps->ps_mtx);
29077f96995eSDavid Xu 	if ((ps->ps_flag & PS_NOCLDSTOP) == 0) {
29087f96995eSDavid Xu 		mtx_unlock(&ps->ps_mtx);
29097f96995eSDavid Xu 		sigparent(p, reason, status);
29107f96995eSDavid Xu 	} else
29117f96995eSDavid Xu 		mtx_unlock(&ps->ps_mtx);
29127f96995eSDavid Xu }
29137f96995eSDavid Xu 
29147f96995eSDavid Xu void
29157f96995eSDavid Xu childproc_stopped(struct proc *p, int reason)
29167f96995eSDavid Xu {
29177f96995eSDavid Xu 	childproc_jobstate(p, reason, p->p_xstat);
29187f96995eSDavid Xu }
29197f96995eSDavid Xu 
2920ebceaf6dSDavid Xu void
2921ebceaf6dSDavid Xu childproc_continued(struct proc *p)
2922ebceaf6dSDavid Xu {
29237f96995eSDavid Xu 	childproc_jobstate(p, CLD_CONTINUED, SIGCONT);
2924ebceaf6dSDavid Xu }
2925ebceaf6dSDavid Xu 
2926ebceaf6dSDavid Xu void
2927ebceaf6dSDavid Xu childproc_exited(struct proc *p)
2928ebceaf6dSDavid Xu {
2929ebceaf6dSDavid Xu 	int reason;
2930f4d85223SDavid Xu 	int status = p->p_xstat; /* convert to int */
2931ebceaf6dSDavid Xu 
2932ebceaf6dSDavid Xu 	reason = CLD_EXITED;
2933f4d85223SDavid Xu 	if (WCOREDUMP(status))
2934ebceaf6dSDavid Xu 		reason = CLD_DUMPED;
2935f4d85223SDavid Xu 	else if (WIFSIGNALED(status))
2936ebceaf6dSDavid Xu 		reason = CLD_KILLED;
29377f96995eSDavid Xu 	/*
29387f96995eSDavid Xu 	 * XXX avoid calling wakeup(p->p_pptr), the work is
29397f96995eSDavid Xu 	 * done in exit1().
29407f96995eSDavid Xu 	 */
29417f96995eSDavid Xu 	sigparent(p, reason, status);
2942ebceaf6dSDavid Xu }
2943ebceaf6dSDavid Xu 
29446d1ab6edSWarner Losh static char corefilename[MAXPATHLEN] = {"%N.core"};
2945c5edb423SSean Eric Fagan SYSCTL_STRING(_kern, OID_AUTO, corefile, CTLFLAG_RW, corefilename,
2946c5edb423SSean Eric Fagan 	      sizeof(corefilename), "process corefile name format string");
2947c5edb423SSean Eric Fagan 
2948c5edb423SSean Eric Fagan /*
2949c5edb423SSean Eric Fagan  * expand_name(name, uid, pid)
2950c5edb423SSean Eric Fagan  * Expand the name described in corefilename, using name, uid, and pid.
2951c5edb423SSean Eric Fagan  * corefilename is a printf-like string, with three format specifiers:
2952c5edb423SSean Eric Fagan  *	%N	name of process ("name")
2953c5edb423SSean Eric Fagan  *	%P	process id (pid)
2954c5edb423SSean Eric Fagan  *	%U	user id (uid)
2955c5edb423SSean Eric Fagan  * For example, "%N.core" is the default; they can be disabled completely
2956c5edb423SSean Eric Fagan  * by using "/dev/null", or all core files can be stored in "/cores/%U/%N-%P".
2957c5edb423SSean Eric Fagan  * This is controlled by the sysctl variable kern.corefile (see above).
2958c5edb423SSean Eric Fagan  */
2959c5edb423SSean Eric Fagan 
2960fca666a1SJulian Elischer static char *
2961c5edb423SSean Eric Fagan expand_name(name, uid, pid)
29628b43b535SAlfred Perlstein 	const char *name;
29638b43b535SAlfred Perlstein 	uid_t uid;
29648b43b535SAlfred Perlstein 	pid_t pid;
29658b43b535SAlfred Perlstein {
29668b43b535SAlfred Perlstein 	const char *format, *appendstr;
2967c5edb423SSean Eric Fagan 	char *temp;
2968c5edb423SSean Eric Fagan 	char buf[11];		/* Buffer for pid/uid -- max 4B */
29698b43b535SAlfred Perlstein 	size_t i, l, n;
2970c5edb423SSean Eric Fagan 
29718b43b535SAlfred Perlstein 	format = corefilename;
29728b43b535SAlfred Perlstein 	temp = malloc(MAXPATHLEN, M_TEMP, M_NOWAIT | M_ZERO);
29730bfe2990SEivind Eklund 	if (temp == NULL)
29748b43b535SAlfred Perlstein 		return (NULL);
2975ce38ca0fSAlfred Perlstein 	for (i = 0, n = 0; n < MAXPATHLEN && format[i]; i++) {
2976c5edb423SSean Eric Fagan 		switch (format[i]) {
2977c5edb423SSean Eric Fagan 		case '%':	/* Format character */
2978c5edb423SSean Eric Fagan 			i++;
2979c5edb423SSean Eric Fagan 			switch (format[i]) {
2980c5edb423SSean Eric Fagan 			case '%':
29818b43b535SAlfred Perlstein 				appendstr = "%";
2982c5edb423SSean Eric Fagan 				break;
2983c5edb423SSean Eric Fagan 			case 'N':	/* process name */
29848b43b535SAlfred Perlstein 				appendstr = name;
2985c5edb423SSean Eric Fagan 				break;
2986c5edb423SSean Eric Fagan 			case 'P':	/* process id */
29878b43b535SAlfred Perlstein 				sprintf(buf, "%u", pid);
29888b43b535SAlfred Perlstein 				appendstr = buf;
2989c5edb423SSean Eric Fagan 				break;
2990c5edb423SSean Eric Fagan 			case 'U':	/* user id */
29918b43b535SAlfred Perlstein 				sprintf(buf, "%u", uid);
29928b43b535SAlfred Perlstein 				appendstr = buf;
2993c5edb423SSean Eric Fagan 				break;
2994c5edb423SSean Eric Fagan 			default:
29958b43b535SAlfred Perlstein 				appendstr = "";
29968b43b535SAlfred Perlstein 			  	log(LOG_ERR,
29978b43b535SAlfred Perlstein 				    "Unknown format character %c in `%s'\n",
29988b43b535SAlfred Perlstein 				    format[i], format);
2999c5edb423SSean Eric Fagan 			}
30008b43b535SAlfred Perlstein 			l = strlen(appendstr);
30018b43b535SAlfred Perlstein 			if ((n + l) >= MAXPATHLEN)
30028b43b535SAlfred Perlstein 				goto toolong;
30038b43b535SAlfred Perlstein 			memcpy(temp + n, appendstr, l);
30048b43b535SAlfred Perlstein 			n += l;
3005c5edb423SSean Eric Fagan 			break;
3006c5edb423SSean Eric Fagan 		default:
3007c5edb423SSean Eric Fagan 			temp[n++] = format[i];
3008c5edb423SSean Eric Fagan 		}
3009c5edb423SSean Eric Fagan 	}
30108b43b535SAlfred Perlstein 	if (format[i] != '\0')
30118b43b535SAlfred Perlstein 		goto toolong;
30128b43b535SAlfred Perlstein 	return (temp);
30138b43b535SAlfred Perlstein toolong:
30148b43b535SAlfred Perlstein 	log(LOG_ERR, "pid %ld (%s), uid (%lu): corename is too long\n",
30158b43b535SAlfred Perlstein 	    (long)pid, name, (u_long)uid);
30168b43b535SAlfred Perlstein 	free(temp, M_TEMP);
30178b43b535SAlfred Perlstein 	return (NULL);
3018c5edb423SSean Eric Fagan }
3019c5edb423SSean Eric Fagan 
3020df8bae1dSRodney W. Grimes /*
3021fca666a1SJulian Elischer  * Dump a process' core.  The main routine does some
3022fca666a1SJulian Elischer  * policy checking, and creates the name of the coredump;
3023fca666a1SJulian Elischer  * then it passes on a vnode and a size limit to the process-specific
3024fca666a1SJulian Elischer  * coredump routine if there is one; if there _is not_ one, it returns
3025fca666a1SJulian Elischer  * ENOSYS; otherwise it returns the error from the process-specific routine.
3026fca666a1SJulian Elischer  */
3027fca666a1SJulian Elischer 
3028fca666a1SJulian Elischer static int
3029b40ce416SJulian Elischer coredump(struct thread *td)
3030fca666a1SJulian Elischer {
3031b40ce416SJulian Elischer 	struct proc *p = td->td_proc;
3032fca666a1SJulian Elischer 	register struct vnode *vp;
30339c1ab3e0SJohn Baldwin 	register struct ucred *cred = td->td_ucred;
303406ae1e91SMatthew Dillon 	struct flock lf;
3035fca666a1SJulian Elischer 	struct nameidata nd;
3036fca666a1SJulian Elischer 	struct vattr vattr;
3037c447f5b2SRobert Watson 	int error, error1, flags, locked;
3038f2a2857bSKirk McKusick 	struct mount *mp;
3039fca666a1SJulian Elischer 	char *name;			/* name of corefile */
3040fca666a1SJulian Elischer 	off_t limit;
304133f19beeSJohn Baldwin 	int vfslocked;
3042fca666a1SJulian Elischer 
30434ae89b95SJohn Baldwin 	PROC_LOCK_ASSERT(p, MA_OWNED);
3044f97c3df1SDavid Schultz 	MPASS((p->p_flag & P_HADTHREADS) == 0 || p->p_singlethread == td);
3045628d2653SJohn Baldwin 	_STOPEVENT(p, S_CORE, 0);
3046fca666a1SJulian Elischer 
3047628d2653SJohn Baldwin 	if (((sugid_coredump == 0) && p->p_flag & P_SUGID) || do_coredump == 0) {
3048628d2653SJohn Baldwin 		PROC_UNLOCK(p);
3049fca666a1SJulian Elischer 		return (EFAULT);
3050628d2653SJohn Baldwin 	}
3051fca666a1SJulian Elischer 
3052fca666a1SJulian Elischer 	/*
305335a2598fSSean Eric Fagan 	 * Note that the bulk of limit checking is done after
305435a2598fSSean Eric Fagan 	 * the corefile is created.  The exception is if the limit
305535a2598fSSean Eric Fagan 	 * for corefiles is 0, in which case we don't bother
305635a2598fSSean Eric Fagan 	 * creating the corefile at all.  This layout means that
305735a2598fSSean Eric Fagan 	 * a corefile is truncated instead of not being created,
305835a2598fSSean Eric Fagan 	 * if it is larger than the limit.
3059fca666a1SJulian Elischer 	 */
306091d5354aSJohn Baldwin 	limit = (off_t)lim_cur(p, RLIMIT_CORE);
3061628d2653SJohn Baldwin 	PROC_UNLOCK(p);
306291d5354aSJohn Baldwin 	if (limit == 0)
306391d5354aSJohn Baldwin 		return (EFBIG);
306435a2598fSSean Eric Fagan 
3065f2a2857bSKirk McKusick restart:
30669c1ab3e0SJohn Baldwin 	name = expand_name(p->p_comm, td->td_ucred->cr_uid, p->p_pid);
306733f19beeSJohn Baldwin 	if (name == NULL)
3068ccdbd10cSPeter Pentchev 		return (EINVAL);
306933f19beeSJohn Baldwin 	NDINIT(&nd, LOOKUP, NOFOLLOW | MPSAFE, UIO_SYSSPACE, name, td);
3070e6796b67SKirk McKusick 	flags = O_CREAT | FWRITE | O_NOFOLLOW;
30717c89f162SPoul-Henning Kamp 	error = vn_open(&nd, &flags, S_IRUSR | S_IWUSR, -1);
3072fca666a1SJulian Elischer 	free(name, M_TEMP);
307333f19beeSJohn Baldwin 	if (error)
3074fca666a1SJulian Elischer 		return (error);
307533f19beeSJohn Baldwin 	vfslocked = NDHASGIANT(&nd);
3076762e6b85SEivind Eklund 	NDFREE(&nd, NDF_ONLY_PNBUF);
3077fca666a1SJulian Elischer 	vp = nd.ni_vp;
307806ae1e91SMatthew Dillon 
3079832dafadSDon Lewis 	/* Don't dump to non-regular files or files with links. */
3080832dafadSDon Lewis 	if (vp->v_type != VREG ||
3081832dafadSDon Lewis 	    VOP_GETATTR(vp, &vattr, cred, td) || vattr.va_nlink != 1) {
3082832dafadSDon Lewis 		VOP_UNLOCK(vp, 0, td);
3083832dafadSDon Lewis 		error = EFAULT;
308433f19beeSJohn Baldwin 		goto close;
3085832dafadSDon Lewis 	}
3086832dafadSDon Lewis 
3087b40ce416SJulian Elischer 	VOP_UNLOCK(vp, 0, td);
308806ae1e91SMatthew Dillon 	lf.l_whence = SEEK_SET;
308906ae1e91SMatthew Dillon 	lf.l_start = 0;
309006ae1e91SMatthew Dillon 	lf.l_len = 0;
309106ae1e91SMatthew Dillon 	lf.l_type = F_WRLCK;
3092c447f5b2SRobert Watson 	locked = (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &lf, F_FLOCK) == 0);
309306ae1e91SMatthew Dillon 
309406ae1e91SMatthew Dillon 	if (vn_start_write(vp, &mp, V_NOWAIT) != 0) {
309506ae1e91SMatthew Dillon 		lf.l_type = F_UNLCK;
309636bbf86bSRobert Watson 		if (locked)
309706ae1e91SMatthew Dillon 			VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_FLOCK);
3098b40ce416SJulian Elischer 		if ((error = vn_close(vp, FWRITE, cred, td)) != 0)
309933f19beeSJohn Baldwin 			goto out;
3100f2a2857bSKirk McKusick 		if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
310133f19beeSJohn Baldwin 			goto out;
310233f19beeSJohn Baldwin 		VFS_UNLOCK_GIANT(vfslocked);
3103f2a2857bSKirk McKusick 		goto restart;
3104f2a2857bSKirk McKusick 	}
3105fca666a1SJulian Elischer 
3106fca666a1SJulian Elischer 	VATTR_NULL(&vattr);
3107fca666a1SJulian Elischer 	vattr.va_size = 0;
31086141e04aSJohn-Mark Gurney 	if (set_core_nodump_flag)
31096141e04aSJohn-Mark Gurney 		vattr.va_flags = UF_NODUMP;
311088b1d98fSPaul Saab 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
3111b40ce416SJulian Elischer 	VOP_LEASE(vp, td, cred, LEASE_WRITE);
3112b40ce416SJulian Elischer 	VOP_SETATTR(vp, &vattr, cred, td);
311388b1d98fSPaul Saab 	VOP_UNLOCK(vp, 0, td);
311411991ab4STor Egge 	vn_finished_write(mp);
3115628d2653SJohn Baldwin 	PROC_LOCK(p);
3116fca666a1SJulian Elischer 	p->p_acflag |= ACORE;
3117628d2653SJohn Baldwin 	PROC_UNLOCK(p);
3118fca666a1SJulian Elischer 
3119fca666a1SJulian Elischer 	error = p->p_sysent->sv_coredump ?
3120b40ce416SJulian Elischer 	  p->p_sysent->sv_coredump(td, vp, limit) :
3121fca666a1SJulian Elischer 	  ENOSYS;
3122fca666a1SJulian Elischer 
3123c447f5b2SRobert Watson 	if (locked) {
312406ae1e91SMatthew Dillon 		lf.l_type = F_UNLCK;
312506ae1e91SMatthew Dillon 		VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_FLOCK);
3126c447f5b2SRobert Watson 	}
312733f19beeSJohn Baldwin close:
3128b40ce416SJulian Elischer 	error1 = vn_close(vp, FWRITE, cred, td);
3129fca666a1SJulian Elischer 	if (error == 0)
3130fca666a1SJulian Elischer 		error = error1;
313133f19beeSJohn Baldwin out:
313233f19beeSJohn Baldwin 	VFS_UNLOCK_GIANT(vfslocked);
3133fca666a1SJulian Elischer 	return (error);
3134fca666a1SJulian Elischer }
3135fca666a1SJulian Elischer 
3136fca666a1SJulian Elischer /*
31370c14ff0eSRobert Watson  * Nonexistent system call-- signal process (may want to handle it).  Flag
31380c14ff0eSRobert Watson  * error in case process won't see signal immediately (blocked or ignored).
3139df8bae1dSRodney W. Grimes  */
3140d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_
3141df8bae1dSRodney W. Grimes struct nosys_args {
3142df8bae1dSRodney W. Grimes 	int	dummy;
3143df8bae1dSRodney W. Grimes };
3144d2d3e875SBruce Evans #endif
3145df8bae1dSRodney W. Grimes /* ARGSUSED */
314626f9a767SRodney W. Grimes int
3147b40ce416SJulian Elischer nosys(td, args)
3148b40ce416SJulian Elischer 	struct thread *td;
3149df8bae1dSRodney W. Grimes 	struct nosys_args *args;
3150df8bae1dSRodney W. Grimes {
3151b40ce416SJulian Elischer 	struct proc *p = td->td_proc;
3152b40ce416SJulian Elischer 
3153628d2653SJohn Baldwin 	PROC_LOCK(p);
3154df8bae1dSRodney W. Grimes 	psignal(p, SIGSYS);
3155628d2653SJohn Baldwin 	PROC_UNLOCK(p);
3156f5216b9aSBruce Evans 	return (ENOSYS);
3157df8bae1dSRodney W. Grimes }
3158831d27a9SDon Lewis 
3159831d27a9SDon Lewis /*
31600c14ff0eSRobert Watson  * Send a SIGIO or SIGURG signal to a process or process group using stored
31610c14ff0eSRobert Watson  * credentials rather than those of the current process.
3162831d27a9SDon Lewis  */
3163831d27a9SDon Lewis void
3164f1320723SAlfred Perlstein pgsigio(sigiop, sig, checkctty)
3165f1320723SAlfred Perlstein 	struct sigio **sigiop;
31662c42a146SMarcel Moolenaar 	int sig, checkctty;
3167831d27a9SDon Lewis {
3168f1320723SAlfred Perlstein 	struct sigio *sigio;
3169831d27a9SDon Lewis 
3170f1320723SAlfred Perlstein 	SIGIO_LOCK();
3171f1320723SAlfred Perlstein 	sigio = *sigiop;
3172f1320723SAlfred Perlstein 	if (sigio == NULL) {
3173f1320723SAlfred Perlstein 		SIGIO_UNLOCK();
3174f1320723SAlfred Perlstein 		return;
3175f1320723SAlfred Perlstein 	}
3176831d27a9SDon Lewis 	if (sigio->sio_pgid > 0) {
3177628d2653SJohn Baldwin 		PROC_LOCK(sigio->sio_proc);
31782b87b6d4SRobert Watson 		if (CANSIGIO(sigio->sio_ucred, sigio->sio_proc->p_ucred))
31792c42a146SMarcel Moolenaar 			psignal(sigio->sio_proc, sig);
3180628d2653SJohn Baldwin 		PROC_UNLOCK(sigio->sio_proc);
3181831d27a9SDon Lewis 	} else if (sigio->sio_pgid < 0) {
3182831d27a9SDon Lewis 		struct proc *p;
3183831d27a9SDon Lewis 
3184f591779bSSeigo Tanimura 		PGRP_LOCK(sigio->sio_pgrp);
3185628d2653SJohn Baldwin 		LIST_FOREACH(p, &sigio->sio_pgrp->pg_members, p_pglist) {
3186628d2653SJohn Baldwin 			PROC_LOCK(p);
31872b87b6d4SRobert Watson 			if (CANSIGIO(sigio->sio_ucred, p->p_ucred) &&
3188831d27a9SDon Lewis 			    (checkctty == 0 || (p->p_flag & P_CONTROLT)))
31892c42a146SMarcel Moolenaar 				psignal(p, sig);
3190628d2653SJohn Baldwin 			PROC_UNLOCK(p);
3191628d2653SJohn Baldwin 		}
3192f591779bSSeigo Tanimura 		PGRP_UNLOCK(sigio->sio_pgrp);
3193831d27a9SDon Lewis 	}
3194f1320723SAlfred Perlstein 	SIGIO_UNLOCK();
3195831d27a9SDon Lewis }
3196cb679c38SJonathan Lemon 
3197cb679c38SJonathan Lemon static int
3198cb679c38SJonathan Lemon filt_sigattach(struct knote *kn)
3199cb679c38SJonathan Lemon {
3200cb679c38SJonathan Lemon 	struct proc *p = curproc;
3201cb679c38SJonathan Lemon 
3202cb679c38SJonathan Lemon 	kn->kn_ptr.p_proc = p;
3203cb679c38SJonathan Lemon 	kn->kn_flags |= EV_CLEAR;		/* automatically set */
3204cb679c38SJonathan Lemon 
3205ad3b9257SJohn-Mark Gurney 	knlist_add(&p->p_klist, kn, 0);
3206cb679c38SJonathan Lemon 
3207cb679c38SJonathan Lemon 	return (0);
3208cb679c38SJonathan Lemon }
3209cb679c38SJonathan Lemon 
3210cb679c38SJonathan Lemon static void
3211cb679c38SJonathan Lemon filt_sigdetach(struct knote *kn)
3212cb679c38SJonathan Lemon {
3213cb679c38SJonathan Lemon 	struct proc *p = kn->kn_ptr.p_proc;
3214cb679c38SJonathan Lemon 
3215ad3b9257SJohn-Mark Gurney 	knlist_remove(&p->p_klist, kn, 0);
3216cb679c38SJonathan Lemon }
3217cb679c38SJonathan Lemon 
3218cb679c38SJonathan Lemon /*
3219cb679c38SJonathan Lemon  * signal knotes are shared with proc knotes, so we apply a mask to
3220cb679c38SJonathan Lemon  * the hint in order to differentiate them from process hints.  This
3221cb679c38SJonathan Lemon  * could be avoided by using a signal-specific knote list, but probably
3222cb679c38SJonathan Lemon  * isn't worth the trouble.
3223cb679c38SJonathan Lemon  */
3224cb679c38SJonathan Lemon static int
3225cb679c38SJonathan Lemon filt_signal(struct knote *kn, long hint)
3226cb679c38SJonathan Lemon {
3227cb679c38SJonathan Lemon 
3228cb679c38SJonathan Lemon 	if (hint & NOTE_SIGNAL) {
3229cb679c38SJonathan Lemon 		hint &= ~NOTE_SIGNAL;
3230cb679c38SJonathan Lemon 
3231cb679c38SJonathan Lemon 		if (kn->kn_id == hint)
3232cb679c38SJonathan Lemon 			kn->kn_data++;
3233cb679c38SJonathan Lemon 	}
3234cb679c38SJonathan Lemon 	return (kn->kn_data != 0);
3235cb679c38SJonathan Lemon }
323690af4afaSJohn Baldwin 
323790af4afaSJohn Baldwin struct sigacts *
323890af4afaSJohn Baldwin sigacts_alloc(void)
323990af4afaSJohn Baldwin {
324090af4afaSJohn Baldwin 	struct sigacts *ps;
324190af4afaSJohn Baldwin 
324290af4afaSJohn Baldwin 	ps = malloc(sizeof(struct sigacts), M_SUBPROC, M_WAITOK | M_ZERO);
324390af4afaSJohn Baldwin 	ps->ps_refcnt = 1;
324490af4afaSJohn Baldwin 	mtx_init(&ps->ps_mtx, "sigacts", NULL, MTX_DEF);
324590af4afaSJohn Baldwin 	return (ps);
324690af4afaSJohn Baldwin }
324790af4afaSJohn Baldwin 
324890af4afaSJohn Baldwin void
324990af4afaSJohn Baldwin sigacts_free(struct sigacts *ps)
325090af4afaSJohn Baldwin {
325190af4afaSJohn Baldwin 
325290af4afaSJohn Baldwin 	mtx_lock(&ps->ps_mtx);
325390af4afaSJohn Baldwin 	ps->ps_refcnt--;
325490af4afaSJohn Baldwin 	if (ps->ps_refcnt == 0) {
325590af4afaSJohn Baldwin 		mtx_destroy(&ps->ps_mtx);
325690af4afaSJohn Baldwin 		free(ps, M_SUBPROC);
325790af4afaSJohn Baldwin 	} else
325890af4afaSJohn Baldwin 		mtx_unlock(&ps->ps_mtx);
325990af4afaSJohn Baldwin }
326090af4afaSJohn Baldwin 
326190af4afaSJohn Baldwin struct sigacts *
326290af4afaSJohn Baldwin sigacts_hold(struct sigacts *ps)
326390af4afaSJohn Baldwin {
326490af4afaSJohn Baldwin 	mtx_lock(&ps->ps_mtx);
326590af4afaSJohn Baldwin 	ps->ps_refcnt++;
326690af4afaSJohn Baldwin 	mtx_unlock(&ps->ps_mtx);
326790af4afaSJohn Baldwin 	return (ps);
326890af4afaSJohn Baldwin }
326990af4afaSJohn Baldwin 
327090af4afaSJohn Baldwin void
327190af4afaSJohn Baldwin sigacts_copy(struct sigacts *dest, struct sigacts *src)
327290af4afaSJohn Baldwin {
327390af4afaSJohn Baldwin 
327490af4afaSJohn Baldwin 	KASSERT(dest->ps_refcnt == 1, ("sigacts_copy to shared dest"));
327590af4afaSJohn Baldwin 	mtx_lock(&src->ps_mtx);
327690af4afaSJohn Baldwin 	bcopy(src, dest, offsetof(struct sigacts, ps_refcnt));
327790af4afaSJohn Baldwin 	mtx_unlock(&src->ps_mtx);
327890af4afaSJohn Baldwin }
327990af4afaSJohn Baldwin 
328090af4afaSJohn Baldwin int
328190af4afaSJohn Baldwin sigacts_shared(struct sigacts *ps)
328290af4afaSJohn Baldwin {
328390af4afaSJohn Baldwin 	int shared;
328490af4afaSJohn Baldwin 
328590af4afaSJohn Baldwin 	mtx_lock(&ps->ps_mtx);
328690af4afaSJohn Baldwin 	shared = ps->ps_refcnt > 1;
328790af4afaSJohn Baldwin 	mtx_unlock(&ps->ps_mtx);
328890af4afaSJohn Baldwin 	return (shared);
328990af4afaSJohn Baldwin }
3290