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