1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 * Copyright (c) 2014, Joyent, Inc. All rights reserved.
26 */
27
28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
29 /* All Rights Reserved */
30
31 #include <sys/param.h>
32 #include <sys/types.h>
33 #include <sys/bitmap.h>
34 #include <sys/sysmacros.h>
35 #include <sys/systm.h>
36 #include <sys/cred.h>
37 #include <sys/user.h>
38 #include <sys/errno.h>
39 #include <sys/proc.h>
40 #include <sys/poll_impl.h> /* only needed for kludge in sigwaiting_send() */
41 #include <sys/signal.h>
42 #include <sys/siginfo.h>
43 #include <sys/fault.h>
44 #include <sys/ucontext.h>
45 #include <sys/procfs.h>
46 #include <sys/wait.h>
47 #include <sys/class.h>
48 #include <sys/mman.h>
49 #include <sys/procset.h>
50 #include <sys/kmem.h>
51 #include <sys/cpuvar.h>
52 #include <sys/prsystm.h>
53 #include <sys/debug.h>
54 #include <vm/as.h>
55 #include <sys/bitmap.h>
56 #include <c2/audit.h>
57 #include <sys/core.h>
58 #include <sys/schedctl.h>
59 #include <sys/contract/process_impl.h>
60 #include <sys/cyclic.h>
61 #include <sys/dtrace.h>
62 #include <sys/sdt.h>
63 #include <sys/signalfd.h>
64
65 const k_sigset_t nullsmask = {{0, 0, 0}};
66
67 const k_sigset_t fillset = { /* MUST be contiguous */
68 {FILLSET0, FILLSET1, FILLSET2}};
69
70 const k_sigset_t cantmask = {
71 {CANTMASK0, CANTMASK1, CANTMASK2}};
72
73 const k_sigset_t cantreset = {
74 {(sigmask(SIGILL)|sigmask(SIGTRAP)|sigmask(SIGPWR)), 0, 0}};
75
76 const k_sigset_t ignoredefault = {
77 {(sigmask(SIGCONT)|sigmask(SIGCLD)|sigmask(SIGPWR)
78 |sigmask(SIGWINCH)|sigmask(SIGURG)|sigmask(SIGWAITING)),
79 (sigmask(SIGLWP)|sigmask(SIGCANCEL)|sigmask(SIGFREEZE)
80 |sigmask(SIGTHAW)|sigmask(SIGXRES)|sigmask(SIGJVM1)
81 |sigmask(SIGJVM2)|sigmask(SIGINFO)), 0}};
82
83 const k_sigset_t stopdefault = {
84 {(sigmask(SIGSTOP)|sigmask(SIGTSTP)|sigmask(SIGTTOU)|sigmask(SIGTTIN)),
85 0, 0}};
86
87 const k_sigset_t coredefault = {
88 {(sigmask(SIGQUIT)|sigmask(SIGILL)|sigmask(SIGTRAP)|sigmask(SIGIOT)
89 |sigmask(SIGEMT)|sigmask(SIGFPE)|sigmask(SIGBUS)|sigmask(SIGSEGV)
90 |sigmask(SIGSYS)|sigmask(SIGXCPU)|sigmask(SIGXFSZ)), 0, 0}};
91
92 const k_sigset_t holdvfork = {
93 {(sigmask(SIGTTOU)|sigmask(SIGTTIN)|sigmask(SIGTSTP)), 0, 0}};
94
95 static int isjobstop(int);
96 static void post_sigcld(proc_t *, sigqueue_t *);
97
98
99 /*
100 * signalfd helper function which is set when the signalfd driver loads.
101 */
102 void (*sigfd_exit_helper)();
103
104 /*
105 * Internal variables for counting number of user thread stop requests posted.
106 * They may not be accurate at some special situation such as that a virtually
107 * stopped thread starts to run.
108 */
109 static int num_utstop;
110 /*
111 * Internal variables for broadcasting an event when all thread stop requests
112 * are processed.
113 */
114 static kcondvar_t utstop_cv;
115
116 static kmutex_t thread_stop_lock;
117 void del_one_utstop(void);
118
119 /*
120 * Send the specified signal to the specified process.
121 */
122 void
123 psignal(proc_t *p, int sig)
124 {
125 mutex_enter(&p->p_lock);
126 sigtoproc(p, NULL, sig);
127 mutex_exit(&p->p_lock);
128 }
129
130 /*
131 * Send the specified signal to the specified thread.
132 */
133 void
134 tsignal(kthread_t *t, int sig)
135 {
136 proc_t *p = ttoproc(t);
137
138 mutex_enter(&p->p_lock);
139 sigtoproc(p, t, sig);
140 mutex_exit(&p->p_lock);
141 }
142
143 int
144 signal_is_blocked(kthread_t *t, int sig)
145 {
146 return (sigismember(&t->t_hold, sig) ||
147 (schedctl_sigblock(t) && !sigismember(&cantmask, sig)));
148 }
149
150 /*
151 * Return true if the signal can safely be discarded on generation.
152 * That is, if there is no need for the signal on the receiving end.
153 * The answer is true if the process is a zombie or
154 * if all of these conditions are true:
155 * the signal is being ignored
156 * the process is single-threaded
157 * the signal is not being traced by /proc
158 * the signal is not blocked by the process
159 * the signal is not being accepted via sigwait()
160 */
161 static int
162 sig_discardable(proc_t *p, int sig)
163 {
164 kthread_t *t = p->p_tlist;
165
166 return (t == NULL || /* if zombie or ... */
167 (sigismember(&p->p_ignore, sig) && /* signal is ignored */
168 t->t_forw == t && /* and single-threaded */
169 !tracing(p, sig) && /* and no /proc tracing */
170 !signal_is_blocked(t, sig) && /* and signal not blocked */
171 !sigismember(&t->t_sigwait, sig))); /* and not being accepted */
172 }
173
174 /*
175 * Return true if this thread is going to eat this signal soon.
176 * Note that, if the signal is SIGKILL, we force stopped threads to be
177 * set running (to make SIGKILL be a sure kill), but only if the process
178 * is not currently locked by /proc (the P_PR_LOCK flag). Code in /proc
179 * relies on the fact that a process will not change shape while P_PR_LOCK
180 * is set (it drops and reacquires p->p_lock while leaving P_PR_LOCK set).
181 * We wish that we could simply call prbarrier() below, in sigtoproc(), to
182 * ensure that the process is not locked by /proc, but prbarrier() drops
183 * and reacquires p->p_lock and dropping p->p_lock here would be damaging.
184 */
185 int
186 eat_signal(kthread_t *t, int sig)
187 {
188 int rval = 0;
189 ASSERT(THREAD_LOCK_HELD(t));
190
191 /*
192 * Do not do anything if the target thread has the signal blocked.
193 */
194 if (!signal_is_blocked(t, sig)) {
195 t->t_sig_check = 1; /* have thread do an issig */
196 if (ISWAKEABLE(t) || ISWAITING(t)) {
197 setrun_locked(t);
198 rval = 1;
199 } else if (t->t_state == TS_STOPPED && sig == SIGKILL &&
200 !(ttoproc(t)->p_proc_flag & P_PR_LOCK)) {
201 ttoproc(t)->p_stopsig = 0;
202 t->t_dtrace_stop = 0;
203 t->t_schedflag |= TS_XSTART | TS_PSTART;
204 setrun_locked(t);
205 } else if (t != curthread && t->t_state == TS_ONPROC) {
206 aston(t); /* make it do issig promptly */
207 if (t->t_cpu != CPU)
208 poke_cpu(t->t_cpu->cpu_id);
209 rval = 1;
210 } else if (t->t_state == TS_RUN) {
211 rval = 1;
212 }
213 }
214
215 return (rval);
216 }
217
218 /*
219 * Post a signal.
220 * If a non-null thread pointer is passed, then post the signal
221 * to the thread/lwp, otherwise post the signal to the process.
222 */
223 void
224 sigtoproc(proc_t *p, kthread_t *t, int sig)
225 {
226 kthread_t *tt;
227 int ext = !(curproc->p_flag & SSYS) &&
228 (curproc->p_ct_process != p->p_ct_process);
229
230 ASSERT(MUTEX_HELD(&p->p_lock));
231
232 /* System processes don't get signals */
233 if (sig <= 0 || sig >= NSIG || (p->p_flag & SSYS))
234 return;
235
236 /*
237 * Regardless of origin or directedness,
238 * SIGKILL kills all lwps in the process immediately
239 * and jobcontrol signals affect all lwps in the process.
240 */
241 if (sig == SIGKILL) {
242 p->p_flag |= SKILLED | (ext ? SEXTKILLED : 0);
243 t = NULL;
244 } else if (sig == SIGCONT) {
245 /*
246 * The SSCONT flag will remain set until a stopping
247 * signal comes in (below). This is harmless.
248 */
249 p->p_flag |= SSCONT;
250 sigdelq(p, NULL, SIGSTOP);
251 sigdelq(p, NULL, SIGTSTP);
252 sigdelq(p, NULL, SIGTTOU);
253 sigdelq(p, NULL, SIGTTIN);
254 sigdiffset(&p->p_sig, &stopdefault);
255 sigdiffset(&p->p_extsig, &stopdefault);
256 p->p_stopsig = 0;
257 if ((tt = p->p_tlist) != NULL) {
258 do {
259 sigdelq(p, tt, SIGSTOP);
260 sigdelq(p, tt, SIGTSTP);
261 sigdelq(p, tt, SIGTTOU);
262 sigdelq(p, tt, SIGTTIN);
263 sigdiffset(&tt->t_sig, &stopdefault);
264 sigdiffset(&tt->t_extsig, &stopdefault);
265 } while ((tt = tt->t_forw) != p->p_tlist);
266 }
267 if ((tt = p->p_tlist) != NULL) {
268 do {
269 thread_lock(tt);
270 if (tt->t_state == TS_STOPPED &&
271 tt->t_whystop == PR_JOBCONTROL) {
272 tt->t_schedflag |= TS_XSTART;
273 setrun_locked(tt);
274 }
275 thread_unlock(tt);
276 } while ((tt = tt->t_forw) != p->p_tlist);
277 }
278 } else if (sigismember(&stopdefault, sig)) {
279 /*
280 * This test has a race condition which we can't fix:
281 * By the time the stopping signal is received by
282 * the target process/thread, the signal handler
283 * and/or the detached state might have changed.
284 */
285 if (PTOU(p)->u_signal[sig-1] == SIG_DFL &&
286 (sig == SIGSTOP || !p->p_pgidp->pid_pgorphaned))
287 p->p_flag &= ~SSCONT;
288 sigdelq(p, NULL, SIGCONT);
289 sigdelset(&p->p_sig, SIGCONT);
290 sigdelset(&p->p_extsig, SIGCONT);
291 if ((tt = p->p_tlist) != NULL) {
292 do {
293 sigdelq(p, tt, SIGCONT);
294 sigdelset(&tt->t_sig, SIGCONT);
295 sigdelset(&tt->t_extsig, SIGCONT);
296 } while ((tt = tt->t_forw) != p->p_tlist);
297 }
298 }
299
300 if (sig_discardable(p, sig)) {
301 DTRACE_PROC3(signal__discard, kthread_t *, p->p_tlist,
302 proc_t *, p, int, sig);
303 return;
304 }
305
306 if (t != NULL) {
307 /*
308 * This is a directed signal, wake up the lwp.
309 */
310 sigaddset(&t->t_sig, sig);
311 if (ext)
312 sigaddset(&t->t_extsig, sig);
313 thread_lock(t);
314 (void) eat_signal(t, sig);
315 thread_unlock(t);
316 DTRACE_PROC2(signal__send, kthread_t *, t, int, sig);
317 if (p->p_sigfd != NULL && ((sigfd_proc_state_t *)
318 (p->p_sigfd))->sigfd_pollwake_cb != NULL)
319 (*((sigfd_proc_state_t *)(p->p_sigfd))->
320 sigfd_pollwake_cb)(p, sig);
321
322 } else if ((tt = p->p_tlist) != NULL) {
323 /*
324 * Make sure that some lwp that already exists
325 * in the process fields the signal soon.
326 * Wake up an interruptibly sleeping lwp if necessary.
327 * For SIGKILL make all of the lwps see the signal;
328 * This is needed to guarantee a sure kill for processes
329 * with a mix of realtime and non-realtime threads.
330 */
331 int su = 0;
332
333 sigaddset(&p->p_sig, sig);
334 if (ext)
335 sigaddset(&p->p_extsig, sig);
336 do {
337 thread_lock(tt);
338 if (eat_signal(tt, sig) && sig != SIGKILL) {
339 thread_unlock(tt);
340 break;
341 }
342 if (SUSPENDED(tt))
343 su++;
344 thread_unlock(tt);
345 } while ((tt = tt->t_forw) != p->p_tlist);
346 /*
347 * If the process is deadlocked, make somebody run and die.
348 */
349 if (sig == SIGKILL && p->p_stat != SIDL &&
350 p->p_lwprcnt == 0 && p->p_lwpcnt == su &&
351 !(p->p_proc_flag & P_PR_LOCK)) {
352 thread_lock(tt);
353 p->p_lwprcnt++;
354 tt->t_schedflag |= TS_CSTART;
355 setrun_locked(tt);
356 thread_unlock(tt);
357 }
358
359 DTRACE_PROC2(signal__send, kthread_t *, tt, int, sig);
360 if (p->p_sigfd != NULL && ((sigfd_proc_state_t *)
361 (p->p_sigfd))->sigfd_pollwake_cb != NULL)
362 (*((sigfd_proc_state_t *)(p->p_sigfd))->
363 sigfd_pollwake_cb)(p, sig);
364 }
365 }
366
367 static int
368 isjobstop(int sig)
369 {
370 proc_t *p = ttoproc(curthread);
371
372 ASSERT(MUTEX_HELD(&p->p_lock));
373
374 if (PTOU(curproc)->u_signal[sig-1] == SIG_DFL &&
375 sigismember(&stopdefault, sig)) {
376 /*
377 * If SIGCONT has been posted since we promoted this signal
378 * from pending to current, then don't do a jobcontrol stop.
379 */
380 if (!(p->p_flag & SSCONT) &&
381 (sig == SIGSTOP || !p->p_pgidp->pid_pgorphaned) &&
382 curthread != p->p_agenttp) {
383 sigqueue_t *sqp;
384
385 stop(PR_JOBCONTROL, sig);
386 mutex_exit(&p->p_lock);
387 sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);
388 mutex_enter(&pidlock);
389 /*
390 * Only the first lwp to continue notifies the parent.
391 */
392 if (p->p_pidflag & CLDCONT)
393 siginfofree(sqp);
394 else {
395 p->p_pidflag |= CLDCONT;
396 p->p_wcode = CLD_CONTINUED;
397 p->p_wdata = SIGCONT;
398 sigcld(p, sqp);
399 }
400 mutex_exit(&pidlock);
401 mutex_enter(&p->p_lock);
402 }
403 return (1);
404 }
405 return (0);
406 }
407
408 /*
409 * Returns true if the current process has a signal to process, and
410 * the signal is not held. The signal to process is put in p_cursig.
411 * This is asked at least once each time a process enters the system
412 * (though this can usually be done without actually calling issig by
413 * checking the pending signal masks). A signal does not do anything
414 * directly to a process; it sets a flag that asks the process to do
415 * something to itself.
416 *
417 * The "why" argument indicates the allowable side-effects of the call:
418 *
419 * FORREAL: Extract the next pending signal from p_sig into p_cursig;
420 * stop the process if a stop has been requested or if a traced signal
421 * is pending.
422 *
423 * JUSTLOOKING: Don't stop the process, just indicate whether or not
424 * a signal might be pending (FORREAL is needed to tell for sure).
425 *
426 * XXX: Changes to the logic in these routines should be propagated
427 * to lm_sigispending(). See bug 1201594.
428 */
429
430 static int issig_forreal(void);
431 static int issig_justlooking(void);
432
433 int
434 issig(int why)
435 {
436 ASSERT(why == FORREAL || why == JUSTLOOKING);
437
438 return ((why == FORREAL)? issig_forreal() : issig_justlooking());
439 }
440
441
442 static int
443 issig_justlooking(void)
444 {
445 kthread_t *t = curthread;
446 klwp_t *lwp = ttolwp(t);
447 proc_t *p = ttoproc(t);
448 k_sigset_t set;
449
450 /*
451 * This function answers the question:
452 * "Is there any reason to call issig_forreal()?"
453 *
454 * We have to answer the question w/o grabbing any locks
455 * because we are (most likely) being called after we
456 * put ourselves on the sleep queue.
457 */
458
459 if (t->t_dtrace_stop | t->t_dtrace_sig)
460 return (1);
461
462 /*
463 * Another piece of complexity in this process. When single-stepping a
464 * process, we don't want an intervening signal or TP_PAUSE request to
465 * suspend the current thread. Otherwise, the controlling process will
466 * hang beacuse we will be stopped with TS_PSTART set in t_schedflag.
467 * We will trigger any remaining signals when we re-enter the kernel on
468 * the single step trap.
469 */
470 if (lwp->lwp_pcb.pcb_flags & NORMAL_STEP)
471 return (0);
472
473 if ((lwp->lwp_asleep && MUSTRETURN(p, t)) ||
474 (p->p_flag & (SEXITLWPS|SKILLED)) ||
475 (lwp->lwp_nostop == 0 &&
476 (p->p_stopsig | (p->p_flag & (SHOLDFORK1|SHOLDWATCH)) |
477 (t->t_proc_flag &
478 (TP_PRSTOP|TP_HOLDLWP|TP_CHKPT|TP_PAUSE)))) ||
479 lwp->lwp_cursig)
480 return (1);
481
482 if (p->p_flag & SVFWAIT)
483 return (0);
484 set = p->p_sig;
485 sigorset(&set, &t->t_sig);
486 if (schedctl_sigblock(t)) /* all blockable signals blocked */
487 sigandset(&set, &cantmask);
488 else
489 sigdiffset(&set, &t->t_hold);
490 if (p->p_flag & SVFORK)
491 sigdiffset(&set, &holdvfork);
492
493 if (!sigisempty(&set)) {
494 int sig;
495
496 for (sig = 1; sig < NSIG; sig++) {
497 if (sigismember(&set, sig) &&
498 (tracing(p, sig) ||
499 sigismember(&t->t_sigwait, sig) ||
500 !sigismember(&p->p_ignore, sig))) {
501 /*
502 * Don't promote a signal that will stop
503 * the process when lwp_nostop is set.
504 */
505 if (!lwp->lwp_nostop ||
506 PTOU(p)->u_signal[sig-1] != SIG_DFL ||
507 !sigismember(&stopdefault, sig))
508 return (1);
509 }
510 }
511 }
512
513 return (0);
514 }
515
516 static int
517 issig_forreal(void)
518 {
519 int sig = 0, ext = 0;
520 kthread_t *t = curthread;
521 klwp_t *lwp = ttolwp(t);
522 proc_t *p = ttoproc(t);
523 int toproc = 0;
524 int sigcld_found = 0;
525 int nostop_break = 0;
526
527 ASSERT(t->t_state == TS_ONPROC);
528
529 mutex_enter(&p->p_lock);
530 schedctl_finish_sigblock(t);
531
532 if (t->t_dtrace_stop | t->t_dtrace_sig) {
533 if (t->t_dtrace_stop) {
534 /*
535 * If DTrace's "stop" action has been invoked on us,
536 * set TP_PRSTOP.
537 */
538 t->t_proc_flag |= TP_PRSTOP;
539 }
540
541 if (t->t_dtrace_sig != 0) {
542 k_siginfo_t info;
543
544 /*
545 * Post the signal generated as the result of
546 * DTrace's "raise" action as a normal signal before
547 * the full-fledged signal checking begins.
548 */
549 bzero(&info, sizeof (info));
550 info.si_signo = t->t_dtrace_sig;
551 info.si_code = SI_DTRACE;
552
553 sigaddq(p, NULL, &info, KM_NOSLEEP);
554
555 t->t_dtrace_sig = 0;
556 }
557 }
558
559 for (;;) {
560 if (p->p_flag & (SEXITLWPS|SKILLED)) {
561 lwp->lwp_cursig = sig = SIGKILL;
562 lwp->lwp_extsig = ext = (p->p_flag & SEXTKILLED) != 0;
563 t->t_sig_check = 1;
564 break;
565 }
566
567 /*
568 * Another piece of complexity in this process. When
569 * single-stepping a process, we don't want an intervening
570 * signal or TP_PAUSE request to suspend the current thread.
571 * Otherwise, the controlling process will hang beacuse we will
572 * be stopped with TS_PSTART set in t_schedflag. We will
573 * trigger any remaining signals when we re-enter the kernel on
574 * the single step trap.
575 */
576 if (lwp->lwp_pcb.pcb_flags & NORMAL_STEP) {
577 sig = 0;
578 break;
579 }
580
581 /*
582 * Hold the lwp here for watchpoint manipulation.
583 */
584 if ((t->t_proc_flag & TP_PAUSE) && !lwp->lwp_nostop) {
585 stop(PR_SUSPENDED, SUSPEND_PAUSE);
586 continue;
587 }
588
589 if (lwp->lwp_asleep && MUSTRETURN(p, t)) {
590 if ((sig = lwp->lwp_cursig) != 0) {
591 /*
592 * Make sure we call ISSIG() in post_syscall()
593 * to re-validate this current signal.
594 */
595 t->t_sig_check = 1;
596 }
597 break;
598 }
599
600 /*
601 * If the request is PR_CHECKPOINT, ignore the rest of signals
602 * or requests. Honor other stop requests or signals later.
603 * Go back to top of loop here to check if an exit or hold
604 * event has occurred while stopped.
605 */
606 if ((t->t_proc_flag & TP_CHKPT) && !lwp->lwp_nostop) {
607 stop(PR_CHECKPOINT, 0);
608 continue;
609 }
610
611 /*
612 * Honor SHOLDFORK1, SHOLDWATCH, and TP_HOLDLWP before dealing
613 * with signals or /proc. Another lwp is executing fork1(),
614 * or is undergoing watchpoint activity (remapping a page),
615 * or is executing lwp_suspend() on this lwp.
616 * Again, go back to top of loop to check if an exit
617 * or hold event has occurred while stopped.
618 */
619 if (((p->p_flag & (SHOLDFORK1|SHOLDWATCH)) ||
620 (t->t_proc_flag & TP_HOLDLWP)) && !lwp->lwp_nostop) {
621 stop(PR_SUSPENDED, SUSPEND_NORMAL);
622 continue;
623 }
624
625 /*
626 * Honor requested stop before dealing with the
627 * current signal; a debugger may change it.
628 * Do not want to go back to loop here since this is a special
629 * stop that means: make incremental progress before the next
630 * stop. The danger is that returning to top of loop would most
631 * likely drop the thread right back here to stop soon after it
632 * was continued, violating the incremental progress request.
633 */
634 if ((t->t_proc_flag & TP_PRSTOP) && !lwp->lwp_nostop)
635 stop(PR_REQUESTED, 0);
636
637 /*
638 * If a debugger wants us to take a signal it will have
639 * left it in lwp->lwp_cursig. If lwp_cursig has been cleared
640 * or if it's being ignored, we continue on looking for another
641 * signal. Otherwise we return the specified signal, provided
642 * it's not a signal that causes a job control stop.
643 *
644 * When stopped on PR_JOBCONTROL, there is no current
645 * signal; we cancel lwp->lwp_cursig temporarily before
646 * calling isjobstop(). The current signal may be reset
647 * by a debugger while we are stopped in isjobstop().
648 *
649 * If the current thread is accepting the signal
650 * (via sigwait(), sigwaitinfo(), or sigtimedwait()),
651 * we allow the signal to be accepted, even if it is
652 * being ignored, and without causing a job control stop.
653 */
654 if ((sig = lwp->lwp_cursig) != 0) {
655 ext = lwp->lwp_extsig;
656 lwp->lwp_cursig = 0;
657 lwp->lwp_extsig = 0;
658 if (sigismember(&t->t_sigwait, sig) ||
659 (!sigismember(&p->p_ignore, sig) &&
660 !isjobstop(sig))) {
661 if (p->p_flag & (SEXITLWPS|SKILLED)) {
662 sig = SIGKILL;
663 ext = (p->p_flag & SEXTKILLED) != 0;
664 }
665 lwp->lwp_cursig = (uchar_t)sig;
666 lwp->lwp_extsig = (uchar_t)ext;
667 break;
668 }
669 /*
670 * The signal is being ignored or it caused a
671 * job-control stop. If another current signal
672 * has not been established, return the current
673 * siginfo, if any, to the memory manager.
674 */
675 if (lwp->lwp_cursig == 0 && lwp->lwp_curinfo != NULL) {
676 siginfofree(lwp->lwp_curinfo);
677 lwp->lwp_curinfo = NULL;
678 }
679 /*
680 * Loop around again in case we were stopped
681 * on a job control signal and a /proc stop
682 * request was posted or another current signal
683 * was established while we were stopped.
684 */
685 continue;
686 }
687
688 if (p->p_stopsig && !lwp->lwp_nostop &&
689 curthread != p->p_agenttp) {
690 /*
691 * Some lwp in the process has already stopped
692 * showing PR_JOBCONTROL. This is a stop in
693 * sympathy with the other lwp, even if this
694 * lwp is blocking the stopping signal.
695 */
696 stop(PR_JOBCONTROL, p->p_stopsig);
697 continue;
698 }
699
700 /*
701 * Loop on the pending signals until we find a
702 * non-held signal that is traced or not ignored.
703 * First check the signals pending for the lwp,
704 * then the signals pending for the process as a whole.
705 */
706 for (;;) {
707 if ((sig = fsig(&t->t_sig, t)) != 0) {
708 toproc = 0;
709 if (tracing(p, sig) ||
710 sigismember(&t->t_sigwait, sig) ||
711 !sigismember(&p->p_ignore, sig)) {
712 if (sigismember(&t->t_extsig, sig))
713 ext = 1;
714 break;
715 }
716 sigdelset(&t->t_sig, sig);
717 sigdelset(&t->t_extsig, sig);
718 sigdelq(p, t, sig);
719 } else if ((sig = fsig(&p->p_sig, t)) != 0) {
720 if (sig == SIGCLD)
721 sigcld_found = 1;
722 toproc = 1;
723 if (tracing(p, sig) ||
724 sigismember(&t->t_sigwait, sig) ||
725 !sigismember(&p->p_ignore, sig)) {
726 if (sigismember(&p->p_extsig, sig))
727 ext = 1;
728 break;
729 }
730 sigdelset(&p->p_sig, sig);
731 sigdelset(&p->p_extsig, sig);
732 sigdelq(p, NULL, sig);
733 } else {
734 /* no signal was found */
735 break;
736 }
737 }
738
739 if (sig == 0) { /* no signal was found */
740 if (p->p_flag & (SEXITLWPS|SKILLED)) {
741 lwp->lwp_cursig = SIGKILL;
742 sig = SIGKILL;
743 ext = (p->p_flag & SEXTKILLED) != 0;
744 }
745 break;
746 }
747
748 /*
749 * If we have been informed not to stop (i.e., we are being
750 * called from within a network operation), then don't promote
751 * the signal at this time, just return the signal number.
752 * We will call issig() again later when it is safe.
753 *
754 * fsig() does not return a jobcontrol stopping signal
755 * with a default action of stopping the process if
756 * lwp_nostop is set, so we won't be causing a bogus
757 * EINTR by this action. (Such a signal is eaten by
758 * isjobstop() when we loop around to do final checks.)
759 */
760 if (lwp->lwp_nostop) {
761 nostop_break = 1;
762 break;
763 }
764
765 /*
766 * Promote the signal from pending to current.
767 *
768 * Note that sigdeq() will set lwp->lwp_curinfo to NULL
769 * if no siginfo_t exists for this signal.
770 */
771 lwp->lwp_cursig = (uchar_t)sig;
772 lwp->lwp_extsig = (uchar_t)ext;
773 t->t_sig_check = 1; /* so post_syscall will see signal */
774 ASSERT(lwp->lwp_curinfo == NULL);
775 sigdeq(p, toproc ? NULL : t, sig, &lwp->lwp_curinfo);
776
777 if (tracing(p, sig))
778 stop(PR_SIGNALLED, sig);
779
780 /*
781 * Loop around to check for requested stop before
782 * performing the usual current-signal actions.
783 */
784 }
785
786 mutex_exit(&p->p_lock);
787
788 /*
789 * If SIGCLD was dequeued from the process's signal queue,
790 * search for other pending SIGCLD's from the list of children.
791 */
792 if (sigcld_found)
793 sigcld_repost();
794
795 if (sig != 0)
796 (void) undo_watch_step(NULL);
797
798 /*
799 * If we have been blocked since the p_lock was dropped off
800 * above, then this promoted signal might have been handled
801 * already when we were on the way back from sleep queue, so
802 * just ignore it.
803 * If we have been informed not to stop, just return the signal
804 * number. Also see comments above.
805 */
806 if (!nostop_break) {
807 sig = lwp->lwp_cursig;
808 }
809
810 return (sig != 0);
811 }
812
813 /*
814 * Return true if the process is currently stopped showing PR_JOBCONTROL.
815 * This is true only if all of the process's lwp's are so stopped.
816 * If this is asked by one of the lwps in the process, exclude that lwp.
817 */
818 int
819 jobstopped(proc_t *p)
820 {
821 kthread_t *t;
822
823 ASSERT(MUTEX_HELD(&p->p_lock));
824
825 if ((t = p->p_tlist) == NULL)
826 return (0);
827
828 do {
829 thread_lock(t);
830 /* ignore current, zombie and suspended lwps in the test */
831 if (!(t == curthread || t->t_state == TS_ZOMB ||
832 SUSPENDED(t)) &&
833 (t->t_state != TS_STOPPED ||
834 t->t_whystop != PR_JOBCONTROL)) {
835 thread_unlock(t);
836 return (0);
837 }
838 thread_unlock(t);
839 } while ((t = t->t_forw) != p->p_tlist);
840
841 return (1);
842 }
843
844 /*
845 * Put ourself (curthread) into the stopped state and notify tracers.
846 */
847 void
848 stop(int why, int what)
849 {
850 kthread_t *t = curthread;
851 proc_t *p = ttoproc(t);
852 klwp_t *lwp = ttolwp(t);
853 kthread_t *tx;
854 lwpent_t *lep;
855 int procstop;
856 int flags = TS_ALLSTART;
857 hrtime_t stoptime;
858
859 /*
860 * Can't stop a system process.
861 */
862 if (p == NULL || lwp == NULL || (p->p_flag & SSYS) || p->p_as == &kas)
863 return;
864
865 ASSERT(MUTEX_HELD(&p->p_lock));
866
867 if (why != PR_SUSPENDED && why != PR_CHECKPOINT) {
868 /*
869 * Don't stop an lwp with SIGKILL pending.
870 * Don't stop if the process or lwp is exiting.
871 */
872 if (lwp->lwp_cursig == SIGKILL ||
873 sigismember(&t->t_sig, SIGKILL) ||
874 sigismember(&p->p_sig, SIGKILL) ||
875 (t->t_proc_flag & TP_LWPEXIT) ||
876 (p->p_flag & (SEXITLWPS|SKILLED))) {
877 p->p_stopsig = 0;
878 t->t_proc_flag &= ~(TP_PRSTOP|TP_PRVSTOP);
879 return;
880 }
881 }
882
883 /*
884 * Make sure we don't deadlock on a recursive call to prstop().
885 * prstop() sets the lwp_nostop flag.
886 */
887 if (lwp->lwp_nostop)
888 return;
889
890 /*
891 * Make sure the lwp is in an orderly state for inspection
892 * by a debugger through /proc or for dumping via core().
893 */
894 schedctl_finish_sigblock(t);
895 t->t_proc_flag |= TP_STOPPING; /* must set before dropping p_lock */
896 mutex_exit(&p->p_lock);
897 stoptime = gethrtime();
898 prstop(why, what);
899 (void) undo_watch_step(NULL);
900 mutex_enter(&p->p_lock);
901 ASSERT(t->t_state == TS_ONPROC);
902
903 switch (why) {
904 case PR_CHECKPOINT:
905 /*
906 * The situation may have changed since we dropped
907 * and reacquired p->p_lock. Double-check now
908 * whether we should stop or not.
909 */
910 if (!(t->t_proc_flag & TP_CHKPT)) {
911 t->t_proc_flag &= ~TP_STOPPING;
912 return;
913 }
914 t->t_proc_flag &= ~TP_CHKPT;
915 flags &= ~TS_RESUME;
916 break;
917
918 case PR_JOBCONTROL:
919 ASSERT(what == SIGSTOP || what == SIGTSTP ||
920 what == SIGTTIN || what == SIGTTOU);
921 flags &= ~TS_XSTART;
922 break;
923
924 case PR_SUSPENDED:
925 ASSERT(what == SUSPEND_NORMAL || what == SUSPEND_PAUSE);
926 /*
927 * The situation may have changed since we dropped
928 * and reacquired p->p_lock. Double-check now
929 * whether we should stop or not.
930 */
931 if (what == SUSPEND_PAUSE) {
932 if (!(t->t_proc_flag & TP_PAUSE)) {
933 t->t_proc_flag &= ~TP_STOPPING;
934 return;
935 }
936 flags &= ~TS_UNPAUSE;
937 } else {
938 if (!((t->t_proc_flag & TP_HOLDLWP) ||
939 (p->p_flag & (SHOLDFORK|SHOLDFORK1|SHOLDWATCH)))) {
940 t->t_proc_flag &= ~TP_STOPPING;
941 return;
942 }
943 /*
944 * If SHOLDFORK is in effect and we are stopping
945 * while asleep (not at the top of the stack),
946 * we return now to allow the hold to take effect
947 * when we reach the top of the kernel stack.
948 */
949 if (lwp->lwp_asleep && (p->p_flag & SHOLDFORK)) {
950 t->t_proc_flag &= ~TP_STOPPING;
951 return;
952 }
953 flags &= ~TS_CSTART;
954 }
955 break;
956
957 default: /* /proc stop */
958 flags &= ~TS_PSTART;
959 /*
960 * Do synchronous stop unless the async-stop flag is set.
961 * If why is PR_REQUESTED and t->t_dtrace_stop flag is set,
962 * then no debugger is present and we also do synchronous stop.
963 */
964 if ((why != PR_REQUESTED || t->t_dtrace_stop) &&
965 !(p->p_proc_flag & P_PR_ASYNC)) {
966 int notify;
967
968 for (tx = t->t_forw; tx != t; tx = tx->t_forw) {
969 notify = 0;
970 thread_lock(tx);
971 if (ISTOPPED(tx) ||
972 (tx->t_proc_flag & TP_PRSTOP)) {
973 thread_unlock(tx);
974 continue;
975 }
976 tx->t_proc_flag |= TP_PRSTOP;
977 tx->t_sig_check = 1;
978 if (tx->t_state == TS_SLEEP &&
979 (tx->t_flag & T_WAKEABLE)) {
980 /*
981 * Don't actually wake it up if it's
982 * in one of the lwp_*() syscalls.
983 * Mark it virtually stopped and
984 * notify /proc waiters (below).
985 */
986 if (tx->t_wchan0 == NULL)
987 setrun_locked(tx);
988 else {
989 tx->t_proc_flag |= TP_PRVSTOP;
990 tx->t_stoptime = stoptime;
991 notify = 1;
992 }
993 }
994
995 /* Move waiting thread to run queue */
996 if (ISWAITING(tx))
997 setrun_locked(tx);
998
999 /*
1000 * force the thread into the kernel
1001 * if it is not already there.
1002 */
1003 if (tx->t_state == TS_ONPROC &&
1004 tx->t_cpu != CPU)
1005 poke_cpu(tx->t_cpu->cpu_id);
1006 thread_unlock(tx);
1007 lep = p->p_lwpdir[tx->t_dslot].ld_entry;
1008 if (notify && lep->le_trace)
1009 prnotify(lep->le_trace);
1010 }
1011 /*
1012 * We do this just in case one of the threads we asked
1013 * to stop is in holdlwps() (called from cfork()) or
1014 * lwp_suspend().
1015 */
1016 cv_broadcast(&p->p_holdlwps);
1017 }
1018 break;
1019 }
1020
1021 t->t_stoptime = stoptime;
1022
1023 if (why == PR_JOBCONTROL || (why == PR_SUSPENDED && p->p_stopsig)) {
1024 /*
1025 * Determine if the whole process is jobstopped.
1026 */
1027 if (jobstopped(p)) {
1028 sigqueue_t *sqp;
1029 int sig;
1030
1031 if ((sig = p->p_stopsig) == 0)
1032 p->p_stopsig = (uchar_t)(sig = what);
1033 mutex_exit(&p->p_lock);
1034 sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);
1035 mutex_enter(&pidlock);
1036 /*
1037 * The last lwp to stop notifies the parent.
1038 * Turn off the CLDCONT flag now so the first
1039 * lwp to continue knows what to do.
1040 */
1041 p->p_pidflag &= ~CLDCONT;
1042 p->p_wcode = CLD_STOPPED;
1043 p->p_wdata = sig;
1044 sigcld(p, sqp);
1045 /*
1046 * Grab p->p_lock before releasing pidlock so the
1047 * parent and the child don't have a race condition.
1048 */
1049 mutex_enter(&p->p_lock);
1050 mutex_exit(&pidlock);
1051 p->p_stopsig = 0;
1052 } else if (why == PR_JOBCONTROL && p->p_stopsig == 0) {
1053 /*
1054 * Set p->p_stopsig and wake up sleeping lwps
1055 * so they will stop in sympathy with this lwp.
1056 */
1057 p->p_stopsig = (uchar_t)what;
1058 pokelwps(p);
1059 /*
1060 * We do this just in case one of the threads we asked
1061 * to stop is in holdlwps() (called from cfork()) or
1062 * lwp_suspend().
1063 */
1064 cv_broadcast(&p->p_holdlwps);
1065 }
1066 }
1067
1068 if (why != PR_JOBCONTROL && why != PR_CHECKPOINT) {
1069 /*
1070 * Do process-level notification when all lwps are
1071 * either stopped on events of interest to /proc
1072 * or are stopped showing PR_SUSPENDED or are zombies.
1073 */
1074 procstop = 1;
1075 for (tx = t->t_forw; procstop && tx != t; tx = tx->t_forw) {
1076 if (VSTOPPED(tx))
1077 continue;
1078 thread_lock(tx);
1079 switch (tx->t_state) {
1080 case TS_ZOMB:
1081 break;
1082 case TS_STOPPED:
1083 /* neither ISTOPPED nor SUSPENDED? */
1084 if ((tx->t_schedflag &
1085 (TS_CSTART | TS_UNPAUSE | TS_PSTART)) ==
1086 (TS_CSTART | TS_UNPAUSE | TS_PSTART))
1087 procstop = 0;
1088 break;
1089 case TS_SLEEP:
1090 /* not paused for watchpoints? */
1091 if (!(tx->t_flag & T_WAKEABLE) ||
1092 tx->t_wchan0 == NULL ||
1093 !(tx->t_proc_flag & TP_PAUSE))
1094 procstop = 0;
1095 break;
1096 default:
1097 procstop = 0;
1098 break;
1099 }
1100 thread_unlock(tx);
1101 }
1102 if (procstop) {
1103 /* there must not be any remapped watched pages now */
1104 ASSERT(p->p_mapcnt == 0);
1105 if (p->p_proc_flag & P_PR_PTRACE) {
1106 /* ptrace() compatibility */
1107 mutex_exit(&p->p_lock);
1108 mutex_enter(&pidlock);
1109 p->p_wcode = CLD_TRAPPED;
1110 p->p_wdata = (why == PR_SIGNALLED)?
1111 what : SIGTRAP;
1112 cv_broadcast(&p->p_parent->p_cv);
1113 /*
1114 * Grab p->p_lock before releasing pidlock so
1115 * parent and child don't have a race condition.
1116 */
1117 mutex_enter(&p->p_lock);
1118 mutex_exit(&pidlock);
1119 }
1120 if (p->p_trace) /* /proc */
1121 prnotify(p->p_trace);
1122 cv_broadcast(&pr_pid_cv[p->p_slot]); /* pauselwps() */
1123 cv_broadcast(&p->p_holdlwps); /* holdwatch() */
1124 }
1125 if (why != PR_SUSPENDED) {
1126 lep = p->p_lwpdir[t->t_dslot].ld_entry;
1127 if (lep->le_trace) /* /proc */
1128 prnotify(lep->le_trace);
1129 /*
1130 * Special notification for creation of the agent lwp.
1131 */
1132 if (t == p->p_agenttp &&
1133 (t->t_proc_flag & TP_PRSTOP) &&
1134 p->p_trace)
1135 prnotify(p->p_trace);
1136 /*
1137 * The situation may have changed since we dropped
1138 * and reacquired p->p_lock. Double-check now
1139 * whether we should stop or not.
1140 */
1141 if (!(t->t_proc_flag & TP_STOPPING)) {
1142 if (t->t_proc_flag & TP_PRSTOP)
1143 t->t_proc_flag |= TP_STOPPING;
1144 }
1145 t->t_proc_flag &= ~(TP_PRSTOP|TP_PRVSTOP);
1146 prnostep(lwp);
1147 }
1148 }
1149
1150 if (why == PR_SUSPENDED) {
1151
1152 /*
1153 * We always broadcast in the case of SUSPEND_PAUSE. This is
1154 * because checks for TP_PAUSE take precedence over checks for
1155 * SHOLDWATCH. If a thread is trying to stop because of
1156 * SUSPEND_PAUSE and tries to do a holdwatch(), it will be
1157 * waiting for the rest of the threads to enter a stopped state.
1158 * If we are stopping for a SUSPEND_PAUSE, we may be the last
1159 * lwp and not know it, so broadcast just in case.
1160 */
1161 if (what == SUSPEND_PAUSE ||
1162 --p->p_lwprcnt == 0 || (t->t_proc_flag & TP_HOLDLWP))
1163 cv_broadcast(&p->p_holdlwps);
1164
1165 }
1166
1167 /*
1168 * Need to do this here (rather than after the thread is officially
1169 * stopped) because we can't call mutex_enter from a stopped thread.
1170 */
1171 if (why == PR_CHECKPOINT)
1172 del_one_utstop();
1173
1174 thread_lock(t);
1175 ASSERT((t->t_schedflag & TS_ALLSTART) == 0);
1176 t->t_schedflag |= flags;
1177 t->t_whystop = (short)why;
1178 t->t_whatstop = (short)what;
1179 CL_STOP(t, why, what);
1180 (void) new_mstate(t, LMS_STOPPED);
1181 thread_stop(t); /* set stop state and drop lock */
1182
1183 if (why != PR_SUSPENDED && why != PR_CHECKPOINT) {
1184 /*
1185 * We may have gotten a SIGKILL or a SIGCONT when
1186 * we released p->p_lock; make one last check.
1187 * Also check for a /proc run-on-last-close.
1188 */
1189 if (sigismember(&t->t_sig, SIGKILL) ||
1190 sigismember(&p->p_sig, SIGKILL) ||
1191 (t->t_proc_flag & TP_LWPEXIT) ||
1192 (p->p_flag & (SEXITLWPS|SKILLED))) {
1193 p->p_stopsig = 0;
1194 thread_lock(t);
1195 t->t_schedflag |= TS_XSTART | TS_PSTART;
1196 setrun_locked(t);
1197 thread_unlock_nopreempt(t);
1198 } else if (why == PR_JOBCONTROL) {
1199 if (p->p_flag & SSCONT) {
1200 /*
1201 * This resulted from a SIGCONT posted
1202 * while we were not holding p->p_lock.
1203 */
1204 p->p_stopsig = 0;
1205 thread_lock(t);
1206 t->t_schedflag |= TS_XSTART;
1207 setrun_locked(t);
1208 thread_unlock_nopreempt(t);
1209 }
1210 } else if (!(t->t_proc_flag & TP_STOPPING)) {
1211 /*
1212 * This resulted from a /proc run-on-last-close.
1213 */
1214 thread_lock(t);
1215 t->t_schedflag |= TS_PSTART;
1216 setrun_locked(t);
1217 thread_unlock_nopreempt(t);
1218 }
1219 }
1220
1221 t->t_proc_flag &= ~TP_STOPPING;
1222 mutex_exit(&p->p_lock);
1223
1224 swtch();
1225 setallwatch(); /* reestablish any watchpoints set while stopped */
1226 mutex_enter(&p->p_lock);
1227 prbarrier(p); /* barrier against /proc locking */
1228 }
1229
1230 /* Interface for resetting user thread stop count. */
1231 void
1232 utstop_init(void)
1233 {
1234 mutex_enter(&thread_stop_lock);
1235 num_utstop = 0;
1236 mutex_exit(&thread_stop_lock);
1237 }
1238
1239 /* Interface for registering a user thread stop request. */
1240 void
1241 add_one_utstop(void)
1242 {
1243 mutex_enter(&thread_stop_lock);
1244 num_utstop++;
1245 mutex_exit(&thread_stop_lock);
1246 }
1247
1248 /* Interface for cancelling a user thread stop request */
1249 void
1250 del_one_utstop(void)
1251 {
1252 mutex_enter(&thread_stop_lock);
1253 num_utstop--;
1254 if (num_utstop == 0)
1255 cv_broadcast(&utstop_cv);
1256 mutex_exit(&thread_stop_lock);
1257 }
1258
1259 /* Interface to wait for all user threads to be stopped */
1260 void
1261 utstop_timedwait(clock_t ticks)
1262 {
1263 mutex_enter(&thread_stop_lock);
1264 if (num_utstop > 0)
1265 (void) cv_reltimedwait(&utstop_cv, &thread_stop_lock, ticks,
1266 TR_CLOCK_TICK);
1267 mutex_exit(&thread_stop_lock);
1268 }
1269
1270 /*
1271 * Perform the action specified by the current signal.
1272 * The usual sequence is:
1273 * if (issig())
1274 * psig();
1275 * The signal bit has already been cleared by issig(),
1276 * the current signal number has been stored in lwp_cursig,
1277 * and the current siginfo is now referenced by lwp_curinfo.
1278 */
1279 void
1280 psig(void)
1281 {
1282 kthread_t *t = curthread;
1283 proc_t *p = ttoproc(t);
1284 klwp_t *lwp = ttolwp(t);
1285 void (*func)();
1286 int sig, rc, code, ext;
1287 pid_t pid = -1;
1288 id_t ctid = 0;
1289 zoneid_t zoneid = -1;
1290 sigqueue_t *sqp = NULL;
1291 uint32_t auditing = AU_AUDITING();
1292
1293 mutex_enter(&p->p_lock);
1294 schedctl_finish_sigblock(t);
1295 code = CLD_KILLED;
1296
1297 if (p->p_flag & SEXITLWPS) {
1298 lwp_exit();
1299 return; /* not reached */
1300 }
1301 sig = lwp->lwp_cursig;
1302 ext = lwp->lwp_extsig;
1303
1304 ASSERT(sig < NSIG);
1305
1306 /*
1307 * Re-check lwp_cursig after we acquire p_lock. Since p_lock was
1308 * dropped between issig() and psig(), a debugger may have cleared
1309 * lwp_cursig via /proc in the intervening window.
1310 */
1311 if (sig == 0) {
1312 if (lwp->lwp_curinfo) {
1313 siginfofree(lwp->lwp_curinfo);
1314 lwp->lwp_curinfo = NULL;
1315 }
1316 if (t->t_flag & T_TOMASK) { /* sigsuspend or pollsys */
1317 t->t_flag &= ~T_TOMASK;
1318 t->t_hold = lwp->lwp_sigoldmask;
1319 }
1320 mutex_exit(&p->p_lock);
1321 return;
1322 }
1323 func = PTOU(curproc)->u_signal[sig-1];
1324
1325 /*
1326 * The signal disposition could have changed since we promoted
1327 * this signal from pending to current (we dropped p->p_lock).
1328 * This can happen only in a multi-threaded process.
1329 */
1330 if (sigismember(&p->p_ignore, sig) ||
1331 (func == SIG_DFL && sigismember(&stopdefault, sig))) {
1332 lwp->lwp_cursig = 0;
1333 lwp->lwp_extsig = 0;
1334 if (lwp->lwp_curinfo) {
1335 siginfofree(lwp->lwp_curinfo);
1336 lwp->lwp_curinfo = NULL;
1337 }
1338 if (t->t_flag & T_TOMASK) { /* sigsuspend or pollsys */
1339 t->t_flag &= ~T_TOMASK;
1340 t->t_hold = lwp->lwp_sigoldmask;
1341 }
1342 mutex_exit(&p->p_lock);
1343 return;
1344 }
1345
1346 /*
1347 * We check lwp_curinfo first since pr_setsig can actually
1348 * stuff a sigqueue_t there for SIGKILL.
1349 */
1350 if (lwp->lwp_curinfo) {
1351 sqp = lwp->lwp_curinfo;
1352 } else if (sig == SIGKILL && p->p_killsqp) {
1353 sqp = p->p_killsqp;
1354 }
1355
1356 if (sqp != NULL) {
1357 if (SI_FROMUSER(&sqp->sq_info)) {
1358 pid = sqp->sq_info.si_pid;
1359 ctid = sqp->sq_info.si_ctid;
1360 zoneid = sqp->sq_info.si_zoneid;
1361 }
1362 /*
1363 * If we have a sigqueue_t, its sq_external value
1364 * trumps the lwp_extsig value. It is theoretically
1365 * possible to make lwp_extsig reflect reality, but it
1366 * would unnecessarily complicate things elsewhere.
1367 */
1368 ext = sqp->sq_external;
1369 }
1370
1371 if (func == SIG_DFL) {
1372 mutex_exit(&p->p_lock);
1373 DTRACE_PROC3(signal__handle, int, sig, k_siginfo_t *,
1374 NULL, void (*)(void), func);
1375 } else {
1376 k_siginfo_t *sip = NULL;
1377
1378 /*
1379 * If DTrace user-land tracing is active, give DTrace a
1380 * chance to defer the signal until after tracing is
1381 * complete.
1382 */
1383 if (t->t_dtrace_on && dtrace_safe_defer_signal()) {
1384 mutex_exit(&p->p_lock);
1385 return;
1386 }
1387
1388 /*
1389 * save siginfo pointer here, in case the
1390 * the signal's reset bit is on
1391 *
1392 * The presence of a current signal prevents paging
1393 * from succeeding over a network. We copy the current
1394 * signal information to the side and cancel the current
1395 * signal so that sendsig() will succeed.
1396 */
1397 if (sigismember(&p->p_siginfo, sig)) {
1398 sip = &lwp->lwp_siginfo;
1399 if (sqp) {
1400 bcopy(&sqp->sq_info, sip, sizeof (*sip));
1401 /*
1402 * If we were interrupted out of a system call
1403 * due to pthread_cancel(), inform libc.
1404 */
1405 if (sig == SIGCANCEL &&
1406 sip->si_code == SI_LWP &&
1407 t->t_sysnum != 0)
1408 schedctl_cancel_eintr();
1409 } else if (sig == SIGPROF && sip->si_signo == SIGPROF &&
1410 t->t_rprof != NULL && t->t_rprof->rp_anystate) {
1411 /* EMPTY */;
1412 } else {
1413 bzero(sip, sizeof (*sip));
1414 sip->si_signo = sig;
1415 sip->si_code = SI_NOINFO;
1416 }
1417 }
1418
1419 if (t->t_flag & T_TOMASK)
1420 t->t_flag &= ~T_TOMASK;
1421 else
1422 lwp->lwp_sigoldmask = t->t_hold;
1423 sigorset(&t->t_hold, &PTOU(curproc)->u_sigmask[sig-1]);
1424 if (!sigismember(&PTOU(curproc)->u_signodefer, sig))
1425 sigaddset(&t->t_hold, sig);
1426 if (sigismember(&PTOU(curproc)->u_sigresethand, sig))
1427 setsigact(sig, SIG_DFL, &nullsmask, 0);
1428
1429 DTRACE_PROC3(signal__handle, int, sig, k_siginfo_t *,
1430 sip, void (*)(void), func);
1431
1432 lwp->lwp_cursig = 0;
1433 lwp->lwp_extsig = 0;
1434 if (lwp->lwp_curinfo) {
1435 /* p->p_killsqp is freed by freeproc */
1436 siginfofree(lwp->lwp_curinfo);
1437 lwp->lwp_curinfo = NULL;
1438 }
1439 mutex_exit(&p->p_lock);
1440 lwp->lwp_ru.nsignals++;
1441
1442 if (p->p_model == DATAMODEL_NATIVE)
1443 rc = sendsig(sig, sip, func);
1444 #ifdef _SYSCALL32_IMPL
1445 else
1446 rc = sendsig32(sig, sip, func);
1447 #endif /* _SYSCALL32_IMPL */
1448 if (rc)
1449 return;
1450 sig = lwp->lwp_cursig = SIGSEGV;
1451 ext = 0; /* lwp_extsig was set above */
1452 pid = -1;
1453 ctid = 0;
1454 }
1455
1456 if (sigismember(&coredefault, sig)) {
1457 /*
1458 * Terminate all LWPs but don't discard them.
1459 * If another lwp beat us to the punch by calling exit(),
1460 * evaporate now.
1461 */
1462 proc_is_exiting(p);
1463 if (exitlwps(1) != 0) {
1464 mutex_enter(&p->p_lock);
1465 lwp_exit();
1466 }
1467 /* if we got a SIGKILL from anywhere, no core dump */
1468 if (p->p_flag & SKILLED) {
1469 sig = SIGKILL;
1470 ext = (p->p_flag & SEXTKILLED) != 0;
1471 } else {
1472 if (auditing) /* audit core dump */
1473 audit_core_start(sig);
1474 if (core(sig, ext) == 0)
1475 code = CLD_DUMPED;
1476 if (auditing) /* audit core dump */
1477 audit_core_finish(code);
1478 }
1479 }
1480
1481 /*
1482 * Generate a contract event once if the process is killed
1483 * by a signal.
1484 */
1485 if (ext) {
1486 proc_is_exiting(p);
1487 if (exitlwps(0) != 0) {
1488 mutex_enter(&p->p_lock);
1489 lwp_exit();
1490 }
1491 contract_process_sig(p->p_ct_process, p, sig, pid, ctid,
1492 zoneid);
1493 }
1494
1495 exit(code, sig);
1496 }
1497
1498 /*
1499 * Find next unheld signal in ssp for thread t.
1500 */
1501 int
1502 fsig(k_sigset_t *ssp, kthread_t *t)
1503 {
1504 proc_t *p = ttoproc(t);
1505 user_t *up = PTOU(p);
1506 int i;
1507 k_sigset_t temp;
1508
1509 ASSERT(MUTEX_HELD(&p->p_lock));
1510
1511 /*
1512 * Don't promote any signals for the parent of a vfork()d
1513 * child that hasn't yet released the parent's memory.
1514 */
1515 if (p->p_flag & SVFWAIT)
1516 return (0);
1517
1518 temp = *ssp;
1519 sigdiffset(&temp, &t->t_hold);
1520
1521 /*
1522 * Don't promote stopping signals (except SIGSTOP) for a child
1523 * of vfork() that hasn't yet released the parent's memory.
1524 */
1525 if (p->p_flag & SVFORK)
1526 sigdiffset(&temp, &holdvfork);
1527
1528 /*
1529 * Don't promote a signal that will stop
1530 * the process when lwp_nostop is set.
1531 */
1532 if (ttolwp(t)->lwp_nostop) {
1533 sigdelset(&temp, SIGSTOP);
1534 if (!p->p_pgidp->pid_pgorphaned) {
1535 if (up->u_signal[SIGTSTP-1] == SIG_DFL)
1536 sigdelset(&temp, SIGTSTP);
1537 if (up->u_signal[SIGTTIN-1] == SIG_DFL)
1538 sigdelset(&temp, SIGTTIN);
1539 if (up->u_signal[SIGTTOU-1] == SIG_DFL)
1540 sigdelset(&temp, SIGTTOU);
1541 }
1542 }
1543
1544 /*
1545 * Choose SIGKILL and SIGPROF before all other pending signals.
1546 * The rest are promoted in signal number order.
1547 */
1548 if (sigismember(&temp, SIGKILL))
1549 return (SIGKILL);
1550 if (sigismember(&temp, SIGPROF))
1551 return (SIGPROF);
1552
1553 for (i = 0; i < sizeof (temp) / sizeof (temp.__sigbits[0]); i++) {
1554 if (temp.__sigbits[i])
1555 return ((i * NBBY * sizeof (temp.__sigbits[0])) +
1556 lowbit(temp.__sigbits[i]));
1557 }
1558
1559 return (0);
1560 }
1561
1562 void
1563 setsigact(int sig, void (*disp)(), const k_sigset_t *mask, int flags)
1564 {
1565 proc_t *p = ttoproc(curthread);
1566 kthread_t *t;
1567
1568 ASSERT(MUTEX_HELD(&p->p_lock));
1569
1570 PTOU(curproc)->u_signal[sig - 1] = disp;
1571
1572 /*
1573 * Honor the SA_SIGINFO flag if the signal is being caught.
1574 * Force the SA_SIGINFO flag if the signal is not being caught.
1575 * This is necessary to make sigqueue() and sigwaitinfo() work
1576 * properly together when the signal is set to default or is
1577 * being temporarily ignored.
1578 */
1579 if ((flags & SA_SIGINFO) || disp == SIG_DFL || disp == SIG_IGN)
1580 sigaddset(&p->p_siginfo, sig);
1581 else
1582 sigdelset(&p->p_siginfo, sig);
1583
1584 if (disp != SIG_DFL && disp != SIG_IGN) {
1585 sigdelset(&p->p_ignore, sig);
1586 PTOU(curproc)->u_sigmask[sig - 1] = *mask;
1587 if (!sigismember(&cantreset, sig)) {
1588 if (flags & SA_RESETHAND)
1589 sigaddset(&PTOU(curproc)->u_sigresethand, sig);
1590 else
1591 sigdelset(&PTOU(curproc)->u_sigresethand, sig);
1592 }
1593 if (flags & SA_NODEFER)
1594 sigaddset(&PTOU(curproc)->u_signodefer, sig);
1595 else
1596 sigdelset(&PTOU(curproc)->u_signodefer, sig);
1597 if (flags & SA_RESTART)
1598 sigaddset(&PTOU(curproc)->u_sigrestart, sig);
1599 else
1600 sigdelset(&PTOU(curproc)->u_sigrestart, sig);
1601 if (flags & SA_ONSTACK)
1602 sigaddset(&PTOU(curproc)->u_sigonstack, sig);
1603 else
1604 sigdelset(&PTOU(curproc)->u_sigonstack, sig);
1605 } else if (disp == SIG_IGN ||
1606 (disp == SIG_DFL && sigismember(&ignoredefault, sig))) {
1607 /*
1608 * Setting the signal action to SIG_IGN results in the
1609 * discarding of all pending signals of that signal number.
1610 * Setting the signal action to SIG_DFL does the same *only*
1611 * if the signal's default behavior is to be ignored.
1612 */
1613 sigaddset(&p->p_ignore, sig);
1614 sigdelset(&p->p_sig, sig);
1615 sigdelset(&p->p_extsig, sig);
1616 sigdelq(p, NULL, sig);
1617 t = p->p_tlist;
1618 do {
1619 sigdelset(&t->t_sig, sig);
1620 sigdelset(&t->t_extsig, sig);
1621 sigdelq(p, t, sig);
1622 } while ((t = t->t_forw) != p->p_tlist);
1623 } else {
1624 /*
1625 * The signal action is being set to SIG_DFL and the default
1626 * behavior is to do something: make sure it is not ignored.
1627 */
1628 sigdelset(&p->p_ignore, sig);
1629 }
1630
1631 if (sig == SIGCLD) {
1632 if (flags & SA_NOCLDWAIT)
1633 p->p_flag |= SNOWAIT;
1634 else
1635 p->p_flag &= ~SNOWAIT;
1636
1637 if (flags & SA_NOCLDSTOP)
1638 p->p_flag &= ~SJCTL;
1639 else
1640 p->p_flag |= SJCTL;
1641
1642 if ((p->p_flag & SNOWAIT) || disp == SIG_IGN) {
1643 proc_t *cp, *tp;
1644
1645 mutex_exit(&p->p_lock);
1646 mutex_enter(&pidlock);
1647 for (cp = p->p_child; cp != NULL; cp = tp) {
1648 tp = cp->p_sibling;
1649 if (cp->p_stat == SZOMB &&
1650 !(cp->p_pidflag & CLDWAITPID))
1651 freeproc(cp);
1652 }
1653 mutex_exit(&pidlock);
1654 mutex_enter(&p->p_lock);
1655 }
1656 }
1657 }
1658
1659 /*
1660 * Set all signal actions not already set to SIG_DFL or SIG_IGN to SIG_DFL.
1661 * Called from exec_common() for a process undergoing execve()
1662 * and from cfork() for a newly-created child of vfork().
1663 * In the vfork() case, 'p' is not the current process.
1664 * In both cases, there is only one thread in the process.
1665 */
1666 void
1667 sigdefault(proc_t *p)
1668 {
1669 kthread_t *t = p->p_tlist;
1670 struct user *up = PTOU(p);
1671 int sig;
1672
1673 ASSERT(MUTEX_HELD(&p->p_lock));
1674
1675 for (sig = 1; sig < NSIG; sig++) {
1676 if (up->u_signal[sig - 1] != SIG_DFL &&
1677 up->u_signal[sig - 1] != SIG_IGN) {
1678 up->u_signal[sig - 1] = SIG_DFL;
1679 sigemptyset(&up->u_sigmask[sig - 1]);
1680 if (sigismember(&ignoredefault, sig)) {
1681 sigdelq(p, NULL, sig);
1682 sigdelq(p, t, sig);
1683 }
1684 if (sig == SIGCLD)
1685 p->p_flag &= ~(SNOWAIT|SJCTL);
1686 }
1687 }
1688 sigorset(&p->p_ignore, &ignoredefault);
1689 sigfillset(&p->p_siginfo);
1690 sigdiffset(&p->p_siginfo, &cantmask);
1691 sigdiffset(&p->p_sig, &ignoredefault);
1692 sigdiffset(&p->p_extsig, &ignoredefault);
1693 sigdiffset(&t->t_sig, &ignoredefault);
1694 sigdiffset(&t->t_extsig, &ignoredefault);
1695 }
1696
1697 void
1698 sigcld(proc_t *cp, sigqueue_t *sqp)
1699 {
1700 proc_t *pp = cp->p_parent;
1701
1702 ASSERT(MUTEX_HELD(&pidlock));
1703
1704 switch (cp->p_wcode) {
1705 case CLD_EXITED:
1706 case CLD_DUMPED:
1707 case CLD_KILLED:
1708 ASSERT(cp->p_stat == SZOMB);
1709 /*
1710 * The broadcast on p_srwchan_cv is a kludge to
1711 * wakeup a possible thread in uadmin(A_SHUTDOWN).
1712 */
1713 cv_broadcast(&cp->p_srwchan_cv);
1714
1715 /*
1716 * Add to newstate list of the parent
1717 */
1718 add_ns(pp, cp);
1719
1720 cv_broadcast(&pp->p_cv);
1721 if ((pp->p_flag & SNOWAIT) ||
1722 PTOU(pp)->u_signal[SIGCLD - 1] == SIG_IGN) {
1723 if (!(cp->p_pidflag & CLDWAITPID))
1724 freeproc(cp);
1725 } else if (!(cp->p_pidflag & CLDNOSIGCHLD)) {
1726 post_sigcld(cp, sqp);
1727 sqp = NULL;
1728 }
1729 break;
1730
1731 case CLD_STOPPED:
1732 case CLD_CONTINUED:
1733 cv_broadcast(&pp->p_cv);
1734 if (pp->p_flag & SJCTL) {
1735 post_sigcld(cp, sqp);
1736 sqp = NULL;
1737 }
1738 break;
1739 }
1740
1741 if (sqp)
1742 siginfofree(sqp);
1743 }
1744
1745 /*
1746 * Common code called from sigcld() and from
1747 * waitid() and issig_forreal() via sigcld_repost().
1748 * Give the parent process a SIGCLD if it does not have one pending,
1749 * else mark the child process so a SIGCLD can be posted later.
1750 */
1751 static void
1752 post_sigcld(proc_t *cp, sigqueue_t *sqp)
1753 {
1754 proc_t *pp = cp->p_parent;
1755 k_siginfo_t info;
1756
1757 ASSERT(MUTEX_HELD(&pidlock));
1758 mutex_enter(&pp->p_lock);
1759
1760 /*
1761 * If a SIGCLD is pending, then just mark the child process
1762 * so that its SIGCLD will be posted later, when the first
1763 * SIGCLD is taken off the queue or when the parent is ready
1764 * to receive it or accept it, if ever.
1765 */
1766 if (sigismember(&pp->p_sig, SIGCLD)) {
1767 cp->p_pidflag |= CLDPEND;
1768 } else {
1769 cp->p_pidflag &= ~CLDPEND;
1770 if (sqp == NULL) {
1771 /*
1772 * This can only happen when the parent is init.
1773 * (See call to sigcld(q, NULL) in exit().)
1774 * Use KM_NOSLEEP to avoid deadlock.
1775 */
1776 ASSERT(pp == proc_init);
1777 winfo(cp, &info, 0);
1778 sigaddq(pp, NULL, &info, KM_NOSLEEP);
1779 } else {
1780 winfo(cp, &sqp->sq_info, 0);
1781 sigaddqa(pp, NULL, sqp);
1782 sqp = NULL;
1783 }
1784 }
1785
1786 mutex_exit(&pp->p_lock);
1787
1788 if (sqp)
1789 siginfofree(sqp);
1790 }
1791
1792 /*
1793 * Search for a child that has a pending SIGCLD for us, the parent.
1794 * The queue of SIGCLD signals is implied by the list of children.
1795 * We post the SIGCLD signals one at a time so they don't get lost.
1796 * When one is dequeued, another is enqueued, until there are no more.
1797 */
1798 void
1799 sigcld_repost()
1800 {
1801 proc_t *pp = curproc;
1802 proc_t *cp;
1803 sigqueue_t *sqp;
1804
1805 sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);
1806 mutex_enter(&pidlock);
1807 for (cp = pp->p_child; cp; cp = cp->p_sibling) {
1808 if (cp->p_pidflag & CLDPEND) {
1809 post_sigcld(cp, sqp);
1810 mutex_exit(&pidlock);
1811 return;
1812 }
1813 }
1814 mutex_exit(&pidlock);
1815 kmem_free(sqp, sizeof (sigqueue_t));
1816 }
1817
1818 /*
1819 * count number of sigqueue send by sigaddqa()
1820 */
1821 void
1822 sigqsend(int cmd, proc_t *p, kthread_t *t, sigqueue_t *sigqp)
1823 {
1824 sigqhdr_t *sqh;
1825
1826 sqh = (sigqhdr_t *)sigqp->sq_backptr;
1827 ASSERT(sqh);
1828
1829 mutex_enter(&sqh->sqb_lock);
1830 sqh->sqb_sent++;
1831 mutex_exit(&sqh->sqb_lock);
1832
1833 if (cmd == SN_SEND)
1834 sigaddqa(p, t, sigqp);
1835 else
1836 siginfofree(sigqp);
1837 }
1838
1839 int
1840 sigsendproc(proc_t *p, sigsend_t *pv)
1841 {
1842 struct cred *cr;
1843 proc_t *myprocp = curproc;
1844
1845 ASSERT(MUTEX_HELD(&pidlock));
1846
1847 if (p->p_pid == 1 && pv->sig && sigismember(&cantmask, pv->sig))
1848 return (EPERM);
1849
1850 cr = CRED();
1851
1852 if (pv->checkperm == 0 ||
1853 (pv->sig == SIGCONT && p->p_sessp == myprocp->p_sessp) ||
1854 prochasprocperm(p, myprocp, cr)) {
1855 pv->perm++;
1856 if (pv->sig) {
1857 /* Make sure we should be setting si_pid and friends */
1858 ASSERT(pv->sicode <= 0);
1859 if (SI_CANQUEUE(pv->sicode)) {
1860 sigqueue_t *sqp;
1861
1862 mutex_enter(&myprocp->p_lock);
1863 sqp = sigqalloc(myprocp->p_sigqhdr);
1864 mutex_exit(&myprocp->p_lock);
1865 if (sqp == NULL)
1866 return (EAGAIN);
1867 sqp->sq_info.si_signo = pv->sig;
1868 sqp->sq_info.si_code = pv->sicode;
1869 sqp->sq_info.si_pid = myprocp->p_pid;
1870 sqp->sq_info.si_ctid = PRCTID(myprocp);
1871 sqp->sq_info.si_zoneid = getzoneid();
1872 sqp->sq_info.si_uid = crgetruid(cr);
1873 sqp->sq_info.si_value = pv->value;
1874 mutex_enter(&p->p_lock);
1875 sigqsend(SN_SEND, p, NULL, sqp);
1876 mutex_exit(&p->p_lock);
1877 } else {
1878 k_siginfo_t info;
1879 bzero(&info, sizeof (info));
1880 info.si_signo = pv->sig;
1881 info.si_code = pv->sicode;
1882 info.si_pid = myprocp->p_pid;
1883 info.si_ctid = PRCTID(myprocp);
1884 info.si_zoneid = getzoneid();
1885 info.si_uid = crgetruid(cr);
1886 mutex_enter(&p->p_lock);
1887 /*
1888 * XXX: Should be KM_SLEEP but
1889 * we have to avoid deadlock.
1890 */
1891 sigaddq(p, NULL, &info, KM_NOSLEEP);
1892 mutex_exit(&p->p_lock);
1893 }
1894 }
1895 }
1896
1897 return (0);
1898 }
1899
1900 int
1901 sigsendset(procset_t *psp, sigsend_t *pv)
1902 {
1903 int error;
1904
1905 error = dotoprocs(psp, sigsendproc, (char *)pv);
1906 if (error == 0 && pv->perm == 0)
1907 return (EPERM);
1908
1909 return (error);
1910 }
1911
1912 /*
1913 * Dequeue a queued siginfo structure.
1914 * If a non-null thread pointer is passed then dequeue from
1915 * the thread queue, otherwise dequeue from the process queue.
1916 */
1917 void
1918 sigdeq(proc_t *p, kthread_t *t, int sig, sigqueue_t **qpp)
1919 {
1920 sigqueue_t **psqp, *sqp;
1921
1922 ASSERT(MUTEX_HELD(&p->p_lock));
1923
1924 *qpp = NULL;
1925
1926 if (t != NULL) {
1927 sigdelset(&t->t_sig, sig);
1928 sigdelset(&t->t_extsig, sig);
1929 psqp = &t->t_sigqueue;
1930 } else {
1931 sigdelset(&p->p_sig, sig);
1932 sigdelset(&p->p_extsig, sig);
1933 psqp = &p->p_sigqueue;
1934 }
1935
1936 for (;;) {
1937 if ((sqp = *psqp) == NULL)
1938 return;
1939 if (sqp->sq_info.si_signo == sig)
1940 break;
1941 else
1942 psqp = &sqp->sq_next;
1943 }
1944 *qpp = sqp;
1945 *psqp = sqp->sq_next;
1946 for (sqp = *psqp; sqp; sqp = sqp->sq_next) {
1947 if (sqp->sq_info.si_signo == sig) {
1948 if (t != (kthread_t *)NULL) {
1949 sigaddset(&t->t_sig, sig);
1950 t->t_sig_check = 1;
1951 } else {
1952 sigaddset(&p->p_sig, sig);
1953 set_proc_ast(p);
1954 }
1955 break;
1956 }
1957 }
1958 }
1959
1960 /*
1961 * Delete a queued SIGCLD siginfo structure matching the k_siginfo_t argument.
1962 */
1963 void
1964 sigcld_delete(k_siginfo_t *ip)
1965 {
1966 proc_t *p = curproc;
1967 int another_sigcld = 0;
1968 sigqueue_t **psqp, *sqp;
1969
1970 ASSERT(ip->si_signo == SIGCLD);
1971
1972 mutex_enter(&p->p_lock);
1973
1974 if (!sigismember(&p->p_sig, SIGCLD)) {
1975 mutex_exit(&p->p_lock);
1976 return;
1977 }
1978
1979 psqp = &p->p_sigqueue;
1980 for (;;) {
1981 if ((sqp = *psqp) == NULL) {
1982 mutex_exit(&p->p_lock);
1983 return;
1984 }
1985 if (sqp->sq_info.si_signo == SIGCLD) {
1986 if (sqp->sq_info.si_pid == ip->si_pid &&
1987 sqp->sq_info.si_code == ip->si_code &&
1988 sqp->sq_info.si_status == ip->si_status)
1989 break;
1990 another_sigcld = 1;
1991 }
1992 psqp = &sqp->sq_next;
1993 }
1994 *psqp = sqp->sq_next;
1995
1996 siginfofree(sqp);
1997
1998 for (sqp = *psqp; !another_sigcld && sqp; sqp = sqp->sq_next) {
1999 if (sqp->sq_info.si_signo == SIGCLD)
2000 another_sigcld = 1;
2001 }
2002
2003 if (!another_sigcld) {
2004 sigdelset(&p->p_sig, SIGCLD);
2005 sigdelset(&p->p_extsig, SIGCLD);
2006 }
2007
2008 mutex_exit(&p->p_lock);
2009 }
2010
2011 /*
2012 * Delete queued siginfo structures.
2013 * If a non-null thread pointer is passed then delete from
2014 * the thread queue, otherwise delete from the process queue.
2015 */
2016 void
2017 sigdelq(proc_t *p, kthread_t *t, int sig)
2018 {
2019 sigqueue_t **psqp, *sqp;
2020
2021 /*
2022 * We must be holding p->p_lock unless the process is
2023 * being reaped or has failed to get started on fork.
2024 */
2025 ASSERT(MUTEX_HELD(&p->p_lock) ||
2026 p->p_stat == SIDL || p->p_stat == SZOMB);
2027
2028 if (t != (kthread_t *)NULL)
2029 psqp = &t->t_sigqueue;
2030 else
2031 psqp = &p->p_sigqueue;
2032
2033 while (*psqp) {
2034 sqp = *psqp;
2035 if (sig == 0 || sqp->sq_info.si_signo == sig) {
2036 *psqp = sqp->sq_next;
2037 siginfofree(sqp);
2038 } else
2039 psqp = &sqp->sq_next;
2040 }
2041 }
2042
2043 /*
2044 * Insert a siginfo structure into a queue.
2045 * If a non-null thread pointer is passed then add to the thread queue,
2046 * otherwise add to the process queue.
2047 *
2048 * The function sigaddqins() is called with sigqueue already allocated.
2049 * It is called from sigaddqa() and sigaddq() below.
2050 *
2051 * The value of si_code implicitly indicates whether sigp is to be
2052 * explicitly queued, or to be queued to depth one.
2053 */
2054 static void
2055 sigaddqins(proc_t *p, kthread_t *t, sigqueue_t *sigqp)
2056 {
2057 sigqueue_t **psqp;
2058 int sig = sigqp->sq_info.si_signo;
2059
2060 sigqp->sq_external = (curproc != &p0) &&
2061 (curproc->p_ct_process != p->p_ct_process);
2062
2063 /*
2064 * issig_forreal() doesn't bother dequeueing signals if SKILLED
2065 * is set, and even if it did, we would want to avoid situation
2066 * (which would be unique to SIGKILL) where one thread dequeued
2067 * the sigqueue_t and another executed psig(). So we create a
2068 * separate stash for SIGKILL's sigqueue_t. Because a second
2069 * SIGKILL can set SEXTKILLED, we overwrite the existing entry
2070 * if (and only if) it was non-extracontractual.
2071 */
2072 if (sig == SIGKILL) {
2073 if (p->p_killsqp == NULL || !p->p_killsqp->sq_external) {
2074 if (p->p_killsqp != NULL)
2075 siginfofree(p->p_killsqp);
2076 p->p_killsqp = sigqp;
2077 sigqp->sq_next = NULL;
2078 } else {
2079 siginfofree(sigqp);
2080 }
2081 return;
2082 }
2083
2084 ASSERT(sig >= 1 && sig < NSIG);
2085 if (t != NULL) /* directed to a thread */
2086 psqp = &t->t_sigqueue;
2087 else /* directed to a process */
2088 psqp = &p->p_sigqueue;
2089 if (SI_CANQUEUE(sigqp->sq_info.si_code) &&
2090 sigismember(&p->p_siginfo, sig)) {
2091 for (; *psqp != NULL; psqp = &(*psqp)->sq_next)
2092 ;
2093 } else {
2094 for (; *psqp != NULL; psqp = &(*psqp)->sq_next) {
2095 if ((*psqp)->sq_info.si_signo == sig) {
2096 siginfofree(sigqp);
2097 return;
2098 }
2099 }
2100 }
2101 *psqp = sigqp;
2102 sigqp->sq_next = NULL;
2103 }
2104
2105 /*
2106 * The function sigaddqa() is called with sigqueue already allocated.
2107 * If signal is ignored, discard but guarantee KILL and generation semantics.
2108 * It is called from sigqueue() and other places.
2109 */
2110 void
2111 sigaddqa(proc_t *p, kthread_t *t, sigqueue_t *sigqp)
2112 {
2113 int sig = sigqp->sq_info.si_signo;
2114
2115 ASSERT(MUTEX_HELD(&p->p_lock));
2116 ASSERT(sig >= 1 && sig < NSIG);
2117
2118 if (sig_discardable(p, sig))
2119 siginfofree(sigqp);
2120 else
2121 sigaddqins(p, t, sigqp);
2122
2123 sigtoproc(p, t, sig);
2124 }
2125
2126 /*
2127 * Allocate the sigqueue_t structure and call sigaddqins().
2128 */
2129 void
2130 sigaddq(proc_t *p, kthread_t *t, k_siginfo_t *infop, int km_flags)
2131 {
2132 sigqueue_t *sqp;
2133 int sig = infop->si_signo;
2134
2135 ASSERT(MUTEX_HELD(&p->p_lock));
2136 ASSERT(sig >= 1 && sig < NSIG);
2137
2138 /*
2139 * If the signal will be discarded by sigtoproc() or
2140 * if the process isn't requesting siginfo and it isn't
2141 * blocking the signal (it *could* change it's mind while
2142 * the signal is pending) then don't bother creating one.
2143 */
2144 if (!sig_discardable(p, sig) &&
2145 (sigismember(&p->p_siginfo, sig) ||
2146 (curproc->p_ct_process != p->p_ct_process) ||
2147 (sig == SIGCLD && SI_FROMKERNEL(infop))) &&
2148 ((sqp = kmem_alloc(sizeof (sigqueue_t), km_flags)) != NULL)) {
2149 bcopy(infop, &sqp->sq_info, sizeof (k_siginfo_t));
2150 sqp->sq_func = NULL;
2151 sqp->sq_next = NULL;
2152 sigaddqins(p, t, sqp);
2153 }
2154 sigtoproc(p, t, sig);
2155 }
2156
2157 /*
2158 * Handle stop-on-fault processing for the debugger. Returns 0
2159 * if the fault is cleared during the stop, nonzero if it isn't.
2160 */
2161 int
2162 stop_on_fault(uint_t fault, k_siginfo_t *sip)
2163 {
2164 proc_t *p = ttoproc(curthread);
2165 klwp_t *lwp = ttolwp(curthread);
2166
2167 ASSERT(prismember(&p->p_fltmask, fault));
2168
2169 /*
2170 * Record current fault and siginfo structure so debugger can
2171 * find it.
2172 */
2173 mutex_enter(&p->p_lock);
2174 lwp->lwp_curflt = (uchar_t)fault;
2175 lwp->lwp_siginfo = *sip;
2176
2177 stop(PR_FAULTED, fault);
2178
2179 fault = lwp->lwp_curflt;
2180 lwp->lwp_curflt = 0;
2181 mutex_exit(&p->p_lock);
2182 return (fault);
2183 }
2184
2185 void
2186 sigorset(k_sigset_t *s1, const k_sigset_t *s2)
2187 {
2188 s1->__sigbits[0] |= s2->__sigbits[0];
2189 s1->__sigbits[1] |= s2->__sigbits[1];
2190 s1->__sigbits[2] |= s2->__sigbits[2];
2191 }
2192
2193 void
2194 sigandset(k_sigset_t *s1, const k_sigset_t *s2)
2195 {
2196 s1->__sigbits[0] &= s2->__sigbits[0];
2197 s1->__sigbits[1] &= s2->__sigbits[1];
2198 s1->__sigbits[2] &= s2->__sigbits[2];
2199 }
2200
2201 void
2202 sigdiffset(k_sigset_t *s1, const k_sigset_t *s2)
2203 {
2204 s1->__sigbits[0] &= ~(s2->__sigbits[0]);
2205 s1->__sigbits[1] &= ~(s2->__sigbits[1]);
2206 s1->__sigbits[2] &= ~(s2->__sigbits[2]);
2207 }
2208
2209 /*
2210 * Return non-zero if curthread->t_sig_check should be set to 1, that is,
2211 * if there are any signals the thread might take on return from the kernel.
2212 * If ksigset_t's were a single word, we would do:
2213 * return (((p->p_sig | t->t_sig) & ~t->t_hold) & fillset);
2214 */
2215 int
2216 sigcheck(proc_t *p, kthread_t *t)
2217 {
2218 sc_shared_t *tdp = t->t_schedctl;
2219
2220 /*
2221 * If signals are blocked via the schedctl interface
2222 * then we only check for the unmaskable signals.
2223 * The unmaskable signal numbers should all be contained
2224 * in __sigbits[0] and we assume this for speed.
2225 */
2226 #if (CANTMASK1 == 0 && CANTMASK2 == 0)
2227 if (tdp != NULL && tdp->sc_sigblock)
2228 return ((p->p_sig.__sigbits[0] | t->t_sig.__sigbits[0]) &
2229 CANTMASK0);
2230 #else
2231 #error "fix me: CANTMASK1 and CANTMASK2 are not zero"
2232 #endif
2233
2234 /* see uts/common/sys/signal.h for why this must be true */
2235 #if ((MAXSIG > (2 * 32)) && (MAXSIG <= (3 * 32)))
2236 return (((p->p_sig.__sigbits[0] | t->t_sig.__sigbits[0]) &
2237 ~t->t_hold.__sigbits[0]) |
2238 ((p->p_sig.__sigbits[1] | t->t_sig.__sigbits[1]) &
2239 ~t->t_hold.__sigbits[1]) |
2240 (((p->p_sig.__sigbits[2] | t->t_sig.__sigbits[2]) &
2241 ~t->t_hold.__sigbits[2]) & FILLSET2));
2242 #else
2243 #error "fix me: MAXSIG out of bounds"
2244 #endif
2245 }
2246
2247 void
2248 sigintr(k_sigset_t *smask, int intable)
2249 {
2250 proc_t *p;
2251 int owned;
2252 k_sigset_t lmask; /* local copy of cantmask */
2253 klwp_t *lwp = ttolwp(curthread);
2254
2255 /*
2256 * Mask out all signals except SIGHUP, SIGINT, SIGQUIT
2257 * and SIGTERM. (Preserving the existing masks).
2258 * This function supports the -intr nfs and ufs mount option.
2259 */
2260
2261 /*
2262 * don't do kernel threads
2263 */
2264 if (lwp == NULL)
2265 return;
2266
2267 /*
2268 * get access to signal mask
2269 */
2270 p = ttoproc(curthread);
2271 owned = mutex_owned(&p->p_lock); /* this is filthy */
2272 if (!owned)
2273 mutex_enter(&p->p_lock);
2274
2275 /*
2276 * remember the current mask
2277 */
2278 schedctl_finish_sigblock(curthread);
2279 *smask = curthread->t_hold;
2280
2281 /*
2282 * mask out all signals
2283 */
2284 sigfillset(&curthread->t_hold);
2285
2286 /*
2287 * Unmask the non-maskable signals (e.g., KILL), as long as
2288 * they aren't already masked (which could happen at exit).
2289 * The first sigdiffset sets lmask to (cantmask & ~curhold). The
2290 * second sets the current hold mask to (~0 & ~lmask), which reduces
2291 * to (~cantmask | curhold).
2292 */
2293 lmask = cantmask;
2294 sigdiffset(&lmask, smask);
2295 sigdiffset(&curthread->t_hold, &lmask);
2296
2297 /*
2298 * Re-enable HUP, QUIT, and TERM iff they were originally enabled
2299 * Re-enable INT if it's originally enabled and the NFS mount option
2300 * nointr is not set.
2301 */
2302 if (!sigismember(smask, SIGHUP))
2303 sigdelset(&curthread->t_hold, SIGHUP);
2304 if (!sigismember(smask, SIGINT) && intable)
2305 sigdelset(&curthread->t_hold, SIGINT);
2306 if (!sigismember(smask, SIGQUIT))
2307 sigdelset(&curthread->t_hold, SIGQUIT);
2308 if (!sigismember(smask, SIGTERM))
2309 sigdelset(&curthread->t_hold, SIGTERM);
2310
2311 /*
2312 * release access to signal mask
2313 */
2314 if (!owned)
2315 mutex_exit(&p->p_lock);
2316
2317 /*
2318 * Indicate that this lwp is not to be stopped.
2319 */
2320 lwp->lwp_nostop++;
2321
2322 }
2323
2324 void
2325 sigunintr(k_sigset_t *smask)
2326 {
2327 proc_t *p;
2328 int owned;
2329 klwp_t *lwp = ttolwp(curthread);
2330
2331 /*
2332 * Reset previous mask (See sigintr() above)
2333 */
2334 if (lwp != NULL) {
2335 lwp->lwp_nostop--; /* restore lwp stoppability */
2336 p = ttoproc(curthread);
2337 owned = mutex_owned(&p->p_lock); /* this is filthy */
2338 if (!owned)
2339 mutex_enter(&p->p_lock);
2340 curthread->t_hold = *smask;
2341 /* so unmasked signals will be seen */
2342 curthread->t_sig_check = 1;
2343 if (!owned)
2344 mutex_exit(&p->p_lock);
2345 }
2346 }
2347
2348 void
2349 sigreplace(k_sigset_t *newmask, k_sigset_t *oldmask)
2350 {
2351 proc_t *p;
2352 int owned;
2353 /*
2354 * Save current signal mask in oldmask, then
2355 * set it to newmask.
2356 */
2357 if (ttolwp(curthread) != NULL) {
2358 p = ttoproc(curthread);
2359 owned = mutex_owned(&p->p_lock); /* this is filthy */
2360 if (!owned)
2361 mutex_enter(&p->p_lock);
2362 schedctl_finish_sigblock(curthread);
2363 if (oldmask != NULL)
2364 *oldmask = curthread->t_hold;
2365 curthread->t_hold = *newmask;
2366 curthread->t_sig_check = 1;
2367 if (!owned)
2368 mutex_exit(&p->p_lock);
2369 }
2370 }
2371
2372 /*
2373 * Return true if the signal number is in range
2374 * and the signal code specifies signal queueing.
2375 */
2376 int
2377 sigwillqueue(int sig, int code)
2378 {
2379 if (sig >= 0 && sig < NSIG) {
2380 switch (code) {
2381 case SI_QUEUE:
2382 case SI_TIMER:
2383 case SI_ASYNCIO:
2384 case SI_MESGQ:
2385 return (1);
2386 }
2387 }
2388 return (0);
2389 }
2390
2391 /*
2392 * The pre-allocated pool (with _SIGQUEUE_PREALLOC entries) is
2393 * allocated at the first sigqueue/signotify call.
2394 */
2395 sigqhdr_t *
2396 sigqhdralloc(size_t size, uint_t maxcount)
2397 {
2398 size_t i;
2399 sigqueue_t *sq, *next;
2400 sigqhdr_t *sqh;
2401
2402 /*
2403 * Before the introduction of process.max-sigqueue-size
2404 * _SC_SIGQUEUE_MAX had this static value.
2405 */
2406 #define _SIGQUEUE_PREALLOC 32
2407
2408 i = (_SIGQUEUE_PREALLOC * size) + sizeof (sigqhdr_t);
2409 ASSERT(maxcount <= INT_MAX);
2410 sqh = kmem_alloc(i, KM_SLEEP);
2411 sqh->sqb_count = maxcount;
2412 sqh->sqb_maxcount = maxcount;
2413 sqh->sqb_size = i;
2414 sqh->sqb_pexited = 0;
2415 sqh->sqb_sent = 0;
2416 sqh->sqb_free = sq = (sigqueue_t *)(sqh + 1);
2417 for (i = _SIGQUEUE_PREALLOC - 1; i != 0; i--) {
2418 next = (sigqueue_t *)((uintptr_t)sq + size);
2419 sq->sq_next = next;
2420 sq = next;
2421 }
2422 sq->sq_next = NULL;
2423 cv_init(&sqh->sqb_cv, NULL, CV_DEFAULT, NULL);
2424 mutex_init(&sqh->sqb_lock, NULL, MUTEX_DEFAULT, NULL);
2425 return (sqh);
2426 }
2427
2428 static void sigqrel(sigqueue_t *);
2429
2430 /*
2431 * Allocate a sigqueue/signotify structure from the per process
2432 * pre-allocated pool or allocate a new sigqueue/signotify structure
2433 * if the pre-allocated pool is exhausted.
2434 */
2435 sigqueue_t *
2436 sigqalloc(sigqhdr_t *sqh)
2437 {
2438 sigqueue_t *sq = NULL;
2439
2440 ASSERT(MUTEX_HELD(&curproc->p_lock));
2441
2442 if (sqh != NULL) {
2443 mutex_enter(&sqh->sqb_lock);
2444 if (sqh->sqb_count > 0) {
2445 sqh->sqb_count--;
2446 if (sqh->sqb_free == NULL) {
2447 /*
2448 * The pre-allocated pool is exhausted.
2449 */
2450 sq = kmem_alloc(sizeof (sigqueue_t), KM_SLEEP);
2451 sq->sq_func = NULL;
2452 } else {
2453 sq = sqh->sqb_free;
2454 sq->sq_func = sigqrel;
2455 sqh->sqb_free = sq->sq_next;
2456 }
2457 mutex_exit(&sqh->sqb_lock);
2458 bzero(&sq->sq_info, sizeof (k_siginfo_t));
2459 sq->sq_backptr = sqh;
2460 sq->sq_next = NULL;
2461 sq->sq_external = 0;
2462 } else {
2463 mutex_exit(&sqh->sqb_lock);
2464 }
2465 }
2466 return (sq);
2467 }
2468
2469 /*
2470 * Return a sigqueue structure back to the pre-allocated pool.
2471 */
2472 static void
2473 sigqrel(sigqueue_t *sq)
2474 {
2475 sigqhdr_t *sqh;
2476
2477 /* make sure that p_lock of the affected process is held */
2478
2479 sqh = (sigqhdr_t *)sq->sq_backptr;
2480 mutex_enter(&sqh->sqb_lock);
2481 if (sqh->sqb_pexited && sqh->sqb_sent == 1) {
2482 mutex_exit(&sqh->sqb_lock);
2483 cv_destroy(&sqh->sqb_cv);
2484 mutex_destroy(&sqh->sqb_lock);
2485 kmem_free(sqh, sqh->sqb_size);
2486 } else {
2487 sqh->sqb_count++;
2488 sqh->sqb_sent--;
2489 sq->sq_next = sqh->sqb_free;
2490 sq->sq_backptr = NULL;
2491 sqh->sqb_free = sq;
2492 cv_signal(&sqh->sqb_cv);
2493 mutex_exit(&sqh->sqb_lock);
2494 }
2495 }
2496
2497 /*
2498 * Free up the pre-allocated sigqueue headers of sigqueue pool
2499 * and signotify pool, if possible.
2500 * Called only by the owning process during exec() and exit().
2501 */
2502 void
2503 sigqfree(proc_t *p)
2504 {
2505 ASSERT(MUTEX_HELD(&p->p_lock));
2506
2507 if (p->p_sigqhdr != NULL) { /* sigqueue pool */
2508 sigqhdrfree(p->p_sigqhdr);
2509 p->p_sigqhdr = NULL;
2510 }
2511 if (p->p_signhdr != NULL) { /* signotify pool */
2512 sigqhdrfree(p->p_signhdr);
2513 p->p_signhdr = NULL;
2514 }
2515 }
2516
2517 /*
2518 * Free up the pre-allocated header and sigq pool if possible.
2519 */
2520 void
2521 sigqhdrfree(sigqhdr_t *sqh)
2522 {
2523 mutex_enter(&sqh->sqb_lock);
2524 if (sqh->sqb_sent == 0) {
2525 mutex_exit(&sqh->sqb_lock);
2526 cv_destroy(&sqh->sqb_cv);
2527 mutex_destroy(&sqh->sqb_lock);
2528 kmem_free(sqh, sqh->sqb_size);
2529 } else {
2530 sqh->sqb_pexited = 1;
2531 mutex_exit(&sqh->sqb_lock);
2532 }
2533 }
2534
2535 /*
2536 * Free up a single sigqueue structure.
2537 * No other code should free a sigqueue directly.
2538 */
2539 void
2540 siginfofree(sigqueue_t *sqp)
2541 {
2542 if (sqp != NULL) {
2543 if (sqp->sq_func != NULL)
2544 (sqp->sq_func)(sqp);
2545 else
2546 kmem_free(sqp, sizeof (sigqueue_t));
2547 }
2548 }
2549
2550 /*
2551 * Generate a synchronous signal caused by a hardware
2552 * condition encountered by an lwp. Called from trap().
2553 */
2554 void
2555 trapsig(k_siginfo_t *ip, int restartable)
2556 {
2557 proc_t *p = ttoproc(curthread);
2558 int sig = ip->si_signo;
2559 sigqueue_t *sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);
2560
2561 ASSERT(sig > 0 && sig < NSIG);
2562
2563 if (curthread->t_dtrace_on)
2564 dtrace_safe_synchronous_signal();
2565
2566 mutex_enter(&p->p_lock);
2567 schedctl_finish_sigblock(curthread);
2568 /*
2569 * Avoid a possible infinite loop if the lwp is holding the
2570 * signal generated by a trap of a restartable instruction or
2571 * if the signal so generated is being ignored by the process.
2572 */
2573 if (restartable &&
2574 (sigismember(&curthread->t_hold, sig) ||
2575 p->p_user.u_signal[sig-1] == SIG_IGN)) {
2576 sigdelset(&curthread->t_hold, sig);
2577 p->p_user.u_signal[sig-1] = SIG_DFL;
2578 sigdelset(&p->p_ignore, sig);
2579 }
2580 bcopy(ip, &sqp->sq_info, sizeof (k_siginfo_t));
2581 sigaddqa(p, curthread, sqp);
2582 mutex_exit(&p->p_lock);
2583 }
2584
2585 /*
2586 * Dispatch the real time profiling signal in the traditional way,
2587 * honoring all of the /proc tracing mechanism built into issig().
2588 */
2589 static void
2590 realsigprof_slow(int sysnum, int nsysarg, int error)
2591 {
2592 kthread_t *t = curthread;
2593 proc_t *p = ttoproc(t);
2594 klwp_t *lwp = ttolwp(t);
2595 k_siginfo_t *sip = &lwp->lwp_siginfo;
2596 void (*func)();
2597
2598 mutex_enter(&p->p_lock);
2599 func = PTOU(p)->u_signal[SIGPROF - 1];
2600 if (p->p_rprof_cyclic == CYCLIC_NONE ||
2601 func == SIG_DFL || func == SIG_IGN) {
2602 bzero(t->t_rprof, sizeof (*t->t_rprof));
2603 mutex_exit(&p->p_lock);
2604 return;
2605 }
2606 if (sigismember(&t->t_hold, SIGPROF)) {
2607 mutex_exit(&p->p_lock);
2608 return;
2609 }
2610 sip->si_signo = SIGPROF;
2611 sip->si_code = PROF_SIG;
2612 sip->si_errno = error;
2613 hrt2ts(gethrtime(), &sip->si_tstamp);
2614 sip->si_syscall = sysnum;
2615 sip->si_nsysarg = nsysarg;
2616 sip->si_fault = lwp->lwp_lastfault;
2617 sip->si_faddr = lwp->lwp_lastfaddr;
2618 lwp->lwp_lastfault = 0;
2619 lwp->lwp_lastfaddr = NULL;
2620 sigtoproc(p, t, SIGPROF);
2621 mutex_exit(&p->p_lock);
2622 ASSERT(lwp->lwp_cursig == 0);
2623 if (issig(FORREAL))
2624 psig();
2625 sip->si_signo = 0;
2626 bzero(t->t_rprof, sizeof (*t->t_rprof));
2627 }
2628
2629 /*
2630 * We are not tracing the SIGPROF signal, or doing any other unnatural
2631 * acts, like watchpoints, so dispatch the real time profiling signal
2632 * directly, bypassing all of the overhead built into issig().
2633 */
2634 static void
2635 realsigprof_fast(int sysnum, int nsysarg, int error)
2636 {
2637 kthread_t *t = curthread;
2638 proc_t *p = ttoproc(t);
2639 klwp_t *lwp = ttolwp(t);
2640 k_siginfo_t *sip = &lwp->lwp_siginfo;
2641 void (*func)();
2642 int rc;
2643 int code;
2644
2645 /*
2646 * We don't need to acquire p->p_lock here;
2647 * we are manipulating thread-private data.
2648 */
2649 func = PTOU(p)->u_signal[SIGPROF - 1];
2650 if (p->p_rprof_cyclic == CYCLIC_NONE ||
2651 func == SIG_DFL || func == SIG_IGN) {
2652 bzero(t->t_rprof, sizeof (*t->t_rprof));
2653 return;
2654 }
2655 if (lwp->lwp_cursig != 0 ||
2656 lwp->lwp_curinfo != NULL ||
2657 sigismember(&t->t_hold, SIGPROF)) {
2658 return;
2659 }
2660 sip->si_signo = SIGPROF;
2661 sip->si_code = PROF_SIG;
2662 sip->si_errno = error;
2663 hrt2ts(gethrtime(), &sip->si_tstamp);
2664 sip->si_syscall = sysnum;
2665 sip->si_nsysarg = nsysarg;
2666 sip->si_fault = lwp->lwp_lastfault;
2667 sip->si_faddr = lwp->lwp_lastfaddr;
2668 lwp->lwp_lastfault = 0;
2669 lwp->lwp_lastfaddr = NULL;
2670 if (t->t_flag & T_TOMASK)
2671 t->t_flag &= ~T_TOMASK;
2672 else
2673 lwp->lwp_sigoldmask = t->t_hold;
2674 sigorset(&t->t_hold, &PTOU(p)->u_sigmask[SIGPROF - 1]);
2675 if (!sigismember(&PTOU(p)->u_signodefer, SIGPROF))
2676 sigaddset(&t->t_hold, SIGPROF);
2677 lwp->lwp_extsig = 0;
2678 lwp->lwp_ru.nsignals++;
2679 if (p->p_model == DATAMODEL_NATIVE)
2680 rc = sendsig(SIGPROF, sip, func);
2681 #ifdef _SYSCALL32_IMPL
2682 else
2683 rc = sendsig32(SIGPROF, sip, func);
2684 #endif /* _SYSCALL32_IMPL */
2685 sip->si_signo = 0;
2686 bzero(t->t_rprof, sizeof (*t->t_rprof));
2687 if (rc == 0) {
2688 /*
2689 * sendsig() failed; we must dump core with a SIGSEGV.
2690 * See psig(). This code is copied from there.
2691 */
2692 lwp->lwp_cursig = SIGSEGV;
2693 code = CLD_KILLED;
2694 proc_is_exiting(p);
2695 if (exitlwps(1) != 0) {
2696 mutex_enter(&p->p_lock);
2697 lwp_exit();
2698 }
2699 if (audit_active == C2AUDIT_LOADED)
2700 audit_core_start(SIGSEGV);
2701 if (core(SIGSEGV, 0) == 0)
2702 code = CLD_DUMPED;
2703 if (audit_active == C2AUDIT_LOADED)
2704 audit_core_finish(code);
2705 exit(code, SIGSEGV);
2706 }
2707 }
2708
2709 /*
2710 * Arrange for the real time profiling signal to be dispatched.
2711 */
2712 void
2713 realsigprof(int sysnum, int nsysarg, int error)
2714 {
2715 kthread_t *t = curthread;
2716 proc_t *p = ttoproc(t);
2717
2718 if (t->t_rprof->rp_anystate == 0)
2719 return;
2720
2721 schedctl_finish_sigblock(t);
2722
2723 /* test for any activity that requires p->p_lock */
2724 if (tracing(p, SIGPROF) || pr_watch_active(p) ||
2725 sigismember(&PTOU(p)->u_sigresethand, SIGPROF)) {
2726 /* do it the classic slow way */
2727 realsigprof_slow(sysnum, nsysarg, error);
2728 } else {
2729 /* do it the cheating-a-little fast way */
2730 realsigprof_fast(sysnum, nsysarg, error);
2731 }
2732 }
2733
2734 #ifdef _SYSCALL32_IMPL
2735
2736 /*
2737 * It's tricky to transmit a sigval between 32-bit and 64-bit
2738 * process, since in the 64-bit world, a pointer and an integer
2739 * are different sizes. Since we're constrained by the standards
2740 * world not to change the types, and it's unclear how useful it is
2741 * to send pointers between address spaces this way, we preserve
2742 * the 'int' interpretation for 32-bit processes interoperating
2743 * with 64-bit processes. The full semantics (pointers or integers)
2744 * are available for N-bit processes interoperating with N-bit
2745 * processes.
2746 */
2747 void
2748 siginfo_kto32(const k_siginfo_t *src, siginfo32_t *dest)
2749 {
2750 bzero(dest, sizeof (*dest));
2751
2752 /*
2753 * The absolute minimum content is si_signo and si_code.
2754 */
2755 dest->si_signo = src->si_signo;
2756 if ((dest->si_code = src->si_code) == SI_NOINFO)
2757 return;
2758
2759 /*
2760 * A siginfo generated by user level is structured
2761 * differently from one generated by the kernel.
2762 */
2763 if (SI_FROMUSER(src)) {
2764 dest->si_pid = src->si_pid;
2765 dest->si_ctid = src->si_ctid;
2766 dest->si_zoneid = src->si_zoneid;
2767 dest->si_uid = src->si_uid;
2768 if (SI_CANQUEUE(src->si_code))
2769 dest->si_value.sival_int =
2770 (int32_t)src->si_value.sival_int;
2771 return;
2772 }
2773
2774 dest->si_errno = src->si_errno;
2775
2776 switch (src->si_signo) {
2777 default:
2778 dest->si_pid = src->si_pid;
2779 dest->si_ctid = src->si_ctid;
2780 dest->si_zoneid = src->si_zoneid;
2781 dest->si_uid = src->si_uid;
2782 dest->si_value.sival_int = (int32_t)src->si_value.sival_int;
2783 break;
2784 case SIGCLD:
2785 dest->si_pid = src->si_pid;
2786 dest->si_ctid = src->si_ctid;
2787 dest->si_zoneid = src->si_zoneid;
2788 dest->si_status = src->si_status;
2789 dest->si_stime = src->si_stime;
2790 dest->si_utime = src->si_utime;
2791 break;
2792 case SIGSEGV:
2793 case SIGBUS:
2794 case SIGILL:
2795 case SIGTRAP:
2796 case SIGFPE:
2797 case SIGEMT:
2798 dest->si_addr = (caddr32_t)(uintptr_t)src->si_addr;
2799 dest->si_trapno = src->si_trapno;
2800 dest->si_pc = (caddr32_t)(uintptr_t)src->si_pc;
2801 break;
2802 case SIGPOLL:
2803 case SIGXFSZ:
2804 dest->si_fd = src->si_fd;
2805 dest->si_band = src->si_band;
2806 break;
2807 case SIGPROF:
2808 dest->si_faddr = (caddr32_t)(uintptr_t)src->si_faddr;
2809 dest->si_tstamp.tv_sec = src->si_tstamp.tv_sec;
2810 dest->si_tstamp.tv_nsec = src->si_tstamp.tv_nsec;
2811 dest->si_syscall = src->si_syscall;
2812 dest->si_nsysarg = src->si_nsysarg;
2813 dest->si_fault = src->si_fault;
2814 break;
2815 }
2816 }
2817
2818 void
2819 siginfo_32tok(const siginfo32_t *src, k_siginfo_t *dest)
2820 {
2821 bzero(dest, sizeof (*dest));
2822
2823 /*
2824 * The absolute minimum content is si_signo and si_code.
2825 */
2826 dest->si_signo = src->si_signo;
2827 if ((dest->si_code = src->si_code) == SI_NOINFO)
2828 return;
2829
2830 /*
2831 * A siginfo generated by user level is structured
2832 * differently from one generated by the kernel.
2833 */
2834 if (SI_FROMUSER(src)) {
2835 dest->si_pid = src->si_pid;
2836 dest->si_ctid = src->si_ctid;
2837 dest->si_zoneid = src->si_zoneid;
2838 dest->si_uid = src->si_uid;
2839 if (SI_CANQUEUE(src->si_code))
2840 dest->si_value.sival_int =
2841 (int)src->si_value.sival_int;
2842 return;
2843 }
2844
2845 dest->si_errno = src->si_errno;
2846
2847 switch (src->si_signo) {
2848 default:
2849 dest->si_pid = src->si_pid;
2850 dest->si_ctid = src->si_ctid;
2851 dest->si_zoneid = src->si_zoneid;
2852 dest->si_uid = src->si_uid;
2853 dest->si_value.sival_int = (int)src->si_value.sival_int;
2854 break;
2855 case SIGCLD:
2856 dest->si_pid = src->si_pid;
2857 dest->si_ctid = src->si_ctid;
2858 dest->si_zoneid = src->si_zoneid;
2859 dest->si_status = src->si_status;
2860 dest->si_stime = src->si_stime;
2861 dest->si_utime = src->si_utime;
2862 break;
2863 case SIGSEGV:
2864 case SIGBUS:
2865 case SIGILL:
2866 case SIGTRAP:
2867 case SIGFPE:
2868 case SIGEMT:
2869 dest->si_addr = (void *)(uintptr_t)src->si_addr;
2870 dest->si_trapno = src->si_trapno;
2871 dest->si_pc = (void *)(uintptr_t)src->si_pc;
2872 break;
2873 case SIGPOLL:
2874 case SIGXFSZ:
2875 dest->si_fd = src->si_fd;
2876 dest->si_band = src->si_band;
2877 break;
2878 case SIGPROF:
2879 dest->si_faddr = (void *)(uintptr_t)src->si_faddr;
2880 dest->si_tstamp.tv_sec = src->si_tstamp.tv_sec;
2881 dest->si_tstamp.tv_nsec = src->si_tstamp.tv_nsec;
2882 dest->si_syscall = src->si_syscall;
2883 dest->si_nsysarg = src->si_nsysarg;
2884 dest->si_fault = src->si_fault;
2885 break;
2886 }
2887 }
2888
2889 #endif /* _SYSCALL32_IMPL */