signal.c 64.9 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6
/*
 *  linux/kernel/signal.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
7 8 9 10
 *
 *  2003-06-02  Jim Houston - Concurrent Computer Corp.
 *		Changes to use preallocated sigqueue structures
 *		to allow signals to be sent reliably.
Linus Torvalds's avatar
Linus Torvalds committed
11 12 13 14 15 16 17 18
 */

#include <linux/config.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/smp_lock.h>
#include <linux/init.h>
#include <linux/sched.h>
19
#include <linux/fs.h>
20 21
#include <linux/tty.h>
#include <linux/binfmts.h>
22
#include <linux/security.h>
23
#include <linux/ptrace.h>
Ingo Molnar's avatar
Ingo Molnar committed
24
#include <asm/param.h>
Linus Torvalds's avatar
Linus Torvalds committed
25
#include <asm/uaccess.h>
26
#include <asm/unistd.h>
27
#include <asm/siginfo.h>
Linus Torvalds's avatar
Linus Torvalds committed
28 29 30 31 32 33 34 35 36 37

/*
 * SLAB caches for signal bits.
 */

static kmem_cache_t *sigqueue_cachep;

atomic_t nr_queued_signals;
int max_queued_signals = 1024;

38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
/*
 * In POSIX a signal is sent either to a specific thread (Linux task)
 * or to the process as a whole (Linux thread group).  How the signal
 * is sent determines whether it's to one thread or the whole group,
 * which determines which signal mask(s) are involved in blocking it
 * from being delivered until later.  When the signal is delivered,
 * either it's caught or ignored by a user handler or it has a default
 * effect that applies to the whole thread group (POSIX process).
 *
 * The possible effects an unblocked signal set to SIG_DFL can have are:
 *   ignore	- Nothing Happens
 *   terminate	- kill the process, i.e. all threads in the group,
 * 		  similar to exit_group.  The group leader (only) reports
 *		  WIFSIGNALED status to its parent.
 *   coredump	- write a core dump file describing all threads using
 *		  the same mm and then kill all those threads
 *   stop 	- stop all the threads in the group, i.e. TASK_STOPPED state
 *
 * SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
 * Other signals when not blocked and set to SIG_DFL behaves as follows.
 * The job control signals also have other special effects.
 *
 *	+--------------------+------------------+
 *	|  POSIX signal      |  default action  |
 *	+--------------------+------------------+
 *	|  SIGHUP            |  terminate	|
 *	|  SIGINT            |	terminate	|
 *	|  SIGQUIT           |	coredump 	|
 *	|  SIGILL            |	coredump 	|
 *	|  SIGTRAP           |	coredump 	|
 *	|  SIGABRT/SIGIOT    |	coredump 	|
 *	|  SIGBUS            |	coredump 	|
 *	|  SIGFPE            |	coredump 	|
 *	|  SIGKILL           |	terminate(+)	|
 *	|  SIGUSR1           |	terminate	|
 *	|  SIGSEGV           |	coredump 	|
 *	|  SIGUSR2           |	terminate	|
 *	|  SIGPIPE           |	terminate	|
 *	|  SIGALRM           |	terminate	|
 *	|  SIGTERM           |	terminate	|
 *	|  SIGCHLD           |	ignore   	|
 *	|  SIGCONT           |	ignore(*)	|
 *	|  SIGSTOP           |	stop(*)(+)  	|
 *	|  SIGTSTP           |	stop(*)  	|
 *	|  SIGTTIN           |	stop(*)  	|
 *	|  SIGTTOU           |	stop(*)  	|
 *	|  SIGURG            |	ignore   	|
 *	|  SIGXCPU           |	coredump 	|
 *	|  SIGXFSZ           |	coredump 	|
 *	|  SIGVTALRM         |	terminate	|
 *	|  SIGPROF           |	terminate	|
 *	|  SIGPOLL/SIGIO     |	terminate	|
 *	|  SIGSYS/SIGUNUSED  |	coredump 	|
 *	|  SIGSTKFLT         |	terminate	|
 *	|  SIGWINCH          |	ignore   	|
 *	|  SIGPWR            |	terminate	|
 *	|  SIGRTMIN-SIGRTMAX |	terminate       |
 *	+--------------------+------------------+
 *	|  non-POSIX signal  |  default action  |
 *	+--------------------+------------------+
 *	|  SIGEMT            |  coredump	|
 *	+--------------------+------------------+
 *
 * (+) For SIGKILL and SIGSTOP the action is "always", not just "default".
 * (*) Special job control effects:
 * When SIGCONT is sent, it resumes the process (all threads in the group)
 * from TASK_STOPPED state and also clears any pending/queued stop signals
 * (any of those marked with "stop(*)").  This happens regardless of blocking,
 * catching, or ignoring SIGCONT.  When any stop signal is sent, it clears
 * any pending/queued SIGCONT signals; this happens regardless of blocking,
 * catching, or ignored the stop signal, though (except for SIGSTOP) the
 * default action of stopping the process may happen later or never.
110 111
 */

112 113 114 115 116 117
#ifdef SIGEMT
#define M_SIGEMT	M(SIGEMT)
#else
#define M_SIGEMT	0
#endif

118
#if SIGRTMIN > BITS_PER_LONG
Ingo Molnar's avatar
Ingo Molnar committed
119
#define M(sig) (1ULL << ((sig)-1))
120
#else
Ingo Molnar's avatar
Ingo Molnar committed
121
#define M(sig) (1UL << ((sig)-1))
122
#endif
Ingo Molnar's avatar
Ingo Molnar committed
123
#define T(sig, mask) (M(sig) & (mask))
Ingo Molnar's avatar
Ingo Molnar committed
124 125 126 127

#define SIG_KERNEL_ONLY_MASK (\
	M(SIGKILL)   |  M(SIGSTOP)                                   )

Ingo Molnar's avatar
Ingo Molnar committed
128 129 130
#define SIG_KERNEL_STOP_MASK (\
	M(SIGSTOP)   |  M(SIGTSTP)   |  M(SIGTTIN)   |  M(SIGTTOU)   )

Ingo Molnar's avatar
Ingo Molnar committed
131 132 133
#define SIG_KERNEL_COREDUMP_MASK (\
        M(SIGQUIT)   |  M(SIGILL)    |  M(SIGTRAP)   |  M(SIGABRT)   | \
        M(SIGFPE)    |  M(SIGSEGV)   |  M(SIGBUS)    |  M(SIGSYS)    | \
134
        M(SIGXCPU)   |  M(SIGXFSZ)   |  M_SIGEMT                     )
Ingo Molnar's avatar
Ingo Molnar committed
135

Ingo Molnar's avatar
Ingo Molnar committed
136 137 138
#define SIG_KERNEL_IGNORE_MASK (\
        M(SIGCONT)   |  M(SIGCHLD)   |  M(SIGWINCH)  |  M(SIGURG)    )

139 140 141 142
#define sig_kernel_only(sig) \
		(((sig) < SIGRTMIN)  && T(sig, SIG_KERNEL_ONLY_MASK))
#define sig_kernel_coredump(sig) \
		(((sig) < SIGRTMIN)  && T(sig, SIG_KERNEL_COREDUMP_MASK))
Ingo Molnar's avatar
Ingo Molnar committed
143 144 145 146
#define sig_kernel_ignore(sig) \
		(((sig) < SIGRTMIN)  && T(sig, SIG_KERNEL_IGNORE_MASK))
#define sig_kernel_stop(sig) \
		(((sig) < SIGRTMIN)  && T(sig, SIG_KERNEL_STOP_MASK))
Ingo Molnar's avatar
Ingo Molnar committed
147

