2 * linux/kernel/signal.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
6 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
8 * 2003-06-02 Jim Houston - Concurrent Computer Corp.
9 * Changes to use preallocated sigqueue structures
10 * to allow signals to be sent reliably.
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/sched.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>
23 #include <linux/signal.h>
24 #include <linux/signalfd.h>
25 #include <linux/ratelimit.h>
26 #include <linux/tracehook.h>
27 #include <linux/capability.h>
28 #include <linux/freezer.h>
29 #include <linux/pid_namespace.h>
30 #include <linux/nsproxy.h>
31 #define CREATE_TRACE_POINTS
32 #include <trace/events/signal.h>
34 #include <asm/param.h>
35 #include <asm/uaccess.h>
36 #include <asm/unistd.h>
37 #include <asm/siginfo.h>
38 #include "audit.h" /* audit_signal_info() */
41 * SLAB caches for signal bits.
44 static struct kmem_cache
*sigqueue_cachep
;
46 int print_fatal_signals __read_mostly
;
48 static void __user
*sig_handler(struct task_struct
*t
, int sig
)
50 return t
->sighand
->action
[sig
- 1].sa
.sa_handler
;
53 static int sig_handler_ignored(void __user
*handler
, int sig
)
55 /* Is it explicitly or implicitly ignored? */
56 return handler
== SIG_IGN
||
57 (handler
== SIG_DFL
&& sig_kernel_ignore(sig
));
60 static int sig_task_ignored(struct task_struct
*t
, int sig
,
65 handler
= sig_handler(t
, sig
);
67 if (unlikely(t
->signal
->flags
& SIGNAL_UNKILLABLE
) &&
68 handler
== SIG_DFL
&& !from_ancestor_ns
)
71 return sig_handler_ignored(handler
, sig
);
74 static int sig_ignored(struct task_struct
*t
, int sig
, int from_ancestor_ns
)
77 * Blocked signals are never ignored, since the
78 * signal handler may change by the time it is
81 if (sigismember(&t
->blocked
, sig
) || sigismember(&t
->real_blocked
, sig
))
84 if (!sig_task_ignored(t
, sig
, from_ancestor_ns
))
88 * Tracers may want to know about even ignored signals.
90 return !tracehook_consider_ignored_signal(t
, sig
);
94 * Re-calculate pending state from the set of locally pending
95 * signals, globally pending signals, and blocked signals.
97 static inline int has_pending_signals(sigset_t
*signal
, sigset_t
*blocked
)
102 switch (_NSIG_WORDS
) {
104 for (i
= _NSIG_WORDS
, ready
= 0; --i
>= 0 ;)
105 ready
|= signal
->sig
[i
] &~ blocked
->sig
[i
];
108 case 4: ready
= signal
->sig
[3] &~ blocked
->sig
[3];
109 ready
|= signal
->sig
[2] &~ blocked
->sig
[2];
110 ready
|= signal
->sig
[1] &~ blocked
->sig
[1];
111 ready
|= signal
->sig
[0] &~ blocked
->sig
[0];
114 case 2: ready
= signal
->sig
[1] &~ blocked
->sig
[1];
115 ready
|= signal
->sig
[0] &~ blocked
->sig
[0];
118 case 1: ready
= signal
->sig
[0] &~ blocked
->sig
[0];
123 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
125 static int recalc_sigpending_tsk(struct task_struct
*t
)
127 if (t
->signal
->group_stop_count
> 0 ||
128 PENDING(&t
->pending
, &t
->blocked
) ||
129 PENDING(&t
->signal
->shared_pending
, &t
->blocked
)) {
130 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
134 * We must never clear the flag in another thread, or in current
135 * when it's possible the current syscall is returning -ERESTART*.
136 * So we don't clear it here, and only callers who know they should do.
142 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
143 * This is superfluous when called on current, the wakeup is a harmless no-op.
145 void recalc_sigpending_and_wake(struct task_struct
*t
)
147 if (recalc_sigpending_tsk(t
))
148 signal_wake_up(t
, 0);
151 void recalc_sigpending(void)
153 if (unlikely(tracehook_force_sigpending()))
154 set_thread_flag(TIF_SIGPENDING
);
155 else if (!recalc_sigpending_tsk(current
) && !freezing(current
))
156 clear_thread_flag(TIF_SIGPENDING
);
160 /* Given the mask, find the first available signal that should be serviced. */
162 #define SYNCHRONOUS_MASK \
163 (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
164 sigmask(SIGTRAP) | sigmask(SIGFPE))
166 int next_signal(struct sigpending
*pending
, sigset_t
*mask
)
168 unsigned long i
, *s
, *m
, x
;
171 s
= pending
->signal
.sig
;
175 * Handle the first word specially: it contains the
176 * synchronous signals that need to be dequeued first.
180 if (x
& SYNCHRONOUS_MASK
)
181 x
&= SYNCHRONOUS_MASK
;
186 switch (_NSIG_WORDS
) {
188 for (i
= 1; i
< _NSIG_WORDS
; ++i
) {
192 sig
= ffz(~x
) + i
*_NSIG_BPW
+ 1;
201 sig
= ffz(~x
) + _NSIG_BPW
+ 1;
212 static inline void print_dropped_signal(int sig
)
214 static DEFINE_RATELIMIT_STATE(ratelimit_state
, 5 * HZ
, 10);
216 if (!print_fatal_signals
)
219 if (!__ratelimit(&ratelimit_state
))
222 printk(KERN_INFO
"%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
223 current
->comm
, current
->pid
, sig
);
227 * allocate a new signal queue record
228 * - this may be called without locks if and only if t == current, otherwise an
229 * appopriate lock must be held to stop the target task from exiting
231 static struct sigqueue
*
232 __sigqueue_alloc(int sig
, struct task_struct
*t
, gfp_t flags
, int override_rlimit
)
234 struct sigqueue
*q
= NULL
;
235 struct user_struct
*user
;
238 * Protect access to @t credentials. This can go away when all
239 * callers hold rcu read lock.
242 user
= get_uid(__task_cred(t
)->user
);
243 atomic_inc(&user
->sigpending
);
246 if (override_rlimit
||
247 atomic_read(&user
->sigpending
) <=
248 task_rlimit(t
, RLIMIT_SIGPENDING
)) {
249 q
= kmem_cache_alloc(sigqueue_cachep
, flags
);
251 print_dropped_signal(sig
);
254 if (unlikely(q
== NULL
)) {
255 atomic_dec(&user
->sigpending
);
258 INIT_LIST_HEAD(&q
->list
);
266 static void __sigqueue_free(struct sigqueue
*q
)
268 if (q
->flags
& SIGQUEUE_PREALLOC
)
270 atomic_dec(&q
->user
->sigpending
);
272 kmem_cache_free(sigqueue_cachep
, q
);
275 void flush_sigqueue(struct sigpending
*queue
)
279 sigemptyset(&queue
->signal
);
280 while (!list_empty(&queue
->list
)) {
281 q
= list_entry(queue
->list
.next
, struct sigqueue
, list
);
282 list_del_init(&q
->list
);
288 * Flush all pending signals for a task.
290 void __flush_signals(struct task_struct
*t
)
292 clear_tsk_thread_flag(t
, TIF_SIGPENDING
);
293 flush_sigqueue(&t
->pending
);
294 flush_sigqueue(&t
->signal
->shared_pending
);
297 void flush_signals(struct task_struct
*t
)
301 spin_lock_irqsave(&t
->sighand
->siglock
, flags
);
303 spin_unlock_irqrestore(&t
->sighand
->siglock
, flags
);
306 static void __flush_itimer_signals(struct sigpending
*pending
)
308 sigset_t signal
, retain
;
309 struct sigqueue
*q
, *n
;
311 signal
= pending
->signal
;
312 sigemptyset(&retain
);
314 list_for_each_entry_safe(q
, n
, &pending
->list
, list
) {
315 int sig
= q
->info
.si_signo
;
317 if (likely(q
->info
.si_code
!= SI_TIMER
)) {
318 sigaddset(&retain
, sig
);
320 sigdelset(&signal
, sig
);
321 list_del_init(&q
->list
);
326 sigorsets(&pending
->signal
, &signal
, &retain
);
329 void flush_itimer_signals(void)
331 struct task_struct
*tsk
= current
;
334 spin_lock_irqsave(&tsk
->sighand
->siglock
, flags
);
335 __flush_itimer_signals(&tsk
->pending
);
336 __flush_itimer_signals(&tsk
->signal
->shared_pending
);
337 spin_unlock_irqrestore(&tsk
->sighand
->siglock
, flags
);
340 void ignore_signals(struct task_struct
*t
)
344 for (i
= 0; i
< _NSIG
; ++i
)
345 t
->sighand
->action
[i
].sa
.sa_handler
= SIG_IGN
;
351 * Flush all handlers for a task.
355 flush_signal_handlers(struct task_struct
*t
, int force_default
)
358 struct k_sigaction
*ka
= &t
->sighand
->action
[0];
359 for (i
= _NSIG
; i
!= 0 ; i
--) {
360 if (force_default
|| ka
->sa
.sa_handler
!= SIG_IGN
)
361 ka
->sa
.sa_handler
= SIG_DFL
;
363 sigemptyset(&ka
->sa
.sa_mask
);
368 int unhandled_signal(struct task_struct
*tsk
, int sig
)
370 void __user
*handler
= tsk
->sighand
->action
[sig
-1].sa
.sa_handler
;
371 if (is_global_init(tsk
))
373 if (handler
!= SIG_IGN
&& handler
!= SIG_DFL
)
375 return !tracehook_consider_fatal_signal(tsk
, sig
);
379 /* Notify the system that a driver wants to block all signals for this
380 * process, and wants to be notified if any signals at all were to be
381 * sent/acted upon. If the notifier routine returns non-zero, then the
382 * signal will be acted upon after all. If the notifier routine returns 0,
383 * then then signal will be blocked. Only one block per process is
384 * allowed. priv is a pointer to private data that the notifier routine
385 * can use to determine if the signal should be blocked or not. */
388 block_all_signals(int (*notifier
)(void *priv
), void *priv
, sigset_t
*mask
)
392 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
393 current
->notifier_mask
= mask
;
394 current
->notifier_data
= priv
;
395 current
->notifier
= notifier
;
396 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
399 /* Notify the system that blocking has ended. */
402 unblock_all_signals(void)
406 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
407 current
->notifier
= NULL
;
408 current
->notifier_data
= NULL
;
410 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
413 static void collect_signal(int sig
, struct sigpending
*list
, siginfo_t
*info
)
415 struct sigqueue
*q
, *first
= NULL
;
418 * Collect the siginfo appropriate to this signal. Check if
419 * there is another siginfo for the same signal.
421 list_for_each_entry(q
, &list
->list
, list
) {
422 if (q
->info
.si_signo
== sig
) {
429 sigdelset(&list
->signal
, sig
);
433 list_del_init(&first
->list
);
434 copy_siginfo(info
, &first
->info
);
435 __sigqueue_free(first
);
437 /* Ok, it wasn't in the queue. This must be
438 a fast-pathed signal or we must have been
439 out of queue space. So zero out the info.
441 info
->si_signo
= sig
;
443 info
->si_code
= SI_USER
;
449 static int __dequeue_signal(struct sigpending
*pending
, sigset_t
*mask
,
452 int sig
= next_signal(pending
, mask
);
455 if (current
->notifier
) {
456 if (sigismember(current
->notifier_mask
, sig
)) {
457 if (!(current
->notifier
)(current
->notifier_data
)) {
458 clear_thread_flag(TIF_SIGPENDING
);
464 collect_signal(sig
, pending
, info
);
471 * Dequeue a signal and return the element to the caller, which is
472 * expected to free it.
474 * All callers have to hold the siglock.
476 int dequeue_signal(struct task_struct
*tsk
, sigset_t
*mask
, siginfo_t
*info
)
480 /* We only dequeue private signals from ourselves, we don't let
481 * signalfd steal them
483 signr
= __dequeue_signal(&tsk
->pending
, mask
, info
);
485 signr
= __dequeue_signal(&tsk
->signal
->shared_pending
,
490 * itimers are process shared and we restart periodic
491 * itimers in the signal delivery path to prevent DoS
492 * attacks in the high resolution timer case. This is
493 * compliant with the old way of self restarting
494 * itimers, as the SIGALRM is a legacy signal and only
495 * queued once. Changing the restart behaviour to
496 * restart the timer in the signal dequeue path is
497 * reducing the timer noise on heavy loaded !highres
500 if (unlikely(signr
== SIGALRM
)) {
501 struct hrtimer
*tmr
= &tsk
->signal
->real_timer
;
503 if (!hrtimer_is_queued(tmr
) &&
504 tsk
->signal
->it_real_incr
.tv64
!= 0) {
505 hrtimer_forward(tmr
, tmr
->base
->get_time(),
506 tsk
->signal
->it_real_incr
);
507 hrtimer_restart(tmr
);
516 if (unlikely(sig_kernel_stop(signr
))) {
518 * Set a marker that we have dequeued a stop signal. Our
519 * caller might release the siglock and then the pending
520 * stop signal it is about to process is no longer in the
521 * pending bitmasks, but must still be cleared by a SIGCONT
522 * (and overruled by a SIGKILL). So those cases clear this
523 * shared flag after we've set it. Note that this flag may
524 * remain set after the signal we return is ignored or
525 * handled. That doesn't matter because its only purpose
526 * is to alert stop-signal processing code when another
527 * processor has come along and cleared the flag.
529 tsk
->signal
->flags
|= SIGNAL_STOP_DEQUEUED
;
531 if ((info
->si_code
& __SI_MASK
) == __SI_TIMER
&& info
->si_sys_private
) {
533 * Release the siglock to ensure proper locking order
534 * of timer locks outside of siglocks. Note, we leave
535 * irqs disabled here, since the posix-timers code is
536 * about to disable them again anyway.
538 spin_unlock(&tsk
->sighand
->siglock
);
539 do_schedule_next_timer(info
);
540 spin_lock(&tsk
->sighand
->siglock
);
546 * Tell a process that it has a new active signal..
548 * NOTE! we rely on the previous spin_lock to
549 * lock interrupts for us! We can only be called with
550 * "siglock" held, and the local interrupt must
551 * have been disabled when that got acquired!
553 * No need to set need_resched since signal event passing
554 * goes through ->blocked
556 void signal_wake_up(struct task_struct
*t
, int resume
)
560 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
563 * For SIGKILL, we want to wake it up in the stopped/traced/killable
564 * case. We don't check t->state here because there is a race with it
565 * executing another processor and just now entering stopped state.
566 * By using wake_up_state, we ensure the process will wake up and
567 * handle its death signal.
569 mask
= TASK_INTERRUPTIBLE
;
571 mask
|= TASK_WAKEKILL
;
572 if (!wake_up_state(t
, mask
))
577 * Remove signals in mask from the pending set and queue.
578 * Returns 1 if any signals were found.
580 * All callers must be holding the siglock.
582 * This version takes a sigset mask and looks at all signals,
583 * not just those in the first mask word.
585 static int rm_from_queue_full(sigset_t
*mask
, struct sigpending
*s
)
587 struct sigqueue
*q
, *n
;
590 sigandsets(&m
, mask
, &s
->signal
);
591 if (sigisemptyset(&m
))
594 signandsets(&s
->signal
, &s
->signal
, mask
);
595 list_for_each_entry_safe(q
, n
, &s
->list
, list
) {
596 if (sigismember(mask
, q
->info
.si_signo
)) {
597 list_del_init(&q
->list
);
604 * Remove signals in mask from the pending set and queue.
605 * Returns 1 if any signals were found.
607 * All callers must be holding the siglock.
609 static int rm_from_queue(unsigned long mask
, struct sigpending
*s
)
611 struct sigqueue
*q
, *n
;
613 if (!sigtestsetmask(&s
->signal
, mask
))
616 sigdelsetmask(&s
->signal
, mask
);
617 list_for_each_entry_safe(q
, n
, &s
->list
, list
) {
618 if (q
->info
.si_signo
< SIGRTMIN
&&
619 (mask
& sigmask(q
->info
.si_signo
))) {
620 list_del_init(&q
->list
);
627 static inline int is_si_special(const struct siginfo
*info
)
629 return info
<= SEND_SIG_FORCED
;
632 static inline bool si_fromuser(const struct siginfo
*info
)
634 return info
== SEND_SIG_NOINFO
||
635 (!is_si_special(info
) && SI_FROMUSER(info
));
639 * Bad permissions for sending the signal
640 * - the caller must hold the RCU read lock
642 static int check_kill_permission(int sig
, struct siginfo
*info
,
643 struct task_struct
*t
)
645 const struct cred
*cred
, *tcred
;
649 if (!valid_signal(sig
))
652 if (!si_fromuser(info
))
655 error
= audit_signal_info(sig
, t
); /* Let audit system see the signal */
659 cred
= current_cred();
660 tcred
= __task_cred(t
);
661 if (!same_thread_group(current
, t
) &&
662 (cred
->euid
^ tcred
->suid
) &&
663 (cred
->euid
^ tcred
->uid
) &&
664 (cred
->uid
^ tcred
->suid
) &&
665 (cred
->uid
^ tcred
->uid
) &&
666 !capable(CAP_KILL
)) {
669 sid
= task_session(t
);
671 * We don't return the error if sid == NULL. The
672 * task was unhashed, the caller must notice this.
674 if (!sid
|| sid
== task_session(current
))
681 return security_task_kill(t
, info
, sig
, 0);
685 * Handle magic process-wide effects of stop/continue signals. Unlike
686 * the signal actions, these happen immediately at signal-generation
687 * time regardless of blocking, ignoring, or handling. This does the
688 * actual continuing for SIGCONT, but not the actual stopping for stop
689 * signals. The process stop is done as a signal action for SIG_DFL.
691 * Returns true if the signal should be actually delivered, otherwise
692 * it should be dropped.
694 static int prepare_signal(int sig
, struct task_struct
*p
, int from_ancestor_ns
)
696 struct signal_struct
*signal
= p
->signal
;
697 struct task_struct
*t
;
699 if (unlikely(signal
->flags
& SIGNAL_GROUP_EXIT
)) {
701 * The process is in the middle of dying, nothing to do.
703 } else if (sig_kernel_stop(sig
)) {
705 * This is a stop signal. Remove SIGCONT from all queues.
707 rm_from_queue(sigmask(SIGCONT
), &signal
->shared_pending
);
710 rm_from_queue(sigmask(SIGCONT
), &t
->pending
);
711 } while_each_thread(p
, t
);
712 } else if (sig
== SIGCONT
) {
715 * Remove all stop signals from all queues,
716 * and wake all threads.
718 rm_from_queue(SIG_KERNEL_STOP_MASK
, &signal
->shared_pending
);
722 rm_from_queue(SIG_KERNEL_STOP_MASK
, &t
->pending
);
724 * If there is a handler for SIGCONT, we must make
725 * sure that no thread returns to user mode before
726 * we post the signal, in case it was the only
727 * thread eligible to run the signal handler--then
728 * it must not do anything between resuming and
729 * running the handler. With the TIF_SIGPENDING
730 * flag set, the thread will pause and acquire the
731 * siglock that we hold now and until we've queued
732 * the pending signal.
734 * Wake up the stopped thread _after_ setting
737 state
= __TASK_STOPPED
;
738 if (sig_user_defined(t
, SIGCONT
) && !sigismember(&t
->blocked
, SIGCONT
)) {
739 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
740 state
|= TASK_INTERRUPTIBLE
;
742 wake_up_state(t
, state
);
743 } while_each_thread(p
, t
);
746 * Notify the parent with CLD_CONTINUED if we were stopped.
748 * If we were in the middle of a group stop, we pretend it
749 * was already finished, and then continued. Since SIGCHLD
750 * doesn't queue we report only CLD_STOPPED, as if the next
751 * CLD_CONTINUED was dropped.
754 if (signal
->flags
& SIGNAL_STOP_STOPPED
)
755 why
|= SIGNAL_CLD_CONTINUED
;
756 else if (signal
->group_stop_count
)
757 why
|= SIGNAL_CLD_STOPPED
;
761 * The first thread which returns from do_signal_stop()
762 * will take ->siglock, notice SIGNAL_CLD_MASK, and
763 * notify its parent. See get_signal_to_deliver().
765 signal
->flags
= why
| SIGNAL_STOP_CONTINUED
;
766 signal
->group_stop_count
= 0;
767 signal
->group_exit_code
= 0;
770 * We are not stopped, but there could be a stop
771 * signal in the middle of being processed after
772 * being removed from the queue. Clear that too.
774 signal
->flags
&= ~SIGNAL_STOP_DEQUEUED
;
778 return !sig_ignored(p
, sig
, from_ancestor_ns
);
782 * Test if P wants to take SIG. After we've checked all threads with this,
783 * it's equivalent to finding no threads not blocking SIG. Any threads not
784 * blocking SIG were ruled out because they are not running and already
785 * have pending signals. Such threads will dequeue from the shared queue
786 * as soon as they're available, so putting the signal on the shared queue
787 * will be equivalent to sending it to one such thread.
789 static inline int wants_signal(int sig
, struct task_struct
*p
)
791 if (sigismember(&p
->blocked
, sig
))
793 if (p
->flags
& PF_EXITING
)
797 if (task_is_stopped_or_traced(p
))
799 return task_curr(p
) || !signal_pending(p
);
802 static void complete_signal(int sig
, struct task_struct
*p
, int group
)
804 struct signal_struct
*signal
= p
->signal
;
805 struct task_struct
*t
;
808 * Now find a thread we can wake up to take the signal off the queue.
810 * If the main thread wants the signal, it gets first crack.
811 * Probably the least surprising to the average bear.
813 if (wants_signal(sig
, p
))
815 else if (!group
|| thread_group_empty(p
))
817 * There is just one thread and it does not need to be woken.
818 * It will dequeue unblocked signals before it runs again.
823 * Otherwise try to find a suitable thread.
825 t
= signal
->curr_target
;
826 while (!wants_signal(sig
, t
)) {
828 if (t
== signal
->curr_target
)
830 * No thread needs to be woken.
831 * Any eligible threads will see
832 * the signal in the queue soon.
836 signal
->curr_target
= t
;
840 * Found a killable thread. If the signal will be fatal,
841 * then start taking the whole group down immediately.
843 if (sig_fatal(p
, sig
) &&
844 !(signal
->flags
& (SIGNAL_UNKILLABLE
| SIGNAL_GROUP_EXIT
)) &&
845 !sigismember(&t
->real_blocked
, sig
) &&
847 !tracehook_consider_fatal_signal(t
, sig
))) {
849 * This signal will be fatal to the whole group.
851 if (!sig_kernel_coredump(sig
)) {
853 * Start a group exit and wake everybody up.
854 * This way we don't have other threads
855 * running and doing things after a slower
856 * thread has the fatal signal pending.
858 signal
->flags
= SIGNAL_GROUP_EXIT
;
859 signal
->group_exit_code
= sig
;
860 signal
->group_stop_count
= 0;
863 sigaddset(&t
->pending
.signal
, SIGKILL
);
864 signal_wake_up(t
, 1);
865 } while_each_thread(p
, t
);
871 * The signal is already in the shared-pending queue.
872 * Tell the chosen thread to wake up and dequeue it.
874 signal_wake_up(t
, sig
== SIGKILL
);
878 static inline int legacy_queue(struct sigpending
*signals
, int sig
)
880 return (sig
< SIGRTMIN
) && sigismember(&signals
->signal
, sig
);
883 static int __send_signal(int sig
, struct siginfo
*info
, struct task_struct
*t
,
884 int group
, int from_ancestor_ns
)
886 struct sigpending
*pending
;
890 trace_signal_generate(sig
, info
, t
);
892 assert_spin_locked(&t
->sighand
->siglock
);
894 if (!prepare_signal(sig
, t
, from_ancestor_ns
))
897 pending
= group
? &t
->signal
->shared_pending
: &t
->pending
;
899 * Short-circuit ignored signals and support queuing
900 * exactly one non-rt signal, so that we can get more
901 * detailed information about the cause of the signal.
903 if (legacy_queue(pending
, sig
))
906 * fast-pathed signals for kernel-internal things like SIGSTOP
909 if (info
== SEND_SIG_FORCED
)
912 /* Real-time signals must be queued if sent by sigqueue, or
913 some other real-time mechanism. It is implementation
914 defined whether kill() does so. We attempt to do so, on
915 the principle of least surprise, but since kill is not
916 allowed to fail with EAGAIN when low on memory we just
917 make sure at least one signal gets delivered and don't
918 pass on the info struct. */
921 override_rlimit
= (is_si_special(info
) || info
->si_code
>= 0);
925 q
= __sigqueue_alloc(sig
, t
, GFP_ATOMIC
| __GFP_NOTRACK_FALSE_POSITIVE
,
928 list_add_tail(&q
->list
, &pending
->list
);
929 switch ((unsigned long) info
) {
930 case (unsigned long) SEND_SIG_NOINFO
:
931 q
->info
.si_signo
= sig
;
932 q
->info
.si_errno
= 0;
933 q
->info
.si_code
= SI_USER
;
934 q
->info
.si_pid
= task_tgid_nr_ns(current
,
935 task_active_pid_ns(t
));
936 q
->info
.si_uid
= current_uid();
938 case (unsigned long) SEND_SIG_PRIV
:
939 q
->info
.si_signo
= sig
;
940 q
->info
.si_errno
= 0;
941 q
->info
.si_code
= SI_KERNEL
;
946 copy_siginfo(&q
->info
, info
);
947 if (from_ancestor_ns
)
951 } else if (!is_si_special(info
)) {
952 if (sig
>= SIGRTMIN
&& info
->si_code
!= SI_USER
) {
954 * Queue overflow, abort. We may abort if the
955 * signal was rt and sent by user using something
958 trace_signal_overflow_fail(sig
, group
, info
);
962 * This is a silent loss of information. We still
963 * send the signal, but the *info bits are lost.
965 trace_signal_lose_info(sig
, group
, info
);
970 signalfd_notify(t
, sig
);
971 sigaddset(&pending
->signal
, sig
);
972 complete_signal(sig
, t
, group
);
976 static int send_signal(int sig
, struct siginfo
*info
, struct task_struct
*t
,
979 int from_ancestor_ns
= 0;
982 from_ancestor_ns
= si_fromuser(info
) &&
983 !task_pid_nr_ns(current
, task_active_pid_ns(t
));
986 return __send_signal(sig
, info
, t
, group
, from_ancestor_ns
);
989 static void print_fatal_signal(struct pt_regs
*regs
, int signr
)
991 printk("%s/%d: potentially unexpected fatal signal %d.\n",
992 current
->comm
, task_pid_nr(current
), signr
);
994 #if defined(__i386__) && !defined(__arch_um__)
995 printk("code at %08lx: ", regs
->ip
);
998 for (i
= 0; i
< 16; i
++) {
1001 if (get_user(insn
, (unsigned char *)(regs
->ip
+ i
)))
1003 printk("%02x ", insn
);
1013 static int __init
setup_print_fatal_signals(char *str
)
1015 get_option (&str
, &print_fatal_signals
);
1020 __setup("print-fatal-signals=", setup_print_fatal_signals
);
1023 __group_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1025 return send_signal(sig
, info
, p
, 1);
1029 specific_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*t
)
1031 return send_signal(sig
, info
, t
, 0);
1034 int do_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
,
1037 unsigned long flags
;
1040 if (lock_task_sighand(p
, &flags
)) {
1041 ret
= send_signal(sig
, info
, p
, group
);
1042 unlock_task_sighand(p
, &flags
);
1049 * Force a signal that the process can't ignore: if necessary
1050 * we unblock the signal and change any SIG_IGN to SIG_DFL.
1052 * Note: If we unblock the signal, we always reset it to SIG_DFL,
1053 * since we do not want to have a signal handler that was blocked
1054 * be invoked when user space had explicitly blocked it.
1056 * We don't want to have recursive SIGSEGV's etc, for example,
1057 * that is why we also clear SIGNAL_UNKILLABLE.
1060 force_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*t
)
1062 unsigned long int flags
;
1063 int ret
, blocked
, ignored
;
1064 struct k_sigaction
*action
;
1066 spin_lock_irqsave(&t
->sighand
->siglock
, flags
);
1067 action
= &t
->sighand
->action
[sig
-1];
1068 ignored
= action
->sa
.sa_handler
== SIG_IGN
;
1069 blocked
= sigismember(&t
->blocked
, sig
);
1070 if (blocked
|| ignored
) {
1071 action
->sa
.sa_handler
= SIG_DFL
;
1073 sigdelset(&t
->blocked
, sig
);
1074 recalc_sigpending_and_wake(t
);
1077 if (action
->sa
.sa_handler
== SIG_DFL
)
1078 t
->signal
->flags
&= ~SIGNAL_UNKILLABLE
;
1079 ret
= specific_send_sig_info(sig
, info
, t
);
1080 spin_unlock_irqrestore(&t
->sighand
->siglock
, flags
);
1086 * Nuke all other threads in the group.
1088 int zap_other_threads(struct task_struct
*p
)
1090 struct task_struct
*t
= p
;
1093 p
->signal
->group_stop_count
= 0;
1095 while_each_thread(p
, t
) {
1098 /* Don't bother with already dead threads */
1101 sigaddset(&t
->pending
.signal
, SIGKILL
);
1102 signal_wake_up(t
, 1);
1108 struct sighand_struct
*__lock_task_sighand(struct task_struct
*tsk
,
1109 unsigned long *flags
)
1111 struct sighand_struct
*sighand
;
1115 sighand
= rcu_dereference(tsk
->sighand
);
1116 if (unlikely(sighand
== NULL
))
1119 spin_lock_irqsave(&sighand
->siglock
, *flags
);
1120 if (likely(sighand
== tsk
->sighand
))
1122 spin_unlock_irqrestore(&sighand
->siglock
, *flags
);
1130 * send signal info to all the members of a group
1132 int group_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1137 ret
= check_kill_permission(sig
, info
, p
);
1141 ret
= do_send_sig_info(sig
, info
, p
, true);
1147 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1148 * control characters do (^C, ^Z etc)
1149 * - the caller must hold at least a readlock on tasklist_lock
1151 int __kill_pgrp_info(int sig
, struct siginfo
*info
, struct pid
*pgrp
)
1153 struct task_struct
*p
= NULL
;
1154 int retval
, success
;
1158 do_each_pid_task(pgrp
, PIDTYPE_PGID
, p
) {
1159 int err
= group_send_sig_info(sig
, info
, p
);
1162 } while_each_pid_task(pgrp
, PIDTYPE_PGID
, p
);
1163 return success
? 0 : retval
;
1166 int kill_pid_info(int sig
, struct siginfo
*info
, struct pid
*pid
)
1169 struct task_struct
*p
;
1173 p
= pid_task(pid
, PIDTYPE_PID
);
1175 error
= group_send_sig_info(sig
, info
, p
);
1176 if (unlikely(error
== -ESRCH
))
1178 * The task was unhashed in between, try again.
1179 * If it is dead, pid_task() will return NULL,
1180 * if we race with de_thread() it will find the
1191 kill_proc_info(int sig
, struct siginfo
*info
, pid_t pid
)
1195 error
= kill_pid_info(sig
, info
, find_vpid(pid
));
1200 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1201 int kill_pid_info_as_uid(int sig
, struct siginfo
*info
, struct pid
*pid
,
1202 uid_t uid
, uid_t euid
, u32 secid
)
1205 struct task_struct
*p
;
1206 const struct cred
*pcred
;
1207 unsigned long flags
;
1209 if (!valid_signal(sig
))
1213 p
= pid_task(pid
, PIDTYPE_PID
);
1218 pcred
= __task_cred(p
);
1219 if (si_fromuser(info
) &&
1220 euid
!= pcred
->suid
&& euid
!= pcred
->uid
&&
1221 uid
!= pcred
->suid
&& uid
!= pcred
->uid
) {
1225 ret
= security_task_kill(p
, info
, sig
, secid
);
1230 if (lock_task_sighand(p
, &flags
)) {
1231 ret
= __send_signal(sig
, info
, p
, 1, 0);
1232 unlock_task_sighand(p
, &flags
);
1240 EXPORT_SYMBOL_GPL(kill_pid_info_as_uid
);
1243 * kill_something_info() interprets pid in interesting ways just like kill(2).
1245 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1246 * is probably wrong. Should make it like BSD or SYSV.
1249 static int kill_something_info(int sig
, struct siginfo
*info
, pid_t pid
)
1255 ret
= kill_pid_info(sig
, info
, find_vpid(pid
));
1260 read_lock(&tasklist_lock
);
1262 ret
= __kill_pgrp_info(sig
, info
,
1263 pid
? find_vpid(-pid
) : task_pgrp(current
));
1265 int retval
= 0, count
= 0;
1266 struct task_struct
* p
;
1268 for_each_process(p
) {
1269 if (task_pid_vnr(p
) > 1 &&
1270 !same_thread_group(p
, current
)) {
1271 int err
= group_send_sig_info(sig
, info
, p
);
1277 ret
= count
? retval
: -ESRCH
;
1279 read_unlock(&tasklist_lock
);
1285 * These are for backward compatibility with the rest of the kernel source.
1289 send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1292 * Make sure legacy kernel users don't send in bad values
1293 * (normal paths check this in check_kill_permission).
1295 if (!valid_signal(sig
))
1298 return do_send_sig_info(sig
, info
, p
, false);
1301 #define __si_special(priv) \
1302 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1305 send_sig(int sig
, struct task_struct
*p
, int priv
)
1307 return send_sig_info(sig
, __si_special(priv
), p
);
1311 force_sig(int sig
, struct task_struct
*p
)
1313 force_sig_info(sig
, SEND_SIG_PRIV
, p
);
1317 * When things go south during signal handling, we
1318 * will force a SIGSEGV. And if the signal that caused
1319 * the problem was already a SIGSEGV, we'll want to
1320 * make sure we don't even try to deliver the signal..
1323 force_sigsegv(int sig
, struct task_struct
*p
)
1325 if (sig
== SIGSEGV
) {
1326 unsigned long flags
;
1327 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1328 p
->sighand
->action
[sig
- 1].sa
.sa_handler
= SIG_DFL
;
1329 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1331 force_sig(SIGSEGV
, p
);
1335 int kill_pgrp(struct pid
*pid
, int sig
, int priv
)
1339 read_lock(&tasklist_lock
);
1340 ret
= __kill_pgrp_info(sig
, __si_special(priv
), pid
);
1341 read_unlock(&tasklist_lock
);
1345 EXPORT_SYMBOL(kill_pgrp
);
1347 int kill_pid(struct pid
*pid
, int sig
, int priv
)
1349 return kill_pid_info(sig
, __si_special(priv
), pid
);
1351 EXPORT_SYMBOL(kill_pid
);
1354 * These functions support sending signals using preallocated sigqueue
1355 * structures. This is needed "because realtime applications cannot
1356 * afford to lose notifications of asynchronous events, like timer
1357 * expirations or I/O completions". In the case of Posix Timers
1358 * we allocate the sigqueue structure from the timer_create. If this
1359 * allocation fails we are able to report the failure to the application
1360 * with an EAGAIN error.
1362 struct sigqueue
*sigqueue_alloc(void)
1364 struct sigqueue
*q
= __sigqueue_alloc(-1, current
, GFP_KERNEL
, 0);
1367 q
->flags
|= SIGQUEUE_PREALLOC
;
1372 void sigqueue_free(struct sigqueue
*q
)
1374 unsigned long flags
;
1375 spinlock_t
*lock
= ¤t
->sighand
->siglock
;
1377 BUG_ON(!(q
->flags
& SIGQUEUE_PREALLOC
));
1379 * We must hold ->siglock while testing q->list
1380 * to serialize with collect_signal() or with
1381 * __exit_signal()->flush_sigqueue().
1383 spin_lock_irqsave(lock
, flags
);
1384 q
->flags
&= ~SIGQUEUE_PREALLOC
;
1386 * If it is queued it will be freed when dequeued,
1387 * like the "regular" sigqueue.
1389 if (!list_empty(&q
->list
))
1391 spin_unlock_irqrestore(lock
, flags
);
1397 int send_sigqueue(struct sigqueue
*q
, struct task_struct
*t
, int group
)
1399 int sig
= q
->info
.si_signo
;
1400 struct sigpending
*pending
;
1401 unsigned long flags
;
1404 BUG_ON(!(q
->flags
& SIGQUEUE_PREALLOC
));
1407 if (!likely(lock_task_sighand(t
, &flags
)))
1410 ret
= 1; /* the signal is ignored */
1411 if (!prepare_signal(sig
, t
, 0))
1415 if (unlikely(!list_empty(&q
->list
))) {
1417 * If an SI_TIMER entry is already queue just increment
1418 * the overrun count.
1420 BUG_ON(q
->info
.si_code
!= SI_TIMER
);
1421 q
->info
.si_overrun
++;
1424 q
->info
.si_overrun
= 0;
1426 signalfd_notify(t
, sig
);
1427 pending
= group
? &t
->signal
->shared_pending
: &t
->pending
;
1428 list_add_tail(&q
->list
, &pending
->list
);
1429 sigaddset(&pending
->signal
, sig
);
1430 complete_signal(sig
, t
, group
);
1432 unlock_task_sighand(t
, &flags
);
1438 * Let a parent know about the death of a child.
1439 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1441 * Returns -1 if our parent ignored us and so we've switched to
1442 * self-reaping, or else @sig.
1444 int do_notify_parent(struct task_struct
*tsk
, int sig
)
1446 struct siginfo info
;
1447 unsigned long flags
;
1448 struct sighand_struct
*psig
;
1453 /* do_notify_parent_cldstop should have been called instead. */
1454 BUG_ON(task_is_stopped_or_traced(tsk
));
1456 BUG_ON(!task_ptrace(tsk
) &&
1457 (tsk
->group_leader
!= tsk
|| !thread_group_empty(tsk
)));
1459 info
.si_signo
= sig
;
1462 * we are under tasklist_lock here so our parent is tied to
1463 * us and cannot exit and release its namespace.
1465 * the only it can is to switch its nsproxy with sys_unshare,
1466 * bu uncharing pid namespaces is not allowed, so we'll always
1467 * see relevant namespace
1469 * write_lock() currently calls preempt_disable() which is the
1470 * same as rcu_read_lock(), but according to Oleg, this is not
1471 * correct to rely on this
1474 info
.si_pid
= task_pid_nr_ns(tsk
, tsk
->parent
->nsproxy
->pid_ns
);
1475 info
.si_uid
= __task_cred(tsk
)->uid
;
1478 info
.si_utime
= cputime_to_clock_t(cputime_add(tsk
->utime
,
1479 tsk
->signal
->utime
));
1480 info
.si_stime
= cputime_to_clock_t(cputime_add(tsk
->stime
,
1481 tsk
->signal
->stime
));
1483 info
.si_status
= tsk
->exit_code
& 0x7f;
1484 if (tsk
->exit_code
& 0x80)
1485 info
.si_code
= CLD_DUMPED
;
1486 else if (tsk
->exit_code
& 0x7f)
1487 info
.si_code
= CLD_KILLED
;
1489 info
.si_code
= CLD_EXITED
;
1490 info
.si_status
= tsk
->exit_code
>> 8;
1493 psig
= tsk
->parent
->sighand
;
1494 spin_lock_irqsave(&psig
->siglock
, flags
);
1495 if (!task_ptrace(tsk
) && sig
== SIGCHLD
&&
1496 (psig
->action
[SIGCHLD
-1].sa
.sa_handler
== SIG_IGN
||
1497 (psig
->action
[SIGCHLD
-1].sa
.sa_flags
& SA_NOCLDWAIT
))) {
1499 * We are exiting and our parent doesn't care. POSIX.1
1500 * defines special semantics for setting SIGCHLD to SIG_IGN
1501 * or setting the SA_NOCLDWAIT flag: we should be reaped
1502 * automatically and not left for our parent's wait4 call.
1503 * Rather than having the parent do it as a magic kind of
1504 * signal handler, we just set this to tell do_exit that we
1505 * can be cleaned up without becoming a zombie. Note that
1506 * we still call __wake_up_parent in this case, because a
1507 * blocked sys_wait4 might now return -ECHILD.
1509 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1510 * is implementation-defined: we do (if you don't want
1511 * it, just use SIG_IGN instead).
1513 ret
= tsk
->exit_signal
= -1;
1514 if (psig
->action
[SIGCHLD
-1].sa
.sa_handler
== SIG_IGN
)
1517 if (valid_signal(sig
) && sig
> 0)
1518 __group_send_sig_info(sig
, &info
, tsk
->parent
);
1519 __wake_up_parent(tsk
, tsk
->parent
);
1520 spin_unlock_irqrestore(&psig
->siglock
, flags
);
1525 static void do_notify_parent_cldstop(struct task_struct
*tsk
, int why
)
1527 struct siginfo info
;
1528 unsigned long flags
;
1529 struct task_struct
*parent
;
1530 struct sighand_struct
*sighand
;
1532 if (task_ptrace(tsk
))
1533 parent
= tsk
->parent
;
1535 tsk
= tsk
->group_leader
;
1536 parent
= tsk
->real_parent
;
1539 info
.si_signo
= SIGCHLD
;
1542 * see comment in do_notify_parent() abot the following 3 lines
1545 info
.si_pid
= task_pid_nr_ns(tsk
, parent
->nsproxy
->pid_ns
);
1546 info
.si_uid
= __task_cred(tsk
)->uid
;
1549 info
.si_utime
= cputime_to_clock_t(tsk
->utime
);
1550 info
.si_stime
= cputime_to_clock_t(tsk
->stime
);
1555 info
.si_status
= SIGCONT
;
1558 info
.si_status
= tsk
->signal
->group_exit_code
& 0x7f;
1561 info
.si_status
= tsk
->exit_code
& 0x7f;
1567 sighand
= parent
->sighand
;
1568 spin_lock_irqsave(&sighand
->siglock
, flags
);
1569 if (sighand
->action
[SIGCHLD
-1].sa
.sa_handler
!= SIG_IGN
&&
1570 !(sighand
->action
[SIGCHLD
-1].sa
.sa_flags
& SA_NOCLDSTOP
))
1571 __group_send_sig_info(SIGCHLD
, &info
, parent
);
1573 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1575 __wake_up_parent(tsk
, parent
);
1576 spin_unlock_irqrestore(&sighand
->siglock
, flags
);
1579 static inline int may_ptrace_stop(void)
1581 if (!likely(task_ptrace(current
)))
1584 * Are we in the middle of do_coredump?
1585 * If so and our tracer is also part of the coredump stopping
1586 * is a deadlock situation, and pointless because our tracer
1587 * is dead so don't allow us to stop.
1588 * If SIGKILL was already sent before the caller unlocked
1589 * ->siglock we must see ->core_state != NULL. Otherwise it
1590 * is safe to enter schedule().
1592 if (unlikely(current
->mm
->core_state
) &&
1593 unlikely(current
->mm
== current
->parent
->mm
))
1600 * Return nonzero if there is a SIGKILL that should be waking us up.
1601 * Called with the siglock held.
1603 static int sigkill_pending(struct task_struct
*tsk
)
1605 return sigismember(&tsk
->pending
.signal
, SIGKILL
) ||
1606 sigismember(&tsk
->signal
->shared_pending
.signal
, SIGKILL
);
1610 * This must be called with current->sighand->siglock held.
1612 * This should be the path for all ptrace stops.
1613 * We always set current->last_siginfo while stopped here.
1614 * That makes it a way to test a stopped process for
1615 * being ptrace-stopped vs being job-control-stopped.
1617 * If we actually decide not to stop at all because the tracer
1618 * is gone, we keep current->exit_code unless clear_code.
1620 static void ptrace_stop(int exit_code
, int clear_code
, siginfo_t
*info
)
1621 __releases(¤t
->sighand
->siglock
)
1622 __acquires(¤t
->sighand
->siglock
)
1624 if (arch_ptrace_stop_needed(exit_code
, info
)) {
1626 * The arch code has something special to do before a
1627 * ptrace stop. This is allowed to block, e.g. for faults
1628 * on user stack pages. We can't keep the siglock while
1629 * calling arch_ptrace_stop, so we must release it now.
1630 * To preserve proper semantics, we must do this before
1631 * any signal bookkeeping like checking group_stop_count.
1632 * Meanwhile, a SIGKILL could come in before we retake the
1633 * siglock. That must prevent us from sleeping in TASK_TRACED.
1634 * So after regaining the lock, we must check for SIGKILL.
1636 spin_unlock_irq(¤t
->sighand
->siglock
);
1637 arch_ptrace_stop(exit_code
, info
);
1638 spin_lock_irq(¤t
->sighand
->siglock
);
1639 if (sigkill_pending(current
))
1644 * If there is a group stop in progress,
1645 * we must participate in the bookkeeping.
1647 if (current
->signal
->group_stop_count
> 0)
1648 --current
->signal
->group_stop_count
;
1650 current
->last_siginfo
= info
;
1651 current
->exit_code
= exit_code
;
1653 /* Let the debugger run. */
1654 __set_current_state(TASK_TRACED
);
1655 spin_unlock_irq(¤t
->sighand
->siglock
);
1656 read_lock(&tasklist_lock
);
1657 if (may_ptrace_stop()) {
1658 do_notify_parent_cldstop(current
, CLD_TRAPPED
);
1660 * Don't want to allow preemption here, because
1661 * sys_ptrace() needs this task to be inactive.
1663 * XXX: implement read_unlock_no_resched().
1666 read_unlock(&tasklist_lock
);
1667 preempt_enable_no_resched();
1671 * By the time we got the lock, our tracer went away.
1672 * Don't drop the lock yet, another tracer may come.
1674 __set_current_state(TASK_RUNNING
);
1676 current
->exit_code
= 0;
1677 read_unlock(&tasklist_lock
);
1681 * While in TASK_TRACED, we were considered "frozen enough".
1682 * Now that we woke up, it's crucial if we're supposed to be
1683 * frozen that we freeze now before running anything substantial.
1688 * We are back. Now reacquire the siglock before touching
1689 * last_siginfo, so that we are sure to have synchronized with
1690 * any signal-sending on another CPU that wants to examine it.
1692 spin_lock_irq(¤t
->sighand
->siglock
);
1693 current
->last_siginfo
= NULL
;
1696 * Queued signals ignored us while we were stopped for tracing.
1697 * So check for any that we should take before resuming user mode.
1698 * This sets TIF_SIGPENDING, but never clears it.
1700 recalc_sigpending_tsk(current
);
1703 void ptrace_notify(int exit_code
)
1707 BUG_ON((exit_code
& (0x7f | ~0xffff)) != SIGTRAP
);
1709 memset(&info
, 0, sizeof info
);
1710 info
.si_signo
= SIGTRAP
;
1711 info
.si_code
= exit_code
;
1712 info
.si_pid
= task_pid_vnr(current
);
1713 info
.si_uid
= current_uid();
1715 /* Let the debugger run. */
1716 spin_lock_irq(¤t
->sighand
->siglock
);
1717 ptrace_stop(exit_code
, 1, &info
);
1718 spin_unlock_irq(¤t
->sighand
->siglock
);
1722 * This performs the stopping for SIGSTOP and other stop signals.
1723 * We have to stop all threads in the thread group.
1724 * Returns nonzero if we've actually stopped and released the siglock.
1725 * Returns zero if we didn't stop and still hold the siglock.
1727 static int do_signal_stop(int signr
)
1729 struct signal_struct
*sig
= current
->signal
;
1732 if (!sig
->group_stop_count
) {
1733 struct task_struct
*t
;
1735 if (!likely(sig
->flags
& SIGNAL_STOP_DEQUEUED
) ||
1736 unlikely(signal_group_exit(sig
)))
1739 * There is no group stop already in progress.
1740 * We must initiate one now.
1742 sig
->group_exit_code
= signr
;
1744 sig
->group_stop_count
= 1;
1745 for (t
= next_thread(current
); t
!= current
; t
= next_thread(t
))
1747 * Setting state to TASK_STOPPED for a group
1748 * stop is always done with the siglock held,
1749 * so this check has no races.
1751 if (!(t
->flags
& PF_EXITING
) &&
1752 !task_is_stopped_or_traced(t
)) {
1753 sig
->group_stop_count
++;
1754 signal_wake_up(t
, 0);
1758 * If there are no other threads in the group, or if there is
1759 * a group stop in progress and we are the last to stop, report
1760 * to the parent. When ptraced, every thread reports itself.
1762 notify
= sig
->group_stop_count
== 1 ? CLD_STOPPED
: 0;
1763 notify
= tracehook_notify_jctl(notify
, CLD_STOPPED
);
1765 * tracehook_notify_jctl() can drop and reacquire siglock, so
1766 * we keep ->group_stop_count != 0 before the call. If SIGCONT
1767 * or SIGKILL comes in between ->group_stop_count == 0.
1769 if (sig
->group_stop_count
) {
1770 if (!--sig
->group_stop_count
)
1771 sig
->flags
= SIGNAL_STOP_STOPPED
;
1772 current
->exit_code
= sig
->group_exit_code
;
1773 __set_current_state(TASK_STOPPED
);
1775 spin_unlock_irq(¤t
->sighand
->siglock
);
1778 read_lock(&tasklist_lock
);
1779 do_notify_parent_cldstop(current
, notify
);
1780 read_unlock(&tasklist_lock
);
1783 /* Now we don't run again until woken by SIGCONT or SIGKILL */
1786 tracehook_finish_jctl();
1787 current
->exit_code
= 0;
1792 static int ptrace_signal(int signr
, siginfo_t
*info
,
1793 struct pt_regs
*regs
, void *cookie
)
1795 if (!task_ptrace(current
))
1798 ptrace_signal_deliver(regs
, cookie
);
1800 /* Let the debugger run. */
1801 ptrace_stop(signr
, 0, info
);
1803 /* We're back. Did the debugger cancel the sig? */
1804 signr
= current
->exit_code
;
1808 current
->exit_code
= 0;
1810 /* Update the siginfo structure if the signal has
1811 changed. If the debugger wanted something
1812 specific in the siginfo structure then it should
1813 have updated *info via PTRACE_SETSIGINFO. */
1814 if (signr
!= info
->si_signo
) {
1815 info
->si_signo
= signr
;
1817 info
->si_code
= SI_USER
;
1818 info
->si_pid
= task_pid_vnr(current
->parent
);
1819 info
->si_uid
= task_uid(current
->parent
);
1822 /* If the (new) signal is now blocked, requeue it. */
1823 if (sigismember(¤t
->blocked
, signr
)) {
1824 specific_send_sig_info(signr
, info
, current
);
1831 int get_signal_to_deliver(siginfo_t
*info
, struct k_sigaction
*return_ka
,
1832 struct pt_regs
*regs
, void *cookie
)
1834 struct sighand_struct
*sighand
= current
->sighand
;
1835 struct signal_struct
*signal
= current
->signal
;
1840 * We'll jump back here after any time we were stopped in TASK_STOPPED.
1841 * While in TASK_STOPPED, we were considered "frozen enough".
1842 * Now that we woke up, it's crucial if we're supposed to be
1843 * frozen that we freeze now before running anything substantial.
1847 spin_lock_irq(&sighand
->siglock
);
1849 * Every stopped thread goes here after wakeup. Check to see if
1850 * we should notify the parent, prepare_signal(SIGCONT) encodes
1851 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
1853 if (unlikely(signal
->flags
& SIGNAL_CLD_MASK
)) {
1856 if (signal
->flags
& SIGNAL_CLD_CONTINUED
)
1857 why
= CLD_CONTINUED
;
1861 signal
->flags
&= ~SIGNAL_CLD_MASK
;
1863 why
= tracehook_notify_jctl(why
, CLD_CONTINUED
);
1864 spin_unlock_irq(&sighand
->siglock
);
1867 read_lock(&tasklist_lock
);
1868 do_notify_parent_cldstop(current
->group_leader
, why
);
1869 read_unlock(&tasklist_lock
);
1875 struct k_sigaction
*ka
;
1877 * Tracing can induce an artifical signal and choose sigaction.
1878 * The return value in @signr determines the default action,
1879 * but @info->si_signo is the signal number we will report.
1881 signr
= tracehook_get_signal(current
, regs
, info
, return_ka
);
1882 if (unlikely(signr
< 0))
1884 if (unlikely(signr
!= 0))
1887 if (unlikely(signal
->group_stop_count
> 0) &&
1891 signr
= dequeue_signal(current
, ¤t
->blocked
,
1895 break; /* will return 0 */
1897 if (signr
!= SIGKILL
) {
1898 signr
= ptrace_signal(signr
, info
,
1904 ka
= &sighand
->action
[signr
-1];
1907 /* Trace actually delivered signals. */
1908 trace_signal_deliver(signr
, info
, ka
);
1910 if (ka
->sa
.sa_handler
== SIG_IGN
) /* Do nothing. */
1912 if (ka
->sa
.sa_handler
!= SIG_DFL
) {
1913 /* Run the handler. */
1916 if (ka
->sa
.sa_flags
& SA_ONESHOT
)
1917 ka
->sa
.sa_handler
= SIG_DFL
;
1919 break; /* will return non-zero "signr" value */
1923 * Now we are doing the default action for this signal.
1925 if (sig_kernel_ignore(signr
)) /* Default is nothing. */
1929 * Global init gets no signals it doesn't want.
1930 * Container-init gets no signals it doesn't want from same
1933 * Note that if global/container-init sees a sig_kernel_only()
1934 * signal here, the signal must have been generated internally
1935 * or must have come from an ancestor namespace. In either
1936 * case, the signal cannot be dropped.
1938 if (unlikely(signal
->flags
& SIGNAL_UNKILLABLE
) &&
1939 !sig_kernel_only(signr
))
1942 if (sig_kernel_stop(signr
)) {
1944 * The default action is to stop all threads in
1945 * the thread group. The job control signals
1946 * do nothing in an orphaned pgrp, but SIGSTOP
1947 * always works. Note that siglock needs to be
1948 * dropped during the call to is_orphaned_pgrp()
1949 * because of lock ordering with tasklist_lock.
1950 * This allows an intervening SIGCONT to be posted.
1951 * We need to check for that and bail out if necessary.
1953 if (signr
!= SIGSTOP
) {
1954 spin_unlock_irq(&sighand
->siglock
);
1956 /* signals can be posted during this window */
1958 if (is_current_pgrp_orphaned())
1961 spin_lock_irq(&sighand
->siglock
);
1964 if (likely(do_signal_stop(info
->si_signo
))) {
1965 /* It released the siglock. */
1970 * We didn't actually stop, due to a race
1971 * with SIGCONT or something like that.
1976 spin_unlock_irq(&sighand
->siglock
);
1979 * Anything else is fatal, maybe with a core dump.
1981 current
->flags
|= PF_SIGNALED
;
1983 if (sig_kernel_coredump(signr
)) {
1984 if (print_fatal_signals
)
1985 print_fatal_signal(regs
, info
->si_signo
);
1987 * If it was able to dump core, this kills all
1988 * other threads in the group and synchronizes with
1989 * their demise. If we lost the race with another
1990 * thread getting here, it set group_exit_code
1991 * first and our do_group_exit call below will use
1992 * that value and ignore the one we pass it.
1994 do_coredump(info
->si_signo
, info
->si_signo
, regs
);
1998 * Death signals, no core dump.
2000 do_group_exit(info
->si_signo
);
2003 spin_unlock_irq(&sighand
->siglock
);
2007 void exit_signals(struct task_struct
*tsk
)
2010 struct task_struct
*t
;
2012 if (thread_group_empty(tsk
) || signal_group_exit(tsk
->signal
)) {
2013 tsk
->flags
|= PF_EXITING
;
2017 spin_lock_irq(&tsk
->sighand
->siglock
);
2019 * From now this task is not visible for group-wide signals,
2020 * see wants_signal(), do_signal_stop().
2022 tsk
->flags
|= PF_EXITING
;
2023 if (!signal_pending(tsk
))
2026 /* It could be that __group_complete_signal() choose us to
2027 * notify about group-wide signal. Another thread should be
2028 * woken now to take the signal since we will not.
2030 for (t
= tsk
; (t
= next_thread(t
)) != tsk
; )
2031 if (!signal_pending(t
) && !(t
->flags
& PF_EXITING
))
2032 recalc_sigpending_and_wake(t
);
2034 if (unlikely(tsk
->signal
->group_stop_count
) &&
2035 !--tsk
->signal
->group_stop_count
) {
2036 tsk
->signal
->flags
= SIGNAL_STOP_STOPPED
;
2037 group_stop
= tracehook_notify_jctl(CLD_STOPPED
, CLD_STOPPED
);
2040 spin_unlock_irq(&tsk
->sighand
->siglock
);
2042 if (unlikely(group_stop
)) {
2043 read_lock(&tasklist_lock
);
2044 do_notify_parent_cldstop(tsk
, group_stop
);
2045 read_unlock(&tasklist_lock
);
2049 EXPORT_SYMBOL(recalc_sigpending
);
2050 EXPORT_SYMBOL_GPL(dequeue_signal
);
2051 EXPORT_SYMBOL(flush_signals
);
2052 EXPORT_SYMBOL(force_sig
);
2053 EXPORT_SYMBOL(send_sig
);
2054 EXPORT_SYMBOL(send_sig_info
);
2055 EXPORT_SYMBOL(sigprocmask
);
2056 EXPORT_SYMBOL(block_all_signals
);
2057 EXPORT_SYMBOL(unblock_all_signals
);
2061 * System call entry points.
2064 SYSCALL_DEFINE0(restart_syscall
)
2066 struct restart_block
*restart
= ¤t_thread_info()->restart_block
;
2067 return restart
->fn(restart
);
2070 long do_no_restart_syscall(struct restart_block
*param
)
2076 * We don't need to get the kernel lock - this is all local to this
2077 * particular thread.. (and that's good, because this is _heavily_
2078 * used by various programs)
2082 * This is also useful for kernel threads that want to temporarily
2083 * (or permanently) block certain signals.
2085 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2086 * interface happily blocks "unblockable" signals like SIGKILL
2089 int sigprocmask(int how
, sigset_t
*set
, sigset_t
*oldset
)
2093 spin_lock_irq(¤t
->sighand
->siglock
);
2095 *oldset
= current
->blocked
;
2100 sigorsets(¤t
->blocked
, ¤t
->blocked
, set
);
2103 signandsets(¤t
->blocked
, ¤t
->blocked
, set
);
2106 current
->blocked
= *set
;
2111 recalc_sigpending();
2112 spin_unlock_irq(¤t
->sighand
->siglock
);
2117 SYSCALL_DEFINE4(rt_sigprocmask
, int, how
, sigset_t __user
*, set
,
2118 sigset_t __user
*, oset
, size_t, sigsetsize
)
2120 int error
= -EINVAL
;
2121 sigset_t old_set
, new_set
;
2123 /* XXX: Don't preclude handling different sized sigset_t's. */
2124 if (sigsetsize
!= sizeof(sigset_t
))
2129 if (copy_from_user(&new_set
, set
, sizeof(*set
)))
2131 sigdelsetmask(&new_set
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
2133 error
= sigprocmask(how
, &new_set
, &old_set
);
2139 spin_lock_irq(¤t
->sighand
->siglock
);
2140 old_set
= current
->blocked
;
2141 spin_unlock_irq(¤t
->sighand
->siglock
);
2145 if (copy_to_user(oset
, &old_set
, sizeof(*oset
)))
2153 long do_sigpending(void __user
*set
, unsigned long sigsetsize
)
2155 long error
= -EINVAL
;
2158 if (sigsetsize
> sizeof(sigset_t
))
2161 spin_lock_irq(¤t
->sighand
->siglock
);
2162 sigorsets(&pending
, ¤t
->pending
.signal
,
2163 ¤t
->signal
->shared_pending
.signal
);
2164 spin_unlock_irq(¤t
->sighand
->siglock
);
2166 /* Outside the lock because only this thread touches it. */
2167 sigandsets(&pending
, ¤t
->blocked
, &pending
);
2170 if (!copy_to_user(set
, &pending
, sigsetsize
))
2177 SYSCALL_DEFINE2(rt_sigpending
, sigset_t __user
*, set
, size_t, sigsetsize
)
2179 return do_sigpending(set
, sigsetsize
);
2182 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2184 int copy_siginfo_to_user(siginfo_t __user
*to
, siginfo_t
*from
)
2188 if (!access_ok (VERIFY_WRITE
, to
, sizeof(siginfo_t
)))
2190 if (from
->si_code
< 0)
2191 return __copy_to_user(to
, from
, sizeof(siginfo_t
))
2194 * If you change siginfo_t structure, please be sure
2195 * this code is fixed accordingly.
2196 * Please remember to update the signalfd_copyinfo() function
2197 * inside fs/signalfd.c too, in case siginfo_t changes.
2198 * It should never copy any pad contained in the structure
2199 * to avoid security leaks, but must copy the generic
2200 * 3 ints plus the relevant union member.
2202 err
= __put_user(from
->si_signo
, &to
->si_signo
);
2203 err
|= __put_user(from
->si_errno
, &to
->si_errno
);
2204 err
|= __put_user((short)from
->si_code
, &to
->si_code
);
2205 switch (from
->si_code
& __SI_MASK
) {
2207 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2208 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2211 err
|= __put_user(from
->si_tid
, &to
->si_tid
);
2212 err
|= __put_user(from
->si_overrun
, &to
->si_overrun
);
2213 err
|= __put_user(from
->si_ptr
, &to
->si_ptr
);
2216 err
|= __put_user(from
->si_band
, &to
->si_band
);
2217 err
|= __put_user(from
->si_fd
, &to
->si_fd
);
2220 err
|= __put_user(from
->si_addr
, &to
->si_addr
);
2221 #ifdef __ARCH_SI_TRAPNO
2222 err
|= __put_user(from
->si_trapno
, &to
->si_trapno
);
2224 #ifdef BUS_MCEERR_AO
2226 * Other callers might not initialize the si_lsb field,
2227 * so check explicitely for the right codes here.
2229 if (from
->si_code
== BUS_MCEERR_AR
|| from
->si_code
== BUS_MCEERR_AO
)
2230 err
|= __put_user(from
->si_addr_lsb
, &to
->si_addr_lsb
);
2234 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2235 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2236 err
|= __put_user(from
->si_status
, &to
->si_status
);
2237 err
|= __put_user(from
->si_utime
, &to
->si_utime
);
2238 err
|= __put_user(from
->si_stime
, &to
->si_stime
);
2240 case __SI_RT
: /* This is not generated by the kernel as of now. */
2241 case __SI_MESGQ
: /* But this is */
2242 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2243 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2244 err
|= __put_user(from
->si_ptr
, &to
->si_ptr
);
2246 default: /* this is just in case for now ... */
2247 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2248 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2256 SYSCALL_DEFINE4(rt_sigtimedwait
, const sigset_t __user
*, uthese
,
2257 siginfo_t __user
*, uinfo
, const struct timespec __user
*, uts
,
2266 /* XXX: Don't preclude handling different sized sigset_t's. */
2267 if (sigsetsize
!= sizeof(sigset_t
))
2270 if (copy_from_user(&these
, uthese
, sizeof(these
)))
2274 * Invert the set of allowed signals to get those we
2277 sigdelsetmask(&these
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
2281 if (copy_from_user(&ts
, uts
, sizeof(ts
)))
2283 if (ts
.tv_nsec
>= 1000000000L || ts
.tv_nsec
< 0
2288 spin_lock_irq(¤t
->sighand
->siglock
);
2289 sig
= dequeue_signal(current
, &these
, &info
);
2291 timeout
= MAX_SCHEDULE_TIMEOUT
;
2293 timeout
= (timespec_to_jiffies(&ts
)
2294 + (ts
.tv_sec
|| ts
.tv_nsec
));
2297 /* None ready -- temporarily unblock those we're
2298 * interested while we are sleeping in so that we'll
2299 * be awakened when they arrive. */
2300 current
->real_blocked
= current
->blocked
;
2301 sigandsets(¤t
->blocked
, ¤t
->blocked
, &these
);
2302 recalc_sigpending();
2303 spin_unlock_irq(¤t
->sighand
->siglock
);
2305 timeout
= schedule_timeout_interruptible(timeout
);
2307 spin_lock_irq(¤t
->sighand
->siglock
);
2308 sig
= dequeue_signal(current
, &these
, &info
);
2309 current
->blocked
= current
->real_blocked
;
2310 siginitset(¤t
->real_blocked
, 0);
2311 recalc_sigpending();
2314 spin_unlock_irq(¤t
->sighand
->siglock
);
2319 if (copy_siginfo_to_user(uinfo
, &info
))
2331 SYSCALL_DEFINE2(kill
, pid_t
, pid
, int, sig
)
2333 struct siginfo info
;
2335 info
.si_signo
= sig
;
2337 info
.si_code
= SI_USER
;
2338 info
.si_pid
= task_tgid_vnr(current
);
2339 info
.si_uid
= current_uid();
2341 return kill_something_info(sig
, &info
, pid
);
2345 do_send_specific(pid_t tgid
, pid_t pid
, int sig
, struct siginfo
*info
)
2347 struct task_struct
*p
;
2351 p
= find_task_by_vpid(pid
);
2352 if (p
&& (tgid
<= 0 || task_tgid_vnr(p
) == tgid
)) {
2353 error
= check_kill_permission(sig
, info
, p
);
2355 * The null signal is a permissions and process existence
2356 * probe. No signal is actually delivered.
2358 if (!error
&& sig
) {
2359 error
= do_send_sig_info(sig
, info
, p
, false);
2361 * If lock_task_sighand() failed we pretend the task
2362 * dies after receiving the signal. The window is tiny,
2363 * and the signal is private anyway.
2365 if (unlikely(error
== -ESRCH
))
2374 static int do_tkill(pid_t tgid
, pid_t pid
, int sig
)
2376 struct siginfo info
;
2378 info
.si_signo
= sig
;
2380 info
.si_code
= SI_TKILL
;
2381 info
.si_pid
= task_tgid_vnr(current
);
2382 info
.si_uid
= current_uid();
2384 return do_send_specific(tgid
, pid
, sig
, &info
);
2388 * sys_tgkill - send signal to one specific thread
2389 * @tgid: the thread group ID of the thread
2390 * @pid: the PID of the thread
2391 * @sig: signal to be sent
2393 * This syscall also checks the @tgid and returns -ESRCH even if the PID
2394 * exists but it's not belonging to the target process anymore. This
2395 * method solves the problem of threads exiting and PIDs getting reused.
2397 SYSCALL_DEFINE3(tgkill
, pid_t
, tgid
, pid_t
, pid
, int, sig
)
2399 /* This is only valid for single tasks */
2400 if (pid
<= 0 || tgid
<= 0)
2403 return do_tkill(tgid
, pid
, sig
);
2407 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2409 SYSCALL_DEFINE2(tkill
, pid_t
, pid
, int, sig
)
2411 /* This is only valid for single tasks */
2415 return do_tkill(0, pid
, sig
);
2418 SYSCALL_DEFINE3(rt_sigqueueinfo
, pid_t
, pid
, int, sig
,
2419 siginfo_t __user
*, uinfo
)
2423 if (copy_from_user(&info
, uinfo
, sizeof(siginfo_t
)))
2426 /* Not even root can pretend to send signals from the kernel.
2427 * Nor can they impersonate a kill()/tgkill(), which adds source info.
2429 if (info
.si_code
!= SI_QUEUE
) {
2430 /* We used to allow any < 0 si_code */
2431 WARN_ON_ONCE(info
.si_code
< 0);
2434 info
.si_signo
= sig
;
2436 /* POSIX.1b doesn't mention process groups. */
2437 return kill_proc_info(sig
, &info
, pid
);
2440 long do_rt_tgsigqueueinfo(pid_t tgid
, pid_t pid
, int sig
, siginfo_t
*info
)
2442 /* This is only valid for single tasks */
2443 if (pid
<= 0 || tgid
<= 0)
2446 /* Not even root can pretend to send signals from the kernel.
2447 * Nor can they impersonate a kill()/tgkill(), which adds source info.
2449 if (info
->si_code
!= SI_QUEUE
) {
2450 /* We used to allow any < 0 si_code */
2451 WARN_ON_ONCE(info
->si_code
< 0);
2454 info
->si_signo
= sig
;
2456 return do_send_specific(tgid
, pid
, sig
, info
);
2459 SYSCALL_DEFINE4(rt_tgsigqueueinfo
, pid_t
, tgid
, pid_t
, pid
, int, sig
,
2460 siginfo_t __user
*, uinfo
)
2464 if (copy_from_user(&info
, uinfo
, sizeof(siginfo_t
)))
2467 return do_rt_tgsigqueueinfo(tgid
, pid
, sig
, &info
);
2470 int do_sigaction(int sig
, struct k_sigaction
*act
, struct k_sigaction
*oact
)
2472 struct task_struct
*t
= current
;
2473 struct k_sigaction
*k
;
2476 if (!valid_signal(sig
) || sig
< 1 || (act
&& sig_kernel_only(sig
)))
2479 k
= &t
->sighand
->action
[sig
-1];
2481 spin_lock_irq(¤t
->sighand
->siglock
);
2486 sigdelsetmask(&act
->sa
.sa_mask
,
2487 sigmask(SIGKILL
) | sigmask(SIGSTOP
));
2491 * "Setting a signal action to SIG_IGN for a signal that is
2492 * pending shall cause the pending signal to be discarded,
2493 * whether or not it is blocked."
2495 * "Setting a signal action to SIG_DFL for a signal that is
2496 * pending and whose default action is to ignore the signal
2497 * (for example, SIGCHLD), shall cause the pending signal to
2498 * be discarded, whether or not it is blocked"
2500 if (sig_handler_ignored(sig_handler(t
, sig
), sig
)) {
2502 sigaddset(&mask
, sig
);
2503 rm_from_queue_full(&mask
, &t
->signal
->shared_pending
);
2505 rm_from_queue_full(&mask
, &t
->pending
);
2507 } while (t
!= current
);
2511 spin_unlock_irq(¤t
->sighand
->siglock
);
2516 do_sigaltstack (const stack_t __user
*uss
, stack_t __user
*uoss
, unsigned long sp
)
2521 oss
.ss_sp
= (void __user
*) current
->sas_ss_sp
;
2522 oss
.ss_size
= current
->sas_ss_size
;
2523 oss
.ss_flags
= sas_ss_flags(sp
);
2531 if (!access_ok(VERIFY_READ
, uss
, sizeof(*uss
)))
2533 error
= __get_user(ss_sp
, &uss
->ss_sp
) |
2534 __get_user(ss_flags
, &uss
->ss_flags
) |
2535 __get_user(ss_size
, &uss
->ss_size
);
2540 if (on_sig_stack(sp
))
2546 * Note - this code used to test ss_flags incorrectly
2547 * old code may have been written using ss_flags==0
2548 * to mean ss_flags==SS_ONSTACK (as this was the only
2549 * way that worked) - this fix preserves that older
2552 if (ss_flags
!= SS_DISABLE
&& ss_flags
!= SS_ONSTACK
&& ss_flags
!= 0)
2555 if (ss_flags
== SS_DISABLE
) {
2560 if (ss_size
< MINSIGSTKSZ
)
2564 current
->sas_ss_sp
= (unsigned long) ss_sp
;
2565 current
->sas_ss_size
= ss_size
;
2571 if (!access_ok(VERIFY_WRITE
, uoss
, sizeof(*uoss
)))
2573 error
= __put_user(oss
.ss_sp
, &uoss
->ss_sp
) |
2574 __put_user(oss
.ss_size
, &uoss
->ss_size
) |
2575 __put_user(oss
.ss_flags
, &uoss
->ss_flags
);
2582 #ifdef __ARCH_WANT_SYS_SIGPENDING
2584 SYSCALL_DEFINE1(sigpending
, old_sigset_t __user
*, set
)
2586 return do_sigpending(set
, sizeof(*set
));
2591 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2592 /* Some platforms have their own version with special arguments others
2593 support only sys_rt_sigprocmask. */
2595 SYSCALL_DEFINE3(sigprocmask
, int, how
, old_sigset_t __user
*, set
,
2596 old_sigset_t __user
*, oset
)
2599 old_sigset_t old_set
, new_set
;
2603 if (copy_from_user(&new_set
, set
, sizeof(*set
)))
2605 new_set
&= ~(sigmask(SIGKILL
) | sigmask(SIGSTOP
));
2607 spin_lock_irq(¤t
->sighand
->siglock
);
2608 old_set
= current
->blocked
.sig
[0];
2616 sigaddsetmask(¤t
->blocked
, new_set
);
2619 sigdelsetmask(¤t
->blocked
, new_set
);
2622 current
->blocked
.sig
[0] = new_set
;
2626 recalc_sigpending();
2627 spin_unlock_irq(¤t
->sighand
->siglock
);
2633 old_set
= current
->blocked
.sig
[0];
2636 if (copy_to_user(oset
, &old_set
, sizeof(*oset
)))
2643 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2645 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2646 SYSCALL_DEFINE4(rt_sigaction
, int, sig
,
2647 const struct sigaction __user
*, act
,
2648 struct sigaction __user
*, oact
,
2651 struct k_sigaction new_sa
, old_sa
;
2654 /* XXX: Don't preclude handling different sized sigset_t's. */
2655 if (sigsetsize
!= sizeof(sigset_t
))
2659 if (copy_from_user(&new_sa
.sa
, act
, sizeof(new_sa
.sa
)))
2663 ret
= do_sigaction(sig
, act
? &new_sa
: NULL
, oact
? &old_sa
: NULL
);
2666 if (copy_to_user(oact
, &old_sa
.sa
, sizeof(old_sa
.sa
)))
2672 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2674 #ifdef __ARCH_WANT_SYS_SGETMASK
2677 * For backwards compatibility. Functionality superseded by sigprocmask.
2679 SYSCALL_DEFINE0(sgetmask
)
2682 return current
->blocked
.sig
[0];
2685 SYSCALL_DEFINE1(ssetmask
, int, newmask
)
2689 spin_lock_irq(¤t
->sighand
->siglock
);
2690 old
= current
->blocked
.sig
[0];
2692 siginitset(¤t
->blocked
, newmask
& ~(sigmask(SIGKILL
)|
2694 recalc_sigpending();
2695 spin_unlock_irq(¤t
->sighand
->siglock
);
2699 #endif /* __ARCH_WANT_SGETMASK */
2701 #ifdef __ARCH_WANT_SYS_SIGNAL
2703 * For backwards compatibility. Functionality superseded by sigaction.
2705 SYSCALL_DEFINE2(signal
, int, sig
, __sighandler_t
, handler
)
2707 struct k_sigaction new_sa
, old_sa
;
2710 new_sa
.sa
.sa_handler
= handler
;
2711 new_sa
.sa
.sa_flags
= SA_ONESHOT
| SA_NOMASK
;
2712 sigemptyset(&new_sa
.sa
.sa_mask
);
2714 ret
= do_sigaction(sig
, &new_sa
, &old_sa
);
2716 return ret
? ret
: (unsigned long)old_sa
.sa
.sa_handler
;
2718 #endif /* __ARCH_WANT_SYS_SIGNAL */
2720 #ifdef __ARCH_WANT_SYS_PAUSE
2722 SYSCALL_DEFINE0(pause
)
2724 current
->state
= TASK_INTERRUPTIBLE
;
2726 return -ERESTARTNOHAND
;
2731 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2732 SYSCALL_DEFINE2(rt_sigsuspend
, sigset_t __user
*, unewset
, size_t, sigsetsize
)
2736 /* XXX: Don't preclude handling different sized sigset_t's. */
2737 if (sigsetsize
!= sizeof(sigset_t
))
2740 if (copy_from_user(&newset
, unewset
, sizeof(newset
)))
2742 sigdelsetmask(&newset
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
2744 spin_lock_irq(¤t
->sighand
->siglock
);
2745 current
->saved_sigmask
= current
->blocked
;
2746 current
->blocked
= newset
;
2747 recalc_sigpending();
2748 spin_unlock_irq(¤t
->sighand
->siglock
);
2750 current
->state
= TASK_INTERRUPTIBLE
;
2752 set_restore_sigmask();
2753 return -ERESTARTNOHAND
;
2755 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2757 __attribute__((weak
)) const char *arch_vma_name(struct vm_area_struct
*vma
)
2762 void __init
signals_init(void)
2764 sigqueue_cachep
= KMEM_CACHE(sigqueue
, SLAB_PANIC
);
2767 #ifdef CONFIG_KGDB_KDB
2768 #include <linux/kdb.h>
2770 * kdb_send_sig_info - Allows kdb to send signals without exposing
2771 * signal internals. This function checks if the required locks are
2772 * available before calling the main signal code, to avoid kdb
2776 kdb_send_sig_info(struct task_struct
*t
, struct siginfo
*info
)
2778 static struct task_struct
*kdb_prev_t
;
2780 if (!spin_trylock(&t
->sighand
->siglock
)) {
2781 kdb_printf("Can't do kill command now.\n"
2782 "The sigmask lock is held somewhere else in "
2783 "kernel, try again later\n");
2786 spin_unlock(&t
->sighand
->siglock
);
2787 new_t
= kdb_prev_t
!= t
;
2789 if (t
->state
!= TASK_RUNNING
&& new_t
) {
2790 kdb_printf("Process is not RUNNING, sending a signal from "
2791 "kdb risks deadlock\n"
2792 "on the run queue locks. "
2793 "The signal has _not_ been sent.\n"
2794 "Reissue the kill command if you want to risk "
2798 sig
= info
->si_signo
;
2799 if (send_sig_info(sig
, info
, t
))
2800 kdb_printf("Fail to deliver Signal %d to process %d.\n",
2803 kdb_printf("Signal %d is sent to process %d.\n", sig
, t
->pid
);
2805 #endif /* CONFIG_KGDB_KDB */