xref: /illumos-gate/usr/src/uts/common/os/sig.c (revision 3d729aec)
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
psignal(proc_t * p,int sig)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
tsignal(kthread_t * t,int sig)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
signal_is_blocked(kthread_t * t,int sig)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
sig_discardable(proc_t * p,int sig)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
eat_signal(kthread_t * t,int sig)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
sigtoproc(proc_t * p,kthread_t * t,int sig)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
isjobstop(int sig)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
issig(int why)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
issig_justlooking(void)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
issig_forreal(void)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
jobstopped(proc_t * p)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
stop(int why,int what)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
utstop_init(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
add_one_utstop(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
del_one_utstop(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
utstop_timedwait(clock_t ticks)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
psig(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
fsig(k_sigset_t * ssp,kthread_t * t)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
setsigact(int sig,void (* disp)(),const k_sigset_t * mask,int flags)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
sigdefault(proc_t * p)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
sigcld(proc_t * cp,sigqueue_t * sqp)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
post_sigcld(proc_t * cp,sigqueue_t * sqp)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
sigcld_repost()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
sigqsend(int cmd,proc_t * p,kthread_t * t,sigqueue_t * sigqp)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
sigsendproc(proc_t * p,sigsend_t * pv)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
sigsendset(procset_t * psp,sigsend_t * pv)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
sigdeq(proc_t * p,kthread_t * t,int sig,sigqueue_t ** qpp)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
sigcld_delete(k_siginfo_t * ip)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
sigdelq(proc_t * p,kthread_t * t,int sig)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
sigaddqins(proc_t * p,kthread_t * t,sigqueue_t * sigqp)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
sigaddqa(proc_t * p,kthread_t * t,sigqueue_t * sigqp)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
sigaddq(proc_t * p,kthread_t * t,k_siginfo_t * infop,int km_flags)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
stop_on_fault(uint_t fault,k_siginfo_t * sip)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
sigorset(k_sigset_t * s1,const k_sigset_t * s2)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
sigandset(k_sigset_t * s1,const k_sigset_t * s2)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
sigdiffset(k_sigset_t * s1,const k_sigset_t * s2)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
sigcheck(proc_t * p,kthread_t * t)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
sigintr(k_sigset_t * smask,int intable)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
sigunintr(k_sigset_t * smask)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
sigreplace(k_sigset_t * newmask,k_sigset_t * oldmask)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
sigwillqueue(int sig,int code)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 *
sigqhdralloc(size_t size,uint_t maxcount)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 *
sigqalloc(sigqhdr_t * sqh)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
sigqrel(sigqueue_t * sq)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
sigqfree(proc_t * p)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
sigqhdrfree(sigqhdr_t * sqh)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
siginfofree(sigqueue_t * sqp)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
trapsig(k_siginfo_t * ip,int restartable)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
realsigprof_slow(int sysnum,int nsysarg,int error)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
realsigprof_fast(int sysnum,int nsysarg,int error)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
realsigprof(int sysnum,int nsysarg,int error)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
siginfo_kto32(const k_siginfo_t * src,siginfo32_t * dest)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
siginfo_32tok(const siginfo32_t * src,k_siginfo_t * dest)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 */
2890