Ingo Molnar's avatar
Ingo Molnar committed
148
#define sig_user_defined(t, signr) \
149 150
	(((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) &&	\
	 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
Ingo Molnar's avatar
Ingo Molnar committed
151

Ingo Molnar's avatar
Ingo Molnar committed
152 153
#define sig_fatal(t, signr) \
	(!T(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
154
	 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
Linus Torvalds's avatar
Linus Torvalds committed
155

156 157 158 159 160
#define sig_avoid_stop_race() \
	(sigtestsetmask(&current->pending.signal, M(SIGCONT) | M(SIGKILL)) || \
	 sigtestsetmask(&current->signal->shared_pending.signal, \
						  M(SIGCONT) | M(SIGKILL)))

Andrew Morton's avatar
Andrew Morton committed
161
static int sig_ignored(struct task_struct *t, int sig)
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
{
	void * handler;

	/*
	 * Tracers always want to know about signals..
	 */
	if (t->ptrace & PT_PTRACED)
		return 0;

	/*
	 * Blocked signals are never ignored, since the
	 * signal handler may change by the time it is
	 * unblocked.
	 */
	if (sigismember(&t->blocked, sig))
		return 0;

	/* Is it explicitly or implicitly ignored? */
	handler = t->sighand->action[sig-1].sa.sa_handler;
	return   handler == SIG_IGN ||
		(handler == SIG_DFL && sig_kernel_ignore(sig));
}

185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
/*
 * Re-calculate pending state from the set of locally pending
 * signals, globally pending signals, and blocked signals.
 */
static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
{
	unsigned long ready;
	long i;

	switch (_NSIG_WORDS) {
	default:
		for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
			ready |= signal->sig[i] &~ blocked->sig[i];
		break;

	case 4: ready  = signal->sig[3] &~ blocked->sig[3];
		ready |= signal->sig[2] &~ blocked->sig[2];
		ready |= signal->sig[1] &~ blocked->sig[1];
		ready |= signal->sig[0] &~ blocked->sig[0];
		break;

	case 2: ready  = signal->sig[1] &~ blocked->sig[1];
		ready |= signal->sig[0] &~ blocked->sig[0];
		break;

	case 1: ready  = signal->sig[0] &~ blocked->sig[0];
	}
	return ready !=	0;
}

Ingo Molnar's avatar
Ingo Molnar committed
215 216
#define PENDING(p,b) has_pending_signals(&(p)->signal, (b))

217
fastcall void recalc_sigpending_tsk(struct task_struct *t)
Ingo Molnar's avatar
Ingo Molnar committed
218
{
219
	if (t->signal->group_stop_count > 0 ||
Ingo Molnar's avatar
Ingo Molnar committed
220
	    PENDING(&t->pending, &t->blocked) ||
221
	    PENDING(&t->signal->shared_pending, &t->blocked))
Ingo Molnar's avatar
Ingo Molnar committed
222 223 224 225 226 227 228
		set_tsk_thread_flag(t, TIF_SIGPENDING);
	else
		clear_tsk_thread_flag(t, TIF_SIGPENDING);
}

void recalc_sigpending(void)
{
Ingo Molnar's avatar
Ingo Molnar committed
229
	recalc_sigpending_tsk(current);
Ingo Molnar's avatar
Ingo Molnar committed
230
}
Linus Torvalds's avatar
Linus Torvalds committed
231 232 233 234

/* Given the mask, find the first available signal that should be serviced. */

static int
Ingo Molnar's avatar
Ingo Molnar committed
235
next_signal(struct sigpending *pending, sigset_t *mask)
Linus Torvalds's avatar
Linus Torvalds committed
236 237 238 239
{
	unsigned long i, *s, *m, x;
	int sig = 0;
	
Ingo Molnar's avatar
Ingo Molnar committed
240
	s = pending->signal.sig;
Linus Torvalds's avatar
Linus Torvalds committed
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
	m = mask->sig;
	switch (_NSIG_WORDS) {
	default:
		for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
			if ((x = *s &~ *m) != 0) {
				sig = ffz(~x) + i*_NSIG_BPW + 1;
				break;
			}
		break;

	case 2: if ((x = s[0] &~ m[0]) != 0)
			sig = 1;
		else if ((x = s[1] &~ m[1]) != 0)
			sig = _NSIG_BPW + 1;
		else
			break;
		sig += ffz(~x);
		break;

	case 1: if ((x = *s &~ *m) != 0)
			sig = ffz(~x) + 1;
		break;
	}
	
	return sig;
}

268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
struct sigqueue *__sigqueue_alloc(void)
{
	struct sigqueue *q = 0;

	if (atomic_read(&nr_queued_signals) < max_queued_signals)
		q = kmem_cache_alloc(sigqueue_cachep, GFP_ATOMIC);
	if (q) {
		atomic_inc(&nr_queued_signals);
		INIT_LIST_HEAD(&q->list);
		q->flags = 0;
		q->lock = 0;
	}
	return(q);
}

static inline void __sigqueue_free(struct sigqueue *q)
{
	if (q->flags & SIGQUEUE_PREALLOC)
		return;
	kmem_cache_free(sigqueue_cachep, q);
	atomic_dec(&nr_queued_signals);
}

Linus Torvalds's avatar
Linus Torvalds committed
291 292
static void flush_sigqueue(struct sigpending *queue)
{
293
	struct sigqueue *q;
Linus Torvalds's avatar
Linus Torvalds committed
294 295

	sigemptyset(&queue->signal);
296 297 298 299
	while (!list_empty(&queue->list)) {
		q = list_entry(queue->list.next, struct sigqueue , list);
		list_del_init(&q->list);
		__sigqueue_free(q);
Linus Torvalds's avatar
Linus Torvalds committed
300 301 302 303 304 305 306 307 308 309
	}
}

/*
 * Flush all pending signals for a task.
 */

void
flush_signals(struct task_struct *t)
{
310 311 312
	unsigned long flags;

	spin_lock_irqsave(&t->sighand->siglock, flags);
313
	clear_tsk_thread_flag(t,TIF_SIGPENDING);
Linus Torvalds's avatar
Linus Torvalds committed
314
	flush_sigqueue(&t->pending);
315 316
	flush_sigqueue(&t->signal->shared_pending);
	spin_unlock_irqrestore(&t->sighand->siglock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
317 318
}

319 320 321 322
/*
 * This function expects the tasklist_lock write-locked.
 */
void __exit_sighand(struct task_struct *tsk)
Linus Torvalds's avatar
Linus Torvalds committed
323
{
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
	struct sighand_struct * sighand = tsk->sighand;

	/* Ok, we're done with the signal handlers */
	tsk->sighand = NULL;
	if (atomic_dec_and_test(&sighand->count))
		kmem_cache_free(sighand_cachep, sighand);
}

void exit_sighand(struct task_struct *tsk)
{
	write_lock_irq(&tasklist_lock);
	__exit_sighand(tsk);
	write_unlock_irq(&tasklist_lock);
}

/*
 * This function expects the tasklist_lock write-locked.
 */
void __exit_signal(struct task_struct *tsk)
{
	struct signal_struct * sig = tsk->signal;
	struct sighand_struct * sighand = tsk->sighand;
Linus Torvalds's avatar
Linus Torvalds committed
346

Ingo Molnar's avatar
Ingo Molnar committed
347 348 349 350
	if (!sig)
		BUG();
	if (!atomic_read(&sig->count))
		BUG();
351
	spin_lock(&sighand->siglock);
352
	if (atomic_dec_and_test(&sig->count)) {
Ingo Molnar's avatar
Ingo Molnar committed
353 354
		if (tsk == sig->curr_target)
			sig->curr_target = next_thread(tsk);
355 356
		tsk->signal = NULL;
		spin_unlock(&sighand->siglock);
357 358
		flush_sigqueue(&sig->shared_pending);
	} else {
359 360 361 362
		/*
		 * If there is any task waiting for the group exit
		 * then notify it:
		 */
363
		if (sig->group_exit_task && atomic_read(&sig->count) == sig->notify_count) {
364 365 366
			wake_up_process(sig->group_exit_task);
			sig->group_exit_task = NULL;
		}
Ingo Molnar's avatar
Ingo Molnar committed
367 368
		if (tsk == sig->curr_target)
			sig->curr_target = next_thread(tsk);
369 370
		tsk->signal = NULL;
		spin_unlock(&sighand->siglock);
371
		sig = NULL;	/* Marker for below.  */
Linus Torvalds's avatar
Linus Torvalds committed
372
	}
373
	clear_tsk_thread_flag(tsk,TIF_SIGPENDING);
Linus Torvalds's avatar
Linus Torvalds committed
374
	flush_sigqueue(&tsk->pending);
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
	if (sig) {
		/*
		 * We are cleaning up the signal_struct here.  We delayed
		 * calling exit_itimers until after flush_sigqueue, just in
		 * case our thread-local pending queue contained a queued
		 * timer signal that would have been cleared in
		 * exit_itimers.  When that called sigqueue_free, it would
		 * attempt to re-take the tasklist_lock and deadlock.  This
		 * can never happen if we ensure that all queues the
		 * timer's signal might be queued on have been flushed
		 * first.  The shared_pending queue, and our own pending
		 * queue are the only queues the timer could be on, since
		 * there are no other threads left in the group and timer
		 * signals are constrained to threads inside the group.
		 */
		exit_itimers(sig);
		kmem_cache_free(signal_cachep, sig);
	}
393 394
}

395
void exit_signal(struct task_struct *tsk)
396 397
{
	write_lock_irq(&tasklist_lock);
398
	__exit_signal(tsk);
399
	write_unlock_irq(&tasklist_lock);
Linus Torvalds's avatar
Linus Torvalds committed
400 401 402 403 404 405 406
}

/*
 * Flush all handlers for a task.
 */

void
407
flush_signal_handlers(struct task_struct *t, int force_default)
Linus Torvalds's avatar
Linus Torvalds committed
408 409
{
	int i;
410
	struct k_sigaction *ka = &t->sighand->action[0];
Linus Torvalds's avatar
Linus Torvalds committed
411
	for (i = _NSIG ; i != 0 ; i--) {
412
		if (force_default || ka->sa.sa_handler != SIG_IGN)
Linus Torvalds's avatar
Linus Torvalds committed
413 414 415 416 417 418 419
			ka->sa.sa_handler = SIG_DFL;
		ka->sa.sa_flags = 0;
		sigemptyset(&ka->sa.sa_mask);
		ka++;
	}
}

420

Linus Torvalds's avatar
Linus Torvalds committed
421 422 423 424 425 426 427 428 429 430 431 432 433
/* Notify the system that a driver wants to block all signals for this
 * process, and wants to be notified if any signals at all were to be
 * sent/acted upon.  If the notifier routine returns non-zero, then the
 * signal will be acted upon after all.  If the notifier routine returns 0,
 * then then signal will be blocked.  Only one block per process is
 * allowed.  priv is a pointer to private data that the notifier routine
 * can use to determine if the signal should be blocked or not.  */

void
block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
{
	unsigned long flags;

434
	spin_lock_irqsave(&current->sighand->siglock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
435 436 437
	current->notifier_mask = mask;
	current->notifier_data = priv;
	current->notifier = notifier;
438
	spin_unlock_irqrestore(&current->sighand->siglock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
439 440 441 442 443 444 445 446 447
}

/* Notify the system that blocking has ended. */

void
unblock_all_signals(void)
{
	unsigned long flags;

448
	spin_lock_irqsave(&current->sighand->siglock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
449 450
	current->notifier = NULL;
	current->notifier_data = NULL;
451
	recalc_sigpending();
452
	spin_unlock_irqrestore(&current->sighand->siglock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
453 454
}

Ingo Molnar's avatar
Ingo Molnar committed
455
static inline int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
Linus Torvalds's avatar
Linus Torvalds committed
456
{
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473
	struct sigqueue *q, *first = 0;
	int still_pending = 0;

	if (unlikely(!sigismember(&list->signal, sig)))
		return 0;

	/*
	 * Collect the siginfo appropriate to this signal.  Check if
	 * there is another siginfo for the same signal.
	*/
	list_for_each_entry(q, &list->list, list) {
		if (q->info.si_signo == sig) {
			if (first) {
				still_pending = 1;
				break;
			}
			first = q;
Linus Torvalds's avatar
Linus Torvalds committed
474
		}
475 476 477 478 479 480 481 482
	}
	if (first) {
		list_del_init(&first->list);
		copy_siginfo(info, &first->info);
		__sigqueue_free(first);
		if (!still_pending)
			sigdelset(&list->signal, sig);
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
483

Ingo Molnar's avatar
Ingo Molnar committed
484 485 486 487
		/* Ok, it wasn't in the queue.  This must be
		   a fast-pathed signal or we must have been
		   out of queue space.  So zero out the info.
		 */
Linus Torvalds's avatar
Linus Torvalds committed
488 489 490 491 492 493 494
		sigdelset(&list->signal, sig);
		info->si_signo = sig;
		info->si_errno = 0;
		info->si_code = 0;
		info->si_pid = 0;
		info->si_uid = 0;
	}
495
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
496 497
}

Ingo Molnar's avatar
Ingo Molnar committed
498 499
static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
			siginfo_t *info)
Linus Torvalds's avatar
Linus Torvalds committed
500 501 502
{
	int sig = 0;

Ingo Molnar's avatar
Ingo Molnar committed
503
	sig = next_signal(pending, mask);
Linus Torvalds's avatar
Linus Torvalds committed
504 505 506 507
	if (sig) {
		if (current->notifier) {
			if (sigismember(current->notifier_mask, sig)) {
				if (!(current->notifier)(current->notifier_data)) {
508
					clear_thread_flag(TIF_SIGPENDING);
Linus Torvalds's avatar
Linus Torvalds committed
509 510
					return 0;
				}
Linus Torvalds's avatar
Linus Torvalds committed
511 512 513
			}
		}

Ingo Molnar's avatar
Ingo Molnar committed
514
		if (!collect_signal(sig, pending, info))
Linus Torvalds's avatar
Linus Torvalds committed
515 516 517
			sig = 0;
				
	}
518
	recalc_sigpending();
Linus Torvalds's avatar
Linus Torvalds committed
519 520 521 522

	return sig;
}

Ingo Molnar's avatar
Ingo Molnar committed
523 524 525 526 527 528
/*
 * Dequeue a signal and return the element to the caller, which is 
 * expected to free it.
 *
 * All callers have to hold the siglock.
 */
529
int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
Ingo Molnar's avatar
Ingo Molnar committed
530
{
531
	int signr = __dequeue_signal(&tsk->pending, mask, info);
Ingo Molnar's avatar
Ingo Molnar committed
532
	if (!signr)
533
		signr = __dequeue_signal(&tsk->signal->shared_pending,
Ingo Molnar's avatar
Ingo Molnar committed
534
					 mask, info);
535 536 537 538 539
	if ( signr &&
	     ((info->si_code & __SI_MASK) == __SI_TIMER) &&
	     info->si_sys_private){
		do_schedule_next_timer(info);
	}
Ingo Molnar's avatar
Ingo Molnar committed
540 541 542 543 544 545 546 547 548 549 550 551 552 553
	return signr;
}

/*
 * Tell a process that it has a new active signal..
 *
 * NOTE! we rely on the previous spin_lock to
 * lock interrupts for us! We can only be called with
 * "siglock" held, and the local interrupt must
 * have been disabled when that got acquired!
 *
 * No need to set need_resched since signal event passing
 * goes through ->blocked
 */
554
void signal_wake_up(struct task_struct *t, int resume)
Ingo Molnar's avatar
Ingo Molnar committed
555
{
556 557
	unsigned int mask;

Ingo Molnar's avatar
Ingo Molnar committed
558
	set_tsk_thread_flag(t, TIF_SIGPENDING);
Ingo Molnar's avatar
Ingo Molnar committed
559

Ingo Molnar's avatar
Ingo Molnar committed
560
	/*
Ingo Molnar's avatar
Ingo Molnar committed
561 562 563 564 565
	 * If resume is set, we want to wake it up in the TASK_STOPPED case.
	 * We don't check for TASK_STOPPED because there is a race with it
	 * executing another processor and just now entering stopped state.
	 * By calling wake_up_process any time resume is set, we ensure
	 * the process will wake up and handle its stop or death signal.
Ingo Molnar's avatar
Ingo Molnar committed
566
	 */
567 568 569
	mask = TASK_INTERRUPTIBLE;
	if (resume)
		mask |= TASK_STOPPED;
570
	if (!wake_up_state(t, mask))
Ingo Molnar's avatar
Ingo Molnar committed
571
		kick_process(t);
Ingo Molnar's avatar
Ingo Molnar committed
572 573
}

Ingo Molnar's avatar
Ingo Molnar committed
574 575 576 577 578 579 580
/*
 * Remove signals in mask from the pending set and queue.
 * Returns 1 if any signals were found.
 *
 * All callers must be holding the siglock.
 */
static int rm_from_queue(unsigned long mask, struct sigpending *s)
Linus Torvalds's avatar
Linus Torvalds committed
581
{
582
	struct sigqueue *q, *n;
Linus Torvalds's avatar
Linus Torvalds committed
583

Ingo Molnar's avatar
Ingo Molnar committed
584
	if (!sigtestsetmask(&s->signal, mask))
Linus Torvalds's avatar
Linus Torvalds committed
585 586
		return 0;

Ingo Molnar's avatar
Ingo Molnar committed
587
	sigdelsetmask(&s->signal, mask);
588
	list_for_each_entry_safe(q, n, &s->list, list) {
Ingo Molnar's avatar
Ingo Molnar committed
589
		if (q->info.si_signo < SIGRTMIN &&
590 591 592
		    (mask & sigmask(q->info.si_signo))) {
			list_del_init(&q->list);
			__sigqueue_free(q);
Linus Torvalds's avatar
Linus Torvalds committed
593 594 595 596 597 598 599 600
		}
	}
	return 1;
}

/*
 * Bad permissions for sending the signal
 */
601 602
static int check_kill_permission(int sig, struct siginfo *info,
				 struct task_struct *t)
Linus Torvalds's avatar
Linus Torvalds committed
603
{
Ingo Molnar's avatar
Ingo Molnar committed
604 605 606 607 608
	int error = -EINVAL;
	if (sig < 0 || sig > _NSIG)
		return error;
	error = -EPERM;
	if ((!info || ((unsigned long)info != 1 &&
Ingo Molnar's avatar
Ingo Molnar committed
609
			(unsigned long)info != 2 && SI_FROMUSER(info)))
610 611
	    && ((sig != SIGCONT) ||
		(current->signal->session != t->signal->session))
Linus Torvalds's avatar
Linus Torvalds committed
612 613
	    && (current->euid ^ t->suid) && (current->euid ^ t->uid)
	    && (current->uid ^ t->suid) && (current->uid ^ t->uid)
Ingo Molnar's avatar
Ingo Molnar committed
614 615 616
	    && !capable(CAP_KILL))
		return error;
	return security_task_kill(t, info, sig);
Linus Torvalds's avatar
Linus Torvalds committed
617 618
}

Ingo Molnar's avatar
Ingo Molnar committed
619 620 621 622
/* forward decl */
static void do_notify_parent_cldstop(struct task_struct *tsk,
				     struct task_struct *parent);

Linus Torvalds's avatar
Linus Torvalds committed
623
/*
624
 * Handle magic process-wide effects of stop/continue signals.
Ingo Molnar's avatar
Ingo Molnar committed
625 626 627 628
 * Unlike the signal actions, these happen immediately at signal-generation
 * time regardless of blocking, ignoring, or handling.  This does the
 * actual continuing for SIGCONT, but not the actual stopping for stop
 * signals.  The process stop is done as a signal action for SIG_DFL.
Linus Torvalds's avatar
Linus Torvalds committed
629
 */
Ingo Molnar's avatar
Ingo Molnar committed
630
static void handle_stop_signal(int sig, struct task_struct *p)
Linus Torvalds's avatar
Linus Torvalds committed
631
{
Ingo Molnar's avatar
Ingo Molnar committed
632
	struct task_struct *t;
Linus Torvalds's avatar
Linus Torvalds committed
633

Ingo Molnar's avatar
Ingo Molnar committed
634 635 636 637
	if (sig_kernel_stop(sig)) {
		/*
		 * This is a stop signal.  Remove SIGCONT from all queues.
		 */
638
		rm_from_queue(sigmask(SIGCONT), &p->signal->shared_pending);
Ingo Molnar's avatar
Ingo Molnar committed
639 640 641 642 643
		t = p;
		do {
			rm_from_queue(sigmask(SIGCONT), &t->pending);
			t = next_thread(t);
		} while (t != p);
644
	} else if (sig == SIGCONT) {
Ingo Molnar's avatar
Ingo Molnar committed
645 646 647
		/*
		 * Remove all stop signals from all queues,
		 * and wake all threads.
648 649
		 */
		if (unlikely(p->signal->group_stop_count > 0)) {
Ingo Molnar's avatar
Ingo Molnar committed
650 651 652 653 654 655 656 657 658 659 660 661
			/*
			 * There was a group stop in progress.  We'll
			 * pretend it finished before we got here.  We are
			 * obliged to report it to the parent: if the
			 * SIGSTOP happened "after" this SIGCONT, then it
			 * would have cleared this pending SIGCONT.  If it
			 * happened "before" this SIGCONT, then the parent
			 * got the SIGCHLD about the stop finishing before
			 * the continue happened.  We do the notification
			 * now, and it's as if the stop had finished and
			 * the SIGCHLD was pending on entry to this kill.
			 */
662
			p->signal->group_stop_count = 0;
Ingo Molnar's avatar
Ingo Molnar committed
663 664 665 666 667 668 669
			if (p->ptrace & PT_PTRACED)
				do_notify_parent_cldstop(p, p->parent);
			else
				do_notify_parent_cldstop(
					p->group_leader,
					p->group_leader->real_parent);
		}
670
		rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
Ingo Molnar's avatar
Ingo Molnar committed
671 672
		t = p;
		do {
673
			unsigned int state;
Ingo Molnar's avatar
Ingo Molnar committed
674
			rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
675
			
676 677 678 679 680 681 682 683 684
			/*
			 * If there is a handler for SIGCONT, we must make
			 * sure that no thread returns to user mode before
			 * we post the signal, in case it was the only
			 * thread eligible to run the signal handler--then
			 * it must not do anything between resuming and
			 * running the handler.  With the TIF_SIGPENDING
			 * flag set, the thread will pause and acquire the
			 * siglock that we hold now and until we've queued
685
			 * the pending signal. 
686 687 688
			 *
			 * Wake up the stopped thread _after_ setting
			 * TIF_SIGPENDING
689
			 */
690
			state = TASK_STOPPED;
691
			if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
692
				set_tsk_thread_flag(t, TIF_SIGPENDING);
693 694 695
				state |= TASK_INTERRUPTIBLE;
			}
			wake_up_state(t, state);
696

Ingo Molnar's avatar
Ingo Molnar committed
697 698
			t = next_thread(t);
		} while (t != p);
Linus Torvalds's avatar
Linus Torvalds committed
699 700 701 702 703 704
	}
}

static int send_signal(int sig, struct siginfo *info, struct sigpending *signals)
{
	struct sigqueue * q = NULL;
705
	int ret = 0;
Linus Torvalds's avatar
Linus Torvalds committed
706

Ingo Molnar's avatar
Ingo Molnar committed
707 708 709 710 711 712 713
	/*
	 * fast-pathed signals for kernel-internal things like SIGSTOP
	 * or SIGKILL.
	 */
	if ((unsigned long)info == 2)
		goto out_set;

Linus Torvalds's avatar
Linus Torvalds committed
714 715 716 717 718 719 720 721
	/* Real-time signals must be queued if sent by sigqueue, or
	   some other real-time mechanism.  It is implementation
	   defined whether kill() does so.  We attempt to do so, on
	   the principle of least surprise, but since kill is not
	   allowed to fail with EAGAIN when low on memory we just
	   make sure at least one signal gets delivered and don't
	   pass on the info struct.  */

Ingo Molnar's avatar
Ingo Molnar committed
722
	if (atomic_read(&nr_queued_signals) < max_queued_signals)
Linus Torvalds's avatar
Linus Torvalds committed
723 724 725 726
		q = kmem_cache_alloc(sigqueue_cachep, GFP_ATOMIC);

	if (q) {
		atomic_inc(&nr_queued_signals);
727 728
		q->flags = 0;
		list_add_tail(&q->list, &signals->list);
Linus Torvalds's avatar
Linus Torvalds committed
729
		switch ((unsigned long) info) {
730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
		case 0:
			q->info.si_signo = sig;
			q->info.si_errno = 0;
			q->info.si_code = SI_USER;
			q->info.si_pid = current->pid;
			q->info.si_uid = current->uid;
			break;
		case 1:
			q->info.si_signo = sig;
			q->info.si_errno = 0;
			q->info.si_code = SI_KERNEL;
			q->info.si_pid = 0;
			q->info.si_uid = 0;
			break;
		default:
			copy_siginfo(&q->info, info);
			break;
Linus Torvalds's avatar
Linus Torvalds committed
747
		}
748 749
	} else {
		if (sig >= SIGRTMIN && info && (unsigned long)info != 1
Ingo Molnar's avatar
Ingo Molnar committed
750
		   && info->si_code != SI_USER)
Linus Torvalds's avatar
Linus Torvalds committed
751 752 753 754
		/*
		 * Queue overflow, abort.  We may abort if the signal was rt
		 * and sent by user using something other than kill().
		 */
755 756 757 758 759 760 761 762
			return -EAGAIN;
		if (((unsigned long)info > 1) && (info->si_code == SI_TIMER))
			/*
			 * Set up a return to indicate that we dropped 
			 * the signal.
			 */
			ret = info->si_sys_private;
	}
Linus Torvalds's avatar
Linus Torvalds committed
763

Ingo Molnar's avatar
Ingo Molnar committed
764
out_set:
Linus Torvalds's avatar
Linus Torvalds committed
765
	sigaddset(&signals->signal, sig);
766
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
767 768
}

Ingo Molnar's avatar
Ingo Molnar committed
769 770
#define LEGACY_QUEUE(sigptr, sig) \
	(((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
Linus Torvalds's avatar
Linus Torvalds committed
771 772


Ingo Molnar's avatar
Ingo Molnar committed
773
static int
Ingo Molnar's avatar
Ingo Molnar committed
774
specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
Linus Torvalds's avatar
Linus Torvalds committed
775
{
776
	int ret = 0;
Linus Torvalds's avatar
Linus Torvalds committed
777

Ingo Molnar's avatar
Ingo Molnar committed
778 779
	if (!irqs_disabled())
		BUG();
780
#ifdef CONFIG_SMP
781
	if (!spin_is_locked(&t->sighand->siglock))
Ingo Molnar's avatar
Ingo Molnar committed
782
		BUG();
Linus Torvalds's avatar
Linus Torvalds committed
783 784
#endif

785 786 787 788 789 790
	if (((unsigned long)info > 2) && (info->si_code == SI_TIMER))
		/*
		 * Set up a return to indicate that we dropped the signal.
		 */
		ret = info->si_sys_private;

Ingo Molnar's avatar
Ingo Molnar committed
791 792
	/* Short-circuit ignored signals.  */
	if (sig_ignored(t, sig))
793
		goto out;
Ingo Molnar's avatar
Ingo Molnar committed
794

795 796 797 798
	/* Support queueing exactly one non-rt signal, so that we
	   can get more detailed information about the cause of
	   the signal. */
	if (LEGACY_QUEUE(&t->pending, sig))
799
		goto out;
Ingo Molnar's avatar
Ingo Molnar committed
800 801 802 803

	ret = send_signal(sig, info, &t->pending);
	if (!ret && !sigismember(&t->blocked, sig))
		signal_wake_up(t, sig == SIGKILL);
804
out:
Linus Torvalds's avatar
Linus Torvalds committed
805 806 807 808 809 810 811 812 813 814 815 816
	return ret;
}

/*
 * Force a signal that the process can't ignore: if necessary
 * we unblock the signal and change any SIG_IGN to SIG_DFL.
 */

int
force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
	unsigned long int flags;
Ingo Molnar's avatar
Ingo Molnar committed
817
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
818

819
	spin_lock_irqsave(&t->sighand->siglock, flags);
820
	if (sigismember(&t->blocked, sig) || t->sighand->action[sig-1].sa.sa_handler == SIG_IGN) {
821
		t->sighand->action[sig-1].sa.sa_handler = SIG_DFL;
822 823 824
		sigdelset(&t->blocked, sig);
		recalc_sigpending_tsk(t);
	}
Ingo Molnar's avatar
Ingo Molnar committed
825
	ret = specific_send_sig_info(sig, info, t);
826
	spin_unlock_irqrestore(&t->sighand->siglock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
827

Ingo Molnar's avatar
Ingo Molnar committed
828
	return ret;
Ingo Molnar's avatar
Ingo Molnar committed
829 830
}

831 832 833 834 835
void
force_sig_specific(int sig, struct task_struct *t)
{
	unsigned long int flags;

836 837 838
	spin_lock_irqsave(&t->sighand->siglock, flags);
	if (t->sighand->action[sig-1].sa.sa_handler == SIG_IGN)
		t->sighand->action[sig-1].sa.sa_handler = SIG_DFL;
839 840
	sigdelset(&t->blocked, sig);
	recalc_sigpending_tsk(t);
Ingo Molnar's avatar
Ingo Molnar committed
841
	specific_send_sig_info(sig, (void *)2, t);
842
	spin_unlock_irqrestore(&t->sighand->siglock, flags);
843 844
}

Ingo Molnar's avatar
Ingo Molnar committed
845 846 847 848 849 850 851 852
/*
 * Test if P wants to take SIG.  After we've checked all threads with this,
 * it's equivalent to finding no threads not blocking SIG.  Any threads not
 * blocking SIG were ruled out because they are not running and already
 * have pending signals.  Such threads will dequeue from the shared queue
 * as soon as they're available, so putting the signal on the shared queue
 * will be equivalent to sending it to one such thread.
 */
853 854 855 856 857
#define wants_signal(sig, p, mask) 			\
	(!sigismember(&(p)->blocked, sig)		\
	 && !((p)->state & mask)			\
	 && !((p)->flags & PF_EXITING)			\
	 && (task_curr(p) || !signal_pending(p)))
Ingo Molnar's avatar
Ingo Molnar committed
858

859

860
static void
861
__group_complete_signal(int sig, struct task_struct *p, unsigned int mask)
Ingo Molnar's avatar
Ingo Molnar committed
862
{
Ingo Molnar's avatar
Ingo Molnar committed
863
	struct task_struct *t;
Ingo Molnar's avatar
Ingo Molnar committed
864 865

	/*
Ingo Molnar's avatar
Ingo Molnar committed
866 867 868 869 870
	 * Now find a thread we can wake up to take the signal off the queue.
	 *
	 * If the main thread wants the signal, it gets first crack.
	 * Probably the least surprising to the average bear.
	 */
871
	if (wants_signal(sig, p, mask))
Ingo Molnar's avatar
Ingo Molnar committed
872 873 874 875 876 877
		t = p;
	else if (thread_group_empty(p))
		/*
		 * There is just one thread and it does not need to be woken.
		 * It will dequeue unblocked signals before it runs again.
		 */
878
		return;
Ingo Molnar's avatar
Ingo Molnar committed
879 880
	else {
		/*
881 882 883
		 * Otherwise try to find a suitable thread.
		 */
		t = p->signal->curr_target;
Ingo Molnar's avatar
Ingo Molnar committed
884
		if (t == NULL)
885 886
			/* restart balancing at this thread */
			t = p->signal->curr_target = p;
Ingo Molnar's avatar
Ingo Molnar committed
887
		BUG_ON(t->tgid != p->tgid);
Ingo Molnar's avatar
Ingo Molnar committed
888

889
		while (!wants_signal(sig, t, mask)) {
Ingo Molnar's avatar
Ingo Molnar committed
890
			t = next_thread(t);
891 892
			if (t == p->signal->curr_target)
				/*
Ingo Molnar's avatar
Ingo Molnar committed
893 894 895
				 * No thread needs to be woken.
				 * Any eligible threads will see
				 * the signal in the queue soon.
896
				 */
897
				return;
Ingo Molnar's avatar
Ingo Molnar committed
898
		}
899
		p->signal->curr_target = t;
Ingo Molnar's avatar
Ingo Molnar committed
900
	}
Ingo Molnar's avatar
Ingo Molnar committed
901

Ingo Molnar's avatar
Ingo Molnar committed
902
	/*
Ingo Molnar's avatar
Ingo Molnar committed
903 904
	 * Found a killable thread.  If the signal will be fatal,
	 * then start taking the whole group down immediately.
Ingo Molnar's avatar
Ingo Molnar committed
905
	 */
906
	if (sig_fatal(p, sig) && !p->signal->group_exit &&
Ingo Molnar's avatar
Ingo Molnar committed
907 908 909 910 911 912 913 914 915 916 917 918
	    !sigismember(&t->real_blocked, sig) &&
	    (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
		/*
		 * This signal will be fatal to the whole group.
		 */
		if (!sig_kernel_coredump(sig)) {
			/*
			 * Start a group exit and wake everybody up.
			 * This way we don't have other threads
			 * running and doing things after a slower
			 * thread has the fatal signal pending.
			 */
919 920 921
			p->signal->group_exit = 1;
			p->signal->group_exit_code = sig;
			p->signal->group_stop_count = 0;
Ingo Molnar's avatar
Ingo Molnar committed
922 923 924 925 926 927
			t = p;
			do {
				sigaddset(&t->pending.signal, SIGKILL);
				signal_wake_up(t, 1);
				t = next_thread(t);
			} while (t != p);
928
			return;
Ingo Molnar's avatar
Ingo Molnar committed
929
		}
Ingo Molnar's avatar
Ingo Molnar committed
930

Ingo Molnar's avatar
Ingo Molnar committed
931 932 933 934 935 936 937 938 939 940 941
		/*
		 * There will be a core dump.  We make all threads other
		 * than the chosen one go into a group stop so that nothing
		 * happens until it gets scheduled, takes the signal off
		 * the shared queue, and does the core dump.  This is a
		 * little more complicated than strictly necessary, but it
		 * keeps the signal state that winds up in the core dump
		 * unchanged from the death state, e.g. which thread had
		 * the core-dump signal unblocked.
		 */
		rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
942 943 944
		rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
		p->signal->group_stop_count = 0;
		p->signal->group_exit_task = t;
Ingo Molnar's avatar
Ingo Molnar committed
945 946
		t = p;
		do {
947
			p->signal->group_stop_count++;
Ingo Molnar's avatar
Ingo Molnar committed
948 949 950
			signal_wake_up(t, 0);
			t = next_thread(t);
		} while (t != p);
951
		wake_up_process(p->signal->group_exit_task);
952
		return;
Ingo Molnar's avatar
Ingo Molnar committed
953
	}
954

Ingo Molnar's avatar
Ingo Molnar committed
955 956 957 958 959
	/*
	 * The signal is already in the shared-pending queue.
	 * Tell the chosen thread to wake up and dequeue it.
	 */
	signal_wake_up(t, sig == SIGKILL);
960 961 962
	return;
}

963
static int
964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006
__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
	unsigned int mask;
	int ret = 0;

#ifdef CONFIG_SMP
	if (!spin_is_locked(&p->sighand->siglock))
		BUG();
#endif
	handle_stop_signal(sig, p);

	if (((unsigned long)info > 2) && (info->si_code == SI_TIMER))
		/*
		 * Set up a return to indicate that we dropped the signal.
		 */
		ret = info->si_sys_private;

	/* Short-circuit ignored signals.  */
	if (sig_ignored(p, sig))
		return ret;

	if (LEGACY_QUEUE(&p->signal->shared_pending, sig))
		/* This is a non-RT signal and we already have one queued.  */
		return ret;

	/*
	 * Don't bother zombies and stopped tasks (but
	 * SIGKILL will punch through stopped state)
	 */
	mask = TASK_DEAD | TASK_ZOMBIE;
	if (sig != SIGKILL)
		mask |= TASK_STOPPED;

	/*
	 * Put this signal on the shared-pending queue, or fail with EAGAIN.
	 * We always use the shared queue for process-wide signals,
	 * to avoid several races.
	 */
	ret = send_signal(sig, info, &p->signal->shared_pending);
	if (unlikely(ret))
		return ret;

	__group_complete_signal(sig, p, mask);
Ingo Molnar's avatar
Ingo Molnar committed
1007
	return 0;
1008 1009
}

Ingo Molnar's avatar
Ingo Molnar committed
1010 1011 1012 1013
/*
 * Nuke all other threads in the group.
 */
void zap_other_threads(struct task_struct *p)
Ingo Molnar's avatar
Ingo Molnar committed
1014
{
1015
	struct task_struct *t;
Ingo Molnar's avatar
Ingo Molnar committed
1016

1017
	p->signal->group_stop_count = 0;
Ingo Molnar's avatar
Ingo Molnar committed
1018

Ingo Molnar's avatar
Ingo Molnar committed
1019 1020
	if (thread_group_empty(p))
		return;
Ingo Molnar's avatar
Ingo Molnar committed
1021

Ingo Molnar's avatar
Ingo Molnar committed
1022
	for (t = next_thread(p); t != p; t = next_thread(t)) {
1023 1024 1025
		/*
		 * Don't bother with already dead threads
		 */
1026
		if (t->state & (TASK_ZOMBIE|TASK_DEAD))
1027 1028
			continue;

1029 1030 1031 1032 1033
		/*
		 * We don't want to notify the parent, since we are
		 * killed as part of a thread group due to another
		 * thread doing an execve() or similar. So set the
		 * exit signal to -1 to allow immediate reaping of
1034 1035
		 * the process.  But don't detach the thread group
		 * leader.
1036
		 */
1037 1038
		if (t != p->group_leader)
			t->exit_signal = -1;
1039

Ingo Molnar's avatar
Ingo Molnar committed
1040 1041 1042
		sigaddset(&t->pending.signal, SIGKILL);
		rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
		signal_wake_up(t, 1);
Ingo Molnar's avatar
Ingo Molnar committed
1043
	}
Ingo Molnar's avatar
Ingo Molnar committed
1044 1045
}

1046 1047 1048 1049
/*
 * Must be called with the tasklist_lock held for reading!
 */
int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
Ingo Molnar's avatar
Ingo Molnar committed
1050 1051 1052 1053
{
	unsigned long flags;
	int ret;

Ingo Molnar's avatar
Ingo Molnar committed
1054
	ret = check_kill_permission(sig, info, p);
1055 1056
	if (!ret && sig && p->sighand) {
		spin_lock_irqsave(&p->sighand->siglock, flags);
Ingo Molnar's avatar
Ingo Molnar committed
1057
		ret = __group_send_sig_info(sig, info, p);
1058
		spin_unlock_irqrestore(&p->sighand->siglock, flags);
Ingo Molnar's avatar
Ingo Molnar committed
1059
	}
Ingo Molnar's avatar
Ingo Molnar committed
1060

Ingo Molnar's avatar
Ingo Molnar committed
1061
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1062 1063 1064 1065 1066 1067 1068
}

/*
 * kill_pg_info() sends a signal to a process group: this is what the tty
 * control characters do (^C, ^Z etc)
 */

1069
int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
Linus Torvalds's avatar
Linus Torvalds committed
1070
{
1071 1072 1073
	struct task_struct *p;
	struct list_head *l;
	struct pid *pid;
1074
	int retval, success;
1075 1076 1077 1078

	if (pgrp <= 0)
		return -EINVAL;

1079 1080
	success = 0;
	retval = -ESRCH;
1081
	for_each_task_pid(pgrp, PIDTYPE_PGID, p, l, pid) {
1082 1083 1084
		int err = group_send_sig_info(sig, info, p);
		success |= !err;
		retval = err;
Linus Torvalds's avatar
Linus Torvalds committed
1085
	}
1086
	return success ? 0 : retval;
Linus Torvalds's avatar
Linus Torvalds committed
1087 1088
}

1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
int
kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
{
	int retval;

	read_lock(&tasklist_lock);
	retval = __kill_pg_info(sig, info, pgrp);
	read_unlock(&tasklist_lock);

	return retval;
}

Linus Torvalds's avatar
Linus Torvalds committed
1101 1102 1103 1104 1105 1106
/*
 * kill_sl_info() sends a signal to the session leader: this is used
 * to send SIGHUP to the controlling process of a terminal when
 * the connection is lost.
 */

1107

Linus Torvalds's avatar
Linus Torvalds committed
1108
int
1109
kill_sl_info(int sig, struct siginfo *info, pid_t sid)
Linus Torvalds's avatar
Linus Torvalds committed
1110
{
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
	int err, retval = -EINVAL;
	struct pid *pid;
	struct list_head *l;
	struct task_struct *p;

	if (sid <= 0)
		goto out;

	retval = -ESRCH;
	read_lock(&tasklist_lock);
	for_each_task_pid(sid, PIDTYPE_SID, p, l, pid) {
1122
		if (!p->signal->leader)
1123
			continue;
Ingo Molnar's avatar
Ingo Molnar committed
1124
		err = group_send_sig_info(sig, info, p);
1125 1126
		if (retval)
			retval = err;
Linus Torvalds's avatar
Linus Torvalds committed
1127
	}
1128 1129
	read_unlock(&tasklist_lock);
out:
Linus Torvalds's avatar
Linus Torvalds committed
1130 1131 1132
	return retval;
}

1133
int
Linus Torvalds's avatar
Linus Torvalds committed
1134 1135 1136 1137 1138 1139 1140 1141
kill_proc_info(int sig, struct siginfo *info, pid_t pid)
{
	int error;
	struct task_struct *p;

	read_lock(&tasklist_lock);
	p = find_task_by_pid(pid);
	error = -ESRCH;
Ingo Molnar's avatar
Ingo Molnar committed
1142
	if (p)
Ingo Molnar's avatar
Ingo Molnar committed
1143
		error = group_send_sig_info(sig, info, p);
Linus Torvalds's avatar
Linus Torvalds committed
1144 1145 1146 1147 1148 1149 1150 1151
	read_unlock(&tasklist_lock);
	return error;
}


/*
 * kill_something_info() interprets pid in interesting ways just like kill(2).
 *
Linus Torvalds's avatar
Linus Torvalds committed
1152 1153
 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
 * is probably wrong.  Should make it like BSD or SYSV.
Linus Torvalds's avatar
Linus Torvalds committed
1154 1155 1156 1157 1158
 */

static int kill_something_info(int sig, struct siginfo *info, int pid)
{
	if (!pid) {
1159
		return kill_pg_info(sig, info, process_group(current));
Linus Torvalds's avatar
Linus Torvalds committed
1160 1161 1162 1163 1164
	} else if (pid == -1) {
		int retval = 0, count = 0;
		struct task_struct * p;

		read_lock(&tasklist_lock);
Ingo Molnar's avatar
Ingo Molnar committed
1165
		for_each_process(p) {
Ingo Molnar's avatar
Ingo Molnar committed
1166 1167
			if (p->pid > 1 && p->tgid != current->tgid) {
				int err = group_send_sig_info(sig, info, p);
Linus Torvalds's avatar
Linus Torvalds committed
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
				++count;
				if (err != -EPERM)
					retval = err;
			}
		}
		read_unlock(&tasklist_lock);
		return count ? retval : -ESRCH;
	} else if (pid < 0) {
		return kill_pg_info(sig, info, -pid);
	} else {
		return kill_proc_info(sig, info, pid);
	}
}

/*
 * These are for backward compatibility with the rest of the kernel source.
 */

1186
/*
1187 1188
 * These two are the most common entry points.  They send a signal
 * just to the specific thread.
1189
 */
Ingo Molnar's avatar
Ingo Molnar committed
1190 1191 1192
int
send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
1193
	int ret;
1194
	unsigned long flags;
1195

1196 1197 1198 1199 1200 1201 1202
	/*
	 * We need the tasklist lock even for the specific
	 * thread case (when we don't need to follow the group
	 * lists) in order to avoid races with "p->sighand"
	 * going away or changing from under us.
	 */
	read_lock(&tasklist_lock);  
1203
	spin_lock_irqsave(&p->sighand->siglock, flags);
1204
	ret = specific_send_sig_info(sig, info, p);
1205
	spin_unlock_irqrestore(&p->sighand->siglock, flags);
1206
	read_unlock(&tasklist_lock);
1207
	return ret;
Ingo Molnar's avatar
Ingo Molnar committed
1208 1209
}

Linus Torvalds's avatar
Linus Torvalds committed
1210 1211 1212 1213 1214 1215
int
send_sig(int sig, struct task_struct *p, int priv)
{
	return send_sig_info(sig, (void*)(long)(priv != 0), p);
}

1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
/*
 * This is the entry point for "process-wide" signals.
 * They will go to an appropriate thread in the thread group.
 */
int
send_group_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
	int ret;
	read_lock(&tasklist_lock);
	ret = group_send_sig_info(sig, info, p);
	read_unlock(&tasklist_lock);
	return ret;
}

Linus Torvalds's avatar
Linus Torvalds committed
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
void
force_sig(int sig, struct task_struct *p)
{
	force_sig_info(sig, (void*)1L, p);
}

int
kill_pg(pid_t pgrp, int sig, int priv)
{
	return kill_pg_info(sig, (void *)(long)(priv != 0), pgrp);
}

int
kill_sl(pid_t sess, int sig, int priv)
{
	return kill_sl_info(sig, (void *)(long)(priv != 0), sess);
}

int
kill_proc(pid_t pid, int sig, int priv)
{
	return kill_proc_info(sig, (void *)(long)(priv != 0), pid);
}

1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389
/*
 * These functions support sending signals using preallocated sigqueue
 * structures.  This is needed "because realtime applications cannot
 * afford to lose notifications of asynchronous events, like timer
 * expirations or I/O completions".  In the case of Posix Timers 
 * we allocate the sigqueue structure from the timer_create.  If this
 * allocation fails we are able to report the failure to the application
 * with an EAGAIN error.
 */
 
struct sigqueue *sigqueue_alloc(void)
{
	struct sigqueue *q;

	if ((q = __sigqueue_alloc()))
		q->flags |= SIGQUEUE_PREALLOC;
	return(q);
}

void sigqueue_free(struct sigqueue *q)
{
	unsigned long flags;
	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
	/*
	 * If the signal is still pending remove it from the
	 * pending queue.
	 */
	if (unlikely(!list_empty(&q->list))) {
		read_lock(&tasklist_lock);  
		spin_lock_irqsave(q->lock, flags);
		if (!list_empty(&q->list))
			list_del_init(&q->list);
		spin_unlock_irqrestore(q->lock, flags);
		read_unlock(&tasklist_lock);
	}
	q->flags &= ~SIGQUEUE_PREALLOC;
	__sigqueue_free(q);
}

int
send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
{
	unsigned long flags;
	int ret = 0;

	/*
	 * We need the tasklist lock even for the specific
	 * thread case (when we don't need to follow the group
	 * lists) in order to avoid races with "p->sighand"
	 * going away or changing from under us.
	 */
	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
	read_lock(&tasklist_lock);  
	spin_lock_irqsave(&p->sighand->siglock, flags);
	
	if (unlikely(!list_empty(&q->list))) {
		/*
		 * If an SI_TIMER entry is already queue just increment
		 * the overrun count.
		 */
		if (q->info.si_code != SI_TIMER)
			BUG();
		q->info.si_overrun++;
		goto out;
	} 
	/* Short-circuit ignored signals.  */
	if (sig_ignored(p, sig)) {
		ret = 1;
		goto out;
	}

	q->lock = &p->sighand->siglock;
	list_add_tail(&q->list, &p->pending.list);
	sigaddset(&p->pending.signal, sig);
	if (!sigismember(&p->blocked, sig))
		signal_wake_up(p, sig == SIGKILL);

out:
	spin_unlock_irqrestore(&p->sighand->siglock, flags);
	read_unlock(&tasklist_lock);
	return(ret);
}

int
send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
{
	unsigned long flags;
	unsigned int mask;
	int ret = 0;

	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
	read_lock(&tasklist_lock);
	spin_lock_irqsave(&p->sighand->siglock, flags);
	handle_stop_signal(sig, p);

	/* Short-circuit ignored signals.  */
	if (sig_ignored(p, sig)) {
		ret = 1;
		goto out;
	}

	if (unlikely(!list_empty(&q->list))) {
		/*
		 * If an SI_TIMER entry is already queue just increment
		 * the overrun count.  Other uses should not try to
		 * send the signal multiple times.
		 */
		if (q->info.si_code != SI_TIMER)
			BUG();
		q->info.si_overrun++;
		goto out;
	} 
	/*
	 * Don't bother zombies and stopped tasks (but
	 * SIGKILL will punch through stopped state)
	 */
	mask = TASK_DEAD | TASK_ZOMBIE;
	if (sig != SIGKILL)
		mask |= TASK_STOPPED;

	/*
	 * Put this signal on the shared-pending queue.
	 * We always use the shared queue for process-wide signals,
	 * to avoid several races.
	 */
	q->lock = &p->sighand->siglock;
	list_add_tail(&q->list, &p->signal->shared_pending.list);
	sigaddset(&p->signal->shared_pending.signal, sig);

	__group_complete_signal(sig, p, mask);
out:
	spin_unlock_irqrestore(&p->sighand->siglock, flags);
	read_unlock(&tasklist_lock);
	return(ret);
}

Linus Torvalds's avatar
Linus Torvalds committed
1390 1391 1392 1393
/*
 * Joy. Or not. Pthread wants us to wake up every thread
 * in our parent group.
 */
1394
static void __wake_up_parent(struct task_struct *p,
Ingo Molnar's avatar
Ingo Molnar committed
1395
				    struct task_struct *parent)
Linus Torvalds's avatar
Linus Torvalds committed
1396
{
Ingo Molnar's avatar
Ingo Molnar committed
1397
	struct task_struct *tsk = parent;
Linus Torvalds's avatar
Linus Torvalds committed
1398

Ingo Molnar's avatar
Ingo Molnar committed
1399 1400 1401 1402
	/*
	 * Fortunately this is not necessary for thread groups:
	 */
	if (p->tgid == tsk->tgid) {
1403
		wake_up_interruptible_sync(&tsk->wait_chldexit);
Ingo Molnar's avatar
Ingo Molnar committed
1404 1405
		return;
	}
Ingo Molnar's avatar
Ingo Molnar committed
1406

Linus Torvalds's avatar
Linus Torvalds committed
1407
	do {
1408
		wake_up_interruptible_sync(&tsk->wait_chldexit);
Linus Torvalds's avatar
Linus Torvalds committed
1409
		tsk = next_thread(tsk);
1410
		if (tsk->signal != parent->signal)
Ingo Molnar's avatar
Ingo Molnar committed
1411
			BUG();
Linus Torvalds's avatar
Linus Torvalds committed
1412 1413 1414 1415 1416 1417
	} while (tsk != parent);
}

/*
 * Let a parent know about a status change of a child.
 */
Ingo Molnar's avatar
Ingo Molnar committed
1418

Linus Torvalds's avatar
Linus Torvalds committed
1419 1420 1421
void do_notify_parent(struct task_struct *tsk, int sig)
{
	struct siginfo info;
Ingo Molnar's avatar
Ingo Molnar committed
1422
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
1423
	int why, status;
1424
	struct sighand_struct *psig;
Linus Torvalds's avatar
Linus Torvalds committed
1425

1426
	if (sig == -1)
1427 1428
		BUG();

1429 1430 1431
	BUG_ON(tsk->group_leader != tsk && tsk->group_leader->state != TASK_ZOMBIE && !tsk->ptrace);
	BUG_ON(tsk->group_leader == tsk && !thread_group_empty(tsk) && !tsk->ptrace);

Linus Torvalds's avatar
Linus Torvalds committed
1432 1433 1434 1435 1436 1437
	info.si_signo = sig;
	info.si_errno = 0;
	info.si_pid = tsk->pid;
	info.si_uid = tsk->uid;

	/* FIXME: find out whether or not this is supposed to be c*time. */
1438 1439
	info.si_utime = tsk->utime;
	info.si_stime = tsk->stime;
Linus Torvalds's avatar
Linus Torvalds committed
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465

	status = tsk->exit_code & 0x7f;
	why = SI_KERNEL;	/* shouldn't happen */
	switch (tsk->state) {
	case TASK_STOPPED:
		/* FIXME -- can we deduce CLD_TRAPPED or CLD_CONTINUED? */
		if (tsk->ptrace & PT_PTRACED)
			why = CLD_TRAPPED;
		else
			why = CLD_STOPPED;
		break;

	default:
		if (tsk->exit_code & 0x80)
			why = CLD_DUMPED;
		else if (tsk->exit_code & 0x7f)
			why = CLD_KILLED;
		else {
			why = CLD_EXITED;
			status = tsk->exit_code >> 8;
		}
		break;
	}
	info.si_code = why;
	info.si_status = status;

1466
	psig = tsk->parent->sighand;
Ingo Molnar's avatar
Ingo Molnar committed
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493
	spin_lock_irqsave(&psig->siglock, flags);
	if (sig == SIGCHLD && tsk->state != TASK_STOPPED &&
	    (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
	     (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
		/*
		 * We are exiting and our parent doesn't care.  POSIX.1
		 * defines special semantics for setting SIGCHLD to SIG_IGN
		 * or setting the SA_NOCLDWAIT flag: we should be reaped
		 * automatically and not left for our parent's wait4 call.
		 * Rather than having the parent do it as a magic kind of
		 * signal handler, we just set this to tell do_exit that we
		 * can be cleaned up without becoming a zombie.  Note that
		 * we still call __wake_up_parent in this case, because a
		 * blocked sys_wait4 might now return -ECHILD.
		 *
		 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
		 * is implementation-defined: we do (if you don't want
		 * it, just use SIG_IGN instead).
		 */
		tsk->exit_signal = -1;
		if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
			sig = 0;
	}
	if (sig > 0 && sig <= _NSIG)
		__group_send_sig_info(sig, &info, tsk->parent);
	__wake_up_parent(tsk, tsk->parent);
	spin_unlock_irqrestore(&psig->siglock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506
}


/*
 * We need the tasklist lock because it's the only
 * thing that protects out "parent" pointer.
 *
 * exit.c calls "do_notify_parent()" directly, because
 * it already has the tasklist lock.
 */
void
notify_parent(struct task_struct *tsk, int sig)
{
1507 1508 1509 1510 1511
	if (sig != -1) {
		read_lock(&tasklist_lock);
		do_notify_parent(tsk, sig);
		read_unlock(&tasklist_lock);
	}
Linus Torvalds's avatar
Linus Torvalds committed
1512 1513
}

Ingo Molnar's avatar
Ingo Molnar committed
1514 1515 1516 1517 1518
static void
do_notify_parent_cldstop(struct task_struct *tsk, struct task_struct *parent)
{
	struct siginfo info;
	unsigned long flags;
1519
	struct sighand_struct *sighand;
Ingo Molnar's avatar
Ingo Molnar committed
1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532

	info.si_signo = SIGCHLD;
	info.si_errno = 0;
	info.si_pid = tsk->pid;
	info.si_uid = tsk->uid;

	/* FIXME: find out whether or not this is supposed to be c*time. */
	info.si_utime = tsk->utime;
	info.si_stime = tsk->stime;

	info.si_status = tsk->exit_code & 0x7f;
	info.si_code = CLD_STOPPED;

1533 1534 1535 1536
	sighand = parent->sighand;
	spin_lock_irqsave(&sighand->siglock, flags);
	if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
	    !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
Ingo Molnar's avatar
Ingo Molnar committed
1537 1538 1539 1540 1541
		__group_send_sig_info(SIGCHLD, &info, parent);
	/*
	 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
	 */
	__wake_up_parent(tsk, parent);
1542
	spin_unlock_irqrestore(&sighand->siglock, flags);
Ingo Molnar's avatar
Ingo Molnar committed
1543 1544
}

1545 1546 1547

#ifndef HAVE_ARCH_GET_SIGNAL_TO_DELIVER

Ingo Molnar's avatar
Ingo Molnar committed
1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581
static void
finish_stop(int stop_count)
{
	/*
	 * If there are no other threads in the group, or if there is
	 * a group stop in progress and we are the last to stop,
	 * report to the parent.  When ptraced, every thread reports itself.
	 */
	if (stop_count < 0 || (current->ptrace & PT_PTRACED)) {
		read_lock(&tasklist_lock);
		do_notify_parent_cldstop(current, current->parent);
		read_unlock(&tasklist_lock);
	}
	else if (stop_count == 0) {
		read_lock(&tasklist_lock);
		do_notify_parent_cldstop(current->group_leader,
					 current->group_leader->real_parent);
		read_unlock(&tasklist_lock);
	}

	schedule();
	/*
	 * Now we don't run again until continued.
	 */
	current->exit_code = 0;
}

/*
 * This performs the stopping for SIGSTOP and other stop signals.
 * We have to stop all threads in the thread group.
 */
static void
do_signal_stop(int signr)
{
1582 1583
	struct signal_struct *sig = current->signal;
	struct sighand_struct *sighand = current->sighand;
Ingo Molnar's avatar
Ingo Molnar committed
1584 1585
	int stop_count = -1;

1586 1587
	/* spin_lock_irq(&sighand->siglock) is now done in caller */

Ingo Molnar's avatar
Ingo Molnar committed
1588 1589 1590 1591 1592 1593 1594 1595 1596
	if (sig->group_stop_count > 0) {
		/*
		 * There is a group stop in progress.  We don't need to
		 * start another one.
		 */
		signr = sig->group_exit_code;
		stop_count = --sig->group_stop_count;
		current->exit_code = signr;
		set_current_state(TASK_STOPPED);
1597
		spin_unlock_irq(&sighand->siglock);
Ingo Molnar's avatar
Ingo Molnar committed
1598 1599 1600
	}
	else if (thread_group_empty(current)) {
		/*
1601
		 * Lock must be held through transition to stopped state.
Ingo Molnar's avatar
Ingo Molnar committed
1602 1603 1604
		 */
		current->exit_code = signr;
		set_current_state(TASK_STOPPED);
1605
		spin_unlock_irq(&sighand->siglock);
Ingo Molnar's avatar
Ingo Molnar committed
1606 1607 1608 1609
	}
	else {
		/*
		 * There is no group stop already in progress.
1610 1611 1612 1613 1614
		 * We must initiate one now, but that requires
		 * dropping siglock to get both the tasklist lock
		 * and siglock again in the proper order.  Note that
		 * this allows an intervening SIGCONT to be posted.
		 * We need to check for that and bail out if necessary.
Ingo Molnar's avatar
Ingo Molnar committed
1615 1616
		 */
		struct task_struct *t;
1617 1618 1619 1620 1621

		spin_unlock_irq(&sighand->siglock);

		/* signals can be posted during this window */

Ingo Molnar's avatar
Ingo Molnar committed
1622
		read_lock(&tasklist_lock);
1623
		spin_lock_irq(&sighand->siglock);
Ingo Molnar's avatar
Ingo Molnar committed
1624 1625 1626 1627 1628 1629 1630

		if (unlikely(sig->group_exit)) {
			/*
			 * There is a group exit in progress now.
			 * We'll just ignore the stop and process the
			 * associated fatal signal.
			 */
1631
			spin_unlock_irq(&sighand->siglock);
Ingo Molnar's avatar
Ingo Molnar committed
1632 1633 1634 1635
			read_unlock(&tasklist_lock);
			return;
		}

1636 1637 1638 1639 1640 1641 1642 1643 1644 1645
		if (unlikely(sig_avoid_stop_race())) {
			/*
			 * Either a SIGCONT or a SIGKILL signal was
			 * posted in the siglock-not-held window.
			 */
			spin_unlock_irq(&sighand->siglock);
			read_unlock(&tasklist_lock);
			return;
		}

Ingo Molnar's avatar
Ingo Molnar committed
1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
		if (sig->group_stop_count == 0) {
			sig->group_exit_code = signr;
			stop_count = 0;
			for (t = next_thread(current); t != current;
			     t = next_thread(t))
				/*
				 * Setting state to TASK_STOPPED for a group
				 * stop is always done with the siglock held,
				 * so this check has no races.
				 */
				if (t->state < TASK_STOPPED) {
					stop_count++;
					signal_wake_up(t, 0);
				}
			sig->group_stop_count = stop_count;
		}
		else {
			/* A race with another thread while unlocked.  */
			signr = sig->group_exit_code;
			stop_count = --sig->group_stop_count;
		}

		current->exit_code = signr;
		set_current_state(TASK_STOPPED);

1671
		spin_unlock_irq(&sighand->siglock);
Ingo Molnar's avatar
Ingo Molnar committed
1672 1673 1674 1675 1676 1677
		read_unlock(&tasklist_lock);
	}

	finish_stop(stop_count);
}

1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
/*
 * Do appropriate magic when group_stop_count > 0.
 * We return nonzero if we stopped, after releasing the siglock.
 * We return zero if we still hold the siglock and should look
 * for another signal without checking group_stop_count again.
 */
static inline int handle_group_stop(void)
{
	int stop_count;

	if (current->signal->group_exit_task == current) {
		/*
		 * Group stop is so we can do a core dump,
		 * We are the initiating thread, so get on with it.
		 */
		current->signal->group_exit_task = NULL;
		return 0;
	}

	if (current->signal->group_exit)
		/*
		 * Group stop is so another thread can do a core dump,
		 * or else we are racing against a death signal.
		 * Just punt the stop so we can get the next signal.
		 */
		return 0;

	/*
	 * There is a group stop in progress.  We stop
	 * without any associated signal being in our queue.
	 */
	stop_count = --current->signal->group_stop_count;
	current->exit_code = current->signal->group_exit_code;
	set_current_state(TASK_STOPPED);
	spin_unlock_irq(&current->sighand->siglock);
	finish_stop(stop_count);
	return 1;
}

1717
int get_signal_to_deliver(siginfo_t *info, struct pt_regs *regs, void *cookie)
1718
{
Ingo Molnar's avatar
Ingo Molnar committed
1719
	sigset_t *mask = &current->blocked;
1720
	int signr = 0;
Ingo Molnar's avatar
Ingo Molnar committed
1721

1722 1723
relock:
	spin_lock_irq(&current->sighand->siglock);
1724 1725 1726
	for (;;) {
		struct k_sigaction *ka;

1727 1728
		if (unlikely(current->signal->group_stop_count > 0) &&
		    handle_group_stop())
1729 1730
			goto relock;

1731
		signr = dequeue_signal(current, mask, info);
1732 1733

		if (!signr)
1734
			break; /* will return 0 */
1735 1736

		if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1737 1738
			ptrace_signal_deliver(regs, cookie);

Ingo Molnar's avatar
Ingo Molnar committed
1739 1740 1741 1742
			/*
			 * If there is a group stop in progress,
			 * we must participate in the bookkeeping.
			 */
1743
			if (current->signal->group_stop_count > 0)
1744
				--current->signal->group_stop_count;
Ingo Molnar's avatar
Ingo Molnar committed
1745

1746 1747
			/* Let the debugger run.  */
			current->exit_code = signr;
1748
			current->last_siginfo = info;
1749
			set_current_state(TASK_STOPPED);
1750
			spin_unlock_irq(&current->sighand->siglock);
1751 1752 1753
			notify_parent(current, SIGCHLD);
			schedule();

1754 1755
			current->last_siginfo = NULL;

1756
			/* We're back.  Did the debugger cancel the sig?  */
1757
			spin_lock_irq(&current->sighand->siglock);
1758 1759 1760
			signr = current->exit_code;
			if (signr == 0)
				continue;
1761

1762 1763
			current->exit_code = 0;

1764 1765 1766 1767
			/* Update the siginfo structure if the signal has
			   changed.  If the debugger wanted something
			   specific in the siginfo structure then it should
			   have updated *info via PTRACE_SETSIGINFO.  */
1768 1769 1770 1771 1772 1773 1774 1775 1776 1777
			if (signr != info->si_signo) {
				info->si_signo = signr;
				info->si_errno = 0;
				info->si_code = SI_USER;
				info->si_pid = current->parent->pid;
				info->si_uid = current->parent->uid;
			}

			/* If the (new) signal is now blocked, requeue it.  */
			if (sigismember(&current->blocked, signr)) {
Ingo Molnar's avatar
Ingo Molnar committed
1778
				specific_send_sig_info(signr, info, current);
1779 1780 1781 1782
				continue;
			}
		}

1783
		ka = &current->sighand->action[signr-1];
Ingo Molnar's avatar
Ingo Molnar committed
1784
		if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
1785
			continue;
Ingo Molnar's avatar
Ingo Molnar committed
1786
		if (ka->sa.sa_handler != SIG_DFL) /* Run the handler.  */
1787
			break; /* will return non-zero "signr" value */
1788

Ingo Molnar's avatar
Ingo Molnar committed
1789 1790 1791 1792 1793
		/*
		 * Now we are doing the default action for this signal.
		 */
		if (sig_kernel_ignore(signr)) /* Default is nothing. */
			continue;
1794

1795 1796 1797
		/* Init gets no signals it doesn't want.  */
		if (current->pid == 1)
			continue;
1798

Ingo Molnar's avatar
Ingo Molnar committed
1799 1800 1801 1802 1803
		if (sig_kernel_stop(signr)) {
			/*
			 * The default action is to stop all threads in
			 * the thread group.  The job control signals
			 * do nothing in an orphaned pgrp, but SIGSTOP
1804 1805 1806 1807 1808
			 * always works.  Note that siglock needs to be
			 * dropped during the call to is_orphaned_pgrp()
			 * because of lock ordering with tasklist_lock.
			 * This allows an intervening SIGCONT to be posted.
			 * We need to check for that and bail out if necessary.
Ingo Molnar's avatar
Ingo Molnar committed
1809
			 */
1810 1811 1812 1813 1814 1815 1816 1817
			if (signr == SIGSTOP) {
				do_signal_stop(signr); /* releases siglock */
				goto relock;
			}
			spin_unlock_irq(&current->sighand->siglock);

			/* signals can be posted during this window */

1818
			if (is_orphaned_pgrp(process_group(current)))
1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831
				goto relock;

			spin_lock_irq(&current->sighand->siglock);
			if (unlikely(sig_avoid_stop_race())) {
				/*
				 * Either a SIGCONT or a SIGKILL signal was
				 * posted in the siglock-not-held window.
				 */
				continue;
			}

			do_signal_stop(signr); /* releases siglock */
			goto relock;
1832
		}
1833

1834 1835
		spin_unlock_irq(&current->sighand->siglock);

Ingo Molnar's avatar
Ingo Molnar committed
1836 1837 1838 1839 1840
		/*
		 * Anything else is fatal, maybe with a core dump.
		 */
		current->flags |= PF_SIGNALED;
		if (sig_kernel_coredump(signr) &&
1841
		    do_coredump((long)signr, signr, regs)) {
Ingo Molnar's avatar
Ingo Molnar committed
1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
			/*
			 * That killed all other threads in the group and
			 * synchronized with their demise, so there can't
			 * be any more left to kill now.  The group_exit
			 * flags are set by do_coredump.  Note that
			 * thread_group_empty won't always be true yet,
			 * because those threads were blocked in __exit_mm
			 * and we just let them go to finish dying.
			 */
			const int code = signr | 0x80;
1852 1853
			BUG_ON(!current->signal->group_exit);
			BUG_ON(current->signal->group_exit_code != code);
Ingo Molnar's avatar
Ingo Molnar committed
1854
			do_exit(code);
1855 1856
			/* NOTREACHED */
		}
Ingo Molnar's avatar
Ingo Molnar committed
1857 1858 1859 1860 1861 1862

		/*
		 * Death signals, no core dump.
		 */
		do_group_exit(signr);
		/* NOTREACHED */
1863
	}
1864 1865
	spin_unlock_irq(&current->sighand->siglock);
	return signr;
1866 1867 1868 1869
}

#endif

1870
EXPORT_SYMBOL(recalc_sigpending);
Ingo Molnar's avatar
Ingo Molnar committed
1871
EXPORT_SYMBOL_GPL(dequeue_signal);
Linus Torvalds's avatar
Linus Torvalds committed
1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883
EXPORT_SYMBOL(flush_signals);
EXPORT_SYMBOL(force_sig);
EXPORT_SYMBOL(force_sig_info);
EXPORT_SYMBOL(kill_pg);
EXPORT_SYMBOL(kill_pg_info);
EXPORT_SYMBOL(kill_proc);
EXPORT_SYMBOL(kill_proc_info);
EXPORT_SYMBOL(kill_sl);
EXPORT_SYMBOL(kill_sl_info);
EXPORT_SYMBOL(notify_parent);
EXPORT_SYMBOL(send_sig);
EXPORT_SYMBOL(send_sig_info);
1884
EXPORT_SYMBOL(send_group_sig_info);
1885 1886 1887 1888
EXPORT_SYMBOL(sigqueue_alloc);
EXPORT_SYMBOL(sigqueue_free);
EXPORT_SYMBOL(send_sigqueue);
EXPORT_SYMBOL(send_group_sigqueue);
1889
EXPORT_SYMBOL(sigprocmask);
Linus Torvalds's avatar
Linus Torvalds committed
1890 1891 1892 1893 1894 1895 1896 1897
EXPORT_SYMBOL(block_all_signals);
EXPORT_SYMBOL(unblock_all_signals);


/*
 * System call entry points.
 */

1898 1899
asmlinkage long sys_restart_syscall(void)
{
1900 1901
	struct restart_block *restart = &current_thread_info()->restart_block;
	return restart->fn(restart);
1902 1903 1904 1905 1906 1907 1908
}

long do_no_restart_syscall(struct restart_block *param)
{
	return -EINTR;
}

Linus Torvalds's avatar
Linus Torvalds committed
1909 1910 1911 1912 1913 1914
/*
 * We don't need to get the kernel lock - this is all local to this
 * particular thread.. (and that's good, because this is _heavily_
 * used by various programs)
 */

1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939
/*
 * This is also useful for kernel threads that want to temporarily
 * (or permanently) block certain signals.
 *
 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
 * interface happily blocks "unblockable" signals like SIGKILL
 * and friends.
 */
int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
{
	int error;
	sigset_t old_block;

	spin_lock_irq(&current->sighand->siglock);
	old_block = current->blocked;
	error = 0;
	switch (how) {
	case SIG_BLOCK:
		sigorsets(&current->blocked, &current->blocked, set);
		break;
	case SIG_UNBLOCK:
		signandsets(&current->blocked, &current->blocked, set);
		break;
	case SIG_SETMASK:
		current->blocked = *set;
1940
		break;
1941 1942 1943 1944 1945 1946 1947 1948 1949 1950
	default:
		error = -EINVAL;
	}
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);
	if (oldset)
		*oldset = old_block;
	return error;
}

Linus Torvalds's avatar
Linus Torvalds committed
1951
asmlinkage long
1952
sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
Linus Torvalds's avatar
Linus Torvalds committed
1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966
{
	int error = -EINVAL;
	sigset_t old_set, new_set;

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(sigset_t))
		goto out;

	if (set) {
		error = -EFAULT;
		if (copy_from_user(&new_set, set, sizeof(*set)))
			goto out;
		sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));

1967
		error = sigprocmask(how, &new_set, &old_set);
Linus Torvalds's avatar
Linus Torvalds committed
1968 1969 1970 1971 1972
		if (error)
			goto out;
		if (oset)
			goto set_old;
	} else if (oset) {
1973
		spin_lock_irq(&current->sighand->siglock);
Linus Torvalds's avatar
Linus Torvalds committed
1974
		old_set = current->blocked;
1975
		spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds's avatar
Linus Torvalds committed
1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986

	set_old:
		error = -EFAULT;
		if (copy_to_user(oset, &old_set, sizeof(*oset)))
			goto out;
	}
	error = 0;
out:
	return error;
}

1987
long do_sigpending(void __user *set, unsigned long sigsetsize)
Linus Torvalds's avatar
Linus Torvalds committed
1988 1989 1990 1991 1992 1993 1994
{
	long error = -EINVAL;
	sigset_t pending;

	if (sigsetsize > sizeof(sigset_t))
		goto out;

1995
	spin_lock_irq(&current->sighand->siglock);
Ingo Molnar's avatar
Ingo Molnar committed
1996
	sigorsets(&pending, &current->pending.signal,
1997 1998
		  &current->signal->shared_pending.signal);
	spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds's avatar
Linus Torvalds committed
1999

Ingo Molnar's avatar
Ingo Molnar committed
2000 2001 2002
	/* Outside the lock because only this thread touches it.  */
	sigandsets(&pending, &current->blocked, &pending);

Linus Torvalds's avatar
Linus Torvalds committed
2003 2004 2005
	error = -EFAULT;
	if (!copy_to_user(set, &pending, sigsetsize))
		error = 0;
Ingo Molnar's avatar
Ingo Molnar committed
2006

Linus Torvalds's avatar
Linus Torvalds committed
2007 2008 2009 2010 2011
out:
	return error;
}	

asmlinkage long
2012
sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
Linus Torvalds's avatar
Linus Torvalds committed
2013 2014 2015 2016
{
	return do_sigpending(set, sigsetsize);
}

2017 2018
#ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER

2019
int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2020
{
2021 2022
	int err;

2023 2024 2025
	if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
		return -EFAULT;
	if (from->si_code < 0)
2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
		return __copy_to_user(to, from, sizeof(siginfo_t))
			? -EFAULT : 0;
	/*
	 * If you change siginfo_t structure, please be sure
	 * this code is fixed accordingly.
	 * It should never copy any pad contained in the structure
	 * to avoid security leaks, but must copy the generic
	 * 3 ints plus the relevant union member.
	 */
	err = __put_user(from->si_signo, &to->si_signo);
	err |= __put_user(from->si_errno, &to->si_errno);
	err |= __put_user((short)from->si_code, &to->si_code);
	switch (from->si_code & __SI_MASK) {
	case __SI_KILL:
2040
		err |= __put_user(from->si_pid, &to->si_pid);
2041 2042 2043
		err |= __put_user(from->si_uid, &to->si_uid);
		break;
	case __SI_TIMER:
2044 2045 2046
		 err |= __put_user(from->si_tid, &to->si_tid);
		 err |= __put_user(from->si_overrun, &to->si_overrun);
		 err |= __put_user(from->si_ptr, &to->si_ptr);
2047 2048 2049 2050 2051 2052 2053
		break;
	case __SI_POLL:
		err |= __put_user(from->si_band, &to->si_band);
		err |= __put_user(from->si_fd, &to->si_fd);
		break;
	case __SI_FAULT:
		err |= __put_user(from->si_addr, &to->si_addr);
2054 2055 2056
#ifdef __ARCH_SI_TRAPNO
		err |= __put_user(from->si_trapno, &to->si_trapno);
#endif
2057 2058 2059 2060 2061 2062 2063 2064 2065
		break;
	case __SI_CHLD:
		err |= __put_user(from->si_pid, &to->si_pid);
		err |= __put_user(from->si_uid, &to->si_uid);
		err |= __put_user(from->si_status, &to->si_status);
		err |= __put_user(from->si_utime, &to->si_utime);
		err |= __put_user(from->si_stime, &to->si_stime);
		break;
	case __SI_RT: /* This is not generated by the kernel as of now. */
2066
	case __SI_MESGQ: /* But this is */
2067 2068 2069 2070 2071 2072 2073 2074
		err |= __put_user(from->si_pid, &to->si_pid);
		err |= __put_user(from->si_uid, &to->si_uid);
		err |= __put_user(from->si_ptr, &to->si_ptr);
		break;
	default: /* this is just in case for now ... */
		err |= __put_user(from->si_pid, &to->si_pid);
		err |= __put_user(from->si_uid, &to->si_uid);
		break;
2075
	}
2076
	return err;
2077 2078 2079 2080
}

#endif

Linus Torvalds's avatar
Linus Torvalds committed
2081
asmlinkage long
2082 2083 2084 2085
sys_rt_sigtimedwait(const sigset_t __user *uthese,
		    siginfo_t __user *uinfo,
		    const struct timespec __user *uts,
		    size_t sigsetsize)
Linus Torvalds's avatar
Linus Torvalds committed
2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114
{
	int ret, sig;
	sigset_t these;
	struct timespec ts;
	siginfo_t info;
	long timeout = 0;

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(sigset_t))
		return -EINVAL;

	if (copy_from_user(&these, uthese, sizeof(these)))
		return -EFAULT;
		
	/*
	 * Invert the set of allowed signals to get those we
	 * want to block.
	 */
	sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
	signotset(&these);

	if (uts) {
		if (copy_from_user(&ts, uts, sizeof(ts)))
			return -EFAULT;
		if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
		    || ts.tv_sec < 0)
			return -EINVAL;
	}

2115
	spin_lock_irq(&current->sighand->siglock);
2116
	sig = dequeue_signal(current, &these, &info);
Linus Torvalds's avatar
Linus Torvalds committed
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
	if (!sig) {
		timeout = MAX_SCHEDULE_TIMEOUT;
		if (uts)
			timeout = (timespec_to_jiffies(&ts)
				   + (ts.tv_sec || ts.tv_nsec));

		if (timeout) {
			/* None ready -- temporarily unblock those we're
			 * interested while we are sleeping in so that we'll
			 * be awakened when they arrive.  */
Ingo Molnar's avatar
Ingo Molnar committed
2127
			current->real_blocked = current->blocked;
Linus Torvalds's avatar
Linus Torvalds committed
2128
			sigandsets(&current->blocked, &current->blocked, &these);
2129
			recalc_sigpending();
2130
			spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds's avatar
Linus Torvalds committed
2131 2132 2133 2134

			current->state = TASK_INTERRUPTIBLE;
			timeout = schedule_timeout(timeout);

2135
			spin_lock_irq(&current->sighand->siglock);
2136
			sig = dequeue_signal(current, &these, &info);
Ingo Molnar's avatar
Ingo Molnar committed
2137 2138
			current->blocked = current->real_blocked;
			siginitset(&current->real_blocked, 0);
2139
			recalc_sigpending();
Linus Torvalds's avatar
Linus Torvalds committed
2140 2141
		}
	}
2142
	spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds's avatar
Linus Torvalds committed
2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166

	if (sig) {
		ret = sig;
		if (uinfo) {
			if (copy_siginfo_to_user(uinfo, &info))
				ret = -EFAULT;
		}
	} else {
		ret = -EAGAIN;
		if (timeout)
			ret = -EINTR;
	}

	return ret;
}

asmlinkage long
sys_kill(int pid, int sig)
{
	struct siginfo info;

	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_USER;
2167
	info.si_pid = current->tgid;
Linus Torvalds's avatar
Linus Torvalds committed
2168 2169 2170 2171 2172
	info.si_uid = current->uid;

	return kill_something_info(sig, &info, pid);
}

2173
/**
2174
 *  sys_tgkill - send signal to one specific thread
2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218
 *  @tgid: the thread group ID of the thread
 *  @pid: the PID of the thread
 *  @sig: signal to be sent
 *
 *  This syscall also checks the tgid and returns -ESRCH even if the PID
 *  exists but it's not belonging to the target process anymore. This
 *  method solves the problem of threads exiting and PIDs getting reused.
 */
asmlinkage long sys_tgkill(int tgid, int pid, int sig)
{
	struct siginfo info;
	int error;
	struct task_struct *p;

	/* This is only valid for single tasks */
	if (pid <= 0 || tgid <= 0)
		return -EINVAL;

	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_TKILL;
	info.si_pid = current->tgid;
	info.si_uid = current->uid;

	read_lock(&tasklist_lock);
	p = find_task_by_pid(pid);
	error = -ESRCH;
	if (p && (p->tgid == tgid)) {
		error = check_kill_permission(sig, &info, p);
		/*
		 * The null signal is a permissions and process existence
		 * probe.  No signal is actually delivered.
		 */
		if (!error && sig && p->sighand) {
			spin_lock_irq(&p->sighand->siglock);
			handle_stop_signal(sig, p);
			error = specific_send_sig_info(sig, &info, p);
			spin_unlock_irq(&p->sighand->siglock);
		}
	}
	read_unlock(&tasklist_lock);
	return error;
}

2219
/*
Ingo Molnar's avatar
Ingo Molnar committed
2220
 *  Send a signal to only one task, even if it's a CLONE_THREAD task.
2221 2222 2223 2224
 */
asmlinkage long
sys_tkill(int pid, int sig)
{
Ingo Molnar's avatar
Ingo Molnar committed
2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235
	struct siginfo info;
	int error;
	struct task_struct *p;

	/* This is only valid for single tasks */
	if (pid <= 0)
		return -EINVAL;

	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_TKILL;
2236
	info.si_pid = current->tgid;
Ingo Molnar's avatar
Ingo Molnar committed
2237 2238 2239 2240 2241 2242
	info.si_uid = current->uid;

	read_lock(&tasklist_lock);
	p = find_task_by_pid(pid);
	error = -ESRCH;
	if (p) {
Ingo Molnar's avatar
Ingo Molnar committed
2243 2244 2245 2246 2247
		error = check_kill_permission(sig, &info, p);
		/*
		 * The null signal is a permissions and process existence
		 * probe.  No signal is actually delivered.
		 */
2248 2249
		if (!error && sig && p->sighand) {
			spin_lock_irq(&p->sighand->siglock);
Ingo Molnar's avatar
Ingo Molnar committed
2250 2251
			handle_stop_signal(sig, p);
			error = specific_send_sig_info(sig, &info, p);
2252
			spin_unlock_irq(&p->sighand->siglock);
Ingo Molnar's avatar
Ingo Molnar committed
2253
		}
Ingo Molnar's avatar
Ingo Molnar committed
2254 2255 2256
	}
	read_unlock(&tasklist_lock);
	return error;
2257 2258
}

Linus Torvalds's avatar
Linus Torvalds committed
2259
asmlinkage long
2260
sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
Linus Torvalds's avatar
Linus Torvalds committed
2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281
{
	siginfo_t info;

	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
		return -EFAULT;

	/* Not even root can pretend to send signals from the kernel.
	   Nor can they impersonate a kill(), which adds source info.  */
	if (info.si_code >= 0)
		return -EPERM;
	info.si_signo = sig;

	/* POSIX.1b doesn't mention process groups.  */
	return kill_proc_info(sig, &info, pid);
}

int
do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact)
{
	struct k_sigaction *k;

Ingo Molnar's avatar
Ingo Molnar committed
2282
	if (sig < 1 || sig > _NSIG || (act && sig_kernel_only(sig)))
Linus Torvalds's avatar
Linus Torvalds committed
2283 2284
		return -EINVAL;

2285
	k = &current->sighand->action[sig-1];
Linus Torvalds's avatar
Linus Torvalds committed
2286

2287
	spin_lock_irq(&current->sighand->siglock);
Ingo Molnar's avatar
Ingo Molnar committed
2288 2289 2290 2291 2292
	if (signal_pending(current)) {
		/*
		 * If there might be a fatal signal pending on multiple
		 * threads, make sure we take it before changing the action.
		 */
2293
		spin_unlock_irq(&current->sighand->siglock);
2294
		return -ERESTARTNOINTR;
Ingo Molnar's avatar
Ingo Molnar committed
2295
	}
Linus Torvalds's avatar
Linus Torvalds committed
2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311

	if (oact)
		*oact = *k;

	if (act) {
		/*
		 * POSIX 3.3.1.3:
		 *  "Setting a signal action to SIG_IGN for a signal that is
		 *   pending shall cause the pending signal to be discarded,
		 *   whether or not it is blocked."
		 *
		 *  "Setting a signal action to SIG_DFL for a signal that is
		 *   pending and whose default action is to ignore the signal
		 *   (for example, SIGCHLD), shall cause the pending signal to
		 *   be discarded, whether or not it is blocked"
		 */
2312 2313 2314 2315 2316 2317 2318 2319 2320
		if (act->sa.sa_handler == SIG_IGN ||
		    (act->sa.sa_handler == SIG_DFL &&
		     sig_kernel_ignore(sig))) {
			/*
			 * This is a fairly rare case, so we only take the
			 * tasklist_lock once we're sure we'll need it.
			 * Now we must do this little unlock and relock
			 * dance to maintain the lock hierarchy.
			 */
Ingo Molnar's avatar
Ingo Molnar committed
2321
			struct task_struct *t = current;
2322
			spin_unlock_irq(&t->sighand->siglock);
2323
			read_lock(&tasklist_lock);
2324
			spin_lock_irq(&t->sighand->siglock);
2325 2326 2327
			*k = *act;
			sigdelsetmask(&k->sa.sa_mask,
				      sigmask(SIGKILL) | sigmask(SIGSTOP));
2328
			rm_from_queue(sigmask(sig), &t->signal->shared_pending);
Ingo Molnar's avatar
Ingo Molnar committed
2329 2330 2331 2332 2333
			do {
				rm_from_queue(sigmask(sig), &t->pending);
				recalc_sigpending_tsk(t);
				t = next_thread(t);
			} while (t != current);
2334 2335
			spin_unlock_irq(&current->sighand->siglock);
			read_unlock(&tasklist_lock);
2336 2337
			return 0;
		}
Ingo Molnar's avatar
Ingo Molnar committed
2338

2339 2340 2341 2342 2343
		*k = *act;
		sigdelsetmask(&k->sa.sa_mask,
			      sigmask(SIGKILL) | sigmask(SIGSTOP));
	}

2344
	spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds's avatar
Linus Torvalds committed
2345 2346 2347 2348
	return 0;
}

int 
2349
do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
Linus Torvalds's avatar
Linus Torvalds committed
2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372
{
	stack_t oss;
	int error;

	if (uoss) {
		oss.ss_sp = (void *) current->sas_ss_sp;
		oss.ss_size = current->sas_ss_size;
		oss.ss_flags = sas_ss_flags(sp);
	}

	if (uss) {
		void *ss_sp;
		size_t ss_size;
		int ss_flags;

		error = -EFAULT;
		if (verify_area(VERIFY_READ, uss, sizeof(*uss))
		    || __get_user(ss_sp, &uss->ss_sp)
		    || __get_user(ss_flags, &uss->ss_flags)
		    || __get_user(ss_size, &uss->ss_size))
			goto out;

		error = -EPERM;
2373
		if (on_sig_stack(sp))
Linus Torvalds's avatar
Linus Torvalds committed
2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411
			goto out;

		error = -EINVAL;
		/*
		 *
		 * Note - this code used to test ss_flags incorrectly
		 *  	  old code may have been written using ss_flags==0
		 *	  to mean ss_flags==SS_ONSTACK (as this was the only
		 *	  way that worked) - this fix preserves that older
		 *	  mechanism
		 */
		if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
			goto out;

		if (ss_flags == SS_DISABLE) {
			ss_size = 0;
			ss_sp = NULL;
		} else {
			error = -ENOMEM;
			if (ss_size < MINSIGSTKSZ)
				goto out;
		}

		current->sas_ss_sp = (unsigned long) ss_sp;
		current->sas_ss_size = ss_size;
	}

	if (uoss) {
		error = -EFAULT;
		if (copy_to_user(uoss, &oss, sizeof(oss)))
			goto out;
	}

	error = 0;
out:
	return error;
}

2412 2413
#ifdef __ARCH_WANT_SYS_SIGPENDING

Linus Torvalds's avatar
Linus Torvalds committed
2414
asmlinkage long
2415
sys_sigpending(old_sigset_t __user *set)
Linus Torvalds's avatar
Linus Torvalds committed
2416 2417 2418 2419
{
	return do_sigpending(set, sizeof(*set));
}

2420 2421 2422 2423 2424
#endif

#ifdef __ARCH_WANT_SYS_SIGPROCMASK
/* Some platforms have their own version with special arguments others
   support only sys_rt_sigprocmask.  */
Linus Torvalds's avatar
Linus Torvalds committed
2425 2426

asmlinkage long
2427
sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
Linus Torvalds's avatar
Linus Torvalds committed
2428 2429 2430 2431 2432 2433 2434 2435
{
	int error;
	old_sigset_t old_set, new_set;

	if (set) {
		error = -EFAULT;
		if (copy_from_user(&new_set, set, sizeof(*set)))
			goto out;
2436
		new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
Linus Torvalds's avatar
Linus Torvalds committed
2437

2438
		spin_lock_irq(&current->sighand->siglock);
Linus Torvalds's avatar
Linus Torvalds committed
2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456
		old_set = current->blocked.sig[0];

		error = 0;
		switch (how) {
		default:
			error = -EINVAL;
			break;
		case SIG_BLOCK:
			sigaddsetmask(&current->blocked, new_set);
			break;
		case SIG_UNBLOCK:
			sigdelsetmask(&current->blocked, new_set);
			break;
		case SIG_SETMASK:
			current->blocked.sig[0] = new_set;
			break;
		}

2457
		recalc_sigpending();
2458
		spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds's avatar
Linus Torvalds committed
2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473
		if (error)
			goto out;
		if (oset)
			goto set_old;
	} else if (oset) {
		old_set = current->blocked.sig[0];
	set_old:
		error = -EFAULT;
		if (copy_to_user(oset, &old_set, sizeof(*oset)))
			goto out;
	}
	error = 0;
out:
	return error;
}
2474
#endif /* __ARCH_WANT_SYS_SIGPROCMASK */
Linus Torvalds's avatar
Linus Torvalds committed
2475

2476
#ifdef __ARCH_WANT_SYS_RT_SIGACTION
Linus Torvalds's avatar
Linus Torvalds committed
2477
asmlinkage long
2478 2479 2480
sys_rt_sigaction(int sig,
		 const struct sigaction __user *act,
		 struct sigaction __user *oact,
Linus Torvalds's avatar
Linus Torvalds committed
2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503
		 size_t sigsetsize)
{
	struct k_sigaction new_sa, old_sa;
	int ret = -EINVAL;

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(sigset_t))
		goto out;

	if (act) {
		if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
			return -EFAULT;
	}

	ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);

	if (!ret && oact) {
		if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
			return -EFAULT;
	}
out:
	return ret;
}
2504
#endif /* __ARCH_WANT_SYS_RT_SIGACTION */
Linus Torvalds's avatar
Linus Torvalds committed
2505

2506 2507
#ifdef __ARCH_WANT_SYS_SGETMASK

Linus Torvalds's avatar
Linus Torvalds committed
2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522
/*
 * For backwards compatibility.  Functionality superseded by sigprocmask.
 */
asmlinkage long
sys_sgetmask(void)
{
	/* SMP safe */
	return current->blocked.sig[0];
}

asmlinkage long
sys_ssetmask(int newmask)
{
	int old;

2523
	spin_lock_irq(&current->sighand->siglock);
Linus Torvalds's avatar
Linus Torvalds committed
2524 2525 2526 2527
	old = current->blocked.sig[0];

	siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
						  sigmask(SIGSTOP)));
