blob: 1c8814481a117d5df731465b5a56bbf4738c48c1 [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>
Mathieu Desnoyers0a16b602008-07-18 12:16:17 -040030#include <trace/sched.h>
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -080031
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <asm/param.h>
33#include <asm/uaccess.h>
34#include <asm/unistd.h>
35#include <asm/siginfo.h>
Al Viroe1396062006-05-25 10:19:47 -040036#include "audit.h" /* audit_signal_info() */
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38/*
39 * SLAB caches for signal bits.
40 */
41
Christoph Lametere18b8902006-12-06 20:33:20 -080042static struct kmem_cache *sigqueue_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
Mathieu Desnoyers7e066fb2008-11-14 17:47:47 -050044DEFINE_TRACE(sched_signal_send);
45
Roland McGrath35de2542008-07-25 19:45:51 -070046static void __user *sig_handler(struct task_struct *t, int sig)
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070047{
Roland McGrath35de2542008-07-25 19:45:51 -070048 return t->sighand->action[sig - 1].sa.sa_handler;
49}
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070050
Roland McGrath35de2542008-07-25 19:45:51 -070051static int sig_handler_ignored(void __user *handler, int sig)
52{
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070053 /* Is it explicitly or implicitly ignored? */
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070054 return handler == SIG_IGN ||
55 (handler == SIG_DFL && sig_kernel_ignore(sig));
56}
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
58static int sig_ignored(struct task_struct *t, int sig)
59{
Roland McGrath35de2542008-07-25 19:45:51 -070060 void __user *handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62 /*
63 * Blocked signals are never ignored, since the
64 * signal handler may change by the time it is
65 * unblocked.
66 */
Roland McGrath325d22d2007-11-12 15:41:55 -080067 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 return 0;
69
Roland McGrath35de2542008-07-25 19:45:51 -070070 handler = sig_handler(t, sig);
71 if (!sig_handler_ignored(handler, sig))
72 return 0;
73
74 /*
75 * Tracers may want to know about even ignored signals.
76 */
77 return !tracehook_consider_ignored_signal(t, sig, handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078}
79
80/*
81 * Re-calculate pending state from the set of locally pending
82 * signals, globally pending signals, and blocked signals.
83 */
84static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
85{
86 unsigned long ready;
87 long i;
88
89 switch (_NSIG_WORDS) {
90 default:
91 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
92 ready |= signal->sig[i] &~ blocked->sig[i];
93 break;
94
95 case 4: ready = signal->sig[3] &~ blocked->sig[3];
96 ready |= signal->sig[2] &~ blocked->sig[2];
97 ready |= signal->sig[1] &~ blocked->sig[1];
98 ready |= signal->sig[0] &~ blocked->sig[0];
99 break;
100
101 case 2: ready = signal->sig[1] &~ blocked->sig[1];
102 ready |= signal->sig[0] &~ blocked->sig[0];
103 break;
104
105 case 1: ready = signal->sig[0] &~ blocked->sig[0];
106 }
107 return ready != 0;
108}
109
110#define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
111
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700112static int recalc_sigpending_tsk(struct task_struct *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113{
114 if (t->signal->group_stop_count > 0 ||
115 PENDING(&t->pending, &t->blocked) ||
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700116 PENDING(&t->signal->shared_pending, &t->blocked)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 set_tsk_thread_flag(t, TIF_SIGPENDING);
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700118 return 1;
119 }
Roland McGrathb74d0de2007-06-06 03:59:00 -0700120 /*
121 * We must never clear the flag in another thread, or in current
122 * when it's possible the current syscall is returning -ERESTART*.
123 * So we don't clear it here, and only callers who know they should do.
124 */
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700125 return 0;
126}
127
128/*
129 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
130 * This is superfluous when called on current, the wakeup is a harmless no-op.
131 */
132void recalc_sigpending_and_wake(struct task_struct *t)
133{
134 if (recalc_sigpending_tsk(t))
135 signal_wake_up(t, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136}
137
138void recalc_sigpending(void)
139{
Roland McGrathb787f7b2008-07-25 19:45:55 -0700140 if (unlikely(tracehook_force_sigpending()))
141 set_thread_flag(TIF_SIGPENDING);
142 else if (!recalc_sigpending_tsk(current) && !freezing(current))
Roland McGrathb74d0de2007-06-06 03:59:00 -0700143 clear_thread_flag(TIF_SIGPENDING);
144
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145}
146
147/* Given the mask, find the first available signal that should be serviced. */
148
Davide Libenzifba2afa2007-05-10 22:23:13 -0700149int next_signal(struct sigpending *pending, sigset_t *mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150{
151 unsigned long i, *s, *m, x;
152 int sig = 0;
153
154 s = pending->signal.sig;
155 m = mask->sig;
156 switch (_NSIG_WORDS) {
157 default:
158 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
159 if ((x = *s &~ *m) != 0) {
160 sig = ffz(~x) + i*_NSIG_BPW + 1;
161 break;
162 }
163 break;
164
165 case 2: if ((x = s[0] &~ m[0]) != 0)
166 sig = 1;
167 else if ((x = s[1] &~ m[1]) != 0)
168 sig = _NSIG_BPW + 1;
169 else
170 break;
171 sig += ffz(~x);
172 break;
173
174 case 1: if ((x = *s &~ *m) != 0)
175 sig = ffz(~x) + 1;
176 break;
177 }
178
179 return sig;
180}
181
David Howellsc69e8d92008-11-14 10:39:19 +1100182/*
183 * allocate a new signal queue record
184 * - this may be called without locks if and only if t == current, otherwise an
David Howellsd84f4f92008-11-14 10:39:23 +1100185 * appopriate lock must be held to stop the target task from exiting
David Howellsc69e8d92008-11-14 10:39:19 +1100186 */
Al Virodd0fc662005-10-07 07:46:04 +0100187static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 int override_rlimit)
189{
190 struct sigqueue *q = NULL;
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800191 struct user_struct *user;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800193 /*
David Howellsc69e8d92008-11-14 10:39:19 +1100194 * We won't get problems with the target's UID changing under us
195 * because changing it requires RCU be used, and if t != current, the
196 * caller must be holding the RCU readlock (by way of a spinlock) and
197 * we use RCU protection here
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800198 */
David Howellsd84f4f92008-11-14 10:39:23 +1100199 user = get_uid(__task_cred(t)->user);
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800200 atomic_inc(&user->sigpending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 if (override_rlimit ||
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800202 atomic_read(&user->sigpending) <=
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
204 q = kmem_cache_alloc(sigqueue_cachep, flags);
205 if (unlikely(q == NULL)) {
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800206 atomic_dec(&user->sigpending);
David Howellsd84f4f92008-11-14 10:39:23 +1100207 free_uid(user);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 } else {
209 INIT_LIST_HEAD(&q->list);
210 q->flags = 0;
David Howellsd84f4f92008-11-14 10:39:23 +1100211 q->user = user;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 }
David Howellsd84f4f92008-11-14 10:39:23 +1100213
214 return q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215}
216
Andrew Morton514a01b2006-02-03 03:04:41 -0800217static void __sigqueue_free(struct sigqueue *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
219 if (q->flags & SIGQUEUE_PREALLOC)
220 return;
221 atomic_dec(&q->user->sigpending);
222 free_uid(q->user);
223 kmem_cache_free(sigqueue_cachep, q);
224}
225
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800226void flush_sigqueue(struct sigpending *queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227{
228 struct sigqueue *q;
229
230 sigemptyset(&queue->signal);
231 while (!list_empty(&queue->list)) {
232 q = list_entry(queue->list.next, struct sigqueue , list);
233 list_del_init(&q->list);
234 __sigqueue_free(q);
235 }
236}
237
238/*
239 * Flush all pending signals for a task.
240 */
Oleg Nesterovc81addc2006-03-28 16:11:17 -0800241void flush_signals(struct task_struct *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242{
243 unsigned long flags;
244
245 spin_lock_irqsave(&t->sighand->siglock, flags);
Pavel Machekf5264482008-04-21 22:15:06 +0000246 clear_tsk_thread_flag(t, TIF_SIGPENDING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 flush_sigqueue(&t->pending);
248 flush_sigqueue(&t->signal->shared_pending);
249 spin_unlock_irqrestore(&t->sighand->siglock, flags);
250}
251
Oleg Nesterovcbaffba2008-05-26 20:55:42 +0400252static void __flush_itimer_signals(struct sigpending *pending)
253{
254 sigset_t signal, retain;
255 struct sigqueue *q, *n;
256
257 signal = pending->signal;
258 sigemptyset(&retain);
259
260 list_for_each_entry_safe(q, n, &pending->list, list) {
261 int sig = q->info.si_signo;
262
263 if (likely(q->info.si_code != SI_TIMER)) {
264 sigaddset(&retain, sig);
265 } else {
266 sigdelset(&signal, sig);
267 list_del_init(&q->list);
268 __sigqueue_free(q);
269 }
270 }
271
272 sigorsets(&pending->signal, &signal, &retain);
273}
274
275void flush_itimer_signals(void)
276{
277 struct task_struct *tsk = current;
278 unsigned long flags;
279
280 spin_lock_irqsave(&tsk->sighand->siglock, flags);
281 __flush_itimer_signals(&tsk->pending);
282 __flush_itimer_signals(&tsk->signal->shared_pending);
283 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
284}
285
Oleg Nesterov10ab8252007-05-09 02:34:37 -0700286void ignore_signals(struct task_struct *t)
287{
288 int i;
289
290 for (i = 0; i < _NSIG; ++i)
291 t->sighand->action[i].sa.sa_handler = SIG_IGN;
292
293 flush_signals(t);
294}
295
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 * Flush all handlers for a task.
298 */
299
300void
301flush_signal_handlers(struct task_struct *t, int force_default)
302{
303 int i;
304 struct k_sigaction *ka = &t->sighand->action[0];
305 for (i = _NSIG ; i != 0 ; i--) {
306 if (force_default || ka->sa.sa_handler != SIG_IGN)
307 ka->sa.sa_handler = SIG_DFL;
308 ka->sa.sa_flags = 0;
309 sigemptyset(&ka->sa.sa_mask);
310 ka++;
311 }
312}
313
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200314int unhandled_signal(struct task_struct *tsk, int sig)
315{
Roland McGrath445a91d2008-07-25 19:45:52 -0700316 void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
Serge E. Hallynb460cbc2007-10-18 23:39:52 -0700317 if (is_global_init(tsk))
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200318 return 1;
Roland McGrath445a91d2008-07-25 19:45:52 -0700319 if (handler != SIG_IGN && handler != SIG_DFL)
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200320 return 0;
Roland McGrath445a91d2008-07-25 19:45:52 -0700321 return !tracehook_consider_fatal_signal(tsk, sig, handler);
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200322}
323
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
325/* Notify the system that a driver wants to block all signals for this
326 * process, and wants to be notified if any signals at all were to be
327 * sent/acted upon. If the notifier routine returns non-zero, then the
328 * signal will be acted upon after all. If the notifier routine returns 0,
329 * then then signal will be blocked. Only one block per process is
330 * allowed. priv is a pointer to private data that the notifier routine
331 * can use to determine if the signal should be blocked or not. */
332
333void
334block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
335{
336 unsigned long flags;
337
338 spin_lock_irqsave(&current->sighand->siglock, flags);
339 current->notifier_mask = mask;
340 current->notifier_data = priv;
341 current->notifier = notifier;
342 spin_unlock_irqrestore(&current->sighand->siglock, flags);
343}
344
345/* Notify the system that blocking has ended. */
346
347void
348unblock_all_signals(void)
349{
350 unsigned long flags;
351
352 spin_lock_irqsave(&current->sighand->siglock, flags);
353 current->notifier = NULL;
354 current->notifier_data = NULL;
355 recalc_sigpending();
356 spin_unlock_irqrestore(&current->sighand->siglock, flags);
357}
358
Oleg Nesterov100360f2008-07-25 01:47:29 -0700359static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360{
361 struct sigqueue *q, *first = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 /*
364 * Collect the siginfo appropriate to this signal. Check if
365 * there is another siginfo for the same signal.
366 */
367 list_for_each_entry(q, &list->list, list) {
368 if (q->info.si_signo == sig) {
Oleg Nesterovd4434202008-07-25 01:47:28 -0700369 if (first)
370 goto still_pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 first = q;
372 }
373 }
Oleg Nesterovd4434202008-07-25 01:47:28 -0700374
375 sigdelset(&list->signal, sig);
376
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 if (first) {
Oleg Nesterovd4434202008-07-25 01:47:28 -0700378still_pending:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 list_del_init(&first->list);
380 copy_siginfo(info, &first->info);
381 __sigqueue_free(first);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 /* Ok, it wasn't in the queue. This must be
384 a fast-pathed signal or we must have been
385 out of queue space. So zero out the info.
386 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 info->si_signo = sig;
388 info->si_errno = 0;
389 info->si_code = 0;
390 info->si_pid = 0;
391 info->si_uid = 0;
392 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393}
394
395static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
396 siginfo_t *info)
397{
Roland McGrath27d91e02006-09-29 02:00:31 -0700398 int sig = next_signal(pending, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 if (sig) {
401 if (current->notifier) {
402 if (sigismember(current->notifier_mask, sig)) {
403 if (!(current->notifier)(current->notifier_data)) {
404 clear_thread_flag(TIF_SIGPENDING);
405 return 0;
406 }
407 }
408 }
409
Oleg Nesterov100360f2008-07-25 01:47:29 -0700410 collect_signal(sig, pending, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
413 return sig;
414}
415
416/*
417 * Dequeue a signal and return the element to the caller, which is
418 * expected to free it.
419 *
420 * All callers have to hold the siglock.
421 */
422int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
423{
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700424 int signr;
Benjamin Herrenschmidtcaec4e82007-06-12 08:16:18 +1000425
426 /* We only dequeue private signals from ourselves, we don't let
427 * signalfd steal them
428 */
Davide Libenzib8fceee2007-09-20 12:40:16 -0700429 signr = __dequeue_signal(&tsk->pending, mask, info);
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800430 if (!signr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 signr = __dequeue_signal(&tsk->signal->shared_pending,
432 mask, info);
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800433 /*
434 * itimer signal ?
435 *
436 * itimers are process shared and we restart periodic
437 * itimers in the signal delivery path to prevent DoS
438 * attacks in the high resolution timer case. This is
439 * compliant with the old way of self restarting
440 * itimers, as the SIGALRM is a legacy signal and only
441 * queued once. Changing the restart behaviour to
442 * restart the timer in the signal dequeue path is
443 * reducing the timer noise on heavy loaded !highres
444 * systems too.
445 */
446 if (unlikely(signr == SIGALRM)) {
447 struct hrtimer *tmr = &tsk->signal->real_timer;
448
449 if (!hrtimer_is_queued(tmr) &&
450 tsk->signal->it_real_incr.tv64 != 0) {
451 hrtimer_forward(tmr, tmr->base->get_time(),
452 tsk->signal->it_real_incr);
453 hrtimer_restart(tmr);
454 }
455 }
456 }
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700457
Davide Libenzib8fceee2007-09-20 12:40:16 -0700458 recalc_sigpending();
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700459 if (!signr)
460 return 0;
461
462 if (unlikely(sig_kernel_stop(signr))) {
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800463 /*
464 * Set a marker that we have dequeued a stop signal. Our
465 * caller might release the siglock and then the pending
466 * stop signal it is about to process is no longer in the
467 * pending bitmasks, but must still be cleared by a SIGCONT
468 * (and overruled by a SIGKILL). So those cases clear this
469 * shared flag after we've set it. Note that this flag may
470 * remain set after the signal we return is ignored or
471 * handled. That doesn't matter because its only purpose
472 * is to alert stop-signal processing code when another
473 * processor has come along and cleared the flag.
474 */
Oleg Nesterov92413d72008-07-25 01:47:30 -0700475 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800476 }
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700477 if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 /*
479 * Release the siglock to ensure proper locking order
480 * of timer locks outside of siglocks. Note, we leave
481 * irqs disabled here, since the posix-timers code is
482 * about to disable them again anyway.
483 */
484 spin_unlock(&tsk->sighand->siglock);
485 do_schedule_next_timer(info);
486 spin_lock(&tsk->sighand->siglock);
487 }
488 return signr;
489}
490
491/*
492 * Tell a process that it has a new active signal..
493 *
494 * NOTE! we rely on the previous spin_lock to
495 * lock interrupts for us! We can only be called with
496 * "siglock" held, and the local interrupt must
497 * have been disabled when that got acquired!
498 *
499 * No need to set need_resched since signal event passing
500 * goes through ->blocked
501 */
502void signal_wake_up(struct task_struct *t, int resume)
503{
504 unsigned int mask;
505
506 set_tsk_thread_flag(t, TIF_SIGPENDING);
507
508 /*
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500509 * For SIGKILL, we want to wake it up in the stopped/traced/killable
510 * case. We don't check t->state here because there is a race with it
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 * executing another processor and just now entering stopped state.
512 * By using wake_up_state, we ensure the process will wake up and
513 * handle its death signal.
514 */
515 mask = TASK_INTERRUPTIBLE;
516 if (resume)
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500517 mask |= TASK_WAKEKILL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 if (!wake_up_state(t, mask))
519 kick_process(t);
520}
521
522/*
523 * Remove signals in mask from the pending set and queue.
524 * Returns 1 if any signals were found.
525 *
526 * All callers must be holding the siglock.
George Anzinger71fabd52006-01-08 01:02:48 -0800527 *
528 * This version takes a sigset mask and looks at all signals,
529 * not just those in the first mask word.
530 */
531static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
532{
533 struct sigqueue *q, *n;
534 sigset_t m;
535
536 sigandsets(&m, mask, &s->signal);
537 if (sigisemptyset(&m))
538 return 0;
539
540 signandsets(&s->signal, &s->signal, mask);
541 list_for_each_entry_safe(q, n, &s->list, list) {
542 if (sigismember(mask, q->info.si_signo)) {
543 list_del_init(&q->list);
544 __sigqueue_free(q);
545 }
546 }
547 return 1;
548}
549/*
550 * Remove signals in mask from the pending set and queue.
551 * Returns 1 if any signals were found.
552 *
553 * All callers must be holding the siglock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 */
555static int rm_from_queue(unsigned long mask, struct sigpending *s)
556{
557 struct sigqueue *q, *n;
558
559 if (!sigtestsetmask(&s->signal, mask))
560 return 0;
561
562 sigdelsetmask(&s->signal, mask);
563 list_for_each_entry_safe(q, n, &s->list, list) {
564 if (q->info.si_signo < SIGRTMIN &&
565 (mask & sigmask(q->info.si_signo))) {
566 list_del_init(&q->list);
567 __sigqueue_free(q);
568 }
569 }
570 return 1;
571}
572
573/*
574 * Bad permissions for sending the signal
David Howellsc69e8d92008-11-14 10:39:19 +1100575 * - the caller must hold at least the RCU read lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 */
577static int check_kill_permission(int sig, struct siginfo *info,
578 struct task_struct *t)
579{
David Howellsc69e8d92008-11-14 10:39:19 +1100580 const struct cred *cred = current_cred(), *tcred;
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700581 struct pid *sid;
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700582 int error;
583
Jesper Juhl7ed20e12005-05-01 08:59:14 -0700584 if (!valid_signal(sig))
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700585 return -EINVAL;
586
587 if (info != SEND_SIG_NOINFO && (is_si_special(info) || SI_FROMKERNEL(info)))
588 return 0;
589
590 error = audit_signal_info(sig, t); /* Let audit system see the signal */
591 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 return error;
Amy Griffise54dc242007-03-29 18:01:04 -0400593
David Howellsc69e8d92008-11-14 10:39:19 +1100594 tcred = __task_cred(t);
595 if ((cred->euid ^ tcred->suid) &&
596 (cred->euid ^ tcred->uid) &&
597 (cred->uid ^ tcred->suid) &&
598 (cred->uid ^ tcred->uid) &&
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700599 !capable(CAP_KILL)) {
600 switch (sig) {
601 case SIGCONT:
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700602 sid = task_session(t);
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700603 /*
604 * We don't return the error if sid == NULL. The
605 * task was unhashed, the caller must notice this.
606 */
607 if (!sid || sid == task_session(current))
608 break;
609 default:
610 return -EPERM;
611 }
612 }
Steve Grubbc2f0c7c2005-05-06 12:38:39 +0100613
Amy Griffise54dc242007-03-29 18:01:04 -0400614 return security_task_kill(t, info, sig, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615}
616
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617/*
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700618 * Handle magic process-wide effects of stop/continue signals. Unlike
619 * the signal actions, these happen immediately at signal-generation
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 * time regardless of blocking, ignoring, or handling. This does the
621 * actual continuing for SIGCONT, but not the actual stopping for stop
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700622 * signals. The process stop is done as a signal action for SIG_DFL.
623 *
624 * Returns true if the signal should be actually delivered, otherwise
625 * it should be dropped.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 */
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700627static int prepare_signal(int sig, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628{
Oleg Nesterovad16a462008-04-30 00:52:46 -0700629 struct signal_struct *signal = p->signal;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 struct task_struct *t;
631
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700632 if (unlikely(signal->flags & SIGNAL_GROUP_EXIT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 /*
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700634 * The process is in the middle of dying, nothing to do.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 */
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700636 } else if (sig_kernel_stop(sig)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 /*
638 * This is a stop signal. Remove SIGCONT from all queues.
639 */
Oleg Nesterovad16a462008-04-30 00:52:46 -0700640 rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 t = p;
642 do {
643 rm_from_queue(sigmask(SIGCONT), &t->pending);
Oleg Nesterovad16a462008-04-30 00:52:46 -0700644 } while_each_thread(p, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 } else if (sig == SIGCONT) {
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700646 unsigned int why;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 /*
648 * Remove all stop signals from all queues,
649 * and wake all threads.
650 */
Oleg Nesterovad16a462008-04-30 00:52:46 -0700651 rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 t = p;
653 do {
654 unsigned int state;
655 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 /*
657 * If there is a handler for SIGCONT, we must make
658 * sure that no thread returns to user mode before
659 * we post the signal, in case it was the only
660 * thread eligible to run the signal handler--then
661 * it must not do anything between resuming and
662 * running the handler. With the TIF_SIGPENDING
663 * flag set, the thread will pause and acquire the
664 * siglock that we hold now and until we've queued
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700665 * the pending signal.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 *
667 * Wake up the stopped thread _after_ setting
668 * TIF_SIGPENDING
669 */
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500670 state = __TASK_STOPPED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
672 set_tsk_thread_flag(t, TIF_SIGPENDING);
673 state |= TASK_INTERRUPTIBLE;
674 }
675 wake_up_state(t, state);
Oleg Nesterovad16a462008-04-30 00:52:46 -0700676 } while_each_thread(p, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700678 /*
679 * Notify the parent with CLD_CONTINUED if we were stopped.
680 *
681 * If we were in the middle of a group stop, we pretend it
682 * was already finished, and then continued. Since SIGCHLD
683 * doesn't queue we report only CLD_STOPPED, as if the next
684 * CLD_CONTINUED was dropped.
685 */
686 why = 0;
Oleg Nesterovad16a462008-04-30 00:52:46 -0700687 if (signal->flags & SIGNAL_STOP_STOPPED)
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700688 why |= SIGNAL_CLD_CONTINUED;
Oleg Nesterovad16a462008-04-30 00:52:46 -0700689 else if (signal->group_stop_count)
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700690 why |= SIGNAL_CLD_STOPPED;
691
692 if (why) {
Oleg Nesterov021e1ae2008-04-30 00:53:00 -0700693 /*
694 * The first thread which returns from finish_stop()
695 * will take ->siglock, notice SIGNAL_CLD_MASK, and
696 * notify its parent. See get_signal_to_deliver().
697 */
Oleg Nesterovad16a462008-04-30 00:52:46 -0700698 signal->flags = why | SIGNAL_STOP_CONTINUED;
699 signal->group_stop_count = 0;
700 signal->group_exit_code = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 } else {
702 /*
703 * We are not stopped, but there could be a stop
704 * signal in the middle of being processed after
705 * being removed from the queue. Clear that too.
706 */
Oleg Nesterovad16a462008-04-30 00:52:46 -0700707 signal->flags &= ~SIGNAL_STOP_DEQUEUED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 }
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700710
711 return !sig_ignored(p, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712}
713
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700714/*
715 * Test if P wants to take SIG. After we've checked all threads with this,
716 * it's equivalent to finding no threads not blocking SIG. Any threads not
717 * blocking SIG were ruled out because they are not running and already
718 * have pending signals. Such threads will dequeue from the shared queue
719 * as soon as they're available, so putting the signal on the shared queue
720 * will be equivalent to sending it to one such thread.
721 */
722static inline int wants_signal(int sig, struct task_struct *p)
723{
724 if (sigismember(&p->blocked, sig))
725 return 0;
726 if (p->flags & PF_EXITING)
727 return 0;
728 if (sig == SIGKILL)
729 return 1;
730 if (task_is_stopped_or_traced(p))
731 return 0;
732 return task_curr(p) || !signal_pending(p);
733}
734
Oleg Nesterov5fcd8352008-04-30 00:52:55 -0700735static void complete_signal(int sig, struct task_struct *p, int group)
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700736{
737 struct signal_struct *signal = p->signal;
738 struct task_struct *t;
739
740 /*
741 * Now find a thread we can wake up to take the signal off the queue.
742 *
743 * If the main thread wants the signal, it gets first crack.
744 * Probably the least surprising to the average bear.
745 */
746 if (wants_signal(sig, p))
747 t = p;
Oleg Nesterov5fcd8352008-04-30 00:52:55 -0700748 else if (!group || thread_group_empty(p))
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700749 /*
750 * There is just one thread and it does not need to be woken.
751 * It will dequeue unblocked signals before it runs again.
752 */
753 return;
754 else {
755 /*
756 * Otherwise try to find a suitable thread.
757 */
758 t = signal->curr_target;
759 while (!wants_signal(sig, t)) {
760 t = next_thread(t);
761 if (t == signal->curr_target)
762 /*
763 * No thread needs to be woken.
764 * Any eligible threads will see
765 * the signal in the queue soon.
766 */
767 return;
768 }
769 signal->curr_target = t;
770 }
771
772 /*
773 * Found a killable thread. If the signal will be fatal,
774 * then start taking the whole group down immediately.
775 */
Oleg Nesterovfae5fa42008-04-30 00:53:03 -0700776 if (sig_fatal(p, sig) &&
777 !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700778 !sigismember(&t->real_blocked, sig) &&
Roland McGrath445a91d2008-07-25 19:45:52 -0700779 (sig == SIGKILL ||
780 !tracehook_consider_fatal_signal(t, sig, SIG_DFL))) {
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700781 /*
782 * This signal will be fatal to the whole group.
783 */
784 if (!sig_kernel_coredump(sig)) {
785 /*
786 * Start a group exit and wake everybody up.
787 * This way we don't have other threads
788 * running and doing things after a slower
789 * thread has the fatal signal pending.
790 */
791 signal->flags = SIGNAL_GROUP_EXIT;
792 signal->group_exit_code = sig;
793 signal->group_stop_count = 0;
794 t = p;
795 do {
796 sigaddset(&t->pending.signal, SIGKILL);
797 signal_wake_up(t, 1);
798 } while_each_thread(p, t);
799 return;
800 }
801 }
802
803 /*
804 * The signal is already in the shared-pending queue.
805 * Tell the chosen thread to wake up and dequeue it.
806 */
807 signal_wake_up(t, sig == SIGKILL);
808 return;
809}
810
Pavel Emelyanovaf7fff92008-04-30 00:52:34 -0700811static inline int legacy_queue(struct sigpending *signals, int sig)
812{
813 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
814}
815
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700817 int group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818{
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700819 struct sigpending *pending;
Oleg Nesterov6e65acb2008-04-30 00:52:50 -0700820 struct sigqueue *q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821
Mathieu Desnoyers0a16b602008-07-18 12:16:17 -0400822 trace_sched_signal_send(sig, t);
823
Oleg Nesterov6e65acb2008-04-30 00:52:50 -0700824 assert_spin_locked(&t->sighand->siglock);
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700825 if (!prepare_signal(sig, t))
826 return 0;
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700827
828 pending = group ? &t->signal->shared_pending : &t->pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 /*
Pavel Emelyanov2acb0242008-04-30 00:52:35 -0700830 * Short-circuit ignored signals and support queuing
831 * exactly one non-rt signal, so that we can get more
832 * detailed information about the cause of the signal.
833 */
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700834 if (legacy_queue(pending, sig))
Pavel Emelyanov2acb0242008-04-30 00:52:35 -0700835 return 0;
Davide Libenzifba2afa2007-05-10 22:23:13 -0700836 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 * fast-pathed signals for kernel-internal things like SIGSTOP
838 * or SIGKILL.
839 */
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800840 if (info == SEND_SIG_FORCED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 goto out_set;
842
843 /* Real-time signals must be queued if sent by sigqueue, or
844 some other real-time mechanism. It is implementation
845 defined whether kill() does so. We attempt to do so, on
846 the principle of least surprise, but since kill is not
847 allowed to fail with EAGAIN when low on memory we just
848 make sure at least one signal gets delivered and don't
849 pass on the info struct. */
850
851 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
Oleg Nesterov621d3122005-10-30 15:03:45 -0800852 (is_si_special(info) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 info->si_code >= 0)));
854 if (q) {
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700855 list_add_tail(&q->list, &pending->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 switch ((unsigned long) info) {
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800857 case (unsigned long) SEND_SIG_NOINFO:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 q->info.si_signo = sig;
859 q->info.si_errno = 0;
860 q->info.si_code = SI_USER;
Sukadev Bhattiprolu9cd4fd12009-01-06 14:42:46 -0800861 q->info.si_pid = task_tgid_nr_ns(current,
Sukadev Bhattiprolu09bca052009-01-06 14:42:45 -0800862 task_active_pid_ns(t));
David Howells76aac0e2008-11-14 10:39:12 +1100863 q->info.si_uid = current_uid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 break;
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800865 case (unsigned long) SEND_SIG_PRIV:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 q->info.si_signo = sig;
867 q->info.si_errno = 0;
868 q->info.si_code = SI_KERNEL;
869 q->info.si_pid = 0;
870 q->info.si_uid = 0;
871 break;
872 default:
873 copy_siginfo(&q->info, info);
874 break;
875 }
Oleg Nesterov621d3122005-10-30 15:03:45 -0800876 } else if (!is_si_special(info)) {
877 if (sig >= SIGRTMIN && info->si_code != SI_USER)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 /*
879 * Queue overflow, abort. We may abort if the signal was rt
880 * and sent by user using something other than kill().
881 */
882 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 }
884
885out_set:
Oleg Nesterov53c30332008-04-30 00:53:00 -0700886 signalfd_notify(t, sig);
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700887 sigaddset(&pending->signal, sig);
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -0700888 complete_signal(sig, t, group);
889 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890}
891
Ingo Molnar45807a12007-07-15 23:40:10 -0700892int print_fatal_signals;
893
894static void print_fatal_signal(struct pt_regs *regs, int signr)
895{
896 printk("%s/%d: potentially unexpected fatal signal %d.\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -0700897 current->comm, task_pid_nr(current), signr);
Ingo Molnar45807a12007-07-15 23:40:10 -0700898
Al Viroca5cd872007-10-29 04:31:16 +0000899#if defined(__i386__) && !defined(__arch_um__)
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100900 printk("code at %08lx: ", regs->ip);
Ingo Molnar45807a12007-07-15 23:40:10 -0700901 {
902 int i;
903 for (i = 0; i < 16; i++) {
904 unsigned char insn;
905
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100906 __get_user(insn, (unsigned char *)(regs->ip + i));
Ingo Molnar45807a12007-07-15 23:40:10 -0700907 printk("%02x ", insn);
908 }
909 }
910#endif
911 printk("\n");
Ed Swierk3a9f84d2009-01-26 15:33:31 -0800912 preempt_disable();
Ingo Molnar45807a12007-07-15 23:40:10 -0700913 show_regs(regs);
Ed Swierk3a9f84d2009-01-26 15:33:31 -0800914 preempt_enable();
Ingo Molnar45807a12007-07-15 23:40:10 -0700915}
916
917static int __init setup_print_fatal_signals(char *str)
918{
919 get_option (&str, &print_fatal_signals);
920
921 return 1;
922}
923
924__setup("print-fatal-signals=", setup_print_fatal_signals);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -0700926int
927__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
928{
929 return send_signal(sig, info, p, 1);
930}
931
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932static int
933specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
934{
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -0700935 return send_signal(sig, info, t, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936}
937
938/*
939 * Force a signal that the process can't ignore: if necessary
940 * we unblock the signal and change any SIG_IGN to SIG_DFL.
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700941 *
942 * Note: If we unblock the signal, we always reset it to SIG_DFL,
943 * since we do not want to have a signal handler that was blocked
944 * be invoked when user space had explicitly blocked it.
945 *
Oleg Nesterov80fe7282008-04-30 00:53:05 -0700946 * We don't want to have recursive SIGSEGV's etc, for example,
947 * that is why we also clear SIGNAL_UNKILLABLE.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949int
950force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
951{
952 unsigned long int flags;
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700953 int ret, blocked, ignored;
954 struct k_sigaction *action;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955
956 spin_lock_irqsave(&t->sighand->siglock, flags);
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700957 action = &t->sighand->action[sig-1];
958 ignored = action->sa.sa_handler == SIG_IGN;
959 blocked = sigismember(&t->blocked, sig);
960 if (blocked || ignored) {
961 action->sa.sa_handler = SIG_DFL;
962 if (blocked) {
963 sigdelset(&t->blocked, sig);
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700964 recalc_sigpending_and_wake(t);
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700965 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 }
Oleg Nesterov80fe7282008-04-30 00:53:05 -0700967 if (action->sa.sa_handler == SIG_DFL)
968 t->signal->flags &= ~SIGNAL_UNKILLABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 ret = specific_send_sig_info(sig, info, t);
970 spin_unlock_irqrestore(&t->sighand->siglock, flags);
971
972 return ret;
973}
974
975void
976force_sig_specific(int sig, struct task_struct *t)
977{
Paul E. McKenneyb0423a02005-10-30 15:03:46 -0800978 force_sig_info(sig, SEND_SIG_FORCED, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979}
980
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981/*
982 * Nuke all other threads in the group.
983 */
984void zap_other_threads(struct task_struct *p)
985{
986 struct task_struct *t;
987
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 p->signal->group_stop_count = 0;
989
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 for (t = next_thread(p); t != p; t = next_thread(t)) {
991 /*
992 * Don't bother with already dead threads
993 */
994 if (t->exit_state)
995 continue;
996
Andrea Arcangeli30e0fca2005-10-30 15:02:38 -0800997 /* SIGKILL will be handled before any pending SIGSTOP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 sigaddset(&t->pending.signal, SIGKILL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 signal_wake_up(t, 1);
1000 }
1001}
1002
Harvey Harrisonb5606c22008-02-13 15:03:16 -08001003int __fatal_signal_pending(struct task_struct *tsk)
Matthew Wilcoxf776d122007-12-06 11:15:50 -05001004{
1005 return sigismember(&tsk->pending.signal, SIGKILL);
1006}
Trond Myklebust13f09b92008-01-31 20:40:29 -05001007EXPORT_SYMBOL(__fatal_signal_pending);
Matthew Wilcoxf776d122007-12-06 11:15:50 -05001008
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001009struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
1010{
1011 struct sighand_struct *sighand;
1012
Oleg Nesterov1406f2d2008-04-30 00:52:37 -07001013 rcu_read_lock();
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001014 for (;;) {
1015 sighand = rcu_dereference(tsk->sighand);
1016 if (unlikely(sighand == NULL))
1017 break;
1018
1019 spin_lock_irqsave(&sighand->siglock, *flags);
1020 if (likely(sighand == tsk->sighand))
1021 break;
1022 spin_unlock_irqrestore(&sighand->siglock, *flags);
1023 }
Oleg Nesterov1406f2d2008-04-30 00:52:37 -07001024 rcu_read_unlock();
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001025
1026 return sighand;
1027}
1028
David Howellsc69e8d92008-11-14 10:39:19 +11001029/*
1030 * send signal info to all the members of a group
1031 * - the caller must hold the RCU read lock at least
1032 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1034{
1035 unsigned long flags;
1036 int ret;
1037
1038 ret = check_kill_permission(sig, info, p);
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001039
1040 if (!ret && sig) {
1041 ret = -ESRCH;
1042 if (lock_task_sighand(p, &flags)) {
1043 ret = __group_send_sig_info(sig, info, p);
1044 unlock_task_sighand(p, &flags);
Ingo Molnare56d0902006-01-08 01:01:37 -08001045 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 }
1047
1048 return ret;
1049}
1050
1051/*
Pavel Emelyanov146a5052008-02-08 04:19:22 -08001052 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 * control characters do (^C, ^Z etc)
David Howellsc69e8d92008-11-14 10:39:19 +11001054 * - the caller must hold at least a readlock on tasklist_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 */
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001056int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057{
1058 struct task_struct *p = NULL;
1059 int retval, success;
1060
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 success = 0;
1062 retval = -ESRCH;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001063 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 int err = group_send_sig_info(sig, info, p);
1065 success |= !err;
1066 retval = err;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001067 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 return success ? 0 : retval;
1069}
1070
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001071int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072{
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001073 int error = -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 struct task_struct *p;
1075
Ingo Molnare56d0902006-01-08 01:01:37 -08001076 rcu_read_lock();
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001077retry:
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001078 p = pid_task(pid, PIDTYPE_PID);
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001079 if (p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 error = group_send_sig_info(sig, info, p);
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001081 if (unlikely(error == -ESRCH))
1082 /*
1083 * The task was unhashed in between, try again.
1084 * If it is dead, pid_task() will return NULL,
1085 * if we race with de_thread() it will find the
1086 * new leader.
1087 */
1088 goto retry;
1089 }
Ingo Molnare56d0902006-01-08 01:01:37 -08001090 rcu_read_unlock();
Oleg Nesterov6ca25b52008-04-30 00:52:45 -07001091
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 return error;
1093}
1094
Matthew Wilcoxc3de4b32007-02-09 08:11:47 -07001095int
1096kill_proc_info(int sig, struct siginfo *info, pid_t pid)
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001097{
1098 int error;
1099 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001100 error = kill_pid_info(sig, info, find_vpid(pid));
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001101 rcu_read_unlock();
1102 return error;
1103}
1104
Eric W. Biederman2425c082006-10-02 02:17:28 -07001105/* like kill_pid_info(), but doesn't use uid/euid of "current" */
1106int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
David Quigley8f95dc52006-06-30 01:55:47 -07001107 uid_t uid, uid_t euid, u32 secid)
Harald Welte46113832005-10-10 19:44:29 +02001108{
1109 int ret = -EINVAL;
1110 struct task_struct *p;
David Howellsc69e8d92008-11-14 10:39:19 +11001111 const struct cred *pcred;
Harald Welte46113832005-10-10 19:44:29 +02001112
1113 if (!valid_signal(sig))
1114 return ret;
1115
1116 read_lock(&tasklist_lock);
Eric W. Biederman2425c082006-10-02 02:17:28 -07001117 p = pid_task(pid, PIDTYPE_PID);
Harald Welte46113832005-10-10 19:44:29 +02001118 if (!p) {
1119 ret = -ESRCH;
1120 goto out_unlock;
1121 }
David Howellsc69e8d92008-11-14 10:39:19 +11001122 pcred = __task_cred(p);
1123 if ((info == SEND_SIG_NOINFO ||
1124 (!is_si_special(info) && SI_FROMUSER(info))) &&
1125 euid != pcred->suid && euid != pcred->uid &&
1126 uid != pcred->suid && uid != pcred->uid) {
Harald Welte46113832005-10-10 19:44:29 +02001127 ret = -EPERM;
1128 goto out_unlock;
1129 }
David Quigley8f95dc52006-06-30 01:55:47 -07001130 ret = security_task_kill(p, info, sig, secid);
1131 if (ret)
1132 goto out_unlock;
Harald Welte46113832005-10-10 19:44:29 +02001133 if (sig && p->sighand) {
1134 unsigned long flags;
1135 spin_lock_irqsave(&p->sighand->siglock, flags);
1136 ret = __group_send_sig_info(sig, info, p);
1137 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1138 }
1139out_unlock:
1140 read_unlock(&tasklist_lock);
1141 return ret;
1142}
Eric W. Biederman2425c082006-10-02 02:17:28 -07001143EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
1145/*
1146 * kill_something_info() interprets pid in interesting ways just like kill(2).
1147 *
1148 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1149 * is probably wrong. Should make it like BSD or SYSV.
1150 */
1151
Gustavo Fernando Padovanbc64efd2008-07-25 01:47:33 -07001152static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153{
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001154 int ret;
Pavel Emelyanovd5df7632008-02-08 04:19:22 -08001155
1156 if (pid > 0) {
1157 rcu_read_lock();
1158 ret = kill_pid_info(sig, info, find_vpid(pid));
1159 rcu_read_unlock();
1160 return ret;
1161 }
1162
1163 read_lock(&tasklist_lock);
1164 if (pid != -1) {
1165 ret = __kill_pgrp_info(sig, info,
1166 pid ? find_vpid(-pid) : task_pgrp(current));
1167 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 int retval = 0, count = 0;
1169 struct task_struct * p;
1170
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 for_each_process(p) {
Sukadev Bhattiprolud25141a2008-10-29 14:01:11 -07001172 if (task_pid_vnr(p) > 1 &&
1173 !same_thread_group(p, current)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 int err = group_send_sig_info(sig, info, p);
1175 ++count;
1176 if (err != -EPERM)
1177 retval = err;
1178 }
1179 }
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001180 ret = count ? retval : -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 }
Pavel Emelyanovd5df7632008-02-08 04:19:22 -08001182 read_unlock(&tasklist_lock);
1183
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001184 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185}
1186
1187/*
1188 * These are for backward compatibility with the rest of the kernel source.
1189 */
1190
1191/*
Oleg Nesterov08d2c302008-04-30 00:52:51 -07001192 * The caller must ensure the task can't exit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 */
1194int
1195send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1196{
1197 int ret;
1198 unsigned long flags;
1199
1200 /*
1201 * Make sure legacy kernel users don't send in bad values
1202 * (normal paths check this in check_kill_permission).
1203 */
Jesper Juhl7ed20e12005-05-01 08:59:14 -07001204 if (!valid_signal(sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 return -EINVAL;
1206
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 spin_lock_irqsave(&p->sighand->siglock, flags);
1208 ret = specific_send_sig_info(sig, info, p);
1209 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 return ret;
1211}
1212
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001213#define __si_special(priv) \
1214 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1215
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216int
1217send_sig(int sig, struct task_struct *p, int priv)
1218{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001219 return send_sig_info(sig, __si_special(priv), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220}
1221
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222void
1223force_sig(int sig, struct task_struct *p)
1224{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001225 force_sig_info(sig, SEND_SIG_PRIV, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226}
1227
1228/*
1229 * When things go south during signal handling, we
1230 * will force a SIGSEGV. And if the signal that caused
1231 * the problem was already a SIGSEGV, we'll want to
1232 * make sure we don't even try to deliver the signal..
1233 */
1234int
1235force_sigsegv(int sig, struct task_struct *p)
1236{
1237 if (sig == SIGSEGV) {
1238 unsigned long flags;
1239 spin_lock_irqsave(&p->sighand->siglock, flags);
1240 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1241 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1242 }
1243 force_sig(SIGSEGV, p);
1244 return 0;
1245}
1246
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001247int kill_pgrp(struct pid *pid, int sig, int priv)
1248{
Pavel Emelyanov146a5052008-02-08 04:19:22 -08001249 int ret;
1250
1251 read_lock(&tasklist_lock);
1252 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1253 read_unlock(&tasklist_lock);
1254
1255 return ret;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001256}
1257EXPORT_SYMBOL(kill_pgrp);
1258
1259int kill_pid(struct pid *pid, int sig, int priv)
1260{
1261 return kill_pid_info(sig, __si_special(priv), pid);
1262}
1263EXPORT_SYMBOL(kill_pid);
1264
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265/*
1266 * These functions support sending signals using preallocated sigqueue
1267 * structures. This is needed "because realtime applications cannot
1268 * afford to lose notifications of asynchronous events, like timer
1269 * expirations or I/O completions". In the case of Posix Timers
1270 * we allocate the sigqueue structure from the timer_create. If this
1271 * allocation fails we are able to report the failure to the application
1272 * with an EAGAIN error.
1273 */
1274
1275struct sigqueue *sigqueue_alloc(void)
1276{
1277 struct sigqueue *q;
1278
1279 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1280 q->flags |= SIGQUEUE_PREALLOC;
1281 return(q);
1282}
1283
1284void sigqueue_free(struct sigqueue *q)
1285{
1286 unsigned long flags;
Oleg Nesterov60187d22007-08-30 23:56:35 -07001287 spinlock_t *lock = &current->sighand->siglock;
1288
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1290 /*
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001291 * We must hold ->siglock while testing q->list
1292 * to serialize with collect_signal() or with
Oleg Nesterovda7978b2008-05-23 13:04:41 -07001293 * __exit_signal()->flush_sigqueue().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 */
Oleg Nesterov60187d22007-08-30 23:56:35 -07001295 spin_lock_irqsave(lock, flags);
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001296 q->flags &= ~SIGQUEUE_PREALLOC;
1297 /*
1298 * If it is queued it will be freed when dequeued,
1299 * like the "regular" sigqueue.
1300 */
Oleg Nesterov60187d22007-08-30 23:56:35 -07001301 if (!list_empty(&q->list))
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001302 q = NULL;
Oleg Nesterov60187d22007-08-30 23:56:35 -07001303 spin_unlock_irqrestore(lock, flags);
1304
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001305 if (q)
1306 __sigqueue_free(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307}
1308
Oleg Nesterovac5c2152008-04-30 00:52:57 -07001309int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001310{
Oleg Nesterove62e6652008-04-30 00:52:56 -07001311 int sig = q->info.si_signo;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001312 struct sigpending *pending;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001313 unsigned long flags;
1314 int ret;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001315
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001316 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
Oleg Nesterove62e6652008-04-30 00:52:56 -07001317
1318 ret = -1;
1319 if (!likely(lock_task_sighand(t, &flags)))
1320 goto ret;
1321
Oleg Nesterov7e695a52008-04-30 00:52:59 -07001322 ret = 1; /* the signal is ignored */
1323 if (!prepare_signal(sig, t))
Oleg Nesterove62e6652008-04-30 00:52:56 -07001324 goto out;
1325
1326 ret = 0;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001327 if (unlikely(!list_empty(&q->list))) {
1328 /*
1329 * If an SI_TIMER entry is already queue just increment
1330 * the overrun count.
1331 */
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001332 BUG_ON(q->info.si_code != SI_TIMER);
1333 q->info.si_overrun++;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001334 goto out;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001335 }
Oleg Nesterovba661292008-07-23 20:52:05 +04001336 q->info.si_overrun = 0;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001337
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001338 signalfd_notify(t, sig);
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001339 pending = group ? &t->signal->shared_pending : &t->pending;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001340 list_add_tail(&q->list, &pending->list);
1341 sigaddset(&pending->signal, sig);
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001342 complete_signal(sig, t, group);
Oleg Nesterove62e6652008-04-30 00:52:56 -07001343out:
1344 unlock_task_sighand(t, &flags);
1345ret:
1346 return ret;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001347}
1348
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349/*
1350 * Wake up any threads in the parent blocked in wait* syscalls.
1351 */
1352static inline void __wake_up_parent(struct task_struct *p,
1353 struct task_struct *parent)
1354{
1355 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1356}
1357
1358/*
1359 * Let a parent know about the death of a child.
1360 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
Roland McGrath2b2a1ff2008-07-25 19:45:54 -07001361 *
1362 * Returns -1 if our parent ignored us and so we've switched to
1363 * self-reaping, or else @sig.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 */
Roland McGrath2b2a1ff2008-07-25 19:45:54 -07001365int do_notify_parent(struct task_struct *tsk, int sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366{
1367 struct siginfo info;
1368 unsigned long flags;
1369 struct sighand_struct *psig;
Roland McGrath1b046242008-08-19 20:37:07 -07001370 int ret = sig;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371
1372 BUG_ON(sig == -1);
1373
1374 /* do_notify_parent_cldstop should have been called instead. */
Matthew Wilcoxe1abb392007-12-06 11:07:35 -05001375 BUG_ON(task_is_stopped_or_traced(tsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
1377 BUG_ON(!tsk->ptrace &&
1378 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1379
1380 info.si_signo = sig;
1381 info.si_errno = 0;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001382 /*
1383 * we are under tasklist_lock here so our parent is tied to
1384 * us and cannot exit and release its namespace.
1385 *
1386 * the only it can is to switch its nsproxy with sys_unshare,
1387 * bu uncharing pid namespaces is not allowed, so we'll always
1388 * see relevant namespace
1389 *
1390 * write_lock() currently calls preempt_disable() which is the
1391 * same as rcu_read_lock(), but according to Oleg, this is not
1392 * correct to rely on this
1393 */
1394 rcu_read_lock();
1395 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
David Howellsc69e8d92008-11-14 10:39:19 +11001396 info.si_uid = __task_cred(tsk)->uid;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001397 rcu_read_unlock();
1398
Peter Zijlstra32bd6712009-02-05 12:24:15 +01001399 info.si_utime = cputime_to_clock_t(cputime_add(tsk->utime,
1400 tsk->signal->utime));
1401 info.si_stime = cputime_to_clock_t(cputime_add(tsk->stime,
1402 tsk->signal->stime));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403
1404 info.si_status = tsk->exit_code & 0x7f;
1405 if (tsk->exit_code & 0x80)
1406 info.si_code = CLD_DUMPED;
1407 else if (tsk->exit_code & 0x7f)
1408 info.si_code = CLD_KILLED;
1409 else {
1410 info.si_code = CLD_EXITED;
1411 info.si_status = tsk->exit_code >> 8;
1412 }
1413
1414 psig = tsk->parent->sighand;
1415 spin_lock_irqsave(&psig->siglock, flags);
Oleg Nesterov7ed01752005-11-10 17:22:18 +03001416 if (!tsk->ptrace && sig == SIGCHLD &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1418 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1419 /*
1420 * We are exiting and our parent doesn't care. POSIX.1
1421 * defines special semantics for setting SIGCHLD to SIG_IGN
1422 * or setting the SA_NOCLDWAIT flag: we should be reaped
1423 * automatically and not left for our parent's wait4 call.
1424 * Rather than having the parent do it as a magic kind of
1425 * signal handler, we just set this to tell do_exit that we
1426 * can be cleaned up without becoming a zombie. Note that
1427 * we still call __wake_up_parent in this case, because a
1428 * blocked sys_wait4 might now return -ECHILD.
1429 *
1430 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1431 * is implementation-defined: we do (if you don't want
1432 * it, just use SIG_IGN instead).
1433 */
Roland McGrath1b046242008-08-19 20:37:07 -07001434 ret = tsk->exit_signal = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
Roland McGrath2b2a1ff2008-07-25 19:45:54 -07001436 sig = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 }
Jesper Juhl7ed20e12005-05-01 08:59:14 -07001438 if (valid_signal(sig) && sig > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 __group_send_sig_info(sig, &info, tsk->parent);
1440 __wake_up_parent(tsk, tsk->parent);
1441 spin_unlock_irqrestore(&psig->siglock, flags);
Roland McGrath2b2a1ff2008-07-25 19:45:54 -07001442
Roland McGrath1b046242008-08-19 20:37:07 -07001443 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444}
1445
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001446static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447{
1448 struct siginfo info;
1449 unsigned long flags;
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001450 struct task_struct *parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451 struct sighand_struct *sighand;
1452
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001453 if (tsk->ptrace & PT_PTRACED)
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001454 parent = tsk->parent;
1455 else {
1456 tsk = tsk->group_leader;
1457 parent = tsk->real_parent;
1458 }
1459
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 info.si_signo = SIGCHLD;
1461 info.si_errno = 0;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001462 /*
1463 * see comment in do_notify_parent() abot the following 3 lines
1464 */
1465 rcu_read_lock();
1466 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
David Howellsc69e8d92008-11-14 10:39:19 +11001467 info.si_uid = __task_cred(tsk)->uid;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001468 rcu_read_unlock();
1469
Michael Kerriskd8878ba2008-07-25 01:47:32 -07001470 info.si_utime = cputime_to_clock_t(tsk->utime);
1471 info.si_stime = cputime_to_clock_t(tsk->stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
1473 info.si_code = why;
1474 switch (why) {
1475 case CLD_CONTINUED:
1476 info.si_status = SIGCONT;
1477 break;
1478 case CLD_STOPPED:
1479 info.si_status = tsk->signal->group_exit_code & 0x7f;
1480 break;
1481 case CLD_TRAPPED:
1482 info.si_status = tsk->exit_code & 0x7f;
1483 break;
1484 default:
1485 BUG();
1486 }
1487
1488 sighand = parent->sighand;
1489 spin_lock_irqsave(&sighand->siglock, flags);
1490 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1491 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1492 __group_send_sig_info(SIGCHLD, &info, parent);
1493 /*
1494 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1495 */
1496 __wake_up_parent(tsk, parent);
1497 spin_unlock_irqrestore(&sighand->siglock, flags);
1498}
1499
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001500static inline int may_ptrace_stop(void)
1501{
1502 if (!likely(current->ptrace & PT_PTRACED))
1503 return 0;
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001504 /*
1505 * Are we in the middle of do_coredump?
1506 * If so and our tracer is also part of the coredump stopping
1507 * is a deadlock situation, and pointless because our tracer
1508 * is dead so don't allow us to stop.
1509 * If SIGKILL was already sent before the caller unlocked
Oleg Nesterov999d9fc2008-07-25 01:47:41 -07001510 * ->siglock we must see ->core_state != NULL. Otherwise it
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001511 * is safe to enter schedule().
1512 */
Oleg Nesterov999d9fc2008-07-25 01:47:41 -07001513 if (unlikely(current->mm->core_state) &&
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001514 unlikely(current->mm == current->parent->mm))
1515 return 0;
1516
1517 return 1;
1518}
1519
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520/*
Roland McGrath1a669c22008-02-06 01:37:37 -08001521 * Return nonzero if there is a SIGKILL that should be waking us up.
1522 * Called with the siglock held.
1523 */
1524static int sigkill_pending(struct task_struct *tsk)
1525{
Oleg Nesterov3d749b92008-07-25 01:47:37 -07001526 return sigismember(&tsk->pending.signal, SIGKILL) ||
1527 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
Roland McGrath1a669c22008-02-06 01:37:37 -08001528}
1529
1530/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 * This must be called with current->sighand->siglock held.
1532 *
1533 * This should be the path for all ptrace stops.
1534 * We always set current->last_siginfo while stopped here.
1535 * That makes it a way to test a stopped process for
1536 * being ptrace-stopped vs being job-control-stopped.
1537 *
Oleg Nesterov20686a32008-02-08 04:19:03 -08001538 * If we actually decide not to stop at all because the tracer
1539 * is gone, we keep current->exit_code unless clear_code.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 */
Oleg Nesterov20686a32008-02-08 04:19:03 -08001541static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542{
Roland McGrath1a669c22008-02-06 01:37:37 -08001543 if (arch_ptrace_stop_needed(exit_code, info)) {
1544 /*
1545 * The arch code has something special to do before a
1546 * ptrace stop. This is allowed to block, e.g. for faults
1547 * on user stack pages. We can't keep the siglock while
1548 * calling arch_ptrace_stop, so we must release it now.
1549 * To preserve proper semantics, we must do this before
1550 * any signal bookkeeping like checking group_stop_count.
1551 * Meanwhile, a SIGKILL could come in before we retake the
1552 * siglock. That must prevent us from sleeping in TASK_TRACED.
1553 * So after regaining the lock, we must check for SIGKILL.
1554 */
1555 spin_unlock_irq(&current->sighand->siglock);
1556 arch_ptrace_stop(exit_code, info);
1557 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterov3d749b92008-07-25 01:47:37 -07001558 if (sigkill_pending(current))
1559 return;
Roland McGrath1a669c22008-02-06 01:37:37 -08001560 }
1561
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 /*
1563 * If there is a group stop in progress,
1564 * we must participate in the bookkeeping.
1565 */
1566 if (current->signal->group_stop_count > 0)
1567 --current->signal->group_stop_count;
1568
1569 current->last_siginfo = info;
1570 current->exit_code = exit_code;
1571
1572 /* Let the debugger run. */
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -08001573 __set_current_state(TASK_TRACED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 spin_unlock_irq(&current->sighand->siglock);
1575 read_lock(&tasklist_lock);
Oleg Nesterov3d749b92008-07-25 01:47:37 -07001576 if (may_ptrace_stop()) {
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001577 do_notify_parent_cldstop(current, CLD_TRAPPED);
Miklos Szeredi53da1d92009-03-23 16:07:24 +01001578 /*
1579 * Don't want to allow preemption here, because
1580 * sys_ptrace() needs this task to be inactive.
1581 *
1582 * XXX: implement read_unlock_no_resched().
1583 */
1584 preempt_disable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 read_unlock(&tasklist_lock);
Miklos Szeredi53da1d92009-03-23 16:07:24 +01001586 preempt_enable_no_resched();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 schedule();
1588 } else {
1589 /*
1590 * By the time we got the lock, our tracer went away.
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001591 * Don't drop the lock yet, another tracer may come.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 */
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001593 __set_current_state(TASK_RUNNING);
Oleg Nesterov20686a32008-02-08 04:19:03 -08001594 if (clear_code)
1595 current->exit_code = 0;
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001596 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 }
1598
1599 /*
Roland McGrath13b1c3d2008-03-03 20:22:05 -08001600 * While in TASK_TRACED, we were considered "frozen enough".
1601 * Now that we woke up, it's crucial if we're supposed to be
1602 * frozen that we freeze now before running anything substantial.
1603 */
1604 try_to_freeze();
1605
1606 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 * We are back. Now reacquire the siglock before touching
1608 * last_siginfo, so that we are sure to have synchronized with
1609 * any signal-sending on another CPU that wants to examine it.
1610 */
1611 spin_lock_irq(&current->sighand->siglock);
1612 current->last_siginfo = NULL;
1613
1614 /*
1615 * Queued signals ignored us while we were stopped for tracing.
1616 * So check for any that we should take before resuming user mode.
Roland McGrathb74d0de2007-06-06 03:59:00 -07001617 * This sets TIF_SIGPENDING, but never clears it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 */
Roland McGrathb74d0de2007-06-06 03:59:00 -07001619 recalc_sigpending_tsk(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620}
1621
1622void ptrace_notify(int exit_code)
1623{
1624 siginfo_t info;
1625
1626 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1627
1628 memset(&info, 0, sizeof info);
1629 info.si_signo = SIGTRAP;
1630 info.si_code = exit_code;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001631 info.si_pid = task_pid_vnr(current);
David Howells76aac0e2008-11-14 10:39:12 +11001632 info.si_uid = current_uid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633
1634 /* Let the debugger run. */
1635 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterov20686a32008-02-08 04:19:03 -08001636 ptrace_stop(exit_code, 1, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 spin_unlock_irq(&current->sighand->siglock);
1638}
1639
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640static void
1641finish_stop(int stop_count)
1642{
1643 /*
1644 * If there are no other threads in the group, or if there is
1645 * a group stop in progress and we are the last to stop,
1646 * report to the parent. When ptraced, every thread reports itself.
1647 */
Roland McGrathfa00b802008-07-25 19:45:54 -07001648 if (tracehook_notify_jctl(stop_count == 0, CLD_STOPPED)) {
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001649 read_lock(&tasklist_lock);
1650 do_notify_parent_cldstop(current, CLD_STOPPED);
1651 read_unlock(&tasklist_lock);
1652 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
Rafael J. Wysocki3df494a2006-12-13 00:34:28 -08001654 do {
1655 schedule();
1656 } while (try_to_freeze());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 /*
1658 * Now we don't run again until continued.
1659 */
1660 current->exit_code = 0;
1661}
1662
1663/*
1664 * This performs the stopping for SIGSTOP and other stop signals.
1665 * We have to stop all threads in the thread group.
1666 * Returns nonzero if we've actually stopped and released the siglock.
1667 * Returns zero if we didn't stop and still hold the siglock.
1668 */
Oleg Nesterova122b342006-03-28 16:11:22 -08001669static int do_signal_stop(int signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670{
1671 struct signal_struct *sig = current->signal;
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001672 int stop_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 if (sig->group_stop_count > 0) {
1675 /*
1676 * There is a group stop in progress. We don't need to
1677 * start another one.
1678 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 stop_count = --sig->group_stop_count;
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001680 } else {
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08001681 struct task_struct *t;
1682
Oleg Nesterov2b201a92008-07-25 01:47:31 -07001683 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED) ||
Oleg Nesterov573cf9a2008-04-30 00:52:36 -07001684 unlikely(signal_group_exit(sig)))
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08001685 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 * There is no group stop already in progress.
Oleg Nesterova122b342006-03-28 16:11:22 -08001688 * We must initiate one now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 */
Oleg Nesterova122b342006-03-28 16:11:22 -08001690 sig->group_exit_code = signr;
1691
1692 stop_count = 0;
1693 for (t = next_thread(current); t != current; t = next_thread(t))
1694 /*
1695 * Setting state to TASK_STOPPED for a group
1696 * stop is always done with the siglock held,
1697 * so this check has no races.
1698 */
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001699 if (!(t->flags & PF_EXITING) &&
Matthew Wilcoxe1abb392007-12-06 11:07:35 -05001700 !task_is_stopped_or_traced(t)) {
Oleg Nesterova122b342006-03-28 16:11:22 -08001701 stop_count++;
1702 signal_wake_up(t, 0);
1703 }
1704 sig->group_stop_count = stop_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 }
1706
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001707 if (stop_count == 0)
1708 sig->flags = SIGNAL_STOP_STOPPED;
1709 current->exit_code = sig->group_exit_code;
1710 __set_current_state(TASK_STOPPED);
1711
1712 spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 finish_stop(stop_count);
1714 return 1;
1715}
1716
Roland McGrath18c98b62008-04-17 18:44:38 -07001717static int ptrace_signal(int signr, siginfo_t *info,
1718 struct pt_regs *regs, void *cookie)
1719{
1720 if (!(current->ptrace & PT_PTRACED))
1721 return signr;
1722
1723 ptrace_signal_deliver(regs, cookie);
1724
1725 /* Let the debugger run. */
1726 ptrace_stop(signr, 0, info);
1727
1728 /* We're back. Did the debugger cancel the sig? */
1729 signr = current->exit_code;
1730 if (signr == 0)
1731 return signr;
1732
1733 current->exit_code = 0;
1734
1735 /* Update the siginfo structure if the signal has
1736 changed. If the debugger wanted something
1737 specific in the siginfo structure then it should
1738 have updated *info via PTRACE_SETSIGINFO. */
1739 if (signr != info->si_signo) {
1740 info->si_signo = signr;
1741 info->si_errno = 0;
1742 info->si_code = SI_USER;
1743 info->si_pid = task_pid_vnr(current->parent);
David Howellsc69e8d92008-11-14 10:39:19 +11001744 info->si_uid = task_uid(current->parent);
Roland McGrath18c98b62008-04-17 18:44:38 -07001745 }
1746
1747 /* If the (new) signal is now blocked, requeue it. */
1748 if (sigismember(&current->blocked, signr)) {
1749 specific_send_sig_info(signr, info, current);
1750 signr = 0;
1751 }
1752
1753 return signr;
1754}
1755
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1757 struct pt_regs *regs, void *cookie)
1758{
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001759 struct sighand_struct *sighand = current->sighand;
1760 struct signal_struct *signal = current->signal;
1761 int signr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762
Roland McGrath13b1c3d2008-03-03 20:22:05 -08001763relock:
1764 /*
1765 * We'll jump back here after any time we were stopped in TASK_STOPPED.
1766 * While in TASK_STOPPED, we were considered "frozen enough".
1767 * Now that we woke up, it's crucial if we're supposed to be
1768 * frozen that we freeze now before running anything substantial.
1769 */
Rafael J. Wysockifc558a72006-03-23 03:00:05 -08001770 try_to_freeze();
1771
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001772 spin_lock_irq(&sighand->siglock);
Oleg Nesterov021e1ae2008-04-30 00:53:00 -07001773 /*
1774 * Every stopped thread goes here after wakeup. Check to see if
1775 * we should notify the parent, prepare_signal(SIGCONT) encodes
1776 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
1777 */
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001778 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
1779 int why = (signal->flags & SIGNAL_STOP_CONTINUED)
Oleg Nesterove4420552008-04-30 00:52:44 -07001780 ? CLD_CONTINUED : CLD_STOPPED;
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001781 signal->flags &= ~SIGNAL_CLD_MASK;
1782 spin_unlock_irq(&sighand->siglock);
Oleg Nesterove4420552008-04-30 00:52:44 -07001783
Roland McGrathfa00b802008-07-25 19:45:54 -07001784 if (unlikely(!tracehook_notify_jctl(1, why)))
1785 goto relock;
1786
Oleg Nesterove4420552008-04-30 00:52:44 -07001787 read_lock(&tasklist_lock);
1788 do_notify_parent_cldstop(current->group_leader, why);
1789 read_unlock(&tasklist_lock);
1790 goto relock;
1791 }
1792
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 for (;;) {
1794 struct k_sigaction *ka;
1795
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001796 if (unlikely(signal->group_stop_count > 0) &&
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08001797 do_signal_stop(0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 goto relock;
1799
Roland McGrath7bcf6a22008-07-25 19:45:53 -07001800 /*
1801 * Tracing can induce an artifical signal and choose sigaction.
1802 * The return value in @signr determines the default action,
1803 * but @info->si_signo is the signal number we will report.
1804 */
1805 signr = tracehook_get_signal(current, regs, info, return_ka);
1806 if (unlikely(signr < 0))
1807 goto relock;
1808 if (unlikely(signr != 0))
1809 ka = return_ka;
1810 else {
1811 signr = dequeue_signal(current, &current->blocked,
1812 info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813
Roland McGrath18c98b62008-04-17 18:44:38 -07001814 if (!signr)
Roland McGrath7bcf6a22008-07-25 19:45:53 -07001815 break; /* will return 0 */
1816
1817 if (signr != SIGKILL) {
1818 signr = ptrace_signal(signr, info,
1819 regs, cookie);
1820 if (!signr)
1821 continue;
1822 }
1823
1824 ka = &sighand->action[signr-1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 }
1826
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1828 continue;
1829 if (ka->sa.sa_handler != SIG_DFL) {
1830 /* Run the handler. */
1831 *return_ka = *ka;
1832
1833 if (ka->sa.sa_flags & SA_ONESHOT)
1834 ka->sa.sa_handler = SIG_DFL;
1835
1836 break; /* will return non-zero "signr" value */
1837 }
1838
1839 /*
1840 * Now we are doing the default action for this signal.
1841 */
1842 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1843 continue;
1844
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -08001845 /*
Sukadev Bhattiprolu0fbc26a2007-10-18 23:40:13 -07001846 * Global init gets no signals it doesn't want.
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -08001847 */
Oleg Nesterovfae5fa42008-04-30 00:53:03 -07001848 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
1849 !signal_group_exit(signal))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 continue;
1851
1852 if (sig_kernel_stop(signr)) {
1853 /*
1854 * The default action is to stop all threads in
1855 * the thread group. The job control signals
1856 * do nothing in an orphaned pgrp, but SIGSTOP
1857 * always works. Note that siglock needs to be
1858 * dropped during the call to is_orphaned_pgrp()
1859 * because of lock ordering with tasklist_lock.
1860 * This allows an intervening SIGCONT to be posted.
1861 * We need to check for that and bail out if necessary.
1862 */
1863 if (signr != SIGSTOP) {
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001864 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865
1866 /* signals can be posted during this window */
1867
Eric W. Biederman3e7cd6c2007-02-12 00:52:58 -08001868 if (is_current_pgrp_orphaned())
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 goto relock;
1870
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001871 spin_lock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 }
1873
Roland McGrath7bcf6a22008-07-25 19:45:53 -07001874 if (likely(do_signal_stop(info->si_signo))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 /* It released the siglock. */
1876 goto relock;
1877 }
1878
1879 /*
1880 * We didn't actually stop, due to a race
1881 * with SIGCONT or something like that.
1882 */
1883 continue;
1884 }
1885
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001886 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887
1888 /*
1889 * Anything else is fatal, maybe with a core dump.
1890 */
1891 current->flags |= PF_SIGNALED;
Oleg Nesterov2dce81b2008-04-30 00:52:58 -07001892
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 if (sig_kernel_coredump(signr)) {
Oleg Nesterov2dce81b2008-04-30 00:52:58 -07001894 if (print_fatal_signals)
Roland McGrath7bcf6a22008-07-25 19:45:53 -07001895 print_fatal_signal(regs, info->si_signo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 /*
1897 * If it was able to dump core, this kills all
1898 * other threads in the group and synchronizes with
1899 * their demise. If we lost the race with another
1900 * thread getting here, it set group_exit_code
1901 * first and our do_group_exit call below will use
1902 * that value and ignore the one we pass it.
1903 */
Roland McGrath7bcf6a22008-07-25 19:45:53 -07001904 do_coredump(info->si_signo, info->si_signo, regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 }
1906
1907 /*
1908 * Death signals, no core dump.
1909 */
Roland McGrath7bcf6a22008-07-25 19:45:53 -07001910 do_group_exit(info->si_signo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 /* NOTREACHED */
1912 }
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001913 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 return signr;
1915}
1916
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001917void exit_signals(struct task_struct *tsk)
1918{
1919 int group_stop = 0;
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001920 struct task_struct *t;
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001921
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001922 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
1923 tsk->flags |= PF_EXITING;
1924 return;
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001925 }
1926
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001927 spin_lock_irq(&tsk->sighand->siglock);
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001928 /*
1929 * From now this task is not visible for group-wide signals,
1930 * see wants_signal(), do_signal_stop().
1931 */
1932 tsk->flags |= PF_EXITING;
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001933 if (!signal_pending(tsk))
1934 goto out;
1935
1936 /* It could be that __group_complete_signal() choose us to
1937 * notify about group-wide signal. Another thread should be
1938 * woken now to take the signal since we will not.
1939 */
1940 for (t = tsk; (t = next_thread(t)) != tsk; )
1941 if (!signal_pending(t) && !(t->flags & PF_EXITING))
1942 recalc_sigpending_and_wake(t);
1943
1944 if (unlikely(tsk->signal->group_stop_count) &&
1945 !--tsk->signal->group_stop_count) {
1946 tsk->signal->flags = SIGNAL_STOP_STOPPED;
1947 group_stop = 1;
1948 }
1949out:
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001950 spin_unlock_irq(&tsk->sighand->siglock);
1951
Roland McGrathfa00b802008-07-25 19:45:54 -07001952 if (unlikely(group_stop) && tracehook_notify_jctl(1, CLD_STOPPED)) {
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001953 read_lock(&tasklist_lock);
1954 do_notify_parent_cldstop(tsk, CLD_STOPPED);
1955 read_unlock(&tasklist_lock);
1956 }
1957}
1958
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959EXPORT_SYMBOL(recalc_sigpending);
1960EXPORT_SYMBOL_GPL(dequeue_signal);
1961EXPORT_SYMBOL(flush_signals);
1962EXPORT_SYMBOL(force_sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963EXPORT_SYMBOL(send_sig);
1964EXPORT_SYMBOL(send_sig_info);
1965EXPORT_SYMBOL(sigprocmask);
1966EXPORT_SYMBOL(block_all_signals);
1967EXPORT_SYMBOL(unblock_all_signals);
1968
1969
1970/*
1971 * System call entry points.
1972 */
1973
Heiko Carstens754fe8d2009-01-14 14:14:09 +01001974SYSCALL_DEFINE0(restart_syscall)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975{
1976 struct restart_block *restart = &current_thread_info()->restart_block;
1977 return restart->fn(restart);
1978}
1979
1980long do_no_restart_syscall(struct restart_block *param)
1981{
1982 return -EINTR;
1983}
1984
1985/*
1986 * We don't need to get the kernel lock - this is all local to this
1987 * particular thread.. (and that's good, because this is _heavily_
1988 * used by various programs)
1989 */
1990
1991/*
1992 * This is also useful for kernel threads that want to temporarily
1993 * (or permanently) block certain signals.
1994 *
1995 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1996 * interface happily blocks "unblockable" signals like SIGKILL
1997 * and friends.
1998 */
1999int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2000{
2001 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002
2003 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterova26fd332006-03-23 03:00:49 -08002004 if (oldset)
2005 *oldset = current->blocked;
2006
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 error = 0;
2008 switch (how) {
2009 case SIG_BLOCK:
2010 sigorsets(&current->blocked, &current->blocked, set);
2011 break;
2012 case SIG_UNBLOCK:
2013 signandsets(&current->blocked, &current->blocked, set);
2014 break;
2015 case SIG_SETMASK:
2016 current->blocked = *set;
2017 break;
2018 default:
2019 error = -EINVAL;
2020 }
2021 recalc_sigpending();
2022 spin_unlock_irq(&current->sighand->siglock);
Oleg Nesterova26fd332006-03-23 03:00:49 -08002023
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 return error;
2025}
2026
Heiko Carstens17da2bd2009-01-14 14:14:10 +01002027SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, set,
2028 sigset_t __user *, oset, size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029{
2030 int error = -EINVAL;
2031 sigset_t old_set, new_set;
2032
2033 /* XXX: Don't preclude handling different sized sigset_t's. */
2034 if (sigsetsize != sizeof(sigset_t))
2035 goto out;
2036
2037 if (set) {
2038 error = -EFAULT;
2039 if (copy_from_user(&new_set, set, sizeof(*set)))
2040 goto out;
2041 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2042
2043 error = sigprocmask(how, &new_set, &old_set);
2044 if (error)
2045 goto out;
2046 if (oset)
2047 goto set_old;
2048 } else if (oset) {
2049 spin_lock_irq(&current->sighand->siglock);
2050 old_set = current->blocked;
2051 spin_unlock_irq(&current->sighand->siglock);
2052
2053 set_old:
2054 error = -EFAULT;
2055 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2056 goto out;
2057 }
2058 error = 0;
2059out:
2060 return error;
2061}
2062
2063long do_sigpending(void __user *set, unsigned long sigsetsize)
2064{
2065 long error = -EINVAL;
2066 sigset_t pending;
2067
2068 if (sigsetsize > sizeof(sigset_t))
2069 goto out;
2070
2071 spin_lock_irq(&current->sighand->siglock);
2072 sigorsets(&pending, &current->pending.signal,
2073 &current->signal->shared_pending.signal);
2074 spin_unlock_irq(&current->sighand->siglock);
2075
2076 /* Outside the lock because only this thread touches it. */
2077 sigandsets(&pending, &current->blocked, &pending);
2078
2079 error = -EFAULT;
2080 if (!copy_to_user(set, &pending, sigsetsize))
2081 error = 0;
2082
2083out:
2084 return error;
2085}
2086
Heiko Carstens17da2bd2009-01-14 14:14:10 +01002087SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, set, size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088{
2089 return do_sigpending(set, sigsetsize);
2090}
2091
2092#ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2093
2094int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2095{
2096 int err;
2097
2098 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2099 return -EFAULT;
2100 if (from->si_code < 0)
2101 return __copy_to_user(to, from, sizeof(siginfo_t))
2102 ? -EFAULT : 0;
2103 /*
2104 * If you change siginfo_t structure, please be sure
2105 * this code is fixed accordingly.
Davide Libenzifba2afa2007-05-10 22:23:13 -07002106 * Please remember to update the signalfd_copyinfo() function
2107 * inside fs/signalfd.c too, in case siginfo_t changes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108 * It should never copy any pad contained in the structure
2109 * to avoid security leaks, but must copy the generic
2110 * 3 ints plus the relevant union member.
2111 */
2112 err = __put_user(from->si_signo, &to->si_signo);
2113 err |= __put_user(from->si_errno, &to->si_errno);
2114 err |= __put_user((short)from->si_code, &to->si_code);
2115 switch (from->si_code & __SI_MASK) {
2116 case __SI_KILL:
2117 err |= __put_user(from->si_pid, &to->si_pid);
2118 err |= __put_user(from->si_uid, &to->si_uid);
2119 break;
2120 case __SI_TIMER:
2121 err |= __put_user(from->si_tid, &to->si_tid);
2122 err |= __put_user(from->si_overrun, &to->si_overrun);
2123 err |= __put_user(from->si_ptr, &to->si_ptr);
2124 break;
2125 case __SI_POLL:
2126 err |= __put_user(from->si_band, &to->si_band);
2127 err |= __put_user(from->si_fd, &to->si_fd);
2128 break;
2129 case __SI_FAULT:
2130 err |= __put_user(from->si_addr, &to->si_addr);
2131#ifdef __ARCH_SI_TRAPNO
2132 err |= __put_user(from->si_trapno, &to->si_trapno);
2133#endif
2134 break;
2135 case __SI_CHLD:
2136 err |= __put_user(from->si_pid, &to->si_pid);
2137 err |= __put_user(from->si_uid, &to->si_uid);
2138 err |= __put_user(from->si_status, &to->si_status);
2139 err |= __put_user(from->si_utime, &to->si_utime);
2140 err |= __put_user(from->si_stime, &to->si_stime);
2141 break;
2142 case __SI_RT: /* This is not generated by the kernel as of now. */
2143 case __SI_MESGQ: /* But this is */
2144 err |= __put_user(from->si_pid, &to->si_pid);
2145 err |= __put_user(from->si_uid, &to->si_uid);
2146 err |= __put_user(from->si_ptr, &to->si_ptr);
2147 break;
2148 default: /* this is just in case for now ... */
2149 err |= __put_user(from->si_pid, &to->si_pid);
2150 err |= __put_user(from->si_uid, &to->si_uid);
2151 break;
2152 }
2153 return err;
2154}
2155
2156#endif
2157
Heiko Carstens17da2bd2009-01-14 14:14:10 +01002158SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
2159 siginfo_t __user *, uinfo, const struct timespec __user *, uts,
2160 size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161{
2162 int ret, sig;
2163 sigset_t these;
2164 struct timespec ts;
2165 siginfo_t info;
2166 long timeout = 0;
2167
2168 /* XXX: Don't preclude handling different sized sigset_t's. */
2169 if (sigsetsize != sizeof(sigset_t))
2170 return -EINVAL;
2171
2172 if (copy_from_user(&these, uthese, sizeof(these)))
2173 return -EFAULT;
2174
2175 /*
2176 * Invert the set of allowed signals to get those we
2177 * want to block.
2178 */
2179 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2180 signotset(&these);
2181
2182 if (uts) {
2183 if (copy_from_user(&ts, uts, sizeof(ts)))
2184 return -EFAULT;
2185 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2186 || ts.tv_sec < 0)
2187 return -EINVAL;
2188 }
2189
2190 spin_lock_irq(&current->sighand->siglock);
2191 sig = dequeue_signal(current, &these, &info);
2192 if (!sig) {
2193 timeout = MAX_SCHEDULE_TIMEOUT;
2194 if (uts)
2195 timeout = (timespec_to_jiffies(&ts)
2196 + (ts.tv_sec || ts.tv_nsec));
2197
2198 if (timeout) {
2199 /* None ready -- temporarily unblock those we're
2200 * interested while we are sleeping in so that we'll
2201 * be awakened when they arrive. */
2202 current->real_blocked = current->blocked;
2203 sigandsets(&current->blocked, &current->blocked, &these);
2204 recalc_sigpending();
2205 spin_unlock_irq(&current->sighand->siglock);
2206
Nishanth Aravamudan75bcc8c2005-09-10 00:27:24 -07002207 timeout = schedule_timeout_interruptible(timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209 spin_lock_irq(&current->sighand->siglock);
2210 sig = dequeue_signal(current, &these, &info);
2211 current->blocked = current->real_blocked;
2212 siginitset(&current->real_blocked, 0);
2213 recalc_sigpending();
2214 }
2215 }
2216 spin_unlock_irq(&current->sighand->siglock);
2217
2218 if (sig) {
2219 ret = sig;
2220 if (uinfo) {
2221 if (copy_siginfo_to_user(uinfo, &info))
2222 ret = -EFAULT;
2223 }
2224 } else {
2225 ret = -EAGAIN;
2226 if (timeout)
2227 ret = -EINTR;
2228 }
2229
2230 return ret;
2231}
2232
Heiko Carstens17da2bd2009-01-14 14:14:10 +01002233SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234{
2235 struct siginfo info;
2236
2237 info.si_signo = sig;
2238 info.si_errno = 0;
2239 info.si_code = SI_USER;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002240 info.si_pid = task_tgid_vnr(current);
David Howells76aac0e2008-11-14 10:39:12 +11002241 info.si_uid = current_uid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242
2243 return kill_something_info(sig, &info, pid);
2244}
2245
Gustavo Fernando Padovanbc64efd2008-07-25 01:47:33 -07002246static int do_tkill(pid_t tgid, pid_t pid, int sig)
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002247{
2248 int error;
2249 struct siginfo info;
2250 struct task_struct *p;
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002251 unsigned long flags;
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002252
2253 error = -ESRCH;
2254 info.si_signo = sig;
2255 info.si_errno = 0;
2256 info.si_code = SI_TKILL;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002257 info.si_pid = task_tgid_vnr(current);
David Howells76aac0e2008-11-14 10:39:12 +11002258 info.si_uid = current_uid();
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002259
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002260 rcu_read_lock();
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -07002261 p = find_task_by_vpid(pid);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002262 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002263 error = check_kill_permission(sig, &info, p);
2264 /*
2265 * The null signal is a permissions and process existence
2266 * probe. No signal is actually delivered.
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002267 *
2268 * If lock_task_sighand() fails we pretend the task dies
2269 * after receiving the signal. The window is tiny, and the
2270 * signal is private anyway.
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002271 */
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002272 if (!error && sig && lock_task_sighand(p, &flags)) {
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002273 error = specific_send_sig_info(sig, &info, p);
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002274 unlock_task_sighand(p, &flags);
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002275 }
2276 }
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002277 rcu_read_unlock();
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002278
2279 return error;
2280}
2281
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282/**
2283 * sys_tgkill - send signal to one specific thread
2284 * @tgid: the thread group ID of the thread
2285 * @pid: the PID of the thread
2286 * @sig: signal to be sent
2287 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08002288 * This syscall also checks the @tgid and returns -ESRCH even if the PID
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289 * exists but it's not belonging to the target process anymore. This
2290 * method solves the problem of threads exiting and PIDs getting reused.
2291 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01002292SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 /* This is only valid for single tasks */
2295 if (pid <= 0 || tgid <= 0)
2296 return -EINVAL;
2297
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002298 return do_tkill(tgid, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299}
2300
2301/*
2302 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2303 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01002304SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306 /* This is only valid for single tasks */
2307 if (pid <= 0)
2308 return -EINVAL;
2309
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002310 return do_tkill(0, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311}
2312
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01002313SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
2314 siginfo_t __user *, uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315{
2316 siginfo_t info;
2317
2318 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2319 return -EFAULT;
2320
2321 /* Not even root can pretend to send signals from the kernel.
2322 Nor can they impersonate a kill(), which adds source info. */
2323 if (info.si_code >= 0)
2324 return -EPERM;
2325 info.si_signo = sig;
2326
2327 /* POSIX.1b doesn't mention process groups. */
2328 return kill_proc_info(sig, &info, pid);
2329}
2330
Oleg Nesterov88531f72006-03-28 16:11:24 -08002331int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332{
Pavel Emelyanov93585ee2008-04-30 00:52:39 -07002333 struct task_struct *t = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 struct k_sigaction *k;
George Anzinger71fabd52006-01-08 01:02:48 -08002335 sigset_t mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336
Jesper Juhl7ed20e12005-05-01 08:59:14 -07002337 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338 return -EINVAL;
2339
Pavel Emelyanov93585ee2008-04-30 00:52:39 -07002340 k = &t->sighand->action[sig-1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341
2342 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343 if (oact)
2344 *oact = *k;
2345
2346 if (act) {
Oleg Nesterov9ac95f22006-02-09 22:41:50 +03002347 sigdelsetmask(&act->sa.sa_mask,
2348 sigmask(SIGKILL) | sigmask(SIGSTOP));
Oleg Nesterov88531f72006-03-28 16:11:24 -08002349 *k = *act;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350 /*
2351 * POSIX 3.3.1.3:
2352 * "Setting a signal action to SIG_IGN for a signal that is
2353 * pending shall cause the pending signal to be discarded,
2354 * whether or not it is blocked."
2355 *
2356 * "Setting a signal action to SIG_DFL for a signal that is
2357 * pending and whose default action is to ignore the signal
2358 * (for example, SIGCHLD), shall cause the pending signal to
2359 * be discarded, whether or not it is blocked"
2360 */
Roland McGrath35de2542008-07-25 19:45:51 -07002361 if (sig_handler_ignored(sig_handler(t, sig), sig)) {
George Anzinger71fabd52006-01-08 01:02:48 -08002362 sigemptyset(&mask);
2363 sigaddset(&mask, sig);
2364 rm_from_queue_full(&mask, &t->signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365 do {
George Anzinger71fabd52006-01-08 01:02:48 -08002366 rm_from_queue_full(&mask, &t->pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367 t = next_thread(t);
2368 } while (t != current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370 }
2371
2372 spin_unlock_irq(&current->sighand->siglock);
2373 return 0;
2374}
2375
2376int
2377do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2378{
2379 stack_t oss;
2380 int error;
2381
2382 if (uoss) {
2383 oss.ss_sp = (void __user *) current->sas_ss_sp;
2384 oss.ss_size = current->sas_ss_size;
2385 oss.ss_flags = sas_ss_flags(sp);
2386 }
2387
2388 if (uss) {
2389 void __user *ss_sp;
2390 size_t ss_size;
2391 int ss_flags;
2392
2393 error = -EFAULT;
2394 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2395 || __get_user(ss_sp, &uss->ss_sp)
2396 || __get_user(ss_flags, &uss->ss_flags)
2397 || __get_user(ss_size, &uss->ss_size))
2398 goto out;
2399
2400 error = -EPERM;
2401 if (on_sig_stack(sp))
2402 goto out;
2403
2404 error = -EINVAL;
2405 /*
2406 *
2407 * Note - this code used to test ss_flags incorrectly
2408 * old code may have been written using ss_flags==0
2409 * to mean ss_flags==SS_ONSTACK (as this was the only
2410 * way that worked) - this fix preserves that older
2411 * mechanism
2412 */
2413 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2414 goto out;
2415
2416 if (ss_flags == SS_DISABLE) {
2417 ss_size = 0;
2418 ss_sp = NULL;
2419 } else {
2420 error = -ENOMEM;
2421 if (ss_size < MINSIGSTKSZ)
2422 goto out;
2423 }
2424
2425 current->sas_ss_sp = (unsigned long) ss_sp;
2426 current->sas_ss_size = ss_size;
2427 }
2428
2429 if (uoss) {
2430 error = -EFAULT;
2431 if (copy_to_user(uoss, &oss, sizeof(oss)))
2432 goto out;
2433 }
2434
2435 error = 0;
2436out:
2437 return error;
2438}
2439
2440#ifdef __ARCH_WANT_SYS_SIGPENDING
2441
Heiko Carstensb290ebe2009-01-14 14:14:06 +01002442SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443{
2444 return do_sigpending(set, sizeof(*set));
2445}
2446
2447#endif
2448
2449#ifdef __ARCH_WANT_SYS_SIGPROCMASK
2450/* Some platforms have their own version with special arguments others
2451 support only sys_rt_sigprocmask. */
2452
Heiko Carstensb290ebe2009-01-14 14:14:06 +01002453SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, set,
2454 old_sigset_t __user *, oset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455{
2456 int error;
2457 old_sigset_t old_set, new_set;
2458
2459 if (set) {
2460 error = -EFAULT;
2461 if (copy_from_user(&new_set, set, sizeof(*set)))
2462 goto out;
2463 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2464
2465 spin_lock_irq(&current->sighand->siglock);
2466 old_set = current->blocked.sig[0];
2467
2468 error = 0;
2469 switch (how) {
2470 default:
2471 error = -EINVAL;
2472 break;
2473 case SIG_BLOCK:
2474 sigaddsetmask(&current->blocked, new_set);
2475 break;
2476 case SIG_UNBLOCK:
2477 sigdelsetmask(&current->blocked, new_set);
2478 break;
2479 case SIG_SETMASK:
2480 current->blocked.sig[0] = new_set;
2481 break;
2482 }
2483
2484 recalc_sigpending();
2485 spin_unlock_irq(&current->sighand->siglock);
2486 if (error)
2487 goto out;
2488 if (oset)
2489 goto set_old;
2490 } else if (oset) {
2491 old_set = current->blocked.sig[0];
2492 set_old:
2493 error = -EFAULT;
2494 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2495 goto out;
2496 }
2497 error = 0;
2498out:
2499 return error;
2500}
2501#endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2502
2503#ifdef __ARCH_WANT_SYS_RT_SIGACTION
Heiko Carstensd4e82042009-01-14 14:14:34 +01002504SYSCALL_DEFINE4(rt_sigaction, int, sig,
2505 const struct sigaction __user *, act,
2506 struct sigaction __user *, oact,
2507 size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002508{
2509 struct k_sigaction new_sa, old_sa;
2510 int ret = -EINVAL;
2511
2512 /* XXX: Don't preclude handling different sized sigset_t's. */
2513 if (sigsetsize != sizeof(sigset_t))
2514 goto out;
2515
2516 if (act) {
2517 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2518 return -EFAULT;
2519 }
2520
2521 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2522
2523 if (!ret && oact) {
2524 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2525 return -EFAULT;
2526 }
2527out:
2528 return ret;
2529}
2530#endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2531
2532#ifdef __ARCH_WANT_SYS_SGETMASK
2533
2534/*
2535 * For backwards compatibility. Functionality superseded by sigprocmask.
2536 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01002537SYSCALL_DEFINE0(sgetmask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538{
2539 /* SMP safe */
2540 return current->blocked.sig[0];
2541}
2542
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01002543SYSCALL_DEFINE1(ssetmask, int, newmask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544{
2545 int old;
2546
2547 spin_lock_irq(&current->sighand->siglock);
2548 old = current->blocked.sig[0];
2549
2550 siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2551 sigmask(SIGSTOP)));
2552 recalc_sigpending();
2553 spin_unlock_irq(&current->sighand->siglock);
2554
2555 return old;
2556}
2557#endif /* __ARCH_WANT_SGETMASK */
2558
2559#ifdef __ARCH_WANT_SYS_SIGNAL
2560/*
2561 * For backwards compatibility. Functionality superseded by sigaction.
2562 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01002563SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564{
2565 struct k_sigaction new_sa, old_sa;
2566 int ret;
2567
2568 new_sa.sa.sa_handler = handler;
2569 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
Oleg Nesterovc70d3d72006-02-09 22:41:41 +03002570 sigemptyset(&new_sa.sa.sa_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571
2572 ret = do_sigaction(sig, &new_sa, &old_sa);
2573
2574 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2575}
2576#endif /* __ARCH_WANT_SYS_SIGNAL */
2577
2578#ifdef __ARCH_WANT_SYS_PAUSE
2579
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01002580SYSCALL_DEFINE0(pause)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581{
2582 current->state = TASK_INTERRUPTIBLE;
2583 schedule();
2584 return -ERESTARTNOHAND;
2585}
2586
2587#endif
2588
David Woodhouse150256d2006-01-18 17:43:57 -08002589#ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
Heiko Carstensd4e82042009-01-14 14:14:34 +01002590SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
David Woodhouse150256d2006-01-18 17:43:57 -08002591{
2592 sigset_t newset;
2593
2594 /* XXX: Don't preclude handling different sized sigset_t's. */
2595 if (sigsetsize != sizeof(sigset_t))
2596 return -EINVAL;
2597
2598 if (copy_from_user(&newset, unewset, sizeof(newset)))
2599 return -EFAULT;
2600 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2601
2602 spin_lock_irq(&current->sighand->siglock);
2603 current->saved_sigmask = current->blocked;
2604 current->blocked = newset;
2605 recalc_sigpending();
2606 spin_unlock_irq(&current->sighand->siglock);
2607
2608 current->state = TASK_INTERRUPTIBLE;
2609 schedule();
Roland McGrath4e4c22c2008-04-30 00:53:06 -07002610 set_restore_sigmask();
David Woodhouse150256d2006-01-18 17:43:57 -08002611 return -ERESTARTNOHAND;
2612}
2613#endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2614
David Howellsf269fdd2006-09-27 01:50:23 -07002615__attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2616{
2617 return NULL;
2618}
2619
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620void __init signals_init(void)
2621{
Christoph Lameter0a31bd52007-05-06 14:49:57 -07002622 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623}