blob: 0a873279393c37e83b40557e56bc1e2d8c884a06 [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 Nesterov10ab8252007-05-09 02:34:37 -0700234void ignore_signals(struct task_struct *t)
235{
236 int i;
237
238 for (i = 0; i < _NSIG; ++i)
239 t->sighand->action[i].sa.sa_handler = SIG_IGN;
240
241 flush_signals(t);
242}
243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 * Flush all handlers for a task.
246 */
247
248void
249flush_signal_handlers(struct task_struct *t, int force_default)
250{
251 int i;
252 struct k_sigaction *ka = &t->sighand->action[0];
253 for (i = _NSIG ; i != 0 ; i--) {
254 if (force_default || ka->sa.sa_handler != SIG_IGN)
255 ka->sa.sa_handler = SIG_DFL;
256 ka->sa.sa_flags = 0;
257 sigemptyset(&ka->sa.sa_mask);
258 ka++;
259 }
260}
261
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200262int unhandled_signal(struct task_struct *tsk, int sig)
263{
Serge E. Hallynb460cbc2007-10-18 23:39:52 -0700264 if (is_global_init(tsk))
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200265 return 1;
266 if (tsk->ptrace & PT_PTRACED)
267 return 0;
268 return (tsk->sighand->action[sig-1].sa.sa_handler == SIG_IGN) ||
269 (tsk->sighand->action[sig-1].sa.sa_handler == SIG_DFL);
270}
271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
273/* Notify the system that a driver wants to block all signals for this
274 * process, and wants to be notified if any signals at all were to be
275 * sent/acted upon. If the notifier routine returns non-zero, then the
276 * signal will be acted upon after all. If the notifier routine returns 0,
277 * then then signal will be blocked. Only one block per process is
278 * allowed. priv is a pointer to private data that the notifier routine
279 * can use to determine if the signal should be blocked or not. */
280
281void
282block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
283{
284 unsigned long flags;
285
286 spin_lock_irqsave(&current->sighand->siglock, flags);
287 current->notifier_mask = mask;
288 current->notifier_data = priv;
289 current->notifier = notifier;
290 spin_unlock_irqrestore(&current->sighand->siglock, flags);
291}
292
293/* Notify the system that blocking has ended. */
294
295void
296unblock_all_signals(void)
297{
298 unsigned long flags;
299
300 spin_lock_irqsave(&current->sighand->siglock, flags);
301 current->notifier = NULL;
302 current->notifier_data = NULL;
303 recalc_sigpending();
304 spin_unlock_irqrestore(&current->sighand->siglock, flags);
305}
306
Arjan van de Ven858119e2006-01-14 13:20:43 -0800307static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308{
309 struct sigqueue *q, *first = NULL;
310 int still_pending = 0;
311
312 if (unlikely(!sigismember(&list->signal, sig)))
313 return 0;
314
315 /*
316 * Collect the siginfo appropriate to this signal. Check if
317 * there is another siginfo for the same signal.
318 */
319 list_for_each_entry(q, &list->list, list) {
320 if (q->info.si_signo == sig) {
321 if (first) {
322 still_pending = 1;
323 break;
324 }
325 first = q;
326 }
327 }
328 if (first) {
329 list_del_init(&first->list);
330 copy_siginfo(info, &first->info);
331 __sigqueue_free(first);
332 if (!still_pending)
333 sigdelset(&list->signal, sig);
334 } else {
335
336 /* Ok, it wasn't in the queue. This must be
337 a fast-pathed signal or we must have been
338 out of queue space. So zero out the info.
339 */
340 sigdelset(&list->signal, sig);
341 info->si_signo = sig;
342 info->si_errno = 0;
343 info->si_code = 0;
344 info->si_pid = 0;
345 info->si_uid = 0;
346 }
347 return 1;
348}
349
350static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
351 siginfo_t *info)
352{
Roland McGrath27d91e02006-09-29 02:00:31 -0700353 int sig = next_signal(pending, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 if (sig) {
356 if (current->notifier) {
357 if (sigismember(current->notifier_mask, sig)) {
358 if (!(current->notifier)(current->notifier_data)) {
359 clear_thread_flag(TIF_SIGPENDING);
360 return 0;
361 }
362 }
363 }
364
365 if (!collect_signal(sig, pending, info))
366 sig = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
369 return sig;
370}
371
372/*
373 * Dequeue a signal and return the element to the caller, which is
374 * expected to free it.
375 *
376 * All callers have to hold the siglock.
377 */
378int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
379{
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700380 int signr;
Benjamin Herrenschmidtcaec4e82007-06-12 08:16:18 +1000381
382 /* We only dequeue private signals from ourselves, we don't let
383 * signalfd steal them
384 */
Davide Libenzib8fceee2007-09-20 12:40:16 -0700385 signr = __dequeue_signal(&tsk->pending, mask, info);
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800386 if (!signr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 signr = __dequeue_signal(&tsk->signal->shared_pending,
388 mask, info);
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800389 /*
390 * itimer signal ?
391 *
392 * itimers are process shared and we restart periodic
393 * itimers in the signal delivery path to prevent DoS
394 * attacks in the high resolution timer case. This is
395 * compliant with the old way of self restarting
396 * itimers, as the SIGALRM is a legacy signal and only
397 * queued once. Changing the restart behaviour to
398 * restart the timer in the signal dequeue path is
399 * reducing the timer noise on heavy loaded !highres
400 * systems too.
401 */
402 if (unlikely(signr == SIGALRM)) {
403 struct hrtimer *tmr = &tsk->signal->real_timer;
404
405 if (!hrtimer_is_queued(tmr) &&
406 tsk->signal->it_real_incr.tv64 != 0) {
407 hrtimer_forward(tmr, tmr->base->get_time(),
408 tsk->signal->it_real_incr);
409 hrtimer_restart(tmr);
410 }
411 }
412 }
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700413
Davide Libenzib8fceee2007-09-20 12:40:16 -0700414 recalc_sigpending();
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700415 if (!signr)
416 return 0;
417
418 if (unlikely(sig_kernel_stop(signr))) {
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800419 /*
420 * Set a marker that we have dequeued a stop signal. Our
421 * caller might release the siglock and then the pending
422 * stop signal it is about to process is no longer in the
423 * pending bitmasks, but must still be cleared by a SIGCONT
424 * (and overruled by a SIGKILL). So those cases clear this
425 * shared flag after we've set it. Note that this flag may
426 * remain set after the signal we return is ignored or
427 * handled. That doesn't matter because its only purpose
428 * is to alert stop-signal processing code when another
429 * processor has come along and cleared the flag.
430 */
431 if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
432 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
433 }
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700434 if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 /*
436 * Release the siglock to ensure proper locking order
437 * of timer locks outside of siglocks. Note, we leave
438 * irqs disabled here, since the posix-timers code is
439 * about to disable them again anyway.
440 */
441 spin_unlock(&tsk->sighand->siglock);
442 do_schedule_next_timer(info);
443 spin_lock(&tsk->sighand->siglock);
444 }
445 return signr;
446}
447
448/*
449 * Tell a process that it has a new active signal..
450 *
451 * NOTE! we rely on the previous spin_lock to
452 * lock interrupts for us! We can only be called with
453 * "siglock" held, and the local interrupt must
454 * have been disabled when that got acquired!
455 *
456 * No need to set need_resched since signal event passing
457 * goes through ->blocked
458 */
459void signal_wake_up(struct task_struct *t, int resume)
460{
461 unsigned int mask;
462
463 set_tsk_thread_flag(t, TIF_SIGPENDING);
464
465 /*
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500466 * For SIGKILL, we want to wake it up in the stopped/traced/killable
467 * case. We don't check t->state here because there is a race with it
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 * executing another processor and just now entering stopped state.
469 * By using wake_up_state, we ensure the process will wake up and
470 * handle its death signal.
471 */
472 mask = TASK_INTERRUPTIBLE;
473 if (resume)
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500474 mask |= TASK_WAKEKILL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 if (!wake_up_state(t, mask))
476 kick_process(t);
477}
478
479/*
480 * Remove signals in mask from the pending set and queue.
481 * Returns 1 if any signals were found.
482 *
483 * All callers must be holding the siglock.
George Anzinger71fabd52006-01-08 01:02:48 -0800484 *
485 * This version takes a sigset mask and looks at all signals,
486 * not just those in the first mask word.
487 */
488static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
489{
490 struct sigqueue *q, *n;
491 sigset_t m;
492
493 sigandsets(&m, mask, &s->signal);
494 if (sigisemptyset(&m))
495 return 0;
496
497 signandsets(&s->signal, &s->signal, mask);
498 list_for_each_entry_safe(q, n, &s->list, list) {
499 if (sigismember(mask, q->info.si_signo)) {
500 list_del_init(&q->list);
501 __sigqueue_free(q);
502 }
503 }
504 return 1;
505}
506/*
507 * Remove signals in mask from the pending set and queue.
508 * Returns 1 if any signals were found.
509 *
510 * All callers must be holding the siglock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 */
512static int rm_from_queue(unsigned long mask, struct sigpending *s)
513{
514 struct sigqueue *q, *n;
515
516 if (!sigtestsetmask(&s->signal, mask))
517 return 0;
518
519 sigdelsetmask(&s->signal, mask);
520 list_for_each_entry_safe(q, n, &s->list, list) {
521 if (q->info.si_signo < SIGRTMIN &&
522 (mask & sigmask(q->info.si_signo))) {
523 list_del_init(&q->list);
524 __sigqueue_free(q);
525 }
526 }
527 return 1;
528}
529
530/*
531 * Bad permissions for sending the signal
532 */
533static int check_kill_permission(int sig, struct siginfo *info,
534 struct task_struct *t)
535{
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700536 int error;
537
Jesper Juhl7ed20e12005-05-01 08:59:14 -0700538 if (!valid_signal(sig))
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700539 return -EINVAL;
540
541 if (info != SEND_SIG_NOINFO && (is_si_special(info) || SI_FROMKERNEL(info)))
542 return 0;
543
544 error = audit_signal_info(sig, t); /* Let audit system see the signal */
545 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 return error;
Amy Griffise54dc242007-03-29 18:01:04 -0400547
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700548 if (((sig != SIGCONT) || (task_session_nr(current) != task_session_nr(t)))
549 && (current->euid ^ t->suid) && (current->euid ^ t->uid)
550 && (current->uid ^ t->suid) && (current->uid ^ t->uid)
551 && !capable(CAP_KILL))
552 return -EPERM;
Steve Grubbc2f0c7c2005-05-06 12:38:39 +0100553
Amy Griffise54dc242007-03-29 18:01:04 -0400554 return security_task_kill(t, info, sig, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555}
556
557/* forward decl */
Oleg Nesterova1d5e212006-03-28 16:11:29 -0800558static void do_notify_parent_cldstop(struct task_struct *tsk, int why);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
560/*
561 * Handle magic process-wide effects of stop/continue signals.
562 * Unlike the signal actions, these happen immediately at signal-generation
563 * time regardless of blocking, ignoring, or handling. This does the
564 * actual continuing for SIGCONT, but not the actual stopping for stop
565 * signals. The process stop is done as a signal action for SIG_DFL.
566 */
567static void handle_stop_signal(int sig, struct task_struct *p)
568{
Oleg Nesterovad16a462008-04-30 00:52:46 -0700569 struct signal_struct *signal = p->signal;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 struct task_struct *t;
571
Oleg Nesterovad16a462008-04-30 00:52:46 -0700572 if (signal->flags & SIGNAL_GROUP_EXIT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 /*
574 * The process is in the middle of dying already.
575 */
576 return;
577
578 if (sig_kernel_stop(sig)) {
579 /*
580 * This is a stop signal. Remove SIGCONT from all queues.
581 */
Oleg Nesterovad16a462008-04-30 00:52:46 -0700582 rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 t = p;
584 do {
585 rm_from_queue(sigmask(SIGCONT), &t->pending);
Oleg Nesterovad16a462008-04-30 00:52:46 -0700586 } while_each_thread(p, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 } else if (sig == SIGCONT) {
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700588 unsigned int why;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 /*
590 * Remove all stop signals from all queues,
591 * and wake all threads.
592 */
Oleg Nesterovad16a462008-04-30 00:52:46 -0700593 rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 t = p;
595 do {
596 unsigned int state;
597 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 /*
599 * If there is a handler for SIGCONT, we must make
600 * sure that no thread returns to user mode before
601 * we post the signal, in case it was the only
602 * thread eligible to run the signal handler--then
603 * it must not do anything between resuming and
604 * running the handler. With the TIF_SIGPENDING
605 * flag set, the thread will pause and acquire the
606 * siglock that we hold now and until we've queued
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700607 * the pending signal.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 *
609 * Wake up the stopped thread _after_ setting
610 * TIF_SIGPENDING
611 */
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500612 state = __TASK_STOPPED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
614 set_tsk_thread_flag(t, TIF_SIGPENDING);
615 state |= TASK_INTERRUPTIBLE;
616 }
617 wake_up_state(t, state);
Oleg Nesterovad16a462008-04-30 00:52:46 -0700618 } while_each_thread(p, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700620 /*
621 * Notify the parent with CLD_CONTINUED if we were stopped.
622 *
623 * If we were in the middle of a group stop, we pretend it
624 * was already finished, and then continued. Since SIGCHLD
625 * doesn't queue we report only CLD_STOPPED, as if the next
626 * CLD_CONTINUED was dropped.
627 */
628 why = 0;
Oleg Nesterovad16a462008-04-30 00:52:46 -0700629 if (signal->flags & SIGNAL_STOP_STOPPED)
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700630 why |= SIGNAL_CLD_CONTINUED;
Oleg Nesterovad16a462008-04-30 00:52:46 -0700631 else if (signal->group_stop_count)
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700632 why |= SIGNAL_CLD_STOPPED;
633
634 if (why) {
Oleg Nesterovad16a462008-04-30 00:52:46 -0700635 signal->flags = why | SIGNAL_STOP_CONTINUED;
636 signal->group_stop_count = 0;
637 signal->group_exit_code = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 } else {
639 /*
640 * We are not stopped, but there could be a stop
641 * signal in the middle of being processed after
642 * being removed from the queue. Clear that too.
643 */
Oleg Nesterovad16a462008-04-30 00:52:46 -0700644 signal->flags &= ~SIGNAL_STOP_DEQUEUED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 }
647}
648
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700649/*
650 * Test if P wants to take SIG. After we've checked all threads with this,
651 * it's equivalent to finding no threads not blocking SIG. Any threads not
652 * blocking SIG were ruled out because they are not running and already
653 * have pending signals. Such threads will dequeue from the shared queue
654 * as soon as they're available, so putting the signal on the shared queue
655 * will be equivalent to sending it to one such thread.
656 */
657static inline int wants_signal(int sig, struct task_struct *p)
658{
659 if (sigismember(&p->blocked, sig))
660 return 0;
661 if (p->flags & PF_EXITING)
662 return 0;
663 if (sig == SIGKILL)
664 return 1;
665 if (task_is_stopped_or_traced(p))
666 return 0;
667 return task_curr(p) || !signal_pending(p);
668}
669
Oleg Nesterov5fcd8352008-04-30 00:52:55 -0700670static void complete_signal(int sig, struct task_struct *p, int group)
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700671{
672 struct signal_struct *signal = p->signal;
673 struct task_struct *t;
674
675 /*
676 * Now find a thread we can wake up to take the signal off the queue.
677 *
678 * If the main thread wants the signal, it gets first crack.
679 * Probably the least surprising to the average bear.
680 */
681 if (wants_signal(sig, p))
682 t = p;
Oleg Nesterov5fcd8352008-04-30 00:52:55 -0700683 else if (!group || thread_group_empty(p))
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700684 /*
685 * There is just one thread and it does not need to be woken.
686 * It will dequeue unblocked signals before it runs again.
687 */
688 return;
689 else {
690 /*
691 * Otherwise try to find a suitable thread.
692 */
693 t = signal->curr_target;
694 while (!wants_signal(sig, t)) {
695 t = next_thread(t);
696 if (t == signal->curr_target)
697 /*
698 * No thread needs to be woken.
699 * Any eligible threads will see
700 * the signal in the queue soon.
701 */
702 return;
703 }
704 signal->curr_target = t;
705 }
706
707 /*
708 * Found a killable thread. If the signal will be fatal,
709 * then start taking the whole group down immediately.
710 */
711 if (sig_fatal(p, sig) && !(signal->flags & SIGNAL_GROUP_EXIT) &&
712 !sigismember(&t->real_blocked, sig) &&
713 (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
714 /*
715 * This signal will be fatal to the whole group.
716 */
717 if (!sig_kernel_coredump(sig)) {
718 /*
719 * Start a group exit and wake everybody up.
720 * This way we don't have other threads
721 * running and doing things after a slower
722 * thread has the fatal signal pending.
723 */
724 signal->flags = SIGNAL_GROUP_EXIT;
725 signal->group_exit_code = sig;
726 signal->group_stop_count = 0;
727 t = p;
728 do {
729 sigaddset(&t->pending.signal, SIGKILL);
730 signal_wake_up(t, 1);
731 } while_each_thread(p, t);
732 return;
733 }
734 }
735
736 /*
737 * The signal is already in the shared-pending queue.
738 * Tell the chosen thread to wake up and dequeue it.
739 */
740 signal_wake_up(t, sig == SIGKILL);
741 return;
742}
743
Pavel Emelyanovaf7fff92008-04-30 00:52:34 -0700744static inline int legacy_queue(struct sigpending *signals, int sig)
745{
746 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
747}
748
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700750 int group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751{
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700752 struct sigpending *pending;
Oleg Nesterov6e65acb2008-04-30 00:52:50 -0700753 struct sigqueue *q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
Oleg Nesterov6e65acb2008-04-30 00:52:50 -0700755 assert_spin_locked(&t->sighand->siglock);
756 handle_stop_signal(sig, t);
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700757
758 pending = group ? &t->signal->shared_pending : &t->pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 /*
Pavel Emelyanov2acb0242008-04-30 00:52:35 -0700760 * Short-circuit ignored signals and support queuing
761 * exactly one non-rt signal, so that we can get more
762 * detailed information about the cause of the signal.
763 */
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700764 if (sig_ignored(t, sig) || legacy_queue(pending, sig))
Pavel Emelyanov2acb0242008-04-30 00:52:35 -0700765 return 0;
766
767 /*
Davide Libenzifba2afa2007-05-10 22:23:13 -0700768 * Deliver the signal to listening signalfds. This must be called
769 * with the sighand lock held.
770 */
771 signalfd_notify(t, sig);
772
773 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 * fast-pathed signals for kernel-internal things like SIGSTOP
775 * or SIGKILL.
776 */
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800777 if (info == SEND_SIG_FORCED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 goto out_set;
779
780 /* Real-time signals must be queued if sent by sigqueue, or
781 some other real-time mechanism. It is implementation
782 defined whether kill() does so. We attempt to do so, on
783 the principle of least surprise, but since kill is not
784 allowed to fail with EAGAIN when low on memory we just
785 make sure at least one signal gets delivered and don't
786 pass on the info struct. */
787
788 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
Oleg Nesterov621d3122005-10-30 15:03:45 -0800789 (is_si_special(info) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 info->si_code >= 0)));
791 if (q) {
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700792 list_add_tail(&q->list, &pending->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 switch ((unsigned long) info) {
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800794 case (unsigned long) SEND_SIG_NOINFO:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 q->info.si_signo = sig;
796 q->info.si_errno = 0;
797 q->info.si_code = SI_USER;
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700798 q->info.si_pid = task_pid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 q->info.si_uid = current->uid;
800 break;
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800801 case (unsigned long) SEND_SIG_PRIV:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 q->info.si_signo = sig;
803 q->info.si_errno = 0;
804 q->info.si_code = SI_KERNEL;
805 q->info.si_pid = 0;
806 q->info.si_uid = 0;
807 break;
808 default:
809 copy_siginfo(&q->info, info);
810 break;
811 }
Oleg Nesterov621d3122005-10-30 15:03:45 -0800812 } else if (!is_si_special(info)) {
813 if (sig >= SIGRTMIN && info->si_code != SI_USER)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 /*
815 * Queue overflow, abort. We may abort if the signal was rt
816 * and sent by user using something other than kill().
817 */
818 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 }
820
821out_set:
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700822 sigaddset(&pending->signal, sig);
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -0700823 complete_signal(sig, t, group);
824 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825}
826
Ingo Molnar45807a12007-07-15 23:40:10 -0700827int print_fatal_signals;
828
829static void print_fatal_signal(struct pt_regs *regs, int signr)
830{
831 printk("%s/%d: potentially unexpected fatal signal %d.\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -0700832 current->comm, task_pid_nr(current), signr);
Ingo Molnar45807a12007-07-15 23:40:10 -0700833
Al Viroca5cd872007-10-29 04:31:16 +0000834#if defined(__i386__) && !defined(__arch_um__)
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100835 printk("code at %08lx: ", regs->ip);
Ingo Molnar45807a12007-07-15 23:40:10 -0700836 {
837 int i;
838 for (i = 0; i < 16; i++) {
839 unsigned char insn;
840
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100841 __get_user(insn, (unsigned char *)(regs->ip + i));
Ingo Molnar45807a12007-07-15 23:40:10 -0700842 printk("%02x ", insn);
843 }
844 }
845#endif
846 printk("\n");
847 show_regs(regs);
848}
849
850static int __init setup_print_fatal_signals(char *str)
851{
852 get_option (&str, &print_fatal_signals);
853
854 return 1;
855}
856
857__setup("print-fatal-signals=", setup_print_fatal_signals);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -0700859int
860__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
861{
862 return send_signal(sig, info, p, 1);
863}
864
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865static int
866specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
867{
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -0700868 return send_signal(sig, info, t, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869}
870
871/*
872 * Force a signal that the process can't ignore: if necessary
873 * we unblock the signal and change any SIG_IGN to SIG_DFL.
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700874 *
875 * Note: If we unblock the signal, we always reset it to SIG_DFL,
876 * since we do not want to have a signal handler that was blocked
877 * be invoked when user space had explicitly blocked it.
878 *
879 * We don't want to have recursive SIGSEGV's etc, for example.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881int
882force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
883{
884 unsigned long int flags;
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700885 int ret, blocked, ignored;
886 struct k_sigaction *action;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
888 spin_lock_irqsave(&t->sighand->siglock, flags);
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700889 action = &t->sighand->action[sig-1];
890 ignored = action->sa.sa_handler == SIG_IGN;
891 blocked = sigismember(&t->blocked, sig);
892 if (blocked || ignored) {
893 action->sa.sa_handler = SIG_DFL;
894 if (blocked) {
895 sigdelset(&t->blocked, sig);
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700896 recalc_sigpending_and_wake(t);
Linus Torvaldsae74c3b2006-08-02 20:17:49 -0700897 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 }
899 ret = specific_send_sig_info(sig, info, t);
900 spin_unlock_irqrestore(&t->sighand->siglock, flags);
901
902 return ret;
903}
904
905void
906force_sig_specific(int sig, struct task_struct *t)
907{
Paul E. McKenneyb0423a02005-10-30 15:03:46 -0800908 force_sig_info(sig, SEND_SIG_FORCED, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909}
910
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911/*
912 * Nuke all other threads in the group.
913 */
914void zap_other_threads(struct task_struct *p)
915{
916 struct task_struct *t;
917
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 p->signal->group_stop_count = 0;
919
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 for (t = next_thread(p); t != p; t = next_thread(t)) {
921 /*
922 * Don't bother with already dead threads
923 */
924 if (t->exit_state)
925 continue;
926
Andrea Arcangeli30e0fca2005-10-30 15:02:38 -0800927 /* SIGKILL will be handled before any pending SIGSTOP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 sigaddset(&t->pending.signal, SIGKILL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 signal_wake_up(t, 1);
930 }
931}
932
Harvey Harrisonb5606c22008-02-13 15:03:16 -0800933int __fatal_signal_pending(struct task_struct *tsk)
Matthew Wilcoxf776d122007-12-06 11:15:50 -0500934{
935 return sigismember(&tsk->pending.signal, SIGKILL);
936}
Trond Myklebust13f09b92008-01-31 20:40:29 -0500937EXPORT_SYMBOL(__fatal_signal_pending);
Matthew Wilcoxf776d122007-12-06 11:15:50 -0500938
Oleg Nesterovf63ee722006-03-28 16:11:13 -0800939struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
940{
941 struct sighand_struct *sighand;
942
Oleg Nesterov1406f2d2008-04-30 00:52:37 -0700943 rcu_read_lock();
Oleg Nesterovf63ee722006-03-28 16:11:13 -0800944 for (;;) {
945 sighand = rcu_dereference(tsk->sighand);
946 if (unlikely(sighand == NULL))
947 break;
948
949 spin_lock_irqsave(&sighand->siglock, *flags);
950 if (likely(sighand == tsk->sighand))
951 break;
952 spin_unlock_irqrestore(&sighand->siglock, *flags);
953 }
Oleg Nesterov1406f2d2008-04-30 00:52:37 -0700954 rcu_read_unlock();
Oleg Nesterovf63ee722006-03-28 16:11:13 -0800955
956 return sighand;
957}
958
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
960{
961 unsigned long flags;
962 int ret;
963
964 ret = check_kill_permission(sig, info, p);
Oleg Nesterovf63ee722006-03-28 16:11:13 -0800965
966 if (!ret && sig) {
967 ret = -ESRCH;
968 if (lock_task_sighand(p, &flags)) {
969 ret = __group_send_sig_info(sig, info, p);
970 unlock_task_sighand(p, &flags);
Ingo Molnare56d0902006-01-08 01:01:37 -0800971 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 }
973
974 return ret;
975}
976
977/*
Pavel Emelyanov146a5052008-02-08 04:19:22 -0800978 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 * control characters do (^C, ^Z etc)
980 */
981
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -0700982int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983{
984 struct task_struct *p = NULL;
985 int retval, success;
986
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 success = 0;
988 retval = -ESRCH;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -0700989 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 int err = group_send_sig_info(sig, info, p);
991 success |= !err;
992 retval = err;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -0700993 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 return success ? 0 : retval;
995}
996
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -0700997int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998{
Oleg Nesterovd36174b2008-02-08 04:19:18 -0800999 int error = -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 struct task_struct *p;
1001
Ingo Molnare56d0902006-01-08 01:01:37 -08001002 rcu_read_lock();
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001003retry:
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001004 p = pid_task(pid, PIDTYPE_PID);
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001005 if (p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 error = group_send_sig_info(sig, info, p);
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001007 if (unlikely(error == -ESRCH))
1008 /*
1009 * The task was unhashed in between, try again.
1010 * If it is dead, pid_task() will return NULL,
1011 * if we race with de_thread() it will find the
1012 * new leader.
1013 */
1014 goto retry;
1015 }
Ingo Molnare56d0902006-01-08 01:01:37 -08001016 rcu_read_unlock();
Oleg Nesterov6ca25b52008-04-30 00:52:45 -07001017
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 return error;
1019}
1020
Matthew Wilcoxc3de4b32007-02-09 08:11:47 -07001021int
1022kill_proc_info(int sig, struct siginfo *info, pid_t pid)
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001023{
1024 int error;
1025 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001026 error = kill_pid_info(sig, info, find_vpid(pid));
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001027 rcu_read_unlock();
1028 return error;
1029}
1030
Eric W. Biederman2425c082006-10-02 02:17:28 -07001031/* like kill_pid_info(), but doesn't use uid/euid of "current" */
1032int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
David Quigley8f95dc52006-06-30 01:55:47 -07001033 uid_t uid, uid_t euid, u32 secid)
Harald Welte46113832005-10-10 19:44:29 +02001034{
1035 int ret = -EINVAL;
1036 struct task_struct *p;
1037
1038 if (!valid_signal(sig))
1039 return ret;
1040
1041 read_lock(&tasklist_lock);
Eric W. Biederman2425c082006-10-02 02:17:28 -07001042 p = pid_task(pid, PIDTYPE_PID);
Harald Welte46113832005-10-10 19:44:29 +02001043 if (!p) {
1044 ret = -ESRCH;
1045 goto out_unlock;
1046 }
Oleg Nesterov0811af22006-01-08 01:03:09 -08001047 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
Harald Welte46113832005-10-10 19:44:29 +02001048 && (euid != p->suid) && (euid != p->uid)
1049 && (uid != p->suid) && (uid != p->uid)) {
1050 ret = -EPERM;
1051 goto out_unlock;
1052 }
David Quigley8f95dc52006-06-30 01:55:47 -07001053 ret = security_task_kill(p, info, sig, secid);
1054 if (ret)
1055 goto out_unlock;
Harald Welte46113832005-10-10 19:44:29 +02001056 if (sig && p->sighand) {
1057 unsigned long flags;
1058 spin_lock_irqsave(&p->sighand->siglock, flags);
1059 ret = __group_send_sig_info(sig, info, p);
1060 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1061 }
1062out_unlock:
1063 read_unlock(&tasklist_lock);
1064 return ret;
1065}
Eric W. Biederman2425c082006-10-02 02:17:28 -07001066EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067
1068/*
1069 * kill_something_info() interprets pid in interesting ways just like kill(2).
1070 *
1071 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1072 * is probably wrong. Should make it like BSD or SYSV.
1073 */
1074
1075static int kill_something_info(int sig, struct siginfo *info, int pid)
1076{
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001077 int ret;
Pavel Emelyanovd5df7632008-02-08 04:19:22 -08001078
1079 if (pid > 0) {
1080 rcu_read_lock();
1081 ret = kill_pid_info(sig, info, find_vpid(pid));
1082 rcu_read_unlock();
1083 return ret;
1084 }
1085
1086 read_lock(&tasklist_lock);
1087 if (pid != -1) {
1088 ret = __kill_pgrp_info(sig, info,
1089 pid ? find_vpid(-pid) : task_pgrp(current));
1090 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 int retval = 0, count = 0;
1092 struct task_struct * p;
1093
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 for_each_process(p) {
Pavel Emelyanovbac0abd2007-10-18 23:40:18 -07001095 if (p->pid > 1 && !same_thread_group(p, current)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 int err = group_send_sig_info(sig, info, p);
1097 ++count;
1098 if (err != -EPERM)
1099 retval = err;
1100 }
1101 }
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001102 ret = count ? retval : -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 }
Pavel Emelyanovd5df7632008-02-08 04:19:22 -08001104 read_unlock(&tasklist_lock);
1105
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001106 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107}
1108
1109/*
1110 * These are for backward compatibility with the rest of the kernel source.
1111 */
1112
1113/*
Oleg Nesterov08d2c302008-04-30 00:52:51 -07001114 * The caller must ensure the task can't exit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 */
1116int
1117send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1118{
1119 int ret;
1120 unsigned long flags;
1121
1122 /*
1123 * Make sure legacy kernel users don't send in bad values
1124 * (normal paths check this in check_kill_permission).
1125 */
Jesper Juhl7ed20e12005-05-01 08:59:14 -07001126 if (!valid_signal(sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 return -EINVAL;
1128
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 spin_lock_irqsave(&p->sighand->siglock, flags);
1130 ret = specific_send_sig_info(sig, info, p);
1131 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 return ret;
1133}
1134
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001135#define __si_special(priv) \
1136 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1137
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138int
1139send_sig(int sig, struct task_struct *p, int priv)
1140{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001141 return send_sig_info(sig, __si_special(priv), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142}
1143
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144void
1145force_sig(int sig, struct task_struct *p)
1146{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001147 force_sig_info(sig, SEND_SIG_PRIV, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148}
1149
1150/*
1151 * When things go south during signal handling, we
1152 * will force a SIGSEGV. And if the signal that caused
1153 * the problem was already a SIGSEGV, we'll want to
1154 * make sure we don't even try to deliver the signal..
1155 */
1156int
1157force_sigsegv(int sig, struct task_struct *p)
1158{
1159 if (sig == SIGSEGV) {
1160 unsigned long flags;
1161 spin_lock_irqsave(&p->sighand->siglock, flags);
1162 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1163 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1164 }
1165 force_sig(SIGSEGV, p);
1166 return 0;
1167}
1168
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001169int kill_pgrp(struct pid *pid, int sig, int priv)
1170{
Pavel Emelyanov146a5052008-02-08 04:19:22 -08001171 int ret;
1172
1173 read_lock(&tasklist_lock);
1174 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1175 read_unlock(&tasklist_lock);
1176
1177 return ret;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001178}
1179EXPORT_SYMBOL(kill_pgrp);
1180
1181int kill_pid(struct pid *pid, int sig, int priv)
1182{
1183 return kill_pid_info(sig, __si_special(priv), pid);
1184}
1185EXPORT_SYMBOL(kill_pid);
1186
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188kill_proc(pid_t pid, int sig, int priv)
1189{
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001190 int ret;
1191
1192 rcu_read_lock();
1193 ret = kill_pid_info(sig, __si_special(priv), find_pid(pid));
1194 rcu_read_unlock();
1195 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196}
1197
1198/*
1199 * These functions support sending signals using preallocated sigqueue
1200 * structures. This is needed "because realtime applications cannot
1201 * afford to lose notifications of asynchronous events, like timer
1202 * expirations or I/O completions". In the case of Posix Timers
1203 * we allocate the sigqueue structure from the timer_create. If this
1204 * allocation fails we are able to report the failure to the application
1205 * with an EAGAIN error.
1206 */
1207
1208struct sigqueue *sigqueue_alloc(void)
1209{
1210 struct sigqueue *q;
1211
1212 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1213 q->flags |= SIGQUEUE_PREALLOC;
1214 return(q);
1215}
1216
1217void sigqueue_free(struct sigqueue *q)
1218{
1219 unsigned long flags;
Oleg Nesterov60187d22007-08-30 23:56:35 -07001220 spinlock_t *lock = &current->sighand->siglock;
1221
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1223 /*
1224 * If the signal is still pending remove it from the
Oleg Nesterov60187d22007-08-30 23:56:35 -07001225 * pending queue. We must hold ->siglock while testing
1226 * q->list to serialize with collect_signal().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 */
Oleg Nesterov60187d22007-08-30 23:56:35 -07001228 spin_lock_irqsave(lock, flags);
1229 if (!list_empty(&q->list))
1230 list_del_init(&q->list);
1231 spin_unlock_irqrestore(lock, flags);
1232
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 q->flags &= ~SIGQUEUE_PREALLOC;
1234 __sigqueue_free(q);
1235}
1236
Oleg Nesterovac5c2152008-04-30 00:52:57 -07001237int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001238{
Oleg Nesterove62e6652008-04-30 00:52:56 -07001239 int sig = q->info.si_signo;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001240 struct sigpending *pending;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001241 unsigned long flags;
1242 int ret;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001243
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001244 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
Oleg Nesterove62e6652008-04-30 00:52:56 -07001245
1246 ret = -1;
1247 if (!likely(lock_task_sighand(t, &flags)))
1248 goto ret;
1249
Oleg Nesterov5fc894b2008-04-30 00:52:48 -07001250 handle_stop_signal(sig, t);
1251
Oleg Nesterove62e6652008-04-30 00:52:56 -07001252 ret = 1;
1253 if (sig_ignored(t, sig))
1254 goto out;
1255
1256 ret = 0;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001257 if (unlikely(!list_empty(&q->list))) {
1258 /*
1259 * If an SI_TIMER entry is already queue just increment
1260 * the overrun count.
1261 */
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001262 BUG_ON(q->info.si_code != SI_TIMER);
1263 q->info.si_overrun++;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001264 goto out;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001265 }
1266
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001267 signalfd_notify(t, sig);
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001268 pending = group ? &t->signal->shared_pending : &t->pending;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001269 list_add_tail(&q->list, &pending->list);
1270 sigaddset(&pending->signal, sig);
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001271 complete_signal(sig, t, group);
Oleg Nesterove62e6652008-04-30 00:52:56 -07001272out:
1273 unlock_task_sighand(t, &flags);
1274ret:
1275 return ret;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001276}
1277
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278/*
1279 * Wake up any threads in the parent blocked in wait* syscalls.
1280 */
1281static inline void __wake_up_parent(struct task_struct *p,
1282 struct task_struct *parent)
1283{
1284 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1285}
1286
1287/*
1288 * Let a parent know about the death of a child.
1289 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1290 */
1291
1292void do_notify_parent(struct task_struct *tsk, int sig)
1293{
1294 struct siginfo info;
1295 unsigned long flags;
1296 struct sighand_struct *psig;
1297
1298 BUG_ON(sig == -1);
1299
1300 /* do_notify_parent_cldstop should have been called instead. */
Matthew Wilcoxe1abb392007-12-06 11:07:35 -05001301 BUG_ON(task_is_stopped_or_traced(tsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302
1303 BUG_ON(!tsk->ptrace &&
1304 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1305
1306 info.si_signo = sig;
1307 info.si_errno = 0;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001308 /*
1309 * we are under tasklist_lock here so our parent is tied to
1310 * us and cannot exit and release its namespace.
1311 *
1312 * the only it can is to switch its nsproxy with sys_unshare,
1313 * bu uncharing pid namespaces is not allowed, so we'll always
1314 * see relevant namespace
1315 *
1316 * write_lock() currently calls preempt_disable() which is the
1317 * same as rcu_read_lock(), but according to Oleg, this is not
1318 * correct to rely on this
1319 */
1320 rcu_read_lock();
1321 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1322 rcu_read_unlock();
1323
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 info.si_uid = tsk->uid;
1325
1326 /* FIXME: find out whether or not this is supposed to be c*time. */
1327 info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1328 tsk->signal->utime));
1329 info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1330 tsk->signal->stime));
1331
1332 info.si_status = tsk->exit_code & 0x7f;
1333 if (tsk->exit_code & 0x80)
1334 info.si_code = CLD_DUMPED;
1335 else if (tsk->exit_code & 0x7f)
1336 info.si_code = CLD_KILLED;
1337 else {
1338 info.si_code = CLD_EXITED;
1339 info.si_status = tsk->exit_code >> 8;
1340 }
1341
1342 psig = tsk->parent->sighand;
1343 spin_lock_irqsave(&psig->siglock, flags);
Oleg Nesterov7ed01752005-11-10 17:22:18 +03001344 if (!tsk->ptrace && sig == SIGCHLD &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1346 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1347 /*
1348 * We are exiting and our parent doesn't care. POSIX.1
1349 * defines special semantics for setting SIGCHLD to SIG_IGN
1350 * or setting the SA_NOCLDWAIT flag: we should be reaped
1351 * automatically and not left for our parent's wait4 call.
1352 * Rather than having the parent do it as a magic kind of
1353 * signal handler, we just set this to tell do_exit that we
1354 * can be cleaned up without becoming a zombie. Note that
1355 * we still call __wake_up_parent in this case, because a
1356 * blocked sys_wait4 might now return -ECHILD.
1357 *
1358 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1359 * is implementation-defined: we do (if you don't want
1360 * it, just use SIG_IGN instead).
1361 */
1362 tsk->exit_signal = -1;
1363 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1364 sig = 0;
1365 }
Jesper Juhl7ed20e12005-05-01 08:59:14 -07001366 if (valid_signal(sig) && sig > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 __group_send_sig_info(sig, &info, tsk->parent);
1368 __wake_up_parent(tsk, tsk->parent);
1369 spin_unlock_irqrestore(&psig->siglock, flags);
1370}
1371
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001372static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373{
1374 struct siginfo info;
1375 unsigned long flags;
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001376 struct task_struct *parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 struct sighand_struct *sighand;
1378
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001379 if (tsk->ptrace & PT_PTRACED)
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001380 parent = tsk->parent;
1381 else {
1382 tsk = tsk->group_leader;
1383 parent = tsk->real_parent;
1384 }
1385
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 info.si_signo = SIGCHLD;
1387 info.si_errno = 0;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001388 /*
1389 * see comment in do_notify_parent() abot the following 3 lines
1390 */
1391 rcu_read_lock();
1392 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1393 rcu_read_unlock();
1394
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 info.si_uid = tsk->uid;
1396
1397 /* FIXME: find out whether or not this is supposed to be c*time. */
1398 info.si_utime = cputime_to_jiffies(tsk->utime);
1399 info.si_stime = cputime_to_jiffies(tsk->stime);
1400
1401 info.si_code = why;
1402 switch (why) {
1403 case CLD_CONTINUED:
1404 info.si_status = SIGCONT;
1405 break;
1406 case CLD_STOPPED:
1407 info.si_status = tsk->signal->group_exit_code & 0x7f;
1408 break;
1409 case CLD_TRAPPED:
1410 info.si_status = tsk->exit_code & 0x7f;
1411 break;
1412 default:
1413 BUG();
1414 }
1415
1416 sighand = parent->sighand;
1417 spin_lock_irqsave(&sighand->siglock, flags);
1418 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1419 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1420 __group_send_sig_info(SIGCHLD, &info, parent);
1421 /*
1422 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1423 */
1424 __wake_up_parent(tsk, parent);
1425 spin_unlock_irqrestore(&sighand->siglock, flags);
1426}
1427
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001428static inline int may_ptrace_stop(void)
1429{
1430 if (!likely(current->ptrace & PT_PTRACED))
1431 return 0;
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001432 /*
1433 * Are we in the middle of do_coredump?
1434 * If so and our tracer is also part of the coredump stopping
1435 * is a deadlock situation, and pointless because our tracer
1436 * is dead so don't allow us to stop.
1437 * If SIGKILL was already sent before the caller unlocked
1438 * ->siglock we must see ->core_waiters != 0. Otherwise it
1439 * is safe to enter schedule().
1440 */
1441 if (unlikely(current->mm->core_waiters) &&
1442 unlikely(current->mm == current->parent->mm))
1443 return 0;
1444
1445 return 1;
1446}
1447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448/*
Roland McGrath1a669c22008-02-06 01:37:37 -08001449 * Return nonzero if there is a SIGKILL that should be waking us up.
1450 * Called with the siglock held.
1451 */
1452static int sigkill_pending(struct task_struct *tsk)
1453{
1454 return ((sigismember(&tsk->pending.signal, SIGKILL) ||
1455 sigismember(&tsk->signal->shared_pending.signal, SIGKILL)) &&
1456 !unlikely(sigismember(&tsk->blocked, SIGKILL)));
1457}
1458
1459/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 * This must be called with current->sighand->siglock held.
1461 *
1462 * This should be the path for all ptrace stops.
1463 * We always set current->last_siginfo while stopped here.
1464 * That makes it a way to test a stopped process for
1465 * being ptrace-stopped vs being job-control-stopped.
1466 *
Oleg Nesterov20686a32008-02-08 04:19:03 -08001467 * If we actually decide not to stop at all because the tracer
1468 * is gone, we keep current->exit_code unless clear_code.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 */
Oleg Nesterov20686a32008-02-08 04:19:03 -08001470static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471{
Roland McGrath1a669c22008-02-06 01:37:37 -08001472 int killed = 0;
1473
1474 if (arch_ptrace_stop_needed(exit_code, info)) {
1475 /*
1476 * The arch code has something special to do before a
1477 * ptrace stop. This is allowed to block, e.g. for faults
1478 * on user stack pages. We can't keep the siglock while
1479 * calling arch_ptrace_stop, so we must release it now.
1480 * To preserve proper semantics, we must do this before
1481 * any signal bookkeeping like checking group_stop_count.
1482 * Meanwhile, a SIGKILL could come in before we retake the
1483 * siglock. That must prevent us from sleeping in TASK_TRACED.
1484 * So after regaining the lock, we must check for SIGKILL.
1485 */
1486 spin_unlock_irq(&current->sighand->siglock);
1487 arch_ptrace_stop(exit_code, info);
1488 spin_lock_irq(&current->sighand->siglock);
1489 killed = sigkill_pending(current);
1490 }
1491
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 /*
1493 * If there is a group stop in progress,
1494 * we must participate in the bookkeeping.
1495 */
1496 if (current->signal->group_stop_count > 0)
1497 --current->signal->group_stop_count;
1498
1499 current->last_siginfo = info;
1500 current->exit_code = exit_code;
1501
1502 /* Let the debugger run. */
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -08001503 __set_current_state(TASK_TRACED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 spin_unlock_irq(&current->sighand->siglock);
1505 read_lock(&tasklist_lock);
Roland McGrath1a669c22008-02-06 01:37:37 -08001506 if (!unlikely(killed) && may_ptrace_stop()) {
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001507 do_notify_parent_cldstop(current, CLD_TRAPPED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 read_unlock(&tasklist_lock);
1509 schedule();
1510 } else {
1511 /*
1512 * By the time we got the lock, our tracer went away.
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001513 * Don't drop the lock yet, another tracer may come.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 */
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001515 __set_current_state(TASK_RUNNING);
Oleg Nesterov20686a32008-02-08 04:19:03 -08001516 if (clear_code)
1517 current->exit_code = 0;
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001518 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 }
1520
1521 /*
Roland McGrath13b1c3d2008-03-03 20:22:05 -08001522 * While in TASK_TRACED, we were considered "frozen enough".
1523 * Now that we woke up, it's crucial if we're supposed to be
1524 * frozen that we freeze now before running anything substantial.
1525 */
1526 try_to_freeze();
1527
1528 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 * We are back. Now reacquire the siglock before touching
1530 * last_siginfo, so that we are sure to have synchronized with
1531 * any signal-sending on another CPU that wants to examine it.
1532 */
1533 spin_lock_irq(&current->sighand->siglock);
1534 current->last_siginfo = NULL;
1535
1536 /*
1537 * Queued signals ignored us while we were stopped for tracing.
1538 * So check for any that we should take before resuming user mode.
Roland McGrathb74d0de2007-06-06 03:59:00 -07001539 * This sets TIF_SIGPENDING, but never clears it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 */
Roland McGrathb74d0de2007-06-06 03:59:00 -07001541 recalc_sigpending_tsk(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542}
1543
1544void ptrace_notify(int exit_code)
1545{
1546 siginfo_t info;
1547
1548 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1549
1550 memset(&info, 0, sizeof info);
1551 info.si_signo = SIGTRAP;
1552 info.si_code = exit_code;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001553 info.si_pid = task_pid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 info.si_uid = current->uid;
1555
1556 /* Let the debugger run. */
1557 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterov20686a32008-02-08 04:19:03 -08001558 ptrace_stop(exit_code, 1, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 spin_unlock_irq(&current->sighand->siglock);
1560}
1561
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562static void
1563finish_stop(int stop_count)
1564{
1565 /*
1566 * If there are no other threads in the group, or if there is
1567 * a group stop in progress and we are the last to stop,
1568 * report to the parent. When ptraced, every thread reports itself.
1569 */
Oleg Nesterova1d5e212006-03-28 16:11:29 -08001570 if (stop_count == 0 || (current->ptrace & PT_PTRACED)) {
1571 read_lock(&tasklist_lock);
1572 do_notify_parent_cldstop(current, CLD_STOPPED);
1573 read_unlock(&tasklist_lock);
1574 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575
Rafael J. Wysocki3df494a2006-12-13 00:34:28 -08001576 do {
1577 schedule();
1578 } while (try_to_freeze());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 /*
1580 * Now we don't run again until continued.
1581 */
1582 current->exit_code = 0;
1583}
1584
1585/*
1586 * This performs the stopping for SIGSTOP and other stop signals.
1587 * We have to stop all threads in the thread group.
1588 * Returns nonzero if we've actually stopped and released the siglock.
1589 * Returns zero if we didn't stop and still hold the siglock.
1590 */
Oleg Nesterova122b342006-03-28 16:11:22 -08001591static int do_signal_stop(int signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592{
1593 struct signal_struct *sig = current->signal;
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001594 int stop_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 if (sig->group_stop_count > 0) {
1597 /*
1598 * There is a group stop in progress. We don't need to
1599 * start another one.
1600 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 stop_count = --sig->group_stop_count;
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001602 } else {
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08001603 struct task_struct *t;
1604
Oleg Nesteroved5d2ca2008-02-04 22:27:24 -08001605 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED) ||
Oleg Nesterov573cf9a2008-04-30 00:52:36 -07001606 unlikely(signal_group_exit(sig)))
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08001607 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 * There is no group stop already in progress.
Oleg Nesterova122b342006-03-28 16:11:22 -08001610 * We must initiate one now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 */
Oleg Nesterova122b342006-03-28 16:11:22 -08001612 sig->group_exit_code = signr;
1613
1614 stop_count = 0;
1615 for (t = next_thread(current); t != current; t = next_thread(t))
1616 /*
1617 * Setting state to TASK_STOPPED for a group
1618 * stop is always done with the siglock held,
1619 * so this check has no races.
1620 */
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001621 if (!(t->flags & PF_EXITING) &&
Matthew Wilcoxe1abb392007-12-06 11:07:35 -05001622 !task_is_stopped_or_traced(t)) {
Oleg Nesterova122b342006-03-28 16:11:22 -08001623 stop_count++;
1624 signal_wake_up(t, 0);
1625 }
1626 sig->group_stop_count = stop_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 }
1628
Oleg Nesterovdac27f42006-03-28 16:11:28 -08001629 if (stop_count == 0)
1630 sig->flags = SIGNAL_STOP_STOPPED;
1631 current->exit_code = sig->group_exit_code;
1632 __set_current_state(TASK_STOPPED);
1633
1634 spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 finish_stop(stop_count);
1636 return 1;
1637}
1638
Roland McGrath18c98b62008-04-17 18:44:38 -07001639static int ptrace_signal(int signr, siginfo_t *info,
1640 struct pt_regs *regs, void *cookie)
1641{
1642 if (!(current->ptrace & PT_PTRACED))
1643 return signr;
1644
1645 ptrace_signal_deliver(regs, cookie);
1646
1647 /* Let the debugger run. */
1648 ptrace_stop(signr, 0, info);
1649
1650 /* We're back. Did the debugger cancel the sig? */
1651 signr = current->exit_code;
1652 if (signr == 0)
1653 return signr;
1654
1655 current->exit_code = 0;
1656
1657 /* Update the siginfo structure if the signal has
1658 changed. If the debugger wanted something
1659 specific in the siginfo structure then it should
1660 have updated *info via PTRACE_SETSIGINFO. */
1661 if (signr != info->si_signo) {
1662 info->si_signo = signr;
1663 info->si_errno = 0;
1664 info->si_code = SI_USER;
1665 info->si_pid = task_pid_vnr(current->parent);
1666 info->si_uid = current->parent->uid;
1667 }
1668
1669 /* If the (new) signal is now blocked, requeue it. */
1670 if (sigismember(&current->blocked, signr)) {
1671 specific_send_sig_info(signr, info, current);
1672 signr = 0;
1673 }
1674
1675 return signr;
1676}
1677
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1679 struct pt_regs *regs, void *cookie)
1680{
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001681 struct sighand_struct *sighand = current->sighand;
1682 struct signal_struct *signal = current->signal;
1683 int signr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684
Roland McGrath13b1c3d2008-03-03 20:22:05 -08001685relock:
1686 /*
1687 * We'll jump back here after any time we were stopped in TASK_STOPPED.
1688 * While in TASK_STOPPED, we were considered "frozen enough".
1689 * Now that we woke up, it's crucial if we're supposed to be
1690 * frozen that we freeze now before running anything substantial.
1691 */
Rafael J. Wysockifc558a72006-03-23 03:00:05 -08001692 try_to_freeze();
1693
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001694 spin_lock_irq(&sighand->siglock);
Oleg Nesterove4420552008-04-30 00:52:44 -07001695
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001696 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
1697 int why = (signal->flags & SIGNAL_STOP_CONTINUED)
Oleg Nesterove4420552008-04-30 00:52:44 -07001698 ? CLD_CONTINUED : CLD_STOPPED;
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001699 signal->flags &= ~SIGNAL_CLD_MASK;
1700 spin_unlock_irq(&sighand->siglock);
Oleg Nesterove4420552008-04-30 00:52:44 -07001701
1702 read_lock(&tasklist_lock);
1703 do_notify_parent_cldstop(current->group_leader, why);
1704 read_unlock(&tasklist_lock);
1705 goto relock;
1706 }
1707
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 for (;;) {
1709 struct k_sigaction *ka;
1710
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001711 if (unlikely(signal->group_stop_count > 0) &&
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08001712 do_signal_stop(0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 goto relock;
1714
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001715 signr = dequeue_signal(current, &current->blocked, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 if (!signr)
1717 break; /* will return 0 */
1718
Roland McGrath18c98b62008-04-17 18:44:38 -07001719 if (signr != SIGKILL) {
1720 signr = ptrace_signal(signr, info, regs, cookie);
1721 if (!signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 }
1724
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001725 ka = &sighand->action[signr-1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1727 continue;
1728 if (ka->sa.sa_handler != SIG_DFL) {
1729 /* Run the handler. */
1730 *return_ka = *ka;
1731
1732 if (ka->sa.sa_flags & SA_ONESHOT)
1733 ka->sa.sa_handler = SIG_DFL;
1734
1735 break; /* will return non-zero "signr" value */
1736 }
1737
1738 /*
1739 * Now we are doing the default action for this signal.
1740 */
1741 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1742 continue;
1743
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -08001744 /*
Sukadev Bhattiprolu0fbc26a2007-10-18 23:40:13 -07001745 * Global init gets no signals it doesn't want.
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -08001746 */
Sukadev Bhattiprolu0fbc26a2007-10-18 23:40:13 -07001747 if (is_global_init(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 continue;
1749
1750 if (sig_kernel_stop(signr)) {
1751 /*
1752 * The default action is to stop all threads in
1753 * the thread group. The job control signals
1754 * do nothing in an orphaned pgrp, but SIGSTOP
1755 * always works. Note that siglock needs to be
1756 * dropped during the call to is_orphaned_pgrp()
1757 * because of lock ordering with tasklist_lock.
1758 * This allows an intervening SIGCONT to be posted.
1759 * We need to check for that and bail out if necessary.
1760 */
1761 if (signr != SIGSTOP) {
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001762 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763
1764 /* signals can be posted during this window */
1765
Eric W. Biederman3e7cd6c2007-02-12 00:52:58 -08001766 if (is_current_pgrp_orphaned())
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 goto relock;
1768
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001769 spin_lock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 }
1771
1772 if (likely(do_signal_stop(signr))) {
1773 /* It released the siglock. */
1774 goto relock;
1775 }
1776
1777 /*
1778 * We didn't actually stop, due to a race
1779 * with SIGCONT or something like that.
1780 */
1781 continue;
1782 }
1783
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001784 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785
1786 /*
1787 * Anything else is fatal, maybe with a core dump.
1788 */
1789 current->flags |= PF_SIGNALED;
Ingo Molnar45807a12007-07-15 23:40:10 -07001790 if ((signr != SIGKILL) && print_fatal_signals)
1791 print_fatal_signal(regs, signr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 if (sig_kernel_coredump(signr)) {
1793 /*
1794 * If it was able to dump core, this kills all
1795 * other threads in the group and synchronizes with
1796 * their demise. If we lost the race with another
1797 * thread getting here, it set group_exit_code
1798 * first and our do_group_exit call below will use
1799 * that value and ignore the one we pass it.
1800 */
1801 do_coredump((long)signr, signr, regs);
1802 }
1803
1804 /*
1805 * Death signals, no core dump.
1806 */
1807 do_group_exit(signr);
1808 /* NOTREACHED */
1809 }
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07001810 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 return signr;
1812}
1813
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001814void exit_signals(struct task_struct *tsk)
1815{
1816 int group_stop = 0;
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001817 struct task_struct *t;
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001818
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001819 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
1820 tsk->flags |= PF_EXITING;
1821 return;
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001822 }
1823
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001824 spin_lock_irq(&tsk->sighand->siglock);
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001825 /*
1826 * From now this task is not visible for group-wide signals,
1827 * see wants_signal(), do_signal_stop().
1828 */
1829 tsk->flags |= PF_EXITING;
Oleg Nesterov5dee1702008-02-08 04:19:13 -08001830 if (!signal_pending(tsk))
1831 goto out;
1832
1833 /* It could be that __group_complete_signal() choose us to
1834 * notify about group-wide signal. Another thread should be
1835 * woken now to take the signal since we will not.
1836 */
1837 for (t = tsk; (t = next_thread(t)) != tsk; )
1838 if (!signal_pending(t) && !(t->flags & PF_EXITING))
1839 recalc_sigpending_and_wake(t);
1840
1841 if (unlikely(tsk->signal->group_stop_count) &&
1842 !--tsk->signal->group_stop_count) {
1843 tsk->signal->flags = SIGNAL_STOP_STOPPED;
1844 group_stop = 1;
1845 }
1846out:
Oleg Nesterovd12619b2008-02-08 04:19:12 -08001847 spin_unlock_irq(&tsk->sighand->siglock);
1848
1849 if (unlikely(group_stop)) {
1850 read_lock(&tasklist_lock);
1851 do_notify_parent_cldstop(tsk, CLD_STOPPED);
1852 read_unlock(&tasklist_lock);
1853 }
1854}
1855
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856EXPORT_SYMBOL(recalc_sigpending);
1857EXPORT_SYMBOL_GPL(dequeue_signal);
1858EXPORT_SYMBOL(flush_signals);
1859EXPORT_SYMBOL(force_sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860EXPORT_SYMBOL(kill_proc);
1861EXPORT_SYMBOL(ptrace_notify);
1862EXPORT_SYMBOL(send_sig);
1863EXPORT_SYMBOL(send_sig_info);
1864EXPORT_SYMBOL(sigprocmask);
1865EXPORT_SYMBOL(block_all_signals);
1866EXPORT_SYMBOL(unblock_all_signals);
1867
1868
1869/*
1870 * System call entry points.
1871 */
1872
1873asmlinkage long sys_restart_syscall(void)
1874{
1875 struct restart_block *restart = &current_thread_info()->restart_block;
1876 return restart->fn(restart);
1877}
1878
1879long do_no_restart_syscall(struct restart_block *param)
1880{
1881 return -EINTR;
1882}
1883
1884/*
1885 * We don't need to get the kernel lock - this is all local to this
1886 * particular thread.. (and that's good, because this is _heavily_
1887 * used by various programs)
1888 */
1889
1890/*
1891 * This is also useful for kernel threads that want to temporarily
1892 * (or permanently) block certain signals.
1893 *
1894 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1895 * interface happily blocks "unblockable" signals like SIGKILL
1896 * and friends.
1897 */
1898int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
1899{
1900 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901
1902 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterova26fd332006-03-23 03:00:49 -08001903 if (oldset)
1904 *oldset = current->blocked;
1905
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 error = 0;
1907 switch (how) {
1908 case SIG_BLOCK:
1909 sigorsets(&current->blocked, &current->blocked, set);
1910 break;
1911 case SIG_UNBLOCK:
1912 signandsets(&current->blocked, &current->blocked, set);
1913 break;
1914 case SIG_SETMASK:
1915 current->blocked = *set;
1916 break;
1917 default:
1918 error = -EINVAL;
1919 }
1920 recalc_sigpending();
1921 spin_unlock_irq(&current->sighand->siglock);
Oleg Nesterova26fd332006-03-23 03:00:49 -08001922
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 return error;
1924}
1925
1926asmlinkage long
1927sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
1928{
1929 int error = -EINVAL;
1930 sigset_t old_set, new_set;
1931
1932 /* XXX: Don't preclude handling different sized sigset_t's. */
1933 if (sigsetsize != sizeof(sigset_t))
1934 goto out;
1935
1936 if (set) {
1937 error = -EFAULT;
1938 if (copy_from_user(&new_set, set, sizeof(*set)))
1939 goto out;
1940 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
1941
1942 error = sigprocmask(how, &new_set, &old_set);
1943 if (error)
1944 goto out;
1945 if (oset)
1946 goto set_old;
1947 } else if (oset) {
1948 spin_lock_irq(&current->sighand->siglock);
1949 old_set = current->blocked;
1950 spin_unlock_irq(&current->sighand->siglock);
1951
1952 set_old:
1953 error = -EFAULT;
1954 if (copy_to_user(oset, &old_set, sizeof(*oset)))
1955 goto out;
1956 }
1957 error = 0;
1958out:
1959 return error;
1960}
1961
1962long do_sigpending(void __user *set, unsigned long sigsetsize)
1963{
1964 long error = -EINVAL;
1965 sigset_t pending;
1966
1967 if (sigsetsize > sizeof(sigset_t))
1968 goto out;
1969
1970 spin_lock_irq(&current->sighand->siglock);
1971 sigorsets(&pending, &current->pending.signal,
1972 &current->signal->shared_pending.signal);
1973 spin_unlock_irq(&current->sighand->siglock);
1974
1975 /* Outside the lock because only this thread touches it. */
1976 sigandsets(&pending, &current->blocked, &pending);
1977
1978 error = -EFAULT;
1979 if (!copy_to_user(set, &pending, sigsetsize))
1980 error = 0;
1981
1982out:
1983 return error;
1984}
1985
1986asmlinkage long
1987sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
1988{
1989 return do_sigpending(set, sigsetsize);
1990}
1991
1992#ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
1993
1994int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
1995{
1996 int err;
1997
1998 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
1999 return -EFAULT;
2000 if (from->si_code < 0)
2001 return __copy_to_user(to, from, sizeof(siginfo_t))
2002 ? -EFAULT : 0;
2003 /*
2004 * If you change siginfo_t structure, please be sure
2005 * this code is fixed accordingly.
Davide Libenzifba2afa2007-05-10 22:23:13 -07002006 * Please remember to update the signalfd_copyinfo() function
2007 * inside fs/signalfd.c too, in case siginfo_t changes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 * It should never copy any pad contained in the structure
2009 * to avoid security leaks, but must copy the generic
2010 * 3 ints plus the relevant union member.
2011 */
2012 err = __put_user(from->si_signo, &to->si_signo);
2013 err |= __put_user(from->si_errno, &to->si_errno);
2014 err |= __put_user((short)from->si_code, &to->si_code);
2015 switch (from->si_code & __SI_MASK) {
2016 case __SI_KILL:
2017 err |= __put_user(from->si_pid, &to->si_pid);
2018 err |= __put_user(from->si_uid, &to->si_uid);
2019 break;
2020 case __SI_TIMER:
2021 err |= __put_user(from->si_tid, &to->si_tid);
2022 err |= __put_user(from->si_overrun, &to->si_overrun);
2023 err |= __put_user(from->si_ptr, &to->si_ptr);
2024 break;
2025 case __SI_POLL:
2026 err |= __put_user(from->si_band, &to->si_band);
2027 err |= __put_user(from->si_fd, &to->si_fd);
2028 break;
2029 case __SI_FAULT:
2030 err |= __put_user(from->si_addr, &to->si_addr);
2031#ifdef __ARCH_SI_TRAPNO
2032 err |= __put_user(from->si_trapno, &to->si_trapno);
2033#endif
2034 break;
2035 case __SI_CHLD:
2036 err |= __put_user(from->si_pid, &to->si_pid);
2037 err |= __put_user(from->si_uid, &to->si_uid);
2038 err |= __put_user(from->si_status, &to->si_status);
2039 err |= __put_user(from->si_utime, &to->si_utime);
2040 err |= __put_user(from->si_stime, &to->si_stime);
2041 break;
2042 case __SI_RT: /* This is not generated by the kernel as of now. */
2043 case __SI_MESGQ: /* But this is */
2044 err |= __put_user(from->si_pid, &to->si_pid);
2045 err |= __put_user(from->si_uid, &to->si_uid);
2046 err |= __put_user(from->si_ptr, &to->si_ptr);
2047 break;
2048 default: /* this is just in case for now ... */
2049 err |= __put_user(from->si_pid, &to->si_pid);
2050 err |= __put_user(from->si_uid, &to->si_uid);
2051 break;
2052 }
2053 return err;
2054}
2055
2056#endif
2057
2058asmlinkage long
2059sys_rt_sigtimedwait(const sigset_t __user *uthese,
2060 siginfo_t __user *uinfo,
2061 const struct timespec __user *uts,
2062 size_t sigsetsize)
2063{
2064 int ret, sig;
2065 sigset_t these;
2066 struct timespec ts;
2067 siginfo_t info;
2068 long timeout = 0;
2069
2070 /* XXX: Don't preclude handling different sized sigset_t's. */
2071 if (sigsetsize != sizeof(sigset_t))
2072 return -EINVAL;
2073
2074 if (copy_from_user(&these, uthese, sizeof(these)))
2075 return -EFAULT;
2076
2077 /*
2078 * Invert the set of allowed signals to get those we
2079 * want to block.
2080 */
2081 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2082 signotset(&these);
2083
2084 if (uts) {
2085 if (copy_from_user(&ts, uts, sizeof(ts)))
2086 return -EFAULT;
2087 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2088 || ts.tv_sec < 0)
2089 return -EINVAL;
2090 }
2091
2092 spin_lock_irq(&current->sighand->siglock);
2093 sig = dequeue_signal(current, &these, &info);
2094 if (!sig) {
2095 timeout = MAX_SCHEDULE_TIMEOUT;
2096 if (uts)
2097 timeout = (timespec_to_jiffies(&ts)
2098 + (ts.tv_sec || ts.tv_nsec));
2099
2100 if (timeout) {
2101 /* None ready -- temporarily unblock those we're
2102 * interested while we are sleeping in so that we'll
2103 * be awakened when they arrive. */
2104 current->real_blocked = current->blocked;
2105 sigandsets(&current->blocked, &current->blocked, &these);
2106 recalc_sigpending();
2107 spin_unlock_irq(&current->sighand->siglock);
2108
Nishanth Aravamudan75bcc8c2005-09-10 00:27:24 -07002109 timeout = schedule_timeout_interruptible(timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111 spin_lock_irq(&current->sighand->siglock);
2112 sig = dequeue_signal(current, &these, &info);
2113 current->blocked = current->real_blocked;
2114 siginitset(&current->real_blocked, 0);
2115 recalc_sigpending();
2116 }
2117 }
2118 spin_unlock_irq(&current->sighand->siglock);
2119
2120 if (sig) {
2121 ret = sig;
2122 if (uinfo) {
2123 if (copy_siginfo_to_user(uinfo, &info))
2124 ret = -EFAULT;
2125 }
2126 } else {
2127 ret = -EAGAIN;
2128 if (timeout)
2129 ret = -EINTR;
2130 }
2131
2132 return ret;
2133}
2134
2135asmlinkage long
2136sys_kill(int pid, int sig)
2137{
2138 struct siginfo info;
2139
2140 info.si_signo = sig;
2141 info.si_errno = 0;
2142 info.si_code = SI_USER;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002143 info.si_pid = task_tgid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144 info.si_uid = current->uid;
2145
2146 return kill_something_info(sig, &info, pid);
2147}
2148
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002149static int do_tkill(int tgid, int pid, int sig)
2150{
2151 int error;
2152 struct siginfo info;
2153 struct task_struct *p;
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002154 unsigned long flags;
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002155
2156 error = -ESRCH;
2157 info.si_signo = sig;
2158 info.si_errno = 0;
2159 info.si_code = SI_TKILL;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002160 info.si_pid = task_tgid_vnr(current);
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002161 info.si_uid = current->uid;
2162
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002163 rcu_read_lock();
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -07002164 p = find_task_by_vpid(pid);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002165 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002166 error = check_kill_permission(sig, &info, p);
2167 /*
2168 * The null signal is a permissions and process existence
2169 * probe. No signal is actually delivered.
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002170 *
2171 * If lock_task_sighand() fails we pretend the task dies
2172 * after receiving the signal. The window is tiny, and the
2173 * signal is private anyway.
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002174 */
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002175 if (!error && sig && lock_task_sighand(p, &flags)) {
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002176 error = specific_send_sig_info(sig, &info, p);
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002177 unlock_task_sighand(p, &flags);
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002178 }
2179 }
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002180 rcu_read_unlock();
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002181
2182 return error;
2183}
2184
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185/**
2186 * sys_tgkill - send signal to one specific thread
2187 * @tgid: the thread group ID of the thread
2188 * @pid: the PID of the thread
2189 * @sig: signal to be sent
2190 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08002191 * This syscall also checks the @tgid and returns -ESRCH even if the PID
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 * exists but it's not belonging to the target process anymore. This
2193 * method solves the problem of threads exiting and PIDs getting reused.
2194 */
2195asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2196{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 /* This is only valid for single tasks */
2198 if (pid <= 0 || tgid <= 0)
2199 return -EINVAL;
2200
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002201 return do_tkill(tgid, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202}
2203
2204/*
2205 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2206 */
2207asmlinkage long
2208sys_tkill(int pid, int sig)
2209{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210 /* This is only valid for single tasks */
2211 if (pid <= 0)
2212 return -EINVAL;
2213
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002214 return do_tkill(0, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215}
2216
2217asmlinkage long
2218sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2219{
2220 siginfo_t info;
2221
2222 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2223 return -EFAULT;
2224
2225 /* Not even root can pretend to send signals from the kernel.
2226 Nor can they impersonate a kill(), which adds source info. */
2227 if (info.si_code >= 0)
2228 return -EPERM;
2229 info.si_signo = sig;
2230
2231 /* POSIX.1b doesn't mention process groups. */
2232 return kill_proc_info(sig, &info, pid);
2233}
2234
Oleg Nesterov88531f72006-03-28 16:11:24 -08002235int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236{
Pavel Emelyanov93585ee2008-04-30 00:52:39 -07002237 struct task_struct *t = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 struct k_sigaction *k;
George Anzinger71fabd52006-01-08 01:02:48 -08002239 sigset_t mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240
Jesper Juhl7ed20e12005-05-01 08:59:14 -07002241 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 return -EINVAL;
2243
Pavel Emelyanov93585ee2008-04-30 00:52:39 -07002244 k = &t->sighand->action[sig-1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245
2246 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 if (oact)
2248 *oact = *k;
2249
2250 if (act) {
Oleg Nesterov9ac95f22006-02-09 22:41:50 +03002251 sigdelsetmask(&act->sa.sa_mask,
2252 sigmask(SIGKILL) | sigmask(SIGSTOP));
Oleg Nesterov88531f72006-03-28 16:11:24 -08002253 *k = *act;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254 /*
2255 * POSIX 3.3.1.3:
2256 * "Setting a signal action to SIG_IGN for a signal that is
2257 * pending shall cause the pending signal to be discarded,
2258 * whether or not it is blocked."
2259 *
2260 * "Setting a signal action to SIG_DFL for a signal that is
2261 * pending and whose default action is to ignore the signal
2262 * (for example, SIGCHLD), shall cause the pending signal to
2263 * be discarded, whether or not it is blocked"
2264 */
Pavel Emelyanov93585ee2008-04-30 00:52:39 -07002265 if (__sig_ignored(t, sig)) {
George Anzinger71fabd52006-01-08 01:02:48 -08002266 sigemptyset(&mask);
2267 sigaddset(&mask, sig);
2268 rm_from_queue_full(&mask, &t->signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002269 do {
George Anzinger71fabd52006-01-08 01:02:48 -08002270 rm_from_queue_full(&mask, &t->pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271 t = next_thread(t);
2272 } while (t != current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 }
2275
2276 spin_unlock_irq(&current->sighand->siglock);
2277 return 0;
2278}
2279
2280int
2281do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2282{
2283 stack_t oss;
2284 int error;
2285
2286 if (uoss) {
2287 oss.ss_sp = (void __user *) current->sas_ss_sp;
2288 oss.ss_size = current->sas_ss_size;
2289 oss.ss_flags = sas_ss_flags(sp);
2290 }
2291
2292 if (uss) {
2293 void __user *ss_sp;
2294 size_t ss_size;
2295 int ss_flags;
2296
2297 error = -EFAULT;
2298 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2299 || __get_user(ss_sp, &uss->ss_sp)
2300 || __get_user(ss_flags, &uss->ss_flags)
2301 || __get_user(ss_size, &uss->ss_size))
2302 goto out;
2303
2304 error = -EPERM;
2305 if (on_sig_stack(sp))
2306 goto out;
2307
2308 error = -EINVAL;
2309 /*
2310 *
2311 * Note - this code used to test ss_flags incorrectly
2312 * old code may have been written using ss_flags==0
2313 * to mean ss_flags==SS_ONSTACK (as this was the only
2314 * way that worked) - this fix preserves that older
2315 * mechanism
2316 */
2317 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2318 goto out;
2319
2320 if (ss_flags == SS_DISABLE) {
2321 ss_size = 0;
2322 ss_sp = NULL;
2323 } else {
2324 error = -ENOMEM;
2325 if (ss_size < MINSIGSTKSZ)
2326 goto out;
2327 }
2328
2329 current->sas_ss_sp = (unsigned long) ss_sp;
2330 current->sas_ss_size = ss_size;
2331 }
2332
2333 if (uoss) {
2334 error = -EFAULT;
2335 if (copy_to_user(uoss, &oss, sizeof(oss)))
2336 goto out;
2337 }
2338
2339 error = 0;
2340out:
2341 return error;
2342}
2343
2344#ifdef __ARCH_WANT_SYS_SIGPENDING
2345
2346asmlinkage long
2347sys_sigpending(old_sigset_t __user *set)
2348{
2349 return do_sigpending(set, sizeof(*set));
2350}
2351
2352#endif
2353
2354#ifdef __ARCH_WANT_SYS_SIGPROCMASK
2355/* Some platforms have their own version with special arguments others
2356 support only sys_rt_sigprocmask. */
2357
2358asmlinkage long
2359sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2360{
2361 int error;
2362 old_sigset_t old_set, new_set;
2363
2364 if (set) {
2365 error = -EFAULT;
2366 if (copy_from_user(&new_set, set, sizeof(*set)))
2367 goto out;
2368 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2369
2370 spin_lock_irq(&current->sighand->siglock);
2371 old_set = current->blocked.sig[0];
2372
2373 error = 0;
2374 switch (how) {
2375 default:
2376 error = -EINVAL;
2377 break;
2378 case SIG_BLOCK:
2379 sigaddsetmask(&current->blocked, new_set);
2380 break;
2381 case SIG_UNBLOCK:
2382 sigdelsetmask(&current->blocked, new_set);
2383 break;
2384 case SIG_SETMASK:
2385 current->blocked.sig[0] = new_set;
2386 break;
2387 }
2388
2389 recalc_sigpending();
2390 spin_unlock_irq(&current->sighand->siglock);
2391 if (error)
2392 goto out;
2393 if (oset)
2394 goto set_old;
2395 } else if (oset) {
2396 old_set = current->blocked.sig[0];
2397 set_old:
2398 error = -EFAULT;
2399 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2400 goto out;
2401 }
2402 error = 0;
2403out:
2404 return error;
2405}
2406#endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2407
2408#ifdef __ARCH_WANT_SYS_RT_SIGACTION
2409asmlinkage long
2410sys_rt_sigaction(int sig,
2411 const struct sigaction __user *act,
2412 struct sigaction __user *oact,
2413 size_t sigsetsize)
2414{
2415 struct k_sigaction new_sa, old_sa;
2416 int ret = -EINVAL;
2417
2418 /* XXX: Don't preclude handling different sized sigset_t's. */
2419 if (sigsetsize != sizeof(sigset_t))
2420 goto out;
2421
2422 if (act) {
2423 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2424 return -EFAULT;
2425 }
2426
2427 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2428
2429 if (!ret && oact) {
2430 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2431 return -EFAULT;
2432 }
2433out:
2434 return ret;
2435}
2436#endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2437
2438#ifdef __ARCH_WANT_SYS_SGETMASK
2439
2440/*
2441 * For backwards compatibility. Functionality superseded by sigprocmask.
2442 */
2443asmlinkage long
2444sys_sgetmask(void)
2445{
2446 /* SMP safe */
2447 return current->blocked.sig[0];
2448}
2449
2450asmlinkage long
2451sys_ssetmask(int newmask)
2452{
2453 int old;
2454
2455 spin_lock_irq(&current->sighand->siglock);
2456 old = current->blocked.sig[0];
2457
2458 siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2459 sigmask(SIGSTOP)));
2460 recalc_sigpending();
2461 spin_unlock_irq(&current->sighand->siglock);
2462
2463 return old;
2464}
2465#endif /* __ARCH_WANT_SGETMASK */
2466
2467#ifdef __ARCH_WANT_SYS_SIGNAL
2468/*
2469 * For backwards compatibility. Functionality superseded by sigaction.
2470 */
2471asmlinkage unsigned long
2472sys_signal(int sig, __sighandler_t handler)
2473{
2474 struct k_sigaction new_sa, old_sa;
2475 int ret;
2476
2477 new_sa.sa.sa_handler = handler;
2478 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
Oleg Nesterovc70d3d72006-02-09 22:41:41 +03002479 sigemptyset(&new_sa.sa.sa_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480
2481 ret = do_sigaction(sig, &new_sa, &old_sa);
2482
2483 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2484}
2485#endif /* __ARCH_WANT_SYS_SIGNAL */
2486
2487#ifdef __ARCH_WANT_SYS_PAUSE
2488
2489asmlinkage long
2490sys_pause(void)
2491{
2492 current->state = TASK_INTERRUPTIBLE;
2493 schedule();
2494 return -ERESTARTNOHAND;
2495}
2496
2497#endif
2498
David Woodhouse150256d2006-01-18 17:43:57 -08002499#ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2500asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2501{
2502 sigset_t newset;
2503
2504 /* XXX: Don't preclude handling different sized sigset_t's. */
2505 if (sigsetsize != sizeof(sigset_t))
2506 return -EINVAL;
2507
2508 if (copy_from_user(&newset, unewset, sizeof(newset)))
2509 return -EFAULT;
2510 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2511
2512 spin_lock_irq(&current->sighand->siglock);
2513 current->saved_sigmask = current->blocked;
2514 current->blocked = newset;
2515 recalc_sigpending();
2516 spin_unlock_irq(&current->sighand->siglock);
2517
2518 current->state = TASK_INTERRUPTIBLE;
2519 schedule();
2520 set_thread_flag(TIF_RESTORE_SIGMASK);
2521 return -ERESTARTNOHAND;
2522}
2523#endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2524
David Howellsf269fdd2006-09-27 01:50:23 -07002525__attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2526{
2527 return NULL;
2528}
2529
Linus Torvalds1da177e2005-04-16 15:20:36 -07002530void __init signals_init(void)
2531{
Christoph Lameter0a31bd52007-05-06 14:49:57 -07002532 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002533}