FreeBSD kernel kern code
kern_sig.c
Go to the documentation of this file.
1 /*-
2  * Copyright (c) 1982, 1986, 1989, 1991, 1993
3  * The Regents of the University of California. All rights reserved.
4  * (c) UNIX System Laboratories, Inc.
5  * All or some portions of this file are derived from material licensed
6  * to the University of California by American Telephone and Telegraph
7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8  * the permission of UNIX System Laboratories, Inc.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  * notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  * notice, this list of conditions and the following disclaimer in the
17  * documentation and/or other materials provided with the distribution.
18  * 4. Neither the name of the University nor the names of its contributors
19  * may be used to endorse or promote products derived from this software
20  * without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  *
34  * @(#)kern_sig.c 8.7 (Berkeley) 4/18/94
35  */
36 
37 #include <sys/cdefs.h>
38 __FBSDID("$BSDSUniX$");
39 
40 #include "opt_compat.h"
41 #include "opt_kdtrace.h"
42 #include "opt_ktrace.h"
43 #include "opt_core.h"
44 #include "opt_procdesc.h"
45 
46 #include <sys/param.h>
47 #include <sys/systm.h>
48 #include <sys/signalvar.h>
49 #include <sys/vnode.h>
50 #include <sys/acct.h>
51 #include <sys/capability.h>
52 #include <sys/condvar.h>
53 #include <sys/event.h>
54 #include <sys/fcntl.h>
55 #include <sys/imgact.h>
56 #include <sys/kernel.h>
57 #include <sys/ktr.h>
58 #include <sys/ktrace.h>
59 #include <sys/lock.h>
60 #include <sys/malloc.h>
61 #include <sys/mutex.h>
62 #include <sys/namei.h>
63 #include <sys/proc.h>
64 #include <sys/procdesc.h>
65 #include <sys/posix4.h>
66 #include <sys/pioctl.h>
67 #include <sys/racct.h>
68 #include <sys/resourcevar.h>
69 #include <sys/sdt.h>
70 #include <sys/sbuf.h>
71 #include <sys/sleepqueue.h>
72 #include <sys/smp.h>
73 #include <sys/stat.h>
74 #include <sys/sx.h>
75 #include <sys/syscallsubr.h>
76 #include <sys/sysctl.h>
77 #include <sys/sysent.h>
78 #include <sys/syslog.h>
79 #include <sys/sysproto.h>
80 #include <sys/timers.h>
81 #include <sys/unistd.h>
82 #include <sys/wait.h>
83 #include <vm/vm.h>
84 #include <vm/vm_extern.h>
85 #include <vm/uma.h>
86 
87 #include <sys/jail.h>
88 
89 #include <machine/cpu.h>
90 
91 #include <security/audit/audit.h>
92 
93 #define ONSIG 32 /* NSIG for osig* syscalls. XXX. */
94 
95 SDT_PROVIDER_DECLARE(proc);
96 SDT_PROBE_DEFINE3(proc, kernel, , signal__send, "struct thread *",
97  "struct proc *", "int");
98 SDT_PROBE_DEFINE2(proc, kernel, , signal__clear, "int",
99  "ksiginfo_t *");
100 SDT_PROBE_DEFINE3(proc, kernel, , signal__discard,
101  "struct thread *", "struct proc *", "int");
102 
103 static int coredump(struct thread *);
104 static char *expand_name(const char *, uid_t, pid_t, struct thread *, int);
105 static int killpg1(struct thread *td, int sig, int pgid, int all,
106  ksiginfo_t *ksi);
107 static int issignal(struct thread *td, int stop_allowed);
108 static int sigprop(int sig);
109 static void tdsigwakeup(struct thread *, int, sig_t, int);
110 static void sig_suspend_threads(struct thread *, struct proc *, int);
111 static int filt_sigattach(struct knote *kn);
112 static void filt_sigdetach(struct knote *kn);
113 static int filt_signal(struct knote *kn, long hint);
114 static struct thread *sigtd(struct proc *p, int sig, int prop);
115 static void sigqueue_start(void);
116 
117 static uma_zone_t ksiginfo_zone = NULL;
118 struct filterops sig_filtops = {
119  .f_isfd = 0,
120  .f_attach = filt_sigattach,
121  .f_detach = filt_sigdetach,
122  .f_event = filt_signal,
123 };
124 
125 static int kern_logsigexit = 1;
126 SYSCTL_INT(_kern, KERN_LOGSIGEXIT, logsigexit, CTLFLAG_RW,
127  &kern_logsigexit, 0,
128  "Log processes quitting on abnormal signals to syslog(3)");
129 
130 static int kern_forcesigexit = 1;
131 SYSCTL_INT(_kern, OID_AUTO, forcesigexit, CTLFLAG_RW,
132  &kern_forcesigexit, 0, "Force trap signal to be handled");
133 
134 static SYSCTL_NODE(_kern, OID_AUTO, sigqueue, CTLFLAG_RW, 0,
135  "POSIX real time signal");
136 
137 static int max_pending_per_proc = 128;
138 SYSCTL_INT(_kern_sigqueue, OID_AUTO, max_pending_per_proc, CTLFLAG_RW,
139  &max_pending_per_proc, 0, "Max pending signals per proc");
140 
141 static int preallocate_siginfo = 1024;
142 TUNABLE_INT("kern.sigqueue.preallocate", &preallocate_siginfo);
143 SYSCTL_INT(_kern_sigqueue, OID_AUTO, preallocate, CTLFLAG_RD,
144  &preallocate_siginfo, 0, "Preallocated signal memory size");
145 
146 static int signal_overflow = 0;
147 SYSCTL_INT(_kern_sigqueue, OID_AUTO, overflow, CTLFLAG_RD,
148  &signal_overflow, 0, "Number of signals overflew");
149 
150 static int signal_alloc_fail = 0;
151 SYSCTL_INT(_kern_sigqueue, OID_AUTO, alloc_fail, CTLFLAG_RD,
152  &signal_alloc_fail, 0, "signals failed to be allocated");
153 
154 SYSINIT(signal, SI_SUB_P1003_1B, SI_ORDER_FIRST+3, sigqueue_start, NULL);
155 
156 /*
157  * Policy -- Can ucred cr1 send SIGIO to process cr2?
158  * Should use cr_cansignal() once cr_cansignal() allows SIGIO and SIGURG
159  * in the right situations.
160  */
161 #define CANSIGIO(cr1, cr2) \
162  ((cr1)->cr_uid == 0 || \
163  (cr1)->cr_ruid == (cr2)->cr_ruid || \
164  (cr1)->cr_uid == (cr2)->cr_ruid || \
165  (cr1)->cr_ruid == (cr2)->cr_uid || \
166  (cr1)->cr_uid == (cr2)->cr_uid)
167 
168 static int sugid_coredump;
169 SYSCTL_INT(_kern, OID_AUTO, sugid_coredump, CTLFLAG_RW,
170  &sugid_coredump, 0, "Allow setuid and setgid processes to dump core");
171 
172 static int do_coredump = 1;
173 SYSCTL_INT(_kern, OID_AUTO, coredump, CTLFLAG_RW,
174  &do_coredump, 0, "Enable/Disable coredumps");
175 
176 static int set_core_nodump_flag = 0;
177 SYSCTL_INT(_kern, OID_AUTO, nodump_coredump, CTLFLAG_RW, &set_core_nodump_flag,
178  0, "Enable setting the NODUMP flag on coredump files");
179 
180 /*
181  * Signal properties and actions.
182  * The array below categorizes the signals and their default actions
183  * according to the following properties:
184  */
185 #define SA_KILL 0x01 /* terminates process by default */
186 #define SA_CORE 0x02 /* ditto and coredumps */
187 #define SA_STOP 0x04 /* suspend process */
188 #define SA_TTYSTOP 0x08 /* ditto, from tty */
189 #define SA_IGNORE 0x10 /* ignore by default */
190 #define SA_CONT 0x20 /* continue if suspended */
191 #define SA_CANTMASK 0x40 /* non-maskable, catchable */
192 #define SA_PROC 0x80 /* deliverable to any thread */
193 
194 static int sigproptbl[NSIG] = {
195  SA_KILL|SA_PROC, /* SIGHUP */
196  SA_KILL|SA_PROC, /* SIGINT */
197  SA_KILL|SA_CORE|SA_PROC, /* SIGQUIT */
198  SA_KILL|SA_CORE, /* SIGILL */
199  SA_KILL|SA_CORE, /* SIGTRAP */
200  SA_KILL|SA_CORE, /* SIGABRT */
201  SA_KILL|SA_CORE|SA_PROC, /* SIGEMT */
202  SA_KILL|SA_CORE, /* SIGFPE */
203  SA_KILL|SA_PROC, /* SIGKILL */
204  SA_KILL|SA_CORE, /* SIGBUS */
205  SA_KILL|SA_CORE, /* SIGSEGV */
206  SA_KILL|SA_CORE, /* SIGSYS */
207  SA_KILL|SA_PROC, /* SIGPIPE */
208  SA_KILL|SA_PROC, /* SIGALRM */
209  SA_KILL|SA_PROC, /* SIGTERM */
210  SA_IGNORE|SA_PROC, /* SIGURG */
211  SA_STOP|SA_PROC, /* SIGSTOP */
212  SA_STOP|SA_TTYSTOP|SA_PROC, /* SIGTSTP */
213  SA_IGNORE|SA_CONT|SA_PROC, /* SIGCONT */
214  SA_IGNORE|SA_PROC, /* SIGCHLD */
215  SA_STOP|SA_TTYSTOP|SA_PROC, /* SIGTTIN */
216  SA_STOP|SA_TTYSTOP|SA_PROC, /* SIGTTOU */
217  SA_IGNORE|SA_PROC, /* SIGIO */
218  SA_KILL, /* SIGXCPU */
219  SA_KILL, /* SIGXFSZ */
220  SA_KILL|SA_PROC, /* SIGVTALRM */
221  SA_KILL|SA_PROC, /* SIGPROF */
222  SA_IGNORE|SA_PROC, /* SIGWINCH */
223  SA_IGNORE|SA_PROC, /* SIGINFO */
224  SA_KILL|SA_PROC, /* SIGUSR1 */
225  SA_KILL|SA_PROC, /* SIGUSR2 */
226 };
227 
228 static void reschedule_signals(struct proc *p, sigset_t block, int flags);
229 
230 static void
231 sigqueue_start(void)
232 {
233  ksiginfo_zone = uma_zcreate("ksiginfo", sizeof(ksiginfo_t),
234  NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
235  uma_prealloc(ksiginfo_zone, preallocate_siginfo);
236  p31b_setcfg(CTL_P1003_1B_REALTIME_SIGNALS, _POSIX_REALTIME_SIGNALS);
237  p31b_setcfg(CTL_P1003_1B_RTSIG_MAX, SIGRTMAX - SIGRTMIN + 1);
238  p31b_setcfg(CTL_P1003_1B_SIGQUEUE_MAX, max_pending_per_proc);
239 }
240 
241 ksiginfo_t *
242 ksiginfo_alloc(int wait)
243 {
244  int flags;
245 
246  flags = M_ZERO;
247  if (! wait)
248  flags |= M_NOWAIT;
249  if (ksiginfo_zone != NULL)
250  return ((ksiginfo_t *)uma_zalloc(ksiginfo_zone, flags));
251  return (NULL);
252 }
253 
254 void
255 ksiginfo_free(ksiginfo_t *ksi)
256 {
257  uma_zfree(ksiginfo_zone, ksi);
258 }
259 
260 static __inline int
261 ksiginfo_tryfree(ksiginfo_t *ksi)
262 {
263  if (!(ksi->ksi_flags & KSI_EXT)) {
264  uma_zfree(ksiginfo_zone, ksi);
265  return (1);
266  }
267  return (0);
268 }
269 
270 void
271 sigqueue_init(sigqueue_t *list, struct proc *p)
272 {
273  SIGEMPTYSET(list->sq_signals);
274  SIGEMPTYSET(list->sq_kill);
275  TAILQ_INIT(&list->sq_list);
276  list->sq_proc = p;
277  list->sq_flags = SQ_INIT;
278 }
279 
280 /*
281  * Get a signal's ksiginfo.
282  * Return:
283  * 0 - signal not found
284  * others - signal number
285  */
286 static int
287 sigqueue_get(sigqueue_t *sq, int signo, ksiginfo_t *si)
288 {
289  struct proc *p = sq->sq_proc;
290  struct ksiginfo *ksi, *next;
291  int count = 0;
292 
293  KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited"));
294 
295  if (!SIGISMEMBER(sq->sq_signals, signo))
296  return (0);
297 
298  if (SIGISMEMBER(sq->sq_kill, signo)) {
299  count++;
300  SIGDELSET(sq->sq_kill, signo);
301  }
302 
303  TAILQ_FOREACH_SAFE(ksi, &sq->sq_list, ksi_link, next) {
304  if (ksi->ksi_signo == signo) {
305  if (count == 0) {
306  TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link);
307  ksi->ksi_sigq = NULL;
308  ksiginfo_copy(ksi, si);
309  if (ksiginfo_tryfree(ksi) && p != NULL)
310  p->p_pendingcnt--;
311  }
312  if (++count > 1)
313  break;
314  }
315  }
316 
317  if (count <= 1)
318  SIGDELSET(sq->sq_signals, signo);
319  si->ksi_signo = signo;
320  return (signo);
321 }
322 
323 void
324 sigqueue_take(ksiginfo_t *ksi)
325 {
326  struct ksiginfo *kp;
327  struct proc *p;
328  sigqueue_t *sq;
329 
330  if (ksi == NULL || (sq = ksi->ksi_sigq) == NULL)
331  return;
332 
333  p = sq->sq_proc;
334  TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link);
335  ksi->ksi_sigq = NULL;
336  if (!(ksi->ksi_flags & KSI_EXT) && p != NULL)
337  p->p_pendingcnt--;
338 
339  for (kp = TAILQ_FIRST(&sq->sq_list); kp != NULL;
340  kp = TAILQ_NEXT(kp, ksi_link)) {
341  if (kp->ksi_signo == ksi->ksi_signo)
342  break;
343  }
344  if (kp == NULL && !SIGISMEMBER(sq->sq_kill, ksi->ksi_signo))
345  SIGDELSET(sq->sq_signals, ksi->ksi_signo);
346 }
347 
348 static int
349 sigqueue_add(sigqueue_t *sq, int signo, ksiginfo_t *si)
350 {
351  struct proc *p = sq->sq_proc;
352  struct ksiginfo *ksi;
353  int ret = 0;
354 
355  KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited"));
356 
357  if (signo == SIGKILL || signo == SIGSTOP || si == NULL) {
358  SIGADDSET(sq->sq_kill, signo);
359  goto out_set_bit;
360  }
361 
362  /* directly insert the ksi, don't copy it */
363  if (si->ksi_flags & KSI_INS) {
364  if (si->ksi_flags & KSI_HEAD)
365  TAILQ_INSERT_HEAD(&sq->sq_list, si, ksi_link);
366  else
367  TAILQ_INSERT_TAIL(&sq->sq_list, si, ksi_link);
368  si->ksi_sigq = sq;
369  goto out_set_bit;
370  }
371 
372  if (__predict_false(ksiginfo_zone == NULL)) {
373  SIGADDSET(sq->sq_kill, signo);
374  goto out_set_bit;
375  }
376 
377  if (p != NULL && p->p_pendingcnt >= max_pending_per_proc) {
378  signal_overflow++;
379  ret = EAGAIN;
380  } else if ((ksi = ksiginfo_alloc(0)) == NULL) {
381  signal_alloc_fail++;
382  ret = EAGAIN;
383  } else {
384  if (p != NULL)
385  p->p_pendingcnt++;
386  ksiginfo_copy(si, ksi);
387  ksi->ksi_signo = signo;
388  if (si->ksi_flags & KSI_HEAD)
389  TAILQ_INSERT_HEAD(&sq->sq_list, ksi, ksi_link);
390  else
391  TAILQ_INSERT_TAIL(&sq->sq_list, ksi, ksi_link);
392  ksi->ksi_sigq = sq;
393  }
394 
395  if ((si->ksi_flags & KSI_TRAP) != 0 ||
396  (si->ksi_flags & KSI_SIGQ) == 0) {
397  if (ret != 0)
398  SIGADDSET(sq->sq_kill, signo);
399  ret = 0;
400  goto out_set_bit;
401  }
402 
403  if (ret != 0)
404  return (ret);
405 
406 out_set_bit:
407  SIGADDSET(sq->sq_signals, signo);
408  return (ret);
409 }
410 
411 void
412 sigqueue_flush(sigqueue_t *sq)
413 {
414  struct proc *p = sq->sq_proc;
415  ksiginfo_t *ksi;
416 
417  KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited"));
418 
419  if (p != NULL)
420  PROC_LOCK_ASSERT(p, MA_OWNED);
421 
422  while ((ksi = TAILQ_FIRST(&sq->sq_list)) != NULL) {
423  TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link);
424  ksi->ksi_sigq = NULL;
425  if (ksiginfo_tryfree(ksi) && p != NULL)
426  p->p_pendingcnt--;
427  }
428 
429  SIGEMPTYSET(sq->sq_signals);
430  SIGEMPTYSET(sq->sq_kill);
431 }
432 
433 static void
434 sigqueue_move_set(sigqueue_t *src, sigqueue_t *dst, const sigset_t *set)
435 {
436  sigset_t tmp;
437  struct proc *p1, *p2;
438  ksiginfo_t *ksi, *next;
439 
440  KASSERT(src->sq_flags & SQ_INIT, ("src sigqueue not inited"));
441  KASSERT(dst->sq_flags & SQ_INIT, ("dst sigqueue not inited"));
442  p1 = src->sq_proc;
443  p2 = dst->sq_proc;
444  /* Move siginfo to target list */
445  TAILQ_FOREACH_SAFE(ksi, &src->sq_list, ksi_link, next) {
446  if (SIGISMEMBER(*set, ksi->ksi_signo)) {
447  TAILQ_REMOVE(&src->sq_list, ksi, ksi_link);
448  if (p1 != NULL)
449  p1->p_pendingcnt--;
450  TAILQ_INSERT_TAIL(&dst->sq_list, ksi, ksi_link);
451  ksi->ksi_sigq = dst;
452  if (p2 != NULL)
453  p2->p_pendingcnt++;
454  }
455  }
456 
457  /* Move pending bits to target list */
458  tmp = src->sq_kill;
459  SIGSETAND(tmp, *set);
460  SIGSETOR(dst->sq_kill, tmp);
461  SIGSETNAND(src->sq_kill, tmp);
462 
463  tmp = src->sq_signals;
464  SIGSETAND(tmp, *set);
465  SIGSETOR(dst->sq_signals, tmp);
466  SIGSETNAND(src->sq_signals, tmp);
467 }
468 
469 #if 0
470 static void
471 sigqueue_move(sigqueue_t *src, sigqueue_t *dst, int signo)
472 {
473  sigset_t set;
474 
475  SIGEMPTYSET(set);
476  SIGADDSET(set, signo);
477  sigqueue_move_set(src, dst, &set);
478 }
479 #endif
480 
481 static void
482 sigqueue_delete_set(sigqueue_t *sq, const sigset_t *set)
483 {
484  struct proc *p = sq->sq_proc;
485  ksiginfo_t *ksi, *next;
486 
487  KASSERT(sq->sq_flags & SQ_INIT, ("src sigqueue not inited"));
488 
489  /* Remove siginfo queue */
490  TAILQ_FOREACH_SAFE(ksi, &sq->sq_list, ksi_link, next) {
491  if (SIGISMEMBER(*set, ksi->ksi_signo)) {
492  TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link);
493  ksi->ksi_sigq = NULL;
494  if (ksiginfo_tryfree(ksi) && p != NULL)
495  p->p_pendingcnt--;
496  }
497  }
498  SIGSETNAND(sq->sq_kill, *set);
499  SIGSETNAND(sq->sq_signals, *set);
500 }
501 
502 void
503 sigqueue_delete(sigqueue_t *sq, int signo)
504 {
505  sigset_t set;
506 
507  SIGEMPTYSET(set);
508  SIGADDSET(set, signo);
509  sigqueue_delete_set(sq, &set);
510 }
511 
512 /* Remove a set of signals for a process */
513 static void
514 sigqueue_delete_set_proc(struct proc *p, const sigset_t *set)
515 {
516  sigqueue_t worklist;
517  struct thread *td0;
518 
519  PROC_LOCK_ASSERT(p, MA_OWNED);
520 
521  sigqueue_init(&worklist, NULL);
522  sigqueue_move_set(&p->p_sigqueue, &worklist, set);
523 
524  FOREACH_THREAD_IN_PROC(p, td0)
525  sigqueue_move_set(&td0->td_sigqueue, &worklist, set);
526 
527  sigqueue_flush(&worklist);
528 }
529 
530 void
531 sigqueue_delete_proc(struct proc *p, int signo)
532 {
533  sigset_t set;
534 
535  SIGEMPTYSET(set);
536  SIGADDSET(set, signo);
537  sigqueue_delete_set_proc(p, &set);
538 }
539 
540 static void
541 sigqueue_delete_stopmask_proc(struct proc *p)
542 {
543  sigset_t set;
544 
545  SIGEMPTYSET(set);
546  SIGADDSET(set, SIGSTOP);
547  SIGADDSET(set, SIGTSTP);
548  SIGADDSET(set, SIGTTIN);
549  SIGADDSET(set, SIGTTOU);
550  sigqueue_delete_set_proc(p, &set);
551 }
552 
553 /*
554  * Determine signal that should be delivered to process p, the current
555  * process, 0 if none. If there is a pending stop signal with default
556  * action, the process stops in issignal().
557  */
558 int
559 cursig(struct thread *td, int stop_allowed)
560 {
561  PROC_LOCK_ASSERT(td->td_proc, MA_OWNED);
562  KASSERT(stop_allowed == SIG_STOP_ALLOWED ||
563  stop_allowed == SIG_STOP_NOT_ALLOWED, ("cursig: stop_allowed"));
564  mtx_assert(&td->td_proc->p_sigacts->ps_mtx, MA_OWNED);
565  THREAD_LOCK_ASSERT(td, MA_NOTOWNED);
566  return (SIGPENDING(td) ? issignal(td, stop_allowed) : 0);
567 }
568 
569 /*
570  * Arrange for ast() to handle unmasked pending signals on return to user
571  * mode. This must be called whenever a signal is added to td_sigqueue or
572  * unmasked in td_sigmask.
573  */
574 void
575 signotify(struct thread *td)
576 {
577  struct proc *p;
578 
579  p = td->td_proc;
580 
581  PROC_LOCK_ASSERT(p, MA_OWNED);
582 
583  if (SIGPENDING(td)) {
584  thread_lock(td);
585  td->td_flags |= TDF_NEEDSIGCHK | TDF_ASTPENDING;
586  thread_unlock(td);
587  }
588 }
589 
590 int
591 sigonstack(size_t sp)
592 {
593  struct thread *td = curthread;
594 
595  return ((td->td_pflags & TDP_ALTSTACK) ?
596 #if defined(COMPAT_43)
597  ((td->td_sigstk.ss_size == 0) ?
598  (td->td_sigstk.ss_flags & SS_ONSTACK) :
599  ((sp - (size_t)td->td_sigstk.ss_sp) < td->td_sigstk.ss_size))
600 #else
601  ((sp - (size_t)td->td_sigstk.ss_sp) < td->td_sigstk.ss_size)
602 #endif
603  : 0);
604 }
605 
606 static __inline int
607 sigprop(int sig)
608 {
609 
610  if (sig > 0 && sig < NSIG)
611  return (sigproptbl[_SIG_IDX(sig)]);
612  return (0);
613 }
614 
615 int
616 sig_ffs(sigset_t *set)
617 {
618  int i;
619 
620  for (i = 0; i < _SIG_WORDS; i++)
621  if (set->__bits[i])
622  return (ffs(set->__bits[i]) + (i * 32));
623  return (0);
624 }
625 
626 /*
627  * kern_sigaction
628  * sigaction
629  * freebsd4_sigaction
630  * osigaction
631  */
632 int
633 kern_sigaction(td, sig, act, oact, flags)
634  struct thread *td;
635  register int sig;
636  struct sigaction *act, *oact;
637  int flags;
638 {
639  struct sigacts *ps;
640  struct proc *p = td->td_proc;
641 
642  if (!_SIG_VALID(sig))
643  return (EINVAL);
644 
645  PROC_LOCK(p);
646  ps = p->p_sigacts;
647  mtx_lock(&ps->ps_mtx);
648  if (oact) {
649  oact->sa_mask = ps->ps_catchmask[_SIG_IDX(sig)];
650  oact->sa_flags = 0;
651  if (SIGISMEMBER(ps->ps_sigonstack, sig))
652  oact->sa_flags |= SA_ONSTACK;
653  if (!SIGISMEMBER(ps->ps_sigintr, sig))
654  oact->sa_flags |= SA_RESTART;
655  if (SIGISMEMBER(ps->ps_sigreset, sig))
656  oact->sa_flags |= SA_RESETHAND;
657  if (SIGISMEMBER(ps->ps_signodefer, sig))
658  oact->sa_flags |= SA_NODEFER;
659  if (SIGISMEMBER(ps->ps_siginfo, sig)) {
660  oact->sa_flags |= SA_SIGINFO;
661  oact->sa_sigaction =
662  (__siginfohandler_t *)ps->ps_sigact[_SIG_IDX(sig)];
663  } else
664  oact->sa_handler = ps->ps_sigact[_SIG_IDX(sig)];
665  if (sig == SIGCHLD && ps->ps_flag & PS_NOCLDSTOP)
666  oact->sa_flags |= SA_NOCLDSTOP;
667  if (sig == SIGCHLD && ps->ps_flag & PS_NOCLDWAIT)
668  oact->sa_flags |= SA_NOCLDWAIT;
669  }
670  if (act) {
671  if ((sig == SIGKILL || sig == SIGSTOP) &&
672  act->sa_handler != SIG_DFL) {
673  mtx_unlock(&ps->ps_mtx);
674  PROC_UNLOCK(p);
675  return (EINVAL);
676  }
677 
678  /*
679  * Change setting atomically.
680  */
681 
682  ps->ps_catchmask[_SIG_IDX(sig)] = act->sa_mask;
683  SIG_CANTMASK(ps->ps_catchmask[_SIG_IDX(sig)]);
684  if (act->sa_flags & SA_SIGINFO) {
685  ps->ps_sigact[_SIG_IDX(sig)] =
686  (__sighandler_t *)act->sa_sigaction;
687  SIGADDSET(ps->ps_siginfo, sig);
688  } else {
689  ps->ps_sigact[_SIG_IDX(sig)] = act->sa_handler;
690  SIGDELSET(ps->ps_siginfo, sig);
691  }
692  if (!(act->sa_flags & SA_RESTART))
693  SIGADDSET(ps->ps_sigintr, sig);
694  else
695  SIGDELSET(ps->ps_sigintr, sig);
696  if (act->sa_flags & SA_ONSTACK)
697  SIGADDSET(ps->ps_sigonstack, sig);
698  else
699  SIGDELSET(ps->ps_sigonstack, sig);
700  if (act->sa_flags & SA_RESETHAND)
701  SIGADDSET(ps->ps_sigreset, sig);
702  else
703  SIGDELSET(ps->ps_sigreset, sig);
704  if (act->sa_flags & SA_NODEFER)
705  SIGADDSET(ps->ps_signodefer, sig);
706  else
707  SIGDELSET(ps->ps_signodefer, sig);
708  if (sig == SIGCHLD) {
709  if (act->sa_flags & SA_NOCLDSTOP)
710  ps->ps_flag |= PS_NOCLDSTOP;
711  else
712  ps->ps_flag &= ~PS_NOCLDSTOP;
713  if (act->sa_flags & SA_NOCLDWAIT) {
714  /*
715  * Paranoia: since SA_NOCLDWAIT is implemented
716  * by reparenting the dying child to PID 1 (and
717  * trust it to reap the zombie), PID 1 itself
718  * is forbidden to set SA_NOCLDWAIT.
719  */
720  if (p->p_pid == 1)
721  ps->ps_flag &= ~PS_NOCLDWAIT;
722  else
723  ps->ps_flag |= PS_NOCLDWAIT;
724  } else
725  ps->ps_flag &= ~PS_NOCLDWAIT;
726  if (ps->ps_sigact[_SIG_IDX(SIGCHLD)] == SIG_IGN)
727  ps->ps_flag |= PS_CLDSIGIGN;
728  else
729  ps->ps_flag &= ~PS_CLDSIGIGN;
730  }
731  /*
732  * Set bit in ps_sigignore for signals that are set to SIG_IGN,
733  * and for signals set to SIG_DFL where the default is to
734  * ignore. However, don't put SIGCONT in ps_sigignore, as we
735  * have to restart the process.
736  */
737  if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN ||
738  (sigprop(sig) & SA_IGNORE &&
739  ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL)) {
740  /* never to be seen again */
741  sigqueue_delete_proc(p, sig);
742  if (sig != SIGCONT)
743  /* easier in psignal */
744  SIGADDSET(ps->ps_sigignore, sig);
745  SIGDELSET(ps->ps_sigcatch, sig);
746  } else {
747  SIGDELSET(ps->ps_sigignore, sig);
748  if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL)
749  SIGDELSET(ps->ps_sigcatch, sig);
750  else
751  SIGADDSET(ps->ps_sigcatch, sig);
752  }
753 #ifdef COMPAT_FREEBSD4
754  if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN ||
755  ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL ||
756  (flags & KSA_FREEBSD4) == 0)
757  SIGDELSET(ps->ps_freebsd4, sig);
758  else
759  SIGADDSET(ps->ps_freebsd4, sig);
760 #endif
761 #ifdef COMPAT_43
762  if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN ||
763  ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL ||
764  (flags & KSA_OSIGSET) == 0)
765  SIGDELSET(ps->ps_osigset, sig);
766  else
767  SIGADDSET(ps->ps_osigset, sig);
768 #endif
769  }
770  mtx_unlock(&ps->ps_mtx);
771  PROC_UNLOCK(p);
772  return (0);
773 }
774 
775 #ifndef _SYS_SYSPROTO_H_
776 struct sigaction_args {
777  int sig;
778  struct sigaction *act;
779  struct sigaction *oact;
780 };
781 #endif
782 int
783 sys_sigaction(td, uap)
784  struct thread *td;
785  register struct sigaction_args *uap;
786 {
787  struct sigaction act, oact;
788  register struct sigaction *actp, *oactp;
789  int error;
790 
791  actp = (uap->act != NULL) ? &act : NULL;
792  oactp = (uap->oact != NULL) ? &oact : NULL;
793  if (actp) {
794  error = copyin(uap->act, actp, sizeof(act));
795  if (error)
796  return (error);
797  }
798  error = kern_sigaction(td, uap->sig, actp, oactp, 0);
799  if (oactp && !error)
800  error = copyout(oactp, uap->oact, sizeof(oact));
801  return (error);
802 }
803 
804 #ifdef COMPAT_FREEBSD4
805 #ifndef _SYS_SYSPROTO_H_
806 struct freebsd4_sigaction_args {
807  int sig;
808  struct sigaction *act;
809  struct sigaction *oact;
810 };
811 #endif
812 int
813 freebsd4_sigaction(td, uap)
814  struct thread *td;
815  register struct freebsd4_sigaction_args *uap;
816 {
817  struct sigaction act, oact;
818  register struct sigaction *actp, *oactp;
819  int error;
820 
821 
822  actp = (uap->act != NULL) ? &act : NULL;
823  oactp = (uap->oact != NULL) ? &oact : NULL;
824  if (actp) {
825  error = copyin(uap->act, actp, sizeof(act));
826  if (error)
827  return (error);
828  }
829  error = kern_sigaction(td, uap->sig, actp, oactp, KSA_FREEBSD4);
830  if (oactp && !error)
831  error = copyout(oactp, uap->oact, sizeof(oact));
832  return (error);
833 }
834 #endif /* COMPAT_FREEBSD4 */
835 
836 #ifdef COMPAT_43 /* XXX - COMPAT_FBSD3 */
837 #ifndef _SYS_SYSPROTO_H_
838 struct osigaction_args {
839  int signum;
840  struct osigaction *nsa;
841  struct osigaction *osa;
842 };
843 #endif
844 int
845 osigaction(td, uap)
846  struct thread *td;
847  register struct osigaction_args *uap;
848 {
849  struct osigaction sa;
850  struct sigaction nsa, osa;
851  register struct sigaction *nsap, *osap;
852  int error;
853 
854  if (uap->signum <= 0 || uap->signum >= ONSIG)
855  return (EINVAL);
856 
857  nsap = (uap->nsa != NULL) ? &nsa : NULL;
858  osap = (uap->osa != NULL) ? &osa : NULL;
859 
860  if (nsap) {
861  error = copyin(uap->nsa, &sa, sizeof(sa));
862  if (error)
863  return (error);
864  nsap->sa_handler = sa.sa_handler;
865  nsap->sa_flags = sa.sa_flags;
866  OSIG2SIG(sa.sa_mask, nsap->sa_mask);
867  }
868  error = kern_sigaction(td, uap->signum, nsap, osap, KSA_OSIGSET);
869  if (osap && !error) {
870  sa.sa_handler = osap->sa_handler;
871  sa.sa_flags = osap->sa_flags;
872  SIG2OSIG(osap->sa_mask, sa.sa_mask);
873  error = copyout(&sa, uap->osa, sizeof(sa));
874  }
875  return (error);
876 }
877 
878 #if !defined(__i386__)
879 /* Avoid replicating the same stub everywhere */
880 int
881 osigreturn(td, uap)
882  struct thread *td;
883  struct osigreturn_args *uap;
884 {
885 
886  return (nosys(td, (struct nosys_args *)uap));
887 }
888 #endif
889 #endif /* COMPAT_43 */
890 
891 /*
892  * Initialize signal state for process 0;
893  * set to ignore signals that are ignored by default.
894  */
895 void
896 siginit(p)
897  struct proc *p;
898 {
899  register int i;
900  struct sigacts *ps;
901 
902  PROC_LOCK(p);
903  ps = p->p_sigacts;
904  mtx_lock(&ps->ps_mtx);
905  for (i = 1; i <= NSIG; i++)
906  if (sigprop(i) & SA_IGNORE && i != SIGCONT)
907  SIGADDSET(ps->ps_sigignore, i);
908  mtx_unlock(&ps->ps_mtx);
909  PROC_UNLOCK(p);
910 }
911 
912 /*
913  * Reset signals for an exec of the specified process.
914  */
915 void
916 execsigs(struct proc *p)
917 {
918  struct sigacts *ps;
919  int sig;
920  struct thread *td;
921 
922  /*
923  * Reset caught signals. Held signals remain held
924  * through td_sigmask (unless they were caught,
925  * and are now ignored by default).
926  */
927  PROC_LOCK_ASSERT(p, MA_OWNED);
928  td = FIRST_THREAD_IN_PROC(p);
929  ps = p->p_sigacts;
930  mtx_lock(&ps->ps_mtx);
931  while (SIGNOTEMPTY(ps->ps_sigcatch)) {
932  sig = sig_ffs(&ps->ps_sigcatch);
933  SIGDELSET(ps->ps_sigcatch, sig);
934  if (sigprop(sig) & SA_IGNORE) {
935  if (sig != SIGCONT)
936  SIGADDSET(ps->ps_sigignore, sig);
937  sigqueue_delete_proc(p, sig);
938  }
939  ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL;
940  }
941  /*
942  * Reset stack state to the user stack.
943  * Clear set of signals caught on the signal stack.
944  */
945  td->td_sigstk.ss_flags = SS_DISABLE;
946  td->td_sigstk.ss_size = 0;
947  td->td_sigstk.ss_sp = 0;
948  td->td_pflags &= ~TDP_ALTSTACK;
949  /*
950  * Reset no zombies if child dies flag as Solaris does.
951  */
952  ps->ps_flag &= ~(PS_NOCLDWAIT | PS_CLDSIGIGN);
953  if (ps->ps_sigact[_SIG_IDX(SIGCHLD)] == SIG_IGN)
954  ps->ps_sigact[_SIG_IDX(SIGCHLD)] = SIG_DFL;
955  mtx_unlock(&ps->ps_mtx);
956 }
957 
958 /*
959  * kern_sigprocmask()
960  *
961  * Manipulate signal mask.
962  */
963 int
964 kern_sigprocmask(struct thread *td, int how, sigset_t *set, sigset_t *oset,
965  int flags)
966 {
967  sigset_t new_block, oset1;
968  struct proc *p;
969  int error;
970 
971  p = td->td_proc;
972  if (!(flags & SIGPROCMASK_PROC_LOCKED))
973  PROC_LOCK(p);
974  if (oset != NULL)
975  *oset = td->td_sigmask;
976 
977  error = 0;
978  if (set != NULL) {
979  switch (how) {
980  case SIG_BLOCK:
981  SIG_CANTMASK(*set);
982  oset1 = td->td_sigmask;
983  SIGSETOR(td->td_sigmask, *set);
984  new_block = td->td_sigmask;
985  SIGSETNAND(new_block, oset1);
986  break;
987  case SIG_UNBLOCK:
988  SIGSETNAND(td->td_sigmask, *set);
989  signotify(td);
990  goto out;
991  case SIG_SETMASK:
992  SIG_CANTMASK(*set);
993  oset1 = td->td_sigmask;
994  if (flags & SIGPROCMASK_OLD)
995  SIGSETLO(td->td_sigmask, *set);
996  else
997  td->td_sigmask = *set;
998  new_block = td->td_sigmask;
999  SIGSETNAND(new_block, oset1);
1000  signotify(td);
1001  break;
1002  default:
1003  error = EINVAL;
1004  goto out;
1005  }
1006 
1007  /*
1008  * The new_block set contains signals that were not previously
1009  * blocked, but are blocked now.
1010  *
1011  * In case we block any signal that was not previously blocked
1012  * for td, and process has the signal pending, try to schedule
1013  * signal delivery to some thread that does not block the
1014  * signal, possibly waking it up.
1015  */
1016  if (p->p_numthreads != 1)
1017  reschedule_signals(p, new_block, flags);
1018  }
1019 
1020 out:
1021  if (!(flags & SIGPROCMASK_PROC_LOCKED))
1022  PROC_UNLOCK(p);
1023  return (error);
1024 }
1025 
1026 #ifndef _SYS_SYSPROTO_H_
1027 struct sigprocmask_args {
1028  int how;
1029  const sigset_t *set;
1030  sigset_t *oset;
1031 };
1032 #endif
1033 int
1034 sys_sigprocmask(td, uap)
1035  register struct thread *td;
1036  struct sigprocmask_args *uap;
1037 {
1038  sigset_t set, oset;
1039  sigset_t *setp, *osetp;
1040  int error;
1041 
1042  setp = (uap->set != NULL) ? &set : NULL;
1043  osetp = (uap->oset != NULL) ? &oset : NULL;
1044  if (setp) {
1045  error = copyin(uap->set, setp, sizeof(set));
1046  if (error)
1047  return (error);
1048  }
1049  error = kern_sigprocmask(td, uap->how, setp, osetp, 0);
1050  if (osetp && !error) {
1051  error = copyout(osetp, uap->oset, sizeof(oset));
1052  }
1053  return (error);
1054 }
1055 
1056 #ifdef COMPAT_43 /* XXX - COMPAT_FBSD3 */
1057 #ifndef _SYS_SYSPROTO_H_
1058 struct osigprocmask_args {
1059  int how;
1060  osigset_t mask;
1061 };
1062 #endif
1063 int
1064 osigprocmask(td, uap)
1065  register struct thread *td;
1066  struct osigprocmask_args *uap;
1067 {
1068  sigset_t set, oset;
1069  int error;
1070 
1071  OSIG2SIG(uap->mask, set);
1072  error = kern_sigprocmask(td, uap->how, &set, &oset, 1);
1073  SIG2OSIG(oset, td->td_retval[0]);
1074  return (error);
1075 }
1076 #endif /* COMPAT_43 */
1077 
1078 int
1079 sys_sigwait(struct thread *td, struct sigwait_args *uap)
1080 {
1081  ksiginfo_t ksi;
1082  sigset_t set;
1083  int error;
1084 
1085  error = copyin(uap->set, &set, sizeof(set));
1086  if (error) {
1087  td->td_retval[0] = error;
1088  return (0);
1089  }
1090 
1091  error = kern_sigtimedwait(td, set, &ksi, NULL);
1092  if (error) {
1093  if (error == EINTR && td->td_proc->p_osrel < P_OSREL_SIGWAIT)
1094  error = ERESTART;
1095  if (error == ERESTART)
1096  return (error);
1097  td->td_retval[0] = error;
1098  return (0);
1099  }
1100 
1101  error = copyout(&ksi.ksi_signo, uap->sig, sizeof(ksi.ksi_signo));
1102  td->td_retval[0] = error;
1103  return (0);
1104 }
1105 
1106 int
1107 sys_sigtimedwait(struct thread *td, struct sigtimedwait_args *uap)
1108 {
1109  struct timespec ts;
1110  struct timespec *timeout;
1111  sigset_t set;
1112  ksiginfo_t ksi;
1113  int error;
1114 
1115  if (uap->timeout) {
1116  error = copyin(uap->timeout, &ts, sizeof(ts));
1117  if (error)
1118  return (error);
1119 
1120  timeout = &ts;
1121  } else
1122  timeout = NULL;
1123 
1124  error = copyin(uap->set, &set, sizeof(set));
1125  if (error)
1126  return (error);
1127 
1128  error = kern_sigtimedwait(td, set, &ksi, timeout);
1129  if (error)
1130  return (error);
1131 
1132  if (uap->info)
1133  error = copyout(&ksi.ksi_info, uap->info, sizeof(siginfo_t));
1134 
1135  if (error == 0)
1136  td->td_retval[0] = ksi.ksi_signo;
1137  return (error);
1138 }
1139 
1140 int
1141 sys_sigwaitinfo(struct thread *td, struct sigwaitinfo_args *uap)
1142 {
1143  ksiginfo_t ksi;
1144  sigset_t set;
1145  int error;
1146 
1147  error = copyin(uap->set, &set, sizeof(set));
1148  if (error)
1149  return (error);
1150 
1151  error = kern_sigtimedwait(td, set, &ksi, NULL);
1152  if (error)
1153  return (error);
1154 
1155  if (uap->info)
1156  error = copyout(&ksi.ksi_info, uap->info, sizeof(siginfo_t));
1157 
1158  if (error == 0)
1159  td->td_retval[0] = ksi.ksi_signo;
1160  return (error);
1161 }
1162 
1163 int
1164 kern_sigtimedwait(struct thread *td, sigset_t waitset, ksiginfo_t *ksi,
1165  struct timespec *timeout)
1166 {
1167  struct sigacts *ps;
1168  sigset_t saved_mask, new_block;
1169  struct proc *p;
1170  int error, sig, timo, timevalid = 0;
1171  struct timespec rts, ets, ts;
1172  struct timeval tv;
1173 
1174  p = td->td_proc;
1175  error = 0;
1176  ets.tv_sec = 0;
1177  ets.tv_nsec = 0;
1178 
1179  if (timeout != NULL) {
1180  if (timeout->tv_nsec >= 0 && timeout->tv_nsec < 1000000000) {
1181  timevalid = 1;
1182  getnanouptime(&rts);
1183  ets = rts;
1184  timespecadd(&ets, timeout);
1185  }
1186  }
1187  ksiginfo_init(ksi);
1188  /* Some signals can not be waited for. */
1189  SIG_CANTMASK(waitset);
1190  ps = p->p_sigacts;
1191  PROC_LOCK(p);
1192  saved_mask = td->td_sigmask;
1193  SIGSETNAND(td->td_sigmask, waitset);
1194  for (;;) {
1195  mtx_lock(&ps->ps_mtx);
1196  sig = cursig(td, SIG_STOP_ALLOWED);
1197  mtx_unlock(&ps->ps_mtx);
1198  if (sig != 0 && SIGISMEMBER(waitset, sig)) {
1199  if (sigqueue_get(&td->td_sigqueue, sig, ksi) != 0 ||
1200  sigqueue_get(&p->p_sigqueue, sig, ksi) != 0) {
1201  error = 0;
1202  break;
1203  }
1204  }
1205 
1206  if (error != 0)
1207  break;
1208 
1209  /*
1210  * POSIX says this must be checked after looking for pending
1211  * signals.
1212  */
1213  if (timeout != NULL) {
1214  if (!timevalid) {
1215  error = EINVAL;
1216  break;
1217  }
1218  getnanouptime(&rts);
1219  if (timespeccmp(&rts, &ets, >=)) {
1220  error = EAGAIN;
1221  break;
1222  }
1223  ts = ets;
1224  timespecsub(&ts, &rts);
1225  TIMESPEC_TO_TIMEVAL(&tv, &ts);
1226  timo = tvtohz(&tv);
1227  } else {
1228  timo = 0;
1229  }
1230 
1231  error = msleep(ps, &p->p_mtx, PPAUSE|PCATCH, "sigwait", timo);
1232 
1233  if (timeout != NULL) {
1234  if (error == ERESTART) {
1235  /* Timeout can not be restarted. */
1236  error = EINTR;
1237  } else if (error == EAGAIN) {
1238  /* We will calculate timeout by ourself. */
1239  error = 0;
1240  }
1241  }
1242  }
1243 
1244  new_block = saved_mask;
1245  SIGSETNAND(new_block, td->td_sigmask);
1246  td->td_sigmask = saved_mask;
1247  /*
1248  * Fewer signals can be delivered to us, reschedule signal
1249  * notification.
1250  */
1251  if (p->p_numthreads != 1)
1252  reschedule_signals(p, new_block, 0);
1253 
1254  if (error == 0) {
1255  SDT_PROBE2(proc, kernel, , signal__clear, sig, ksi);
1256 
1257  if (ksi->ksi_code == SI_TIMER)
1258  itimer_accept(p, ksi->ksi_timerid, ksi);
1259 
1260 #ifdef KTRACE
1261  if (KTRPOINT(td, KTR_PSIG)) {
1262  sig_t action;
1263 
1264  mtx_lock(&ps->ps_mtx);
1265  action = ps->ps_sigact[_SIG_IDX(sig)];
1266  mtx_unlock(&ps->ps_mtx);
1267  ktrpsig(sig, action, &td->td_sigmask, ksi->ksi_code);
1268  }
1269 #endif
1270  if (sig == SIGKILL)
1271  sigexit(td, sig);
1272  }
1273  PROC_UNLOCK(p);
1274  return (error);
1275 }
1276 
1277 #ifndef _SYS_SYSPROTO_H_
1278 struct sigpending_args {
1279  sigset_t *set;
1280 };
1281 #endif
1282 int
1283 sys_sigpending(td, uap)
1284  struct thread *td;
1285  struct sigpending_args *uap;
1286 {
1287  struct proc *p = td->td_proc;
1288  sigset_t pending;
1289 
1290  PROC_LOCK(p);
1291  pending = p->p_sigqueue.sq_signals;
1292  SIGSETOR(pending, td->td_sigqueue.sq_signals);
1293  PROC_UNLOCK(p);
1294  return (copyout(&pending, uap->set, sizeof(sigset_t)));
1295 }
1296 
1297 #ifdef COMPAT_43 /* XXX - COMPAT_FBSD3 */
1298 #ifndef _SYS_SYSPROTO_H_
1299 struct osigpending_args {
1300  int dummy;
1301 };
1302 #endif
1303 int
1304 osigpending(td, uap)
1305  struct thread *td;
1306  struct osigpending_args *uap;
1307 {
1308  struct proc *p = td->td_proc;
1309  sigset_t pending;
1310 
1311  PROC_LOCK(p);
1312  pending = p->p_sigqueue.sq_signals;
1313  SIGSETOR(pending, td->td_sigqueue.sq_signals);
1314  PROC_UNLOCK(p);
1315  SIG2OSIG(pending, td->td_retval[0]);
1316  return (0);
1317 }
1318 #endif /* COMPAT_43 */
1319 
1320 #if defined(COMPAT_43)
1321 /*
1322  * Generalized interface signal handler, 4.3-compatible.
1323  */
1324 #ifndef _SYS_SYSPROTO_H_
1325 struct osigvec_args {
1326  int signum;
1327  struct sigvec *nsv;
1328  struct sigvec *osv;
1329 };
1330 #endif
1331 /* ARGSUSED */
1332 int
1333 osigvec(td, uap)
1334  struct thread *td;
1335  register struct osigvec_args *uap;
1336 {
1337  struct sigvec vec;
1338  struct sigaction nsa, osa;
1339  register struct sigaction *nsap, *osap;
1340  int error;
1341 
1342  if (uap->signum <= 0 || uap->signum >= ONSIG)
1343  return (EINVAL);
1344  nsap = (uap->nsv != NULL) ? &nsa : NULL;
1345  osap = (uap->osv != NULL) ? &osa : NULL;
1346  if (nsap) {
1347  error = copyin(uap->nsv, &vec, sizeof(vec));
1348  if (error)
1349  return (error);
1350  nsap->sa_handler = vec.sv_handler;
1351  OSIG2SIG(vec.sv_mask, nsap->sa_mask);
1352  nsap->sa_flags = vec.sv_flags;
1353  nsap->sa_flags ^= SA_RESTART; /* opposite of SV_INTERRUPT */
1354  }
1355  error = kern_sigaction(td, uap->signum, nsap, osap, KSA_OSIGSET);
1356  if (osap && !error) {
1357  vec.sv_handler = osap->sa_handler;
1358  SIG2OSIG(osap->sa_mask, vec.sv_mask);
1359  vec.sv_flags = osap->sa_flags;
1360  vec.sv_flags &= ~SA_NOCLDWAIT;
1361  vec.sv_flags ^= SA_RESTART;
1362  error = copyout(&vec, uap->osv, sizeof(vec));
1363  }
1364  return (error);
1365 }
1366 
1367 #ifndef _SYS_SYSPROTO_H_
1368 struct osigblock_args {
1369  int mask;
1370 };
1371 #endif
1372 int
1373 osigblock(td, uap)
1374  register struct thread *td;
1375  struct osigblock_args *uap;
1376 {
1377  sigset_t set, oset;
1378 
1379  OSIG2SIG(uap->mask, set);
1380  kern_sigprocmask(td, SIG_BLOCK, &set, &oset, 0);
1381  SIG2OSIG(oset, td->td_retval[0]);
1382  return (0);
1383 }
1384 
1385 #ifndef _SYS_SYSPROTO_H_
1386 struct osigsetmask_args {
1387  int mask;
1388 };
1389 #endif
1390 int
1391 osigsetmask(td, uap)
1392  struct thread *td;
1393  struct osigsetmask_args *uap;
1394 {
1395  sigset_t set, oset;
1396 
1397  OSIG2SIG(uap->mask, set);
1398  kern_sigprocmask(td, SIG_SETMASK, &set, &oset, 0);
1399  SIG2OSIG(oset, td->td_retval[0]);
1400  return (0);
1401 }
1402 #endif /* COMPAT_43 */
1403 
1404 /*
1405  * Suspend calling thread until signal, providing mask to be set in the
1406  * meantime.
1407  */
1408 #ifndef _SYS_SYSPROTO_H_
1409 struct sigsuspend_args {
1410  const sigset_t *sigmask;
1411 };
1412 #endif
1413 /* ARGSUSED */
1414 int
1415 sys_sigsuspend(td, uap)
1416  struct thread *td;
1417  struct sigsuspend_args *uap;
1418 {
1419  sigset_t mask;
1420  int error;
1421 
1422  error = copyin(uap->sigmask, &mask, sizeof(mask));
1423  if (error)
1424  return (error);
1425  return (kern_sigsuspend(td, mask));
1426 }
1427 
1428 int
1429 kern_sigsuspend(struct thread *td, sigset_t mask)
1430 {
1431  struct proc *p = td->td_proc;
1432  int has_sig, sig;
1433 
1434  /*
1435  * When returning from sigsuspend, we want
1436  * the old mask to be restored after the
1437  * signal handler has finished. Thus, we
1438  * save it here and mark the sigacts structure
1439  * to indicate this.
1440  */
1441  PROC_LOCK(p);
1442  kern_sigprocmask(td, SIG_SETMASK, &mask, &td->td_oldsigmask,
1443  SIGPROCMASK_PROC_LOCKED);
1444  td->td_pflags |= TDP_OLDMASK;
1445 
1446  /*
1447  * Process signals now. Otherwise, we can get spurious wakeup
1448  * due to signal entered process queue, but delivered to other
1449  * thread. But sigsuspend should return only on signal
1450  * delivery.
1451  */
1452  (p->p_sysent->sv_set_syscall_retval)(td, EINTR);
1453  for (has_sig = 0; !has_sig;) {
1454  while (msleep(&p->p_sigacts, &p->p_mtx, PPAUSE|PCATCH, "pause",
1455  0) == 0)
1456  /* void */;
1457  thread_suspend_check(0);
1458  mtx_lock(&p->p_sigacts->ps_mtx);
1459  while ((sig = cursig(td, SIG_STOP_ALLOWED)) != 0)
1460  has_sig += postsig(sig);
1461  mtx_unlock(&p->p_sigacts->ps_mtx);
1462  }
1463  PROC_UNLOCK(p);
1464  td->td_errno = EINTR;
1465  td->td_pflags |= TDP_NERRNO;
1466  return (EJUSTRETURN);
1467 }
1468 
1469 #ifdef COMPAT_43 /* XXX - COMPAT_FBSD3 */
1470 /*
1471  * Compatibility sigsuspend call for old binaries. Note nonstandard calling
1472  * convention: libc stub passes mask, not pointer, to save a copyin.
1473  */
1474 #ifndef _SYS_SYSPROTO_H_
1475 struct osigsuspend_args {
1476  osigset_t mask;
1477 };
1478 #endif
1479 /* ARGSUSED */
1480 int
1481 osigsuspend(td, uap)
1482  struct thread *td;
1483  struct osigsuspend_args *uap;
1484 {
1485  sigset_t mask;
1486 
1487  OSIG2SIG(uap->mask, mask);
1488  return (kern_sigsuspend(td, mask));
1489 }
1490 #endif /* COMPAT_43 */
1491 
1492 #if defined(COMPAT_43)
1493 #ifndef _SYS_SYSPROTO_H_
1494 struct osigstack_args {
1495  struct sigstack *nss;
1496  struct sigstack *oss;
1497 };
1498 #endif
1499 /* ARGSUSED */
1500 int
1501 osigstack(td, uap)
1502  struct thread *td;
1503  register struct osigstack_args *uap;
1504 {
1505  struct sigstack nss, oss;
1506  int error = 0;
1507 
1508  if (uap->nss != NULL) {
1509  error = copyin(uap->nss, &nss, sizeof(nss));
1510  if (error)
1511  return (error);
1512  }
1513  oss.ss_sp = td->td_sigstk.ss_sp;
1514  oss.ss_onstack = sigonstack(cpu_getstack(td));
1515  if (uap->nss != NULL) {
1516  td->td_sigstk.ss_sp = nss.ss_sp;
1517  td->td_sigstk.ss_size = 0;
1518  td->td_sigstk.ss_flags |= nss.ss_onstack & SS_ONSTACK;
1519  td->td_pflags |= TDP_ALTSTACK;
1520  }
1521  if (uap->oss != NULL)
1522  error = copyout(&oss, uap->oss, sizeof(oss));
1523 
1524  return (error);
1525 }
1526 #endif /* COMPAT_43 */
1527 
1528 #ifndef _SYS_SYSPROTO_H_
1529 struct sigaltstack_args {
1530  stack_t *ss;
1531  stack_t *oss;
1532 };
1533 #endif
1534 /* ARGSUSED */
1535 int
1536 sys_sigaltstack(td, uap)
1537  struct thread *td;
1538  register struct sigaltstack_args *uap;
1539 {
1540  stack_t ss, oss;
1541  int error;
1542 
1543  if (uap->ss != NULL) {
1544  error = copyin(uap->ss, &ss, sizeof(ss));
1545  if (error)
1546  return (error);
1547  }
1548  error = kern_sigaltstack(td, (uap->ss != NULL) ? &ss : NULL,
1549  (uap->oss != NULL) ? &oss : NULL);
1550  if (error)
1551  return (error);
1552  if (uap->oss != NULL)
1553  error = copyout(&oss, uap->oss, sizeof(stack_t));
1554  return (error);
1555 }
1556 
1557 int
1558 kern_sigaltstack(struct thread *td, stack_t *ss, stack_t *oss)
1559 {
1560  struct proc *p = td->td_proc;
1561  int oonstack;
1562 
1563  oonstack = sigonstack(cpu_getstack(td));
1564 
1565  if (oss != NULL) {
1566  *oss = td->td_sigstk;
1567  oss->ss_flags = (td->td_pflags & TDP_ALTSTACK)
1568  ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE;
1569  }
1570 
1571  if (ss != NULL) {
1572  if (oonstack)
1573  return (EPERM);
1574  if ((ss->ss_flags & ~SS_DISABLE) != 0)
1575  return (EINVAL);
1576  if (!(ss->ss_flags & SS_DISABLE)) {
1577  if (ss->ss_size < p->p_sysent->sv_minsigstksz)
1578  return (ENOMEM);
1579 
1580  td->td_sigstk = *ss;
1581  td->td_pflags |= TDP_ALTSTACK;
1582  } else {
1583  td->td_pflags &= ~TDP_ALTSTACK;
1584  }
1585  }
1586  return (0);
1587 }
1588 
1589 /*
1590  * Common code for kill process group/broadcast kill.
1591  * cp is calling process.
1592  */
1593 static int
1594 killpg1(struct thread *td, int sig, int pgid, int all, ksiginfo_t *ksi)
1595 {
1596  struct proc *p;
1597  struct pgrp *pgrp;
1598  int err;
1599  int ret;
1600 
1601  ret = ESRCH;
1602  if (all) {
1603  /*
1604  * broadcast
1605  */
1606  sx_slock(&allproc_lock);
1607  FOREACH_PROC_IN_SYSTEM(p) {
1608  PROC_LOCK(p);
1609  if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
1610  p == td->td_proc || p->p_state == PRS_NEW) {
1611  PROC_UNLOCK(p);
1612  continue;
1613  }
1614  err = p_cansignal(td, p, sig);
1615  if (err == 0) {
1616  if (sig)
1617  pksignal(p, sig, ksi);
1618  ret = err;
1619  }
1620  else if (ret == ESRCH)
1621  ret = err;
1622  PROC_UNLOCK(p);
1623  }
1624  sx_sunlock(&allproc_lock);
1625  } else {
1626  sx_slock(&proctree_lock);
1627  if (pgid == 0) {
1628  /*
1629  * zero pgid means send to my process group.
1630  */
1631  pgrp = td->td_proc->p_pgrp;
1632  PGRP_LOCK(pgrp);
1633  } else {
1634  pgrp = pgfind(pgid);
1635  if (pgrp == NULL) {
1636  sx_sunlock(&proctree_lock);
1637  return (ESRCH);
1638  }
1639  }
1640  sx_sunlock(&proctree_lock);
1641  LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
1642  PROC_LOCK(p);
1643  if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
1644  p->p_state == PRS_NEW) {
1645  PROC_UNLOCK(p);
1646  continue;
1647  }
1648  err = p_cansignal(td, p, sig);
1649  if (err == 0) {
1650  if (sig)
1651  pksignal(p, sig, ksi);
1652  ret = err;
1653  }
1654  else if (ret == ESRCH)
1655  ret = err;
1656  PROC_UNLOCK(p);
1657  }
1658  PGRP_UNLOCK(pgrp);
1659  }
1660  return (ret);
1661 }
1662 
1663 #ifndef _SYS_SYSPROTO_H_
1664 struct kill_args {
1665  int pid;
1666  int signum;
1667 };
1668 #endif
1669 /* ARGSUSED */
1670 int
1671 sys_kill(struct thread *td, struct kill_args *uap)
1672 {
1673  ksiginfo_t ksi;
1674  struct proc *p;
1675  int error;
1676 
1677  AUDIT_ARG_SIGNUM(uap->signum);
1678  AUDIT_ARG_PID(uap->pid);
1679  if ((u_int)uap->signum > _SIG_MAXSIG)
1680  return (EINVAL);
1681 
1682  ksiginfo_init(&ksi);
1683  ksi.ksi_signo = uap->signum;
1684  ksi.ksi_code = SI_USER;
1685  ksi.ksi_pid = td->td_proc->p_pid;
1686  ksi.ksi_uid = td->td_ucred->cr_ruid;
1687 
1688  if (uap->pid > 0) {
1689  /* kill single process */
1690  if ((p = pfind(uap->pid)) == NULL) {
1691  if ((p = zpfind(uap->pid)) == NULL)
1692  return (ESRCH);
1693  }
1694  AUDIT_ARG_PROCESS(p);
1695  error = p_cansignal(td, p, uap->signum);
1696  if (error == 0 && uap->signum)
1697  pksignal(p, uap->signum, &ksi);
1698  PROC_UNLOCK(p);
1699  return (error);
1700  }
1701  switch (uap->pid) {
1702  case -1: /* broadcast signal */
1703  return (killpg1(td, uap->signum, 0, 1, &ksi));
1704  case 0: /* signal own process group */
1705  return (killpg1(td, uap->signum, 0, 0, &ksi));
1706  default: /* negative explicit process group */
1707  return (killpg1(td, uap->signum, -uap->pid, 0, &ksi));
1708  }
1709  /* NOTREACHED */
1710 }
1711 
1712 int
1713 sys_pdkill(td, uap)
1714  struct thread *td;
1715  struct pdkill_args *uap;
1716 {
1717 #ifdef PROCDESC
1718  struct proc *p;
1719  int error;
1720 
1721  AUDIT_ARG_SIGNUM(uap->signum);
1722  AUDIT_ARG_FD(uap->fd);
1723  if ((u_int)uap->signum > _SIG_MAXSIG)
1724  return (EINVAL);
1725 
1726  error = procdesc_find(td, uap->fd, CAP_PDKILL, &p);
1727  if (error)
1728  return (error);
1729  AUDIT_ARG_PROCESS(p);
1730  error = p_cansignal(td, p, uap->signum);
1731  if (error == 0 && uap->signum)
1732  kern_psignal(p, uap->signum);
1733  PROC_UNLOCK(p);
1734  return (error);
1735 #else
1736  return (ENOSYS);
1737 #endif
1738 }
1739 
1740 #if defined(COMPAT_43)
1741 #ifndef _SYS_SYSPROTO_H_
1742 struct okillpg_args {
1743  int pgid;
1744  int signum;
1745 };
1746 #endif
1747 /* ARGSUSED */
1748 int
1749 okillpg(struct thread *td, struct okillpg_args *uap)
1750 {
1751  ksiginfo_t ksi;
1752 
1753  AUDIT_ARG_SIGNUM(uap->signum);
1754  AUDIT_ARG_PID(uap->pgid);
1755  if ((u_int)uap->signum > _SIG_MAXSIG)
1756  return (EINVAL);
1757 
1758  ksiginfo_init(&ksi);
1759  ksi.ksi_signo = uap->signum;
1760  ksi.ksi_code = SI_USER;
1761  ksi.ksi_pid = td->td_proc->p_pid;
1762  ksi.ksi_uid = td->td_ucred->cr_ruid;
1763  return (killpg1(td, uap->signum, uap->pgid, 0, &ksi));
1764 }
1765 #endif /* COMPAT_43 */
1766 
1767 #ifndef _SYS_SYSPROTO_H_
1768 struct sigqueue_args {
1769  pid_t pid;
1770  int signum;
1771  /* union sigval */ void *value;
1772 };
1773 #endif
1774 int
1775 sys_sigqueue(struct thread *td, struct sigqueue_args *uap)
1776 {
1777  ksiginfo_t ksi;
1778  struct proc *p;
1779  int error;
1780 
1781  if ((u_int)uap->signum > _SIG_MAXSIG)
1782  return (EINVAL);
1783 
1784  /*
1785  * Specification says sigqueue can only send signal to
1786  * single process.
1787  */
1788  if (uap->pid <= 0)
1789  return (EINVAL);
1790 
1791  if ((p = pfind(uap->pid)) == NULL) {
1792  if ((p = zpfind(uap->pid)) == NULL)
1793  return (ESRCH);
1794  }
1795  error = p_cansignal(td, p, uap->signum);
1796  if (error == 0 && uap->signum != 0) {
1797  ksiginfo_init(&ksi);
1798  ksi.ksi_flags = KSI_SIGQ;
1799  ksi.ksi_signo = uap->signum;
1800  ksi.ksi_code = SI_QUEUE;
1801  ksi.ksi_pid = td->td_proc->p_pid;
1802  ksi.ksi_uid = td->td_ucred->cr_ruid;
1803  ksi.ksi_value.sival_ptr = uap->value;
1804  error = pksignal(p, ksi.ksi_signo, &ksi);
1805  }
1806  PROC_UNLOCK(p);
1807  return (error);
1808 }
1809 
1810 /*
1811  * Send a signal to a process group.
1812  */
1813 void
1814 gsignal(int pgid, int sig, ksiginfo_t *ksi)
1815 {
1816  struct pgrp *pgrp;
1817 
1818  if (pgid != 0) {
1819  sx_slock(&proctree_lock);
1820  pgrp = pgfind(pgid);
1821  sx_sunlock(&proctree_lock);
1822  if (pgrp != NULL) {
1823  pgsignal(pgrp, sig, 0, ksi);
1824  PGRP_UNLOCK(pgrp);
1825  }
1826  }
1827 }
1828 
1829 /*
1830  * Send a signal to a process group. If checktty is 1,
1831  * limit to members which have a controlling terminal.
1832  */
1833 void
1834 pgsignal(struct pgrp *pgrp, int sig, int checkctty, ksiginfo_t *ksi)
1835 {
1836  struct proc *p;
1837 
1838  if (pgrp) {
1839  PGRP_LOCK_ASSERT(pgrp, MA_OWNED);
1840  LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
1841  PROC_LOCK(p);
1842  if (p->p_state == PRS_NORMAL &&
1843  (checkctty == 0 || p->p_flag & P_CONTROLT))
1844  pksignal(p, sig, ksi);
1845  PROC_UNLOCK(p);
1846  }
1847  }
1848 }
1849 
1850 
1851 /*
1852  * Recalculate the signal mask and reset the signal disposition after
1853  * usermode frame for delivery is formed. Should be called after
1854  * mach-specific routine, because sysent->sv_sendsig() needs correct
1855  * ps_siginfo and signal mask.
1856  */
1857 static void
1858 postsig_done(int sig, struct thread *td, struct sigacts *ps)
1859 {
1860  sigset_t mask;
1861 
1862  mtx_assert(&ps->ps_mtx, MA_OWNED);
1863  td->td_ru.ru_nsignals++;
1864  mask = ps->ps_catchmask[_SIG_IDX(sig)];
1865  if (!SIGISMEMBER(ps->ps_signodefer, sig))
1866  SIGADDSET(mask, sig);
1867  kern_sigprocmask(td, SIG_BLOCK, &mask, NULL,
1868  SIGPROCMASK_PROC_LOCKED | SIGPROCMASK_PS_LOCKED);
1869  if (SIGISMEMBER(ps->ps_sigreset, sig)) {
1870  SIGDELSET(ps->ps_sigcatch, sig);
1871  if (sig != SIGCONT &&
1872  sigprop(sig) & SA_IGNORE)
1873  SIGADDSET(ps->ps_sigignore, sig);
1874  ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL;
1875  }
1876 }
1877 
1878 /*
1879  * Send a signal caused by a trap to the current thread. If it will be
1880  * caught immediately, deliver it with correct code. Otherwise, post it
1881  * normally.
1882  */
1883 void
1884 trapsignal(struct thread *td, ksiginfo_t *ksi)
1885 {
1886  struct sigacts *ps;
1887  struct proc *p;
1888  int sig;
1889  int code;
1890 
1891  p = td->td_proc;
1892  sig = ksi->ksi_signo;
1893  code = ksi->ksi_code;
1894  KASSERT(_SIG_VALID(sig), ("invalid signal"));
1895 
1896  PROC_LOCK(p);
1897  ps = p->p_sigacts;
1898  mtx_lock(&ps->ps_mtx);
1899  if ((p->p_flag & P_TRACED) == 0 && SIGISMEMBER(ps->ps_sigcatch, sig) &&
1900  !SIGISMEMBER(td->td_sigmask, sig)) {
1901 #ifdef KTRACE
1902  if (KTRPOINT(curthread, KTR_PSIG))
1903  ktrpsig(sig, ps->ps_sigact[_SIG_IDX(sig)],
1904  &td->td_sigmask, code);
1905 #endif
1906  (*p->p_sysent->sv_sendsig)(ps->ps_sigact[_SIG_IDX(sig)],
1907  ksi, &td->td_sigmask);
1908  postsig_done(sig, td, ps);
1909  mtx_unlock(&ps->ps_mtx);
1910  } else {
1911  /*
1912  * Avoid a possible infinite loop if the thread
1913  * masking the signal or process is ignoring the
1914  * signal.
1915  */
1916  if (kern_forcesigexit &&
1917  (SIGISMEMBER(td->td_sigmask, sig) ||
1918  ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN)) {
1919  SIGDELSET(td->td_sigmask, sig);
1920  SIGDELSET(ps->ps_sigcatch, sig);
1921  SIGDELSET(ps->ps_sigignore, sig);
1922  ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL;
1923  }
1924  mtx_unlock(&ps->ps_mtx);
1925  p->p_code = code; /* XXX for core dump/debugger */
1926  p->p_sig = sig; /* XXX to verify code */
1927  tdsendsignal(p, td, sig, ksi);
1928  }
1929  PROC_UNLOCK(p);
1930 }
1931 
1932 static struct thread *
1933 sigtd(struct proc *p, int sig, int prop)
1934 {
1935  struct thread *td, *signal_td;
1936 
1937  PROC_LOCK_ASSERT(p, MA_OWNED);
1938 
1939  /*
1940  * Check if current thread can handle the signal without
1941  * switching context to another thread.
1942  */
1943  if (curproc == p && !SIGISMEMBER(curthread->td_sigmask, sig))
1944  return (curthread);
1945  signal_td = NULL;
1946  FOREACH_THREAD_IN_PROC(p, td) {
1947  if (!SIGISMEMBER(td->td_sigmask, sig)) {
1948  signal_td = td;
1949  break;
1950  }
1951  }
1952  if (signal_td == NULL)
1953  signal_td = FIRST_THREAD_IN_PROC(p);
1954  return (signal_td);
1955 }
1956 
1957 /*
1958  * Send the signal to the process. If the signal has an action, the action
1959  * is usually performed by the target process rather than the caller; we add
1960  * the signal to the set of pending signals for the process.
1961  *
1962  * Exceptions:
1963  * o When a stop signal is sent to a sleeping process that takes the
1964  * default action, the process is stopped without awakening it.
1965  * o SIGCONT restarts stopped processes (or puts them back to sleep)
1966  * regardless of the signal action (eg, blocked or ignored).
1967  *
1968  * Other ignored signals are discarded immediately.
1969  *
1970  * NB: This function may be entered from the debugger via the "kill" DDB
1971  * command. There is little that can be done to mitigate the possibly messy
1972  * side effects of this unwise possibility.
1973  */
1974 void
1975 kern_psignal(struct proc *p, int sig)
1976 {
1977  ksiginfo_t ksi;
1978 
1979  ksiginfo_init(&ksi);
1980  ksi.ksi_signo = sig;
1981  ksi.ksi_code = SI_KERNEL;
1982  (void) tdsendsignal(p, NULL, sig, &ksi);
1983 }
1984 
1985 int
1986 pksignal(struct proc *p, int sig, ksiginfo_t *ksi)
1987 {
1988 
1989  return (tdsendsignal(p, NULL, sig, ksi));
1990 }
1991 
1992 /* Utility function for finding a thread to send signal event to. */
1993 int
1994 sigev_findtd(struct proc *p ,struct sigevent *sigev, struct thread **ttd)
1995 {
1996  struct thread *td;
1997 
1998  if (sigev->sigev_notify == SIGEV_THREAD_ID) {
1999  td = tdfind(sigev->sigev_notify_thread_id, p->p_pid);
2000  if (td == NULL)
2001  return (ESRCH);
2002  *ttd = td;
2003  } else {
2004  *ttd = NULL;
2005  PROC_LOCK(p);
2006  }
2007  return (0);
2008 }
2009 
2010 void
2011 tdsignal(struct thread *td, int sig)
2012 {
2013  ksiginfo_t ksi;
2014 
2015  ksiginfo_init(&ksi);
2016  ksi.ksi_signo = sig;
2017  ksi.ksi_code = SI_KERNEL;
2018  (void) tdsendsignal(td->td_proc, td, sig, &ksi);
2019 }
2020 
2021 void
2022 tdksignal(struct thread *td, int sig, ksiginfo_t *ksi)
2023 {
2024 
2025  (void) tdsendsignal(td->td_proc, td, sig, ksi);
2026 }
2027 
2028 int
2029 tdsendsignal(struct proc *p, struct thread *td, int sig, ksiginfo_t *ksi)
2030 {
2031  sig_t action;
2032  sigqueue_t *sigqueue;
2033  int prop;
2034  struct sigacts *ps;
2035  int intrval;
2036  int ret = 0;
2037  int wakeup_swapper;
2038 
2039  MPASS(td == NULL || p == td->td_proc);
2040  PROC_LOCK_ASSERT(p, MA_OWNED);
2041 
2042  if (!_SIG_VALID(sig))
2043  panic("%s(): invalid signal %d", __func__, sig);
2044 
2045  KASSERT(ksi == NULL || !KSI_ONQ(ksi), ("%s: ksi on queue", __func__));
2046 
2047  /*
2048  * IEEE Std 1003.1-2001: return success when killing a zombie.
2049  */
2050  if (p->p_state == PRS_ZOMBIE) {
2051  if (ksi && (ksi->ksi_flags & KSI_INS))
2052  ksiginfo_tryfree(ksi);
2053  return (ret);
2054  }
2055 
2056  ps = p->p_sigacts;
2057  KNOTE_LOCKED(&p->p_klist, NOTE_SIGNAL | sig);
2058  prop = sigprop(sig);
2059 
2060  if (td == NULL) {
2061  td = sigtd(p, sig, prop);
2062  sigqueue = &p->p_sigqueue;
2063  } else {
2064  KASSERT(td->td_proc == p, ("invalid thread"));
2065  sigqueue = &td->td_sigqueue;
2066  }
2067 
2068  SDT_PROBE3(proc, kernel, , signal__send, td, p, sig);
2069 
2070  /*
2071  * If the signal is being ignored,
2072  * then we forget about it immediately.
2073  * (Note: we don't set SIGCONT in ps_sigignore,
2074  * and if it is set to SIG_IGN,
2075  * action will be SIG_DFL here.)
2076  */
2077  mtx_lock(&ps->ps_mtx);
2078  if (SIGISMEMBER(ps->ps_sigignore, sig)) {
2079  SDT_PROBE3(proc, kernel, , signal__discard, td, p, sig);
2080 
2081  mtx_unlock(&ps->ps_mtx);
2082  if (ksi && (ksi->ksi_flags & KSI_INS))
2083  ksiginfo_tryfree(ksi);
2084  return (ret);
2085  }
2086  if (SIGISMEMBER(td->td_sigmask, sig))
2087  action = SIG_HOLD;
2088  else if (SIGISMEMBER(ps->ps_sigcatch, sig))
2089  action = SIG_CATCH;
2090  else
2091  action = SIG_DFL;
2092  if (SIGISMEMBER(ps->ps_sigintr, sig))
2093  intrval = EINTR;
2094  else
2095  intrval = ERESTART;
2096  mtx_unlock(&ps->ps_mtx);
2097 
2098  if (prop & SA_CONT)
2099  sigqueue_delete_stopmask_proc(p);
2100  else if (prop & SA_STOP) {
2101  /*
2102  * If sending a tty stop signal to a member of an orphaned
2103  * process group, discard the signal here if the action
2104  * is default; don't stop the process below if sleeping,
2105  * and don't clear any pending SIGCONT.
2106  */
2107  if ((prop & SA_TTYSTOP) &&
2108  (p->p_pgrp->pg_jobc == 0) &&
2109  (action == SIG_DFL)) {
2110  if (ksi && (ksi->ksi_flags & KSI_INS))
2111  ksiginfo_tryfree(ksi);
2112  return (ret);
2113  }
2114  sigqueue_delete_proc(p, SIGCONT);
2115  if (p->p_flag & P_CONTINUED) {
2116  p->p_flag &= ~P_CONTINUED;
2117  PROC_LOCK(p->p_pptr);
2118  sigqueue_take(p->p_ksi);
2119  PROC_UNLOCK(p->p_pptr);
2120  }
2121  }
2122 
2123  ret = sigqueue_add(sigqueue, sig, ksi);
2124  if (ret != 0)
2125  return (ret);
2126  signotify(td);
2127  /*
2128  * Defer further processing for signals which are held,
2129  * except that stopped processes must be continued by SIGCONT.
2130  */
2131  if (action == SIG_HOLD &&
2132  !((prop & SA_CONT) && (p->p_flag & P_STOPPED_SIG)))
2133  return (ret);
2134  /*
2135  * SIGKILL: Remove procfs STOPEVENTs.
2136  */
2137  if (sig == SIGKILL) {
2138  /* from procfs_ioctl.c: PIOCBIC */
2139  p->p_stops = 0;
2140  /* from procfs_ioctl.c: PIOCCONT */
2141  p->p_step = 0;
2142  wakeup(&p->p_step);
2143  }
2144  /*
2145  * Some signals have a process-wide effect and a per-thread
2146  * component. Most processing occurs when the process next
2147  * tries to cross the user boundary, however there are some
2148  * times when processing needs to be done immediatly, such as
2149  * waking up threads so that they can cross the user boundary.
2150  * We try do the per-process part here.
2151  */
2152  if (P_SHOULDSTOP(p)) {
2153  KASSERT(!(p->p_flag & P_WEXIT),
2154  ("signal to stopped but exiting process"));
2155  if (sig == SIGKILL) {
2156  /*
2157  * If traced process is already stopped,
2158  * then no further action is necessary.
2159  */
2160  if (p->p_flag & P_TRACED)
2161  goto out;
2162  /*
2163  * SIGKILL sets process running.
2164  * It will die elsewhere.
2165  * All threads must be restarted.
2166  */
2167  p->p_flag &= ~P_STOPPED_SIG;
2168  goto runfast;
2169  }
2170 
2171  if (prop & SA_CONT) {
2172  /*
2173  * If traced process is already stopped,
2174  * then no further action is necessary.
2175  */
2176  if (p->p_flag & P_TRACED)
2177  goto out;
2178  /*
2179  * If SIGCONT is default (or ignored), we continue the
2180  * process but don't leave the signal in sigqueue as
2181  * it has no further action. If SIGCONT is held, we
2182  * continue the process and leave the signal in
2183  * sigqueue. If the process catches SIGCONT, let it
2184  * handle the signal itself. If it isn't waiting on
2185  * an event, it goes back to run state.
2186  * Otherwise, process goes back to sleep state.
2187  */
2188  p->p_flag &= ~P_STOPPED_SIG;
2189  PROC_SLOCK(p);
2190  if (p->p_numthreads == p->p_suspcount) {
2191  PROC_SUNLOCK(p);
2192  p->p_flag |= P_CONTINUED;
2193  p->p_xstat = SIGCONT;
2194  PROC_LOCK(p->p_pptr);
2195  childproc_continued(p);
2196  PROC_UNLOCK(p->p_pptr);
2197  PROC_SLOCK(p);
2198  }
2199  if (action == SIG_DFL) {
2200  thread_unsuspend(p);
2201  PROC_SUNLOCK(p);
2202  sigqueue_delete(sigqueue, sig);
2203  goto out;
2204  }
2205  if (action == SIG_CATCH) {
2206  /*
2207  * The process wants to catch it so it needs
2208  * to run at least one thread, but which one?
2209  */
2210  PROC_SUNLOCK(p);
2211  goto runfast;
2212  }
2213  /*
2214  * The signal is not ignored or caught.
2215  */
2216  thread_unsuspend(p);
2217  PROC_SUNLOCK(p);
2218  goto out;
2219  }
2220 
2221  if (prop & SA_STOP) {
2222  /*
2223  * If traced process is already stopped,
2224  * then no further action is necessary.
2225  */
2226  if (p->p_flag & P_TRACED)
2227  goto out;
2228  /*
2229  * Already stopped, don't need to stop again
2230  * (If we did the shell could get confused).
2231  * Just make sure the signal STOP bit set.
2232  */
2233  p->p_flag |= P_STOPPED_SIG;
2234  sigqueue_delete(sigqueue, sig);
2235  goto out;
2236  }
2237 
2238  /*
2239  * All other kinds of signals:
2240  * If a thread is sleeping interruptibly, simulate a
2241  * wakeup so that when it is continued it will be made
2242  * runnable and can look at the signal. However, don't make
2243  * the PROCESS runnable, leave it stopped.
2244  * It may run a bit until it hits a thread_suspend_check().
2245  */
2246  wakeup_swapper = 0;
2247  PROC_SLOCK(p);
2248  thread_lock(td);
2249  if (TD_ON_SLEEPQ(td) && (td->td_flags & TDF_SINTR))
2250  wakeup_swapper = sleepq_abort(td, intrval);
2251  thread_unlock(td);
2252  PROC_SUNLOCK(p);
2253  if (wakeup_swapper)
2254  kick_proc0();
2255  goto out;
2256  /*
2257  * Mutexes are short lived. Threads waiting on them will
2258  * hit thread_suspend_check() soon.
2259  */
2260  } else if (p->p_state == PRS_NORMAL) {
2261  if (p->p_flag & P_TRACED || action == SIG_CATCH) {
2262  tdsigwakeup(td, sig, action, intrval);
2263  goto out;
2264  }
2265 
2266  MPASS(action == SIG_DFL);
2267 
2268  if (prop & SA_STOP) {
2269  if (p->p_flag & (P_PPWAIT|P_WEXIT))
2270  goto out;
2271  p->p_flag |= P_STOPPED_SIG;
2272  p->p_xstat = sig;
2273  PROC_SLOCK(p);
2274  sig_suspend_threads(td, p, 1);
2275  if (p->p_numthreads == p->p_suspcount) {
2276  /*
2277  * only thread sending signal to another
2278  * process can reach here, if thread is sending
2279  * signal to its process, because thread does
2280  * not suspend itself here, p_numthreads
2281  * should never be equal to p_suspcount.
2282  */
2283  thread_stopped(p);
2284  PROC_SUNLOCK(p);
2285  sigqueue_delete_proc(p, p->p_xstat);
2286  } else
2287  PROC_SUNLOCK(p);
2288  goto out;
2289  }
2290  } else {
2291  /* Not in "NORMAL" state. discard the signal. */
2292  sigqueue_delete(sigqueue, sig);
2293  goto out;
2294  }
2295 
2296  /*
2297  * The process is not stopped so we need to apply the signal to all the
2298  * running threads.
2299  */
2300 runfast:
2301  tdsigwakeup(td, sig, action, intrval);
2302  PROC_SLOCK(p);
2303  thread_unsuspend(p);
2304  PROC_SUNLOCK(p);
2305 out:
2306  /* If we jump here, proc slock should not be owned. */
2307  PROC_SLOCK_ASSERT(p, MA_NOTOWNED);
2308  return (ret);
2309 }
2310 
2311 /*
2312  * The force of a signal has been directed against a single
2313  * thread. We need to see what we can do about knocking it
2314  * out of any sleep it may be in etc.
2315  */
2316 static void
2317 tdsigwakeup(struct thread *td, int sig, sig_t action, int intrval)
2318 {
2319  struct proc *p = td->td_proc;
2320  register int prop;
2321  int wakeup_swapper;
2322 
2323  wakeup_swapper = 0;
2324  PROC_LOCK_ASSERT(p, MA_OWNED);
2325  prop = sigprop(sig);
2326 
2327  PROC_SLOCK(p);
2328  thread_lock(td);
2329  /*
2330  * Bring the priority of a thread up if we want it to get
2331  * killed in this lifetime.
2332  */
2333  if (action == SIG_DFL && (prop & SA_KILL) && td->td_priority > PUSER)
2334  sched_prio(td, PUSER);
2335  if (TD_ON_SLEEPQ(td)) {
2336  /*
2337  * If thread is sleeping uninterruptibly
2338  * we can't interrupt the sleep... the signal will
2339  * be noticed when the process returns through
2340  * trap() or syscall().
2341  */
2342  if ((td->td_flags & TDF_SINTR) == 0)
2343  goto out;
2344  /*
2345  * If SIGCONT is default (or ignored) and process is
2346  * asleep, we are finished; the process should not
2347  * be awakened.
2348  */
2349  if ((prop & SA_CONT) && action == SIG_DFL) {
2350  thread_unlock(td);
2351  PROC_SUNLOCK(p);
2352  sigqueue_delete(&p->p_sigqueue, sig);
2353  /*
2354  * It may be on either list in this state.
2355  * Remove from both for now.
2356  */
2357  sigqueue_delete(&td->td_sigqueue, sig);
2358  return;
2359  }
2360 
2361  /*
2362  * Don't awaken a sleeping thread for SIGSTOP if the
2363  * STOP signal is deferred.
2364  */
2365  if ((prop & SA_STOP) && (td->td_flags & TDF_SBDRY))
2366  goto out;
2367 
2368  /*
2369  * Give low priority threads a better chance to run.
2370  */
2371  if (td->td_priority > PUSER)
2372  sched_prio(td, PUSER);
2373 
2374  wakeup_swapper = sleepq_abort(td, intrval);
2375  } else {
2376  /*
2377  * Other states do nothing with the signal immediately,
2378  * other than kicking ourselves if we are running.
2379  * It will either never be noticed, or noticed very soon.
2380  */
2381 #ifdef SMP
2382  if (TD_IS_RUNNING(td) && td != curthread)
2383  forward_signal(td);
2384 #endif
2385  }
2386 out:
2387  PROC_SUNLOCK(p);
2388  thread_unlock(td);
2389  if (wakeup_swapper)
2390  kick_proc0();
2391 }
2392 
2393 static void
2394 sig_suspend_threads(struct thread *td, struct proc *p, int sending)
2395 {
2396  struct thread *td2;
2397  int wakeup_swapper;
2398 
2399  PROC_LOCK_ASSERT(p, MA_OWNED);
2400  PROC_SLOCK_ASSERT(p, MA_OWNED);
2401 
2402  wakeup_swapper = 0;
2403  FOREACH_THREAD_IN_PROC(p, td2) {
2404  thread_lock(td2);
2405  td2->td_flags |= TDF_ASTPENDING | TDF_NEEDSUSPCHK;
2406  if ((TD_IS_SLEEPING(td2) || TD_IS_SWAPPED(td2)) &&
2407  (td2->td_flags & TDF_SINTR)) {
2408  if (td2->td_flags & TDF_SBDRY) {
2409  /*
2410  * Once a thread is asleep with
2411  * TDF_SBDRY set, it should never
2412  * become suspended due to this check.
2413  */
2414  KASSERT(!TD_IS_SUSPENDED(td2),
2415  ("thread with deferred stops suspended"));
2416  } else if (!TD_IS_SUSPENDED(td2)) {
2417  thread_suspend_one(td2);
2418  }
2419  } else if (!TD_IS_SUSPENDED(td2)) {
2420  if (sending || td != td2)
2421  td2->td_flags |= TDF_ASTPENDING;
2422 #ifdef SMP
2423  if (TD_IS_RUNNING(td2) && td2 != td)
2424  forward_signal(td2);
2425 #endif
2426  }
2427  thread_unlock(td2);
2428  }
2429  if (wakeup_swapper)
2430  kick_proc0();
2431 }
2432 
2433 int
2434 ptracestop(struct thread *td, int sig)
2435 {
2436  struct proc *p = td->td_proc;
2437 
2438  PROC_LOCK_ASSERT(p, MA_OWNED);
2439  KASSERT(!(p->p_flag & P_WEXIT), ("Stopping exiting process"));
2440  WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK,
2441  &p->p_mtx.lock_object, "Stopping for traced signal");
2442 
2443  td->td_dbgflags |= TDB_XSIG;
2444  td->td_xsig = sig;
2445  CTR4(KTR_PTRACE, "ptracestop: tid %d (pid %d) flags %#x sig %d",
2446  td->td_tid, p->p_pid, td->td_dbgflags, sig);
2447  PROC_SLOCK(p);
2448  while ((p->p_flag & P_TRACED) && (td->td_dbgflags & TDB_XSIG)) {
2449  if (p->p_flag & P_SINGLE_EXIT) {
2450  td->td_dbgflags &= ~TDB_XSIG;
2451  PROC_SUNLOCK(p);
2452  return (sig);
2453  }
2454  /*
2455  * Just make wait() to work, the last stopped thread
2456  * will win.
2457  */
2458  p->p_xstat = sig;
2459  p->p_xthread = td;
2460  p->p_flag |= (P_STOPPED_SIG|P_STOPPED_TRACE);
2461  sig_suspend_threads(td, p, 0);
2462  if ((td->td_dbgflags & TDB_STOPATFORK) != 0) {
2463  td->td_dbgflags &= ~TDB_STOPATFORK;
2464  cv_broadcast(&p->p_dbgwait);
2465  }
2466 stopme:
2467  thread_suspend_switch(td);
2468  if (!(p->p_flag & P_TRACED)) {
2469  break;
2470  }
2471  if (td->td_dbgflags & TDB_SUSPEND) {
2472  if (p->p_flag & P_SINGLE_EXIT)
2473  break;
2474  goto stopme;
2475  }
2476  }
2477  PROC_SUNLOCK(p);
2478  return (td->td_xsig);
2479 }
2480 
2481 static void
2482 reschedule_signals(struct proc *p, sigset_t block, int flags)
2483 {
2484  struct sigacts *ps;
2485  struct thread *td;
2486  int sig;
2487 
2488  PROC_LOCK_ASSERT(p, MA_OWNED);
2489  if (SIGISEMPTY(p->p_siglist))
2490  return;
2491  ps = p->p_sigacts;
2492  SIGSETAND(block, p->p_siglist);
2493  while ((sig = sig_ffs(&block)) != 0) {
2494  SIGDELSET(block, sig);
2495  td = sigtd(p, sig, 0);
2496  signotify(td);
2497  if (!(flags & SIGPROCMASK_PS_LOCKED))
2498  mtx_lock(&ps->ps_mtx);
2499  if (p->p_flag & P_TRACED || SIGISMEMBER(ps->ps_sigcatch, sig))
2500  tdsigwakeup(td, sig, SIG_CATCH,
2501  (SIGISMEMBER(ps->ps_sigintr, sig) ? EINTR :
2502  ERESTART));
2503  if (!(flags & SIGPROCMASK_PS_LOCKED))
2504  mtx_unlock(&ps->ps_mtx);
2505  }
2506 }
2507 
2508 void
2509 tdsigcleanup(struct thread *td)
2510 {
2511  struct proc *p;
2512  sigset_t unblocked;
2513 
2514  p = td->td_proc;
2515  PROC_LOCK_ASSERT(p, MA_OWNED);
2516 
2517  sigqueue_flush(&td->td_sigqueue);
2518  if (p->p_numthreads == 1)
2519  return;
2520 
2521  /*
2522  * Since we cannot handle signals, notify signal post code
2523  * about this by filling the sigmask.
2524  *
2525  * Also, if needed, wake up thread(s) that do not block the
2526  * same signals as the exiting thread, since the thread might
2527  * have been selected for delivery and woken up.
2528  */
2529  SIGFILLSET(unblocked);
2530  SIGSETNAND(unblocked, td->td_sigmask);
2531  SIGFILLSET(td->td_sigmask);
2532  reschedule_signals(p, unblocked, 0);
2533 
2534 }
2535 
2536 /*
2537  * Defer the delivery of SIGSTOP for the current thread. Returns true
2538  * if stops were deferred and false if they were already deferred.
2539  */
2540 int
2541 sigdeferstop(void)
2542 {
2543  struct thread *td;
2544 
2545  td = curthread;
2546  if (td->td_flags & TDF_SBDRY)
2547  return (0);
2548  thread_lock(td);
2549  td->td_flags |= TDF_SBDRY;
2550  thread_unlock(td);
2551  return (1);
2552 }
2553 
2554 /*
2555  * Permit the delivery of SIGSTOP for the current thread. This does
2556  * not immediately suspend if a stop was posted. Instead, the thread
2557  * will suspend either via ast() or a subsequent interruptible sleep.
2558  */
2559 void
2560 sigallowstop()
2561 {
2562  struct thread *td;
2563 
2564  td = curthread;
2565  thread_lock(td);
2566  td->td_flags &= ~TDF_SBDRY;
2567  thread_unlock(td);
2568 }
2569 
2570 /*
2571  * If the current process has received a signal (should be caught or cause
2572  * termination, should interrupt current syscall), return the signal number.
2573  * Stop signals with default action are processed immediately, then cleared;
2574  * they aren't returned. This is checked after each entry to the system for
2575  * a syscall or trap (though this can usually be done without calling issignal
2576  * by checking the pending signal masks in cursig.) The normal call
2577  * sequence is
2578  *
2579  * while (sig = cursig(curthread))
2580  * postsig(sig);
2581  */
2582 static int
2583 issignal(struct thread *td, int stop_allowed)
2584 {
2585  struct proc *p;
2586  struct sigacts *ps;
2587  struct sigqueue *queue;
2588  sigset_t sigpending;
2589  int sig, prop, newsig;
2590 
2591  p = td->td_proc;
2592  ps = p->p_sigacts;
2593  mtx_assert(&ps->ps_mtx, MA_OWNED);
2594  PROC_LOCK_ASSERT(p, MA_OWNED);
2595  for (;;) {
2596  int traced = (p->p_flag & P_TRACED) || (p->p_stops & S_SIG);
2597 
2598  sigpending = td->td_sigqueue.sq_signals;
2599  SIGSETOR(sigpending, p->p_sigqueue.sq_signals);
2600  SIGSETNAND(sigpending, td->td_sigmask);
2601 
2602  if (p->p_flag & P_PPWAIT || td->td_flags & TDF_SBDRY)
2603  SIG_STOPSIGMASK(sigpending);
2604  if (SIGISEMPTY(sigpending)) /* no signal to send */
2605  return (0);
2606  sig = sig_ffs(&sigpending);
2607 
2608  if (p->p_stops & S_SIG) {
2609  mtx_unlock(&ps->ps_mtx);
2610  stopevent(p, S_SIG, sig);
2611  mtx_lock(&ps->ps_mtx);
2612  }
2613 
2614  /*
2615  * We should see pending but ignored signals
2616  * only if P_TRACED was on when they were posted.
2617  */
2618  if (SIGISMEMBER(ps->ps_sigignore, sig) && (traced == 0)) {
2619  sigqueue_delete(&td->td_sigqueue, sig);
2620  sigqueue_delete(&p->p_sigqueue, sig);
2621  continue;
2622  }
2623  if (p->p_flag & P_TRACED && (p->p_flag & P_PPTRACE) == 0) {
2624  /*
2625  * If traced, always stop.
2626  * Remove old signal from queue before the stop.
2627  * XXX shrug off debugger, it causes siginfo to
2628  * be thrown away.
2629  */
2630  queue = &td->td_sigqueue;
2631  td->td_dbgksi.ksi_signo = 0;
2632  if (sigqueue_get(queue, sig, &td->td_dbgksi) == 0) {
2633  queue = &p->p_sigqueue;
2634  sigqueue_get(queue, sig, &td->td_dbgksi);
2635  }
2636 
2637  mtx_unlock(&ps->ps_mtx);
2638  newsig = ptracestop(td, sig);
2639  mtx_lock(&ps->ps_mtx);
2640 
2641  if (sig != newsig) {
2642 
2643  /*
2644  * If parent wants us to take the signal,
2645  * then it will leave it in p->p_xstat;
2646  * otherwise we just look for signals again.
2647  */
2648  if (newsig == 0)
2649  continue;
2650  sig = newsig;
2651 
2652  /*
2653  * Put the new signal into td_sigqueue. If the
2654  * signal is being masked, look for other signals.
2655  */
2656  sigqueue_add(queue, sig, NULL);
2657  if (SIGISMEMBER(td->td_sigmask, sig))
2658  continue;
2659  signotify(td);
2660  } else {
2661  if (td->td_dbgksi.ksi_signo != 0) {
2662  td->td_dbgksi.ksi_flags |= KSI_HEAD;
2663  if (sigqueue_add(&td->td_sigqueue, sig,
2664  &td->td_dbgksi) != 0)
2665  td->td_dbgksi.ksi_signo = 0;
2666  }
2667  if (td->td_dbgksi.ksi_signo == 0)
2668  sigqueue_add(&td->td_sigqueue, sig,
2669  NULL);
2670  }
2671 
2672  /*
2673  * If the traced bit got turned off, go back up
2674  * to the top to rescan signals. This ensures
2675  * that p_sig* and p_sigact are consistent.
2676  */
2677  if ((p->p_flag & P_TRACED) == 0)
2678  continue;
2679  }
2680 
2681  prop = sigprop(sig);
2682 
2683  /*
2684  * Decide whether the signal should be returned.
2685  * Return the signal's number, or fall through
2686  * to clear it from the pending mask.
2687  */
2688  switch ((intptr_t)p->p_sigacts->ps_sigact[_SIG_IDX(sig)]) {
2689 
2690  case (intptr_t)SIG_DFL:
2691  /*
2692  * Don't take default actions on system processes.
2693  */
2694  if (p->p_pid <= 1) {
2695 #ifdef DIAGNOSTIC
2696  /*
2697  * Are you sure you want to ignore SIGSEGV
2698  * in init? XXX
2699  */
2700  printf("Process (pid %lu) got signal %d\n",
2701  (u_long)p->p_pid, sig);
2702 #endif
2703  break; /* == ignore */
2704  }
2705  /*
2706  * If there is a pending stop signal to process
2707  * with default action, stop here,
2708  * then clear the signal. However,
2709  * if process is member of an orphaned
2710  * process group, ignore tty stop signals.
2711  */
2712  if (prop & SA_STOP) {
2713  if (p->p_flag & (P_TRACED|P_WEXIT) ||
2714  (p->p_pgrp->pg_jobc == 0 &&
2715  prop & SA_TTYSTOP))
2716  break; /* == ignore */
2717  mtx_unlock(&ps->ps_mtx);
2718  WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK,
2719  &p->p_mtx.lock_object, "Catching SIGSTOP");
2720  p->p_flag |= P_STOPPED_SIG;
2721  p->p_xstat = sig;
2722  PROC_SLOCK(p);
2723  sig_suspend_threads(td, p, 0);
2724  thread_suspend_switch(td);
2725  PROC_SUNLOCK(p);
2726  mtx_lock(&ps->ps_mtx);
2727  break;
2728  } else if (prop & SA_IGNORE) {
2729  /*
2730  * Except for SIGCONT, shouldn't get here.
2731  * Default action is to ignore; drop it.
2732  */
2733  break; /* == ignore */
2734  } else
2735  return (sig);
2736  /*NOTREACHED*/
2737 
2738  case (intptr_t)SIG_IGN:
2739  /*
2740  * Masking above should prevent us ever trying
2741  * to take action on an ignored signal other
2742  * than SIGCONT, unless process is traced.
2743  */
2744  if ((prop & SA_CONT) == 0 &&
2745  (p->p_flag & P_TRACED) == 0)
2746  printf("issignal\n");
2747  break; /* == ignore */
2748 
2749  default:
2750  /*
2751  * This signal has an action, let
2752  * postsig() process it.
2753  */
2754  return (sig);
2755  }
2756  sigqueue_delete(&td->td_sigqueue, sig); /* take the signal! */
2757  sigqueue_delete(&p->p_sigqueue, sig);
2758  }
2759  /* NOTREACHED */
2760 }
2761 
2762 void
2763 thread_stopped(struct proc *p)
2764 {
2765  int n;
2766 
2767  PROC_LOCK_ASSERT(p, MA_OWNED);
2768  PROC_SLOCK_ASSERT(p, MA_OWNED);
2769  n = p->p_suspcount;
2770  if (p == curproc)
2771  n++;
2772  if ((p->p_flag & P_STOPPED_SIG) && (n == p->p_numthreads)) {
2773  PROC_SUNLOCK(p);
2774  p->p_flag &= ~P_WAITED;
2775  PROC_LOCK(p->p_pptr);
2776  childproc_stopped(p, (p->p_flag & P_TRACED) ?
2777  CLD_TRAPPED : CLD_STOPPED);
2778  PROC_UNLOCK(p->p_pptr);
2779  PROC_SLOCK(p);
2780  }
2781 }
2782 
2783 /*
2784  * Take the action for the specified signal
2785  * from the current set of pending signals.
2786  */
2787 int
2788 postsig(sig)
2789  register int sig;
2790 {
2791  struct thread *td = curthread;
2792  register struct proc *p = td->td_proc;
2793  struct sigacts *ps;
2794  sig_t action;
2795  ksiginfo_t ksi;
2796  sigset_t returnmask;
2797 
2798  KASSERT(sig != 0, ("postsig"));
2799 
2800  PROC_LOCK_ASSERT(p, MA_OWNED);
2801  ps = p->p_sigacts;
2802  mtx_assert(&ps->ps_mtx, MA_OWNED);
2803  ksiginfo_init(&ksi);
2804  if (sigqueue_get(&td->td_sigqueue, sig, &ksi) == 0 &&
2805  sigqueue_get(&p->p_sigqueue, sig, &ksi) == 0)
2806  return (0);
2807  ksi.ksi_signo = sig;
2808  if (ksi.ksi_code == SI_TIMER)
2809  itimer_accept(p, ksi.ksi_timerid, &ksi);
2810  action = ps->ps_sigact[_SIG_IDX(sig)];
2811 #ifdef KTRACE
2812  if (KTRPOINT(td, KTR_PSIG))
2813  ktrpsig(sig, action, td->td_pflags & TDP_OLDMASK ?
2814  &td->td_oldsigmask : &td->td_sigmask, ksi.ksi_code);
2815 #endif
2816  if (p->p_stops & S_SIG) {
2817  mtx_unlock(&ps->ps_mtx);
2818  stopevent(p, S_SIG, sig);
2819  mtx_lock(&ps->ps_mtx);
2820  }
2821 
2822  if (action == SIG_DFL) {
2823  /*
2824  * Default action, where the default is to kill
2825  * the process. (Other cases were ignored above.)
2826  */
2827  mtx_unlock(&ps->ps_mtx);
2828  sigexit(td, sig);
2829  /* NOTREACHED */
2830  } else {
2831  /*
2832  * If we get here, the signal must be caught.
2833  */
2834  KASSERT(action != SIG_IGN && !SIGISMEMBER(td->td_sigmask, sig),
2835  ("postsig action"));
2836  /*
2837  * Set the new mask value and also defer further
2838  * occurrences of this signal.
2839  *
2840  * Special case: user has done a sigsuspend. Here the
2841  * current mask is not of interest, but rather the
2842  * mask from before the sigsuspend is what we want
2843  * restored after the signal processing is completed.
2844  */
2845  if (td->td_pflags & TDP_OLDMASK) {
2846  returnmask = td->td_oldsigmask;
2847  td->td_pflags &= ~TDP_OLDMASK;
2848  } else
2849  returnmask = td->td_sigmask;
2850 
2851  if (p->p_sig == sig) {
2852  p->p_code = 0;
2853  p->p_sig = 0;
2854  }
2855  (*p->p_sysent->sv_sendsig)(action, &ksi, &returnmask);
2856  postsig_done(sig, td, ps);
2857  }
2858  return (1);
2859 }
2860 
2861 /*
2862  * Kill the current process for stated reason.
2863  */
2864 void
2865 killproc(p, why)
2866  struct proc *p;
2867  char *why;
2868 {
2869 
2870  PROC_LOCK_ASSERT(p, MA_OWNED);
2871  CTR3(KTR_PROC, "killproc: proc %p (pid %d, %s)",
2872  p, p->p_pid, p->p_comm);
2873  log(LOG_ERR, "pid %d (%s), uid %d, was killed: %s\n", p->p_pid, p->p_comm,
2874  p->p_ucred ? p->p_ucred->cr_uid : -1, why);
2875  p->p_flag |= P_WKILLED;
2876  kern_psignal(p, SIGKILL);
2877 }
2878 
2879 /*
2880  * Force the current process to exit with the specified signal, dumping core
2881  * if appropriate. We bypass the normal tests for masked and caught signals,
2882  * allowing unrecoverable failures to terminate the process without changing
2883  * signal state. Mark the accounting record with the signal termination.
2884  * If dumping core, save the signal number for the debugger. Calls exit and
2885  * does not return.
2886  */
2887 void
2888 sigexit(td, sig)
2889  struct thread *td;
2890  int sig;
2891 {
2892  struct proc *p = td->td_proc;
2893 
2894  PROC_LOCK_ASSERT(p, MA_OWNED);
2895  p->p_acflag |= AXSIG;
2896  /*
2897  * We must be single-threading to generate a core dump. This
2898  * ensures that the registers in the core file are up-to-date.
2899  * Also, the ELF dump handler assumes that the thread list doesn't
2900  * change out from under it.
2901  *
2902  * XXX If another thread attempts to single-thread before us
2903  * (e.g. via fork()), we won't get a dump at all.
2904  */
2905  if ((sigprop(sig) & SA_CORE) && (thread_single(SINGLE_NO_EXIT) == 0)) {
2906  p->p_sig = sig;
2907  /*
2908  * Log signals which would cause core dumps
2909  * (Log as LOG_INFO to appease those who don't want
2910  * these messages.)
2911  * XXX : Todo, as well as euid, write out ruid too
2912  * Note that coredump() drops proc lock.
2913  */
2914  if (coredump(td) == 0)
2915  sig |= WCOREFLAG;
2916  if (kern_logsigexit)
2917  log(LOG_INFO,
2918  "pid %d (%s), uid %d: exited on signal %d%s\n",
2919  p->p_pid, p->p_comm,
2920  td->td_ucred ? td->td_ucred->cr_uid : -1,
2921  sig &~ WCOREFLAG,
2922  sig & WCOREFLAG ? " (core dumped)" : "");
2923  } else
2924  PROC_UNLOCK(p);
2925  exit1(td, W_EXITCODE(0, sig));
2926  /* NOTREACHED */
2927 }
2928 
2929 /*
2930  * Send queued SIGCHLD to parent when child process's state
2931  * is changed.
2932  */
2933 static void
2934 sigparent(struct proc *p, int reason, int status)
2935 {
2936  PROC_LOCK_ASSERT(p, MA_OWNED);
2937  PROC_LOCK_ASSERT(p->p_pptr, MA_OWNED);
2938 
2939  if (p->p_ksi != NULL) {
2940  p->p_ksi->ksi_signo = SIGCHLD;
2941  p->p_ksi->ksi_code = reason;
2942  p->p_ksi->ksi_status = status;
2943  p->p_ksi->ksi_pid = p->p_pid;
2944  p->p_ksi->ksi_uid = p->p_ucred->cr_ruid;
2945  if (KSI_ONQ(p->p_ksi))
2946  return;
2947  }
2948  pksignal(p->p_pptr, SIGCHLD, p->p_ksi);
2949 }
2950 
2951 static void
2952 childproc_jobstate(struct proc *p, int reason, int sig)
2953 {
2954  struct sigacts *ps;
2955 
2956  PROC_LOCK_ASSERT(p, MA_OWNED);
2957  PROC_LOCK_ASSERT(p->p_pptr, MA_OWNED);
2958 
2959  /*
2960  * Wake up parent sleeping in kern_wait(), also send
2961  * SIGCHLD to parent, but SIGCHLD does not guarantee
2962  * that parent will awake, because parent may masked
2963  * the signal.
2964  */
2965  p->p_pptr->p_flag |= P_STATCHILD;
2966  wakeup(p->p_pptr);
2967 
2968  ps = p->p_pptr->p_sigacts;
2969  mtx_lock(&ps->ps_mtx);
2970  if ((ps->ps_flag & PS_NOCLDSTOP) == 0) {
2971  mtx_unlock(&ps->ps_mtx);
2972  sigparent(p, reason, sig);
2973  } else
2974  mtx_unlock(&ps->ps_mtx);
2975 }
2976 
2977 void
2978 childproc_stopped(struct proc *p, int reason)
2979 {
2980  /* p_xstat is a plain signal number, not a full wait() status here. */
2981  childproc_jobstate(p, reason, p->p_xstat);
2982 }
2983 
2984 void
2985 childproc_continued(struct proc *p)
2986 {
2987  childproc_jobstate(p, CLD_CONTINUED, SIGCONT);
2988 }
2989 
2990 void
2991 childproc_exited(struct proc *p)
2992 {
2993  int reason;
2994  int xstat = p->p_xstat; /* convert to int */
2995  int status;
2996 
2997  if (WCOREDUMP(xstat))
2998  reason = CLD_DUMPED, status = WTERMSIG(xstat);
2999  else if (WIFSIGNALED(xstat))
3000  reason = CLD_KILLED, status = WTERMSIG(xstat);
3001  else
3002  reason = CLD_EXITED, status = WEXITSTATUS(xstat);
3003  /*
3004  * XXX avoid calling wakeup(p->p_pptr), the work is
3005  * done in exit1().
3006  */
3007  sigparent(p, reason, status);
3008 }
3009 
3010 /*
3011  * We only have 1 character for the core count in the format
3012  * string, so the range will be 0-9
3013  */
3014 #define MAX_NUM_CORES 10
3015 static int num_cores = 5;
3016 
3017 static int
3018 sysctl_debug_num_cores_check (SYSCTL_HANDLER_ARGS)
3019 {
3020  int error;
3021  int new_val;
3022 
3023  new_val = num_cores;
3024  error = sysctl_handle_int(oidp, &new_val, 0, req);
3025  if (error != 0 || req->newptr == NULL)
3026  return (error);
3027  if (new_val > MAX_NUM_CORES)
3028  new_val = MAX_NUM_CORES;
3029  if (new_val < 0)
3030  new_val = 0;
3031  num_cores = new_val;
3032  return (0);
3033 }
3034 SYSCTL_PROC(_debug, OID_AUTO, ncores, CTLTYPE_INT|CTLFLAG_RW,
3035  0, sizeof(int), sysctl_debug_num_cores_check, "I", "");
3036 
3037 #if defined(COMPRESS_USER_CORES)
3038 int compress_user_cores = 1;
3039 SYSCTL_INT(_kern, OID_AUTO, compress_user_cores, CTLFLAG_RW,
3040  &compress_user_cores, 0, "");
3041 
3042 int compress_user_cores_gzlevel = -1; /* default level */
3043 SYSCTL_INT(_kern, OID_AUTO, compress_user_cores_gzlevel, CTLFLAG_RW,
3044  &compress_user_cores_gzlevel, -1, "user core gz compression level");
3045 
3046 #define GZ_SUFFIX ".gz"
3047 #define GZ_SUFFIX_LEN 3
3048 #endif
3049 
3050 static char corefilename[MAXPATHLEN] = {"%N.core"};
3051 SYSCTL_STRING(_kern, OID_AUTO, corefile, CTLFLAG_RW, corefilename,
3052  sizeof(corefilename), "process corefile name format string");
3053 
3054 /*
3055  * expand_name(name, uid, pid, td, compress)
3056  * Expand the name described in corefilename, using name, uid, and pid.
3057  * corefilename is a printf-like string, with three format specifiers:
3058  * %N name of process ("name")
3059  * %P process id (pid)
3060  * %U user id (uid)
3061  * For example, "%N.core" is the default; they can be disabled completely
3062  * by using "/dev/null", or all core files can be stored in "/cores/%U/%N-%P".
3063  * This is controlled by the sysctl variable kern.corefile (see above).
3064  */
3065 static char *
3066 expand_name(const char *name, uid_t uid, pid_t pid, struct thread *td,
3067  int compress)
3068 {
3069  struct sbuf sb;
3070  const char *format;
3071  char *temp;
3072  size_t i;
3073  int indexpos;
3074  char *hostname;
3075 
3076  hostname = NULL;
3077  format = corefilename;
3078  temp = malloc(MAXPATHLEN, M_TEMP, M_NOWAIT | M_ZERO);
3079  if (temp == NULL)
3080  return (NULL);
3081  indexpos = -1;
3082  (void)sbuf_new(&sb, temp, MAXPATHLEN, SBUF_FIXEDLEN);
3083  for (i = 0; format[i]; i++) {
3084  switch (format[i]) {
3085  case '%': /* Format character */
3086  i++;
3087  switch (format[i]) {
3088  case '%':
3089  sbuf_putc(&sb, '%');
3090  break;
3091  case 'H': /* hostname */
3092  if (hostname == NULL) {
3093  hostname = malloc(MAXHOSTNAMELEN,
3094  M_TEMP, M_NOWAIT);
3095  if (hostname == NULL) {
3096  log(LOG_ERR,
3097  "pid %ld (%s), uid (%lu): "
3098  "unable to alloc memory "
3099  "for corefile hostname\n",
3100  (long)pid, name,
3101  (u_long)uid);
3102  goto nomem;
3103  }
3104  }
3105  getcredhostname(td->td_ucred, hostname,
3106  MAXHOSTNAMELEN);
3107  sbuf_printf(&sb, "%s", hostname);
3108  break;
3109  case 'I': /* autoincrementing index */
3110  sbuf_printf(&sb, "0");
3111  indexpos = sbuf_len(&sb) - 1;
3112  break;
3113  case 'N': /* process name */
3114  sbuf_printf(&sb, "%s", name);
3115  break;
3116  case 'P': /* process id */
3117  sbuf_printf(&sb, "%u", pid);
3118  break;
3119  case 'U': /* user id */
3120  sbuf_printf(&sb, "%u", uid);
3121  break;
3122  default:
3123  log(LOG_ERR,
3124  "Unknown format character %c in "
3125  "corename `%s'\n", format[i], format);
3126  }
3127  break;
3128  default:
3129  sbuf_putc(&sb, format[i]);
3130  }
3131  }
3132  free(hostname, M_TEMP);
3133 #ifdef COMPRESS_USER_CORES
3134  if (compress) {
3135  sbuf_printf(&sb, GZ_SUFFIX);
3136  }
3137 #endif
3138  if (sbuf_error(&sb) != 0) {
3139  log(LOG_ERR, "pid %ld (%s), uid (%lu): corename is too "
3140  "long\n", (long)pid, name, (u_long)uid);
3141 nomem:
3142  sbuf_delete(&sb);
3143  free(temp, M_TEMP);
3144  return (NULL);
3145  }
3146  sbuf_finish(&sb);
3147  sbuf_delete(&sb);
3148 
3149  /*
3150  * If the core format has a %I in it, then we need to check
3151  * for existing corefiles before returning a name.
3152  * To do this we iterate over 0..num_cores to find a
3153  * non-existing core file name to use.
3154  */
3155  if (indexpos != -1) {
3156  struct nameidata nd;
3157  int error, n;
3158  int flags = O_CREAT | O_EXCL | FWRITE | O_NOFOLLOW;
3159  int cmode = S_IRUSR | S_IWUSR;
3160  int vfslocked;
3161 
3162  for (n = 0; n < num_cores; n++) {
3163  temp[indexpos] = '0' + n;
3164  NDINIT(&nd, LOOKUP, NOFOLLOW | MPSAFE, UIO_SYSSPACE,
3165  temp, td);
3166  error = vn_open(&nd, &flags, cmode, NULL);
3167  if (error) {
3168  if (error == EEXIST) {
3169  continue;
3170  }
3171  log(LOG_ERR,
3172  "pid %d (%s), uid (%u): Path `%s' failed "
3173  "on initial open test, error = %d\n",
3174  pid, name, uid, temp, error);
3175  free(temp, M_TEMP);
3176  return (NULL);
3177  }
3178  vfslocked = NDHASGIANT(&nd);
3179  NDFREE(&nd, NDF_ONLY_PNBUF);
3180  VOP_UNLOCK(nd.ni_vp, 0);
3181  error = vn_close(nd.ni_vp, FWRITE, td->td_ucred, td);
3182  VFS_UNLOCK_GIANT(vfslocked);
3183  if (error) {
3184  log(LOG_ERR,
3185  "pid %d (%s), uid (%u): Path `%s' failed "
3186  "on close after initial open test, "
3187  "error = %d\n",
3188  pid, name, uid, temp, error);
3189  free(temp, M_TEMP);
3190  return (NULL);
3191  }
3192  break;
3193  }
3194  }
3195  return (temp);
3196 }
3197 
3198 /*
3199  * Dump a process' core. The main routine does some
3200  * policy checking, and creates the name of the coredump;
3201  * then it passes on a vnode and a size limit to the process-specific
3202  * coredump routine if there is one; if there _is not_ one, it returns
3203  * ENOSYS; otherwise it returns the error from the process-specific routine.
3204  */
3205 
3206 static int
3207 coredump(struct thread *td)
3208 {
3209  struct proc *p = td->td_proc;
3210  register struct vnode *vp;
3211  register struct ucred *cred = td->td_ucred;
3212  struct flock lf;
3213  struct nameidata nd;
3214  struct vattr vattr;
3215  int error, error1, flags, locked;
3216  struct mount *mp;
3217  char *name; /* name of corefile */
3218  off_t limit;
3219  int vfslocked;
3220  int compress;
3221 
3222 #ifdef COMPRESS_USER_CORES
3223  compress = compress_user_cores;
3224 #else
3225  compress = 0;
3226 #endif
3227  PROC_LOCK_ASSERT(p, MA_OWNED);
3228  MPASS((p->p_flag & P_HADTHREADS) == 0 || p->p_singlethread == td);
3229  _STOPEVENT(p, S_CORE, 0);
3230 
3231  name = expand_name(p->p_comm, td->td_ucred->cr_uid, p->p_pid, td,
3232  compress);
3233  if (name == NULL) {
3234  PROC_UNLOCK(p);
3235 #ifdef AUDIT
3236  audit_proc_coredump(td, NULL, EINVAL);
3237 #endif
3238  return (EINVAL);
3239  }
3240  if (((sugid_coredump == 0) && p->p_flag & P_SUGID) || do_coredump == 0) {
3241  PROC_UNLOCK(p);
3242 #ifdef AUDIT
3243  audit_proc_coredump(td, name, EFAULT);
3244 #endif
3245  free(name, M_TEMP);
3246  return (EFAULT);
3247  }
3248 
3249  /*
3250  * Note that the bulk of limit checking is done after
3251  * the corefile is created. The exception is if the limit
3252  * for corefiles is 0, in which case we don't bother
3253  * creating the corefile at all. This layout means that
3254  * a corefile is truncated instead of not being created,
3255  * if it is larger than the limit.
3256  */
3257  limit = (off_t)lim_cur(p, RLIMIT_CORE);
3258  if (limit == 0 || racct_get_available(p, RACCT_CORE) == 0) {
3259  PROC_UNLOCK(p);
3260 #ifdef AUDIT
3261  audit_proc_coredump(td, name, EFBIG);
3262 #endif
3263  free(name, M_TEMP);
3264  return (EFBIG);
3265  }
3266  PROC_UNLOCK(p);
3267 
3268 restart:
3269  NDINIT(&nd, LOOKUP, NOFOLLOW | MPSAFE, UIO_SYSSPACE, name, td);
3270  flags = O_CREAT | FWRITE | O_NOFOLLOW;
3271  error = vn_open_cred(&nd, &flags, S_IRUSR | S_IWUSR, VN_OPEN_NOAUDIT,
3272  cred, NULL);
3273  if (error) {
3274 #ifdef AUDIT
3275  audit_proc_coredump(td, name, error);
3276 #endif
3277  free(name, M_TEMP);
3278  return (error);
3279  }
3280  vfslocked = NDHASGIANT(&nd);
3281  NDFREE(&nd, NDF_ONLY_PNBUF);
3282  vp = nd.ni_vp;
3283 
3284  /* Don't dump to non-regular files or files with links. */
3285  if (vp->v_type != VREG ||
3286  VOP_GETATTR(vp, &vattr, cred) || vattr.va_nlink != 1) {
3287  VOP_UNLOCK(vp, 0);
3288  error = EFAULT;
3289  goto close;
3290  }
3291 
3292  VOP_UNLOCK(vp, 0);
3293  lf.l_whence = SEEK_SET;
3294  lf.l_start = 0;
3295  lf.l_len = 0;
3296  lf.l_type = F_WRLCK;
3297  locked = (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &lf, F_FLOCK) == 0);
3298 
3299  if (vn_start_write(vp, &mp, V_NOWAIT) != 0) {
3300  lf.l_type = F_UNLCK;
3301  if (locked)
3302  VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_FLOCK);
3303  if ((error = vn_close(vp, FWRITE, cred, td)) != 0)
3304  goto out;
3305  if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
3306  goto out;
3307  VFS_UNLOCK_GIANT(vfslocked);
3308  goto restart;
3309  }
3310 
3311  VATTR_NULL(&vattr);
3312  vattr.va_size = 0;
3313  if (set_core_nodump_flag)
3314  vattr.va_flags = UF_NODUMP;
3315  vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
3316  VOP_SETATTR(vp, &vattr, cred);
3317  VOP_UNLOCK(vp, 0);
3318  vn_finished_write(mp);
3319  PROC_LOCK(p);
3320  p->p_acflag |= ACORE;
3321  PROC_UNLOCK(p);
3322 
3323  error = p->p_sysent->sv_coredump ?
3324  p->p_sysent->sv_coredump(td, vp, limit, compress ? IMGACT_CORE_COMPRESS : 0) :
3325  ENOSYS;
3326 
3327  if (locked) {
3328  lf.l_type = F_UNLCK;
3329  VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_FLOCK);
3330  }
3331 close:
3332  error1 = vn_close(vp, FWRITE, cred, td);
3333  if (error == 0)
3334  error = error1;
3335 out:
3336 #ifdef AUDIT
3337  audit_proc_coredump(td, name, error);
3338 #endif
3339  free(name, M_TEMP);
3340  VFS_UNLOCK_GIANT(vfslocked);
3341  return (error);
3342 }
3343 
3344 /*
3345  * Nonexistent system call-- signal process (may want to handle it). Flag
3346  * error in case process won't see signal immediately (blocked or ignored).
3347  */
3348 #ifndef _SYS_SYSPROTO_H_
3349 struct nosys_args {
3350  int dummy;
3351 };
3352 #endif
3353 /* ARGSUSED */
3354 int
3355 nosys(td, args)
3356  struct thread *td;
3357  struct nosys_args *args;
3358 {
3359  struct proc *p = td->td_proc;
3360 
3361  PROC_LOCK(p);
3362  tdsignal(td, SIGSYS);
3363  PROC_UNLOCK(p);
3364  return (ENOSYS);
3365 }
3366 
3367 /*
3368  * Send a SIGIO or SIGURG signal to a process or process group using stored
3369  * credentials rather than those of the current process.
3370  */
3371 void
3372 pgsigio(sigiop, sig, checkctty)
3373  struct sigio **sigiop;
3374  int sig, checkctty;
3375 {
3376  ksiginfo_t ksi;
3377  struct sigio *sigio;
3378 
3379  ksiginfo_init(&ksi);
3380  ksi.ksi_signo = sig;
3381  ksi.ksi_code = SI_KERNEL;
3382 
3383  SIGIO_LOCK();
3384  sigio = *sigiop;
3385  if (sigio == NULL) {
3386  SIGIO_UNLOCK();
3387  return;
3388  }
3389  if (sigio->sio_pgid > 0) {
3390  PROC_LOCK(sigio->sio_proc);
3391  if (CANSIGIO(sigio->sio_ucred, sigio->sio_proc->p_ucred))
3392  kern_psignal(sigio->sio_proc, sig);
3393  PROC_UNLOCK(sigio->sio_proc);
3394  } else if (sigio->sio_pgid < 0) {
3395  struct proc *p;
3396 
3397  PGRP_LOCK(sigio->sio_pgrp);
3398  LIST_FOREACH(p, &sigio->sio_pgrp->pg_members, p_pglist) {
3399  PROC_LOCK(p);
3400  if (p->p_state == PRS_NORMAL &&
3401  CANSIGIO(sigio->sio_ucred, p->p_ucred) &&
3402  (checkctty == 0 || (p->p_flag & P_CONTROLT)))
3403  kern_psignal(p, sig);
3404  PROC_UNLOCK(p);
3405  }
3406  PGRP_UNLOCK(sigio->sio_pgrp);
3407  }
3408  SIGIO_UNLOCK();
3409 }
3410 
3411 static int
3412 filt_sigattach(struct knote *kn)
3413 {
3414  struct proc *p = curproc;
3415 
3416  kn->kn_ptr.p_proc = p;
3417  kn->kn_flags |= EV_CLEAR; /* automatically set */
3418 
3419  knlist_add(&p->p_klist, kn, 0);
3420 
3421  return (0);
3422 }
3423 
3424 static void
3425 filt_sigdetach(struct knote *kn)
3426 {
3427  struct proc *p = kn->kn_ptr.p_proc;
3428 
3429  knlist_remove(&p->p_klist, kn, 0);
3430 }
3431 
3432 /*
3433  * signal knotes are shared with proc knotes, so we apply a mask to
3434  * the hint in order to differentiate them from process hints. This
3435  * could be avoided by using a signal-specific knote list, but probably
3436  * isn't worth the trouble.
3437  */
3438 static int
3439 filt_signal(struct knote *kn, long hint)
3440 {
3441 
3442  if (hint & NOTE_SIGNAL) {
3443  hint &= ~NOTE_SIGNAL;
3444 
3445  if (kn->kn_id == hint)
3446  kn->kn_data++;
3447  }
3448  return (kn->kn_data != 0);
3449 }
3450 
3451 struct sigacts *
3452 sigacts_alloc(void)
3453 {
3454  struct sigacts *ps;
3455 
3456  ps = malloc(sizeof(struct sigacts), M_SUBPROC, M_WAITOK | M_ZERO);
3457  ps->ps_refcnt = 1;
3458  mtx_init(&ps->ps_mtx, "sigacts", NULL, MTX_DEF);
3459  return (ps);
3460 }
3461 
3462 void
3463 sigacts_free(struct sigacts *ps)
3464 {
3465 
3466  mtx_lock(&ps->ps_mtx);
3467  ps->ps_refcnt--;
3468  if (ps->ps_refcnt == 0) {
3469  mtx_destroy(&ps->ps_mtx);
3470  free(ps, M_SUBPROC);
3471  } else
3472  mtx_unlock(&ps->ps_mtx);
3473 }
3474 
3475 struct sigacts *
3476 sigacts_hold(struct sigacts *ps)
3477 {
3478  mtx_lock(&ps->ps_mtx);
3479  ps->ps_refcnt++;
3480  mtx_unlock(&ps->ps_mtx);
3481  return (ps);
3482 }
3483 
3484 void
3485 sigacts_copy(struct sigacts *dest, struct sigacts *src)
3486 {
3487 
3488  KASSERT(dest->ps_refcnt == 1, ("sigacts_copy to shared dest"));
3489  mtx_lock(&src->ps_mtx);
3490  bcopy(src, dest, offsetof(struct sigacts, ps_refcnt));
3491  mtx_unlock(&src->ps_mtx);
3492 }
3493 
3494 int
3495 sigacts_shared(struct sigacts *ps)
3496 {
3497  int shared;
3498 
3499  mtx_lock(&ps->ps_mtx);
3500  shared = ps->ps_refcnt > 1;
3501  mtx_unlock(&ps->ps_mtx);
3502  return (shared);
3503 }
sigprop
static int sigprop(int sig)
Definition: kern_sig.c:607
nosys_args::dummy
int dummy
Definition: kern_sig.c:3350
sigqueue_delete_stopmask_proc
static void sigqueue_delete_stopmask_proc(struct proc *p)
Definition: kern_sig.c:541
sbuf_error
int sbuf_error(const struct sbuf *s)
Definition: subr_sbuf.c:684
kern_forcesigexit
static int kern_forcesigexit
Definition: kern_sig.c:130
SDT_PROBE_DEFINE2
SDT_PROBE_DEFINE2(proc, kernel,, signal__clear,"int","ksiginfo_t *")
killproc
void killproc(struct proc *p, char *why)
Definition: kern_sig.c:2865
sigacts_copy
void sigacts_copy(struct sigacts *dest, struct sigacts *src)
Definition: kern_sig.c:3485
tvtohz
int tvtohz(struct timeval *tv)
Definition: kern_clock.c:590
kill_args::signum
int signum
Definition: kern_sig.c:1666
kern_sigsuspend
int kern_sigsuspend(struct thread *td, sigset_t mask)
Definition: kern_sig.c:1429
sigacts_alloc
struct sigacts * sigacts_alloc(void)
Definition: kern_sig.c:3452
sigsuspend_args
Definition: kern_sig.c:1409
__FBSDID
__FBSDID("$BSDSUniX$")
expand_name
static char * expand_name(const char *, uid_t, pid_t, struct thread *, int)
Definition: kern_sig.c:3066
sig_ffs
int sig_ffs(sigset_t *set)
Definition: kern_sig.c:616
timeout
struct callout_handle timeout(timeout_t *ftn, void *arg, int to_ticks)
Definition: kern_timeout.c:713
set
METHOD int set
Definition: cpufreq_if.m:43
sched_prio
void sched_prio(struct thread *td, u_char prio)
Definition: sched_4bsd.c:897
sigaltstack_args::ss
stack_t * ss
Definition: kern_sig.c:1530
lim_cur
rlim_t lim_cur(struct proc *p, int which)
Definition: kern_resource.c:1180
NDFREE
void NDFREE(struct nameidata *ndp, const u_int flags)
Definition: vfs_lookup.c:1091
sigprocmask_args::oset
sigset_t * oset
Definition: kern_sig.c:1030
pksignal
int pksignal(struct proc *p, int sig, ksiginfo_t *ksi)
Definition: kern_sig.c:1986
ts
struct timespec * ts
Definition: clock_if.m:39
sbuf_putc
int sbuf_putc(struct sbuf *s, int c)
Definition: subr_sbuf.c:647
sbuf_len
ssize_t sbuf_len(struct sbuf *s)
Definition: subr_sbuf.c:736
kern_logsigexit
static int kern_logsigexit
Definition: kern_sig.c:125
SA_PROC
#define SA_PROC
Definition: kern_sig.c:192
kern_sigtimedwait
int kern_sigtimedwait(struct thread *td, sigset_t waitset, ksiginfo_t *ksi, struct timespec *timeout)
Definition: kern_sig.c:1164
sigpending_args::set
sigset_t * set
Definition: kern_sig.c:1279
issignal
static int issignal(struct thread *td, int stop_allowed)
Definition: kern_sig.c:2583
childproc_continued
void childproc_continued(struct proc *p)
Definition: kern_sig.c:2985
ONSIG
#define ONSIG
Definition: kern_sig.c:93
SA_CONT
#define SA_CONT
Definition: kern_sig.c:190
sigparent
static void sigparent(struct proc *p, int reason, int status)
Definition: kern_sig.c:2934
malloc
void * malloc(unsigned long size, struct malloc_type *mtp, int flags)
Definition: kern_malloc.c:454
p_cansignal
int p_cansignal(struct thread *td, struct proc *p, int signum)
Definition: kern_prot.c:1534
ksiginfo_zone
static uma_zone_t ksiginfo_zone
Definition: kern_sig.c:117
postsig
int postsig(int sig)
Definition: kern_sig.c:2788
sigaction_args::sig
int sig
Definition: kern_sig.c:777
sigaction_args
Definition: kern_sig.c:776
siginit
void siginit(struct proc *p)
Definition: kern_sig.c:896
sigprocmask_args
Definition: kern_sig.c:1027
sigqueue_take
void sigqueue_take(ksiginfo_t *ksi)
Definition: kern_sig.c:324
sys_kill
int sys_kill(struct thread *td, struct kill_args *uap)
Definition: kern_sig.c:1671
sigqueue_args::signum
int signum
Definition: kern_sig.c:1770
tdsigcleanup
void tdsigcleanup(struct thread *td)
Definition: kern_sig.c:2509
panic
void panic(const char *fmt,...)
Definition: kern_shutdown.c:557
filt_sigdetach
static void filt_sigdetach(struct knote *kn)
Definition: kern_sig.c:3425
SA_CORE
#define SA_CORE
Definition: kern_sig.c:186
sigacts_free
void sigacts_free(struct sigacts *ps)
Definition: kern_sig.c:3463
sys_sigsuspend
int sys_sigsuspend(struct thread *td, struct sigsuspend_args *uap)
Definition: kern_sig.c:1415
sigdeferstop
int sigdeferstop(void)
Definition: kern_sig.c:2541
thread_stopped
void thread_stopped(struct proc *p)
Definition: kern_sig.c:2763
sigqueue_move_set
static void sigqueue_move_set(sigqueue_t *src, sigqueue_t *dst, const sigset_t *set)
Definition: kern_sig.c:434
vn_finished_write
void vn_finished_write(struct mount *mp)
Definition: vfs_vnops.c:1599
sigqueue_delete_set
static void sigqueue_delete_set(sigqueue_t *sq, const sigset_t *set)
Definition: kern_sig.c:482
num_cores
static int num_cores
Definition: kern_sig.c:3015
thread_unsuspend
void thread_unsuspend(struct proc *p)
Definition: kern_thread.c:923
sleepq_abort
int sleepq_abort(struct thread *td, int intrval)
Definition: subr_sleepqueue.c:986
knote
void knote(struct knlist *list, long hint, int lockflags)
Definition: kern_event.c:1806
sigallowstop
void sigallowstop()
Definition: kern_sig.c:2560
pgsignal
void pgsignal(struct pgrp *pgrp, int sig, int checkctty, ksiginfo_t *ksi)
Definition: kern_sig.c:1834
postsig_done
static void postsig_done(int sig, struct thread *td, struct sigacts *ps)
Definition: kern_sig.c:1858
name
const char * name
Definition: kern_fail.c:97
sigonstack
int sigonstack(size_t sp)
Definition: kern_sig.c:591
preallocate_siginfo
static int preallocate_siginfo
Definition: kern_sig.c:141
tdsigwakeup
static void tdsigwakeup(struct thread *, int, sig_t, int)
Definition: kern_sig.c:2317
killpg1
static int killpg1(struct thread *td, int sig, int pgid, int all, ksiginfo_t *ksi)
Definition: kern_sig.c:1594
kern_psignal
void kern_psignal(struct proc *p, int sig)
Definition: kern_sig.c:1975
nosys
int nosys(struct thread *td, struct nosys_args *args)
Definition: kern_sig.c:3355
nosys_args
Definition: kern_sig.c:3349
sigqueue_flush
void sigqueue_flush(sigqueue_t *sq)
Definition: kern_sig.c:412
sigtd
static struct thread * sigtd(struct proc *p, int sig, int prop)
Definition: kern_sig.c:1933
kern_sigprocmask
int kern_sigprocmask(struct thread *td, int how, sigset_t *set, sigset_t *oset, int flags)
Definition: kern_sig.c:964
sys_sigaction
int sys_sigaction(struct thread *td, struct sigaction_args *uap)
Definition: kern_sig.c:783
getnanouptime
void getnanouptime(struct timespec *tsp)
Definition: kern_tc.c:242
SA_STOP
#define SA_STOP
Definition: kern_sig.c:187
sigqueue_add
static int sigqueue_add(sigqueue_t *sq, int signo, ksiginfo_t *si)
Definition: kern_sig.c:349
sigaltstack_args::oss
stack_t * oss
Definition: kern_sig.c:1531
pfind
struct proc * pfind(pid_t pid)
Definition: kern_proc.c:304
filt_sigattach
static int filt_sigattach(struct knote *kn)
Definition: kern_sig.c:3412
SYSCTL_STRING
SYSCTL_STRING(_kern, OID_AUTO, corefile, CTLFLAG_RW, corefilename, sizeof(corefilename),"process corefile name format string")
allproc_lock
struct sx allproc_lock
Definition: kern_proc.c:136
sigqueue_args::pid
pid_t pid
Definition: kern_sig.c:1769
SA_TTYSTOP
#define SA_TTYSTOP
Definition: kern_sig.c:188
sysctl_debug_num_cores_check
static int sysctl_debug_num_cores_check(SYSCTL_HANDLER_ARGS)
Definition: kern_sig.c:3018
dummy
static int dummy
Definition: uipc_sockbuf.c:1116
p31b_setcfg
void p31b_setcfg(int num, int value)
Definition: posix4_mib.c:127
SA_IGNORE
#define SA_IGNORE
Definition: kern_sig.c:189
vn_open_cred
int vn_open_cred(struct nameidata *ndp, int *flagp, int cmode, u_int vn_open_flags, struct ucred *cred, struct file *fp)
Definition: vfs_vnops.c:124
sig_filtops
struct filterops sig_filtops
Definition: kern_sig.c:118
childproc_stopped
void childproc_stopped(struct proc *p, int reason)
Definition: kern_sig.c:2978
knlist_remove
void knlist_remove(struct knlist *knl, struct knote *kn, int islocked)
Definition: kern_event.c:1909
sigqueue_start
static void sigqueue_start(void)
Definition: kern_sig.c:231
childproc_exited
void childproc_exited(struct proc *p)
Definition: kern_sig.c:2991
childproc_jobstate
static void childproc_jobstate(struct proc *p, int reason, int sig)
Definition: kern_sig.c:2952
sigqueue_delete_proc
void sigqueue_delete_proc(struct proc *p, int signo)
Definition: kern_sig.c:531
signal_overflow
static int signal_overflow
Definition: kern_sig.c:146
sys_pdkill
int sys_pdkill(struct thread *td, struct pdkill_args *uap)
Definition: kern_sig.c:1713
sigaltstack_args
Definition: kern_sig.c:1529
tdsignal
void tdsignal(struct thread *td, int sig)
Definition: kern_sig.c:2011
exit1
void exit1(struct thread *td, int rv)
Definition: kern_exit.c:163
racct_get_available
uint64_t racct_get_available(struct proc *p, int resource)
Definition: kern_racct.c:1256
sbuf_printf
int sbuf_printf(struct sbuf *s, const char *fmt,...)
Definition: subr_sbuf.c:632
sys_sigwait
int sys_sigwait(struct thread *td, struct sigwait_args *uap)
Definition: kern_sig.c:1079
kern_sigaltstack
int kern_sigaltstack(struct thread *td, stack_t *ss, stack_t *oss)
Definition: kern_sig.c:1558
reschedule_signals
static void reschedule_signals(struct proc *p, sigset_t block, int flags)
Definition: kern_sig.c:2482
cursig
int cursig(struct thread *td, int stop_allowed)
Definition: kern_sig.c:559
mask
int mask
Definition: subr_acl_nfs4.c:67
TUNABLE_INT
TUNABLE_INT("kern.sigqueue.preallocate",&preallocate_siginfo)
sys_sigaltstack
int sys_sigaltstack(struct thread *td, struct sigaltstack_args *uap)
Definition: kern_sig.c:1536
ptracestop
int ptracestop(struct thread *td, int sig)
Definition: kern_sig.c:2434
sysctl_handle_int
int sysctl_handle_int(SYSCTL_HANDLER_ARGS)
Definition: kern_sysctl.c:986
sigev_findtd
int sigev_findtd(struct proc *p, struct sigevent *sigev, struct thread **ttd)
Definition: kern_sig.c:1994
sigacts_shared
int sigacts_shared(struct sigacts *ps)
Definition: kern_sig.c:3495
sigqueue_args::value
void * value
Definition: kern_sig.c:1771
knlist_add
void knlist_add(struct knlist *knl, struct knote *kn, int islocked)
Definition: kern_event.c:1866
SDT_PROBE_DEFINE3
SDT_PROBE_DEFINE3(proc, kernel,, signal__send,"struct thread *","struct proc *","int")
sig_suspend_threads
static void sig_suspend_threads(struct thread *, struct proc *, int)
Definition: kern_sig.c:2394
log
void log(int level, const char *fmt,...)
Definition: subr_prf.c:289
sigprocmask_args::how
int how
Definition: kern_sig.c:1028
do_coredump
static int do_coredump
Definition: kern_sig.c:172
thread_single
int thread_single(int mode)
Definition: kern_thread.c:616
signal_alloc_fail
static int signal_alloc_fail
Definition: kern_sig.c:150
pgfind
struct pgrp * pgfind(pid_t pgid)
Definition: kern_proc.c:342
sigproptbl
static int sigproptbl[NSIG]
Definition: kern_sig.c:194
execsigs
void execsigs(struct proc *p)
Definition: kern_sig.c:916
kill_args
Definition: kern_sig.c:1664
sbuf_new
struct sbuf * sbuf_new(struct sbuf *s, char *buf, int length, int flags)
Definition: subr_sbuf.c:211
ksiginfo_free
void ksiginfo_free(ksiginfo_t *ksi)
Definition: kern_sig.c:255
trapsignal
void trapsignal(struct thread *td, ksiginfo_t *ksi)
Definition: kern_sig.c:1884
ksiginfo_alloc
ksiginfo_t * ksiginfo_alloc(int wait)
Definition: kern_sig.c:242
sigaction_args::act
struct sigaction * act
Definition: kern_sig.c:778
sys_sigwaitinfo
int sys_sigwaitinfo(struct thread *td, struct sigwaitinfo_args *uap)
Definition: kern_sig.c:1141
SYSCTL_INT
SYSCTL_INT(_kern, KERN_LOGSIGEXIT, logsigexit, CTLFLAG_RW,&kern_logsigexit, 0,"Log processes quitting on abnormal signals to syslog(3)")
free
void free(void *addr, struct malloc_type *mtp)
Definition: kern_malloc.c:554
filt_signal
static int filt_signal(struct knote *kn, long hint)
Definition: kern_sig.c:3439
vn_close
int vn_close(struct vnode *vp, int flags, struct ucred *file_cred, struct thread *td)
Definition: vfs_vnops.c:303
printf
int printf(const char *fmt,...)
Definition: subr_prf.c:367
set_core_nodump_flag
static int set_core_nodump_flag
Definition: kern_sig.c:176
sigqueue_delete
void sigqueue_delete(sigqueue_t *sq, int signo)
Definition: kern_sig.c:503
SA_KILL
#define SA_KILL
Definition: kern_sig.c:185
sbuf_delete
void sbuf_delete(struct sbuf *s)
Definition: subr_sbuf.c:753
thread_suspend_one
void thread_suspend_one(struct thread *td)
Definition: kern_thread.c:893
max_pending_per_proc
static int max_pending_per_proc
Definition: kern_sig.c:137
sigprocmask_args::set
const sigset_t * set
Definition: kern_sig.c:1029
corefilename
static char corefilename[MAXPATHLEN]
Definition: kern_sig.c:3050
sugid_coredump
static int sugid_coredump
Definition: kern_sig.c:168
mtx_init
void mtx_init(struct mtx *m, const char *name, const char *type, int opts)
Definition: kern_mutex.c:837
wakeup
void wakeup(void *ident)
Definition: kern_synch.c:378
itimer_accept
int itimer_accept(struct proc *p, int timerid, ksiginfo_t *ksi)
Definition: kern_time.c:1468
SYSINIT
SYSINIT(signal, SI_SUB_P1003_1B, SI_ORDER_FIRST+3, sigqueue_start, NULL)
sigqueue_init
void sigqueue_init(sigqueue_t *list, struct proc *p)
Definition: kern_sig.c:271
vn_start_write
int vn_start_write(struct vnode *vp, struct mount **mpp, int flags)
Definition: vfs_vnops.c:1491
SDT_PROVIDER_DECLARE
SDT_PROVIDER_DECLARE(proc)
tdksignal
void tdksignal(struct thread *td, int sig, ksiginfo_t *ksi)
Definition: kern_sig.c:2022
sys_sigprocmask
int sys_sigprocmask(struct thread *td, struct sigprocmask_args *uap)
Definition: kern_sig.c:1034
sbuf_finish
int sbuf_finish(struct sbuf *s)
Definition: subr_sbuf.c:694
sys_sigtimedwait
int sys_sigtimedwait(struct thread *td, struct sigtimedwait_args *uap)
Definition: kern_sig.c:1107
sigsuspend_args::sigmask
const sigset_t * sigmask
Definition: kern_sig.c:1410
sigacts_hold
struct sigacts * sigacts_hold(struct sigacts *ps)
Definition: kern_sig.c:3476
MAX_NUM_CORES
#define MAX_NUM_CORES
Definition: kern_sig.c:3014
tdsendsignal
int tdsendsignal(struct proc *p, struct thread *td, int sig, ksiginfo_t *ksi)
Definition: kern_sig.c:2029
sigqueue_delete_set_proc
static void sigqueue_delete_set_proc(struct proc *p, const sigset_t *set)
Definition: kern_sig.c:514
kern_sigaction
int kern_sigaction(struct thread *td, int sig, struct sigaction *act, struct sigaction *oact, int flags)
Definition: kern_sig.c:633
CANSIGIO
#define CANSIGIO(cr1, cr2)
Definition: kern_sig.c:161
coredump
static int coredump(struct thread *)
Definition: kern_sig.c:3207
proctree_lock
struct sx proctree_lock
Definition: kern_proc.c:137
vn_open
int vn_open(struct nameidata *ndp, int *flagp, int cmode, struct file *fp)
Definition: vfs_vnops.c:106
tdfind
struct thread * tdfind(lwpid_t tid, pid_t pid)
Definition: kern_thread.c:1006
signotify
void signotify(struct thread *td)
Definition: kern_sig.c:575
kill_args::pid
int pid
Definition: kern_sig.c:1665
sigqueue_get
static int sigqueue_get(sigqueue_t *sq, int signo, ksiginfo_t *si)
Definition: kern_sig.c:287
zpfind
struct proc * zpfind(pid_t pid)
Definition: kern_proc.c:1075
mtx_destroy
void mtx_destroy(struct mtx *m)
Definition: kern_mutex.c:884
sigqueue_args
Definition: kern_sig.c:1768
ksiginfo_tryfree
static __inline int ksiginfo_tryfree(ksiginfo_t *ksi)
Definition: kern_sig.c:261
sigaction_args::oact
struct sigaction * oact
Definition: kern_sig.c:779
gsignal
void gsignal(int pgid, int sig, ksiginfo_t *ksi)
Definition: kern_sig.c:1814
sys_sigqueue
int sys_sigqueue(struct thread *td, struct sigqueue_args *uap)
Definition: kern_sig.c:1775
SYSCTL_PROC
SYSCTL_PROC(_debug, OID_AUTO, ncores, CTLTYPE_INT|CTLFLAG_RW, 0, sizeof(int), sysctl_debug_num_cores_check,"I","")
thread_suspend_check
int thread_suspend_check(int return_instead)
Definition: kern_thread.c:767
stopevent
void stopevent(struct proc *p, unsigned int event, unsigned int val)
Definition: sys_process.c:1320
getcredhostname
void getcredhostname(struct ucred *cred, char *buf, size_t size)
Definition: kern_jail.c:3502
pgsigio
void pgsigio(struct sigio **sigiop, int sig, int checkctty)
Definition: kern_sig.c:3372
thread_suspend_switch
void thread_suspend_switch(struct thread *td)
Definition: kern_thread.c:864
sigpending_args
Definition: kern_sig.c:1278
count
int * count
Definition: cpufreq_if.m:63
sys_sigpending
int sys_sigpending(struct thread *td, struct sigpending_args *uap)
Definition: kern_sig.c:1283
SYSCTL_NODE
static SYSCTL_NODE(_kern, OID_AUTO, sigqueue, CTLFLAG_RW, 0,"POSIX real time signal")
sigexit
void sigexit(struct thread *td, int sig)
Definition: kern_sig.c:2888