/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (the "License").  You may not use this file except in compliance

 * with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/

/*	  All Rights Reserved  	*/

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/param.h>

#include <sys/types.h>

#include <sys/bitmap.h>

#include <sys/sysmacros.h>

#include <sys/systm.h>

#include <sys/cred.h>

#include <sys/user.h>

#include <sys/errno.h>

#include <sys/proc.h>

#include <sys/poll_impl.h> /* only needed for kludge in sigwaiting_send() */

#include <sys/signal.h>

#include <sys/siginfo.h>

#include <sys/fault.h>

#include <sys/ucontext.h>

#include <sys/procfs.h>

#include <sys/wait.h>

#include <sys/class.h>

#include <sys/mman.h>

#include <sys/procset.h>

#include <sys/kmem.h>

#include <sys/cpuvar.h>

#include <sys/prsystm.h>

#include <sys/debug.h>

#include <vm/as.h>

#include <sys/bitmap.h>

#include <c2/audit.h>

#include <sys/core.h>

#include <sys/schedctl.h>

#include <sys/contract/process_impl.h>

#include <sys/dtrace.h>

#include <sys/sdt.h>

				/* MUST be contiguous */

k_sigset_t nullsmask = {0, 0};

k_sigset_t fillset = {FILLSET0, FILLSET1};

k_sigset_t cantmask = {CANTMASK0, CANTMASK1};

k_sigset_t cantreset = {(sigmask(SIGILL)|sigmask(SIGTRAP)|sigmask(SIGPWR)), 0};

k_sigset_t ignoredefault = {(sigmask(SIGCONT)|sigmask(SIGCLD)|sigmask(SIGPWR)

			|sigmask(SIGWINCH)|sigmask(SIGURG)|sigmask(SIGWAITING)),

			(sigmask(SIGLWP)|sigmask(SIGCANCEL)|sigmask(SIGFREEZE)

			|sigmask(SIGTHAW)|sigmask(SIGXRES)|sigmask(SIGJVM1)

			|sigmask(SIGJVM2))};

k_sigset_t stopdefault = {(sigmask(SIGSTOP)|sigmask(SIGTSTP)

			|sigmask(SIGTTOU)|sigmask(SIGTTIN)), 0};

k_sigset_t coredefault = {(sigmask(SIGQUIT)|sigmask(SIGILL)|sigmask(SIGTRAP)

			|sigmask(SIGIOT)|sigmask(SIGEMT)|sigmask(SIGFPE)

			|sigmask(SIGBUS)|sigmask(SIGSEGV)|sigmask(SIGSYS)

			|sigmask(SIGXCPU)|sigmask(SIGXFSZ)), 0};

k_sigset_t holdvfork = {(sigmask(SIGTTOU)|sigmask(SIGTTIN)|sigmask(SIGTSTP)),

			0};

static	int	isjobstop(int);

static	void	post_sigcld(proc_t *, sigqueue_t *);

/*

 * Internal variables for counting number of user thread stop requests posted.

 * They may not be accurate at some special situation such as that a virtually

 * stopped thread starts to run.

 */

static int num_utstop;

/*

 * Internal variables for broadcasting an event when all thread stop requests

 * are processed.

 */

static kcondvar_t utstop_cv;

static kmutex_t thread_stop_lock;

void del_one_utstop(void);

/*

 * Send the specified signal to the specified process.

 */

void

psignal(proc_t *p, int sig)

{

	mutex_enter(&p->p_lock);

	sigtoproc(p, NULL, sig);

	mutex_exit(&p->p_lock);

}

/*

 * Send the specified signal to the specified thread.

 */

void

tsignal(kthread_t *t, int sig)

{

	proc_t *p = ttoproc(t);

	mutex_enter(&p->p_lock);

	sigtoproc(p, t, sig);

	mutex_exit(&p->p_lock);

}

int

signal_is_blocked(kthread_t *t, int sig)

{

	return (sigismember(&t->t_hold, sig) ||

	    (schedctl_sigblock(t) && !sigismember(&cantmask, sig)));

}

/*

 * Return true if the signal can safely be discarded on generation.

 * That is, if there is no need for the signal on the receiving end.

 * The answer is true if the process is a zombie or

 * if all of these conditions are true:

 *	the signal is being ignored

 *	the process is single-threaded

 *	the signal is not being traced by /proc

 * 	the signal is not blocked by the process

 */

static int

sig_discardable(proc_t *p, int sig)

