blob: c5b9aabb1550957d9db5203992d359bac91de193 [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>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080025#include <linux/capability.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080026#include <linux/freezer.h>
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -080027#include <linux/pid_namespace.h>
28#include <linux/nsproxy.h>
29
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <asm/param.h>
31#include <asm/uaccess.h>
32#include <asm/unistd.h>
33#include <asm/siginfo.h>
Al Viroe1396062006-05-25 10:19:47 -040034#include "audit.h" /* audit_signal_info() */
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
36/*
37 * SLAB caches for signal bits.
38 */
39
Christoph Lametere18b8902006-12-06 20:33:20 -080040static struct kmem_cache *sigqueue_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070042static int __sig_ignored(struct task_struct *t, int sig)
43{
44 void __user *handler;
45
46 /* Is it explicitly or implicitly ignored? */
47
48 handler = t->sighand->action[sig - 1].sa.sa_handler;
49 return handler == SIG_IGN ||
50 (handler == SIG_DFL && sig_kernel_ignore(sig));
51}
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
53static int sig_ignored(struct task_struct *t, int sig)
54{
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 /*
56 * Tracers always want to know about signals..
57 */
58 if (t->ptrace & PT_PTRACED)
59 return 0;
60
61 /*
62 * Blocked signals are never ignored, since the
63 * signal handler may change by the time it is
64 * unblocked.
65 */
Roland McGrath325d22d2007-11-12 15:41:55 -080066 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 return 0;
68
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070069 return __sig_ignored(t, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070}
71
72/*
73 * Re-calculate pending state from the set of locally pending
74 * signals, globally pending signals, and blocked signals.
75 */
76static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
77{
78 unsigned long ready;
79 long i;
80
81 switch (_NSIG_WORDS) {
82 default:
83 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
84 ready |= signal->sig[i] &~ blocked->sig[i];
85 break;
86
87 case 4: ready = signal->sig[3] &~ blocked->sig[3];
88 ready |= signal->sig[2] &~ blocked->sig[2];
89 ready |= signal->sig[1] &~ blocked->sig[1];
90 ready |= signal->sig[0] &~ blocked->sig[0];
91 break;
92
93 case 2: ready = signal->sig[1] &~ blocked->sig[1];
94 ready |= signal->sig[0] &~ blocked->sig[0];
95 break;
96
97 case 1: ready = signal->sig[0] &~ blocked->sig[0];
98 }
99 return ready != 0;
100}
101
102#define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
103
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700104static int recalc_sigpending_tsk(struct task_struct *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105{
106 if (t->signal->group_stop_count > 0 ||
107 PENDING(&t->pending, &t->blocked) ||
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700108 PENDING(&t->signal->shared_pending, &t->blocked)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 set_tsk_thread_flag(t, TIF_SIGPENDING);
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700110 return 1;
111 }
Roland McGrathb74d0de2007-06-06 03:59:00 -0700112 /*
113 * We must never clear the flag in another thread, or in current
114 * when it's possible the current syscall is returning -ERESTART*.
115 * So we don't clear it here, and only callers who know they should do.
116 */
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700117 return 0;
118}
119
120/*
121 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
122 * This is superfluous when called on current, the wakeup is a harmless no-op.
123 */
124void recalc_sigpending_and_wake(struct task_struct *t)
125{
126 if (recalc_sigpending_tsk(t))
127 signal_wake_up(t, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128}
129
130void recalc_sigpending(void)
131{
Rafael J. Wysockicc5f9162007-10-29 14:37:12 -0700132 if (!recalc_sigpending_tsk(current) && !freezing(current))
Roland McGrathb74d0de2007-06-06 03:59:00 -0700133 clear_thread_flag(TIF_SIGPENDING);
134
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135}
136
137/* Given the mask, find the first available signal that should be serviced. */
138
Davide Libenzifba2afa2007-05-10 22:23:13 -0700139int next_signal(struct sigpending *pending, sigset_t *mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140{
141 unsigned long i, *s, *m, x;
142 int sig = 0;
143
144 s = pending->signal.sig;
145 m = mask->sig;
146 switch (_NSIG_WORDS) {
147 default:
148 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
149 if ((x = *s &~ *m) != 0) {
150 sig = ffz(~x) + i*_NSIG_BPW + 1;
151 break;
152 }
153 break;
154
155 case 2: if ((x = s[0] &~ m[0]) != 0)
156 sig = 1;
157 else if ((x = s[1] &~ m[1]) != 0)
158 sig = _NSIG_BPW + 1;
159 else
160 break;
161 sig += ffz(~x);
162 break;
163
164 case 1: if ((x = *s &~ *m) != 0)
165 sig = ffz(~x) + 1;
166 break;
167 }
168
169 return sig;
170}
171
Al Virodd0fc662005-10-07 07:46:04 +0100172static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 int override_rlimit)
174{
175 struct sigqueue *q = NULL;
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800176 struct user_struct *user;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800178 /*
179 * In order to avoid problems with "switch_user()", we want to make
180 * sure that the compiler doesn't re-load "t->user"
181 */
182 user = t->user;
183 barrier();
184 atomic_inc(&user->sigpending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 if (override_rlimit ||
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800186 atomic_read(&user->sigpending) <=
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
188 q = kmem_cache_alloc(sigqueue_cachep, flags);
189 if (unlikely(q == NULL)) {
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800190 atomic_dec(&user->sigpending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 } else {
192 INIT_LIST_HEAD(&q->list);
193 q->flags = 0;
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800194 q->user = get_uid(user);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 }
196 return(q);
197}
198
Andrew Morton514a01b2006-02-03 03:04:41 -0800199static void __sigqueue_free(struct sigqueue *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200{
201 if (q->flags & SIGQUEUE_PREALLOC)
202 return;
203 atomic_dec(&q->user->sigpending);
204 free_uid(q->user);
205 kmem_cache_free(sigqueue_cachep, q);
206}
207
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800208void flush_sigqueue(struct sigpending *queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209{
210 struct sigqueue *q;
211
212 sigemptyset(&queue->signal);
213 while (!list_empty(&queue->list)) {
214 q = list_entry(queue->list.next, struct sigqueue , list);
215 list_del_init(&q->list);
216 __sigqueue_free(q);
217 }
218}
219
220/*
221 * Flush all pending signals for a task.
222 */
Oleg Nesterovc81addc2006-03-28 16:11:17 -0800223void flush_signals(struct task_struct *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224{
225 unsigned long flags;
226
227 spin_lock_irqsave(&t->sighand->siglock, flags);
Pavel Machekf5264482008-04-21 22:15:06 +0000228 clear_tsk_thread_flag(t, TIF_SIGPENDING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 flush_sigqueue(&t->pending);
230 flush_sigqueue(&t->signal->shared_pending);
231 spin_unlock_irqrestore(&t->sighand->siglock, flags);
232}
233
Oleg Nesterovcbaffba2008-05-26 20:55:42 +0400234static void __flush_itimer_signals(struct sigpending *pending)
235{
236 sigset_t signal, retain;
237 struct sigqueue *q, *n;
238
239 signal = pending->signal;
240 sigemptyset(&retain);
241
242 list_for_each_entry_safe(q, n, &pending->list, list) {
243 int sig = q->info.si_signo;
244
245 if (likely(q->info.si_code != SI_TIMER)) {
246 sigaddset(&retain, sig);
247 } else {
248 sigdelset(&signal, sig);
249 list_del_init(&q->list);
250 __sigqueue_free(q);
251 }
252 }
253
254 sigorsets(&pending->signal, &signal, &retain);
255}
256
257void flush_itimer_signals(void)
258{
259 struct task_struct *tsk = current;
260 unsigned long flags;
261
262 spin_lock_irqsave(&tsk->sighand->siglock, flags);
263 __flush_itimer_signals(&tsk->pending);
264 __flush_itimer_signals(&tsk->signal->shared_pending);
265 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
266}
267
Oleg Nesterov10ab8252007-05-09 02:34:37 -0700268void ignore_signals(struct task_struct *t)
269{
270 int i;
271
272 for (i = 0; i < _NSIG; ++i)
273 t->sighand->action[i].sa.sa_handler = SIG_IGN;
274
275 flush_signals(t);
276}
277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 * Flush all handlers for a task.
280 */
281
282void
283flush_signal_handlers(struct task_struct *t, int force_default)
284{
285 int i;
286 struct k_sigaction *ka = &t->sighand->action[0];
287 for (i = _NSIG ; i != 0 ; i--) {
288 if (force_default || ka->sa.sa_handler != SIG_IGN)
289 ka->sa.sa_handler = SIG_DFL;
290 ka->sa.sa_flags = 0;
291 sigemptyset(&ka->sa.sa_mask);
292 ka++;
293 }
294}
295
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200296int unhandled_signal(struct task_struct *tsk, int sig)
297{
Serge E. Hallynb460cbc2007-10-18 23:39:52 -0700298 if (is_global_init(tsk))
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200299 return 1;
300 if (tsk->ptrace & PT_PTRACED)
301 return 0;
302 return (tsk->sighand->action[sig-1].sa.sa_handler == SIG_IGN) ||
303 (tsk->sighand->action[sig-1].sa.sa_handler == SIG_DFL);
304}
305
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
307/* Notify the system that a driver wants to block all signals for this
308 * process, and wants to be notified if any signals at all were to be
309 * sent/acted upon. If the notifier routine returns non-zero, then the
310 * signal will be acted upon after all. If the notifier routine returns 0,
311 * then then signal will be blocked. Only one block per process is
312 * allowed. priv is a pointer to private data that the notifier routine
313 * can use to determine if the signal should be blocked or not. */
314
315void
316block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
317{
318 unsigned long flags;
319
320 spin_lock_irqsave(&current->sighand->siglock, flags);
321 current->notifier_mask = mask;
322 current->notifier_data = priv;
323 current->notifier = notifier;
324 spin_unlock_irqrestore(&current->sighand->siglock, flags);
325}
326
327/* Notify the system that blocking has ended. */
328
329void
330unblock_all_signals(void)
331{
332 unsigned long flags;
333
334 spin_lock_irqsave(&current->sighand->siglock, flags);
335 current->notifier = NULL;
336 current->notifier_data = NULL;
337 recalc_sigpending();
338 spin_unlock_irqrestore(&current->sighand->siglock, flags);
339}
340
Arjan van de Ven858119e2006-01-14 13:20:43 -0800341static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342{
343 struct sigqueue *q, *first = NULL;
344 int still_pending = 0;
345
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 /*
347 * Collect the siginfo appropriate to this signal. Check if
348 * there is another siginfo for the same signal.
349 */
350 list_for_each_entry(q, &list->list, list) {
351 if (q->info.si_signo == sig) {
352 if (first) {
353 still_pending = 1;
354 break;
355 }
356 first = q;
357 }
358 }
359 if (first) {
360 list_del_init(&first->list);
361 copy_siginfo(info, &first->info);
362 __sigqueue_free(first);
363 if (!still_pending)
364 sigdelset(&list->signal, sig);
365 } else {
366
367 /* Ok, it wasn't in the queue. This must be
368 a fast-pathed signal or we must have been
369 out of queue space. So zero out the info.
370 */
371 sigdelset(&list->signal, sig);
372 info->si_signo = sig;
373 info->si_errno = 0;
374 info->si_code = 0;
375 info->si_pid = 0;
376 info->si_uid = 0;
377 }
378 return 1;
379}
380
381static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
382 siginfo_t *info)
383{
Roland McGrath27d91e02006-09-29 02:00:31 -0700384 int sig = next_signal(pending, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 if (sig) {
387 if (current->notifier) {
388 if (sigismember(current->notifier_mask, sig)) {
389 if (!(current->notifier)(current->notifier_data)) {
390 clear_thread_flag(TIF_SIGPENDING);
391 return 0;
392 }
393 }
394 }
395
396 if (!collect_signal(sig, pending, info))
397 sig = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
400 return sig;
401}
402
403/*
404 * Dequeue a signal and return the element to the caller, which is
405 * expected to free it.
406 *
407 * All callers have to hold the siglock.
408 */
409int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
410{
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700411 int signr;
Benjamin Herrenschmidtcaec4e82007-06-12 08:16:18 +1000412
413 /* We only dequeue private signals from ourselves, we don't let
414 * signalfd steal them
415 */
Davide Libenzib8fceee2007-09-20 12:40:16 -0700416 signr = __dequeue_signal(&tsk->pending, mask, info);
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800417 if (!signr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 signr = __dequeue_signal(&tsk->signal->shared_pending,
419 mask, info);
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800420 /*
421 * itimer signal ?
422 *
423 * itimers are process shared and we restart periodic
424 * itimers in the signal delivery path to prevent DoS
425 * attacks in the high resolution timer case. This is
426 * compliant with the old way of self restarting
427 * itimers, as the SIGALRM is a legacy signal and only
428 * queued once. Changing the restart behaviour to
429 * restart the timer in the signal dequeue path is
430 * reducing the timer noise on heavy loaded !highres
431 * systems too.
432 */
433 if (unlikely(signr == SIGALRM)) {
434 struct hrtimer *tmr = &tsk->signal->real_timer;
435
436 if (!hrtimer_is_queued(tmr) &&
437 tsk->signal->it_real_incr.tv64 != 0) {
438 hrtimer_forward(tmr, tmr->base->get_time(),
439 tsk->signal->it_real_incr);
440 hrtimer_restart(tmr);
441 }
442 }
443 }
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700444
Davide Libenzib8fceee2007-09-20 12:40:16 -0700445 recalc_sigpending();
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700446 if (!signr)
447 return 0;
448
449 if (unlikely(sig_kernel_stop(signr))) {
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800450 /*
451 * Set a marker that we have dequeued a stop signal. Our
452 * caller might release the siglock and then the pending
453 * stop signal it is about to process is no longer in the
454 * pending bitmasks, but must still be cleared by a SIGCONT
455 * (and overruled by a SIGKILL). So those cases clear this
456 * shared flag after we've set it. Note that this flag may
457 * remain set after the signal we return is ignored or
458 * handled. That doesn't matter because its only purpose
459 * is to alert stop-signal processing code when another
460 * processor has come along and cleared the flag.
461 */
462 if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
463 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
464 }
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700465 if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 /*
467 * Release the siglock to ensure proper locking order
468 * of timer locks outside of siglocks. Note, we leave
469 * irqs disabled here, since the posix-timers code is
470 * about to disable them again anyway.
471 */
472 spin_unlock(&tsk->sighand->siglock);
473 do_schedule_next_timer(info);
474 spin_lock(&tsk->sighand->siglock);
475 }
476 return signr;
477}
478
479/*
480 * Tell a process that it has a new active signal..
481 *
482 * NOTE! we rely on the previous spin_lock to
483 * lock interrupts for us! We can only be called with
484 * "siglock" held, and the local interrupt must
485 * have been disabled when that got acquired!
486 *
487 * No need to set need_resched since signal event passing
488 * goes through ->blocked
489 */
490void signal_wake_up(struct task_struct *t, int resume)
491{
492 unsigned int mask;
493
494 set_tsk_thread_flag(t, TIF_SIGPENDING);
495
496 /*
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500497 * For SIGKILL, we want to wake it up in the stopped/traced/killable
498 * case. We don't check t->state here because there is a race with it
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 * executing another processor and just now entering stopped state.
500 * By using wake_up_state, we ensure the process will wake up and
501 * handle its death signal.
502 */
503 mask = TASK_INTERRUPTIBLE;
504 if (resume)
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500505 mask |= TASK_WAKEKILL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 if (!wake_up_state(t, mask))
507 kick_process(t);
508}
509
510/*
511 * Remove signals in mask from the pending set and queue.
512 * Returns 1 if any signals were found.
513 *
514 * All callers must be holding the siglock.
George Anzinger71fabd52006-01-08 01:02:48 -0800515 *
516 * This version takes a sigset mask and looks at all signals,
517 * not just those in the first mask word.
518 */
519static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
520{
521 struct sigqueue *q, *n;
522 sigset_t m;
523
524 sigandsets(&m, mask, &s->signal);
525 if (sigisemptyset(&m))
526 return 0;
527
528 signandsets(&s->signal, &s->signal, mask);
529 list_for_each_entry_safe(q, n, &s->list, list) {
530 if (sigismember(mask, q->info.si_signo)) {
531 list_del_init(&q->list);
532 __sigqueue_free(q);
533 }
534 }
535 return 1;
536}
537/*
538 * Remove signals in mask from the pending set and queue.
539 * Returns 1 if any signals were found.
540 *
541 * All callers must be holding the siglock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 */
543static int rm_from_queue(unsigned long mask, struct sigpending *s)
544{
545 struct sigqueue *q, *n;
546
547 if (!sigtestsetmask(&s->signal, mask))
548 return 0;
549
550 sigdelsetmask(&s->signal, mask);
551 list_for_each_entry_safe(q, n, &s->list, list) {
552 if (q->info.si_signo < SIGRTMIN &&
553 (mask & sigmask(q->info.si_signo))) {
554 list_del_init(&q->list);
555 __sigqueue_free(q);
556 }
557 }
558 return 1;
559}
560
561/*
562 * Bad permissions for sending the signal
563 */
564static int check_kill_permission(int sig, struct siginfo *info,
565 struct task_struct *t)
566{
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700567 struct pid *sid;
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700568 int error;
569
Jesper Juhl7ed20e12005-05-01 08:59:14 -0700570 if (!valid_signal(sig))
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700571 return -EINVAL;
572
573 if (info != SEND_SIG_NOINFO && (is_si_special(info) || SI_FROMKERNEL(info)))
574 return 0;
575
576 error = audit_signal_info(sig, t); /* Let audit system see the signal */
577 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 return error;
Amy Griffise54dc242007-03-29 18:01:04 -0400579
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700580 if ((current->euid ^ t->suid) && (current->euid ^ t->uid) &&
581 (current->uid ^ t->suid) && (current->uid ^ t->uid) &&
582 !capable(CAP_KILL)) {
583 switch (sig) {
584 case SIGCONT:
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700585 sid = task_session(t);
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700586 /*
587 * We don't return the error if sid == NULL. The
588 * task was unhashed, the caller must notice this.
589 */
590 if (!sid || sid == task_session(current))
591 break;
592 default:
593 return -EPERM;
594 }
595 }
Steve Grubbc2f0c7c2005-05-06 12:38:39 +0100596
Amy Griffise54dc242007-03-29 18:01:04 -0400597 return security_task_kill(t, info, sig, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598}
599
600/* forward decl */
Oleg Nesterova1d5e212006-03-28 16:11:29 -0800601static void do_notify_parent_cldstop(struct task_struct *tsk, int why);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
603/*
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700604 * Handle magic process-wide effects of stop/continue signals. Unlike
605 * the signal actions, these happen immediately at signal-generation
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 * time regardless of blocking, ignoring, or handling. This does the
607 * actual continuing for SIGCONT, but not the actual stopping for stop
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700608 * signals. The process stop is done as a signal action for SIG_DFL.
609 *
610 * Returns true if the signal should be actually delivered, otherwise
611 * it should be dropped.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 */
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700613static int prepare_signal(int sig, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614{
Oleg Nesterovad16a462008-04-30 00:52:46 -0700615 struct signal_struct *signal = p->signal;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 struct task_struct *t;
617
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700618 if (unlikely(signal->flags & SIGNAL_GROUP_EXIT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 /*
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700620 * The process is in the middle of dying, nothing to do.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 */
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700622 } else if (sig_kernel_stop(sig)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 /*
624 * This is a stop signal. Remove SIGCONT from all queues.
625 */
Oleg Nesterovad16a462008-04-30 00:52:46 -0700626 rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 t = p;
628 do {
629 rm_from_queue(sigmask(SIGCONT), &t->pending);
Oleg Nesterovad16a462008-04-30 00:52:46 -0700630 } while_each_thread(p, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 } else if (sig == SIGCONT) {
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700632 unsigned int why;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 /*
634 * Remove all stop signals from all queues,
635 * and wake all threads.
636 */
Oleg Nesterovad16a462008-04-30 00:52:46 -0700637 rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 t = p;
639 do {
640 unsigned int state;
641 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 /*
643 * If there is a handler for SIGCONT, we must make
644 * sure that no thread returns to user mode before
645 * we post the signal, in case it was the only
646 * thread eligible to run the signal handler--then
647 * it must not do anything between resuming and
648 * running the handler. With the TIF_SIGPENDING
649 * flag set, the thread will pause and acquire the
650 * siglock that we hold now and until we've queued
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700651 * the pending signal.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 *
653 * Wake up the stopped thread _after_ setting
654 * TIF_SIGPENDING
655 */
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500656 state = __TASK_STOPPED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
658 set_tsk_thread_flag(t, TIF_SIGPENDING);
659 state |= TASK_INTERRUPTIBLE;
660 }
661 wake_up_state(t, state);
Oleg Nesterovad16a462008-04-30 00:52:46 -0700662 } while_each_thread(p, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700664 /*
665 * Notify the parent with CLD_CONTINUED if we were stopped.
666 *
667 * If we were in the middle of a group stop, we pretend it
668 * was already finished, and then continued. Since SIGCHLD
669 * doesn't queue we report only CLD_STOPPED, as if the next
670 * CLD_CONTINUED was dropped.
671 */
672 why = 0;
Oleg Nesterovad16a462008-04-30 00:52:46 -0700673 if (signal->flags & SIGNAL_STOP_STOPPED)
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700674 why |= SIGNAL_CLD_CONTINUED;
Oleg Nesterovad16a462008-04-30 00:52:46 -0700675 else if (signal->group_stop_count)
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700676 why |= SIGNAL_CLD_STOPPED;
677
678 if (why) {
Oleg Nesterov021e1ae2008-04-30 00:53:00 -0700679 /*
680 * The first thread which returns from finish_stop()
681 * will take ->siglock, notice SIGNAL_CLD_MASK, and
682 * notify its parent. See get_signal_to_deliver().
683 */
Oleg Nesterovad16a462008-04-30 00:52:46 -0700684 signal->flags = why | SIGNAL_STOP_CONTINUED;
685 signal->group_stop_count = 0;
686 signal->group_exit_code = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 } else {
688 /*
689 * We are not stopped, but there could be a stop
690 * signal in the middle of being processed after
691 * being removed from the queue. Clear that too.
692 */
Oleg Nesterovad16a462008-04-30 00:52:46 -0700693 signal->flags &= ~SIGNAL_STOP_DEQUEUED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 }
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700696
697 return !sig_ignored(p, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698}
699
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700700/*
701 * Test if P wants to take SIG. After we've checked all threads with this,
702 * it's equivalent to finding no threads not blocking SIG. Any threads not
703 * blocking SIG were ruled out because they are not running and already
704 * have pending signals. Such threads will dequeue from the shared queue
705 * as soon as they're available, so putting the signal on the shared queue
706 * will be equivalent to sending it to one such thread.
707 */
708static inline int wants_signal(int sig, struct task_struct *p)
709{
710 if (sigismember(&p->blocked, sig))
711 return 0;
712 if (p->flags & PF_EXITING)
713 return 0;
714 if (sig == SIGKILL)
715 return 1;
716 if (task_is_stopped_or_traced(p))
717 return 0;
718 return task_curr(p) || !signal_pending(p);
719}
720
Oleg Nesterov5fcd8352008-04-30 00:52:55 -0700721static void complete_signal(int sig, struct task_struct *p, int group)
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700722{
723 struct signal_struct *signal = p->signal;
724 struct task_struct *t;
725
726 /*
727 * Now find a thread we can wake up to take the signal off the queue.
728 *
729 * If the main thread wants the signal, it gets first crack.
730 * Probably the least surprising to the average bear.
731 */
732 if (wants_signal(sig, p))
733 t = p;
Oleg Nesterov5fcd8352008-04-30 00:52:55 -0700734 else if (!group || thread_group_empty(p))
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700735 /*
736 * There is just one thread and it does not need to be woken.
737 * It will dequeue unblocked signals before it runs again.
738 */
739 return;
740 else {
741 /*
742 * Otherwise try to find a suitable thread.
743 */
744 t = signal->curr_target;
745 while (!wants_signal(sig, t)) {
746 t = next_thread(t);
747 if (t == signal->curr_target)
748 /*
749 * No thread needs to be woken.
750 * Any eligible threads will see
751 * the signal in the queue soon.
752 */
753 return;
754 }
755 signal->curr_target = t;
756 }
757
758 /*
759 * Found a killable thread. If the signal will be fatal,
760 * then start taking the whole group down immediately.
761 */
Oleg Nesterovfae5fa42008-04-30 00:53:03 -0700762 if (sig_fatal(p, sig) &&
763 !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700764 !sigismember(&t->real_blocked, sig) &&
765 (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
766 /*
767 * This signal will be fatal to the whole group.
768 */
769 if (!sig_kernel_coredump(sig)) {
770 /*
771 * Start a group exit and wake everybody up.
772 * This way we don't have other threads
773 * running and doing things after a slower
774 * thread has the fatal signal pending.
775 */
776 signal->flags = SIGNAL_GROUP_EXIT;
777 signal->group_exit_code = sig;
778 signal->group_stop_count = 0;
779 t = p;
780 do {
781 sigaddset(&t->pending.signal, SIGKILL);
782 signal_wake_up(t, 1);
783 } while_each_thread(p, t);
784 return;
785 }
786 }
787
788 /*
789 * The signal is already in the shared-pending queue.
790 * Tell the chosen thread to wake up and dequeue it.
791 */
792 signal_wake_up(t, sig == SIGKILL);
793 return;
794}
795
Pavel Emelyanovaf7fff92008-04-30 00:52:34 -0700796static inline int legacy_queue(struct sigpending *signals, int sig)
797{
798 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
799}
800
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700802 int group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803{
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700804 struct sigpending *pending;
Oleg Nesterov6e65acb2008-04-30 00:52:50 -0700805 struct sigqueue *q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
Oleg Nesterov6e65acb2008-04-30 00:52:50 -0700807 assert_spin_locked(&t->sighand->siglock);
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700808 if (!prepare_signal(sig, t))
809 return 0;
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700810
811 pending = group ? &t->signal->shared_pending : &t->pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 /*
Pavel Emelyanov2acb0242008-04-30 00:52:35 -0700813 * Short-circuit ignored signals and support queuing
814 * exactly one non-rt signal, so that we can get more
815 * detailed information about the cause of the signal.
816 */
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700817 if (legacy_queue(pending, sig))
Pavel Emelyanov2acb0242008-04-30 00:52:35 -0700818 return 0;
Davide Libenzifba2afa2007-05-10 22:23:13 -0700819 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 * fast-pathed signals for kernel-internal things like SIGSTOP
821 * or SIGKILL.
822 */
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800823 if (info == SEND_SIG_FORCED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 goto out_set;
825
826 /* Real-time signals must be queued if sent by sigqueue, or
827 some other real-time mechanism. It is implementation
828 defined whether kill() does so. We attempt to do so, on
829 the principle of least surprise, but since kill is not
830 allowed to fail with EAGAIN when low on memory we just
831 make sure at least one signal gets delivered and don't
832 pass on the info struct. */
833
834 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
Oleg Nesterov621d3122005-10-30 15:03:45 -0800835 (is_si_special(info) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 info->si_code >= 0)));
837 if (q) {
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700838 list_add_tail(&q->list, &pending->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 switch ((unsigned long) info) {
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800840 case (unsigned long) SEND_SIG_NOINFO:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 q->info.si_signo = sig;
842 q->info.si_errno = 0;
843 q->info.si_code = SI_USER;
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700844 q->info.si_pid = task_pid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 q->info.si_uid = current->uid;
846 break;
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800847 case (unsigned long) SEND_SIG_PRIV:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 q->info.si_signo = sig;
849 q->info.si_errno = 0;
850 q->info.si_code = SI_KERNEL;
851 q->info.si_pid = 0;
852 q->info.si_uid = 0;
853 break;
854 default:
855 copy_siginfo(&q->info, info);
856 break;
857 }
Oleg Nesterov621d3122005-10-30 15:03:45 -0800858 } else if (!is_si_special(info)) {
859 if (sig >= SIGRTMIN && info->si_code != SI_USER)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 /*
861 * Queue overflow, abort. We may abort if the signal was rt
862 * and sent by user using something other than kill().
863 */
864 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 }
866
867out_set:
Oleg Nesterov53c30332008-04-30 00:53:00 -0700868 signalfd_notify(t, sig);
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700869 sigaddset(&pending->signal, sig);
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -0700870 complete_signal(sig, t, group);
871 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872}
873
Ingo Molnar45807a12007-07-15 23:40:10 -0700874int print_fatal_signals;
875
876static void print_fatal_signal(struct pt_regs *regs, int signr)
877{
878 printk("%s/%d: potentially unexpected fatal signal %d.\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -0700879 current->comm, task_pid_nr(current), signr);
Ingo Molnar45807a12007-07-15 23:40:10 -0700880
Al Viroca5cd872007-10-29 04:31:16 +0000881#if defined(__i386__) && !defined(__arch_um__)
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100882 printk("code at %08lx: ", regs->ip);
Ingo Molnar45807a12007-07-15 23:40:10 -0700883 {
884 int i;
885 for (i = 0; i < 16; i++) {
886 unsigned char insn;
887
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100888 __get_user(insn, (unsigned char *)(regs->ip + i));
Ingo Molnar45807a12007-07-15 23:40:10 -0700889 printk("%02x ", insn);
890 }
891 }
892#endif
893 printk("\n");
894 show_regs(regs);
895}
896
897static int __init setup_print_fatal_signals(char *str)
898{
899 get_option (&str, &print_fatal_signals);
900
901 return 1;
902}
903
904__setup("print-fatal-signals=", setup_print_fatal_signals);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -0700906int
907__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
908{
909 return send_signal(sig, info, p, 1);
910}
911
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912static int
913specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
914{
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -0700915 return send_signal(sig, info, t, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916}
917
918/*
919 * Force a signal that the process can't ignore: if necessary
920 * we unblock the signal and change any SIG_IGN to SIG_DFL.
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700921 *
922 * Note: If we unblock the signal, we always reset it to SIG_DFL,
923 * since we do not want to have a signal handler that was blocked
924 * be invoked when user space had explicitly blocked it.
925 *
Oleg Nesterov80fe7282008-04-30 00:53:05 -0700926 * We don't want to have recursive SIGSEGV's etc, for example,
927 * that is why we also clear SIGNAL_UNKILLABLE.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929int
930force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
931{
932 unsigned long int flags;
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700933 int ret, blocked, ignored;
934 struct k_sigaction *action;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
936 spin_lock_irqsave(&t->sighand->siglock, flags);
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700937 action = &t->sighand->action[sig-1];
938 ignored = action->sa.sa_handler == SIG_IGN;
939 blocked = sigismember(&t->blocked, sig);
940 if (blocked || ignored) {
941 action->sa.sa_handler = SIG_DFL;
942 if (blocked) {
943 sigdelset(&t->blocked, sig);
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700944 recalc_sigpending_and_wake(t);
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700945 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 }
Oleg Nesterov80fe7282008-04-30 00:53:05 -0700947 if (action->sa.sa_handler == SIG_DFL)
948 t->signal->flags &= ~SIGNAL_UNKILLABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 ret = specific_send_sig_info(sig, info, t);
950 spin_unlock_irqrestore(&t->sighand->siglock, flags);
951
952 return ret;
953}
954
955void
956force_sig_specific(int sig, struct task_struct *t)
957{
Paul E. McKenneyb0423a02005-10-30 15:03:46 -0800958 force_sig_info(sig, SEND_SIG_FORCED, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959}
960
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961/*
962 * Nuke all other threads in the group.
963 */
964void zap_other_threads(struct task_struct *p)
965{
966 struct task_struct *t;
967
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 p->signal->group_stop_count = 0;
969
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 for (t = next_thread(p); t != p; t = next_thread(t)) {
971 /*
972 * Don't bother with already dead threads
973 */
974 if (t->exit_state)
975 continue;
976
Andrea Arcangeli30e0fca2005-10-30 15:02:38 -0800977 /* SIGKILL will be handled before any pending SIGSTOP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 sigaddset(&t->pending.signal, SIGKILL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 signal_wake_up(t, 1);
980 }
981}
982
Harvey Harrisonb5606c22008-02-13 15:03:16 -0800983int __fatal_signal_pending(struct task_struct *tsk)
Matthew Wilcoxf776d122007-12-06 11:15:50 -0500984{
985 return sigismember(&tsk->pending.signal, SIGKILL);
986}
Trond Myklebust13f09b92008-01-31 20:40:29 -0500987EXPORT_SYMBOL(__fatal_signal_pending);
Matthew Wilcoxf776d122007-12-06 11:15:50 -0500988
Oleg Nesterovf63ee722006-03-28 16:11:13 -0800989struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
990{
991 struct sighand_struct *sighand;
992
Oleg Nesterov1406f2d2008-04-30 00:52:37 -0700993 rcu_read_lock();
Oleg Nesterovf63ee722006-03-28 16:11:13 -0800994 for (;;) {
995 sighand = rcu_dereference(tsk->sighand);
996 if (unlikely(sighand == NULL))
997 break;
998
999 spin_lock_irqsave(&sighand->siglock, *flags);
1000 if (likely(sighand == tsk->sighand))
1001 break;
1002 spin_unlock_irqrestore(&sighand->siglock, *flags);
1003 }
Oleg Nesterov1406f2d2008-04-30 00:52:37 -07001004 rcu_read_unlock();
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001005
1006 return sighand;
1007}
1008
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1010{
1011 unsigned long flags;
1012 int ret;
1013
1014 ret = check_kill_permission(sig, info, p);
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001015
1016 if (!ret && sig) {
1017 ret = -ESRCH;
1018 if (lock_task_sighand(p, &flags)) {
1019 ret = __group_send_sig_info(sig, info, p);
1020 unlock_task_sighand(p, &flags);
Ingo Molnare56d0902006-01-08 01:01:37 -08001021 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 }
1023
1024 return ret;
1025}
1026
1027/*
Pavel Emelyanov146a5052008-02-08 04:19:22 -08001028 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 * control characters do (^C, ^Z etc)
1030 */
1031
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001032int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033{
1034 struct task_struct *p = NULL;
1035 int retval, success;
1036
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 success = 0;
1038 retval = -ESRCH;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001039 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 int err = group_send_sig_info(sig, info, p);
1041 success |= !err;
1042 retval = err;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001043 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 return success ? 0 : retval;
1045}
1046
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001047int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048{
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001049 int error = -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 struct task_struct *p;
1051
Ingo Molnare56d0902006-01-08 01:01:37 -08001052 rcu_read_lock();
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001053retry:
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001054 p = pid_task(pid, PIDTYPE_PID);
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001055 if (p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 error = group_send_sig_info(sig, info, p);
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001057 if (unlikely(error == -ESRCH))
1058 /*
1059 * The task was unhashed in between, try again.
1060 * If it is dead, pid_task() will return NULL,
1061 * if we race with de_thread() it will find the
1062 * new leader.
1063 */
1064 goto retry;
1065 }
Ingo Molnare56d0902006-01-08 01:01:37 -08001066 rcu_read_unlock();
Oleg Nesterov6ca25b52008-04-30 00:52:45 -07001067
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 return error;
1069}
1070
Matthew Wilcoxc3de4b32007-02-09 08:11:47 -07001071int
1072kill_proc_info(int sig, struct siginfo *info, pid_t pid)
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001073{
1074 int error;
1075 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001076 error = kill_pid_info(sig, info, find_vpid(pid));
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001077 rcu_read_unlock();
1078 return error;
1079}
1080
Eric W. Biederman2425c082006-10-02 02:17:28 -07001081/* like kill_pid_info(), but doesn't use uid/euid of "current" */
1082int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
David Quigley8f95dc52006-06-30 01:55:47 -07001083 uid_t uid, uid_t euid, u32 secid)
Harald Welte46113832005-10-10 19:44:29 +02001084{
1085 int ret = -EINVAL;
1086 struct task_struct *p;
1087
1088 if (!valid_signal(sig))
1089 return ret;
1090
1091 read_lock(&tasklist_lock);
Eric W. Biederman2425c082006-10-02 02:17:28 -07001092 p = pid_task(pid, PIDTYPE_PID);
Harald Welte46113832005-10-10 19:44:29 +02001093 if (!p) {
1094 ret = -ESRCH;
1095 goto out_unlock;
1096 }
Oleg Nesterov0811af22006-01-08 01:03:09 -08001097 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
Harald Welte46113832005-10-10 19:44:29 +02001098 && (euid != p->suid) && (euid != p->uid)
1099 && (uid != p->suid) && (uid != p->uid)) {
1100 ret = -EPERM;
1101 goto out_unlock;
1102 }
David Quigley8f95dc52006-06-30 01:55:47 -07001103 ret = security_task_kill(p, info, sig, secid);
1104 if (ret)
1105 goto out_unlock;
Harald Welte46113832005-10-10 19:44:29 +02001106 if (sig && p->sighand) {
1107 unsigned long flags;
1108 spin_lock_irqsave(&p->sighand->siglock, flags);
1109 ret = __group_send_sig_info(sig, info, p);
1110 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1111 }
1112out_unlock:
1113 read_unlock(&tasklist_lock);
1114 return ret;
1115}
Eric W. Biederman2425c082006-10-02 02:17:28 -07001116EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117
1118/*
1119 * kill_something_info() interprets pid in interesting ways just like kill(2).
1120 *
1121 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1122 * is probably wrong. Should make it like BSD or SYSV.
1123 */
1124
1125static int kill_something_info(int sig, struct siginfo *info, int pid)
1126{
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001127 int ret;
Pavel Emelyanovd5df7632008-02-08 04:19:22 -08001128
1129 if (pid > 0) {
1130 rcu_read_lock();
1131 ret = kill_pid_info(sig, info, find_vpid(pid));
1132 rcu_read_unlock();
1133 return ret;
1134 }
1135
1136 read_lock(&tasklist_lock);
1137 if (pid != -1) {
1138 ret = __kill_pgrp_info(sig, info,
1139 pid ? find_vpid(-pid) : task_pgrp(current));
1140 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 int retval = 0, count = 0;
1142 struct task_struct * p;
1143
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 for_each_process(p) {
Pavel Emelyanovbac0abd2007-10-18 23:40:18 -07001145 if (p->pid > 1 && !same_thread_group(p, current)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 int err = group_send_sig_info(sig, info, p);
1147 ++count;
1148 if (err != -EPERM)
1149 retval = err;
1150 }
1151 }
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001152 ret = count ? retval : -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 }
Pavel Emelyanovd5df7632008-02-08 04:19:22 -08001154 read_unlock(&tasklist_lock);
1155
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001156 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157}
1158
1159/*
1160 * These are for backward compatibility with the rest of the kernel source.
1161 */
1162
1163/*
Oleg Nesterov08d2c302008-04-30 00:52:51 -07001164 * The caller must ensure the task can't exit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 */
1166int
1167send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1168{
1169 int ret;
1170 unsigned long flags;
1171
1172 /*
1173 * Make sure legacy kernel users don't send in bad values
1174 * (normal paths check this in check_kill_permission).
1175 */
Jesper Juhl7ed20e12005-05-01 08:59:14 -07001176 if (!valid_signal(sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 return -EINVAL;
1178
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 spin_lock_irqsave(&p->sighand->siglock, flags);
1180 ret = specific_send_sig_info(sig, info, p);
1181 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 return ret;
1183}
1184
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001185#define __si_special(priv) \
1186 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1187
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188int
1189send_sig(int sig, struct task_struct *p, int priv)
1190{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001191 return send_sig_info(sig, __si_special(priv), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192}
1193
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194void
1195force_sig(int sig, struct task_struct *p)
1196{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001197 force_sig_info(sig, SEND_SIG_PRIV, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198}
1199
1200/*
1201 * When things go south during signal handling, we
1202 * will force a SIGSEGV. And if the signal that caused
1203 * the problem was already a SIGSEGV, we'll want to
1204 * make sure we don't even try to deliver the signal..
1205 */
1206int
1207force_sigsegv(int sig, struct task_struct *p)
1208{
1209 if (sig == SIGSEGV) {
1210 unsigned long flags;
1211 spin_lock_irqsave(&p->sighand->siglock, flags);
1212 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1213 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1214 }
1215 force_sig(SIGSEGV, p);
1216 return 0;
1217}
1218
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001219int kill_pgrp(struct pid *pid, int sig, int priv)
1220{
Pavel Emelyanov146a5052008-02-08 04:19:22 -08001221 int ret;
1222
1223 read_lock(&tasklist_lock);
1224 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1225 read_unlock(&tasklist_lock);
1226
1227 return ret;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001228}
1229EXPORT_SYMBOL(kill_pgrp);
1230
1231int kill_pid(struct pid *pid, int sig, int priv)
1232{
1233 return kill_pid_info(sig, __si_special(priv), pid);
1234}
1235EXPORT_SYMBOL(kill_pid);
1236
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238kill_proc(pid_t pid, int sig, int priv)
1239{
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001240 int ret;
1241
1242 rcu_read_lock();
1243 ret = kill_pid_info(sig, __si_special(priv), find_pid(pid));
1244 rcu_read_unlock();
1245 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246}
1247
1248/*
1249 * These functions support sending signals using preallocated sigqueue
1250 * structures. This is needed "because realtime applications cannot
1251 * afford to lose notifications of asynchronous events, like timer
1252 * expirations or I/O completions". In the case of Posix Timers
1253 * we allocate the sigqueue structure from the timer_create. If this
1254 * allocation fails we are able to report the failure to the application
1255 * with an EAGAIN error.
1256 */
1257
1258struct sigqueue *sigqueue_alloc(void)
1259{
1260 struct sigqueue *q;
1261
1262 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1263 q->flags |= SIGQUEUE_PREALLOC;
1264 return(q);
1265}
1266
1267void sigqueue_free(struct sigqueue *q)
1268{
1269 unsigned long flags;
Oleg Nesterov60187d22007-08-30 23:56:35 -07001270 spinlock_t *lock = &current->sighand->siglock;
1271
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1273 /*
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001274 * We must hold ->siglock while testing q->list
1275 * to serialize with collect_signal() or with
Oleg Nesterovda7978b2008-05-23 13:04:41 -07001276 * __exit_signal()->flush_sigqueue().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 */
Oleg Nesterov60187d22007-08-30 23:56:35 -07001278 spin_lock_irqsave(lock, flags);
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001279 q->flags &= ~SIGQUEUE_PREALLOC;
1280 /*
1281 * If it is queued it will be freed when dequeued,
1282 * like the "regular" sigqueue.
1283 */
Oleg Nesterov60187d22007-08-30 23:56:35 -07001284 if (!list_empty(&q->list))
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001285 q = NULL;
Oleg Nesterov60187d22007-08-30 23:56:35 -07001286 spin_unlock_irqrestore(lock, flags);
1287
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001288 if (q)
1289 __sigqueue_free(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290}
1291
Oleg Nesterovac5c2152008-04-30 00:52:57 -07001292int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001293{
Oleg Nesterove62e6652008-04-30 00:52:56 -07001294 int sig = q->info.si_signo;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001295 struct sigpending *pending;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001296 unsigned long flags;
1297 int ret;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001298
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001299 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
Oleg Nesterove62e6652008-04-30 00:52:56 -07001300
1301 ret = -1;
1302 if (!likely(lock_task_sighand(t, &flags)))
1303 goto ret;
1304
Oleg Nesterov7e695a52008-04-30 00:52:59 -07001305 ret = 1; /* the signal is ignored */
1306 if (!prepare_signal(sig, t))
Oleg Nesterove62e6652008-04-30 00:52:56 -07001307 goto out;
1308
1309 ret = 0;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001310 if (unlikely(!list_empty(&q->list))) {
1311 /*
1312 * If an SI_TIMER entry is already queue just increment
1313 * the overrun count.
1314 */
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001315 BUG_ON(q->info.si_code != SI_TIMER);
1316 q->info.si_overrun++;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001317 goto out;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001318 }
1319
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001320 signalfd_notify(t, sig);
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001321 pending = group ? &t->signal->shared_pending : &t->pending;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001322 list_add_tail(&q->list, &pending->list);
1323 sigaddset(&pending->signal, sig);
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001324 complete_signal(sig, t, group);
Oleg Nesterove62e6652008-04-30 00:52:56 -07001325out:
1326 unlock_task_sighand(t, &flags);
1327ret:
1328 return ret;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001329}
1330
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331/*
1332 * Wake up any threads in the parent blocked in wait* syscalls.
1333 */
1334static inline void __wake_up_parent(struct task_struct *p,
1335 struct task_struct *parent)
1336{
1337 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1338}
1339
1340/*
1341 * Let a parent know about the death of a child.
1342 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1343 */
1344
1345void do_notify_parent(struct task_struct *tsk, int sig)
1346{
1347 struct siginfo info;
1348 unsigned long flags;
1349 struct sighand_struct *psig;
1350
1351 BUG_ON(sig == -1);
1352
1353 /* do_notify_parent_cldstop should have been called instead. */
Matthew Wilcoxe1abb392007-12-06 11:07:35 -05001354 BUG_ON(task_is_stopped_or_traced(tsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355
1356 BUG_ON(!tsk->ptrace &&
1357 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1358
1359 info.si_signo = sig;
1360 info.si_errno = 0;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001361 /*
1362 * we are under tasklist_lock here so our parent is tied to
1363 * us and cannot exit and release its namespace.
1364 *
1365 * the only it can is to switch its nsproxy with sys_unshare,
1366 * bu uncharing pid namespaces is not allowed, so we'll always
1367 * see relevant namespace
1368 *
1369 * write_lock() currently calls preempt_disable() which is the
1370 * same as rcu_read_lock(), but according to Oleg, this is not
1371 * correct to rely on this
1372 */
1373 rcu_read_lock();
1374 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1375 rcu_read_unlock();
1376
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 info.si_uid = tsk->uid;
1378
1379 /* FIXME: find out whether or not this is supposed to be c*time. */
1380 info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1381 tsk->signal->utime));
1382 info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1383 tsk->signal->stime));
1384
1385 info.si_status = tsk->exit_code & 0x7f;
1386 if (tsk->exit_code & 0x80)
1387 info.si_code = CLD_DUMPED;
1388 else if (tsk->exit_code & 0x7f)
1389 info.si_code = CLD_KILLED;
1390 else {
1391 info.si_code = CLD_EXITED;
1392 info.si_status = tsk->exit_code >> 8;
1393 }
1394
1395 psig = tsk->parent->sighand;
1396 spin_lock_irqsave(&psig->siglock, flags);
Oleg Nesterov7ed01752005-11-10 17:22:18 +03001397 if (!tsk->ptrace && sig == SIGCHLD &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1399 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1400 /*
1401 * We are exiting and our parent doesn't care. POSIX.1
1402 * defines special semantics for setting SIGCHLD to SIG_IGN
1403 * or setting the SA_NOCLDWAIT flag: we should be reaped
1404 * automatically and not left for our parent's wait4 call.
1405 * Rather than having the parent do it as a magic kind of
1406 * signal handler, we just set this to tell do_exit that we
1407 * can be cleaned up without becoming a zombie. Note that
1408 * we still call __wake_up_parent in this case, because a
1409 * blocked sys_wait4 might now return -ECHILD.
1410 *
1411 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1412 * is implementation-defined: we do (if you don't want
1413 * it, just use SIG_IGN instead).
1414 */
1415 tsk->exit_signal = -1;
1416 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1417 sig = 0;
1418 }
Jesper Juhl7ed20e12005-05-01 08:59:14 -07001419 if (valid_signal(sig) && sig > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 __group_send_sig_info(sig, &info, tsk->parent);
1421 __wake_up_parent(tsk, tsk->parent);
1422 spin_unlock_irqrestore(&psig->siglock, flags);
1423}
1424
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001425static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426{
1427 struct siginfo info;
1428 unsigned long flags;
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001429 struct task_struct *parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 struct sighand_struct *sighand;
1431
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001432 if (tsk->ptrace & PT_PTRACED)
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001433 parent = tsk->parent;
1434 else {
1435 tsk = tsk->group_leader;
1436 parent = tsk->real_parent;
1437 }
1438
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 info.si_signo = SIGCHLD;
1440 info.si_errno = 0;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001441 /*
1442 * see comment in do_notify_parent() abot the following 3 lines
1443 */
1444 rcu_read_lock();
1445 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1446 rcu_read_unlock();
1447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 info.si_uid = tsk->uid;
1449
1450 /* FIXME: find out whether or not this is supposed to be c*time. */
1451 info.si_utime = cputime_to_jiffies(tsk->utime);
1452 info.si_stime = cputime_to_jiffies(tsk->stime);
1453
1454 info.si_code = why;
1455 switch (why) {
1456 case CLD_CONTINUED:
1457 info.si_status = SIGCONT;
1458 break;
1459 case CLD_STOPPED:
1460 info.si_status = tsk->signal->group_exit_code & 0x7f;
1461 break;
1462 case CLD_TRAPPED:
1463 info.si_status = tsk->exit_code & 0x7f;
1464 break;
1465 default:
1466 BUG();
1467 }
1468
1469 sighand = parent->sighand;
1470 spin_lock_irqsave(&sighand->siglock, flags);
1471 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1472 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1473 __group_send_sig_info(SIGCHLD, &info, parent);
1474 /*
1475 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1476 */
1477 __wake_up_parent(tsk, parent);
1478 spin_unlock_irqrestore(&sighand->siglock, flags);
1479}
1480
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001481static inline int may_ptrace_stop(void)
1482{
1483 if (!likely(current->ptrace & PT_PTRACED))
1484 return 0;
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001485 /*
1486 * Are we in the middle of do_coredump?
1487 * If so and our tracer is also part of the coredump stopping
1488 * is a deadlock situation, and pointless because our tracer
1489 * is dead so don't allow us to stop.
1490 * If SIGKILL was already sent before the caller unlocked
1491 * ->siglock we must see ->core_waiters != 0. Otherwise it
1492 * is safe to enter schedule().
1493 */
1494 if (unlikely(current->mm->core_waiters) &&
1495 unlikely(current->mm == current->parent->mm))
1496 return 0;
1497
1498 return 1;
1499}
1500
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501/*
Roland McGrath1a669c22008-02-06 01:37:37 -08001502 * Return nonzero if there is a SIGKILL that should be waking us up.
1503 * Called with the siglock held.
1504 */
1505static int sigkill_pending(struct task_struct *tsk)
1506{
1507 return ((sigismember(&tsk->pending.signal, SIGKILL) ||
1508 sigismember(&tsk->signal->shared_pending.signal, SIGKILL)) &&
1509 !unlikely(sigismember(&tsk->blocked, SIGKILL)));
1510}
1511
1512/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 * This must be called with current->sighand->siglock held.
1514 *
1515 * This should be the path for all ptrace stops.
1516 * We always set current->last_siginfo while stopped here.
1517 * That makes it a way to test a stopped process for
1518 * being ptrace-stopped vs being job-control-stopped.
1519 *
Oleg Nesterov20686a32008-02-08 04:19:03 -08001520 * If we actually decide not to stop at all because the tracer
1521 * is gone, we keep current->exit_code unless clear_code.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 */
Oleg Nesterov20686a32008-02-08 04:19:03 -08001523static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524{
Roland McGrath1a669c22008-02-06 01:37:37 -08001525 int killed = 0;
1526
1527 if (arch_ptrace_stop_needed(exit_code, info)) {
1528 /*
1529 * The arch code has something special to do before a
1530 * ptrace stop. This is allowed to block, e.g. for faults
1531 * on user stack pages. We can't keep the siglock while
1532 * calling arch_ptrace_stop, so we must release it now.
1533 * To preserve proper semantics, we must do this before
1534 * any signal bookkeeping like checking group_stop_count.
1535 * Meanwhile, a SIGKILL could come in before we retake the
1536 * siglock. That must prevent us from sleeping in TASK_TRACED.
1537 * So after regaining the lock, we must check for SIGKILL.
1538 */
1539 spin_unlock_irq(&current->sighand->siglock);
1540 arch_ptrace_stop(exit_code, info);
1541 spin_lock_irq(&current->sighand->siglock);
1542 killed = sigkill_pending(current);
1543 }
1544
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 /*
1546 * If there is a group stop in progress,
1547 * we must participate in the bookkeeping.
1548 */
1549 if (current->signal->group_stop_count > 0)
1550 --current->signal->group_stop_count;
1551
1552 current->last_siginfo = info;
1553 current->exit_code = exit_code;
1554
1555 /* Let the debugger run. */
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -08001556 __set_current_state(TASK_TRACED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 spin_unlock_irq(&current->sighand->siglock);
1558 read_lock(&tasklist_lock);
Roland McGrath1a669c22008-02-06 01:37:37 -08001559 if (!unlikely(killed) && may_ptrace_stop()) {
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001560 do_notify_parent_cldstop(current, CLD_TRAPPED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 read_unlock(&tasklist_lock);
1562 schedule();
1563 } else {
1564 /*
1565 * By the time we got the lock, our tracer went away.
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001566 * Don't drop the lock yet, another tracer may come.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 */
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001568 __set_current_state(TASK_RUNNING);
Oleg Nesterov20686a32008-02-08 04:19:03 -08001569 if (clear_code)
1570 current->exit_code = 0;
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001571 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 }
1573
1574 /*
Roland McGrath13b1c3d2008-03-03 20:22:05 -08001575 * While in TASK_TRACED, we were considered "frozen enough".
1576 * Now that we woke up, it's crucial if we're supposed to be
1577 * frozen that we freeze now before running anything substantial.
1578 */
1579 try_to_freeze();
1580
1581 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 * We are back. Now reacquire the siglock before touching
1583 * last_siginfo, so that we are sure to have synchronized with
1584 * any signal-sending on another CPU that wants to examine it.
1585 */
1586 spin_lock_irq(&current->sighand->siglock);
1587 current->last_siginfo = NULL;
1588
1589 /*
1590 * Queued signals ignored us while we were stopped for tracing.
1591 * So check for any that we should take before resuming user mode.
Roland McGrathb74d0de2007-06-06 03:59:00 -07001592 * This sets TIF_SIGPENDING, but never clears it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 */
Roland McGrathb74d0de2007-06-06 03:59:00 -07001594 recalc_sigpending_tsk(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595}
1596
1597void ptrace_notify(int exit_code)
1598{
1599 siginfo_t info;
1600
1601 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1602
1603 memset(&info, 0, sizeof info);
1604 info.si_signo = SIGTRAP;
1605 info.si_code = exit_code;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001606 info.si_pid = task_pid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 info.si_uid = current->uid;
1608
1609 /* Let the debugger run. */
1610 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterov20686a32008-02-08 04:19:03 -08001611 ptrace_stop(exit_code, 1, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 spin_unlock_irq(&current->sighand->siglock);
1613}
1614
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615static void
1616finish_stop(int stop_count)
1617{
1618 /*
1619 * If there are no other threads in the group, or if there is
1620 * a group stop in progress and we are the last to stop,
1621 * report to the parent. When ptraced, every thread reports itself.
1622 */
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001623 if (stop_count == 0 || (current->ptrace & PT_PTRACED)) {
1624 read_lock(&tasklist_lock);
1625 do_notify_parent_cldstop(current, CLD_STOPPED);
1626 read_unlock(&tasklist_lock);
1627 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628
Rafael J. Wysocki3df494a2006-12-13 00:34:28 -08001629 do {
1630 schedule();
1631 } while (try_to_freeze());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 /*
1633 * Now we don't run again until continued.
1634 */
1635 current->exit_code = 0;
1636}
1637
1638/*
1639 * This performs the stopping for SIGSTOP and other stop signals.
1640 * We have to stop all threads in the thread group.
1641 * Returns nonzero if we've actually stopped and released the siglock.
1642 * Returns zero if we didn't stop and still hold the siglock.
1643 */
Oleg Nesterova122b342006-03-28 16:11:22 -08001644static int do_signal_stop(int signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645{
1646 struct signal_struct *sig = current->signal;
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001647 int stop_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 if (sig->group_stop_count > 0) {
1650 /*
1651 * There is a group stop in progress. We don't need to
1652 * start another one.
1653 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 stop_count = --sig->group_stop_count;
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001655 } else {
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08001656 struct task_struct *t;
1657
Oleg Nesterovfae5fa42008-04-30 00:53:03 -07001658 if (unlikely((sig->flags & (SIGNAL_STOP_DEQUEUED | SIGNAL_UNKILLABLE))
1659 != SIGNAL_STOP_DEQUEUED) ||
Oleg Nesterov573cf9a2008-04-30 00:52:36 -07001660 unlikely(signal_group_exit(sig)))
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08001661 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 * There is no group stop already in progress.
Oleg Nesterova122b342006-03-28 16:11:22 -08001664 * We must initiate one now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 */
Oleg Nesterova122b342006-03-28 16:11:22 -08001666 sig->group_exit_code = signr;
1667
1668 stop_count = 0;
1669 for (t = next_thread(current); t != current; t = next_thread(t))
1670 /*
1671 * Setting state to TASK_STOPPED for a group
1672 * stop is always done with the siglock held,
1673 * so this check has no races.
1674 */
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001675 if (!(t->flags & PF_EXITING) &&
Matthew Wilcoxe1abb392007-12-06 11:07:35 -05001676 !task_is_stopped_or_traced(t)) {
Oleg Nesterova122b342006-03-28 16:11:22 -08001677 stop_count++;
1678 signal_wake_up(t, 0);
1679 }
1680 sig->group_stop_count = stop_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 }
1682
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001683 if (stop_count == 0)
1684 sig->flags = SIGNAL_STOP_STOPPED;
1685 current->exit_code = sig->group_exit_code;
1686 __set_current_state(TASK_STOPPED);
1687
1688 spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 finish_stop(stop_count);
1690 return 1;
1691}
1692
Roland McGrath18c98b62008-04-17 18:44:38 -07001693static int ptrace_signal(int signr, siginfo_t *info,
1694 struct pt_regs *regs, void *cookie)
1695{
1696 if (!(current->ptrace & PT_PTRACED))
1697 return signr;
1698
1699 ptrace_signal_deliver(regs, cookie);
1700
1701 /* Let the debugger run. */
1702 ptrace_stop(signr, 0, info);
1703
1704 /* We're back. Did the debugger cancel the sig? */
1705 signr = current->exit_code;
1706 if (signr == 0)
1707 return signr;
1708
1709 current->exit_code = 0;
1710
1711 /* Update the siginfo structure if the signal has
1712 changed. If the debugger wanted something
1713 specific in the siginfo structure then it should
1714 have updated *info via PTRACE_SETSIGINFO. */
1715 if (signr != info->si_signo) {
1716 info->si_signo = signr;
1717 info->si_errno = 0;
1718 info->si_code = SI_USER;
1719 info->si_pid = task_pid_vnr(current->parent);
1720 info->si_uid = current->parent->uid;
1721 }
1722
1723 /* If the (new) signal is now blocked, requeue it. */
1724 if (sigismember(&current->blocked, signr)) {
1725 specific_send_sig_info(signr, info, current);
1726 signr = 0;
1727 }
1728
1729 return signr;
1730}
1731
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1733 struct pt_regs *regs, void *cookie)
1734{
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001735 struct sighand_struct *sighand = current->sighand;
1736 struct signal_struct *signal = current->signal;
1737 int signr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738
Roland McGrath13b1c3d2008-03-03 20:22:05 -08001739relock:
1740 /*
1741 * We'll jump back here after any time we were stopped in TASK_STOPPED.
1742 * While in TASK_STOPPED, we were considered "frozen enough".
1743 * Now that we woke up, it's crucial if we're supposed to be
1744 * frozen that we freeze now before running anything substantial.
1745 */
Rafael J. Wysockifc558a72006-03-23 03:00:05 -08001746 try_to_freeze();
1747
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001748 spin_lock_irq(&sighand->siglock);
Oleg Nesterov021e1ae2008-04-30 00:53:00 -07001749 /*
1750 * Every stopped thread goes here after wakeup. Check to see if
1751 * we should notify the parent, prepare_signal(SIGCONT) encodes
1752 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
1753 */
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001754 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
1755 int why = (signal->flags & SIGNAL_STOP_CONTINUED)
Oleg Nesterove4420552008-04-30 00:52:44 -07001756 ? CLD_CONTINUED : CLD_STOPPED;
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001757 signal->flags &= ~SIGNAL_CLD_MASK;
1758 spin_unlock_irq(&sighand->siglock);
Oleg Nesterove4420552008-04-30 00:52:44 -07001759
1760 read_lock(&tasklist_lock);
1761 do_notify_parent_cldstop(current->group_leader, why);
1762 read_unlock(&tasklist_lock);
1763 goto relock;
1764 }
1765
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 for (;;) {
1767 struct k_sigaction *ka;
1768
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001769 if (unlikely(signal->group_stop_count > 0) &&
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08001770 do_signal_stop(0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 goto relock;
1772
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001773 signr = dequeue_signal(current, &current->blocked, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 if (!signr)
1775 break; /* will return 0 */
1776
Roland McGrath18c98b62008-04-17 18:44:38 -07001777 if (signr != SIGKILL) {
1778 signr = ptrace_signal(signr, info, regs, cookie);
1779 if (!signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 }
1782
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001783 ka = &sighand->action[signr-1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1785 continue;
1786 if (ka->sa.sa_handler != SIG_DFL) {
1787 /* Run the handler. */
1788 *return_ka = *ka;
1789
1790 if (ka->sa.sa_flags & SA_ONESHOT)
1791 ka->sa.sa_handler = SIG_DFL;
1792
1793 break; /* will return non-zero "signr" value */
1794 }
1795
1796 /*
1797 * Now we are doing the default action for this signal.
1798 */
1799 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1800 continue;
1801
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -08001802 /*
Sukadev Bhattiprolu0fbc26a2007-10-18 23:40:13 -07001803 * Global init gets no signals it doesn't want.
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -08001804 */
Oleg Nesterovfae5fa42008-04-30 00:53:03 -07001805 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
1806 !signal_group_exit(signal))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 continue;
1808
1809 if (sig_kernel_stop(signr)) {
1810 /*
1811 * The default action is to stop all threads in
1812 * the thread group. The job control signals
1813 * do nothing in an orphaned pgrp, but SIGSTOP
1814 * always works. Note that siglock needs to be
1815 * dropped during the call to is_orphaned_pgrp()
1816 * because of lock ordering with tasklist_lock.
1817 * This allows an intervening SIGCONT to be posted.
1818 * We need to check for that and bail out if necessary.
1819 */
1820 if (signr != SIGSTOP) {
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001821 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822
1823 /* signals can be posted during this window */
1824
Eric W. Biederman3e7cd6c2007-02-12 00:52:58 -08001825 if (is_current_pgrp_orphaned())
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 goto relock;
1827
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001828 spin_lock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 }
1830
1831 if (likely(do_signal_stop(signr))) {
1832 /* It released the siglock. */
1833 goto relock;
1834 }
1835
1836 /*
1837 * We didn't actually stop, due to a race
1838 * with SIGCONT or something like that.
1839 */
1840 continue;
1841 }
1842
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001843 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844
1845 /*
1846 * Anything else is fatal, maybe with a core dump.
1847 */
1848 current->flags |= PF_SIGNALED;
Oleg Nesterov2dce81b2008-04-30 00:52:58 -07001849
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 if (sig_kernel_coredump(signr)) {
Oleg Nesterov2dce81b2008-04-30 00:52:58 -07001851 if (print_fatal_signals)
1852 print_fatal_signal(regs, signr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 /*
1854 * If it was able to dump core, this kills all
1855 * other threads in the group and synchronizes with
1856 * their demise. If we lost the race with another
1857 * thread getting here, it set group_exit_code
1858 * first and our do_group_exit call below will use
1859 * that value and ignore the one we pass it.
1860 */
1861 do_coredump((long)signr, signr, regs);
1862 }
1863
1864 /*
1865 * Death signals, no core dump.
1866 */
1867 do_group_exit(signr);
1868 /* NOTREACHED */
1869 }
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001870 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 return signr;
1872}
1873
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001874void exit_signals(struct task_struct *tsk)
1875{
1876 int group_stop = 0;
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001877 struct task_struct *t;
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001878
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001879 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
1880 tsk->flags |= PF_EXITING;
1881 return;
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001882 }
1883
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001884 spin_lock_irq(&tsk->sighand->siglock);
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001885 /*
1886 * From now this task is not visible for group-wide signals,
1887 * see wants_signal(), do_signal_stop().
1888 */
1889 tsk->flags |= PF_EXITING;
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001890 if (!signal_pending(tsk))
1891 goto out;
1892
1893 /* It could be that __group_complete_signal() choose us to
1894 * notify about group-wide signal. Another thread should be
1895 * woken now to take the signal since we will not.
1896 */
1897 for (t = tsk; (t = next_thread(t)) != tsk; )
1898 if (!signal_pending(t) && !(t->flags & PF_EXITING))
1899 recalc_sigpending_and_wake(t);
1900
1901 if (unlikely(tsk->signal->group_stop_count) &&
1902 !--tsk->signal->group_stop_count) {
1903 tsk->signal->flags = SIGNAL_STOP_STOPPED;
1904 group_stop = 1;
1905 }
1906out:
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001907 spin_unlock_irq(&tsk->sighand->siglock);
1908
1909 if (unlikely(group_stop)) {
1910 read_lock(&tasklist_lock);
1911 do_notify_parent_cldstop(tsk, CLD_STOPPED);
1912 read_unlock(&tasklist_lock);
1913 }
1914}
1915
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916EXPORT_SYMBOL(recalc_sigpending);
1917EXPORT_SYMBOL_GPL(dequeue_signal);
1918EXPORT_SYMBOL(flush_signals);
1919EXPORT_SYMBOL(force_sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920EXPORT_SYMBOL(kill_proc);
1921EXPORT_SYMBOL(ptrace_notify);
1922EXPORT_SYMBOL(send_sig);
1923EXPORT_SYMBOL(send_sig_info);
1924EXPORT_SYMBOL(sigprocmask);
1925EXPORT_SYMBOL(block_all_signals);
1926EXPORT_SYMBOL(unblock_all_signals);
1927
1928
1929/*
1930 * System call entry points.
1931 */
1932
1933asmlinkage long sys_restart_syscall(void)
1934{
1935 struct restart_block *restart = &current_thread_info()->restart_block;
1936 return restart->fn(restart);
1937}
1938
1939long do_no_restart_syscall(struct restart_block *param)
1940{
1941 return -EINTR;
1942}
1943
1944/*
1945 * We don't need to get the kernel lock - this is all local to this
1946 * particular thread.. (and that's good, because this is _heavily_
1947 * used by various programs)
1948 */
1949
1950/*
1951 * This is also useful for kernel threads that want to temporarily
1952 * (or permanently) block certain signals.
1953 *
1954 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1955 * interface happily blocks "unblockable" signals like SIGKILL
1956 * and friends.
1957 */
1958int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
1959{
1960 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961
1962 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterova26fd332006-03-23 03:00:49 -08001963 if (oldset)
1964 *oldset = current->blocked;
1965
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 error = 0;
1967 switch (how) {
1968 case SIG_BLOCK:
1969 sigorsets(&current->blocked, &current->blocked, set);
1970 break;
1971 case SIG_UNBLOCK:
1972 signandsets(&current->blocked, &current->blocked, set);
1973 break;
1974 case SIG_SETMASK:
1975 current->blocked = *set;
1976 break;
1977 default:
1978 error = -EINVAL;
1979 }
1980 recalc_sigpending();
1981 spin_unlock_irq(&current->sighand->siglock);
Oleg Nesterova26fd332006-03-23 03:00:49 -08001982
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 return error;
1984}
1985
1986asmlinkage long
1987sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
1988{
1989 int error = -EINVAL;
1990 sigset_t old_set, new_set;
1991
1992 /* XXX: Don't preclude handling different sized sigset_t's. */
1993 if (sigsetsize != sizeof(sigset_t))
1994 goto out;
1995
1996 if (set) {
1997 error = -EFAULT;
1998 if (copy_from_user(&new_set, set, sizeof(*set)))
1999 goto out;
2000 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2001
2002 error = sigprocmask(how, &new_set, &old_set);
2003 if (error)
2004 goto out;
2005 if (oset)
2006 goto set_old;
2007 } else if (oset) {
2008 spin_lock_irq(&current->sighand->siglock);
2009 old_set = current->blocked;
2010 spin_unlock_irq(&current->sighand->siglock);
2011
2012 set_old:
2013 error = -EFAULT;
2014 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2015 goto out;
2016 }
2017 error = 0;
2018out:
2019 return error;
2020}
2021
2022long do_sigpending(void __user *set, unsigned long sigsetsize)
2023{
2024 long error = -EINVAL;
2025 sigset_t pending;
2026
2027 if (sigsetsize > sizeof(sigset_t))
2028 goto out;
2029
2030 spin_lock_irq(&current->sighand->siglock);
2031 sigorsets(&pending, &current->pending.signal,
2032 &current->signal->shared_pending.signal);
2033 spin_unlock_irq(&current->sighand->siglock);
2034
2035 /* Outside the lock because only this thread touches it. */
2036 sigandsets(&pending, &current->blocked, &pending);
2037
2038 error = -EFAULT;
2039 if (!copy_to_user(set, &pending, sigsetsize))
2040 error = 0;
2041
2042out:
2043 return error;
2044}
2045
2046asmlinkage long
2047sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2048{
2049 return do_sigpending(set, sigsetsize);
2050}
2051
2052#ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2053
2054int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2055{
2056 int err;
2057
2058 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2059 return -EFAULT;
2060 if (from->si_code < 0)
2061 return __copy_to_user(to, from, sizeof(siginfo_t))
2062 ? -EFAULT : 0;
2063 /*
2064 * If you change siginfo_t structure, please be sure
2065 * this code is fixed accordingly.
Davide Libenzifba2afa2007-05-10 22:23:13 -07002066 * Please remember to update the signalfd_copyinfo() function
2067 * inside fs/signalfd.c too, in case siginfo_t changes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068 * It should never copy any pad contained in the structure
2069 * to avoid security leaks, but must copy the generic
2070 * 3 ints plus the relevant union member.
2071 */
2072 err = __put_user(from->si_signo, &to->si_signo);
2073 err |= __put_user(from->si_errno, &to->si_errno);
2074 err |= __put_user((short)from->si_code, &to->si_code);
2075 switch (from->si_code & __SI_MASK) {
2076 case __SI_KILL:
2077 err |= __put_user(from->si_pid, &to->si_pid);
2078 err |= __put_user(from->si_uid, &to->si_uid);
2079 break;
2080 case __SI_TIMER:
2081 err |= __put_user(from->si_tid, &to->si_tid);
2082 err |= __put_user(from->si_overrun, &to->si_overrun);
2083 err |= __put_user(from->si_ptr, &to->si_ptr);
2084 break;
2085 case __SI_POLL:
2086 err |= __put_user(from->si_band, &to->si_band);
2087 err |= __put_user(from->si_fd, &to->si_fd);
2088 break;
2089 case __SI_FAULT:
2090 err |= __put_user(from->si_addr, &to->si_addr);
2091#ifdef __ARCH_SI_TRAPNO
2092 err |= __put_user(from->si_trapno, &to->si_trapno);
2093#endif
2094 break;
2095 case __SI_CHLD:
2096 err |= __put_user(from->si_pid, &to->si_pid);
2097 err |= __put_user(from->si_uid, &to->si_uid);
2098 err |= __put_user(from->si_status, &to->si_status);
2099 err |= __put_user(from->si_utime, &to->si_utime);
2100 err |= __put_user(from->si_stime, &to->si_stime);
2101 break;
2102 case __SI_RT: /* This is not generated by the kernel as of now. */
2103 case __SI_MESGQ: /* But this is */
2104 err |= __put_user(from->si_pid, &to->si_pid);
2105 err |= __put_user(from->si_uid, &to->si_uid);
2106 err |= __put_user(from->si_ptr, &to->si_ptr);
2107 break;
2108 default: /* this is just in case for now ... */
2109 err |= __put_user(from->si_pid, &to->si_pid);
2110 err |= __put_user(from->si_uid, &to->si_uid);
2111 break;
2112 }
2113 return err;
2114}
2115
2116#endif
2117
2118asmlinkage long
2119sys_rt_sigtimedwait(const sigset_t __user *uthese,
2120 siginfo_t __user *uinfo,
2121 const struct timespec __user *uts,
2122 size_t sigsetsize)
2123{
2124 int ret, sig;
2125 sigset_t these;
2126 struct timespec ts;
2127 siginfo_t info;
2128 long timeout = 0;
2129
2130 /* XXX: Don't preclude handling different sized sigset_t's. */
2131 if (sigsetsize != sizeof(sigset_t))
2132 return -EINVAL;
2133
2134 if (copy_from_user(&these, uthese, sizeof(these)))
2135 return -EFAULT;
2136
2137 /*
2138 * Invert the set of allowed signals to get those we
2139 * want to block.
2140 */
2141 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2142 signotset(&these);
2143
2144 if (uts) {
2145 if (copy_from_user(&ts, uts, sizeof(ts)))
2146 return -EFAULT;
2147 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2148 || ts.tv_sec < 0)
2149 return -EINVAL;
2150 }
2151
2152 spin_lock_irq(&current->sighand->siglock);
2153 sig = dequeue_signal(current, &these, &info);
2154 if (!sig) {
2155 timeout = MAX_SCHEDULE_TIMEOUT;
2156 if (uts)
2157 timeout = (timespec_to_jiffies(&ts)
2158 + (ts.tv_sec || ts.tv_nsec));
2159
2160 if (timeout) {
2161 /* None ready -- temporarily unblock those we're
2162 * interested while we are sleeping in so that we'll
2163 * be awakened when they arrive. */
2164 current->real_blocked = current->blocked;
2165 sigandsets(&current->blocked, &current->blocked, &these);
2166 recalc_sigpending();
2167 spin_unlock_irq(&current->sighand->siglock);
2168
Nishanth Aravamudan75bcc8c2005-09-10 00:27:24 -07002169 timeout = schedule_timeout_interruptible(timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171 spin_lock_irq(&current->sighand->siglock);
2172 sig = dequeue_signal(current, &these, &info);
2173 current->blocked = current->real_blocked;
2174 siginitset(&current->real_blocked, 0);
2175 recalc_sigpending();
2176 }
2177 }
2178 spin_unlock_irq(&current->sighand->siglock);
2179
2180 if (sig) {
2181 ret = sig;
2182 if (uinfo) {
2183 if (copy_siginfo_to_user(uinfo, &info))
2184 ret = -EFAULT;
2185 }
2186 } else {
2187 ret = -EAGAIN;
2188 if (timeout)
2189 ret = -EINTR;
2190 }
2191
2192 return ret;
2193}
2194
2195asmlinkage long
2196sys_kill(int pid, int sig)
2197{
2198 struct siginfo info;
2199
2200 info.si_signo = sig;
2201 info.si_errno = 0;
2202 info.si_code = SI_USER;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002203 info.si_pid = task_tgid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204 info.si_uid = current->uid;
2205
2206 return kill_something_info(sig, &info, pid);
2207}
2208
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002209static int do_tkill(int tgid, int pid, int sig)
2210{
2211 int error;
2212 struct siginfo info;
2213 struct task_struct *p;
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002214 unsigned long flags;
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002215
2216 error = -ESRCH;
2217 info.si_signo = sig;
2218 info.si_errno = 0;
2219 info.si_code = SI_TKILL;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002220 info.si_pid = task_tgid_vnr(current);
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002221 info.si_uid = current->uid;
2222
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002223 rcu_read_lock();
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -07002224 p = find_task_by_vpid(pid);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002225 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002226 error = check_kill_permission(sig, &info, p);
2227 /*
2228 * The null signal is a permissions and process existence
2229 * probe. No signal is actually delivered.
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002230 *
2231 * If lock_task_sighand() fails we pretend the task dies
2232 * after receiving the signal. The window is tiny, and the
2233 * signal is private anyway.
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002234 */
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002235 if (!error && sig && lock_task_sighand(p, &flags)) {
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002236 error = specific_send_sig_info(sig, &info, p);
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002237 unlock_task_sighand(p, &flags);
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002238 }
2239 }
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002240 rcu_read_unlock();
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002241
2242 return error;
2243}
2244
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245/**
2246 * sys_tgkill - send signal to one specific thread
2247 * @tgid: the thread group ID of the thread
2248 * @pid: the PID of the thread
2249 * @sig: signal to be sent
2250 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08002251 * This syscall also checks the @tgid and returns -ESRCH even if the PID
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252 * exists but it's not belonging to the target process anymore. This
2253 * method solves the problem of threads exiting and PIDs getting reused.
2254 */
2255asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2256{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257 /* This is only valid for single tasks */
2258 if (pid <= 0 || tgid <= 0)
2259 return -EINVAL;
2260
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002261 return do_tkill(tgid, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262}
2263
2264/*
2265 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2266 */
2267asmlinkage long
2268sys_tkill(int pid, int sig)
2269{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 /* This is only valid for single tasks */
2271 if (pid <= 0)
2272 return -EINVAL;
2273
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002274 return do_tkill(0, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275}
2276
2277asmlinkage long
2278sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2279{
2280 siginfo_t info;
2281
2282 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2283 return -EFAULT;
2284
2285 /* Not even root can pretend to send signals from the kernel.
2286 Nor can they impersonate a kill(), which adds source info. */
2287 if (info.si_code >= 0)
2288 return -EPERM;
2289 info.si_signo = sig;
2290
2291 /* POSIX.1b doesn't mention process groups. */
2292 return kill_proc_info(sig, &info, pid);
2293}
2294
Oleg Nesterov88531f72006-03-28 16:11:24 -08002295int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296{
Pavel Emelyanov93585ee2008-04-30 00:52:39 -07002297 struct task_struct *t = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 struct k_sigaction *k;
George Anzinger71fabd52006-01-08 01:02:48 -08002299 sigset_t mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300
Jesper Juhl7ed20e12005-05-01 08:59:14 -07002301 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 return -EINVAL;
2303
Pavel Emelyanov93585ee2008-04-30 00:52:39 -07002304 k = &t->sighand->action[sig-1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305
2306 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 if (oact)
2308 *oact = *k;
2309
2310 if (act) {
Oleg Nesterov9ac95f22006-02-09 22:41:50 +03002311 sigdelsetmask(&act->sa.sa_mask,
2312 sigmask(SIGKILL) | sigmask(SIGSTOP));
Oleg Nesterov88531f72006-03-28 16:11:24 -08002313 *k = *act;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 /*
2315 * POSIX 3.3.1.3:
2316 * "Setting a signal action to SIG_IGN for a signal that is
2317 * pending shall cause the pending signal to be discarded,
2318 * whether or not it is blocked."
2319 *
2320 * "Setting a signal action to SIG_DFL for a signal that is
2321 * pending and whose default action is to ignore the signal
2322 * (for example, SIGCHLD), shall cause the pending signal to
2323 * be discarded, whether or not it is blocked"
2324 */
Pavel Emelyanov93585ee2008-04-30 00:52:39 -07002325 if (__sig_ignored(t, sig)) {
George Anzinger71fabd52006-01-08 01:02:48 -08002326 sigemptyset(&mask);
2327 sigaddset(&mask, sig);
2328 rm_from_queue_full(&mask, &t->signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 do {
George Anzinger71fabd52006-01-08 01:02:48 -08002330 rm_from_queue_full(&mask, &t->pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 t = next_thread(t);
2332 } while (t != current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 }
2335
2336 spin_unlock_irq(&current->sighand->siglock);
2337 return 0;
2338}
2339
2340int
2341do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2342{
2343 stack_t oss;
2344 int error;
2345
2346 if (uoss) {
2347 oss.ss_sp = (void __user *) current->sas_ss_sp;
2348 oss.ss_size = current->sas_ss_size;
2349 oss.ss_flags = sas_ss_flags(sp);
2350 }
2351
2352 if (uss) {
2353 void __user *ss_sp;
2354 size_t ss_size;
2355 int ss_flags;
2356
2357 error = -EFAULT;
2358 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2359 || __get_user(ss_sp, &uss->ss_sp)
2360 || __get_user(ss_flags, &uss->ss_flags)
2361 || __get_user(ss_size, &uss->ss_size))
2362 goto out;
2363
2364 error = -EPERM;
2365 if (on_sig_stack(sp))
2366 goto out;
2367
2368 error = -EINVAL;
2369 /*
2370 *
2371 * Note - this code used to test ss_flags incorrectly
2372 * old code may have been written using ss_flags==0
2373 * to mean ss_flags==SS_ONSTACK (as this was the only
2374 * way that worked) - this fix preserves that older
2375 * mechanism
2376 */
2377 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2378 goto out;
2379
2380 if (ss_flags == SS_DISABLE) {
2381 ss_size = 0;
2382 ss_sp = NULL;
2383 } else {
2384 error = -ENOMEM;
2385 if (ss_size < MINSIGSTKSZ)
2386 goto out;
2387 }
2388
2389 current->sas_ss_sp = (unsigned long) ss_sp;
2390 current->sas_ss_size = ss_size;
2391 }
2392
2393 if (uoss) {
2394 error = -EFAULT;
2395 if (copy_to_user(uoss, &oss, sizeof(oss)))
2396 goto out;
2397 }
2398
2399 error = 0;
2400out:
2401 return error;
2402}
2403
2404#ifdef __ARCH_WANT_SYS_SIGPENDING
2405
2406asmlinkage long
2407sys_sigpending(old_sigset_t __user *set)
2408{
2409 return do_sigpending(set, sizeof(*set));
2410}
2411
2412#endif
2413
2414#ifdef __ARCH_WANT_SYS_SIGPROCMASK
2415/* Some platforms have their own version with special arguments others
2416 support only sys_rt_sigprocmask. */
2417
2418asmlinkage long
2419sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2420{
2421 int error;
2422 old_sigset_t old_set, new_set;
2423
2424 if (set) {
2425 error = -EFAULT;
2426 if (copy_from_user(&new_set, set, sizeof(*set)))
2427 goto out;
2428 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2429
2430 spin_lock_irq(&current->sighand->siglock);
2431 old_set = current->blocked.sig[0];
2432
2433 error = 0;
2434 switch (how) {
2435 default:
2436 error = -EINVAL;
2437 break;
2438 case SIG_BLOCK:
2439 sigaddsetmask(&current->blocked, new_set);
2440 break;
2441 case SIG_UNBLOCK:
2442 sigdelsetmask(&current->blocked, new_set);
2443 break;
2444 case SIG_SETMASK:
2445 current->blocked.sig[0] = new_set;
2446 break;
2447 }
2448
2449 recalc_sigpending();
2450 spin_unlock_irq(&current->sighand->siglock);
2451 if (error)
2452 goto out;
2453 if (oset)
2454 goto set_old;
2455 } else if (oset) {
2456 old_set = current->blocked.sig[0];
2457 set_old:
2458 error = -EFAULT;
2459 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2460 goto out;
2461 }
2462 error = 0;
2463out:
2464 return error;
2465}
2466#endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2467
2468#ifdef __ARCH_WANT_SYS_RT_SIGACTION
2469asmlinkage long
2470sys_rt_sigaction(int sig,
2471 const struct sigaction __user *act,
2472 struct sigaction __user *oact,
2473 size_t sigsetsize)
2474{
2475 struct k_sigaction new_sa, old_sa;
2476 int ret = -EINVAL;
2477
2478 /* XXX: Don't preclude handling different sized sigset_t's. */
2479 if (sigsetsize != sizeof(sigset_t))
2480 goto out;
2481
2482 if (act) {
2483 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2484 return -EFAULT;
2485 }
2486
2487 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2488
2489 if (!ret && oact) {
2490 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2491 return -EFAULT;
2492 }
2493out:
2494 return ret;
2495}
2496#endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2497
2498#ifdef __ARCH_WANT_SYS_SGETMASK
2499
2500/*
2501 * For backwards compatibility. Functionality superseded by sigprocmask.
2502 */
2503asmlinkage long
2504sys_sgetmask(void)
2505{
2506 /* SMP safe */
2507 return current->blocked.sig[0];
2508}
2509
2510asmlinkage long
2511sys_ssetmask(int newmask)
2512{
2513 int old;
2514
2515 spin_lock_irq(&current->sighand->siglock);
2516 old = current->blocked.sig[0];
2517
2518 siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2519 sigmask(SIGSTOP)));
2520 recalc_sigpending();
2521 spin_unlock_irq(&current->sighand->siglock);
2522
2523 return old;
2524}
2525#endif /* __ARCH_WANT_SGETMASK */
2526
2527#ifdef __ARCH_WANT_SYS_SIGNAL
2528/*
2529 * For backwards compatibility. Functionality superseded by sigaction.
2530 */
2531asmlinkage unsigned long
2532sys_signal(int sig, __sighandler_t handler)
2533{
2534 struct k_sigaction new_sa, old_sa;
2535 int ret;
2536
2537 new_sa.sa.sa_handler = handler;
2538 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
Oleg Nesterovc70d3d72006-02-09 22:41:41 +03002539 sigemptyset(&new_sa.sa.sa_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540
2541 ret = do_sigaction(sig, &new_sa, &old_sa);
2542
2543 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2544}
2545#endif /* __ARCH_WANT_SYS_SIGNAL */
2546
2547#ifdef __ARCH_WANT_SYS_PAUSE
2548
2549asmlinkage long
2550sys_pause(void)
2551{
2552 current->state = TASK_INTERRUPTIBLE;
2553 schedule();
2554 return -ERESTARTNOHAND;
2555}
2556
2557#endif
2558
David Woodhouse150256d2006-01-18 17:43:57 -08002559#ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2560asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2561{
2562 sigset_t newset;
2563
2564 /* XXX: Don't preclude handling different sized sigset_t's. */
2565 if (sigsetsize != sizeof(sigset_t))
2566 return -EINVAL;
2567
2568 if (copy_from_user(&newset, unewset, sizeof(newset)))
2569 return -EFAULT;
2570 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2571
2572 spin_lock_irq(&current->sighand->siglock);
2573 current->saved_sigmask = current->blocked;
2574 current->blocked = newset;
2575 recalc_sigpending();
2576 spin_unlock_irq(&current->sighand->siglock);
2577
2578 current->state = TASK_INTERRUPTIBLE;
2579 schedule();
Roland McGrath4e4c22c2008-04-30 00:53:06 -07002580 set_restore_sigmask();
David Woodhouse150256d2006-01-18 17:43:57 -08002581 return -ERESTARTNOHAND;
2582}
2583#endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2584
David Howellsf269fdd2006-09-27 01:50:23 -07002585__attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2586{
2587 return NULL;
2588}
2589
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590void __init signals_init(void)
2591{
Christoph Lameter0a31bd52007-05-06 14:49:57 -07002592 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002593}