2528
	recalc_sigpending();
2529
	spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds's avatar
Linus Torvalds committed
2530 2531 2532

	return old;
}
2533
#endif /* __ARCH_WANT_SGETMASK */
Linus Torvalds's avatar
Linus Torvalds committed
2534

2535
#ifdef __ARCH_WANT_SYS_SIGNAL
Linus Torvalds's avatar
Linus Torvalds committed
2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551
/*
 * For backwards compatibility.  Functionality superseded by sigaction.
 */
asmlinkage unsigned long
sys_signal(int sig, __sighandler_t handler)
{
	struct k_sigaction new_sa, old_sa;
	int ret;

	new_sa.sa.sa_handler = handler;
	new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;

	ret = do_sigaction(sig, &new_sa, &old_sa);

	return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
}
2552
#endif /* __ARCH_WANT_SYS_SIGNAL */
2553

2554
#ifdef __ARCH_WANT_SYS_PAUSE
2555

2556
asmlinkage long
2557 2558 2559 2560 2561 2562 2563
sys_pause(void)
{
	current->state = TASK_INTERRUPTIBLE;
	schedule();
	return -ERESTARTNOHAND;
}

2564
#endif
Ingo Molnar's avatar
Ingo Molnar committed
2565 2566 2567 2568 2569 2570 2571

void __init signals_init(void)
{
	sigqueue_cachep =
		kmem_cache_create("sigqueue",
				  sizeof(struct sigqueue),
				  __alignof__(struct sigqueue),
2572
				  SLAB_PANIC, NULL, NULL);
Ingo Molnar's avatar
Ingo Molnar committed
2573
}