{

	kthread_t *t = p->p_tlist;

	return (t == NULL ||		/* if zombie or ... */

	    (sigismember(&p->p_ignore, sig) &&	/* signal is ignored */

	    t->t_forw == t &&			/* and single-threaded */

	    !tracing(p, sig) &&			/* and no /proc tracing */

	    !signal_is_blocked(t, sig)));	/* and signal not blocked */

}

/*

 * Return true if this thread is going to eat this signal soon.

 * Note that, if the signal is SIGKILL, we force stopped threads to be

 * set running (to make SIGKILL be a sure kill), but only if the process

 * is not currently locked by /proc (the P_PR_LOCK flag).  Code in /proc

 * relies on the fact that a process will not change shape while P_PR_LOCK

 * is set (it drops and reacquires p->p_lock while leaving P_PR_LOCK set).

 * We wish that we could simply call prbarrier() below, in sigtoproc(), to

 * ensure that the process is not locked by /proc, but prbarrier() drops

 * and reacquires p->p_lock and dropping p->p_lock here would be damaging.

 */

int

eat_signal(kthread_t *t, int sig)

{

	int rval = 0;

	ASSERT(THREAD_LOCK_HELD(t));

	/*

	 * Do not do anything if the target thread has the signal blocked.

	 */

	if (!signal_is_blocked(t, sig)) {

		t->t_sig_check = 1;	/* have thread do an issig */

		if (t->t_state == TS_SLEEP && (t->t_flag & T_WAKEABLE)) {

			setrun_locked(t);

			rval = 1;

		} else if (t->t_state == TS_STOPPED && sig == SIGKILL &&

		    !(ttoproc(t)->p_proc_flag & P_PR_LOCK)) {

			ttoproc(t)->p_stopsig = 0;

			t->t_dtrace_stop = 0;

			t->t_schedflag |= TS_XSTART | TS_PSTART;

			setrun_locked(t);

		} else if (t != curthread && t->t_state == TS_ONPROC) {

			aston(t);	/* make it do issig promptly */

			if (t->t_cpu != CPU)

				poke_cpu(t->t_cpu->cpu_id);

			rval = 1;

		} else if (t->t_state == TS_RUN) {

			rval = 1;

		}

	}

	return (rval);

}

/*

 * Post a signal.

 * If a non-null thread pointer is passed, then post the signal

 * to the thread/lwp, otherwise post the signal to the process.

 */

void

sigtoproc(proc_t *p, kthread_t *t, int sig)

