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 int next_signal(struct sigpending
*pending
, sigset_t
*mask
)
164 unsigned long i
, *s
, *m
, x
;
167 s
= pending
->signal
.sig
;
169 switch (_NSIG_WORDS
) {
171 for (i
= 0; i
< _NSIG_WORDS
; ++i
, ++s
, ++m
)
172 if ((x
= *s
&~ *m
) != 0) {
173 sig
= ffz(~x
) + i
*_NSIG_BPW
+ 1;
178 case 2: if ((x
= s
[0] &~ m
[0]) != 0)
180 else if ((x
= s
[1] &~ m
[1]) != 0)
187 case 1: if ((x
= *s
&~ *m
) != 0)
195 static inline void print_dropped_signal(int sig
)
197 static DEFINE_RATELIMIT_STATE(ratelimit_state
, 5 * HZ
, 10);
199 if (!print_fatal_signals
)
202 if (!__ratelimit(&ratelimit_state
))
205 printk(KERN_INFO
"%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
206 current
->comm
, current
->pid
, sig
);
210 * allocate a new signal queue record
211 * - this may be called without locks if and only if t == current, otherwise an
212 * appopriate lock must be held to stop the target task from exiting
214 static struct sigqueue
*
215 __sigqueue_alloc(int sig
, struct task_struct
*t
, gfp_t flags
, int override_rlimit
)
217 struct sigqueue
*q
= NULL
;
218 struct user_struct
*user
;
221 * We won't get problems with the target's UID changing under us
222 * because changing it requires RCU be used, and if t != current, the
223 * caller must be holding the RCU readlock (by way of a spinlock) and
224 * we use RCU protection here
226 user
= get_uid(__task_cred(t
)->user
);
227 atomic_inc(&user
->sigpending
);
229 if (override_rlimit
||
230 atomic_read(&user
->sigpending
) <=
231 t
->signal
->rlim
[RLIMIT_SIGPENDING
].rlim_cur
) {
232 q
= kmem_cache_alloc(sigqueue_cachep
, flags
);
234 print_dropped_signal(sig
);
237 if (unlikely(q
== NULL
)) {
238 atomic_dec(&user
->sigpending
);
241 INIT_LIST_HEAD(&q
->list
);
249 static void __sigqueue_free(struct sigqueue
*q
)
251 if (q
->flags
& SIGQUEUE_PREALLOC
)
253 atomic_dec(&q
->user
->sigpending
);
255 kmem_cache_free(sigqueue_cachep
, q
);
258 void flush_sigqueue(struct sigpending
*queue
)
262 sigemptyset(&queue
->signal
);
263 while (!list_empty(&queue
->list
)) {
264 q
= list_entry(queue
->list
.next
, struct sigqueue
, list
);
265 list_del_init(&q
->list
);
271 * Flush all pending signals for a task.
273 void __flush_signals(struct task_struct
*t
)
275 clear_tsk_thread_flag(t
, TIF_SIGPENDING
);
276 flush_sigqueue(&t
->pending
);
277 flush_sigqueue(&t
->signal
->shared_pending
);
280 void flush_signals(struct task_struct
*t
)
284 spin_lock_irqsave(&t
->sighand
->siglock
, flags
);
286 spin_unlock_irqrestore(&t
->sighand
->siglock
, flags
);
289 static void __flush_itimer_signals(struct sigpending
*pending
)
291 sigset_t signal
, retain
;
292 struct sigqueue
*q
, *n
;
294 signal
= pending
->signal
;
295 sigemptyset(&retain
);
297 list_for_each_entry_safe(q
, n
, &pending
->list
, list
) {
298 int sig
= q
->info
.si_signo
;
300 if (likely(q
->info
.si_code
!= SI_TIMER
)) {
301 sigaddset(&retain
, sig
);
303 sigdelset(&signal
, sig
);
304 list_del_init(&q
->list
);
309 sigorsets(&pending
->signal
, &signal
, &retain
);
312 void flush_itimer_signals(void)
314 struct task_struct
*tsk
= current
;
317 spin_lock_irqsave(&tsk
->sighand
->siglock
, flags
);
318 __flush_itimer_signals(&tsk
->pending
);
319 __flush_itimer_signals(&tsk
->signal
->shared_pending
);
320 spin_unlock_irqrestore(&tsk
->sighand
->siglock
, flags
);
323 void ignore_signals(struct task_struct
*t
)
327 for (i
= 0; i
< _NSIG
; ++i
)
328 t
->sighand
->action
[i
].sa
.sa_handler
= SIG_IGN
;
334 * Flush all handlers for a task.
338 flush_signal_handlers(struct task_struct
*t
, int force_default
)
341 struct k_sigaction
*ka
= &t
->sighand
->action
[0];
342 for (i
= _NSIG
; i
!= 0 ; i
--) {
343 if (force_default
|| ka
->sa
.sa_handler
!= SIG_IGN
)
344 ka
->sa
.sa_handler
= SIG_DFL
;
346 sigemptyset(&ka
->sa
.sa_mask
);
351 int unhandled_signal(struct task_struct
*tsk
, int sig
)
353 void __user
*handler
= tsk
->sighand
->action
[sig
-1].sa
.sa_handler
;
354 if (is_global_init(tsk
))
356 if (handler
!= SIG_IGN
&& handler
!= SIG_DFL
)
358 return !tracehook_consider_fatal_signal(tsk
, sig
);
362 /* Notify the system that a driver wants to block all signals for this
363 * process, and wants to be notified if any signals at all were to be
364 * sent/acted upon. If the notifier routine returns non-zero, then the
365 * signal will be acted upon after all. If the notifier routine returns 0,
366 * then then signal will be blocked. Only one block per process is
367 * allowed. priv is a pointer to private data that the notifier routine
368 * can use to determine if the signal should be blocked or not. */
371 block_all_signals(int (*notifier
)(void *priv
), void *priv
, sigset_t
*mask
)
375 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
376 current
->notifier_mask
= mask
;
377 current
->notifier_data
= priv
;
378 current
->notifier
= notifier
;
379 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
382 /* Notify the system that blocking has ended. */
385 unblock_all_signals(void)
389 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
390 current
->notifier
= NULL
;
391 current
->notifier_data
= NULL
;
393 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
396 static void collect_signal(int sig
, struct sigpending
*list
, siginfo_t
*info
)
398 struct sigqueue
*q
, *first
= NULL
;
401 * Collect the siginfo appropriate to this signal. Check if
402 * there is another siginfo for the same signal.
404 list_for_each_entry(q
, &list
->list
, list
) {
405 if (q
->info
.si_signo
== sig
) {
412 sigdelset(&list
->signal
, sig
);
416 list_del_init(&first
->list
);
417 copy_siginfo(info
, &first
->info
);
418 __sigqueue_free(first
);
420 /* Ok, it wasn't in the queue. This must be
421 a fast-pathed signal or we must have been
422 out of queue space. So zero out the info.
424 info
->si_signo
= sig
;
426 info
->si_code
= SI_USER
;
432 static int __dequeue_signal(struct sigpending
*pending
, sigset_t
*mask
,
435 int sig
= next_signal(pending
, mask
);
438 if (current
->notifier
) {
439 if (sigismember(current
->notifier_mask
, sig
)) {
440 if (!(current
->notifier
)(current
->notifier_data
)) {
441 clear_thread_flag(TIF_SIGPENDING
);
447 collect_signal(sig
, pending
, info
);
454 * Dequeue a signal and return the element to the caller, which is
455 * expected to free it.
457 * All callers have to hold the siglock.
459 int dequeue_signal(struct task_struct
*tsk
, sigset_t
*mask
, siginfo_t
*info
)
463 /* We only dequeue private signals from ourselves, we don't let
464 * signalfd steal them
466 signr
= __dequeue_signal(&tsk
->pending
, mask
, info
);
468 signr
= __dequeue_signal(&tsk
->signal
->shared_pending
,
473 * itimers are process shared and we restart periodic
474 * itimers in the signal delivery path to prevent DoS
475 * attacks in the high resolution timer case. This is
476 * compliant with the old way of self restarting
477 * itimers, as the SIGALRM is a legacy signal and only
478 * queued once. Changing the restart behaviour to
479 * restart the timer in the signal dequeue path is
480 * reducing the timer noise on heavy loaded !highres
483 if (unlikely(signr
== SIGALRM
)) {
484 struct hrtimer
*tmr
= &tsk
->signal
->real_timer
;
486 if (!hrtimer_is_queued(tmr
) &&
487 tsk
->signal
->it_real_incr
.tv64
!= 0) {
488 hrtimer_forward(tmr
, tmr
->base
->get_time(),
489 tsk
->signal
->it_real_incr
);
490 hrtimer_restart(tmr
);
499 if (unlikely(sig_kernel_stop(signr
))) {
501 * Set a marker that we have dequeued a stop signal. Our
502 * caller might release the siglock and then the pending
503 * stop signal it is about to process is no longer in the
504 * pending bitmasks, but must still be cleared by a SIGCONT
505 * (and overruled by a SIGKILL). So those cases clear this
506 * shared flag after we've set it. Note that this flag may
507 * remain set after the signal we return is ignored or
508 * handled. That doesn't matter because its only purpose
509 * is to alert stop-signal processing code when another
510 * processor has come along and cleared the flag.
512 tsk
->signal
->flags
|= SIGNAL_STOP_DEQUEUED
;
514 if ((info
->si_code
& __SI_MASK
) == __SI_TIMER
&& info
->si_sys_private
) {
516 * Release the siglock to ensure proper locking order
517 * of timer locks outside of siglocks. Note, we leave
518 * irqs disabled here, since the posix-timers code is
519 * about to disable them again anyway.
521 spin_unlock(&tsk
->sighand
->siglock
);
522 do_schedule_next_timer(info
);
523 spin_lock(&tsk
->sighand
->siglock
);
529 * Tell a process that it has a new active signal..
531 * NOTE! we rely on the previous spin_lock to
532 * lock interrupts for us! We can only be called with
533 * "siglock" held, and the local interrupt must
534 * have been disabled when that got acquired!
536 * No need to set need_resched since signal event passing
537 * goes through ->blocked
539 void signal_wake_up(struct task_struct
*t
, int resume
)
543 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
546 * For SIGKILL, we want to wake it up in the stopped/traced/killable
547 * case. We don't check t->state here because there is a race with it
548 * executing another processor and just now entering stopped state.
549 * By using wake_up_state, we ensure the process will wake up and
550 * handle its death signal.
552 mask
= TASK_INTERRUPTIBLE
;
554 mask
|= TASK_WAKEKILL
;
555 if (!wake_up_state(t
, mask
))
560 * Remove signals in mask from the pending set and queue.
561 * Returns 1 if any signals were found.
563 * All callers must be holding the siglock.
565 * This version takes a sigset mask and looks at all signals,
566 * not just those in the first mask word.
568 static int rm_from_queue_full(sigset_t
*mask
, struct sigpending
*s
)
570 struct sigqueue
*q
, *n
;
573 sigandsets(&m
, mask
, &s
->signal
);
574 if (sigisemptyset(&m
))
577 signandsets(&s
->signal
, &s
->signal
, mask
);
578 list_for_each_entry_safe(q
, n
, &s
->list
, list
) {
579 if (sigismember(mask
, q
->info
.si_signo
)) {
580 list_del_init(&q
->list
);
587 * Remove signals in mask from the pending set and queue.
588 * Returns 1 if any signals were found.
590 * All callers must be holding the siglock.
592 static int rm_from_queue(unsigned long mask
, struct sigpending
*s
)
594 struct sigqueue
*q
, *n
;
596 if (!sigtestsetmask(&s
->signal
, mask
))
599 sigdelsetmask(&s
->signal
, mask
);
600 list_for_each_entry_safe(q
, n
, &s
->list
, list
) {
601 if (q
->info
.si_signo
< SIGRTMIN
&&
602 (mask
& sigmask(q
->info
.si_signo
))) {
603 list_del_init(&q
->list
);
610 static inline int is_si_special(const struct siginfo
*info
)
612 return info
<= SEND_SIG_FORCED
;
615 static inline bool si_fromuser(const struct siginfo
*info
)
617 return info
== SEND_SIG_NOINFO
||
618 (!is_si_special(info
) && SI_FROMUSER(info
));
622 * Bad permissions for sending the signal
623 * - the caller must hold at least the RCU read lock
625 static int check_kill_permission(int sig
, struct siginfo
*info
,
626 struct task_struct
*t
)
628 const struct cred
*cred
= current_cred(), *tcred
;
632 if (!valid_signal(sig
))
635 if (!si_fromuser(info
))
638 error
= audit_signal_info(sig
, t
); /* Let audit system see the signal */
642 tcred
= __task_cred(t
);
643 if ((cred
->euid
^ tcred
->suid
) &&
644 (cred
->euid
^ tcred
->uid
) &&
645 (cred
->uid
^ tcred
->suid
) &&
646 (cred
->uid
^ tcred
->uid
) &&
647 !capable(CAP_KILL
)) {
650 sid
= task_session(t
);
652 * We don't return the error if sid == NULL. The
653 * task was unhashed, the caller must notice this.
655 if (!sid
|| sid
== task_session(current
))
662 return security_task_kill(t
, info
, sig
, 0);
666 * Handle magic process-wide effects of stop/continue signals. Unlike
667 * the signal actions, these happen immediately at signal-generation
668 * time regardless of blocking, ignoring, or handling. This does the
669 * actual continuing for SIGCONT, but not the actual stopping for stop
670 * signals. The process stop is done as a signal action for SIG_DFL.
672 * Returns true if the signal should be actually delivered, otherwise
673 * it should be dropped.
675 static int prepare_signal(int sig
, struct task_struct
*p
, int from_ancestor_ns
)
677 struct signal_struct
*signal
= p
->signal
;
678 struct task_struct
*t
;
680 if (unlikely(signal
->flags
& SIGNAL_GROUP_EXIT
)) {
682 * The process is in the middle of dying, nothing to do.
684 } else if (sig_kernel_stop(sig
)) {
686 * This is a stop signal. Remove SIGCONT from all queues.
688 rm_from_queue(sigmask(SIGCONT
), &signal
->shared_pending
);
691 rm_from_queue(sigmask(SIGCONT
), &t
->pending
);
692 } while_each_thread(p
, t
);
693 } else if (sig
== SIGCONT
) {
696 * Remove all stop signals from all queues,
697 * and wake all threads.
699 rm_from_queue(SIG_KERNEL_STOP_MASK
, &signal
->shared_pending
);
703 rm_from_queue(SIG_KERNEL_STOP_MASK
, &t
->pending
);
705 * If there is a handler for SIGCONT, we must make
706 * sure that no thread returns to user mode before
707 * we post the signal, in case it was the only
708 * thread eligible to run the signal handler--then
709 * it must not do anything between resuming and
710 * running the handler. With the TIF_SIGPENDING
711 * flag set, the thread will pause and acquire the
712 * siglock that we hold now and until we've queued
713 * the pending signal.
715 * Wake up the stopped thread _after_ setting
718 state
= __TASK_STOPPED
;
719 if (sig_user_defined(t
, SIGCONT
) && !sigismember(&t
->blocked
, SIGCONT
)) {
720 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
721 state
|= TASK_INTERRUPTIBLE
;
723 wake_up_state(t
, state
);
724 } while_each_thread(p
, t
);
727 * Notify the parent with CLD_CONTINUED if we were stopped.
729 * If we were in the middle of a group stop, we pretend it
730 * was already finished, and then continued. Since SIGCHLD
731 * doesn't queue we report only CLD_STOPPED, as if the next
732 * CLD_CONTINUED was dropped.
735 if (signal
->flags
& SIGNAL_STOP_STOPPED
)
736 why
|= SIGNAL_CLD_CONTINUED
;
737 else if (signal
->group_stop_count
)
738 why
|= SIGNAL_CLD_STOPPED
;
742 * The first thread which returns from do_signal_stop()
743 * will take ->siglock, notice SIGNAL_CLD_MASK, and
744 * notify its parent. See get_signal_to_deliver().
746 signal
->flags
= why
| SIGNAL_STOP_CONTINUED
;
747 signal
->group_stop_count
= 0;
748 signal
->group_exit_code
= 0;
751 * We are not stopped, but there could be a stop
752 * signal in the middle of being processed after
753 * being removed from the queue. Clear that too.
755 signal
->flags
&= ~SIGNAL_STOP_DEQUEUED
;
759 return !sig_ignored(p
, sig
, from_ancestor_ns
);
763 * Test if P wants to take SIG. After we've checked all threads with this,
764 * it's equivalent to finding no threads not blocking SIG. Any threads not
765 * blocking SIG were ruled out because they are not running and already
766 * have pending signals. Such threads will dequeue from the shared queue
767 * as soon as they're available, so putting the signal on the shared queue
768 * will be equivalent to sending it to one such thread.
770 static inline int wants_signal(int sig
, struct task_struct
*p
)
772 if (sigismember(&p
->blocked
, sig
))
774 if (p
->flags
& PF_EXITING
)
778 if (task_is_stopped_or_traced(p
))
780 return task_curr(p
) || !signal_pending(p
);
783 static void complete_signal(int sig
, struct task_struct
*p
, int group
)
785 struct signal_struct
*signal
= p
->signal
;
786 struct task_struct
*t
;
789 * Now find a thread we can wake up to take the signal off the queue.
791 * If the main thread wants the signal, it gets first crack.
792 * Probably the least surprising to the average bear.
794 if (wants_signal(sig
, p
))
796 else if (!group
|| thread_group_empty(p
))
798 * There is just one thread and it does not need to be woken.
799 * It will dequeue unblocked signals before it runs again.
804 * Otherwise try to find a suitable thread.
806 t
= signal
->curr_target
;
807 while (!wants_signal(sig
, t
)) {
809 if (t
== signal
->curr_target
)
811 * No thread needs to be woken.
812 * Any eligible threads will see
813 * the signal in the queue soon.
817 signal
->curr_target
= t
;
821 * Found a killable thread. If the signal will be fatal,
822 * then start taking the whole group down immediately.
824 if (sig_fatal(p
, sig
) &&
825 !(signal
->flags
& (SIGNAL_UNKILLABLE
| SIGNAL_GROUP_EXIT
)) &&
826 !sigismember(&t
->real_blocked
, sig
) &&
828 !tracehook_consider_fatal_signal(t
, sig
))) {
830 * This signal will be fatal to the whole group.
832 if (!sig_kernel_coredump(sig
)) {
834 * Start a group exit and wake everybody up.
835 * This way we don't have other threads
836 * running and doing things after a slower
837 * thread has the fatal signal pending.
839 signal
->flags
= SIGNAL_GROUP_EXIT
;
840 signal
->group_exit_code
= sig
;
841 signal
->group_stop_count
= 0;
844 sigaddset(&t
->pending
.signal
, SIGKILL
);
845 signal_wake_up(t
, 1);
846 } while_each_thread(p
, t
);
852 * The signal is already in the shared-pending queue.
853 * Tell the chosen thread to wake up and dequeue it.
855 signal_wake_up(t
, sig
== SIGKILL
);
859 static inline int legacy_queue(struct sigpending
*signals
, int sig
)
861 return (sig
< SIGRTMIN
) && sigismember(&signals
->signal
, sig
);
864 static int __send_signal(int sig
, struct siginfo
*info
, struct task_struct
*t
,
865 int group
, int from_ancestor_ns
)
867 struct sigpending
*pending
;
871 trace_signal_generate(sig
, info
, t
);
873 assert_spin_locked(&t
->sighand
->siglock
);
875 if (!prepare_signal(sig
, t
, from_ancestor_ns
))
878 pending
= group
? &t
->signal
->shared_pending
: &t
->pending
;
880 * Short-circuit ignored signals and support queuing
881 * exactly one non-rt signal, so that we can get more
882 * detailed information about the cause of the signal.
884 if (legacy_queue(pending
, sig
))
887 * fast-pathed signals for kernel-internal things like SIGSTOP
890 if (info
== SEND_SIG_FORCED
)
893 /* Real-time signals must be queued if sent by sigqueue, or
894 some other real-time mechanism. It is implementation
895 defined whether kill() does so. We attempt to do so, on
896 the principle of least surprise, but since kill is not
897 allowed to fail with EAGAIN when low on memory we just
898 make sure at least one signal gets delivered and don't
899 pass on the info struct. */
902 override_rlimit
= (is_si_special(info
) || info
->si_code
>= 0);
906 q
= __sigqueue_alloc(sig
, t
, GFP_ATOMIC
| __GFP_NOTRACK_FALSE_POSITIVE
,
909 list_add_tail(&q
->list
, &pending
->list
);
910 switch ((unsigned long) info
) {
911 case (unsigned long) SEND_SIG_NOINFO
:
912 q
->info
.si_signo
= sig
;
913 q
->info
.si_errno
= 0;
914 q
->info
.si_code
= SI_USER
;
915 q
->info
.si_pid
= task_tgid_nr_ns(current
,
916 task_active_pid_ns(t
));
917 q
->info
.si_uid
= current_uid();
919 case (unsigned long) SEND_SIG_PRIV
:
920 q
->info
.si_signo
= sig
;
921 q
->info
.si_errno
= 0;
922 q
->info
.si_code
= SI_KERNEL
;
927 copy_siginfo(&q
->info
, info
);
928 if (from_ancestor_ns
)
932 } else if (!is_si_special(info
)) {
933 if (sig
>= SIGRTMIN
&& info
->si_code
!= SI_USER
) {
935 * Queue overflow, abort. We may abort if the
936 * signal was rt and sent by user using something
939 trace_signal_overflow_fail(sig
, group
, info
);
943 * This is a silent loss of information. We still
944 * send the signal, but the *info bits are lost.
946 trace_signal_lose_info(sig
, group
, info
);
951 signalfd_notify(t
, sig
);
952 sigaddset(&pending
->signal
, sig
);
953 complete_signal(sig
, t
, group
);
957 static int send_signal(int sig
, struct siginfo
*info
, struct task_struct
*t
,
960 int from_ancestor_ns
= 0;
963 from_ancestor_ns
= si_fromuser(info
) &&
964 !task_pid_nr_ns(current
, task_active_pid_ns(t
));
967 return __send_signal(sig
, info
, t
, group
, from_ancestor_ns
);
970 static void print_fatal_signal(struct pt_regs
*regs
, int signr
)
972 printk("%s/%d: potentially unexpected fatal signal %d.\n",
973 current
->comm
, task_pid_nr(current
), signr
);
975 #if defined(__i386__) && !defined(__arch_um__)
976 printk("code at %08lx: ", regs
->ip
);
979 for (i
= 0; i
< 16; i
++) {
982 __get_user(insn
, (unsigned char *)(regs
->ip
+ i
));
983 printk("%02x ", insn
);
993 static int __init
setup_print_fatal_signals(char *str
)
995 get_option (&str
, &print_fatal_signals
);
1000 __setup("print-fatal-signals=", setup_print_fatal_signals
);
1003 __group_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1005 return send_signal(sig
, info
, p
, 1);
1009 specific_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*t
)
1011 return send_signal(sig
, info
, t
, 0);
1014 int do_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
,
1017 unsigned long flags
;
1020 if (lock_task_sighand(p
, &flags
)) {
1021 ret
= send_signal(sig
, info
, p
, group
);
1022 unlock_task_sighand(p
, &flags
);
1029 * Force a signal that the process can't ignore: if necessary
1030 * we unblock the signal and change any SIG_IGN to SIG_DFL.
1032 * Note: If we unblock the signal, we always reset it to SIG_DFL,
1033 * since we do not want to have a signal handler that was blocked
1034 * be invoked when user space had explicitly blocked it.
1036 * We don't want to have recursive SIGSEGV's etc, for example,
1037 * that is why we also clear SIGNAL_UNKILLABLE.
1040 force_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*t
)
1042 unsigned long int flags
;
1043 int ret
, blocked
, ignored
;
1044 struct k_sigaction
*action
;
1046 spin_lock_irqsave(&t
->sighand
->siglock
, flags
);
1047 action
= &t
->sighand
->action
[sig
-1];
1048 ignored
= action
->sa
.sa_handler
== SIG_IGN
;
1049 blocked
= sigismember(&t
->blocked
, sig
);
1050 if (blocked
|| ignored
) {
1051 action
->sa
.sa_handler
= SIG_DFL
;
1053 sigdelset(&t
->blocked
, sig
);
1054 recalc_sigpending_and_wake(t
);
1057 if (action
->sa
.sa_handler
== SIG_DFL
)
1058 t
->signal
->flags
&= ~SIGNAL_UNKILLABLE
;
1059 ret
= specific_send_sig_info(sig
, info
, t
);
1060 spin_unlock_irqrestore(&t
->sighand
->siglock
, flags
);
1066 * Nuke all other threads in the group.
1068 void zap_other_threads(struct task_struct
*p
)
1070 struct task_struct
*t
;
1072 p
->signal
->group_stop_count
= 0;
1074 for (t
= next_thread(p
); t
!= p
; t
= next_thread(t
)) {
1076 * Don't bother with already dead threads
1081 /* SIGKILL will be handled before any pending SIGSTOP */
1082 sigaddset(&t
->pending
.signal
, SIGKILL
);
1083 signal_wake_up(t
, 1);
1087 struct sighand_struct
*lock_task_sighand(struct task_struct
*tsk
, unsigned long *flags
)
1089 struct sighand_struct
*sighand
;
1093 sighand
= rcu_dereference(tsk
->sighand
);
1094 if (unlikely(sighand
== NULL
))
1097 spin_lock_irqsave(&sighand
->siglock
, *flags
);
1098 if (likely(sighand
== tsk
->sighand
))
1100 spin_unlock_irqrestore(&sighand
->siglock
, *flags
);
1108 * send signal info to all the members of a group
1109 * - the caller must hold the RCU read lock at least
1111 int group_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1113 int ret
= check_kill_permission(sig
, info
, p
);
1116 ret
= do_send_sig_info(sig
, info
, p
, true);
1122 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1123 * control characters do (^C, ^Z etc)
1124 * - the caller must hold at least a readlock on tasklist_lock
1126 int __kill_pgrp_info(int sig
, struct siginfo
*info
, struct pid
*pgrp
)
1128 struct task_struct
*p
= NULL
;
1129 int retval
, success
;
1133 do_each_pid_task(pgrp
, PIDTYPE_PGID
, p
) {
1134 int err
= group_send_sig_info(sig
, info
, p
);
1137 } while_each_pid_task(pgrp
, PIDTYPE_PGID
, p
);
1138 return success
? 0 : retval
;
1141 int kill_pid_info(int sig
, struct siginfo
*info
, struct pid
*pid
)
1144 struct task_struct
*p
;
1148 p
= pid_task(pid
, PIDTYPE_PID
);
1150 error
= group_send_sig_info(sig
, info
, p
);
1151 if (unlikely(error
== -ESRCH
))
1153 * The task was unhashed in between, try again.
1154 * If it is dead, pid_task() will return NULL,
1155 * if we race with de_thread() it will find the
1166 kill_proc_info(int sig
, struct siginfo
*info
, pid_t pid
)
1170 error
= kill_pid_info(sig
, info
, find_vpid(pid
));
1175 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1176 int kill_pid_info_as_uid(int sig
, struct siginfo
*info
, struct pid
*pid
,
1177 uid_t uid
, uid_t euid
, u32 secid
)
1180 struct task_struct
*p
;
1181 const struct cred
*pcred
;
1183 if (!valid_signal(sig
))
1186 read_lock(&tasklist_lock
);
1187 p
= pid_task(pid
, PIDTYPE_PID
);
1192 pcred
= __task_cred(p
);
1193 if (si_fromuser(info
) &&
1194 euid
!= pcred
->suid
&& euid
!= pcred
->uid
&&
1195 uid
!= pcred
->suid
&& uid
!= pcred
->uid
) {
1199 ret
= security_task_kill(p
, info
, sig
, secid
);
1202 if (sig
&& p
->sighand
) {
1203 unsigned long flags
;
1204 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1205 ret
= __send_signal(sig
, info
, p
, 1, 0);
1206 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1209 read_unlock(&tasklist_lock
);
1212 EXPORT_SYMBOL_GPL(kill_pid_info_as_uid
);
1215 * kill_something_info() interprets pid in interesting ways just like kill(2).
1217 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1218 * is probably wrong. Should make it like BSD or SYSV.
1221 static int kill_something_info(int sig
, struct siginfo
*info
, pid_t pid
)
1227 ret
= kill_pid_info(sig
, info
, find_vpid(pid
));
1232 read_lock(&tasklist_lock
);
1234 ret
= __kill_pgrp_info(sig
, info
,
1235 pid
? find_vpid(-pid
) : task_pgrp(current
));
1237 int retval
= 0, count
= 0;
1238 struct task_struct
* p
;
1240 for_each_process(p
) {
1241 if (task_pid_vnr(p
) > 1 &&
1242 !same_thread_group(p
, current
)) {
1243 int err
= group_send_sig_info(sig
, info
, p
);
1249 ret
= count
? retval
: -ESRCH
;
1251 read_unlock(&tasklist_lock
);
1257 * These are for backward compatibility with the rest of the kernel source.
1261 send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1264 * Make sure legacy kernel users don't send in bad values
1265 * (normal paths check this in check_kill_permission).
1267 if (!valid_signal(sig
))
1270 return do_send_sig_info(sig
, info
, p
, false);
1273 #define __si_special(priv) \
1274 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1277 send_sig(int sig
, struct task_struct
*p
, int priv
)
1279 return send_sig_info(sig
, __si_special(priv
), p
);
1283 force_sig(int sig
, struct task_struct
*p
)
1285 force_sig_info(sig
, SEND_SIG_PRIV
, p
);
1289 * When things go south during signal handling, we
1290 * will force a SIGSEGV. And if the signal that caused
1291 * the problem was already a SIGSEGV, we'll want to
1292 * make sure we don't even try to deliver the signal..
1295 force_sigsegv(int sig
, struct task_struct
*p
)
1297 if (sig
== SIGSEGV
) {
1298 unsigned long flags
;
1299 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1300 p
->sighand
->action
[sig
- 1].sa
.sa_handler
= SIG_DFL
;
1301 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1303 force_sig(SIGSEGV
, p
);
1307 int kill_pgrp(struct pid
*pid
, int sig
, int priv
)
1311 read_lock(&tasklist_lock
);
1312 ret
= __kill_pgrp_info(sig
, __si_special(priv
), pid
);
1313 read_unlock(&tasklist_lock
);
1317 EXPORT_SYMBOL(kill_pgrp
);
1319 int kill_pid(struct pid
*pid
, int sig
, int priv
)
1321 return kill_pid_info(sig
, __si_special(priv
), pid
);
1323 EXPORT_SYMBOL(kill_pid
);
1326 * These functions support sending signals using preallocated sigqueue
1327 * structures. This is needed "because realtime applications cannot
1328 * afford to lose notifications of asynchronous events, like timer
1329 * expirations or I/O completions". In the case of Posix Timers
1330 * we allocate the sigqueue structure from the timer_create. If this
1331 * allocation fails we are able to report the failure to the application
1332 * with an EAGAIN error.
1334 struct sigqueue
*sigqueue_alloc(void)
1336 struct sigqueue
*q
= __sigqueue_alloc(-1, current
, GFP_KERNEL
, 0);
1339 q
->flags
|= SIGQUEUE_PREALLOC
;
1344 void sigqueue_free(struct sigqueue
*q
)
1346 unsigned long flags
;
1347 spinlock_t
*lock
= ¤t
->sighand
->siglock
;
1349 BUG_ON(!(q
->flags
& SIGQUEUE_PREALLOC
));
1351 * We must hold ->siglock while testing q->list
1352 * to serialize with collect_signal() or with
1353 * __exit_signal()->flush_sigqueue().
1355 spin_lock_irqsave(lock
, flags
);
1356 q
->flags
&= ~SIGQUEUE_PREALLOC
;
1358 * If it is queued it will be freed when dequeued,
1359 * like the "regular" sigqueue.
1361 if (!list_empty(&q
->list
))
1363 spin_unlock_irqrestore(lock
, flags
);
1369 int send_sigqueue(struct sigqueue
*q
, struct task_struct
*t
, int group
)
1371 int sig
= q
->info
.si_signo
;
1372 struct sigpending
*pending
;
1373 unsigned long flags
;
1376 BUG_ON(!(q
->flags
& SIGQUEUE_PREALLOC
));
1379 if (!likely(lock_task_sighand(t
, &flags
)))
1382 ret
= 1; /* the signal is ignored */
1383 if (!prepare_signal(sig
, t
, 0))
1387 if (unlikely(!list_empty(&q
->list
))) {
1389 * If an SI_TIMER entry is already queue just increment
1390 * the overrun count.
1392 BUG_ON(q
->info
.si_code
!= SI_TIMER
);
1393 q
->info
.si_overrun
++;
1396 q
->info
.si_overrun
= 0;
1398 signalfd_notify(t
, sig
);
1399 pending
= group
? &t
->signal
->shared_pending
: &t
->pending
;
1400 list_add_tail(&q
->list
, &pending
->list
);
1401 sigaddset(&pending
->signal
, sig
);
1402 complete_signal(sig
, t
, group
);
1404 unlock_task_sighand(t
, &flags
);
1410 * Let a parent know about the death of a child.
1411 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1413 * Returns -1 if our parent ignored us and so we've switched to
1414 * self-reaping, or else @sig.
1416 int do_notify_parent(struct task_struct
*tsk
, int sig
)
1418 struct siginfo info
;
1419 unsigned long flags
;
1420 struct sighand_struct
*psig
;
1425 /* do_notify_parent_cldstop should have been called instead. */
1426 BUG_ON(task_is_stopped_or_traced(tsk
));
1428 BUG_ON(!task_ptrace(tsk
) &&
1429 (tsk
->group_leader
!= tsk
|| !thread_group_empty(tsk
)));
1431 info
.si_signo
= sig
;
1434 * we are under tasklist_lock here so our parent is tied to
1435 * us and cannot exit and release its namespace.
1437 * the only it can is to switch its nsproxy with sys_unshare,
1438 * bu uncharing pid namespaces is not allowed, so we'll always
1439 * see relevant namespace
1441 * write_lock() currently calls preempt_disable() which is the
1442 * same as rcu_read_lock(), but according to Oleg, this is not
1443 * correct to rely on this
1446 info
.si_pid
= task_pid_nr_ns(tsk
, tsk
->parent
->nsproxy
->pid_ns
);
1447 info
.si_uid
= __task_cred(tsk
)->uid
;
1450 info
.si_utime
= cputime_to_clock_t(cputime_add(tsk
->utime
,
1451 tsk
->signal
->utime
));
1452 info
.si_stime
= cputime_to_clock_t(cputime_add(tsk
->stime
,
1453 tsk
->signal
->stime
));
1455 info
.si_status
= tsk
->exit_code
& 0x7f;
1456 if (tsk
->exit_code
& 0x80)
1457 info
.si_code
= CLD_DUMPED
;
1458 else if (tsk
->exit_code
& 0x7f)
1459 info
.si_code
= CLD_KILLED
;
1461 info
.si_code
= CLD_EXITED
;
1462 info
.si_status
= tsk
->exit_code
>> 8;
1465 psig
= tsk
->parent
->sighand
;
1466 spin_lock_irqsave(&psig
->siglock
, flags
);
1467 if (!task_ptrace(tsk
) && sig
== SIGCHLD
&&
1468 (psig
->action
[SIGCHLD
-1].sa
.sa_handler
== SIG_IGN
||
1469 (psig
->action
[SIGCHLD
-1].sa
.sa_flags
& SA_NOCLDWAIT
))) {
1471 * We are exiting and our parent doesn't care. POSIX.1
1472 * defines special semantics for setting SIGCHLD to SIG_IGN
1473 * or setting the SA_NOCLDWAIT flag: we should be reaped
1474 * automatically and not left for our parent's wait4 call.
1475 * Rather than having the parent do it as a magic kind of
1476 * signal handler, we just set this to tell do_exit that we
1477 * can be cleaned up without becoming a zombie. Note that
1478 * we still call __wake_up_parent in this case, because a
1479 * blocked sys_wait4 might now return -ECHILD.
1481 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1482 * is implementation-defined: we do (if you don't want
1483 * it, just use SIG_IGN instead).
1485 ret
= tsk
->exit_signal
= -1;
1486 if (psig
->action
[SIGCHLD
-1].sa
.sa_handler
== SIG_IGN
)
1489 if (valid_signal(sig
) && sig
> 0)
1490 __group_send_sig_info(sig
, &info
, tsk
->parent
);
1491 __wake_up_parent(tsk
, tsk
->parent
);
1492 spin_unlock_irqrestore(&psig
->siglock
, flags
);
1497 static void do_notify_parent_cldstop(struct task_struct
*tsk
, int why
)
1499 struct siginfo info
;
1500 unsigned long flags
;
1501 struct task_struct
*parent
;
1502 struct sighand_struct
*sighand
;
1504 if (task_ptrace(tsk
))
1505 parent
= tsk
->parent
;
1507 tsk
= tsk
->group_leader
;
1508 parent
= tsk
->real_parent
;
1511 info
.si_signo
= SIGCHLD
;
1514 * see comment in do_notify_parent() abot the following 3 lines
1517 info
.si_pid
= task_pid_nr_ns(tsk
, parent
->nsproxy
->pid_ns
);
1518 info
.si_uid
= __task_cred(tsk
)->uid
;
1521 info
.si_utime
= cputime_to_clock_t(tsk
->utime
);
1522 info
.si_stime
= cputime_to_clock_t(tsk
->stime
);
1527 info
.si_status
= SIGCONT
;
1530 info
.si_status
= tsk
->signal
->group_exit_code
& 0x7f;
1533 info
.si_status
= tsk
->exit_code
& 0x7f;
1539 sighand
= parent
->sighand
;
1540 spin_lock_irqsave(&sighand
->siglock
, flags
);
1541 if (sighand
->action
[SIGCHLD
-1].sa
.sa_handler
!= SIG_IGN
&&
1542 !(sighand
->action
[SIGCHLD
-1].sa
.sa_flags
& SA_NOCLDSTOP
))
1543 __group_send_sig_info(SIGCHLD
, &info
, parent
);
1545 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1547 __wake_up_parent(tsk
, parent
);
1548 spin_unlock_irqrestore(&sighand
->siglock
, flags
);
1551 static inline int may_ptrace_stop(void)
1553 if (!likely(task_ptrace(current
)))
1556 * Are we in the middle of do_coredump?
1557 * If so and our tracer is also part of the coredump stopping
1558 * is a deadlock situation, and pointless because our tracer
1559 * is dead so don't allow us to stop.
1560 * If SIGKILL was already sent before the caller unlocked
1561 * ->siglock we must see ->core_state != NULL. Otherwise it
1562 * is safe to enter schedule().
1564 if (unlikely(current
->mm
->core_state
) &&
1565 unlikely(current
->mm
== current
->parent
->mm
))
1572 * Return nonzero if there is a SIGKILL that should be waking us up.
1573 * Called with the siglock held.
1575 static int sigkill_pending(struct task_struct
*tsk
)
1577 return sigismember(&tsk
->pending
.signal
, SIGKILL
) ||
1578 sigismember(&tsk
->signal
->shared_pending
.signal
, SIGKILL
);
1582 * This must be called with current->sighand->siglock held.
1584 * This should be the path for all ptrace stops.
1585 * We always set current->last_siginfo while stopped here.
1586 * That makes it a way to test a stopped process for
1587 * being ptrace-stopped vs being job-control-stopped.
1589 * If we actually decide not to stop at all because the tracer
1590 * is gone, we keep current->exit_code unless clear_code.
1592 static void ptrace_stop(int exit_code
, int clear_code
, siginfo_t
*info
)
1594 if (arch_ptrace_stop_needed(exit_code
, info
)) {
1596 * The arch code has something special to do before a
1597 * ptrace stop. This is allowed to block, e.g. for faults
1598 * on user stack pages. We can't keep the siglock while
1599 * calling arch_ptrace_stop, so we must release it now.
1600 * To preserve proper semantics, we must do this before
1601 * any signal bookkeeping like checking group_stop_count.
1602 * Meanwhile, a SIGKILL could come in before we retake the
1603 * siglock. That must prevent us from sleeping in TASK_TRACED.
1604 * So after regaining the lock, we must check for SIGKILL.
1606 spin_unlock_irq(¤t
->sighand
->siglock
);
1607 arch_ptrace_stop(exit_code
, info
);
1608 spin_lock_irq(¤t
->sighand
->siglock
);
1609 if (sigkill_pending(current
))
1614 * If there is a group stop in progress,
1615 * we must participate in the bookkeeping.
1617 if (current
->signal
->group_stop_count
> 0)
1618 --current
->signal
->group_stop_count
;
1620 current
->last_siginfo
= info
;
1621 current
->exit_code
= exit_code
;
1623 /* Let the debugger run. */
1624 __set_current_state(TASK_TRACED
);
1625 spin_unlock_irq(¤t
->sighand
->siglock
);
1626 read_lock(&tasklist_lock
);
1627 if (may_ptrace_stop()) {
1628 do_notify_parent_cldstop(current
, CLD_TRAPPED
);
1630 * Don't want to allow preemption here, because
1631 * sys_ptrace() needs this task to be inactive.
1633 * XXX: implement read_unlock_no_resched().
1636 read_unlock(&tasklist_lock
);
1637 preempt_enable_no_resched();
1641 * By the time we got the lock, our tracer went away.
1642 * Don't drop the lock yet, another tracer may come.
1644 __set_current_state(TASK_RUNNING
);
1646 current
->exit_code
= 0;
1647 read_unlock(&tasklist_lock
);
1651 * While in TASK_TRACED, we were considered "frozen enough".
1652 * Now that we woke up, it's crucial if we're supposed to be
1653 * frozen that we freeze now before running anything substantial.
1658 * We are back. Now reacquire the siglock before touching
1659 * last_siginfo, so that we are sure to have synchronized with
1660 * any signal-sending on another CPU that wants to examine it.
1662 spin_lock_irq(¤t
->sighand
->siglock
);
1663 current
->last_siginfo
= NULL
;
1666 * Queued signals ignored us while we were stopped for tracing.
1667 * So check for any that we should take before resuming user mode.
1668 * This sets TIF_SIGPENDING, but never clears it.
1670 recalc_sigpending_tsk(current
);
1673 void ptrace_notify(int exit_code
)
1677 BUG_ON((exit_code
& (0x7f | ~0xffff)) != SIGTRAP
);
1679 memset(&info
, 0, sizeof info
);
1680 info
.si_signo
= SIGTRAP
;
1681 info
.si_code
= exit_code
;
1682 info
.si_pid
= task_pid_vnr(current
);
1683 info
.si_uid
= current_uid();
1685 /* Let the debugger run. */
1686 spin_lock_irq(¤t
->sighand
->siglock
);
1687 ptrace_stop(exit_code
, 1, &info
);
1688 spin_unlock_irq(¤t
->sighand
->siglock
);
1692 * This performs the stopping for SIGSTOP and other stop signals.
1693 * We have to stop all threads in the thread group.
1694 * Returns nonzero if we've actually stopped and released the siglock.
1695 * Returns zero if we didn't stop and still hold the siglock.
1697 static int do_signal_stop(int signr
)
1699 struct signal_struct
*sig
= current
->signal
;
1702 if (!sig
->group_stop_count
) {
1703 struct task_struct
*t
;
1705 if (!likely(sig
->flags
& SIGNAL_STOP_DEQUEUED
) ||
1706 unlikely(signal_group_exit(sig
)))
1709 * There is no group stop already in progress.
1710 * We must initiate one now.
1712 sig
->group_exit_code
= signr
;
1714 sig
->group_stop_count
= 1;
1715 for (t
= next_thread(current
); t
!= current
; t
= next_thread(t
))
1717 * Setting state to TASK_STOPPED for a group
1718 * stop is always done with the siglock held,
1719 * so this check has no races.
1721 if (!(t
->flags
& PF_EXITING
) &&
1722 !task_is_stopped_or_traced(t
)) {
1723 sig
->group_stop_count
++;
1724 signal_wake_up(t
, 0);
1728 * If there are no other threads in the group, or if there is
1729 * a group stop in progress and we are the last to stop, report
1730 * to the parent. When ptraced, every thread reports itself.
1732 notify
= sig
->group_stop_count
== 1 ? CLD_STOPPED
: 0;
1733 notify
= tracehook_notify_jctl(notify
, CLD_STOPPED
);
1735 * tracehook_notify_jctl() can drop and reacquire siglock, so
1736 * we keep ->group_stop_count != 0 before the call. If SIGCONT
1737 * or SIGKILL comes in between ->group_stop_count == 0.
1739 if (sig
->group_stop_count
) {
1740 if (!--sig
->group_stop_count
)
1741 sig
->flags
= SIGNAL_STOP_STOPPED
;
1742 current
->exit_code
= sig
->group_exit_code
;
1743 __set_current_state(TASK_STOPPED
);
1745 spin_unlock_irq(¤t
->sighand
->siglock
);
1748 read_lock(&tasklist_lock
);
1749 do_notify_parent_cldstop(current
, notify
);
1750 read_unlock(&tasklist_lock
);
1753 /* Now we don't run again until woken by SIGCONT or SIGKILL */
1756 } while (try_to_freeze());
1758 tracehook_finish_jctl();
1759 current
->exit_code
= 0;
1764 static int ptrace_signal(int signr
, siginfo_t
*info
,
1765 struct pt_regs
*regs
, void *cookie
)
1767 if (!task_ptrace(current
))
1770 ptrace_signal_deliver(regs
, cookie
);
1772 /* Let the debugger run. */
1773 ptrace_stop(signr
, 0, info
);
1775 /* We're back. Did the debugger cancel the sig? */
1776 signr
= current
->exit_code
;
1780 current
->exit_code
= 0;
1782 /* Update the siginfo structure if the signal has
1783 changed. If the debugger wanted something
1784 specific in the siginfo structure then it should
1785 have updated *info via PTRACE_SETSIGINFO. */
1786 if (signr
!= info
->si_signo
) {
1787 info
->si_signo
= signr
;
1789 info
->si_code
= SI_USER
;
1790 info
->si_pid
= task_pid_vnr(current
->parent
);
1791 info
->si_uid
= task_uid(current
->parent
);
1794 /* If the (new) signal is now blocked, requeue it. */
1795 if (sigismember(¤t
->blocked
, signr
)) {
1796 specific_send_sig_info(signr
, info
, current
);
1803 int get_signal_to_deliver(siginfo_t
*info
, struct k_sigaction
*return_ka
,
1804 struct pt_regs
*regs
, void *cookie
)
1806 struct sighand_struct
*sighand
= current
->sighand
;
1807 struct signal_struct
*signal
= current
->signal
;
1812 * We'll jump back here after any time we were stopped in TASK_STOPPED.
1813 * While in TASK_STOPPED, we were considered "frozen enough".
1814 * Now that we woke up, it's crucial if we're supposed to be
1815 * frozen that we freeze now before running anything substantial.
1819 spin_lock_irq(&sighand
->siglock
);
1821 * Every stopped thread goes here after wakeup. Check to see if
1822 * we should notify the parent, prepare_signal(SIGCONT) encodes
1823 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
1825 if (unlikely(signal
->flags
& SIGNAL_CLD_MASK
)) {
1826 int why
= (signal
->flags
& SIGNAL_STOP_CONTINUED
)
1827 ? CLD_CONTINUED
: CLD_STOPPED
;
1828 signal
->flags
&= ~SIGNAL_CLD_MASK
;
1830 why
= tracehook_notify_jctl(why
, CLD_CONTINUED
);
1831 spin_unlock_irq(&sighand
->siglock
);
1834 read_lock(&tasklist_lock
);
1835 do_notify_parent_cldstop(current
->group_leader
, why
);
1836 read_unlock(&tasklist_lock
);
1842 struct k_sigaction
*ka
;
1844 if (unlikely(signal
->group_stop_count
> 0) &&
1849 * Tracing can induce an artifical signal and choose sigaction.
1850 * The return value in @signr determines the default action,
1851 * but @info->si_signo is the signal number we will report.
1853 signr
= tracehook_get_signal(current
, regs
, info
, return_ka
);
1854 if (unlikely(signr
< 0))
1856 if (unlikely(signr
!= 0))
1859 signr
= dequeue_signal(current
, ¤t
->blocked
,
1863 break; /* will return 0 */
1865 if (signr
!= SIGKILL
) {
1866 signr
= ptrace_signal(signr
, info
,
1872 ka
= &sighand
->action
[signr
-1];
1875 /* Trace actually delivered signals. */
1876 trace_signal_deliver(signr
, info
, ka
);
1878 if (ka
->sa
.sa_handler
== SIG_IGN
) /* Do nothing. */
1880 if (ka
->sa
.sa_handler
!= SIG_DFL
) {
1881 /* Run the handler. */
1884 if (ka
->sa
.sa_flags
& SA_ONESHOT
)
1885 ka
->sa
.sa_handler
= SIG_DFL
;
1887 break; /* will return non-zero "signr" value */
1891 * Now we are doing the default action for this signal.
1893 if (sig_kernel_ignore(signr
)) /* Default is nothing. */
1897 * Global init gets no signals it doesn't want.
1898 * Container-init gets no signals it doesn't want from same
1901 * Note that if global/container-init sees a sig_kernel_only()
1902 * signal here, the signal must have been generated internally
1903 * or must have come from an ancestor namespace. In either
1904 * case, the signal cannot be dropped.
1906 if (unlikely(signal
->flags
& SIGNAL_UNKILLABLE
) &&
1907 !sig_kernel_only(signr
))
1910 if (sig_kernel_stop(signr
)) {
1912 * The default action is to stop all threads in
1913 * the thread group. The job control signals
1914 * do nothing in an orphaned pgrp, but SIGSTOP
1915 * always works. Note that siglock needs to be
1916 * dropped during the call to is_orphaned_pgrp()
1917 * because of lock ordering with tasklist_lock.
1918 * This allows an intervening SIGCONT to be posted.
1919 * We need to check for that and bail out if necessary.
1921 if (signr
!= SIGSTOP
) {
1922 spin_unlock_irq(&sighand
->siglock
);
1924 /* signals can be posted during this window */
1926 if (is_current_pgrp_orphaned())
1929 spin_lock_irq(&sighand
->siglock
);
1932 if (likely(do_signal_stop(info
->si_signo
))) {
1933 /* It released the siglock. */
1938 * We didn't actually stop, due to a race
1939 * with SIGCONT or something like that.
1944 spin_unlock_irq(&sighand
->siglock
);
1947 * Anything else is fatal, maybe with a core dump.
1949 current
->flags
|= PF_SIGNALED
;
1951 if (sig_kernel_coredump(signr
)) {
1952 if (print_fatal_signals
)
1953 print_fatal_signal(regs
, info
->si_signo
);
1955 * If it was able to dump core, this kills all
1956 * other threads in the group and synchronizes with
1957 * their demise. If we lost the race with another
1958 * thread getting here, it set group_exit_code
1959 * first and our do_group_exit call below will use
1960 * that value and ignore the one we pass it.
1962 do_coredump(info
->si_signo
, info
->si_signo
, regs
);
1966 * Death signals, no core dump.
1968 do_group_exit(info
->si_signo
);
1971 spin_unlock_irq(&sighand
->siglock
);
1975 void exit_signals(struct task_struct
*tsk
)
1978 struct task_struct
*t
;
1980 if (thread_group_empty(tsk
) || signal_group_exit(tsk
->signal
)) {
1981 tsk
->flags
|= PF_EXITING
;
1985 spin_lock_irq(&tsk
->sighand
->siglock
);
1987 * From now this task is not visible for group-wide signals,
1988 * see wants_signal(), do_signal_stop().
1990 tsk
->flags
|= PF_EXITING
;
1991 if (!signal_pending(tsk
))
1994 /* It could be that __group_complete_signal() choose us to
1995 * notify about group-wide signal. Another thread should be
1996 * woken now to take the signal since we will not.
1998 for (t
= tsk
; (t
= next_thread(t
)) != tsk
; )
1999 if (!signal_pending(t
) && !(t
->flags
& PF_EXITING
))
2000 recalc_sigpending_and_wake(t
);
2002 if (unlikely(tsk
->signal
->group_stop_count
) &&
2003 !--tsk
->signal
->group_stop_count
) {
2004 tsk
->signal
->flags
= SIGNAL_STOP_STOPPED
;
2005 group_stop
= tracehook_notify_jctl(CLD_STOPPED
, CLD_STOPPED
);
2008 spin_unlock_irq(&tsk
->sighand
->siglock
);
2010 if (unlikely(group_stop
)) {
2011 read_lock(&tasklist_lock
);
2012 do_notify_parent_cldstop(tsk
, group_stop
);
2013 read_unlock(&tasklist_lock
);
2017 EXPORT_SYMBOL(recalc_sigpending
);
2018 EXPORT_SYMBOL_GPL(dequeue_signal
);
2019 EXPORT_SYMBOL(flush_signals
);
2020 EXPORT_SYMBOL(force_sig
);
2021 EXPORT_SYMBOL(send_sig
);
2022 EXPORT_SYMBOL(send_sig_info
);
2023 EXPORT_SYMBOL(sigprocmask
);
2024 EXPORT_SYMBOL(block_all_signals
);
2025 EXPORT_SYMBOL(unblock_all_signals
);
2029 * System call entry points.
2032 SYSCALL_DEFINE0(restart_syscall
)
2034 struct restart_block
*restart
= ¤t_thread_info()->restart_block
;
2035 return restart
->fn(restart
);
2038 long do_no_restart_syscall(struct restart_block
*param
)
2044 * We don't need to get the kernel lock - this is all local to this
2045 * particular thread.. (and that's good, because this is _heavily_
2046 * used by various programs)
2050 * This is also useful for kernel threads that want to temporarily
2051 * (or permanently) block certain signals.
2053 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2054 * interface happily blocks "unblockable" signals like SIGKILL
2057 int sigprocmask(int how
, sigset_t
*set
, sigset_t
*oldset
)
2061 spin_lock_irq(¤t
->sighand
->siglock
);
2063 *oldset
= current
->blocked
;
2068 sigorsets(¤t
->blocked
, ¤t
->blocked
, set
);
2071 signandsets(¤t
->blocked
, ¤t
->blocked
, set
);
2074 current
->blocked
= *set
;
2079 recalc_sigpending();
2080 spin_unlock_irq(¤t
->sighand
->siglock
);
2085 SYSCALL_DEFINE4(rt_sigprocmask
, int, how
, sigset_t __user
*, set
,
2086 sigset_t __user
*, oset
, size_t, sigsetsize
)
2088 int error
= -EINVAL
;
2089 sigset_t old_set
, new_set
;
2091 /* XXX: Don't preclude handling different sized sigset_t's. */
2092 if (sigsetsize
!= sizeof(sigset_t
))
2097 if (copy_from_user(&new_set
, set
, sizeof(*set
)))
2099 sigdelsetmask(&new_set
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
2101 error
= sigprocmask(how
, &new_set
, &old_set
);
2107 spin_lock_irq(¤t
->sighand
->siglock
);
2108 old_set
= current
->blocked
;
2109 spin_unlock_irq(¤t
->sighand
->siglock
);
2113 if (copy_to_user(oset
, &old_set
, sizeof(*oset
)))
2121 long do_sigpending(void __user
*set
, unsigned long sigsetsize
)
2123 long error
= -EINVAL
;
2126 if (sigsetsize
> sizeof(sigset_t
))
2129 spin_lock_irq(¤t
->sighand
->siglock
);
2130 sigorsets(&pending
, ¤t
->pending
.signal
,
2131 ¤t
->signal
->shared_pending
.signal
);
2132 spin_unlock_irq(¤t
->sighand
->siglock
);
2134 /* Outside the lock because only this thread touches it. */
2135 sigandsets(&pending
, ¤t
->blocked
, &pending
);
2138 if (!copy_to_user(set
, &pending
, sigsetsize
))
2145 SYSCALL_DEFINE2(rt_sigpending
, sigset_t __user
*, set
, size_t, sigsetsize
)
2147 return do_sigpending(set
, sigsetsize
);
2150 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2152 int copy_siginfo_to_user(siginfo_t __user
*to
, siginfo_t
*from
)
2156 if (!access_ok (VERIFY_WRITE
, to
, sizeof(siginfo_t
)))
2158 if (from
->si_code
< 0)
2159 return __copy_to_user(to
, from
, sizeof(siginfo_t
))
2162 * If you change siginfo_t structure, please be sure
2163 * this code is fixed accordingly.
2164 * Please remember to update the signalfd_copyinfo() function
2165 * inside fs/signalfd.c too, in case siginfo_t changes.
2166 * It should never copy any pad contained in the structure
2167 * to avoid security leaks, but must copy the generic
2168 * 3 ints plus the relevant union member.
2170 err
= __put_user(from
->si_signo
, &to
->si_signo
);
2171 err
|= __put_user(from
->si_errno
, &to
->si_errno
);
2172 err
|= __put_user((short)from
->si_code
, &to
->si_code
);
2173 switch (from
->si_code
& __SI_MASK
) {
2175 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2176 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2179 err
|= __put_user(from
->si_tid
, &to
->si_tid
);
2180 err
|= __put_user(from
->si_overrun
, &to
->si_overrun
);
2181 err
|= __put_user(from
->si_ptr
, &to
->si_ptr
);
2184 err
|= __put_user(from
->si_band
, &to
->si_band
);
2185 err
|= __put_user(from
->si_fd
, &to
->si_fd
);
2188 err
|= __put_user(from
->si_addr
, &to
->si_addr
);
2189 #ifdef __ARCH_SI_TRAPNO
2190 err
|= __put_user(from
->si_trapno
, &to
->si_trapno
);
2194 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2195 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2196 err
|= __put_user(from
->si_status
, &to
->si_status
);
2197 err
|= __put_user(from
->si_utime
, &to
->si_utime
);
2198 err
|= __put_user(from
->si_stime
, &to
->si_stime
);
2200 case __SI_RT
: /* This is not generated by the kernel as of now. */
2201 case __SI_MESGQ
: /* But this is */
2202 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2203 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2204 err
|= __put_user(from
->si_ptr
, &to
->si_ptr
);
2206 default: /* this is just in case for now ... */
2207 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2208 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2216 SYSCALL_DEFINE4(rt_sigtimedwait
, const sigset_t __user
*, uthese
,
2217 siginfo_t __user
*, uinfo
, const struct timespec __user
*, uts
,
2226 /* XXX: Don't preclude handling different sized sigset_t's. */
2227 if (sigsetsize
!= sizeof(sigset_t
))
2230 if (copy_from_user(&these
, uthese
, sizeof(these
)))
2234 * Invert the set of allowed signals to get those we
2237 sigdelsetmask(&these
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
2241 if (copy_from_user(&ts
, uts
, sizeof(ts
)))
2243 if (ts
.tv_nsec
>= 1000000000L || ts
.tv_nsec
< 0
2248 spin_lock_irq(¤t
->sighand
->siglock
);
2249 sig
= dequeue_signal(current
, &these
, &info
);
2251 timeout
= MAX_SCHEDULE_TIMEOUT
;
2253 timeout
= (timespec_to_jiffies(&ts
)
2254 + (ts
.tv_sec
|| ts
.tv_nsec
));
2257 /* None ready -- temporarily unblock those we're
2258 * interested while we are sleeping in so that we'll
2259 * be awakened when they arrive. */
2260 current
->real_blocked
= current
->blocked
;
2261 sigandsets(¤t
->blocked
, ¤t
->blocked
, &these
);
2262 recalc_sigpending();
2263 spin_unlock_irq(¤t
->sighand
->siglock
);
2265 timeout
= schedule_timeout_interruptible(timeout
);
2267 spin_lock_irq(¤t
->sighand
->siglock
);
2268 sig
= dequeue_signal(current
, &these
, &info
);
2269 current
->blocked
= current
->real_blocked
;
2270 siginitset(¤t
->real_blocked
, 0);
2271 recalc_sigpending();
2274 spin_unlock_irq(¤t
->sighand
->siglock
);
2279 if (copy_siginfo_to_user(uinfo
, &info
))
2291 SYSCALL_DEFINE2(kill
, pid_t
, pid
, int, sig
)
2293 struct siginfo info
;
2295 info
.si_signo
= sig
;
2297 info
.si_code
= SI_USER
;
2298 info
.si_pid
= task_tgid_vnr(current
);
2299 info
.si_uid
= current_uid();
2301 return kill_something_info(sig
, &info
, pid
);
2305 do_send_specific(pid_t tgid
, pid_t pid
, int sig
, struct siginfo
*info
)
2307 struct task_struct
*p
;
2311 p
= find_task_by_vpid(pid
);
2312 if (p
&& (tgid
<= 0 || task_tgid_vnr(p
) == tgid
)) {
2313 error
= check_kill_permission(sig
, info
, p
);
2315 * The null signal is a permissions and process existence
2316 * probe. No signal is actually delivered.
2318 if (!error
&& sig
) {
2319 error
= do_send_sig_info(sig
, info
, p
, false);
2321 * If lock_task_sighand() failed we pretend the task
2322 * dies after receiving the signal. The window is tiny,
2323 * and the signal is private anyway.
2325 if (unlikely(error
== -ESRCH
))
2334 static int do_tkill(pid_t tgid
, pid_t pid
, int sig
)
2336 struct siginfo info
;
2338 info
.si_signo
= sig
;
2340 info
.si_code
= SI_TKILL
;
2341 info
.si_pid
= task_tgid_vnr(current
);
2342 info
.si_uid
= current_uid();
2344 return do_send_specific(tgid
, pid
, sig
, &info
);
2348 * sys_tgkill - send signal to one specific thread
2349 * @tgid: the thread group ID of the thread
2350 * @pid: the PID of the thread
2351 * @sig: signal to be sent
2353 * This syscall also checks the @tgid and returns -ESRCH even if the PID
2354 * exists but it's not belonging to the target process anymore. This
2355 * method solves the problem of threads exiting and PIDs getting reused.
2357 SYSCALL_DEFINE3(tgkill
, pid_t
, tgid
, pid_t
, pid
, int, sig
)
2359 /* This is only valid for single tasks */
2360 if (pid
<= 0 || tgid
<= 0)
2363 return do_tkill(tgid
, pid
, sig
);
2367 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2369 SYSCALL_DEFINE2(tkill
, pid_t
, pid
, int, sig
)
2371 /* This is only valid for single tasks */
2375 return do_tkill(0, pid
, sig
);
2378 SYSCALL_DEFINE3(rt_sigqueueinfo
, pid_t
, pid
, int, sig
,
2379 siginfo_t __user
*, uinfo
)
2383 if (copy_from_user(&info
, uinfo
, sizeof(siginfo_t
)))
2386 /* Not even root can pretend to send signals from the kernel.
2387 Nor can they impersonate a kill(), which adds source info. */
2388 if (info
.si_code
>= 0)
2390 info
.si_signo
= sig
;
2392 /* POSIX.1b doesn't mention process groups. */
2393 return kill_proc_info(sig
, &info
, pid
);
2396 long do_rt_tgsigqueueinfo(pid_t tgid
, pid_t pid
, int sig
, siginfo_t
*info
)
2398 /* This is only valid for single tasks */
2399 if (pid
<= 0 || tgid
<= 0)
2402 /* Not even root can pretend to send signals from the kernel.
2403 Nor can they impersonate a kill(), which adds source info. */
2404 if (info
->si_code
>= 0)
2406 info
->si_signo
= sig
;
2408 return do_send_specific(tgid
, pid
, sig
, info
);
2411 SYSCALL_DEFINE4(rt_tgsigqueueinfo
, pid_t
, tgid
, pid_t
, pid
, int, sig
,
2412 siginfo_t __user
*, uinfo
)
2416 if (copy_from_user(&info
, uinfo
, sizeof(siginfo_t
)))
2419 return do_rt_tgsigqueueinfo(tgid
, pid
, sig
, &info
);
2422 int do_sigaction(int sig
, struct k_sigaction
*act
, struct k_sigaction
*oact
)
2424 struct task_struct
*t
= current
;
2425 struct k_sigaction
*k
;
2428 if (!valid_signal(sig
) || sig
< 1 || (act
&& sig_kernel_only(sig
)))
2431 k
= &t
->sighand
->action
[sig
-1];
2433 spin_lock_irq(¤t
->sighand
->siglock
);
2438 sigdelsetmask(&act
->sa
.sa_mask
,
2439 sigmask(SIGKILL
) | sigmask(SIGSTOP
));
2443 * "Setting a signal action to SIG_IGN for a signal that is
2444 * pending shall cause the pending signal to be discarded,
2445 * whether or not it is blocked."
2447 * "Setting a signal action to SIG_DFL for a signal that is
2448 * pending and whose default action is to ignore the signal
2449 * (for example, SIGCHLD), shall cause the pending signal to
2450 * be discarded, whether or not it is blocked"
2452 if (sig_handler_ignored(sig_handler(t
, sig
), sig
)) {
2454 sigaddset(&mask
, sig
);
2455 rm_from_queue_full(&mask
, &t
->signal
->shared_pending
);
2457 rm_from_queue_full(&mask
, &t
->pending
);
2459 } while (t
!= current
);
2463 spin_unlock_irq(¤t
->sighand
->siglock
);
2468 do_sigaltstack (const stack_t __user
*uss
, stack_t __user
*uoss
, unsigned long sp
)
2473 oss
.ss_sp
= (void __user
*) current
->sas_ss_sp
;
2474 oss
.ss_size
= current
->sas_ss_size
;
2475 oss
.ss_flags
= sas_ss_flags(sp
);
2483 if (!access_ok(VERIFY_READ
, uss
, sizeof(*uss
)))
2485 error
= __get_user(ss_sp
, &uss
->ss_sp
) |
2486 __get_user(ss_flags
, &uss
->ss_flags
) |
2487 __get_user(ss_size
, &uss
->ss_size
);
2492 if (on_sig_stack(sp
))
2498 * Note - this code used to test ss_flags incorrectly
2499 * old code may have been written using ss_flags==0
2500 * to mean ss_flags==SS_ONSTACK (as this was the only
2501 * way that worked) - this fix preserves that older
2504 if (ss_flags
!= SS_DISABLE
&& ss_flags
!= SS_ONSTACK
&& ss_flags
!= 0)
2507 if (ss_flags
== SS_DISABLE
) {
2512 if (ss_size
< MINSIGSTKSZ
)
2516 current
->sas_ss_sp
= (unsigned long) ss_sp
;
2517 current
->sas_ss_size
= ss_size
;
2523 if (!access_ok(VERIFY_WRITE
, uoss
, sizeof(*uoss
)))
2525 error
= __put_user(oss
.ss_sp
, &uoss
->ss_sp
) |
2526 __put_user(oss
.ss_size
, &uoss
->ss_size
) |
2527 __put_user(oss
.ss_flags
, &uoss
->ss_flags
);
2534 #ifdef __ARCH_WANT_SYS_SIGPENDING
2536 SYSCALL_DEFINE1(sigpending
, old_sigset_t __user
*, set
)
2538 return do_sigpending(set
, sizeof(*set
));
2543 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2544 /* Some platforms have their own version with special arguments others
2545 support only sys_rt_sigprocmask. */
2547 SYSCALL_DEFINE3(sigprocmask
, int, how
, old_sigset_t __user
*, set
,
2548 old_sigset_t __user
*, oset
)
2551 old_sigset_t old_set
, new_set
;
2555 if (copy_from_user(&new_set
, set
, sizeof(*set
)))
2557 new_set
&= ~(sigmask(SIGKILL
) | sigmask(SIGSTOP
));
2559 spin_lock_irq(¤t
->sighand
->siglock
);
2560 old_set
= current
->blocked
.sig
[0];
2568 sigaddsetmask(¤t
->blocked
, new_set
);
2571 sigdelsetmask(¤t
->blocked
, new_set
);
2574 current
->blocked
.sig
[0] = new_set
;
2578 recalc_sigpending();
2579 spin_unlock_irq(¤t
->sighand
->siglock
);
2585 old_set
= current
->blocked
.sig
[0];
2588 if (copy_to_user(oset
, &old_set
, sizeof(*oset
)))
2595 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2597 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2598 SYSCALL_DEFINE4(rt_sigaction
, int, sig
,
2599 const struct sigaction __user
*, act
,
2600 struct sigaction __user
*, oact
,
2603 struct k_sigaction new_sa
, old_sa
;
2606 /* XXX: Don't preclude handling different sized sigset_t's. */
2607 if (sigsetsize
!= sizeof(sigset_t
))
2611 if (copy_from_user(&new_sa
.sa
, act
, sizeof(new_sa
.sa
)))
2615 ret
= do_sigaction(sig
, act
? &new_sa
: NULL
, oact
? &old_sa
: NULL
);
2618 if (copy_to_user(oact
, &old_sa
.sa
, sizeof(old_sa
.sa
)))
2624 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2626 #ifdef __ARCH_WANT_SYS_SGETMASK
2629 * For backwards compatibility. Functionality superseded by sigprocmask.
2631 SYSCALL_DEFINE0(sgetmask
)
2634 return current
->blocked
.sig
[0];
2637 SYSCALL_DEFINE1(ssetmask
, int, newmask
)
2641 spin_lock_irq(¤t
->sighand
->siglock
);
2642 old
= current
->blocked
.sig
[0];
2644 siginitset(¤t
->blocked
, newmask
& ~(sigmask(SIGKILL
)|
2646 recalc_sigpending();
2647 spin_unlock_irq(¤t
->sighand
->siglock
);
2651 #endif /* __ARCH_WANT_SGETMASK */
2653 #ifdef __ARCH_WANT_SYS_SIGNAL
2655 * For backwards compatibility. Functionality superseded by sigaction.
2657 SYSCALL_DEFINE2(signal
, int, sig
, __sighandler_t
, handler
)
2659 struct k_sigaction new_sa
, old_sa
;
2662 new_sa
.sa
.sa_handler
= handler
;
2663 new_sa
.sa
.sa_flags
= SA_ONESHOT
| SA_NOMASK
;
2664 sigemptyset(&new_sa
.sa
.sa_mask
);
2666 ret
= do_sigaction(sig
, &new_sa
, &old_sa
);
2668 return ret
? ret
: (unsigned long)old_sa
.sa
.sa_handler
;
2670 #endif /* __ARCH_WANT_SYS_SIGNAL */
2672 #ifdef __ARCH_WANT_SYS_PAUSE
2674 SYSCALL_DEFINE0(pause
)
2676 current
->state
= TASK_INTERRUPTIBLE
;
2678 return -ERESTARTNOHAND
;
2683 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2684 SYSCALL_DEFINE2(rt_sigsuspend
, sigset_t __user
*, unewset
, size_t, sigsetsize
)
2688 /* XXX: Don't preclude handling different sized sigset_t's. */
2689 if (sigsetsize
!= sizeof(sigset_t
))
2692 if (copy_from_user(&newset
, unewset
, sizeof(newset
)))
2694 sigdelsetmask(&newset
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
2696 spin_lock_irq(¤t
->sighand
->siglock
);
2697 current
->saved_sigmask
= current
->blocked
;
2698 current
->blocked
= newset
;
2699 recalc_sigpending();
2700 spin_unlock_irq(¤t
->sighand
->siglock
);
2702 current
->state
= TASK_INTERRUPTIBLE
;
2704 set_restore_sigmask();
2705 return -ERESTARTNOHAND
;
2707 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2709 __attribute__((weak
)) const char *arch_vma_name(struct vm_area_struct
*vma
)
2714 void __init
signals_init(void)
2716 sigqueue_cachep
= KMEM_CACHE(sigqueue
, SLAB_PANIC
);