blob: e5f8aea78ffebd71a1322ca8279321aac3b077e6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/kernel/signal.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 *
6 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
7 *
8 * 2003-06-02 Jim Houston - Concurrent Computer Corp.
9 * Changes to use preallocated sigqueue structures
10 * to allow signals to be sent reliably.
11 */
12
13#include <linux/config.h>
14#include <linux/slab.h>
15#include <linux/module.h>
16#include <linux/smp_lock.h>
17#include <linux/init.h>
18#include <linux/sched.h>
19#include <linux/fs.h>
20#include <linux/tty.h>
21#include <linux/binfmts.h>
22#include <linux/security.h>
23#include <linux/syscalls.h>
24#include <linux/ptrace.h>
Jesper Juhl7ed20e12005-05-01 08:59:14 -070025#include <linux/signal.h>
Steve Grubbc2f0c7c2005-05-06 12:38:39 +010026#include <linux/audit.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080027#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <asm/param.h>
29#include <asm/uaccess.h>
30#include <asm/unistd.h>
31#include <asm/siginfo.h>
32
33/*
34 * SLAB caches for signal bits.
35 */
36
37static kmem_cache_t *sigqueue_cachep;
38
39/*
40 * In POSIX a signal is sent either to a specific thread (Linux task)
41 * or to the process as a whole (Linux thread group). How the signal
42 * is sent determines whether it's to one thread or the whole group,
43 * which determines which signal mask(s) are involved in blocking it
44 * from being delivered until later. When the signal is delivered,
45 * either it's caught or ignored by a user handler or it has a default
46 * effect that applies to the whole thread group (POSIX process).
47 *
48 * The possible effects an unblocked signal set to SIG_DFL can have are:
49 * ignore - Nothing Happens
50 * terminate - kill the process, i.e. all threads in the group,
51 * similar to exit_group. The group leader (only) reports
52 * WIFSIGNALED status to its parent.
53 * coredump - write a core dump file describing all threads using
54 * the same mm and then kill all those threads
55 * stop - stop all the threads in the group, i.e. TASK_STOPPED state
56 *
57 * SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
58 * Other signals when not blocked and set to SIG_DFL behaves as follows.
59 * The job control signals also have other special effects.
60 *
61 * +--------------------+------------------+
62 * | POSIX signal | default action |
63 * +--------------------+------------------+
64 * | SIGHUP | terminate |
65 * | SIGINT | terminate |
66 * | SIGQUIT | coredump |
67 * | SIGILL | coredump |
68 * | SIGTRAP | coredump |
69 * | SIGABRT/SIGIOT | coredump |
70 * | SIGBUS | coredump |
71 * | SIGFPE | coredump |
72 * | SIGKILL | terminate(+) |
73 * | SIGUSR1 | terminate |
74 * | SIGSEGV | coredump |
75 * | SIGUSR2 | terminate |
76 * | SIGPIPE | terminate |
77 * | SIGALRM | terminate |
78 * | SIGTERM | terminate |
79 * | SIGCHLD | ignore |
80 * | SIGCONT | ignore(*) |
81 * | SIGSTOP | stop(*)(+) |
82 * | SIGTSTP | stop(*) |
83 * | SIGTTIN | stop(*) |
84 * | SIGTTOU | stop(*) |
85 * | SIGURG | ignore |
86 * | SIGXCPU | coredump |
87 * | SIGXFSZ | coredump |
88 * | SIGVTALRM | terminate |
89 * | SIGPROF | terminate |
90 * | SIGPOLL/SIGIO | terminate |
91 * | SIGSYS/SIGUNUSED | coredump |
92 * | SIGSTKFLT | terminate |
93 * | SIGWINCH | ignore |
94 * | SIGPWR | terminate |
95 * | SIGRTMIN-SIGRTMAX | terminate |
96 * +--------------------+------------------+
97 * | non-POSIX signal | default action |
98 * +--------------------+------------------+
99 * | SIGEMT | coredump |
100 * +--------------------+------------------+
101 *
102 * (+) For SIGKILL and SIGSTOP the action is "always", not just "default".
103 * (*) Special job control effects:
104 * When SIGCONT is sent, it resumes the process (all threads in the group)
105 * from TASK_STOPPED state and also clears any pending/queued stop signals
106 * (any of those marked with "stop(*)"). This happens regardless of blocking,
107 * catching, or ignoring SIGCONT. When any stop signal is sent, it clears
108 * any pending/queued SIGCONT signals; this happens regardless of blocking,
109 * catching, or ignored the stop signal, though (except for SIGSTOP) the
110 * default action of stopping the process may happen later or never.
111 */
112
113#ifdef SIGEMT
114#define M_SIGEMT M(SIGEMT)
115#else
116#define M_SIGEMT 0
117#endif
118
119#if SIGRTMIN > BITS_PER_LONG
120#define M(sig) (1ULL << ((sig)-1))
121#else
122#define M(sig) (1UL << ((sig)-1))
123#endif
124#define T(sig, mask) (M(sig) & (mask))
125
126#define SIG_KERNEL_ONLY_MASK (\
127 M(SIGKILL) | M(SIGSTOP) )
128
129#define SIG_KERNEL_STOP_MASK (\
130 M(SIGSTOP) | M(SIGTSTP) | M(SIGTTIN) | M(SIGTTOU) )
131
132#define SIG_KERNEL_COREDUMP_MASK (\
133 M(SIGQUIT) | M(SIGILL) | M(SIGTRAP) | M(SIGABRT) | \
134 M(SIGFPE) | M(SIGSEGV) | M(SIGBUS) | M(SIGSYS) | \
135 M(SIGXCPU) | M(SIGXFSZ) | M_SIGEMT )
136
137#define SIG_KERNEL_IGNORE_MASK (\
138 M(SIGCONT) | M(SIGCHLD) | M(SIGWINCH) | M(SIGURG) )
139
140#define sig_kernel_only(sig) \
141 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_ONLY_MASK))
142#define sig_kernel_coredump(sig) \
143 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_COREDUMP_MASK))
144#define sig_kernel_ignore(sig) \
145 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_IGNORE_MASK))
146#define sig_kernel_stop(sig) \
147 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_STOP_MASK))
148
Oleg Nesterov6108ccd2006-03-28 16:11:22 -0800149#define sig_needs_tasklist(sig) ((sig) == SIGCONT)
Oleg Nesterova9e88e82006-03-28 16:11:14 -0800150
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151#define sig_user_defined(t, signr) \
152 (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) && \
153 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
154
155#define sig_fatal(t, signr) \
156 (!T(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
157 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
158
159static int sig_ignored(struct task_struct *t, int sig)
160{
161 void __user * handler;
162
163 /*
164 * Tracers always want to know about signals..
165 */
166 if (t->ptrace & PT_PTRACED)
167 return 0;
168
169 /*
170 * Blocked signals are never ignored, since the
171 * signal handler may change by the time it is
172 * unblocked.
173 */
174 if (sigismember(&t->blocked, sig))
175 return 0;
176
177 /* Is it explicitly or implicitly ignored? */
178 handler = t->sighand->action[sig-1].sa.sa_handler;
179 return handler == SIG_IGN ||
180 (handler == SIG_DFL && sig_kernel_ignore(sig));
181}
182
183/*
184 * Re-calculate pending state from the set of locally pending
185 * signals, globally pending signals, and blocked signals.
186 */
187static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
188{
189 unsigned long ready;
190 long i;
191
192 switch (_NSIG_WORDS) {
193 default:
194 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
195 ready |= signal->sig[i] &~ blocked->sig[i];
196 break;
197
198 case 4: ready = signal->sig[3] &~ blocked->sig[3];
199 ready |= signal->sig[2] &~ blocked->sig[2];
200 ready |= signal->sig[1] &~ blocked->sig[1];
201 ready |= signal->sig[0] &~ blocked->sig[0];
202 break;
203
204 case 2: ready = signal->sig[1] &~ blocked->sig[1];
205 ready |= signal->sig[0] &~ blocked->sig[0];
206 break;
207
208 case 1: ready = signal->sig[0] &~ blocked->sig[0];
209 }
210 return ready != 0;
211}
212
213#define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
214
215fastcall void recalc_sigpending_tsk(struct task_struct *t)
216{
217 if (t->signal->group_stop_count > 0 ||
Christoph Lameter3e1d1d22005-06-24 23:13:50 -0700218 (freezing(t)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 PENDING(&t->pending, &t->blocked) ||
220 PENDING(&t->signal->shared_pending, &t->blocked))
221 set_tsk_thread_flag(t, TIF_SIGPENDING);
222 else
223 clear_tsk_thread_flag(t, TIF_SIGPENDING);
224}
225
226void recalc_sigpending(void)
227{
228 recalc_sigpending_tsk(current);
229}
230
231/* Given the mask, find the first available signal that should be serviced. */
232
233static int
234next_signal(struct sigpending *pending, sigset_t *mask)
235{
236 unsigned long i, *s, *m, x;
237 int sig = 0;
238
239 s = pending->signal.sig;
240 m = mask->sig;
241 switch (_NSIG_WORDS) {
242 default:
243 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
244 if ((x = *s &~ *m) != 0) {
245 sig = ffz(~x) + i*_NSIG_BPW + 1;
246 break;
247 }
248 break;
249
250 case 2: if ((x = s[0] &~ m[0]) != 0)
251 sig = 1;
252 else if ((x = s[1] &~ m[1]) != 0)
253 sig = _NSIG_BPW + 1;
254 else
255 break;
256 sig += ffz(~x);
257 break;
258
259 case 1: if ((x = *s &~ *m) != 0)
260 sig = ffz(~x) + 1;
261 break;
262 }
263
264 return sig;
265}
266
Al Virodd0fc662005-10-07 07:46:04 +0100267static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 int override_rlimit)
269{
270 struct sigqueue *q = NULL;
271
272 atomic_inc(&t->user->sigpending);
273 if (override_rlimit ||
274 atomic_read(&t->user->sigpending) <=
275 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
276 q = kmem_cache_alloc(sigqueue_cachep, flags);
277 if (unlikely(q == NULL)) {
278 atomic_dec(&t->user->sigpending);
279 } else {
280 INIT_LIST_HEAD(&q->list);
281 q->flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 q->user = get_uid(t->user);
283 }
284 return(q);
285}
286
Andrew Morton514a01b2006-02-03 03:04:41 -0800287static void __sigqueue_free(struct sigqueue *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
289 if (q->flags & SIGQUEUE_PREALLOC)
290 return;
291 atomic_dec(&q->user->sigpending);
292 free_uid(q->user);
293 kmem_cache_free(sigqueue_cachep, q);
294}
295
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800296void flush_sigqueue(struct sigpending *queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297{
298 struct sigqueue *q;
299
300 sigemptyset(&queue->signal);
301 while (!list_empty(&queue->list)) {
302 q = list_entry(queue->list.next, struct sigqueue , list);
303 list_del_init(&q->list);
304 __sigqueue_free(q);
305 }
306}
307
308/*
309 * Flush all pending signals for a task.
310 */
Oleg Nesterovc81addc2006-03-28 16:11:17 -0800311void flush_signals(struct task_struct *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312{
313 unsigned long flags;
314
315 spin_lock_irqsave(&t->sighand->siglock, flags);
316 clear_tsk_thread_flag(t,TIF_SIGPENDING);
317 flush_sigqueue(&t->pending);
318 flush_sigqueue(&t->signal->shared_pending);
319 spin_unlock_irqrestore(&t->sighand->siglock, flags);
320}
321
322/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 * Flush all handlers for a task.
324 */
325
326void
327flush_signal_handlers(struct task_struct *t, int force_default)
328{
329 int i;
330 struct k_sigaction *ka = &t->sighand->action[0];
331 for (i = _NSIG ; i != 0 ; i--) {
332 if (force_default || ka->sa.sa_handler != SIG_IGN)
333 ka->sa.sa_handler = SIG_DFL;
334 ka->sa.sa_flags = 0;
335 sigemptyset(&ka->sa.sa_mask);
336 ka++;
337 }
338}
339
340
341/* Notify the system that a driver wants to block all signals for this
342 * process, and wants to be notified if any signals at all were to be
343 * sent/acted upon. If the notifier routine returns non-zero, then the
344 * signal will be acted upon after all. If the notifier routine returns 0,
345 * then then signal will be blocked. Only one block per process is
346 * allowed. priv is a pointer to private data that the notifier routine
347 * can use to determine if the signal should be blocked or not. */
348
349void
350block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
351{
352 unsigned long flags;
353
354 spin_lock_irqsave(&current->sighand->siglock, flags);
355 current->notifier_mask = mask;
356 current->notifier_data = priv;
357 current->notifier = notifier;
358 spin_unlock_irqrestore(&current->sighand->siglock, flags);
359}
360
361/* Notify the system that blocking has ended. */
362
363void
364unblock_all_signals(void)
365{
366 unsigned long flags;
367
368 spin_lock_irqsave(&current->sighand->siglock, flags);
369 current->notifier = NULL;
370 current->notifier_data = NULL;
371 recalc_sigpending();
372 spin_unlock_irqrestore(&current->sighand->siglock, flags);
373}
374
Arjan van de Ven858119e2006-01-14 13:20:43 -0800375static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376{
377 struct sigqueue *q, *first = NULL;
378 int still_pending = 0;
379
380 if (unlikely(!sigismember(&list->signal, sig)))
381 return 0;
382
383 /*
384 * Collect the siginfo appropriate to this signal. Check if
385 * there is another siginfo for the same signal.
386 */
387 list_for_each_entry(q, &list->list, list) {
388 if (q->info.si_signo == sig) {
389 if (first) {
390 still_pending = 1;
391 break;
392 }
393 first = q;
394 }
395 }
396 if (first) {
397 list_del_init(&first->list);
398 copy_siginfo(info, &first->info);
399 __sigqueue_free(first);
400 if (!still_pending)
401 sigdelset(&list->signal, sig);
402 } else {
403
404 /* Ok, it wasn't in the queue. This must be
405 a fast-pathed signal or we must have been
406 out of queue space. So zero out the info.
407 */
408 sigdelset(&list->signal, sig);
409 info->si_signo = sig;
410 info->si_errno = 0;
411 info->si_code = 0;
412 info->si_pid = 0;
413 info->si_uid = 0;
414 }
415 return 1;
416}
417
418static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
419 siginfo_t *info)
420{
421 int sig = 0;
422
Heiko Carstensb17b0422005-11-13 16:07:14 -0800423 sig = next_signal(pending, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 if (sig) {
425 if (current->notifier) {
426 if (sigismember(current->notifier_mask, sig)) {
427 if (!(current->notifier)(current->notifier_data)) {
428 clear_thread_flag(TIF_SIGPENDING);
429 return 0;
430 }
431 }
432 }
433
434 if (!collect_signal(sig, pending, info))
435 sig = 0;
436
437 }
438 recalc_sigpending();
439
440 return sig;
441}
442
443/*
444 * Dequeue a signal and return the element to the caller, which is
445 * expected to free it.
446 *
447 * All callers have to hold the siglock.
448 */
449int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
450{
451 int signr = __dequeue_signal(&tsk->pending, mask, info);
452 if (!signr)
453 signr = __dequeue_signal(&tsk->signal->shared_pending,
454 mask, info);
455 if (signr && unlikely(sig_kernel_stop(signr))) {
456 /*
457 * Set a marker that we have dequeued a stop signal. Our
458 * caller might release the siglock and then the pending
459 * stop signal it is about to process is no longer in the
460 * pending bitmasks, but must still be cleared by a SIGCONT
461 * (and overruled by a SIGKILL). So those cases clear this
462 * shared flag after we've set it. Note that this flag may
463 * remain set after the signal we return is ignored or
464 * handled. That doesn't matter because its only purpose
465 * is to alert stop-signal processing code when another
466 * processor has come along and cleared the flag.
467 */
Oleg Nesterov788e05a2005-10-07 17:46:19 +0400468 if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
469 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 }
471 if ( signr &&
472 ((info->si_code & __SI_MASK) == __SI_TIMER) &&
473 info->si_sys_private){
474 /*
475 * Release the siglock to ensure proper locking order
476 * of timer locks outside of siglocks. Note, we leave
477 * irqs disabled here, since the posix-timers code is
478 * about to disable them again anyway.
479 */
480 spin_unlock(&tsk->sighand->siglock);
481 do_schedule_next_timer(info);
482 spin_lock(&tsk->sighand->siglock);
483 }
484 return signr;
485}
486
487/*
488 * Tell a process that it has a new active signal..
489 *
490 * NOTE! we rely on the previous spin_lock to
491 * lock interrupts for us! We can only be called with
492 * "siglock" held, and the local interrupt must
493 * have been disabled when that got acquired!
494 *
495 * No need to set need_resched since signal event passing
496 * goes through ->blocked
497 */
498void signal_wake_up(struct task_struct *t, int resume)
499{
500 unsigned int mask;
501
502 set_tsk_thread_flag(t, TIF_SIGPENDING);
503
504 /*
505 * For SIGKILL, we want to wake it up in the stopped/traced case.
506 * We don't check t->state here because there is a race with it
507 * executing another processor and just now entering stopped state.
508 * By using wake_up_state, we ensure the process will wake up and
509 * handle its death signal.
510 */
511 mask = TASK_INTERRUPTIBLE;
512 if (resume)
513 mask |= TASK_STOPPED | TASK_TRACED;
514 if (!wake_up_state(t, mask))
515 kick_process(t);
516}
517
518/*
519 * Remove signals in mask from the pending set and queue.
520 * Returns 1 if any signals were found.
521 *
522 * All callers must be holding the siglock.
George Anzinger71fabd52006-01-08 01:02:48 -0800523 *
524 * This version takes a sigset mask and looks at all signals,
525 * not just those in the first mask word.
526 */
527static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
528{
529 struct sigqueue *q, *n;
530 sigset_t m;
531
532 sigandsets(&m, mask, &s->signal);
533 if (sigisemptyset(&m))
534 return 0;
535
536 signandsets(&s->signal, &s->signal, mask);
537 list_for_each_entry_safe(q, n, &s->list, list) {
538 if (sigismember(mask, q->info.si_signo)) {
539 list_del_init(&q->list);
540 __sigqueue_free(q);
541 }
542 }
543 return 1;
544}
545/*
546 * Remove signals in mask from the pending set and queue.
547 * Returns 1 if any signals were found.
548 *
549 * All callers must be holding the siglock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 */
551static int rm_from_queue(unsigned long mask, struct sigpending *s)
552{
553 struct sigqueue *q, *n;
554
555 if (!sigtestsetmask(&s->signal, mask))
556 return 0;
557
558 sigdelsetmask(&s->signal, mask);
559 list_for_each_entry_safe(q, n, &s->list, list) {
560 if (q->info.si_signo < SIGRTMIN &&
561 (mask & sigmask(q->info.si_signo))) {
562 list_del_init(&q->list);
563 __sigqueue_free(q);
564 }
565 }
566 return 1;
567}
568
569/*
570 * Bad permissions for sending the signal
571 */
572static int check_kill_permission(int sig, struct siginfo *info,
573 struct task_struct *t)
574{
575 int error = -EINVAL;
Jesper Juhl7ed20e12005-05-01 08:59:14 -0700576 if (!valid_signal(sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 return error;
578 error = -EPERM;
Oleg Nesterov621d3122005-10-30 15:03:45 -0800579 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 && ((sig != SIGCONT) ||
581 (current->signal->session != t->signal->session))
582 && (current->euid ^ t->suid) && (current->euid ^ t->uid)
583 && (current->uid ^ t->suid) && (current->uid ^ t->uid)
584 && !capable(CAP_KILL))
585 return error;
Steve Grubbc2f0c7c2005-05-06 12:38:39 +0100586
587 error = security_task_kill(t, info, sig);
588 if (!error)
589 audit_signal_info(sig, t); /* Let audit system see the signal */
590 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591}
592
593/* forward decl */
Oleg Nesterova1d5e212006-03-28 16:11:29 -0800594static void do_notify_parent_cldstop(struct task_struct *tsk, int why);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
596/*
597 * Handle magic process-wide effects of stop/continue signals.
598 * Unlike the signal actions, these happen immediately at signal-generation
599 * time regardless of blocking, ignoring, or handling. This does the
600 * actual continuing for SIGCONT, but not the actual stopping for stop
601 * signals. The process stop is done as a signal action for SIG_DFL.
602 */
603static void handle_stop_signal(int sig, struct task_struct *p)
604{
605 struct task_struct *t;
606
Bhavesh P. Davdadd12f482005-08-17 12:26:33 -0600607 if (p->signal->flags & SIGNAL_GROUP_EXIT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 /*
609 * The process is in the middle of dying already.
610 */
611 return;
612
613 if (sig_kernel_stop(sig)) {
614 /*
615 * This is a stop signal. Remove SIGCONT from all queues.
616 */
617 rm_from_queue(sigmask(SIGCONT), &p->signal->shared_pending);
618 t = p;
619 do {
620 rm_from_queue(sigmask(SIGCONT), &t->pending);
621 t = next_thread(t);
622 } while (t != p);
623 } else if (sig == SIGCONT) {
624 /*
625 * Remove all stop signals from all queues,
626 * and wake all threads.
627 */
628 if (unlikely(p->signal->group_stop_count > 0)) {
629 /*
630 * There was a group stop in progress. We'll
631 * pretend it finished before we got here. We are
632 * obliged to report it to the parent: if the
633 * SIGSTOP happened "after" this SIGCONT, then it
634 * would have cleared this pending SIGCONT. If it
635 * happened "before" this SIGCONT, then the parent
636 * got the SIGCHLD about the stop finishing before
637 * the continue happened. We do the notification
638 * now, and it's as if the stop had finished and
639 * the SIGCHLD was pending on entry to this kill.
640 */
641 p->signal->group_stop_count = 0;
642 p->signal->flags = SIGNAL_STOP_CONTINUED;
643 spin_unlock(&p->sighand->siglock);
Oleg Nesterova1d5e212006-03-28 16:11:29 -0800644 do_notify_parent_cldstop(p, CLD_STOPPED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 spin_lock(&p->sighand->siglock);
646 }
647 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
648 t = p;
649 do {
650 unsigned int state;
651 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
652
653 /*
654 * If there is a handler for SIGCONT, we must make
655 * sure that no thread returns to user mode before
656 * we post the signal, in case it was the only
657 * thread eligible to run the signal handler--then
658 * it must not do anything between resuming and
659 * running the handler. With the TIF_SIGPENDING
660 * flag set, the thread will pause and acquire the
661 * siglock that we hold now and until we've queued
662 * the pending signal.
663 *
664 * Wake up the stopped thread _after_ setting
665 * TIF_SIGPENDING
666 */
667 state = TASK_STOPPED;
668 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
669 set_tsk_thread_flag(t, TIF_SIGPENDING);
670 state |= TASK_INTERRUPTIBLE;
671 }
672 wake_up_state(t, state);
673
674 t = next_thread(t);
675 } while (t != p);
676
677 if (p->signal->flags & SIGNAL_STOP_STOPPED) {
678 /*
679 * We were in fact stopped, and are now continued.
680 * Notify the parent with CLD_CONTINUED.
681 */
682 p->signal->flags = SIGNAL_STOP_CONTINUED;
683 p->signal->group_exit_code = 0;
684 spin_unlock(&p->sighand->siglock);
Oleg Nesterova1d5e212006-03-28 16:11:29 -0800685 do_notify_parent_cldstop(p, CLD_CONTINUED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 spin_lock(&p->sighand->siglock);
687 } else {
688 /*
689 * We are not stopped, but there could be a stop
690 * signal in the middle of being processed after
691 * being removed from the queue. Clear that too.
692 */
693 p->signal->flags = 0;
694 }
695 } else if (sig == SIGKILL) {
696 /*
697 * Make sure that any pending stop signal already dequeued
698 * is undone by the wakeup for SIGKILL.
699 */
700 p->signal->flags = 0;
701 }
702}
703
704static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
705 struct sigpending *signals)
706{
707 struct sigqueue * q = NULL;
708 int ret = 0;
709
710 /*
711 * fast-pathed signals for kernel-internal things like SIGSTOP
712 * or SIGKILL.
713 */
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800714 if (info == SEND_SIG_FORCED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 goto out_set;
716
717 /* Real-time signals must be queued if sent by sigqueue, or
718 some other real-time mechanism. It is implementation
719 defined whether kill() does so. We attempt to do so, on
720 the principle of least surprise, but since kill is not
721 allowed to fail with EAGAIN when low on memory we just
722 make sure at least one signal gets delivered and don't
723 pass on the info struct. */
724
725 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
Oleg Nesterov621d3122005-10-30 15:03:45 -0800726 (is_si_special(info) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 info->si_code >= 0)));
728 if (q) {
729 list_add_tail(&q->list, &signals->list);
730 switch ((unsigned long) info) {
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800731 case (unsigned long) SEND_SIG_NOINFO:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 q->info.si_signo = sig;
733 q->info.si_errno = 0;
734 q->info.si_code = SI_USER;
735 q->info.si_pid = current->pid;
736 q->info.si_uid = current->uid;
737 break;
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800738 case (unsigned long) SEND_SIG_PRIV:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 q->info.si_signo = sig;
740 q->info.si_errno = 0;
741 q->info.si_code = SI_KERNEL;
742 q->info.si_pid = 0;
743 q->info.si_uid = 0;
744 break;
745 default:
746 copy_siginfo(&q->info, info);
747 break;
748 }
Oleg Nesterov621d3122005-10-30 15:03:45 -0800749 } else if (!is_si_special(info)) {
750 if (sig >= SIGRTMIN && info->si_code != SI_USER)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 /*
752 * Queue overflow, abort. We may abort if the signal was rt
753 * and sent by user using something other than kill().
754 */
755 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 }
757
758out_set:
759 sigaddset(&signals->signal, sig);
760 return ret;
761}
762
763#define LEGACY_QUEUE(sigptr, sig) \
764 (((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
765
766
767static int
768specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
769{
770 int ret = 0;
771
Eric Sesterhennfda8bd72006-04-02 13:44:47 +0200772 BUG_ON(!irqs_disabled());
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 assert_spin_locked(&t->sighand->siglock);
774
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 /* Short-circuit ignored signals. */
776 if (sig_ignored(t, sig))
777 goto out;
778
779 /* Support queueing exactly one non-rt signal, so that we
780 can get more detailed information about the cause of
781 the signal. */
782 if (LEGACY_QUEUE(&t->pending, sig))
783 goto out;
784
785 ret = send_signal(sig, info, t, &t->pending);
786 if (!ret && !sigismember(&t->blocked, sig))
787 signal_wake_up(t, sig == SIGKILL);
788out:
789 return ret;
790}
791
792/*
793 * Force a signal that the process can't ignore: if necessary
794 * we unblock the signal and change any SIG_IGN to SIG_DFL.
795 */
796
797int
798force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
799{
800 unsigned long int flags;
801 int ret;
802
803 spin_lock_irqsave(&t->sighand->siglock, flags);
Paul E. McKenneyb0423a02005-10-30 15:03:46 -0800804 if (t->sighand->action[sig-1].sa.sa_handler == SIG_IGN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 t->sighand->action[sig-1].sa.sa_handler = SIG_DFL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 }
Paul E. McKenneyb0423a02005-10-30 15:03:46 -0800807 if (sigismember(&t->blocked, sig)) {
808 sigdelset(&t->blocked, sig);
809 }
810 recalc_sigpending_tsk(t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 ret = specific_send_sig_info(sig, info, t);
812 spin_unlock_irqrestore(&t->sighand->siglock, flags);
813
814 return ret;
815}
816
817void
818force_sig_specific(int sig, struct task_struct *t)
819{
Paul E. McKenneyb0423a02005-10-30 15:03:46 -0800820 force_sig_info(sig, SEND_SIG_FORCED, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821}
822
823/*
824 * Test if P wants to take SIG. After we've checked all threads with this,
825 * it's equivalent to finding no threads not blocking SIG. Any threads not
826 * blocking SIG were ruled out because they are not running and already
827 * have pending signals. Such threads will dequeue from the shared queue
828 * as soon as they're available, so putting the signal on the shared queue
829 * will be equivalent to sending it to one such thread.
830 */
Linus Torvalds188a1ea2005-09-23 13:22:21 -0700831static inline int wants_signal(int sig, struct task_struct *p)
832{
833 if (sigismember(&p->blocked, sig))
834 return 0;
835 if (p->flags & PF_EXITING)
836 return 0;
837 if (sig == SIGKILL)
838 return 1;
839 if (p->state & (TASK_STOPPED | TASK_TRACED))
840 return 0;
841 return task_curr(p) || !signal_pending(p);
842}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
844static void
845__group_complete_signal(int sig, struct task_struct *p)
846{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 struct task_struct *t;
848
849 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 * Now find a thread we can wake up to take the signal off the queue.
851 *
852 * If the main thread wants the signal, it gets first crack.
853 * Probably the least surprising to the average bear.
854 */
Linus Torvalds188a1ea2005-09-23 13:22:21 -0700855 if (wants_signal(sig, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 t = p;
857 else if (thread_group_empty(p))
858 /*
859 * There is just one thread and it does not need to be woken.
860 * It will dequeue unblocked signals before it runs again.
861 */
862 return;
863 else {
864 /*
865 * Otherwise try to find a suitable thread.
866 */
867 t = p->signal->curr_target;
868 if (t == NULL)
869 /* restart balancing at this thread */
870 t = p->signal->curr_target = p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Linus Torvalds188a1ea2005-09-23 13:22:21 -0700872 while (!wants_signal(sig, t)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 t = next_thread(t);
874 if (t == p->signal->curr_target)
875 /*
876 * No thread needs to be woken.
877 * Any eligible threads will see
878 * the signal in the queue soon.
879 */
880 return;
881 }
882 p->signal->curr_target = t;
883 }
884
885 /*
886 * Found a killable thread. If the signal will be fatal,
887 * then start taking the whole group down immediately.
888 */
889 if (sig_fatal(p, sig) && !(p->signal->flags & SIGNAL_GROUP_EXIT) &&
890 !sigismember(&t->real_blocked, sig) &&
891 (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
892 /*
893 * This signal will be fatal to the whole group.
894 */
895 if (!sig_kernel_coredump(sig)) {
896 /*
897 * Start a group exit and wake everybody up.
898 * This way we don't have other threads
899 * running and doing things after a slower
900 * thread has the fatal signal pending.
901 */
902 p->signal->flags = SIGNAL_GROUP_EXIT;
903 p->signal->group_exit_code = sig;
904 p->signal->group_stop_count = 0;
905 t = p;
906 do {
907 sigaddset(&t->pending.signal, SIGKILL);
908 signal_wake_up(t, 1);
909 t = next_thread(t);
910 } while (t != p);
911 return;
912 }
913
914 /*
915 * There will be a core dump. We make all threads other
916 * than the chosen one go into a group stop so that nothing
917 * happens until it gets scheduled, takes the signal off
918 * the shared queue, and does the core dump. This is a
919 * little more complicated than strictly necessary, but it
920 * keeps the signal state that winds up in the core dump
921 * unchanged from the death state, e.g. which thread had
922 * the core-dump signal unblocked.
923 */
924 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
925 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
926 p->signal->group_stop_count = 0;
927 p->signal->group_exit_task = t;
928 t = p;
929 do {
930 p->signal->group_stop_count++;
931 signal_wake_up(t, 0);
932 t = next_thread(t);
933 } while (t != p);
934 wake_up_process(p->signal->group_exit_task);
935 return;
936 }
937
938 /*
939 * The signal is already in the shared-pending queue.
940 * Tell the chosen thread to wake up and dequeue it.
941 */
942 signal_wake_up(t, sig == SIGKILL);
943 return;
944}
945
946int
947__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
948{
949 int ret = 0;
950
951 assert_spin_locked(&p->sighand->siglock);
952 handle_stop_signal(sig, p);
953
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 /* Short-circuit ignored signals. */
955 if (sig_ignored(p, sig))
956 return ret;
957
958 if (LEGACY_QUEUE(&p->signal->shared_pending, sig))
959 /* This is a non-RT signal and we already have one queued. */
960 return ret;
961
962 /*
963 * Put this signal on the shared-pending queue, or fail with EAGAIN.
964 * We always use the shared queue for process-wide signals,
965 * to avoid several races.
966 */
967 ret = send_signal(sig, info, p, &p->signal->shared_pending);
968 if (unlikely(ret))
969 return ret;
970
971 __group_complete_signal(sig, p);
972 return 0;
973}
974
975/*
976 * Nuke all other threads in the group.
977 */
978void zap_other_threads(struct task_struct *p)
979{
980 struct task_struct *t;
981
982 p->signal->flags = SIGNAL_GROUP_EXIT;
983 p->signal->group_stop_count = 0;
984
985 if (thread_group_empty(p))
986 return;
987
988 for (t = next_thread(p); t != p; t = next_thread(t)) {
989 /*
990 * Don't bother with already dead threads
991 */
992 if (t->exit_state)
993 continue;
994
995 /*
996 * We don't want to notify the parent, since we are
997 * killed as part of a thread group due to another
998 * thread doing an execve() or similar. So set the
999 * exit signal to -1 to allow immediate reaping of
1000 * the process. But don't detach the thread group
1001 * leader.
1002 */
1003 if (t != p->group_leader)
1004 t->exit_signal = -1;
1005
Andrea Arcangeli30e0fca62005-10-30 15:02:38 -08001006 /* SIGKILL will be handled before any pending SIGSTOP */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 sigaddset(&t->pending.signal, SIGKILL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 signal_wake_up(t, 1);
1009 }
1010}
1011
1012/*
Ingo Molnare56d0902006-01-08 01:01:37 -08001013 * Must be called under rcu_read_lock() or with tasklist_lock read-held.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 */
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001015struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
1016{
1017 struct sighand_struct *sighand;
1018
1019 for (;;) {
1020 sighand = rcu_dereference(tsk->sighand);
1021 if (unlikely(sighand == NULL))
1022 break;
1023
1024 spin_lock_irqsave(&sighand->siglock, *flags);
1025 if (likely(sighand == tsk->sighand))
1026 break;
1027 spin_unlock_irqrestore(&sighand->siglock, *flags);
1028 }
1029
1030 return sighand;
1031}
1032
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1034{
1035 unsigned long flags;
1036 int ret;
1037
1038 ret = check_kill_permission(sig, info, p);
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001039
1040 if (!ret && sig) {
1041 ret = -ESRCH;
1042 if (lock_task_sighand(p, &flags)) {
1043 ret = __group_send_sig_info(sig, info, p);
1044 unlock_task_sighand(p, &flags);
Ingo Molnare56d0902006-01-08 01:01:37 -08001045 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 }
1047
1048 return ret;
1049}
1050
1051/*
1052 * kill_pg_info() sends a signal to a process group: this is what the tty
1053 * control characters do (^C, ^Z etc)
1054 */
1055
1056int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1057{
1058 struct task_struct *p = NULL;
1059 int retval, success;
1060
1061 if (pgrp <= 0)
1062 return -EINVAL;
1063
1064 success = 0;
1065 retval = -ESRCH;
1066 do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
1067 int err = group_send_sig_info(sig, info, p);
1068 success |= !err;
1069 retval = err;
1070 } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
1071 return success ? 0 : retval;
1072}
1073
1074int
1075kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1076{
1077 int retval;
1078
1079 read_lock(&tasklist_lock);
1080 retval = __kill_pg_info(sig, info, pgrp);
1081 read_unlock(&tasklist_lock);
1082
1083 return retval;
1084}
1085
1086int
1087kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1088{
1089 int error;
Ingo Molnare56d0902006-01-08 01:01:37 -08001090 int acquired_tasklist_lock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 struct task_struct *p;
1092
Ingo Molnare56d0902006-01-08 01:01:37 -08001093 rcu_read_lock();
Oleg Nesterova9e88e82006-03-28 16:11:14 -08001094 if (unlikely(sig_needs_tasklist(sig))) {
Ingo Molnare56d0902006-01-08 01:01:37 -08001095 read_lock(&tasklist_lock);
1096 acquired_tasklist_lock = 1;
1097 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 p = find_task_by_pid(pid);
1099 error = -ESRCH;
1100 if (p)
1101 error = group_send_sig_info(sig, info, p);
Ingo Molnare56d0902006-01-08 01:01:37 -08001102 if (unlikely(acquired_tasklist_lock))
1103 read_unlock(&tasklist_lock);
1104 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 return error;
1106}
1107
Harald Welte46113832005-10-10 19:44:29 +02001108/* like kill_proc_info(), but doesn't use uid/euid of "current" */
1109int kill_proc_info_as_uid(int sig, struct siginfo *info, pid_t pid,
1110 uid_t uid, uid_t euid)
1111{
1112 int ret = -EINVAL;
1113 struct task_struct *p;
1114
1115 if (!valid_signal(sig))
1116 return ret;
1117
1118 read_lock(&tasklist_lock);
1119 p = find_task_by_pid(pid);
1120 if (!p) {
1121 ret = -ESRCH;
1122 goto out_unlock;
1123 }
Oleg Nesterov0811af22006-01-08 01:03:09 -08001124 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
Harald Welte46113832005-10-10 19:44:29 +02001125 && (euid != p->suid) && (euid != p->uid)
1126 && (uid != p->suid) && (uid != p->uid)) {
1127 ret = -EPERM;
1128 goto out_unlock;
1129 }
1130 if (sig && p->sighand) {
1131 unsigned long flags;
1132 spin_lock_irqsave(&p->sighand->siglock, flags);
1133 ret = __group_send_sig_info(sig, info, p);
1134 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1135 }
1136out_unlock:
1137 read_unlock(&tasklist_lock);
1138 return ret;
1139}
1140EXPORT_SYMBOL_GPL(kill_proc_info_as_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141
1142/*
1143 * kill_something_info() interprets pid in interesting ways just like kill(2).
1144 *
1145 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1146 * is probably wrong. Should make it like BSD or SYSV.
1147 */
1148
1149static int kill_something_info(int sig, struct siginfo *info, int pid)
1150{
1151 if (!pid) {
1152 return kill_pg_info(sig, info, process_group(current));
1153 } else if (pid == -1) {
1154 int retval = 0, count = 0;
1155 struct task_struct * p;
1156
1157 read_lock(&tasklist_lock);
1158 for_each_process(p) {
1159 if (p->pid > 1 && p->tgid != current->tgid) {
1160 int err = group_send_sig_info(sig, info, p);
1161 ++count;
1162 if (err != -EPERM)
1163 retval = err;
1164 }
1165 }
1166 read_unlock(&tasklist_lock);
1167 return count ? retval : -ESRCH;
1168 } else if (pid < 0) {
1169 return kill_pg_info(sig, info, -pid);
1170 } else {
1171 return kill_proc_info(sig, info, pid);
1172 }
1173}
1174
1175/*
1176 * These are for backward compatibility with the rest of the kernel source.
1177 */
1178
1179/*
1180 * These two are the most common entry points. They send a signal
1181 * just to the specific thread.
1182 */
1183int
1184send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1185{
1186 int ret;
1187 unsigned long flags;
1188
1189 /*
1190 * Make sure legacy kernel users don't send in bad values
1191 * (normal paths check this in check_kill_permission).
1192 */
Jesper Juhl7ed20e12005-05-01 08:59:14 -07001193 if (!valid_signal(sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 return -EINVAL;
1195
1196 /*
1197 * We need the tasklist lock even for the specific
1198 * thread case (when we don't need to follow the group
1199 * lists) in order to avoid races with "p->sighand"
1200 * going away or changing from under us.
1201 */
1202 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;
1208}
1209
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001210#define __si_special(priv) \
1211 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1212
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213int
1214send_sig(int sig, struct task_struct *p, int priv)
1215{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001216 return send_sig_info(sig, __si_special(priv), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217}
1218
1219/*
1220 * This is the entry point for "process-wide" signals.
1221 * They will go to an appropriate thread in the thread group.
1222 */
1223int
1224send_group_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1225{
1226 int ret;
1227 read_lock(&tasklist_lock);
1228 ret = group_send_sig_info(sig, info, p);
1229 read_unlock(&tasklist_lock);
1230 return ret;
1231}
1232
1233void
1234force_sig(int sig, struct task_struct *p)
1235{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001236 force_sig_info(sig, SEND_SIG_PRIV, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237}
1238
1239/*
1240 * When things go south during signal handling, we
1241 * will force a SIGSEGV. And if the signal that caused
1242 * the problem was already a SIGSEGV, we'll want to
1243 * make sure we don't even try to deliver the signal..
1244 */
1245int
1246force_sigsegv(int sig, struct task_struct *p)
1247{
1248 if (sig == SIGSEGV) {
1249 unsigned long flags;
1250 spin_lock_irqsave(&p->sighand->siglock, flags);
1251 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1252 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1253 }
1254 force_sig(SIGSEGV, p);
1255 return 0;
1256}
1257
1258int
1259kill_pg(pid_t pgrp, int sig, int priv)
1260{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001261 return kill_pg_info(sig, __si_special(priv), pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262}
1263
1264int
1265kill_proc(pid_t pid, int sig, int priv)
1266{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001267 return kill_proc_info(sig, __si_special(priv), pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268}
1269
1270/*
1271 * These functions support sending signals using preallocated sigqueue
1272 * structures. This is needed "because realtime applications cannot
1273 * afford to lose notifications of asynchronous events, like timer
1274 * expirations or I/O completions". In the case of Posix Timers
1275 * we allocate the sigqueue structure from the timer_create. If this
1276 * allocation fails we are able to report the failure to the application
1277 * with an EAGAIN error.
1278 */
1279
1280struct sigqueue *sigqueue_alloc(void)
1281{
1282 struct sigqueue *q;
1283
1284 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1285 q->flags |= SIGQUEUE_PREALLOC;
1286 return(q);
1287}
1288
1289void sigqueue_free(struct sigqueue *q)
1290{
1291 unsigned long flags;
1292 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1293 /*
1294 * If the signal is still pending remove it from the
1295 * pending queue.
1296 */
1297 if (unlikely(!list_empty(&q->list))) {
Oleg Nesterov19a4fcb2005-10-30 15:02:17 -08001298 spinlock_t *lock = &current->sighand->siglock;
1299 read_lock(&tasklist_lock);
1300 spin_lock_irqsave(lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 if (!list_empty(&q->list))
1302 list_del_init(&q->list);
Oleg Nesterov19a4fcb2005-10-30 15:02:17 -08001303 spin_unlock_irqrestore(lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 read_unlock(&tasklist_lock);
1305 }
1306 q->flags &= ~SIGQUEUE_PREALLOC;
1307 __sigqueue_free(q);
1308}
1309
Oleg Nesterov54767902006-03-28 16:11:30 -08001310int send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311{
1312 unsigned long flags;
1313 int ret = 0;
1314
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
Ingo Molnare56d0902006-01-08 01:01:37 -08001316
1317 /*
1318 * The rcu based delayed sighand destroy makes it possible to
1319 * run this without tasklist lock held. The task struct itself
1320 * cannot go away as create_timer did get_task_struct().
1321 *
1322 * We return -1, when the task is marked exiting, so
1323 * posix_timer_event can redirect it to the group leader
1324 */
1325 rcu_read_lock();
Oleg Nesterove752dd62005-09-06 15:17:42 -07001326
Oleg Nesterov54767902006-03-28 16:11:30 -08001327 if (!likely(lock_task_sighand(p, &flags))) {
Oleg Nesterove752dd62005-09-06 15:17:42 -07001328 ret = -1;
1329 goto out_err;
1330 }
1331
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 if (unlikely(!list_empty(&q->list))) {
1333 /*
1334 * If an SI_TIMER entry is already queue just increment
1335 * the overrun count.
1336 */
Oleg Nesterov54767902006-03-28 16:11:30 -08001337 BUG_ON(q->info.si_code != SI_TIMER);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 q->info.si_overrun++;
1339 goto out;
Oleg Nesterove752dd62005-09-06 15:17:42 -07001340 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 /* Short-circuit ignored signals. */
1342 if (sig_ignored(p, sig)) {
1343 ret = 1;
1344 goto out;
1345 }
1346
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 list_add_tail(&q->list, &p->pending.list);
1348 sigaddset(&p->pending.signal, sig);
1349 if (!sigismember(&p->blocked, sig))
1350 signal_wake_up(p, sig == SIGKILL);
1351
1352out:
Oleg Nesterov54767902006-03-28 16:11:30 -08001353 unlock_task_sighand(p, &flags);
Oleg Nesterove752dd62005-09-06 15:17:42 -07001354out_err:
Ingo Molnare56d0902006-01-08 01:01:37 -08001355 rcu_read_unlock();
Oleg Nesterove752dd62005-09-06 15:17:42 -07001356
1357 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358}
1359
1360int
1361send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1362{
1363 unsigned long flags;
1364 int ret = 0;
1365
1366 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
Ingo Molnare56d0902006-01-08 01:01:37 -08001367
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 read_lock(&tasklist_lock);
Ingo Molnare56d0902006-01-08 01:01:37 -08001369 /* Since it_lock is held, p->sighand cannot be NULL. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 spin_lock_irqsave(&p->sighand->siglock, flags);
1371 handle_stop_signal(sig, p);
1372
1373 /* Short-circuit ignored signals. */
1374 if (sig_ignored(p, sig)) {
1375 ret = 1;
1376 goto out;
1377 }
1378
1379 if (unlikely(!list_empty(&q->list))) {
1380 /*
1381 * If an SI_TIMER entry is already queue just increment
1382 * the overrun count. Other uses should not try to
1383 * send the signal multiple times.
1384 */
Eric Sesterhennfda8bd72006-04-02 13:44:47 +02001385 BUG_ON(q->info.si_code != SI_TIMER);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 q->info.si_overrun++;
1387 goto out;
1388 }
1389
1390 /*
1391 * Put this signal on the shared-pending queue.
1392 * We always use the shared queue for process-wide signals,
1393 * to avoid several races.
1394 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 list_add_tail(&q->list, &p->signal->shared_pending.list);
1396 sigaddset(&p->signal->shared_pending.signal, sig);
1397
1398 __group_complete_signal(sig, p);
1399out:
1400 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1401 read_unlock(&tasklist_lock);
Ingo Molnare56d0902006-01-08 01:01:37 -08001402 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403}
1404
1405/*
1406 * Wake up any threads in the parent blocked in wait* syscalls.
1407 */
1408static inline void __wake_up_parent(struct task_struct *p,
1409 struct task_struct *parent)
1410{
1411 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1412}
1413
1414/*
1415 * Let a parent know about the death of a child.
1416 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1417 */
1418
1419void do_notify_parent(struct task_struct *tsk, int sig)
1420{
1421 struct siginfo info;
1422 unsigned long flags;
1423 struct sighand_struct *psig;
1424
1425 BUG_ON(sig == -1);
1426
1427 /* do_notify_parent_cldstop should have been called instead. */
1428 BUG_ON(tsk->state & (TASK_STOPPED|TASK_TRACED));
1429
1430 BUG_ON(!tsk->ptrace &&
1431 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1432
1433 info.si_signo = sig;
1434 info.si_errno = 0;
1435 info.si_pid = tsk->pid;
1436 info.si_uid = tsk->uid;
1437
1438 /* FIXME: find out whether or not this is supposed to be c*time. */
1439 info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1440 tsk->signal->utime));
1441 info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1442 tsk->signal->stime));
1443
1444 info.si_status = tsk->exit_code & 0x7f;
1445 if (tsk->exit_code & 0x80)
1446 info.si_code = CLD_DUMPED;
1447 else if (tsk->exit_code & 0x7f)
1448 info.si_code = CLD_KILLED;
1449 else {
1450 info.si_code = CLD_EXITED;
1451 info.si_status = tsk->exit_code >> 8;
1452 }
1453
1454 psig = tsk->parent->sighand;
1455 spin_lock_irqsave(&psig->siglock, flags);
Oleg Nesterov7ed01752005-11-10 17:22:18 +03001456 if (!tsk->ptrace && sig == SIGCHLD &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1458 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1459 /*
1460 * We are exiting and our parent doesn't care. POSIX.1
1461 * defines special semantics for setting SIGCHLD to SIG_IGN
1462 * or setting the SA_NOCLDWAIT flag: we should be reaped
1463 * automatically and not left for our parent's wait4 call.
1464 * Rather than having the parent do it as a magic kind of
1465 * signal handler, we just set this to tell do_exit that we
1466 * can be cleaned up without becoming a zombie. Note that
1467 * we still call __wake_up_parent in this case, because a
1468 * blocked sys_wait4 might now return -ECHILD.
1469 *
1470 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1471 * is implementation-defined: we do (if you don't want
1472 * it, just use SIG_IGN instead).
1473 */
1474 tsk->exit_signal = -1;
1475 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1476 sig = 0;
1477 }
Jesper Juhl7ed20e12005-05-01 08:59:14 -07001478 if (valid_signal(sig) && sig > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 __group_send_sig_info(sig, &info, tsk->parent);
1480 __wake_up_parent(tsk, tsk->parent);
1481 spin_unlock_irqrestore(&psig->siglock, flags);
1482}
1483
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001484static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485{
1486 struct siginfo info;
1487 unsigned long flags;
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001488 struct task_struct *parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 struct sighand_struct *sighand;
1490
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001491 if (tsk->ptrace & PT_PTRACED)
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001492 parent = tsk->parent;
1493 else {
1494 tsk = tsk->group_leader;
1495 parent = tsk->real_parent;
1496 }
1497
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 info.si_signo = SIGCHLD;
1499 info.si_errno = 0;
1500 info.si_pid = tsk->pid;
1501 info.si_uid = tsk->uid;
1502
1503 /* FIXME: find out whether or not this is supposed to be c*time. */
1504 info.si_utime = cputime_to_jiffies(tsk->utime);
1505 info.si_stime = cputime_to_jiffies(tsk->stime);
1506
1507 info.si_code = why;
1508 switch (why) {
1509 case CLD_CONTINUED:
1510 info.si_status = SIGCONT;
1511 break;
1512 case CLD_STOPPED:
1513 info.si_status = tsk->signal->group_exit_code & 0x7f;
1514 break;
1515 case CLD_TRAPPED:
1516 info.si_status = tsk->exit_code & 0x7f;
1517 break;
1518 default:
1519 BUG();
1520 }
1521
1522 sighand = parent->sighand;
1523 spin_lock_irqsave(&sighand->siglock, flags);
1524 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1525 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1526 __group_send_sig_info(SIGCHLD, &info, parent);
1527 /*
1528 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1529 */
1530 __wake_up_parent(tsk, parent);
1531 spin_unlock_irqrestore(&sighand->siglock, flags);
1532}
1533
1534/*
1535 * This must be called with current->sighand->siglock held.
1536 *
1537 * This should be the path for all ptrace stops.
1538 * We always set current->last_siginfo while stopped here.
1539 * That makes it a way to test a stopped process for
1540 * being ptrace-stopped vs being job-control-stopped.
1541 *
1542 * If we actually decide not to stop at all because the tracer is gone,
1543 * we leave nostop_code in current->exit_code.
1544 */
1545static void ptrace_stop(int exit_code, int nostop_code, siginfo_t *info)
1546{
1547 /*
1548 * If there is a group stop in progress,
1549 * we must participate in the bookkeeping.
1550 */
1551 if (current->signal->group_stop_count > 0)
1552 --current->signal->group_stop_count;
1553
1554 current->last_siginfo = info;
1555 current->exit_code = exit_code;
1556
1557 /* Let the debugger run. */
1558 set_current_state(TASK_TRACED);
1559 spin_unlock_irq(&current->sighand->siglock);
Pavel Machek85b6bce2006-03-31 02:30:06 -08001560 try_to_freeze();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 read_lock(&tasklist_lock);
1562 if (likely(current->ptrace & PT_PTRACED) &&
1563 likely(current->parent != current->real_parent ||
1564 !(current->ptrace & PT_ATTACHED)) &&
1565 (likely(current->parent->signal != current->signal) ||
1566 !unlikely(current->signal->flags & SIGNAL_GROUP_EXIT))) {
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001567 do_notify_parent_cldstop(current, CLD_TRAPPED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 read_unlock(&tasklist_lock);
1569 schedule();
1570 } else {
1571 /*
1572 * By the time we got the lock, our tracer went away.
1573 * Don't stop here.
1574 */
1575 read_unlock(&tasklist_lock);
1576 set_current_state(TASK_RUNNING);
1577 current->exit_code = nostop_code;
1578 }
1579
1580 /*
1581 * We are back. Now reacquire the siglock before touching
1582 * last_siginfo, so that we are sure to have synchronized with
1583 * any signal-sending on another CPU that wants to examine it.
1584 */
1585 spin_lock_irq(&current->sighand->siglock);
1586 current->last_siginfo = NULL;
1587
1588 /*
1589 * Queued signals ignored us while we were stopped for tracing.
1590 * So check for any that we should take before resuming user mode.
1591 */
1592 recalc_sigpending();
1593}
1594
1595void ptrace_notify(int exit_code)
1596{
1597 siginfo_t info;
1598
1599 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1600
1601 memset(&info, 0, sizeof info);
1602 info.si_signo = SIGTRAP;
1603 info.si_code = exit_code;
1604 info.si_pid = current->pid;
1605 info.si_uid = current->uid;
1606
1607 /* Let the debugger run. */
1608 spin_lock_irq(&current->sighand->siglock);
1609 ptrace_stop(exit_code, 0, &info);
1610 spin_unlock_irq(&current->sighand->siglock);
1611}
1612
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613static void
1614finish_stop(int stop_count)
1615{
1616 /*
1617 * If there are no other threads in the group, or if there is
1618 * a group stop in progress and we are the last to stop,
1619 * report to the parent. When ptraced, every thread reports itself.
1620 */
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001621 if (stop_count == 0 || (current->ptrace & PT_PTRACED)) {
1622 read_lock(&tasklist_lock);
1623 do_notify_parent_cldstop(current, CLD_STOPPED);
1624 read_unlock(&tasklist_lock);
1625 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626
1627 schedule();
1628 /*
1629 * Now we don't run again until continued.
1630 */
1631 current->exit_code = 0;
1632}
1633
1634/*
1635 * This performs the stopping for SIGSTOP and other stop signals.
1636 * We have to stop all threads in the thread group.
1637 * Returns nonzero if we've actually stopped and released the siglock.
1638 * Returns zero if we didn't stop and still hold the siglock.
1639 */
Oleg Nesterova122b342006-03-28 16:11:22 -08001640static int do_signal_stop(int signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641{
1642 struct signal_struct *sig = current->signal;
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001643 int stop_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644
1645 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED))
1646 return 0;
1647
1648 if (sig->group_stop_count > 0) {
1649 /*
1650 * There is a group stop in progress. We don't need to
1651 * start another one.
1652 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 stop_count = --sig->group_stop_count;
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001654 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 * There is no group stop already in progress.
Oleg Nesterova122b342006-03-28 16:11:22 -08001657 * We must initiate one now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 */
1659 struct task_struct *t;
1660
Oleg Nesterova122b342006-03-28 16:11:22 -08001661 sig->group_exit_code = signr;
1662
1663 stop_count = 0;
1664 for (t = next_thread(current); t != current; t = next_thread(t))
1665 /*
1666 * Setting state to TASK_STOPPED for a group
1667 * stop is always done with the siglock held,
1668 * so this check has no races.
1669 */
1670 if (!t->exit_state &&
1671 !(t->state & (TASK_STOPPED|TASK_TRACED))) {
1672 stop_count++;
1673 signal_wake_up(t, 0);
1674 }
1675 sig->group_stop_count = stop_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 }
1677
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001678 if (stop_count == 0)
1679 sig->flags = SIGNAL_STOP_STOPPED;
1680 current->exit_code = sig->group_exit_code;
1681 __set_current_state(TASK_STOPPED);
1682
1683 spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 finish_stop(stop_count);
1685 return 1;
1686}
1687
1688/*
1689 * Do appropriate magic when group_stop_count > 0.
1690 * We return nonzero if we stopped, after releasing the siglock.
1691 * We return zero if we still hold the siglock and should look
1692 * for another signal without checking group_stop_count again.
1693 */
Arjan van de Ven858119e2006-01-14 13:20:43 -08001694static int handle_group_stop(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695{
1696 int stop_count;
1697
1698 if (current->signal->group_exit_task == current) {
1699 /*
1700 * Group stop is so we can do a core dump,
1701 * We are the initiating thread, so get on with it.
1702 */
1703 current->signal->group_exit_task = NULL;
1704 return 0;
1705 }
1706
1707 if (current->signal->flags & SIGNAL_GROUP_EXIT)
1708 /*
1709 * Group stop is so another thread can do a core dump,
1710 * or else we are racing against a death signal.
1711 * Just punt the stop so we can get the next signal.
1712 */
1713 return 0;
1714
1715 /*
1716 * There is a group stop in progress. We stop
1717 * without any associated signal being in our queue.
1718 */
1719 stop_count = --current->signal->group_stop_count;
1720 if (stop_count == 0)
1721 current->signal->flags = SIGNAL_STOP_STOPPED;
1722 current->exit_code = current->signal->group_exit_code;
1723 set_current_state(TASK_STOPPED);
1724 spin_unlock_irq(&current->sighand->siglock);
1725 finish_stop(stop_count);
1726 return 1;
1727}
1728
1729int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1730 struct pt_regs *regs, void *cookie)
1731{
1732 sigset_t *mask = &current->blocked;
1733 int signr = 0;
1734
Rafael J. Wysockifc558a72006-03-23 03:00:05 -08001735 try_to_freeze();
1736
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737relock:
1738 spin_lock_irq(&current->sighand->siglock);
1739 for (;;) {
1740 struct k_sigaction *ka;
1741
1742 if (unlikely(current->signal->group_stop_count > 0) &&
1743 handle_group_stop())
1744 goto relock;
1745
1746 signr = dequeue_signal(current, mask, info);
1747
1748 if (!signr)
1749 break; /* will return 0 */
1750
1751 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1752 ptrace_signal_deliver(regs, cookie);
1753
1754 /* Let the debugger run. */
1755 ptrace_stop(signr, signr, info);
1756
Roland McGrathe57a5052006-04-12 16:30:20 -07001757 /* We're back. Did the debugger cancel the sig? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 signr = current->exit_code;
Roland McGrathe57a5052006-04-12 16:30:20 -07001759 if (signr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 continue;
1761
1762 current->exit_code = 0;
1763
1764 /* Update the siginfo structure if the signal has
1765 changed. If the debugger wanted something
1766 specific in the siginfo structure then it should
1767 have updated *info via PTRACE_SETSIGINFO. */
1768 if (signr != info->si_signo) {
1769 info->si_signo = signr;
1770 info->si_errno = 0;
1771 info->si_code = SI_USER;
1772 info->si_pid = current->parent->pid;
1773 info->si_uid = current->parent->uid;
1774 }
1775
1776 /* If the (new) signal is now blocked, requeue it. */
1777 if (sigismember(&current->blocked, signr)) {
1778 specific_send_sig_info(signr, info, current);
1779 continue;
1780 }
1781 }
1782
1783 ka = &current->sighand->action[signr-1];
1784 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1785 continue;
1786 if (ka->sa.sa_handler != SIG_DFL) {
1787 /* Run the handler. */
1788 *return_ka = *ka;
1789
1790 if (ka->sa.sa_flags & SA_ONESHOT)
1791 ka->sa.sa_handler = SIG_DFL;
1792
1793 break; /* will return non-zero "signr" value */
1794 }
1795
1796 /*
1797 * Now we are doing the default action for this signal.
1798 */
1799 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1800 continue;
1801
1802 /* Init gets no signals it doesn't want. */
Eric W. Biedermanfef23e72006-03-28 16:10:58 -08001803 if (current == child_reaper)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 continue;
1805
1806 if (sig_kernel_stop(signr)) {
1807 /*
1808 * The default action is to stop all threads in
1809 * the thread group. The job control signals
1810 * do nothing in an orphaned pgrp, but SIGSTOP
1811 * always works. Note that siglock needs to be
1812 * dropped during the call to is_orphaned_pgrp()
1813 * because of lock ordering with tasklist_lock.
1814 * This allows an intervening SIGCONT to be posted.
1815 * We need to check for that and bail out if necessary.
1816 */
1817 if (signr != SIGSTOP) {
1818 spin_unlock_irq(&current->sighand->siglock);
1819
1820 /* signals can be posted during this window */
1821
1822 if (is_orphaned_pgrp(process_group(current)))
1823 goto relock;
1824
1825 spin_lock_irq(&current->sighand->siglock);
1826 }
1827
1828 if (likely(do_signal_stop(signr))) {
1829 /* It released the siglock. */
1830 goto relock;
1831 }
1832
1833 /*
1834 * We didn't actually stop, due to a race
1835 * with SIGCONT or something like that.
1836 */
1837 continue;
1838 }
1839
1840 spin_unlock_irq(&current->sighand->siglock);
1841
1842 /*
1843 * Anything else is fatal, maybe with a core dump.
1844 */
1845 current->flags |= PF_SIGNALED;
1846 if (sig_kernel_coredump(signr)) {
1847 /*
1848 * If it was able to dump core, this kills all
1849 * other threads in the group and synchronizes with
1850 * their demise. If we lost the race with another
1851 * thread getting here, it set group_exit_code
1852 * first and our do_group_exit call below will use
1853 * that value and ignore the one we pass it.
1854 */
1855 do_coredump((long)signr, signr, regs);
1856 }
1857
1858 /*
1859 * Death signals, no core dump.
1860 */
1861 do_group_exit(signr);
1862 /* NOTREACHED */
1863 }
1864 spin_unlock_irq(&current->sighand->siglock);
1865 return signr;
1866}
1867
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868EXPORT_SYMBOL(recalc_sigpending);
1869EXPORT_SYMBOL_GPL(dequeue_signal);
1870EXPORT_SYMBOL(flush_signals);
1871EXPORT_SYMBOL(force_sig);
1872EXPORT_SYMBOL(kill_pg);
1873EXPORT_SYMBOL(kill_proc);
1874EXPORT_SYMBOL(ptrace_notify);
1875EXPORT_SYMBOL(send_sig);
1876EXPORT_SYMBOL(send_sig_info);
1877EXPORT_SYMBOL(sigprocmask);
1878EXPORT_SYMBOL(block_all_signals);
1879EXPORT_SYMBOL(unblock_all_signals);
1880
1881
1882/*
1883 * System call entry points.
1884 */
1885
1886asmlinkage long sys_restart_syscall(void)
1887{
1888 struct restart_block *restart = &current_thread_info()->restart_block;
1889 return restart->fn(restart);
1890}
1891
1892long do_no_restart_syscall(struct restart_block *param)
1893{
1894 return -EINTR;
1895}
1896
1897/*
1898 * We don't need to get the kernel lock - this is all local to this
1899 * particular thread.. (and that's good, because this is _heavily_
1900 * used by various programs)
1901 */
1902
1903/*
1904 * This is also useful for kernel threads that want to temporarily
1905 * (or permanently) block certain signals.
1906 *
1907 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1908 * interface happily blocks "unblockable" signals like SIGKILL
1909 * and friends.
1910 */
1911int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
1912{
1913 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914
1915 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterova26fd332006-03-23 03:00:49 -08001916 if (oldset)
1917 *oldset = current->blocked;
1918
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 error = 0;
1920 switch (how) {
1921 case SIG_BLOCK:
1922 sigorsets(&current->blocked, &current->blocked, set);
1923 break;
1924 case SIG_UNBLOCK:
1925 signandsets(&current->blocked, &current->blocked, set);
1926 break;
1927 case SIG_SETMASK:
1928 current->blocked = *set;
1929 break;
1930 default:
1931 error = -EINVAL;
1932 }
1933 recalc_sigpending();
1934 spin_unlock_irq(&current->sighand->siglock);
Oleg Nesterova26fd332006-03-23 03:00:49 -08001935
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 return error;
1937}
1938
1939asmlinkage long
1940sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
1941{
1942 int error = -EINVAL;
1943 sigset_t old_set, new_set;
1944
1945 /* XXX: Don't preclude handling different sized sigset_t's. */
1946 if (sigsetsize != sizeof(sigset_t))
1947 goto out;
1948
1949 if (set) {
1950 error = -EFAULT;
1951 if (copy_from_user(&new_set, set, sizeof(*set)))
1952 goto out;
1953 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
1954
1955 error = sigprocmask(how, &new_set, &old_set);
1956 if (error)
1957 goto out;
1958 if (oset)
1959 goto set_old;
1960 } else if (oset) {
1961 spin_lock_irq(&current->sighand->siglock);
1962 old_set = current->blocked;
1963 spin_unlock_irq(&current->sighand->siglock);
1964
1965 set_old:
1966 error = -EFAULT;
1967 if (copy_to_user(oset, &old_set, sizeof(*oset)))
1968 goto out;
1969 }
1970 error = 0;
1971out:
1972 return error;
1973}
1974
1975long do_sigpending(void __user *set, unsigned long sigsetsize)
1976{
1977 long error = -EINVAL;
1978 sigset_t pending;
1979
1980 if (sigsetsize > sizeof(sigset_t))
1981 goto out;
1982
1983 spin_lock_irq(&current->sighand->siglock);
1984 sigorsets(&pending, &current->pending.signal,
1985 &current->signal->shared_pending.signal);
1986 spin_unlock_irq(&current->sighand->siglock);
1987
1988 /* Outside the lock because only this thread touches it. */
1989 sigandsets(&pending, &current->blocked, &pending);
1990
1991 error = -EFAULT;
1992 if (!copy_to_user(set, &pending, sigsetsize))
1993 error = 0;
1994
1995out:
1996 return error;
1997}
1998
1999asmlinkage long
2000sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2001{
2002 return do_sigpending(set, sigsetsize);
2003}
2004
2005#ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2006
2007int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2008{
2009 int err;
2010
2011 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2012 return -EFAULT;
2013 if (from->si_code < 0)
2014 return __copy_to_user(to, from, sizeof(siginfo_t))
2015 ? -EFAULT : 0;
2016 /*
2017 * If you change siginfo_t structure, please be sure
2018 * this code is fixed accordingly.
2019 * It should never copy any pad contained in the structure
2020 * to avoid security leaks, but must copy the generic
2021 * 3 ints plus the relevant union member.
2022 */
2023 err = __put_user(from->si_signo, &to->si_signo);
2024 err |= __put_user(from->si_errno, &to->si_errno);
2025 err |= __put_user((short)from->si_code, &to->si_code);
2026 switch (from->si_code & __SI_MASK) {
2027 case __SI_KILL:
2028 err |= __put_user(from->si_pid, &to->si_pid);
2029 err |= __put_user(from->si_uid, &to->si_uid);
2030 break;
2031 case __SI_TIMER:
2032 err |= __put_user(from->si_tid, &to->si_tid);
2033 err |= __put_user(from->si_overrun, &to->si_overrun);
2034 err |= __put_user(from->si_ptr, &to->si_ptr);
2035 break;
2036 case __SI_POLL:
2037 err |= __put_user(from->si_band, &to->si_band);
2038 err |= __put_user(from->si_fd, &to->si_fd);
2039 break;
2040 case __SI_FAULT:
2041 err |= __put_user(from->si_addr, &to->si_addr);
2042#ifdef __ARCH_SI_TRAPNO
2043 err |= __put_user(from->si_trapno, &to->si_trapno);
2044#endif
2045 break;
2046 case __SI_CHLD:
2047 err |= __put_user(from->si_pid, &to->si_pid);
2048 err |= __put_user(from->si_uid, &to->si_uid);
2049 err |= __put_user(from->si_status, &to->si_status);
2050 err |= __put_user(from->si_utime, &to->si_utime);
2051 err |= __put_user(from->si_stime, &to->si_stime);
2052 break;
2053 case __SI_RT: /* This is not generated by the kernel as of now. */
2054 case __SI_MESGQ: /* But this is */
2055 err |= __put_user(from->si_pid, &to->si_pid);
2056 err |= __put_user(from->si_uid, &to->si_uid);
2057 err |= __put_user(from->si_ptr, &to->si_ptr);
2058 break;
2059 default: /* this is just in case for now ... */
2060 err |= __put_user(from->si_pid, &to->si_pid);
2061 err |= __put_user(from->si_uid, &to->si_uid);
2062 break;
2063 }
2064 return err;
2065}
2066
2067#endif
2068
2069asmlinkage long
2070sys_rt_sigtimedwait(const sigset_t __user *uthese,
2071 siginfo_t __user *uinfo,
2072 const struct timespec __user *uts,
2073 size_t sigsetsize)
2074{
2075 int ret, sig;
2076 sigset_t these;
2077 struct timespec ts;
2078 siginfo_t info;
2079 long timeout = 0;
2080
2081 /* XXX: Don't preclude handling different sized sigset_t's. */
2082 if (sigsetsize != sizeof(sigset_t))
2083 return -EINVAL;
2084
2085 if (copy_from_user(&these, uthese, sizeof(these)))
2086 return -EFAULT;
2087
2088 /*
2089 * Invert the set of allowed signals to get those we
2090 * want to block.
2091 */
2092 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2093 signotset(&these);
2094
2095 if (uts) {
2096 if (copy_from_user(&ts, uts, sizeof(ts)))
2097 return -EFAULT;
2098 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2099 || ts.tv_sec < 0)
2100 return -EINVAL;
2101 }
2102
2103 spin_lock_irq(&current->sighand->siglock);
2104 sig = dequeue_signal(current, &these, &info);
2105 if (!sig) {
2106 timeout = MAX_SCHEDULE_TIMEOUT;
2107 if (uts)
2108 timeout = (timespec_to_jiffies(&ts)
2109 + (ts.tv_sec || ts.tv_nsec));
2110
2111 if (timeout) {
2112 /* None ready -- temporarily unblock those we're
2113 * interested while we are sleeping in so that we'll
2114 * be awakened when they arrive. */
2115 current->real_blocked = current->blocked;
2116 sigandsets(&current->blocked, &current->blocked, &these);
2117 recalc_sigpending();
2118 spin_unlock_irq(&current->sighand->siglock);
2119
Nishanth Aravamudan75bcc8c2005-09-10 00:27:24 -07002120 timeout = schedule_timeout_interruptible(timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 spin_lock_irq(&current->sighand->siglock);
2123 sig = dequeue_signal(current, &these, &info);
2124 current->blocked = current->real_blocked;
2125 siginitset(&current->real_blocked, 0);
2126 recalc_sigpending();
2127 }
2128 }
2129 spin_unlock_irq(&current->sighand->siglock);
2130
2131 if (sig) {
2132 ret = sig;
2133 if (uinfo) {
2134 if (copy_siginfo_to_user(uinfo, &info))
2135 ret = -EFAULT;
2136 }
2137 } else {
2138 ret = -EAGAIN;
2139 if (timeout)
2140 ret = -EINTR;
2141 }
2142
2143 return ret;
2144}
2145
2146asmlinkage long
2147sys_kill(int pid, int sig)
2148{
2149 struct siginfo info;
2150
2151 info.si_signo = sig;
2152 info.si_errno = 0;
2153 info.si_code = SI_USER;
2154 info.si_pid = current->tgid;
2155 info.si_uid = current->uid;
2156
2157 return kill_something_info(sig, &info, pid);
2158}
2159
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002160static int do_tkill(int tgid, int pid, int sig)
2161{
2162 int error;
2163 struct siginfo info;
2164 struct task_struct *p;
2165
2166 error = -ESRCH;
2167 info.si_signo = sig;
2168 info.si_errno = 0;
2169 info.si_code = SI_TKILL;
2170 info.si_pid = current->tgid;
2171 info.si_uid = current->uid;
2172
2173 read_lock(&tasklist_lock);
2174 p = find_task_by_pid(pid);
2175 if (p && (tgid <= 0 || p->tgid == tgid)) {
2176 error = check_kill_permission(sig, &info, p);
2177 /*
2178 * The null signal is a permissions and process existence
2179 * probe. No signal is actually delivered.
2180 */
2181 if (!error && sig && p->sighand) {
2182 spin_lock_irq(&p->sighand->siglock);
2183 handle_stop_signal(sig, p);
2184 error = specific_send_sig_info(sig, &info, p);
2185 spin_unlock_irq(&p->sighand->siglock);
2186 }
2187 }
2188 read_unlock(&tasklist_lock);
2189
2190 return error;
2191}
2192
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193/**
2194 * sys_tgkill - send signal to one specific thread
2195 * @tgid: the thread group ID of the thread
2196 * @pid: the PID of the thread
2197 * @sig: signal to be sent
2198 *
2199 * This syscall also checks the tgid and returns -ESRCH even if the PID
2200 * exists but it's not belonging to the target process anymore. This
2201 * method solves the problem of threads exiting and PIDs getting reused.
2202 */
2203asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2204{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 /* This is only valid for single tasks */
2206 if (pid <= 0 || tgid <= 0)
2207 return -EINVAL;
2208
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002209 return do_tkill(tgid, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210}
2211
2212/*
2213 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2214 */
2215asmlinkage long
2216sys_tkill(int pid, int sig)
2217{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218 /* This is only valid for single tasks */
2219 if (pid <= 0)
2220 return -EINVAL;
2221
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002222 return do_tkill(0, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223}
2224
2225asmlinkage long
2226sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2227{
2228 siginfo_t info;
2229
2230 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2231 return -EFAULT;
2232
2233 /* Not even root can pretend to send signals from the kernel.
2234 Nor can they impersonate a kill(), which adds source info. */
2235 if (info.si_code >= 0)
2236 return -EPERM;
2237 info.si_signo = sig;
2238
2239 /* POSIX.1b doesn't mention process groups. */
2240 return kill_proc_info(sig, &info, pid);
2241}
2242
Oleg Nesterov88531f72006-03-28 16:11:24 -08002243int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244{
2245 struct k_sigaction *k;
George Anzinger71fabd52006-01-08 01:02:48 -08002246 sigset_t mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247
Jesper Juhl7ed20e12005-05-01 08:59:14 -07002248 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 return -EINVAL;
2250
2251 k = &current->sighand->action[sig-1];
2252
2253 spin_lock_irq(&current->sighand->siglock);
2254 if (signal_pending(current)) {
2255 /*
2256 * If there might be a fatal signal pending on multiple
2257 * threads, make sure we take it before changing the action.
2258 */
2259 spin_unlock_irq(&current->sighand->siglock);
2260 return -ERESTARTNOINTR;
2261 }
2262
2263 if (oact)
2264 *oact = *k;
2265
2266 if (act) {
Oleg Nesterov9ac95f22006-02-09 22:41:50 +03002267 sigdelsetmask(&act->sa.sa_mask,
2268 sigmask(SIGKILL) | sigmask(SIGSTOP));
Oleg Nesterov88531f72006-03-28 16:11:24 -08002269 *k = *act;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 /*
2271 * POSIX 3.3.1.3:
2272 * "Setting a signal action to SIG_IGN for a signal that is
2273 * pending shall cause the pending signal to be discarded,
2274 * whether or not it is blocked."
2275 *
2276 * "Setting a signal action to SIG_DFL for a signal that is
2277 * pending and whose default action is to ignore the signal
2278 * (for example, SIGCHLD), shall cause the pending signal to
2279 * be discarded, whether or not it is blocked"
2280 */
2281 if (act->sa.sa_handler == SIG_IGN ||
Oleg Nesterov88531f72006-03-28 16:11:24 -08002282 (act->sa.sa_handler == SIG_DFL && sig_kernel_ignore(sig))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 struct task_struct *t = current;
George Anzinger71fabd52006-01-08 01:02:48 -08002284 sigemptyset(&mask);
2285 sigaddset(&mask, sig);
2286 rm_from_queue_full(&mask, &t->signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287 do {
George Anzinger71fabd52006-01-08 01:02:48 -08002288 rm_from_queue_full(&mask, &t->pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289 recalc_sigpending_tsk(t);
2290 t = next_thread(t);
2291 } while (t != current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293 }
2294
2295 spin_unlock_irq(&current->sighand->siglock);
2296 return 0;
2297}
2298
2299int
2300do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2301{
2302 stack_t oss;
2303 int error;
2304
2305 if (uoss) {
2306 oss.ss_sp = (void __user *) current->sas_ss_sp;
2307 oss.ss_size = current->sas_ss_size;
2308 oss.ss_flags = sas_ss_flags(sp);
2309 }
2310
2311 if (uss) {
2312 void __user *ss_sp;
2313 size_t ss_size;
2314 int ss_flags;
2315
2316 error = -EFAULT;
2317 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2318 || __get_user(ss_sp, &uss->ss_sp)
2319 || __get_user(ss_flags, &uss->ss_flags)
2320 || __get_user(ss_size, &uss->ss_size))
2321 goto out;
2322
2323 error = -EPERM;
2324 if (on_sig_stack(sp))
2325 goto out;
2326
2327 error = -EINVAL;
2328 /*
2329 *
2330 * Note - this code used to test ss_flags incorrectly
2331 * old code may have been written using ss_flags==0
2332 * to mean ss_flags==SS_ONSTACK (as this was the only
2333 * way that worked) - this fix preserves that older
2334 * mechanism
2335 */
2336 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2337 goto out;
2338
2339 if (ss_flags == SS_DISABLE) {
2340 ss_size = 0;
2341 ss_sp = NULL;
2342 } else {
2343 error = -ENOMEM;
2344 if (ss_size < MINSIGSTKSZ)
2345 goto out;
2346 }
2347
2348 current->sas_ss_sp = (unsigned long) ss_sp;
2349 current->sas_ss_size = ss_size;
2350 }
2351
2352 if (uoss) {
2353 error = -EFAULT;
2354 if (copy_to_user(uoss, &oss, sizeof(oss)))
2355 goto out;
2356 }
2357
2358 error = 0;
2359out:
2360 return error;
2361}
2362
2363#ifdef __ARCH_WANT_SYS_SIGPENDING
2364
2365asmlinkage long
2366sys_sigpending(old_sigset_t __user *set)
2367{
2368 return do_sigpending(set, sizeof(*set));
2369}
2370
2371#endif
2372
2373#ifdef __ARCH_WANT_SYS_SIGPROCMASK
2374/* Some platforms have their own version with special arguments others
2375 support only sys_rt_sigprocmask. */
2376
2377asmlinkage long
2378sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2379{
2380 int error;
2381 old_sigset_t old_set, new_set;
2382
2383 if (set) {
2384 error = -EFAULT;
2385 if (copy_from_user(&new_set, set, sizeof(*set)))
2386 goto out;
2387 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2388
2389 spin_lock_irq(&current->sighand->siglock);
2390 old_set = current->blocked.sig[0];
2391
2392 error = 0;
2393 switch (how) {
2394 default:
2395 error = -EINVAL;
2396 break;
2397 case SIG_BLOCK:
2398 sigaddsetmask(&current->blocked, new_set);
2399 break;
2400 case SIG_UNBLOCK:
2401 sigdelsetmask(&current->blocked, new_set);
2402 break;
2403 case SIG_SETMASK:
2404 current->blocked.sig[0] = new_set;
2405 break;
2406 }
2407
2408 recalc_sigpending();
2409 spin_unlock_irq(&current->sighand->siglock);
2410 if (error)
2411 goto out;
2412 if (oset)
2413 goto set_old;
2414 } else if (oset) {
2415 old_set = current->blocked.sig[0];
2416 set_old:
2417 error = -EFAULT;
2418 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2419 goto out;
2420 }
2421 error = 0;
2422out:
2423 return error;
2424}
2425#endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2426
2427#ifdef __ARCH_WANT_SYS_RT_SIGACTION
2428asmlinkage long
2429sys_rt_sigaction(int sig,
2430 const struct sigaction __user *act,
2431 struct sigaction __user *oact,
2432 size_t sigsetsize)
2433{
2434 struct k_sigaction new_sa, old_sa;
2435 int ret = -EINVAL;
2436
2437 /* XXX: Don't preclude handling different sized sigset_t's. */
2438 if (sigsetsize != sizeof(sigset_t))
2439 goto out;
2440
2441 if (act) {
2442 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2443 return -EFAULT;
2444 }
2445
2446 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2447
2448 if (!ret && oact) {
2449 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2450 return -EFAULT;
2451 }
2452out:
2453 return ret;
2454}
2455#endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2456
2457#ifdef __ARCH_WANT_SYS_SGETMASK
2458
2459/*
2460 * For backwards compatibility. Functionality superseded by sigprocmask.
2461 */
2462asmlinkage long
2463sys_sgetmask(void)
2464{
2465 /* SMP safe */
2466 return current->blocked.sig[0];
2467}
2468
2469asmlinkage long
2470sys_ssetmask(int newmask)
2471{
2472 int old;
2473
2474 spin_lock_irq(&current->sighand->siglock);
2475 old = current->blocked.sig[0];
2476
2477 siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2478 sigmask(SIGSTOP)));
2479 recalc_sigpending();
2480 spin_unlock_irq(&current->sighand->siglock);
2481
2482 return old;
2483}
2484#endif /* __ARCH_WANT_SGETMASK */
2485
2486#ifdef __ARCH_WANT_SYS_SIGNAL
2487/*
2488 * For backwards compatibility. Functionality superseded by sigaction.
2489 */
2490asmlinkage unsigned long
2491sys_signal(int sig, __sighandler_t handler)
2492{
2493 struct k_sigaction new_sa, old_sa;
2494 int ret;
2495
2496 new_sa.sa.sa_handler = handler;
2497 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
Oleg Nesterovc70d3d702006-02-09 22:41:41 +03002498 sigemptyset(&new_sa.sa.sa_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499
2500 ret = do_sigaction(sig, &new_sa, &old_sa);
2501
2502 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2503}
2504#endif /* __ARCH_WANT_SYS_SIGNAL */
2505
2506#ifdef __ARCH_WANT_SYS_PAUSE
2507
2508asmlinkage long
2509sys_pause(void)
2510{
2511 current->state = TASK_INTERRUPTIBLE;
2512 schedule();
2513 return -ERESTARTNOHAND;
2514}
2515
2516#endif
2517
David Woodhouse150256d2006-01-18 17:43:57 -08002518#ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2519asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2520{
2521 sigset_t newset;
2522
2523 /* XXX: Don't preclude handling different sized sigset_t's. */
2524 if (sigsetsize != sizeof(sigset_t))
2525 return -EINVAL;
2526
2527 if (copy_from_user(&newset, unewset, sizeof(newset)))
2528 return -EFAULT;
2529 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2530
2531 spin_lock_irq(&current->sighand->siglock);
2532 current->saved_sigmask = current->blocked;
2533 current->blocked = newset;
2534 recalc_sigpending();
2535 spin_unlock_irq(&current->sighand->siglock);
2536
2537 current->state = TASK_INTERRUPTIBLE;
2538 schedule();
2539 set_thread_flag(TIF_RESTORE_SIGMASK);
2540 return -ERESTARTNOHAND;
2541}
2542#endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2543
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544void __init signals_init(void)
2545{
2546 sigqueue_cachep =
2547 kmem_cache_create("sigqueue",
2548 sizeof(struct sigqueue),
2549 __alignof__(struct sigqueue),
2550 SLAB_PANIC, NULL, NULL);
2551}