{

	kthread_t *tt;

	int ext = !(curproc->p_flag & SSYS) &&

	    (curproc->p_ct_process != p->p_ct_process);

	ASSERT(MUTEX_HELD(&p->p_lock));

	if (sig <= 0 || sig >= NSIG)

		return;

	/*

	 * Regardless of origin or directedness,

	 * SIGKILL kills all lwps in the process immediately

	 * and jobcontrol signals affect all lwps in the process.

	 */

	if (sig == SIGKILL) {

		p->p_flag |= SKILLED | (ext ? SEXTKILLED : 0);

		t = NULL;

	} else if (sig == SIGCONT) {

		/*

		 * The SSCONT flag will remain set until a stopping

		 * signal comes in (below).  This is harmless.

		 */

		p->p_flag |= SSCONT;

		sigdelq(p, NULL, SIGSTOP);

		sigdelq(p, NULL, SIGTSTP);

		sigdelq(p, NULL, SIGTTOU);

		sigdelq(p, NULL, SIGTTIN);

		sigdiffset(&p->p_sig, &stopdefault);

		sigdiffset(&p->p_extsig, &stopdefault);

		p->p_stopsig = 0;

		if ((tt = p->p_tlist) != NULL) {

			do {

				sigdelq(p, tt, SIGSTOP);

				sigdelq(p, tt, SIGTSTP);

				sigdelq(p, tt, SIGTTOU);

				sigdelq(p, tt, SIGTTIN);

				sigdiffset(&tt->t_sig, &stopdefault);

				sigdiffset(&tt->t_extsig, &stopdefault);

			} while ((tt = tt->t_forw) != p->p_tlist);

		}

		if ((tt = p->p_tlist) != NULL) {

			do {

				thread_lock(tt);

				if (tt->t_state == TS_STOPPED &&

				    tt->t_whystop == PR_JOBCONTROL) {

					tt->t_schedflag |= TS_XSTART;

					setrun_locked(tt);

				}

				thread_unlock(tt);

			} while ((tt = tt->t_forw) != p->p_tlist);

		}

	} else if (sigismember(&stopdefault, sig)) {

		/*

		 * This test has a race condition which we can't fix:

		 * By the time the stopping signal is received by

		 * the target process/thread, the signal handler

		 * and/or the detached state might have changed.

		 */

		if (PTOU(p)->u_signal[sig-1] == SIG_DFL &&

		    (sig == SIGSTOP || !p->p_pgidp->pid_pgorphaned))

			p->p_flag &= ~SSCONT;

		sigdelq(p, NULL, SIGCONT);

		sigdelset(&p->p_sig, SIGCONT);

		sigdelset(&p->p_extsig, SIGCONT);

		if ((tt = p->p_tlist) != NULL) {

			do {

				sigdelq(p, tt, SIGCONT);

				sigdelset(&tt->t_sig, SIGCONT);

				sigdelset(&tt->t_extsig, SIGCONT);

			} while ((tt = tt->t_forw) != p->p_tlist);

		}

	}

	if (sig_discardable(p, sig)) {

		DTRACE_PROC3(signal__discard, kthread_t *, p->p_tlist,

		    proc_t *, p, int, sig);

		return;

	}

	if (t != NULL) {

		/*

		 * This is a directed signal, wake up the lwp.

		 */

		sigaddset(&t->t_sig, sig);

		if (ext)

			sigaddset(&t->t_extsig, sig);

		thread_lock(t);

		(void) eat_signal(t, sig);

		thread_unlock(t);

		DTRACE_PROC2(signal__send, kthread_t *, t, int, sig);

	} else if ((tt = p->p_tlist) != NULL) {

		/*

		 * Make sure that some lwp that already exists

		 * in the process fields the signal soon.

		 * Wake up an interruptibly sleeping lwp if necessary.

		 */

		int su = 0;

		sigaddset(&p->p_sig, sig);

		if (ext)

			sigaddset(&p->p_extsig, sig);

		do {

			thread_lock(tt);

			if (eat_signal(tt, sig)) {

				thread_unlock(tt);

				break;

			}

			if (sig == SIGKILL && SUSPENDED(tt))

				su++;

			thread_unlock(tt);

		} while ((tt = tt->t_forw) != p->p_tlist);

		/*

		 * If the process is deadlocked, make somebody run and die.

		 */

		if (sig == SIGKILL && p->p_stat != SIDL &&

		    p->p_lwprcnt == 0 && p->p_lwpcnt == su &&

		    !(p->p_proc_flag & P_PR_LOCK)) {

			thread_lock(tt);

			p->p_lwprcnt++;

			tt->t_schedflag |= TS_CSTART;

			setrun_locked(tt);

			thread_unlock(tt);

		}

		DTRACE_PROC2(signal__send, kthread_t *, tt, int, sig);

	}

}

static int

isjobstop(int sig)

{

	proc_t *p = ttoproc(curthread);

	ASSERT(MUTEX_HELD(&p->p_lock));

	if (u.u_signal[sig-1] == SIG_DFL && sigismember(&stopdefault, sig)) {

		/*

		 * If SIGCONT has been posted since we promoted this signal

		 * from pending to current, then don't do a jobcontrol stop.

		 */

		if (!(p->p_flag & SSCONT) &&

		    (sig == SIGSTOP || !p->p_pgidp->pid_pgorphaned) &&

		    curthread != p->p_agenttp) {

			sigqueue_t *sqp;

			stop(PR_JOBCONTROL, sig);

			mutex_exit(&p->p_lock);

			sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);

			mutex_enter(&pidlock);

			/*

			 * Only the first lwp to continue notifies the parent.

			 */

			if (p->p_pidflag & CLDCONT)

				siginfofree(sqp);

			else {

				p->p_pidflag |= CLDCONT;

				p->p_wcode = CLD_CONTINUED;

				p->p_wdata = SIGCONT;

				sigcld(p, sqp);

			}

			mutex_exit(&pidlock);

			mutex_enter(&p->p_lock);

		}

		return (1);

	}

	return (0);

}

