blob: 954f77d7e3bc2368f405fa2ab83aaf58d6280fb3 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/slab.h>
14#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/init.h>
16#include <linux/sched.h>
17#include <linux/fs.h>
18#include <linux/tty.h>
19#include <linux/binfmts.h>
20#include <linux/security.h>
21#include <linux/syscalls.h>
22#include <linux/ptrace.h>
Jesper Juhl7ed20e12005-05-01 08:59:14 -070023#include <linux/signal.h>
Davide Libenzifba2afa2007-05-10 22:23:13 -070024#include <linux/signalfd.h>
Roland McGrath35de2542008-07-25 19:45:51 -070025#include <linux/tracehook.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080026#include <linux/capability.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080027#include <linux/freezer.h>
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -080028#include <linux/pid_namespace.h>
29#include <linux/nsproxy.h>
30
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <asm/param.h>
32#include <asm/uaccess.h>
33#include <asm/unistd.h>
34#include <asm/siginfo.h>
Al Viroe1396062006-05-25 10:19:47 -040035#include "audit.h" /* audit_signal_info() */
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37/*
38 * SLAB caches for signal bits.
39 */
40
Christoph Lametere18b8902006-12-06 20:33:20 -080041static struct kmem_cache *sigqueue_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Roland McGrath35de2542008-07-25 19:45:51 -070043static void __user *sig_handler(struct task_struct *t, int sig)
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070044{
Roland McGrath35de2542008-07-25 19:45:51 -070045 return t->sighand->action[sig - 1].sa.sa_handler;
46}
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070047
Roland McGrath35de2542008-07-25 19:45:51 -070048static int sig_handler_ignored(void __user *handler, int sig)
49{
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070050 /* Is it explicitly or implicitly ignored? */
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070051 return handler == SIG_IGN ||
52 (handler == SIG_DFL && sig_kernel_ignore(sig));
53}
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
55static int sig_ignored(struct task_struct *t, int sig)
56{
Roland McGrath35de2542008-07-25 19:45:51 -070057 void __user *handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
59 /*
60 * Blocked signals are never ignored, since the
61 * signal handler may change by the time it is
62 * unblocked.
63 */
Roland McGrath325d22d2007-11-12 15:41:55 -080064 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 return 0;
66
Roland McGrath35de2542008-07-25 19:45:51 -070067 handler = sig_handler(t, sig);
68 if (!sig_handler_ignored(handler, sig))
69 return 0;
70
71 /*
72 * Tracers may want to know about even ignored signals.
73 */
74 return !tracehook_consider_ignored_signal(t, sig, handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075}
76
77/*
78 * Re-calculate pending state from the set of locally pending
79 * signals, globally pending signals, and blocked signals.
80 */
81static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
82{
83 unsigned long ready;
84 long i;
85
86 switch (_NSIG_WORDS) {
87 default:
88 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
89 ready |= signal->sig[i] &~ blocked->sig[i];
90 break;
91
92 case 4: ready = signal->sig[3] &~ blocked->sig[3];
93 ready |= signal->sig[2] &~ blocked->sig[2];
94 ready |= signal->sig[1] &~ blocked->sig[1];
95 ready |= signal->sig[0] &~ blocked->sig[0];
96 break;
97
98 case 2: ready = signal->sig[1] &~ blocked->sig[1];
99 ready |= signal->sig[0] &~ blocked->sig[0];
100 break;
101
102 case 1: ready = signal->sig[0] &~ blocked->sig[0];
103 }
104 return ready != 0;
105}
106
107#define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
108
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700109static int recalc_sigpending_tsk(struct task_struct *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110{
111 if (t->signal->group_stop_count > 0 ||
112 PENDING(&t->pending, &t->blocked) ||
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700113 PENDING(&t->signal->shared_pending, &t->blocked)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 set_tsk_thread_flag(t, TIF_SIGPENDING);
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700115 return 1;
116 }
Roland McGrathb74d0de2007-06-06 03:59:00 -0700117 /*
118 * We must never clear the flag in another thread, or in current
119 * when it's possible the current syscall is returning -ERESTART*.
120 * So we don't clear it here, and only callers who know they should do.
121 */
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700122 return 0;
123}
124
125/*
126 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
127 * This is superfluous when called on current, the wakeup is a harmless no-op.
128 */
129void recalc_sigpending_and_wake(struct task_struct *t)
130{
131 if (recalc_sigpending_tsk(t))
132 signal_wake_up(t, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133}
134
135void recalc_sigpending(void)
136{
Roland McGrathb787f7b2008-07-25 19:45:55 -0700137 if (unlikely(tracehook_force_sigpending()))
138 set_thread_flag(TIF_SIGPENDING);
139 else if (!recalc_sigpending_tsk(current) && !freezing(current))
Roland McGrathb74d0de2007-06-06 03:59:00 -0700140 clear_thread_flag(TIF_SIGPENDING);
141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142}
143
144/* Given the mask, find the first available signal that should be serviced. */
145
Davide Libenzifba2afa2007-05-10 22:23:13 -0700146int next_signal(struct sigpending *pending, sigset_t *mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
148 unsigned long i, *s, *m, x;
149 int sig = 0;
150
151 s = pending->signal.sig;
152 m = mask->sig;
153 switch (_NSIG_WORDS) {
154 default:
155 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
156 if ((x = *s &~ *m) != 0) {
157 sig = ffz(~x) + i*_NSIG_BPW + 1;
158 break;
159 }
160 break;
161
162 case 2: if ((x = s[0] &~ m[0]) != 0)
163 sig = 1;
164 else if ((x = s[1] &~ m[1]) != 0)
165 sig = _NSIG_BPW + 1;
166 else
167 break;
168 sig += ffz(~x);
169 break;
170
171 case 1: if ((x = *s &~ *m) != 0)
172 sig = ffz(~x) + 1;
173 break;
174 }
175
176 return sig;
177}
178
Al Virodd0fc662005-10-07 07:46:04 +0100179static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 int override_rlimit)
181{
182 struct sigqueue *q = NULL;
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800183 struct user_struct *user;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800185 /*
186 * In order to avoid problems with "switch_user()", we want to make
187 * sure that the compiler doesn't re-load "t->user"
188 */
189 user = t->user;
190 barrier();
191 atomic_inc(&user->sigpending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 if (override_rlimit ||
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800193 atomic_read(&user->sigpending) <=
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
195 q = kmem_cache_alloc(sigqueue_cachep, flags);
196 if (unlikely(q == NULL)) {
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800197 atomic_dec(&user->sigpending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 } else {
199 INIT_LIST_HEAD(&q->list);
200 q->flags = 0;
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800201 q->user = get_uid(user);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 }
203 return(q);
204}
205
Andrew Morton514a01b2006-02-03 03:04:41 -0800206static void __sigqueue_free(struct sigqueue *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207{
208 if (q->flags & SIGQUEUE_PREALLOC)
209 return;
210 atomic_dec(&q->user->sigpending);
211 free_uid(q->user);
212 kmem_cache_free(sigqueue_cachep, q);
213}
214
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800215void flush_sigqueue(struct sigpending *queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216{
217 struct sigqueue *q;
218
219 sigemptyset(&queue->signal);
220 while (!list_empty(&queue->list)) {
221 q = list_entry(queue->list.next, struct sigqueue , list);
222 list_del_init(&q->list);
223 __sigqueue_free(q);
224 }
225}
226
227/*
228 * Flush all pending signals for a task.
229 */
Oleg Nesterovc81addc2006-03-28 16:11:17 -0800230void flush_signals(struct task_struct *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231{
232 unsigned long flags;
233
234 spin_lock_irqsave(&t->sighand->siglock, flags);
Pavel Machekf5264482008-04-21 22:15:06 +0000235 clear_tsk_thread_flag(t, TIF_SIGPENDING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 flush_sigqueue(&t->pending);
237 flush_sigqueue(&t->signal->shared_pending);
238 spin_unlock_irqrestore(&t->sighand->siglock, flags);
239}
240
Oleg Nesterovcbaffba2008-05-26 20:55:42 +0400241static void __flush_itimer_signals(struct sigpending *pending)
242{
243 sigset_t signal, retain;
244 struct sigqueue *q, *n;
245
246 signal = pending->signal;
247 sigemptyset(&retain);
248
249 list_for_each_entry_safe(q, n, &pending->list, list) {
250 int sig = q->info.si_signo;
251
252 if (likely(q->info.si_code != SI_TIMER)) {
253 sigaddset(&retain, sig);
254 } else {
255 sigdelset(&signal, sig);
256 list_del_init(&q->list);
257 __sigqueue_free(q);
258 }
259 }
260
261 sigorsets(&pending->signal, &signal, &retain);
262}
263
264void flush_itimer_signals(void)
265{
266 struct task_struct *tsk = current;
267 unsigned long flags;
268
269 spin_lock_irqsave(&tsk->sighand->siglock, flags);
270 __flush_itimer_signals(&tsk->pending);
271 __flush_itimer_signals(&tsk->signal->shared_pending);
272 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
273}
274
Oleg Nesterov10ab8252007-05-09 02:34:37 -0700275void ignore_signals(struct task_struct *t)
276{
277 int i;
278
279 for (i = 0; i < _NSIG; ++i)
280 t->sighand->action[i].sa.sa_handler = SIG_IGN;
281
282 flush_signals(t);
283}
284
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 * Flush all handlers for a task.
287 */
288
289void
290flush_signal_handlers(struct task_struct *t, int force_default)
291{
292 int i;
293 struct k_sigaction *ka = &t->sighand->action[0];
294 for (i = _NSIG ; i != 0 ; i--) {
295 if (force_default || ka->sa.sa_handler != SIG_IGN)
296 ka->sa.sa_handler = SIG_DFL;
297 ka->sa.sa_flags = 0;
298 sigemptyset(&ka->sa.sa_mask);
299 ka++;
300 }
301}
302
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200303int unhandled_signal(struct task_struct *tsk, int sig)
304{
Roland McGrath445a91d2008-07-25 19:45:52 -0700305 void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
Serge E. Hallynb460cbc2007-10-18 23:39:52 -0700306 if (is_global_init(tsk))
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200307 return 1;
Roland McGrath445a91d2008-07-25 19:45:52 -0700308 if (handler != SIG_IGN && handler != SIG_DFL)
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200309 return 0;
Roland McGrath445a91d2008-07-25 19:45:52 -0700310 return !tracehook_consider_fatal_signal(tsk, sig, handler);
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200311}
312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
314/* Notify the system that a driver wants to block all signals for this
315 * process, and wants to be notified if any signals at all were to be
316 * sent/acted upon. If the notifier routine returns non-zero, then the
317 * signal will be acted upon after all. If the notifier routine returns 0,
318 * then then signal will be blocked. Only one block per process is
319 * allowed. priv is a pointer to private data that the notifier routine
320 * can use to determine if the signal should be blocked or not. */
321
322void
323block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
324{
325 unsigned long flags;
326
327 spin_lock_irqsave(&current->sighand->siglock, flags);
328 current->notifier_mask = mask;
329 current->notifier_data = priv;
330 current->notifier = notifier;
331 spin_unlock_irqrestore(&current->sighand->siglock, flags);
332}
333
334/* Notify the system that blocking has ended. */
335
336void
337unblock_all_signals(void)
338{
339 unsigned long flags;
340
341 spin_lock_irqsave(&current->sighand->siglock, flags);
342 current->notifier = NULL;
343 current->notifier_data = NULL;
344 recalc_sigpending();
345 spin_unlock_irqrestore(&current->sighand->siglock, flags);
346}
347
Oleg Nesterov100360f2008-07-25 01:47:29 -0700348static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349{
350 struct sigqueue *q, *first = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 /*
353 * Collect the siginfo appropriate to this signal. Check if
354 * there is another siginfo for the same signal.
355 */
356 list_for_each_entry(q, &list->list, list) {
357 if (q->info.si_signo == sig) {
Oleg Nesterovd4434202008-07-25 01:47:28 -0700358 if (first)
359 goto still_pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 first = q;
361 }
362 }
Oleg Nesterovd4434202008-07-25 01:47:28 -0700363
364 sigdelset(&list->signal, sig);
365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 if (first) {
Oleg Nesterovd4434202008-07-25 01:47:28 -0700367still_pending:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 list_del_init(&first->list);
369 copy_siginfo(info, &first->info);
370 __sigqueue_free(first);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 /* Ok, it wasn't in the queue. This must be
373 a fast-pathed signal or we must have been
374 out of queue space. So zero out the info.
375 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 info->si_signo = sig;
377 info->si_errno = 0;
378 info->si_code = 0;
379 info->si_pid = 0;
380 info->si_uid = 0;
381 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382}
383
384static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
385 siginfo_t *info)
386{
Roland McGrath27d91e02006-09-29 02:00:31 -0700387 int sig = next_signal(pending, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 if (sig) {
390 if (current->notifier) {
391 if (sigismember(current->notifier_mask, sig)) {
392 if (!(current->notifier)(current->notifier_data)) {
393 clear_thread_flag(TIF_SIGPENDING);
394 return 0;
395 }
396 }
397 }
398
Oleg Nesterov100360f2008-07-25 01:47:29 -0700399 collect_signal(sig, pending, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
402 return sig;
403}
404
405/*
406 * Dequeue a signal and return the element to the caller, which is
407 * expected to free it.
408 *
409 * All callers have to hold the siglock.
410 */
411int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
412{
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700413 int signr;
Benjamin Herrenschmidtcaec4e82007-06-12 08:16:18 +1000414
415 /* We only dequeue private signals from ourselves, we don't let
416 * signalfd steal them
417 */
Davide Libenzib8fceee2007-09-20 12:40:16 -0700418 signr = __dequeue_signal(&tsk->pending, mask, info);
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800419 if (!signr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 signr = __dequeue_signal(&tsk->signal->shared_pending,
421 mask, info);
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800422 /*
423 * itimer signal ?
424 *
425 * itimers are process shared and we restart periodic
426 * itimers in the signal delivery path to prevent DoS
427 * attacks in the high resolution timer case. This is
428 * compliant with the old way of self restarting
429 * itimers, as the SIGALRM is a legacy signal and only
430 * queued once. Changing the restart behaviour to
431 * restart the timer in the signal dequeue path is
432 * reducing the timer noise on heavy loaded !highres
433 * systems too.
434 */
435 if (unlikely(signr == SIGALRM)) {
436 struct hrtimer *tmr = &tsk->signal->real_timer;
437
438 if (!hrtimer_is_queued(tmr) &&
439 tsk->signal->it_real_incr.tv64 != 0) {
440 hrtimer_forward(tmr, tmr->base->get_time(),
441 tsk->signal->it_real_incr);
442 hrtimer_restart(tmr);
443 }
444 }
445 }
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700446
Davide Libenzib8fceee2007-09-20 12:40:16 -0700447 recalc_sigpending();
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700448 if (!signr)
449 return 0;
450
451 if (unlikely(sig_kernel_stop(signr))) {
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800452 /*
453 * Set a marker that we have dequeued a stop signal. Our
454 * caller might release the siglock and then the pending
455 * stop signal it is about to process is no longer in the
456 * pending bitmasks, but must still be cleared by a SIGCONT
457 * (and overruled by a SIGKILL). So those cases clear this
458 * shared flag after we've set it. Note that this flag may
459 * remain set after the signal we return is ignored or
460 * handled. That doesn't matter because its only purpose
461 * is to alert stop-signal processing code when another
462 * processor has come along and cleared the flag.
463 */
Oleg Nesterov92413d72008-07-25 01:47:30 -0700464 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800465 }
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700466 if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 /*
468 * Release the siglock to ensure proper locking order
469 * of timer locks outside of siglocks. Note, we leave
470 * irqs disabled here, since the posix-timers code is
471 * about to disable them again anyway.
472 */
473 spin_unlock(&tsk->sighand->siglock);
474 do_schedule_next_timer(info);
475 spin_lock(&tsk->sighand->siglock);
476 }
477 return signr;
478}
479
480/*
481 * Tell a process that it has a new active signal..
482 *
483 * NOTE! we rely on the previous spin_lock to
484 * lock interrupts for us! We can only be called with
485 * "siglock" held, and the local interrupt must
486 * have been disabled when that got acquired!
487 *
488 * No need to set need_resched since signal event passing
489 * goes through ->blocked
490 */
491void signal_wake_up(struct task_struct *t, int resume)
492{
493 unsigned int mask;
494
495 set_tsk_thread_flag(t, TIF_SIGPENDING);
496
497 /*
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500498 * For SIGKILL, we want to wake it up in the stopped/traced/killable
499 * case. We don't check t->state here because there is a race with it
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 * executing another processor and just now entering stopped state.
501 * By using wake_up_state, we ensure the process will wake up and
502 * handle its death signal.
503 */
504 mask = TASK_INTERRUPTIBLE;
505 if (resume)
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500506 mask |= TASK_WAKEKILL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 if (!wake_up_state(t, mask))
508 kick_process(t);
509}
510
511/*
512 * Remove signals in mask from the pending set and queue.
513 * Returns 1 if any signals were found.
514 *
515 * All callers must be holding the siglock.
George Anzinger71fabd52006-01-08 01:02:48 -0800516 *
517 * This version takes a sigset mask and looks at all signals,
518 * not just those in the first mask word.
519 */
520static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
521{
522 struct sigqueue *q, *n;
523 sigset_t m;
524
525 sigandsets(&m, mask, &s->signal);
526 if (sigisemptyset(&m))
527 return 0;
528
529 signandsets(&s->signal, &s->signal, mask);
530 list_for_each_entry_safe(q, n, &s->list, list) {
531 if (sigismember(mask, q->info.si_signo)) {
532 list_del_init(&q->list);
533 __sigqueue_free(q);
534 }
535 }
536 return 1;
537}
538/*
539 * Remove signals in mask from the pending set and queue.
540 * Returns 1 if any signals were found.
541 *
542 * All callers must be holding the siglock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 */
544static int rm_from_queue(unsigned long mask, struct sigpending *s)
545{
546 struct sigqueue *q, *n;
547
548 if (!sigtestsetmask(&s->signal, mask))
549 return 0;
550
551 sigdelsetmask(&s->signal, mask);
552 list_for_each_entry_safe(q, n, &s->list, list) {
553 if (q->info.si_signo < SIGRTMIN &&
554 (mask & sigmask(q->info.si_signo))) {
555 list_del_init(&q->list);
556 __sigqueue_free(q);
557 }
558 }
559 return 1;
560}
561
562/*
563 * Bad permissions for sending the signal
564 */
565static int check_kill_permission(int sig, struct siginfo *info,
566 struct task_struct *t)
567{
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700568 struct pid *sid;
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700569 int error;
570
Jesper Juhl7ed20e12005-05-01 08:59:14 -0700571 if (!valid_signal(sig))
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700572 return -EINVAL;
573
574 if (info != SEND_SIG_NOINFO && (is_si_special(info) || SI_FROMKERNEL(info)))
575 return 0;
576
577 error = audit_signal_info(sig, t); /* Let audit system see the signal */
578 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 return error;
Amy Griffise54dc242007-03-29 18:01:04 -0400580
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700581 if ((current->euid ^ t->suid) && (current->euid ^ t->uid) &&
582 (current->uid ^ t->suid) && (current->uid ^ t->uid) &&
583 !capable(CAP_KILL)) {
584 switch (sig) {
585 case SIGCONT:
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700586 sid = task_session(t);
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700587 /*
588 * We don't return the error if sid == NULL. The
589 * task was unhashed, the caller must notice this.
590 */
591 if (!sid || sid == task_session(current))
592 break;
593 default:
594 return -EPERM;
595 }
596 }
Steve Grubbc2f0c7c2005-05-06 12:38:39 +0100597
Amy Griffise54dc242007-03-29 18:01:04 -0400598 return security_task_kill(t, info, sig, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599}
600
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601/*
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700602 * Handle magic process-wide effects of stop/continue signals. Unlike
603 * the signal actions, these happen immediately at signal-generation
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 * time regardless of blocking, ignoring, or handling. This does the
605 * actual continuing for SIGCONT, but not the actual stopping for stop
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700606 * signals. The process stop is done as a signal action for SIG_DFL.
607 *
608 * Returns true if the signal should be actually delivered, otherwise
609 * it should be dropped.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 */
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700611static int prepare_signal(int sig, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612{
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700613 struct signal_struct *signal = p->signal;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 struct task_struct *t;
615
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700616 if (unlikely(signal->flags & SIGNAL_GROUP_EXIT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 /*
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700618 * The process is in the middle of dying, nothing to do.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 */
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700620 } else if (sig_kernel_stop(sig)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 /*
622 * This is a stop signal. Remove SIGCONT from all queues.
623 */
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700624 rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 t = p;
626 do {
627 rm_from_queue(sigmask(SIGCONT), &t->pending);
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700628 } while_each_thread(p, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 } else if (sig == SIGCONT) {
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700630 unsigned int why;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 /*
632 * Remove all stop signals from all queues,
633 * and wake all threads.
634 */
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700635 rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 t = p;
637 do {
638 unsigned int state;
639 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 /*
641 * If there is a handler for SIGCONT, we must make
642 * sure that no thread returns to user mode before
643 * we post the signal, in case it was the only
644 * thread eligible to run the signal handler--then
645 * it must not do anything between resuming and
646 * running the handler. With the TIF_SIGPENDING
647 * flag set, the thread will pause and acquire the
648 * siglock that we hold now and until we've queued
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700649 * the pending signal.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 *
651 * Wake up the stopped thread _after_ setting
652 * TIF_SIGPENDING
653 */
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500654 state = __TASK_STOPPED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
656 set_tsk_thread_flag(t, TIF_SIGPENDING);
657 state |= TASK_INTERRUPTIBLE;
658 }
659 wake_up_state(t, state);
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700660 } while_each_thread(p, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700662 /*
663 * Notify the parent with CLD_CONTINUED if we were stopped.
664 *
665 * If we were in the middle of a group stop, we pretend it
666 * was already finished, and then continued. Since SIGCHLD
667 * doesn't queue we report only CLD_STOPPED, as if the next
668 * CLD_CONTINUED was dropped.
669 */
670 why = 0;
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700671 if (signal->flags & SIGNAL_STOP_STOPPED)
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700672 why |= SIGNAL_CLD_CONTINUED;
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700673 else if (signal->group_stop_count)
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700674 why |= SIGNAL_CLD_STOPPED;
675
676 if (why) {
Oleg Nesterov021e1ae2008-04-30 00:53:00 -0700677 /*
678 * The first thread which returns from finish_stop()
679 * will take ->siglock, notice SIGNAL_CLD_MASK, and
680 * notify its parent. See get_signal_to_deliver().
681 */
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700682 signal->flags = why | SIGNAL_STOP_CONTINUED;
683 signal->group_stop_count = 0;
684 signal->group_exit_code = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 } else {
686 /*
687 * We are not stopped, but there could be a stop
688 * signal in the middle of being processed after
689 * being removed from the queue. Clear that too.
690 */
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700691 signal->flags &= ~SIGNAL_STOP_DEQUEUED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 }
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700694
695 return !sig_ignored(p, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696}
697
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700698/*
699 * Test if P wants to take SIG. After we've checked all threads with this,
700 * it's equivalent to finding no threads not blocking SIG. Any threads not
701 * blocking SIG were ruled out because they are not running and already
702 * have pending signals. Such threads will dequeue from the shared queue
703 * as soon as they're available, so putting the signal on the shared queue
704 * will be equivalent to sending it to one such thread.
705 */
706static inline int wants_signal(int sig, struct task_struct *p)
707{
708 if (sigismember(&p->blocked, sig))
709 return 0;
710 if (p->flags & PF_EXITING)
711 return 0;
712 if (sig == SIGKILL)
713 return 1;
714 if (task_is_stopped_or_traced(p))
715 return 0;
716 return task_curr(p) || !signal_pending(p);
717}
718
Oleg Nesterov5fcd8352008-04-30 00:52:55 -0700719static void complete_signal(int sig, struct task_struct *p, int group)
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700720{
721 struct signal_struct *signal = p->signal;
722 struct task_struct *t;
723
724 /*
725 * Now find a thread we can wake up to take the signal off the queue.
726 *
727 * If the main thread wants the signal, it gets first crack.
728 * Probably the least surprising to the average bear.
729 */
730 if (wants_signal(sig, p))
731 t = p;
Oleg Nesterov5fcd8352008-04-30 00:52:55 -0700732 else if (!group || thread_group_empty(p))
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700733 /*
734 * There is just one thread and it does not need to be woken.
735 * It will dequeue unblocked signals before it runs again.
736 */
737 return;
738 else {
739 /*
740 * Otherwise try to find a suitable thread.
741 */
742 t = signal->curr_target;
743 while (!wants_signal(sig, t)) {
744 t = next_thread(t);
745 if (t == signal->curr_target)
746 /*
747 * No thread needs to be woken.
748 * Any eligible threads will see
749 * the signal in the queue soon.
750 */
751 return;
752 }
753 signal->curr_target = t;
754 }
755
756 /*
757 * Found a killable thread. If the signal will be fatal,
758 * then start taking the whole group down immediately.
759 */
Oleg Nesterovfae5fa42008-04-30 00:53:03 -0700760 if (sig_fatal(p, sig) &&
761 !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700762 !sigismember(&t->real_blocked, sig) &&
Roland McGrath445a91d2008-07-25 19:45:52 -0700763 (sig == SIGKILL ||
764 !tracehook_consider_fatal_signal(t, sig, SIG_DFL))) {
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700765 /*
766 * This signal will be fatal to the whole group.
767 */
768 if (!sig_kernel_coredump(sig)) {
769 /*
770 * Start a group exit and wake everybody up.
771 * This way we don't have other threads
772 * running and doing things after a slower
773 * thread has the fatal signal pending.
774 */
775 signal->flags = SIGNAL_GROUP_EXIT;
776 signal->group_exit_code = sig;
777 signal->group_stop_count = 0;
778 t = p;
779 do {
780 sigaddset(&t->pending.signal, SIGKILL);
781 signal_wake_up(t, 1);
782 } while_each_thread(p, t);
783 return;
784 }
785 }
786
787 /*
788 * The signal is already in the shared-pending queue.
789 * Tell the chosen thread to wake up and dequeue it.
790 */
791 signal_wake_up(t, sig == SIGKILL);
792 return;
793}
794
Pavel Emelyanovaf7fff92008-04-30 00:52:34 -0700795static inline int legacy_queue(struct sigpending *signals, int sig)
796{
797 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
798}
799
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700801 int group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802{
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700803 struct sigpending *pending;
Oleg Nesterov6e65acb2008-04-30 00:52:50 -0700804 struct sigqueue *q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805
Oleg Nesterov6e65acb2008-04-30 00:52:50 -0700806 assert_spin_locked(&t->sighand->siglock);
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700807 if (!prepare_signal(sig, t))
808 return 0;
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700809
810 pending = group ? &t->signal->shared_pending : &t->pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 /*
Pavel Emelyanov2acb0242008-04-30 00:52:35 -0700812 * Short-circuit ignored signals and support queuing
813 * exactly one non-rt signal, so that we can get more
814 * detailed information about the cause of the signal.
815 */
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700816 if (legacy_queue(pending, sig))
Pavel Emelyanov2acb0242008-04-30 00:52:35 -0700817 return 0;
Davide Libenzifba2afa2007-05-10 22:23:13 -0700818 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 * fast-pathed signals for kernel-internal things like SIGSTOP
820 * or SIGKILL.
821 */
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800822 if (info == SEND_SIG_FORCED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 goto out_set;
824
825 /* Real-time signals must be queued if sent by sigqueue, or
826 some other real-time mechanism. It is implementation
827 defined whether kill() does so. We attempt to do so, on
828 the principle of least surprise, but since kill is not
829 allowed to fail with EAGAIN when low on memory we just
830 make sure at least one signal gets delivered and don't
831 pass on the info struct. */
832
833 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
Oleg Nesterov621d3122005-10-30 15:03:45 -0800834 (is_si_special(info) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 info->si_code >= 0)));
836 if (q) {
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700837 list_add_tail(&q->list, &pending->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 switch ((unsigned long) info) {
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800839 case (unsigned long) SEND_SIG_NOINFO:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 q->info.si_signo = sig;
841 q->info.si_errno = 0;
842 q->info.si_code = SI_USER;
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700843 q->info.si_pid = task_pid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 q->info.si_uid = current->uid;
845 break;
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800846 case (unsigned long) SEND_SIG_PRIV:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 q->info.si_signo = sig;
848 q->info.si_errno = 0;
849 q->info.si_code = SI_KERNEL;
850 q->info.si_pid = 0;
851 q->info.si_uid = 0;
852 break;
853 default:
854 copy_siginfo(&q->info, info);
855 break;
856 }
Oleg Nesterov621d3122005-10-30 15:03:45 -0800857 } else if (!is_si_special(info)) {
858 if (sig >= SIGRTMIN && info->si_code != SI_USER)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 /*
860 * Queue overflow, abort. We may abort if the signal was rt
861 * and sent by user using something other than kill().
862 */
863 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 }
865
866out_set:
Oleg Nesterov53c30332008-04-30 00:53:00 -0700867 signalfd_notify(t, sig);
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700868 sigaddset(&pending->signal, sig);
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -0700869 complete_signal(sig, t, group);
870 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871}
872
Ingo Molnar45807a12007-07-15 23:40:10 -0700873int print_fatal_signals;
874
875static void print_fatal_signal(struct pt_regs *regs, int signr)
876{
877 printk("%s/%d: potentially unexpected fatal signal %d.\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -0700878 current->comm, task_pid_nr(current), signr);
Ingo Molnar45807a12007-07-15 23:40:10 -0700879
Al Viroca5cd872007-10-29 04:31:16 +0000880#if defined(__i386__) && !defined(__arch_um__)
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100881 printk("code at %08lx: ", regs->ip);
Ingo Molnar45807a12007-07-15 23:40:10 -0700882 {
883 int i;
884 for (i = 0; i < 16; i++) {
885 unsigned char insn;
886
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100887 __get_user(insn, (unsigned char *)(regs->ip + i));
Ingo Molnar45807a12007-07-15 23:40:10 -0700888 printk("%02x ", insn);
889 }
890 }
891#endif
892 printk("\n");
893 show_regs(regs);
894}
895
896static int __init setup_print_fatal_signals(char *str)
897{
898 get_option (&str, &print_fatal_signals);
899
900 return 1;
901}
902
903__setup("print-fatal-signals=", setup_print_fatal_signals);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -0700905int
906__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
907{
908 return send_signal(sig, info, p, 1);
909}
910
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911static int
912specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
913{
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -0700914 return send_signal(sig, info, t, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915}
916
917/*
918 * Force a signal that the process can't ignore: if necessary
919 * we unblock the signal and change any SIG_IGN to SIG_DFL.
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700920 *
921 * Note: If we unblock the signal, we always reset it to SIG_DFL,
922 * since we do not want to have a signal handler that was blocked
923 * be invoked when user space had explicitly blocked it.
924 *
Oleg Nesterov80fe7282008-04-30 00:53:05 -0700925 * We don't want to have recursive SIGSEGV's etc, for example,
926 * that is why we also clear SIGNAL_UNKILLABLE.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928int
929force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
930{
931 unsigned long int flags;
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700932 int ret, blocked, ignored;
933 struct k_sigaction *action;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
935 spin_lock_irqsave(&t->sighand->siglock, flags);
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700936 action = &t->sighand->action[sig-1];
937 ignored = action->sa.sa_handler == SIG_IGN;
938 blocked = sigismember(&t->blocked, sig);
939 if (blocked || ignored) {
940 action->sa.sa_handler = SIG_DFL;
941 if (blocked) {
942 sigdelset(&t->blocked, sig);
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700943 recalc_sigpending_and_wake(t);
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700944 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 }
Oleg Nesterov80fe7282008-04-30 00:53:05 -0700946 if (action->sa.sa_handler == SIG_DFL)
947 t->signal->flags &= ~SIGNAL_UNKILLABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 ret = specific_send_sig_info(sig, info, t);
949 spin_unlock_irqrestore(&t->sighand->siglock, flags);
950
951 return ret;
952}
953
954void
955force_sig_specific(int sig, struct task_struct *t)
956{
Paul E. McKenneyb0423a02005-10-30 15:03:46 -0800957 force_sig_info(sig, SEND_SIG_FORCED, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958}
959
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960/*
961 * Nuke all other threads in the group.
962 */
963void zap_other_threads(struct task_struct *p)
964{
965 struct task_struct *t;
966
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 p->signal->group_stop_count = 0;
968
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 for (t = next_thread(p); t != p; t = next_thread(t)) {
970 /*
971 * Don't bother with already dead threads
972 */
973 if (t->exit_state)
974 continue;
975
Andrea Arcangeli30e0fca62005-10-30 15:02:38 -0800976 /* SIGKILL will be handled before any pending SIGSTOP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 sigaddset(&t->pending.signal, SIGKILL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 signal_wake_up(t, 1);
979 }
980}
981
Harvey Harrisonb5606c22008-02-13 15:03:16 -0800982int __fatal_signal_pending(struct task_struct *tsk)
Matthew Wilcoxf776d122007-12-06 11:15:50 -0500983{
984 return sigismember(&tsk->pending.signal, SIGKILL);
985}
Trond Myklebust13f09b92008-01-31 20:40:29 -0500986EXPORT_SYMBOL(__fatal_signal_pending);
Matthew Wilcoxf776d122007-12-06 11:15:50 -0500987
Oleg Nesterovf63ee722006-03-28 16:11:13 -0800988struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
989{
990 struct sighand_struct *sighand;
991
Oleg Nesterov1406f2d2008-04-30 00:52:37 -0700992 rcu_read_lock();
Oleg Nesterovf63ee722006-03-28 16:11:13 -0800993 for (;;) {
994 sighand = rcu_dereference(tsk->sighand);
995 if (unlikely(sighand == NULL))
996 break;
997
998 spin_lock_irqsave(&sighand->siglock, *flags);
999 if (likely(sighand == tsk->sighand))
1000 break;
1001 spin_unlock_irqrestore(&sighand->siglock, *flags);
1002 }
Oleg Nesterov1406f2d2008-04-30 00:52:37 -07001003 rcu_read_unlock();
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001004
1005 return sighand;
1006}
1007
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1009{
1010 unsigned long flags;
1011 int ret;
1012
1013 ret = check_kill_permission(sig, info, p);
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001014
1015 if (!ret && sig) {
1016 ret = -ESRCH;
1017 if (lock_task_sighand(p, &flags)) {
1018 ret = __group_send_sig_info(sig, info, p);
1019 unlock_task_sighand(p, &flags);
Ingo Molnare56d0902006-01-08 01:01:37 -08001020 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 }
1022
1023 return ret;
1024}
1025
1026/*
Pavel Emelyanov146a5052008-02-08 04:19:22 -08001027 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 * control characters do (^C, ^Z etc)
1029 */
1030
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001031int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032{
1033 struct task_struct *p = NULL;
1034 int retval, success;
1035
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 success = 0;
1037 retval = -ESRCH;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001038 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 int err = group_send_sig_info(sig, info, p);
1040 success |= !err;
1041 retval = err;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001042 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 return success ? 0 : retval;
1044}
1045
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001046int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047{
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001048 int error = -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 struct task_struct *p;
1050
Ingo Molnare56d0902006-01-08 01:01:37 -08001051 rcu_read_lock();
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001052retry:
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001053 p = pid_task(pid, PIDTYPE_PID);
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001054 if (p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 error = group_send_sig_info(sig, info, p);
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001056 if (unlikely(error == -ESRCH))
1057 /*
1058 * The task was unhashed in between, try again.
1059 * If it is dead, pid_task() will return NULL,
1060 * if we race with de_thread() it will find the
1061 * new leader.
1062 */
1063 goto retry;
1064 }
Ingo Molnare56d0902006-01-08 01:01:37 -08001065 rcu_read_unlock();
Oleg Nesterov6ca25b52008-04-30 00:52:45 -07001066
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 return error;
1068}
1069
Matthew Wilcoxc3de4b32007-02-09 08:11:47 -07001070int
1071kill_proc_info(int sig, struct siginfo *info, pid_t pid)
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001072{
1073 int error;
1074 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001075 error = kill_pid_info(sig, info, find_vpid(pid));
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001076 rcu_read_unlock();
1077 return error;
1078}
1079
Eric W. Biederman2425c082006-10-02 02:17:28 -07001080/* like kill_pid_info(), but doesn't use uid/euid of "current" */
1081int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
David Quigley8f95dc52006-06-30 01:55:47 -07001082 uid_t uid, uid_t euid, u32 secid)
Harald Welte46113832005-10-10 19:44:29 +02001083{
1084 int ret = -EINVAL;
1085 struct task_struct *p;
1086
1087 if (!valid_signal(sig))
1088 return ret;
1089
1090 read_lock(&tasklist_lock);
Eric W. Biederman2425c082006-10-02 02:17:28 -07001091 p = pid_task(pid, PIDTYPE_PID);
Harald Welte46113832005-10-10 19:44:29 +02001092 if (!p) {
1093 ret = -ESRCH;
1094 goto out_unlock;
1095 }
Oleg Nesterov0811af22006-01-08 01:03:09 -08001096 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
Harald Welte46113832005-10-10 19:44:29 +02001097 && (euid != p->suid) && (euid != p->uid)
1098 && (uid != p->suid) && (uid != p->uid)) {
1099 ret = -EPERM;
1100 goto out_unlock;
1101 }
David Quigley8f95dc52006-06-30 01:55:47 -07001102 ret = security_task_kill(p, info, sig, secid);
1103 if (ret)
1104 goto out_unlock;
Harald Welte46113832005-10-10 19:44:29 +02001105 if (sig && p->sighand) {
1106 unsigned long flags;
1107 spin_lock_irqsave(&p->sighand->siglock, flags);
1108 ret = __group_send_sig_info(sig, info, p);
1109 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1110 }
1111out_unlock:
1112 read_unlock(&tasklist_lock);
1113 return ret;
1114}
Eric W. Biederman2425c082006-10-02 02:17:28 -07001115EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116
1117/*
1118 * kill_something_info() interprets pid in interesting ways just like kill(2).
1119 *
1120 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1121 * is probably wrong. Should make it like BSD or SYSV.
1122 */
1123
Gustavo Fernando Padovanbc64efd2008-07-25 01:47:33 -07001124static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125{
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001126 int ret;
Pavel Emelyanovd5df7632008-02-08 04:19:22 -08001127
1128 if (pid > 0) {
1129 rcu_read_lock();
1130 ret = kill_pid_info(sig, info, find_vpid(pid));
1131 rcu_read_unlock();
1132 return ret;
1133 }
1134
1135 read_lock(&tasklist_lock);
1136 if (pid != -1) {
1137 ret = __kill_pgrp_info(sig, info,
1138 pid ? find_vpid(-pid) : task_pgrp(current));
1139 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 int retval = 0, count = 0;
1141 struct task_struct * p;
1142
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 for_each_process(p) {
Pavel Emelyanovbac0abd2007-10-18 23:40:18 -07001144 if (p->pid > 1 && !same_thread_group(p, current)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 int err = group_send_sig_info(sig, info, p);
1146 ++count;
1147 if (err != -EPERM)
1148 retval = err;
1149 }
1150 }
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001151 ret = count ? retval : -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 }
Pavel Emelyanovd5df7632008-02-08 04:19:22 -08001153 read_unlock(&tasklist_lock);
1154
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001155 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156}
1157
1158/*
1159 * These are for backward compatibility with the rest of the kernel source.
1160 */
1161
1162/*
Oleg Nesterov08d2c302008-04-30 00:52:51 -07001163 * The caller must ensure the task can't exit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 */
1165int
1166send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1167{
1168 int ret;
1169 unsigned long flags;
1170
1171 /*
1172 * Make sure legacy kernel users don't send in bad values
1173 * (normal paths check this in check_kill_permission).
1174 */
Jesper Juhl7ed20e12005-05-01 08:59:14 -07001175 if (!valid_signal(sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 return -EINVAL;
1177
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 spin_lock_irqsave(&p->sighand->siglock, flags);
1179 ret = specific_send_sig_info(sig, info, p);
1180 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 return ret;
1182}
1183
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001184#define __si_special(priv) \
1185 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1186
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187int
1188send_sig(int sig, struct task_struct *p, int priv)
1189{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001190 return send_sig_info(sig, __si_special(priv), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191}
1192
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193void
1194force_sig(int sig, struct task_struct *p)
1195{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001196 force_sig_info(sig, SEND_SIG_PRIV, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197}
1198
1199/*
1200 * When things go south during signal handling, we
1201 * will force a SIGSEGV. And if the signal that caused
1202 * the problem was already a SIGSEGV, we'll want to
1203 * make sure we don't even try to deliver the signal..
1204 */
1205int
1206force_sigsegv(int sig, struct task_struct *p)
1207{
1208 if (sig == SIGSEGV) {
1209 unsigned long flags;
1210 spin_lock_irqsave(&p->sighand->siglock, flags);
1211 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1212 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1213 }
1214 force_sig(SIGSEGV, p);
1215 return 0;
1216}
1217
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001218int kill_pgrp(struct pid *pid, int sig, int priv)
1219{
Pavel Emelyanov146a5052008-02-08 04:19:22 -08001220 int ret;
1221
1222 read_lock(&tasklist_lock);
1223 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1224 read_unlock(&tasklist_lock);
1225
1226 return ret;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001227}
1228EXPORT_SYMBOL(kill_pgrp);
1229
1230int kill_pid(struct pid *pid, int sig, int priv)
1231{
1232 return kill_pid_info(sig, __si_special(priv), pid);
1233}
1234EXPORT_SYMBOL(kill_pid);
1235
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236/*
1237 * These functions support sending signals using preallocated sigqueue
1238 * structures. This is needed "because realtime applications cannot
1239 * afford to lose notifications of asynchronous events, like timer
1240 * expirations or I/O completions". In the case of Posix Timers
1241 * we allocate the sigqueue structure from the timer_create. If this
1242 * allocation fails we are able to report the failure to the application
1243 * with an EAGAIN error.
1244 */
1245
1246struct sigqueue *sigqueue_alloc(void)
1247{
1248 struct sigqueue *q;
1249
1250 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1251 q->flags |= SIGQUEUE_PREALLOC;
1252 return(q);
1253}
1254
1255void sigqueue_free(struct sigqueue *q)
1256{
1257 unsigned long flags;
Oleg Nesterov60187d22007-08-30 23:56:35 -07001258 spinlock_t *lock = &current->sighand->siglock;
1259
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1261 /*
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001262 * We must hold ->siglock while testing q->list
1263 * to serialize with collect_signal() or with
Oleg Nesterovda7978b2008-05-23 13:04:41 -07001264 * __exit_signal()->flush_sigqueue().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 */
Oleg Nesterov60187d22007-08-30 23:56:35 -07001266 spin_lock_irqsave(lock, flags);
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001267 q->flags &= ~SIGQUEUE_PREALLOC;
1268 /*
1269 * If it is queued it will be freed when dequeued,
1270 * like the "regular" sigqueue.
1271 */
Oleg Nesterov60187d22007-08-30 23:56:35 -07001272 if (!list_empty(&q->list))
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001273 q = NULL;
Oleg Nesterov60187d22007-08-30 23:56:35 -07001274 spin_unlock_irqrestore(lock, flags);
1275
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001276 if (q)
1277 __sigqueue_free(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278}
1279
Oleg Nesterovac5c2152008-04-30 00:52:57 -07001280int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001281{
Oleg Nesterove62e6652008-04-30 00:52:56 -07001282 int sig = q->info.si_signo;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001283 struct sigpending *pending;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001284 unsigned long flags;
1285 int ret;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001286
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001287 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
Oleg Nesterove62e6652008-04-30 00:52:56 -07001288
1289 ret = -1;
1290 if (!likely(lock_task_sighand(t, &flags)))
1291 goto ret;
1292
Oleg Nesterov7e695a52008-04-30 00:52:59 -07001293 ret = 1; /* the signal is ignored */
1294 if (!prepare_signal(sig, t))
Oleg Nesterove62e6652008-04-30 00:52:56 -07001295 goto out;
1296
1297 ret = 0;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001298 if (unlikely(!list_empty(&q->list))) {
1299 /*
1300 * If an SI_TIMER entry is already queue just increment
1301 * the overrun count.
1302 */
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001303 BUG_ON(q->info.si_code != SI_TIMER);
1304 q->info.si_overrun++;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001305 goto out;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001306 }
1307
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001308 signalfd_notify(t, sig);
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001309 pending = group ? &t->signal->shared_pending : &t->pending;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001310 list_add_tail(&q->list, &pending->list);
1311 sigaddset(&pending->signal, sig);
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001312 complete_signal(sig, t, group);
Oleg Nesterove62e6652008-04-30 00:52:56 -07001313out:
1314 unlock_task_sighand(t, &flags);
1315ret:
1316 return ret;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001317}
1318
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319/*
1320 * Wake up any threads in the parent blocked in wait* syscalls.
1321 */
1322static inline void __wake_up_parent(struct task_struct *p,
1323 struct task_struct *parent)
1324{
1325 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1326}
1327
1328/*
1329 * Let a parent know about the death of a child.
1330 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
Roland McGrath2b2a1ff2008-07-25 19:45:54 -07001331 *
1332 * Returns -1 if our parent ignored us and so we've switched to
1333 * self-reaping, or else @sig.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 */
Roland McGrath2b2a1ff2008-07-25 19:45:54 -07001335int do_notify_parent(struct task_struct *tsk, int sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336{
1337 struct siginfo info;
1338 unsigned long flags;
1339 struct sighand_struct *psig;
1340
1341 BUG_ON(sig == -1);
1342
1343 /* do_notify_parent_cldstop should have been called instead. */
Matthew Wilcoxe1abb392007-12-06 11:07:35 -05001344 BUG_ON(task_is_stopped_or_traced(tsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345
1346 BUG_ON(!tsk->ptrace &&
1347 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1348
1349 info.si_signo = sig;
1350 info.si_errno = 0;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001351 /*
1352 * we are under tasklist_lock here so our parent is tied to
1353 * us and cannot exit and release its namespace.
1354 *
1355 * the only it can is to switch its nsproxy with sys_unshare,
1356 * bu uncharing pid namespaces is not allowed, so we'll always
1357 * see relevant namespace
1358 *
1359 * write_lock() currently calls preempt_disable() which is the
1360 * same as rcu_read_lock(), but according to Oleg, this is not
1361 * correct to rely on this
1362 */
1363 rcu_read_lock();
1364 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1365 rcu_read_unlock();
1366
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 info.si_uid = tsk->uid;
1368
Michael Kerriskd8878ba2008-07-25 01:47:32 -07001369 info.si_utime = cputime_to_clock_t(cputime_add(tsk->utime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 tsk->signal->utime));
Michael Kerriskd8878ba2008-07-25 01:47:32 -07001371 info.si_stime = cputime_to_clock_t(cputime_add(tsk->stime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 tsk->signal->stime));
1373
1374 info.si_status = tsk->exit_code & 0x7f;
1375 if (tsk->exit_code & 0x80)
1376 info.si_code = CLD_DUMPED;
1377 else if (tsk->exit_code & 0x7f)
1378 info.si_code = CLD_KILLED;
1379 else {
1380 info.si_code = CLD_EXITED;
1381 info.si_status = tsk->exit_code >> 8;
1382 }
1383
1384 psig = tsk->parent->sighand;
1385 spin_lock_irqsave(&psig->siglock, flags);
Oleg Nesterov7ed01752005-11-10 17:22:18 +03001386 if (!tsk->ptrace && sig == SIGCHLD &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1388 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1389 /*
1390 * We are exiting and our parent doesn't care. POSIX.1
1391 * defines special semantics for setting SIGCHLD to SIG_IGN
1392 * or setting the SA_NOCLDWAIT flag: we should be reaped
1393 * automatically and not left for our parent's wait4 call.
1394 * Rather than having the parent do it as a magic kind of
1395 * signal handler, we just set this to tell do_exit that we
1396 * can be cleaned up without becoming a zombie. Note that
1397 * we still call __wake_up_parent in this case, because a
1398 * blocked sys_wait4 might now return -ECHILD.
1399 *
1400 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1401 * is implementation-defined: we do (if you don't want
1402 * it, just use SIG_IGN instead).
1403 */
1404 tsk->exit_signal = -1;
1405 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
Roland McGrath2b2a1ff2008-07-25 19:45:54 -07001406 sig = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 }
Jesper Juhl7ed20e12005-05-01 08:59:14 -07001408 if (valid_signal(sig) && sig > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 __group_send_sig_info(sig, &info, tsk->parent);
1410 __wake_up_parent(tsk, tsk->parent);
1411 spin_unlock_irqrestore(&psig->siglock, flags);
Roland McGrath2b2a1ff2008-07-25 19:45:54 -07001412
1413 return sig;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414}
1415
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001416static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417{
1418 struct siginfo info;
1419 unsigned long flags;
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001420 struct task_struct *parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 struct sighand_struct *sighand;
1422
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001423 if (tsk->ptrace & PT_PTRACED)
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001424 parent = tsk->parent;
1425 else {
1426 tsk = tsk->group_leader;
1427 parent = tsk->real_parent;
1428 }
1429
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 info.si_signo = SIGCHLD;
1431 info.si_errno = 0;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001432 /*
1433 * see comment in do_notify_parent() abot the following 3 lines
1434 */
1435 rcu_read_lock();
1436 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1437 rcu_read_unlock();
1438
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 info.si_uid = tsk->uid;
1440
Michael Kerriskd8878ba2008-07-25 01:47:32 -07001441 info.si_utime = cputime_to_clock_t(tsk->utime);
1442 info.si_stime = cputime_to_clock_t(tsk->stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443
1444 info.si_code = why;
1445 switch (why) {
1446 case CLD_CONTINUED:
1447 info.si_status = SIGCONT;
1448 break;
1449 case CLD_STOPPED:
1450 info.si_status = tsk->signal->group_exit_code & 0x7f;
1451 break;
1452 case CLD_TRAPPED:
1453 info.si_status = tsk->exit_code & 0x7f;
1454 break;
1455 default:
1456 BUG();
1457 }
1458
1459 sighand = parent->sighand;
1460 spin_lock_irqsave(&sighand->siglock, flags);
1461 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1462 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1463 __group_send_sig_info(SIGCHLD, &info, parent);
1464 /*
1465 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1466 */
1467 __wake_up_parent(tsk, parent);
1468 spin_unlock_irqrestore(&sighand->siglock, flags);
1469}
1470
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001471static inline int may_ptrace_stop(void)
1472{
1473 if (!likely(current->ptrace & PT_PTRACED))
1474 return 0;
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001475 /*
1476 * Are we in the middle of do_coredump?
1477 * If so and our tracer is also part of the coredump stopping
1478 * is a deadlock situation, and pointless because our tracer
1479 * is dead so don't allow us to stop.
1480 * If SIGKILL was already sent before the caller unlocked
Oleg Nesterov999d9fc2008-07-25 01:47:41 -07001481 * ->siglock we must see ->core_state != NULL. Otherwise it
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001482 * is safe to enter schedule().
1483 */
Oleg Nesterov999d9fc2008-07-25 01:47:41 -07001484 if (unlikely(current->mm->core_state) &&
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001485 unlikely(current->mm == current->parent->mm))
1486 return 0;
1487
1488 return 1;
1489}
1490
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491/*
Roland McGrath1a669c22008-02-06 01:37:37 -08001492 * Return nonzero if there is a SIGKILL that should be waking us up.
1493 * Called with the siglock held.
1494 */
1495static int sigkill_pending(struct task_struct *tsk)
1496{
Oleg Nesterov3d749b92008-07-25 01:47:37 -07001497 return sigismember(&tsk->pending.signal, SIGKILL) ||
1498 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
Roland McGrath1a669c22008-02-06 01:37:37 -08001499}
1500
1501/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 * This must be called with current->sighand->siglock held.
1503 *
1504 * This should be the path for all ptrace stops.
1505 * We always set current->last_siginfo while stopped here.
1506 * That makes it a way to test a stopped process for
1507 * being ptrace-stopped vs being job-control-stopped.
1508 *
Oleg Nesterov20686a32008-02-08 04:19:03 -08001509 * If we actually decide not to stop at all because the tracer
1510 * is gone, we keep current->exit_code unless clear_code.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 */
Oleg Nesterov20686a32008-02-08 04:19:03 -08001512static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513{
Roland McGrath1a669c22008-02-06 01:37:37 -08001514 if (arch_ptrace_stop_needed(exit_code, info)) {
1515 /*
1516 * The arch code has something special to do before a
1517 * ptrace stop. This is allowed to block, e.g. for faults
1518 * on user stack pages. We can't keep the siglock while
1519 * calling arch_ptrace_stop, so we must release it now.
1520 * To preserve proper semantics, we must do this before
1521 * any signal bookkeeping like checking group_stop_count.
1522 * Meanwhile, a SIGKILL could come in before we retake the
1523 * siglock. That must prevent us from sleeping in TASK_TRACED.
1524 * So after regaining the lock, we must check for SIGKILL.
1525 */
1526 spin_unlock_irq(&current->sighand->siglock);
1527 arch_ptrace_stop(exit_code, info);
1528 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterov3d749b92008-07-25 01:47:37 -07001529 if (sigkill_pending(current))
1530 return;
Roland McGrath1a669c22008-02-06 01:37:37 -08001531 }
1532
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 /*
1534 * If there is a group stop in progress,
1535 * we must participate in the bookkeeping.
1536 */
1537 if (current->signal->group_stop_count > 0)
1538 --current->signal->group_stop_count;
1539
1540 current->last_siginfo = info;
1541 current->exit_code = exit_code;
1542
1543 /* Let the debugger run. */
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -08001544 __set_current_state(TASK_TRACED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 spin_unlock_irq(&current->sighand->siglock);
1546 read_lock(&tasklist_lock);
Oleg Nesterov3d749b92008-07-25 01:47:37 -07001547 if (may_ptrace_stop()) {
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001548 do_notify_parent_cldstop(current, CLD_TRAPPED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 read_unlock(&tasklist_lock);
1550 schedule();
1551 } else {
1552 /*
1553 * By the time we got the lock, our tracer went away.
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001554 * Don't drop the lock yet, another tracer may come.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 */
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001556 __set_current_state(TASK_RUNNING);
Oleg Nesterov20686a32008-02-08 04:19:03 -08001557 if (clear_code)
1558 current->exit_code = 0;
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001559 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 }
1561
1562 /*
Roland McGrath13b1c3d2008-03-03 20:22:05 -08001563 * While in TASK_TRACED, we were considered "frozen enough".
1564 * Now that we woke up, it's crucial if we're supposed to be
1565 * frozen that we freeze now before running anything substantial.
1566 */
1567 try_to_freeze();
1568
1569 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 * We are back. Now reacquire the siglock before touching
1571 * last_siginfo, so that we are sure to have synchronized with
1572 * any signal-sending on another CPU that wants to examine it.
1573 */
1574 spin_lock_irq(&current->sighand->siglock);
1575 current->last_siginfo = NULL;
1576
1577 /*
1578 * Queued signals ignored us while we were stopped for tracing.
1579 * So check for any that we should take before resuming user mode.
Roland McGrathb74d0de2007-06-06 03:59:00 -07001580 * This sets TIF_SIGPENDING, but never clears it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 */
Roland McGrathb74d0de2007-06-06 03:59:00 -07001582 recalc_sigpending_tsk(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583}
1584
1585void ptrace_notify(int exit_code)
1586{
1587 siginfo_t info;
1588
1589 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1590
1591 memset(&info, 0, sizeof info);
1592 info.si_signo = SIGTRAP;
1593 info.si_code = exit_code;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001594 info.si_pid = task_pid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 info.si_uid = current->uid;
1596
1597 /* Let the debugger run. */
1598 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterov20686a32008-02-08 04:19:03 -08001599 ptrace_stop(exit_code, 1, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 spin_unlock_irq(&current->sighand->siglock);
1601}
1602
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603static void
1604finish_stop(int stop_count)
1605{
1606 /*
1607 * If there are no other threads in the group, or if there is
1608 * a group stop in progress and we are the last to stop,
1609 * report to the parent. When ptraced, every thread reports itself.
1610 */
Roland McGrathfa00b802008-07-25 19:45:54 -07001611 if (tracehook_notify_jctl(stop_count == 0, CLD_STOPPED)) {
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001612 read_lock(&tasklist_lock);
1613 do_notify_parent_cldstop(current, CLD_STOPPED);
1614 read_unlock(&tasklist_lock);
1615 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616
Rafael J. Wysocki3df494a2006-12-13 00:34:28 -08001617 do {
1618 schedule();
1619 } while (try_to_freeze());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 /*
1621 * Now we don't run again until continued.
1622 */
1623 current->exit_code = 0;
1624}
1625
1626/*
1627 * This performs the stopping for SIGSTOP and other stop signals.
1628 * We have to stop all threads in the thread group.
1629 * Returns nonzero if we've actually stopped and released the siglock.
1630 * Returns zero if we didn't stop and still hold the siglock.
1631 */
Oleg Nesterova122b342006-03-28 16:11:22 -08001632static int do_signal_stop(int signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633{
1634 struct signal_struct *sig = current->signal;
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001635 int stop_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 if (sig->group_stop_count > 0) {
1638 /*
1639 * There is a group stop in progress. We don't need to
1640 * start another one.
1641 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 stop_count = --sig->group_stop_count;
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001643 } else {
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08001644 struct task_struct *t;
1645
Oleg Nesterov2b201a92008-07-25 01:47:31 -07001646 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED) ||
Oleg Nesterov573cf9a2008-04-30 00:52:36 -07001647 unlikely(signal_group_exit(sig)))
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08001648 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 * There is no group stop already in progress.
Oleg Nesterova122b342006-03-28 16:11:22 -08001651 * We must initiate one now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 */
Oleg Nesterova122b342006-03-28 16:11:22 -08001653 sig->group_exit_code = signr;
1654
1655 stop_count = 0;
1656 for (t = next_thread(current); t != current; t = next_thread(t))
1657 /*
1658 * Setting state to TASK_STOPPED for a group
1659 * stop is always done with the siglock held,
1660 * so this check has no races.
1661 */
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001662 if (!(t->flags & PF_EXITING) &&
Matthew Wilcoxe1abb392007-12-06 11:07:35 -05001663 !task_is_stopped_or_traced(t)) {
Oleg Nesterova122b342006-03-28 16:11:22 -08001664 stop_count++;
1665 signal_wake_up(t, 0);
1666 }
1667 sig->group_stop_count = stop_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 }
1669
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001670 if (stop_count == 0)
1671 sig->flags = SIGNAL_STOP_STOPPED;
1672 current->exit_code = sig->group_exit_code;
1673 __set_current_state(TASK_STOPPED);
1674
1675 spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 finish_stop(stop_count);
1677 return 1;
1678}
1679
Roland McGrath18c98b62008-04-17 18:44:38 -07001680static int ptrace_signal(int signr, siginfo_t *info,
1681 struct pt_regs *regs, void *cookie)
1682{
1683 if (!(current->ptrace & PT_PTRACED))
1684 return signr;
1685
1686 ptrace_signal_deliver(regs, cookie);
1687
1688 /* Let the debugger run. */
1689 ptrace_stop(signr, 0, info);
1690
1691 /* We're back. Did the debugger cancel the sig? */
1692 signr = current->exit_code;
1693 if (signr == 0)
1694 return signr;
1695
1696 current->exit_code = 0;
1697
1698 /* Update the siginfo structure if the signal has
1699 changed. If the debugger wanted something
1700 specific in the siginfo structure then it should
1701 have updated *info via PTRACE_SETSIGINFO. */
1702 if (signr != info->si_signo) {
1703 info->si_signo = signr;
1704 info->si_errno = 0;
1705 info->si_code = SI_USER;
1706 info->si_pid = task_pid_vnr(current->parent);
1707 info->si_uid = current->parent->uid;
1708 }
1709
1710 /* If the (new) signal is now blocked, requeue it. */
1711 if (sigismember(&current->blocked, signr)) {
1712 specific_send_sig_info(signr, info, current);
1713 signr = 0;
1714 }
1715
1716 return signr;
1717}
1718
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1720 struct pt_regs *regs, void *cookie)
1721{
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001722 struct sighand_struct *sighand = current->sighand;
1723 struct signal_struct *signal = current->signal;
1724 int signr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
Roland McGrath13b1c3d2008-03-03 20:22:05 -08001726relock:
1727 /*
1728 * We'll jump back here after any time we were stopped in TASK_STOPPED.
1729 * While in TASK_STOPPED, we were considered "frozen enough".
1730 * Now that we woke up, it's crucial if we're supposed to be
1731 * frozen that we freeze now before running anything substantial.
1732 */
Rafael J. Wysockifc558a72006-03-23 03:00:05 -08001733 try_to_freeze();
1734
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001735 spin_lock_irq(&sighand->siglock);
Oleg Nesterov021e1ae2008-04-30 00:53:00 -07001736 /*
1737 * Every stopped thread goes here after wakeup. Check to see if
1738 * we should notify the parent, prepare_signal(SIGCONT) encodes
1739 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
1740 */
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001741 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
1742 int why = (signal->flags & SIGNAL_STOP_CONTINUED)
Oleg Nesterove4420552008-04-30 00:52:44 -07001743 ? CLD_CONTINUED : CLD_STOPPED;
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001744 signal->flags &= ~SIGNAL_CLD_MASK;
1745 spin_unlock_irq(&sighand->siglock);
Oleg Nesterove4420552008-04-30 00:52:44 -07001746
Roland McGrathfa00b802008-07-25 19:45:54 -07001747 if (unlikely(!tracehook_notify_jctl(1, why)))
1748 goto relock;
1749
Oleg Nesterove4420552008-04-30 00:52:44 -07001750 read_lock(&tasklist_lock);
1751 do_notify_parent_cldstop(current->group_leader, why);
1752 read_unlock(&tasklist_lock);
1753 goto relock;
1754 }
1755
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 for (;;) {
1757 struct k_sigaction *ka;
1758
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001759 if (unlikely(signal->group_stop_count > 0) &&
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08001760 do_signal_stop(0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 goto relock;
1762
Roland McGrath7bcf6a22008-07-25 19:45:53 -07001763 /*
1764 * Tracing can induce an artifical signal and choose sigaction.
1765 * The return value in @signr determines the default action,
1766 * but @info->si_signo is the signal number we will report.
1767 */
1768 signr = tracehook_get_signal(current, regs, info, return_ka);
1769 if (unlikely(signr < 0))
1770 goto relock;
1771 if (unlikely(signr != 0))
1772 ka = return_ka;
1773 else {
1774 signr = dequeue_signal(current, &current->blocked,
1775 info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776
Roland McGrath18c98b62008-04-17 18:44:38 -07001777 if (!signr)
Roland McGrath7bcf6a22008-07-25 19:45:53 -07001778 break; /* will return 0 */
1779
1780 if (signr != SIGKILL) {
1781 signr = ptrace_signal(signr, info,
1782 regs, cookie);
1783 if (!signr)
1784 continue;
1785 }
1786
1787 ka = &sighand->action[signr-1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 }
1789
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1791 continue;
1792 if (ka->sa.sa_handler != SIG_DFL) {
1793 /* Run the handler. */
1794 *return_ka = *ka;
1795
1796 if (ka->sa.sa_flags & SA_ONESHOT)
1797 ka->sa.sa_handler = SIG_DFL;
1798
1799 break; /* will return non-zero "signr" value */
1800 }
1801
1802 /*
1803 * Now we are doing the default action for this signal.
1804 */
1805 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1806 continue;
1807
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -08001808 /*
Sukadev Bhattiprolu0fbc26a2007-10-18 23:40:13 -07001809 * Global init gets no signals it doesn't want.
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -08001810 */
Oleg Nesterovfae5fa42008-04-30 00:53:03 -07001811 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
1812 !signal_group_exit(signal))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 continue;
1814
1815 if (sig_kernel_stop(signr)) {
1816 /*
1817 * The default action is to stop all threads in
1818 * the thread group. The job control signals
1819 * do nothing in an orphaned pgrp, but SIGSTOP
1820 * always works. Note that siglock needs to be
1821 * dropped during the call to is_orphaned_pgrp()
1822 * because of lock ordering with tasklist_lock.
1823 * This allows an intervening SIGCONT to be posted.
1824 * We need to check for that and bail out if necessary.
1825 */
1826 if (signr != SIGSTOP) {
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001827 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828
1829 /* signals can be posted during this window */
1830
Eric W. Biederman3e7cd6c2007-02-12 00:52:58 -08001831 if (is_current_pgrp_orphaned())
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 goto relock;
1833
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001834 spin_lock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 }
1836
Roland McGrath7bcf6a22008-07-25 19:45:53 -07001837 if (likely(do_signal_stop(info->si_signo))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 /* It released the siglock. */
1839 goto relock;
1840 }
1841
1842 /*
1843 * We didn't actually stop, due to a race
1844 * with SIGCONT or something like that.
1845 */
1846 continue;
1847 }
1848
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001849 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850
1851 /*
1852 * Anything else is fatal, maybe with a core dump.
1853 */
1854 current->flags |= PF_SIGNALED;
Oleg Nesterov2dce81b2008-04-30 00:52:58 -07001855
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 if (sig_kernel_coredump(signr)) {
Oleg Nesterov2dce81b2008-04-30 00:52:58 -07001857 if (print_fatal_signals)
Roland McGrath7bcf6a22008-07-25 19:45:53 -07001858 print_fatal_signal(regs, info->si_signo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 /*
1860 * If it was able to dump core, this kills all
1861 * other threads in the group and synchronizes with
1862 * their demise. If we lost the race with another
1863 * thread getting here, it set group_exit_code
1864 * first and our do_group_exit call below will use
1865 * that value and ignore the one we pass it.
1866 */
Roland McGrath7bcf6a22008-07-25 19:45:53 -07001867 do_coredump(info->si_signo, info->si_signo, regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868 }
1869
1870 /*
1871 * Death signals, no core dump.
1872 */
Roland McGrath7bcf6a22008-07-25 19:45:53 -07001873 do_group_exit(info->si_signo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 /* NOTREACHED */
1875 }
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001876 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 return signr;
1878}
1879
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001880void exit_signals(struct task_struct *tsk)
1881{
1882 int group_stop = 0;
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001883 struct task_struct *t;
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001884
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001885 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
1886 tsk->flags |= PF_EXITING;
1887 return;
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001888 }
1889
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001890 spin_lock_irq(&tsk->sighand->siglock);
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001891 /*
1892 * From now this task is not visible for group-wide signals,
1893 * see wants_signal(), do_signal_stop().
1894 */
1895 tsk->flags |= PF_EXITING;
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001896 if (!signal_pending(tsk))
1897 goto out;
1898
1899 /* It could be that __group_complete_signal() choose us to
1900 * notify about group-wide signal. Another thread should be
1901 * woken now to take the signal since we will not.
1902 */
1903 for (t = tsk; (t = next_thread(t)) != tsk; )
1904 if (!signal_pending(t) && !(t->flags & PF_EXITING))
1905 recalc_sigpending_and_wake(t);
1906
1907 if (unlikely(tsk->signal->group_stop_count) &&
1908 !--tsk->signal->group_stop_count) {
1909 tsk->signal->flags = SIGNAL_STOP_STOPPED;
1910 group_stop = 1;
1911 }
1912out:
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001913 spin_unlock_irq(&tsk->sighand->siglock);
1914
Roland McGrathfa00b802008-07-25 19:45:54 -07001915 if (unlikely(group_stop) && tracehook_notify_jctl(1, CLD_STOPPED)) {
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001916 read_lock(&tasklist_lock);
1917 do_notify_parent_cldstop(tsk, CLD_STOPPED);
1918 read_unlock(&tasklist_lock);
1919 }
1920}
1921
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922EXPORT_SYMBOL(recalc_sigpending);
1923EXPORT_SYMBOL_GPL(dequeue_signal);
1924EXPORT_SYMBOL(flush_signals);
1925EXPORT_SYMBOL(force_sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926EXPORT_SYMBOL(send_sig);
1927EXPORT_SYMBOL(send_sig_info);
1928EXPORT_SYMBOL(sigprocmask);
1929EXPORT_SYMBOL(block_all_signals);
1930EXPORT_SYMBOL(unblock_all_signals);
1931
1932
1933/*
1934 * System call entry points.
1935 */
1936
1937asmlinkage long sys_restart_syscall(void)
1938{
1939 struct restart_block *restart = &current_thread_info()->restart_block;
1940 return restart->fn(restart);
1941}
1942
1943long do_no_restart_syscall(struct restart_block *param)
1944{
1945 return -EINTR;
1946}
1947
1948/*
1949 * We don't need to get the kernel lock - this is all local to this
1950 * particular thread.. (and that's good, because this is _heavily_
1951 * used by various programs)
1952 */
1953
1954/*
1955 * This is also useful for kernel threads that want to temporarily
1956 * (or permanently) block certain signals.
1957 *
1958 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1959 * interface happily blocks "unblockable" signals like SIGKILL
1960 * and friends.
1961 */
1962int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
1963{
1964 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965
1966 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterova26fd332006-03-23 03:00:49 -08001967 if (oldset)
1968 *oldset = current->blocked;
1969
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 error = 0;
1971 switch (how) {
1972 case SIG_BLOCK:
1973 sigorsets(&current->blocked, &current->blocked, set);
1974 break;
1975 case SIG_UNBLOCK:
1976 signandsets(&current->blocked, &current->blocked, set);
1977 break;
1978 case SIG_SETMASK:
1979 current->blocked = *set;
1980 break;
1981 default:
1982 error = -EINVAL;
1983 }
1984 recalc_sigpending();
1985 spin_unlock_irq(&current->sighand->siglock);
Oleg Nesterova26fd332006-03-23 03:00:49 -08001986
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 return error;
1988}
1989
1990asmlinkage long
1991sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
1992{
1993 int error = -EINVAL;
1994 sigset_t old_set, new_set;
1995
1996 /* XXX: Don't preclude handling different sized sigset_t's. */
1997 if (sigsetsize != sizeof(sigset_t))
1998 goto out;
1999
2000 if (set) {
2001 error = -EFAULT;
2002 if (copy_from_user(&new_set, set, sizeof(*set)))
2003 goto out;
2004 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2005
2006 error = sigprocmask(how, &new_set, &old_set);
2007 if (error)
2008 goto out;
2009 if (oset)
2010 goto set_old;
2011 } else if (oset) {
2012 spin_lock_irq(&current->sighand->siglock);
2013 old_set = current->blocked;
2014 spin_unlock_irq(&current->sighand->siglock);
2015
2016 set_old:
2017 error = -EFAULT;
2018 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2019 goto out;
2020 }
2021 error = 0;
2022out:
2023 return error;
2024}
2025
2026long do_sigpending(void __user *set, unsigned long sigsetsize)
2027{
2028 long error = -EINVAL;
2029 sigset_t pending;
2030
2031 if (sigsetsize > sizeof(sigset_t))
2032 goto out;
2033
2034 spin_lock_irq(&current->sighand->siglock);
2035 sigorsets(&pending, &current->pending.signal,
2036 &current->signal->shared_pending.signal);
2037 spin_unlock_irq(&current->sighand->siglock);
2038
2039 /* Outside the lock because only this thread touches it. */
2040 sigandsets(&pending, &current->blocked, &pending);
2041
2042 error = -EFAULT;
2043 if (!copy_to_user(set, &pending, sigsetsize))
2044 error = 0;
2045
2046out:
2047 return error;
2048}
2049
2050asmlinkage long
2051sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2052{
2053 return do_sigpending(set, sigsetsize);
2054}
2055
2056#ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2057
2058int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2059{
2060 int err;
2061
2062 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2063 return -EFAULT;
2064 if (from->si_code < 0)
2065 return __copy_to_user(to, from, sizeof(siginfo_t))
2066 ? -EFAULT : 0;
2067 /*
2068 * If you change siginfo_t structure, please be sure
2069 * this code is fixed accordingly.
Davide Libenzifba2afa2007-05-10 22:23:13 -07002070 * Please remember to update the signalfd_copyinfo() function
2071 * inside fs/signalfd.c too, in case siginfo_t changes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 * It should never copy any pad contained in the structure
2073 * to avoid security leaks, but must copy the generic
2074 * 3 ints plus the relevant union member.
2075 */
2076 err = __put_user(from->si_signo, &to->si_signo);
2077 err |= __put_user(from->si_errno, &to->si_errno);
2078 err |= __put_user((short)from->si_code, &to->si_code);
2079 switch (from->si_code & __SI_MASK) {
2080 case __SI_KILL:
2081 err |= __put_user(from->si_pid, &to->si_pid);
2082 err |= __put_user(from->si_uid, &to->si_uid);
2083 break;
2084 case __SI_TIMER:
2085 err |= __put_user(from->si_tid, &to->si_tid);
2086 err |= __put_user(from->si_overrun, &to->si_overrun);
2087 err |= __put_user(from->si_ptr, &to->si_ptr);
2088 break;
2089 case __SI_POLL:
2090 err |= __put_user(from->si_band, &to->si_band);
2091 err |= __put_user(from->si_fd, &to->si_fd);
2092 break;
2093 case __SI_FAULT:
2094 err |= __put_user(from->si_addr, &to->si_addr);
2095#ifdef __ARCH_SI_TRAPNO
2096 err |= __put_user(from->si_trapno, &to->si_trapno);
2097#endif
2098 break;
2099 case __SI_CHLD:
2100 err |= __put_user(from->si_pid, &to->si_pid);
2101 err |= __put_user(from->si_uid, &to->si_uid);
2102 err |= __put_user(from->si_status, &to->si_status);
2103 err |= __put_user(from->si_utime, &to->si_utime);
2104 err |= __put_user(from->si_stime, &to->si_stime);
2105 break;
2106 case __SI_RT: /* This is not generated by the kernel as of now. */
2107 case __SI_MESGQ: /* But this is */
2108 err |= __put_user(from->si_pid, &to->si_pid);
2109 err |= __put_user(from->si_uid, &to->si_uid);
2110 err |= __put_user(from->si_ptr, &to->si_ptr);
2111 break;
2112 default: /* this is just in case for now ... */
2113 err |= __put_user(from->si_pid, &to->si_pid);
2114 err |= __put_user(from->si_uid, &to->si_uid);
2115 break;
2116 }
2117 return err;
2118}
2119
2120#endif
2121
2122asmlinkage long
2123sys_rt_sigtimedwait(const sigset_t __user *uthese,
2124 siginfo_t __user *uinfo,
2125 const struct timespec __user *uts,
2126 size_t sigsetsize)
2127{
2128 int ret, sig;
2129 sigset_t these;
2130 struct timespec ts;
2131 siginfo_t info;
2132 long timeout = 0;
2133
2134 /* XXX: Don't preclude handling different sized sigset_t's. */
2135 if (sigsetsize != sizeof(sigset_t))
2136 return -EINVAL;
2137
2138 if (copy_from_user(&these, uthese, sizeof(these)))
2139 return -EFAULT;
2140
2141 /*
2142 * Invert the set of allowed signals to get those we
2143 * want to block.
2144 */
2145 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2146 signotset(&these);
2147
2148 if (uts) {
2149 if (copy_from_user(&ts, uts, sizeof(ts)))
2150 return -EFAULT;
2151 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2152 || ts.tv_sec < 0)
2153 return -EINVAL;
2154 }
2155
2156 spin_lock_irq(&current->sighand->siglock);
2157 sig = dequeue_signal(current, &these, &info);
2158 if (!sig) {
2159 timeout = MAX_SCHEDULE_TIMEOUT;
2160 if (uts)
2161 timeout = (timespec_to_jiffies(&ts)
2162 + (ts.tv_sec || ts.tv_nsec));
2163
2164 if (timeout) {
2165 /* None ready -- temporarily unblock those we're
2166 * interested while we are sleeping in so that we'll
2167 * be awakened when they arrive. */
2168 current->real_blocked = current->blocked;
2169 sigandsets(&current->blocked, &current->blocked, &these);
2170 recalc_sigpending();
2171 spin_unlock_irq(&current->sighand->siglock);
2172
Nishanth Aravamudan75bcc8c2005-09-10 00:27:24 -07002173 timeout = schedule_timeout_interruptible(timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 spin_lock_irq(&current->sighand->siglock);
2176 sig = dequeue_signal(current, &these, &info);
2177 current->blocked = current->real_blocked;
2178 siginitset(&current->real_blocked, 0);
2179 recalc_sigpending();
2180 }
2181 }
2182 spin_unlock_irq(&current->sighand->siglock);
2183
2184 if (sig) {
2185 ret = sig;
2186 if (uinfo) {
2187 if (copy_siginfo_to_user(uinfo, &info))
2188 ret = -EFAULT;
2189 }
2190 } else {
2191 ret = -EAGAIN;
2192 if (timeout)
2193 ret = -EINTR;
2194 }
2195
2196 return ret;
2197}
2198
2199asmlinkage long
Gustavo Fernando Padovanbc64efd2008-07-25 01:47:33 -07002200sys_kill(pid_t pid, int sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201{
2202 struct siginfo info;
2203
2204 info.si_signo = sig;
2205 info.si_errno = 0;
2206 info.si_code = SI_USER;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002207 info.si_pid = task_tgid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 info.si_uid = current->uid;
2209
2210 return kill_something_info(sig, &info, pid);
2211}
2212
Gustavo Fernando Padovanbc64efd2008-07-25 01:47:33 -07002213static int do_tkill(pid_t tgid, pid_t pid, int sig)
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002214{
2215 int error;
2216 struct siginfo info;
2217 struct task_struct *p;
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002218 unsigned long flags;
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002219
2220 error = -ESRCH;
2221 info.si_signo = sig;
2222 info.si_errno = 0;
2223 info.si_code = SI_TKILL;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002224 info.si_pid = task_tgid_vnr(current);
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002225 info.si_uid = current->uid;
2226
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002227 rcu_read_lock();
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -07002228 p = find_task_by_vpid(pid);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002229 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002230 error = check_kill_permission(sig, &info, p);
2231 /*
2232 * The null signal is a permissions and process existence
2233 * probe. No signal is actually delivered.
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002234 *
2235 * If lock_task_sighand() fails we pretend the task dies
2236 * after receiving the signal. The window is tiny, and the
2237 * signal is private anyway.
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002238 */
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002239 if (!error && sig && lock_task_sighand(p, &flags)) {
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002240 error = specific_send_sig_info(sig, &info, p);
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002241 unlock_task_sighand(p, &flags);
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002242 }
2243 }
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002244 rcu_read_unlock();
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002245
2246 return error;
2247}
2248
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249/**
2250 * sys_tgkill - send signal to one specific thread
2251 * @tgid: the thread group ID of the thread
2252 * @pid: the PID of the thread
2253 * @sig: signal to be sent
2254 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08002255 * This syscall also checks the @tgid and returns -ESRCH even if the PID
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 * exists but it's not belonging to the target process anymore. This
2257 * method solves the problem of threads exiting and PIDs getting reused.
2258 */
Gustavo Fernando Padovanbc64efd2008-07-25 01:47:33 -07002259asmlinkage long sys_tgkill(pid_t tgid, pid_t pid, int sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261 /* This is only valid for single tasks */
2262 if (pid <= 0 || tgid <= 0)
2263 return -EINVAL;
2264
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002265 return do_tkill(tgid, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266}
2267
2268/*
2269 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2270 */
2271asmlinkage long
Gustavo Fernando Padovanbc64efd2008-07-25 01:47:33 -07002272sys_tkill(pid_t pid, int sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 /* This is only valid for single tasks */
2275 if (pid <= 0)
2276 return -EINVAL;
2277
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002278 return do_tkill(0, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279}
2280
2281asmlinkage long
Gustavo Fernando Padovanbc64efd2008-07-25 01:47:33 -07002282sys_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t __user *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283{
2284 siginfo_t info;
2285
2286 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2287 return -EFAULT;
2288
2289 /* Not even root can pretend to send signals from the kernel.
2290 Nor can they impersonate a kill(), which adds source info. */
2291 if (info.si_code >= 0)
2292 return -EPERM;
2293 info.si_signo = sig;
2294
2295 /* POSIX.1b doesn't mention process groups. */
2296 return kill_proc_info(sig, &info, pid);
2297}
2298
Oleg Nesterov88531f72006-03-28 16:11:24 -08002299int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300{
Pavel Emelyanov93585ee2008-04-30 00:52:39 -07002301 struct task_struct *t = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 struct k_sigaction *k;
George Anzinger71fabd52006-01-08 01:02:48 -08002303 sigset_t mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304
Jesper Juhl7ed20e12005-05-01 08:59:14 -07002305 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306 return -EINVAL;
2307
Pavel Emelyanov93585ee2008-04-30 00:52:39 -07002308 k = &t->sighand->action[sig-1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309
2310 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311 if (oact)
2312 *oact = *k;
2313
2314 if (act) {
Oleg Nesterov9ac95f22006-02-09 22:41:50 +03002315 sigdelsetmask(&act->sa.sa_mask,
2316 sigmask(SIGKILL) | sigmask(SIGSTOP));
Oleg Nesterov88531f72006-03-28 16:11:24 -08002317 *k = *act;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318 /*
2319 * POSIX 3.3.1.3:
2320 * "Setting a signal action to SIG_IGN for a signal that is
2321 * pending shall cause the pending signal to be discarded,
2322 * whether or not it is blocked."
2323 *
2324 * "Setting a signal action to SIG_DFL for a signal that is
2325 * pending and whose default action is to ignore the signal
2326 * (for example, SIGCHLD), shall cause the pending signal to
2327 * be discarded, whether or not it is blocked"
2328 */
Roland McGrath35de2542008-07-25 19:45:51 -07002329 if (sig_handler_ignored(sig_handler(t, sig), sig)) {
George Anzinger71fabd52006-01-08 01:02:48 -08002330 sigemptyset(&mask);
2331 sigaddset(&mask, sig);
2332 rm_from_queue_full(&mask, &t->signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 do {
George Anzinger71fabd52006-01-08 01:02:48 -08002334 rm_from_queue_full(&mask, &t->pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 t = next_thread(t);
2336 } while (t != current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338 }
2339
2340 spin_unlock_irq(&current->sighand->siglock);
2341 return 0;
2342}
2343
2344int
2345do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2346{
2347 stack_t oss;
2348 int error;
2349
2350 if (uoss) {
2351 oss.ss_sp = (void __user *) current->sas_ss_sp;
2352 oss.ss_size = current->sas_ss_size;
2353 oss.ss_flags = sas_ss_flags(sp);
2354 }
2355
2356 if (uss) {
2357 void __user *ss_sp;
2358 size_t ss_size;
2359 int ss_flags;
2360
2361 error = -EFAULT;
2362 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2363 || __get_user(ss_sp, &uss->ss_sp)
2364 || __get_user(ss_flags, &uss->ss_flags)
2365 || __get_user(ss_size, &uss->ss_size))
2366 goto out;
2367
2368 error = -EPERM;
2369 if (on_sig_stack(sp))
2370 goto out;
2371
2372 error = -EINVAL;
2373 /*
2374 *
2375 * Note - this code used to test ss_flags incorrectly
2376 * old code may have been written using ss_flags==0
2377 * to mean ss_flags==SS_ONSTACK (as this was the only
2378 * way that worked) - this fix preserves that older
2379 * mechanism
2380 */
2381 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2382 goto out;
2383
2384 if (ss_flags == SS_DISABLE) {
2385 ss_size = 0;
2386 ss_sp = NULL;
2387 } else {
2388 error = -ENOMEM;
2389 if (ss_size < MINSIGSTKSZ)
2390 goto out;
2391 }
2392
2393 current->sas_ss_sp = (unsigned long) ss_sp;
2394 current->sas_ss_size = ss_size;
2395 }
2396
2397 if (uoss) {
2398 error = -EFAULT;
2399 if (copy_to_user(uoss, &oss, sizeof(oss)))
2400 goto out;
2401 }
2402
2403 error = 0;
2404out:
2405 return error;
2406}
2407
2408#ifdef __ARCH_WANT_SYS_SIGPENDING
2409
2410asmlinkage long
2411sys_sigpending(old_sigset_t __user *set)
2412{
2413 return do_sigpending(set, sizeof(*set));
2414}
2415
2416#endif
2417
2418#ifdef __ARCH_WANT_SYS_SIGPROCMASK
2419/* Some platforms have their own version with special arguments others
2420 support only sys_rt_sigprocmask. */
2421
2422asmlinkage long
2423sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2424{
2425 int error;
2426 old_sigset_t old_set, new_set;
2427
2428 if (set) {
2429 error = -EFAULT;
2430 if (copy_from_user(&new_set, set, sizeof(*set)))
2431 goto out;
2432 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2433
2434 spin_lock_irq(&current->sighand->siglock);
2435 old_set = current->blocked.sig[0];
2436
2437 error = 0;
2438 switch (how) {
2439 default:
2440 error = -EINVAL;
2441 break;
2442 case SIG_BLOCK:
2443 sigaddsetmask(&current->blocked, new_set);
2444 break;
2445 case SIG_UNBLOCK:
2446 sigdelsetmask(&current->blocked, new_set);
2447 break;
2448 case SIG_SETMASK:
2449 current->blocked.sig[0] = new_set;
2450 break;
2451 }
2452
2453 recalc_sigpending();
2454 spin_unlock_irq(&current->sighand->siglock);
2455 if (error)
2456 goto out;
2457 if (oset)
2458 goto set_old;
2459 } else if (oset) {
2460 old_set = current->blocked.sig[0];
2461 set_old:
2462 error = -EFAULT;
2463 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2464 goto out;
2465 }
2466 error = 0;
2467out:
2468 return error;
2469}
2470#endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2471
2472#ifdef __ARCH_WANT_SYS_RT_SIGACTION
2473asmlinkage long
2474sys_rt_sigaction(int sig,
2475 const struct sigaction __user *act,
2476 struct sigaction __user *oact,
2477 size_t sigsetsize)
2478{
2479 struct k_sigaction new_sa, old_sa;
2480 int ret = -EINVAL;
2481
2482 /* XXX: Don't preclude handling different sized sigset_t's. */
2483 if (sigsetsize != sizeof(sigset_t))
2484 goto out;
2485
2486 if (act) {
2487 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2488 return -EFAULT;
2489 }
2490
2491 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2492
2493 if (!ret && oact) {
2494 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2495 return -EFAULT;
2496 }
2497out:
2498 return ret;
2499}
2500#endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2501
2502#ifdef __ARCH_WANT_SYS_SGETMASK
2503
2504/*
2505 * For backwards compatibility. Functionality superseded by sigprocmask.
2506 */
2507asmlinkage long
2508sys_sgetmask(void)
2509{
2510 /* SMP safe */
2511 return current->blocked.sig[0];
2512}
2513
2514asmlinkage long
2515sys_ssetmask(int newmask)
2516{
2517 int old;
2518
2519 spin_lock_irq(&current->sighand->siglock);
2520 old = current->blocked.sig[0];
2521
2522 siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2523 sigmask(SIGSTOP)));
2524 recalc_sigpending();
2525 spin_unlock_irq(&current->sighand->siglock);
2526
2527 return old;
2528}
2529#endif /* __ARCH_WANT_SGETMASK */
2530
2531#ifdef __ARCH_WANT_SYS_SIGNAL
2532/*
2533 * For backwards compatibility. Functionality superseded by sigaction.
2534 */
2535asmlinkage unsigned long
2536sys_signal(int sig, __sighandler_t handler)
2537{
2538 struct k_sigaction new_sa, old_sa;
2539 int ret;
2540
2541 new_sa.sa.sa_handler = handler;
2542 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
Oleg Nesterovc70d3d702006-02-09 22:41:41 +03002543 sigemptyset(&new_sa.sa.sa_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544
2545 ret = do_sigaction(sig, &new_sa, &old_sa);
2546
2547 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2548}
2549#endif /* __ARCH_WANT_SYS_SIGNAL */
2550
2551#ifdef __ARCH_WANT_SYS_PAUSE
2552
2553asmlinkage long
2554sys_pause(void)
2555{
2556 current->state = TASK_INTERRUPTIBLE;
2557 schedule();
2558 return -ERESTARTNOHAND;
2559}
2560
2561#endif
2562
David Woodhouse150256d2006-01-18 17:43:57 -08002563#ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2564asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2565{
2566 sigset_t newset;
2567
2568 /* XXX: Don't preclude handling different sized sigset_t's. */
2569 if (sigsetsize != sizeof(sigset_t))
2570 return -EINVAL;
2571
2572 if (copy_from_user(&newset, unewset, sizeof(newset)))
2573 return -EFAULT;
2574 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2575
2576 spin_lock_irq(&current->sighand->siglock);
2577 current->saved_sigmask = current->blocked;
2578 current->blocked = newset;
2579 recalc_sigpending();
2580 spin_unlock_irq(&current->sighand->siglock);
2581
2582 current->state = TASK_INTERRUPTIBLE;
2583 schedule();
Roland McGrath4e4c22c2008-04-30 00:53:06 -07002584 set_restore_sigmask();
David Woodhouse150256d2006-01-18 17:43:57 -08002585 return -ERESTARTNOHAND;
2586}
2587#endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2588
David Howellsf269fdd2006-09-27 01:50:23 -07002589__attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2590{
2591 return NULL;
2592}
2593
Linus Torvalds1da177e2005-04-16 15:20:36 -07002594void __init signals_init(void)
2595{
Christoph Lameter0a31bd52007-05-06 14:49:57 -07002596 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597}