/*

 * Returns true if the current process has a signal to process, and

 * the signal is not held.  The signal to process is put in p_cursig.

 * This is asked at least once each time a process enters the system

 * (though this can usually be done without actually calling issig by

 * checking the pending signal masks).  A signal does not do anything

 * directly to a process; it sets a flag that asks the process to do

 * something to itself.

 *

 * The "why" argument indicates the allowable side-effects of the call:

 *

 * FORREAL:  Extract the next pending signal from p_sig into p_cursig;

 * stop the process if a stop has been requested or if a traced signal

 * is pending.

 *

 * JUSTLOOKING:  Don't stop the process, just indicate whether or not

 * a signal might be pending (FORREAL is needed to tell for sure).

 *

 * XXX: Changes to the logic in these routines should be propagated

 * to lm_sigispending().  See bug 1201594.

 */

static int issig_forreal(void);

static int issig_justlooking(void);

int

issig(int why)

{

	ASSERT(why == FORREAL || why == JUSTLOOKING);

	return ((why == FORREAL)? issig_forreal() : issig_justlooking());

}

static int

issig_justlooking(void)

{

	kthread_t *t = curthread;

	klwp_t *lwp = ttolwp(t);

	proc_t *p = ttoproc(t);

	k_sigset_t set;

	/*

	 * This function answers the question:

	 * "Is there any reason to call issig_forreal()?"

	 *

	 * We have to answer the question w/o grabbing any locks

	 * because we are (most likely) being called after we

	 * put ourselves on the sleep queue.

	 */

	if (t->t_dtrace_stop | t->t_dtrace_sig)

		return (1);

	/*

	 * Another piece of complexity in this process.  When single-stepping a

	 * process, we don't want an intervening signal or TP_PAUSE request to

	 * suspend the current thread.  Otherwise, the controlling process will

	 * hang beacuse we will be stopped with TS_PSTART set in t_schedflag.

	 * We will trigger any remaining signals when we re-enter the kernel on

	 * the single step trap.

	 */

	if (lwp->lwp_pcb.pcb_flags & NORMAL_STEP)

		return (0);

	if ((lwp->lwp_asleep && MUSTRETURN(p, t)) ||

	    (p->p_flag & (SEXITLWPS|SKILLED)) ||

	    (!lwp->lwp_nostop_r && ((p->p_flag & (SHOLDFORK1|SHOLDWATCH)) |

		(t->t_proc_flag & TP_HOLDLWP))) ||

	    (!lwp->lwp_nostop && (p->p_stopsig | (t->t_proc_flag &

		(TP_PRSTOP|TP_CHKPT|TP_PAUSE)))) ||

	    lwp->lwp_cursig)

		return (1);

	if (p->p_flag & SVFWAIT)

		return (0);

	set = p->p_sig;

	sigorset(&set, &t->t_sig);

	if (schedctl_sigblock(t))	/* all blockable signals blocked */

		sigandset(&set, &cantmask);

	else

		sigdiffset(&set, &t->t_hold);

	if (p->p_flag & SVFORK)

		sigdiffset(&set, &holdvfork);

	if (!sigisempty(&set)) {

		int sig;

		for (sig = 1; sig < NSIG; sig++) {

			if (sigismember(&set, sig) &&

			    (tracing(p, sig) ||

			    !sigismember(&p->p_ignore, sig))) {

				/*

				 * Don't promote a signal that will stop

				 * the process when lwp_nostop is set.

				 */

				if (!lwp->lwp_nostop ||

				    u.u_signal[sig-1] != SIG_DFL ||

				    !sigismember(&stopdefault, sig))

					return (1);

			}

		}

	}

	return (0);

}

static int

issig_forreal(void)

{

	int sig = 0, ext = 0;

	kthread_t *t = curthread;

	klwp_t *lwp = ttolwp(t);

	proc_t *p = ttoproc(t);

	int toproc = 0;

	int sigcld_found = 0;

	int nostop_break = 0;

	ASSERT(t->t_state == TS_ONPROC);

	mutex_enter(&p->p_lock);

	schedctl_finish_sigblock(t);

	if (t->t_dtrace_stop | t->t_dtrace_sig) {

		if (t->t_dtrace_stop) {

			/*

			 * If DTrace's "stop" action has been invoked on us,

			 * set TP_PRSTOP.

			 */

			t->t_proc_flag |= TP_PRSTOP;

		}

		if (t->t_dtrace_sig != 0) {

			k_siginfo_t info;

			/*

			 * Post the signal generated as the result of

			 * DTrace's "raise" action as a normal signal before

			 * the full-fledged signal checking begins.

			 */

			bzero(&info, sizeof (info));

			info.si_signo = t->t_dtrace_sig;

			info.si_code = SI_DTRACE;