USB: serial: add special case for processing of empty read urbs
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / kernel / signal.c
blobdbd7fe073c558dbc57080e7d0d9344b2cf47b2dd
1 /*
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>
17 #include <linux/fs.h>
18 #include <linux/tty.h>
19 #include <linux/binfmts.h>
20 #include <linux/security.h>
21 #include <linux/syscalls.h>
22 #include <linux/ptrace.h>
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,
61 int from_ancestor_ns)
63 void __user *handler;
65 handler = sig_handler(t, sig);
67 if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
68 handler == SIG_DFL && !from_ancestor_ns)
69 return 1;
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
79 * unblocked.
81 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
82 return 0;
84 if (!sig_task_ignored(t, sig, from_ancestor_ns))
85 return 0;
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)
99 unsigned long ready;
100 long i;
102 switch (_NSIG_WORDS) {
103 default:
104 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
105 ready |= signal->sig[i] &~ blocked->sig[i];
106 break;
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];
112 break;
114 case 2: ready = signal->sig[1] &~ blocked->sig[1];
115 ready |= signal->sig[0] &~ blocked->sig[0];
116 break;
118 case 1: ready = signal->sig[0] &~ blocked->sig[0];
120 return ready != 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);
131 return 1;
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.
138 return 0;
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;
169 int sig = 0;
171 s = pending->signal.sig;
172 m = mask->sig;
175 * Handle the first word specially: it contains the
176 * synchronous signals that need to be dequeued first.
178 x = *s &~ *m;
179 if (x) {
180 if (x & SYNCHRONOUS_MASK)
181 x &= SYNCHRONOUS_MASK;
182 sig = ffz(~x) + 1;
183 return sig;
186 switch (_NSIG_WORDS) {
187 default:
188 for (i = 1; i < _NSIG_WORDS; ++i) {
189 x = *++s &~ *++m;
190 if (!x)
191 continue;
192 sig = ffz(~x) + i*_NSIG_BPW + 1;
193 break;
195 break;
197 case 2:
198 x = s[1] &~ m[1];
199 if (!x)
200 break;
201 sig = ffz(~x) + _NSIG_BPW + 1;
202 break;
204 case 1:
205 /* Nothing to do */
206 break;
209 return sig;
212 static inline void print_dropped_signal(int sig)
214 static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
216 if (!print_fatal_signals)
217 return;
219 if (!__ratelimit(&ratelimit_state))
220 return;
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.
241 rcu_read_lock();
242 user = get_uid(__task_cred(t)->user);
243 atomic_inc(&user->sigpending);
244 rcu_read_unlock();
246 if (override_rlimit ||
247 atomic_read(&user->sigpending) <=
248 task_rlimit(t, RLIMIT_SIGPENDING)) {
249 q = kmem_cache_alloc(sigqueue_cachep, flags);
250 } else {
251 print_dropped_signal(sig);
254 if (unlikely(q == NULL)) {
255 atomic_dec(&user->sigpending);
256 free_uid(user);
257 } else {
258 INIT_LIST_HEAD(&q->list);
259 q->flags = 0;
260 q->user = user;
263 return q;
266 static void __sigqueue_free(struct sigqueue *q)
268 if (q->flags & SIGQUEUE_PREALLOC)
269 return;
270 atomic_dec(&q->user->sigpending);
271 free_uid(q->user);
272 kmem_cache_free(sigqueue_cachep, q);
275 void flush_sigqueue(struct sigpending *queue)
277 struct sigqueue *q;
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);
283 __sigqueue_free(q);
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)
299 unsigned long flags;
301 spin_lock_irqsave(&t->sighand->siglock, flags);
302 __flush_signals(t);
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);
319 } else {
320 sigdelset(&signal, sig);
321 list_del_init(&q->list);
322 __sigqueue_free(q);
326 sigorsets(&pending->signal, &signal, &retain);
329 void flush_itimer_signals(void)
331 struct task_struct *tsk = current;
332 unsigned long flags;
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)
342 int i;
344 for (i = 0; i < _NSIG; ++i)
345 t->sighand->action[i].sa.sa_handler = SIG_IGN;
347 flush_signals(t);
351 * Flush all handlers for a task.
354 void
355 flush_signal_handlers(struct task_struct *t, int force_default)
357 int i;
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;
362 ka->sa.sa_flags = 0;
363 sigemptyset(&ka->sa.sa_mask);
364 ka++;
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))
372 return 1;
373 if (handler != SIG_IGN && handler != SIG_DFL)
374 return 0;
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. */
387 void
388 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
390 unsigned long flags;
392 spin_lock_irqsave(&current->sighand->siglock, flags);
393 current->notifier_mask = mask;
394 current->notifier_data = priv;
395 current->notifier = notifier;
396 spin_unlock_irqrestore(&current->sighand->siglock, flags);
399 /* Notify the system that blocking has ended. */
401 void
402 unblock_all_signals(void)
404 unsigned long flags;
406 spin_lock_irqsave(&current->sighand->siglock, flags);
407 current->notifier = NULL;
408 current->notifier_data = NULL;
409 recalc_sigpending();
410 spin_unlock_irqrestore(&current->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) {
423 if (first)
424 goto still_pending;
425 first = q;
429 sigdelset(&list->signal, sig);
431 if (first) {
432 still_pending:
433 list_del_init(&first->list);
434 copy_siginfo(info, &first->info);
435 __sigqueue_free(first);
436 } else {
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;
442 info->si_errno = 0;
443 info->si_code = SI_USER;
444 info->si_pid = 0;
445 info->si_uid = 0;
449 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
450 siginfo_t *info)
452 int sig = next_signal(pending, mask);
454 if (sig) {
455 if (current->notifier) {
456 if (sigismember(current->notifier_mask, sig)) {
457 if (!(current->notifier)(current->notifier_data)) {
458 clear_thread_flag(TIF_SIGPENDING);
459 return 0;
464 collect_signal(sig, pending, info);
467 return sig;
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)
478 int signr;
480 /* We only dequeue private signals from ourselves, we don't let
481 * signalfd steal them
483 signr = __dequeue_signal(&tsk->pending, mask, info);
484 if (!signr) {
485 signr = __dequeue_signal(&tsk->signal->shared_pending,
486 mask, info);
488 * itimer signal ?
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
498 * systems too.
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);
512 recalc_sigpending();
513 if (!signr)
514 return 0;
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);
542 return signr;
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)
558 unsigned int mask;
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;
570 if (resume)
571 mask |= TASK_WAKEKILL;
572 if (!wake_up_state(t, mask))
573 kick_process(t);
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;
588 sigset_t m;
590 sigandsets(&m, mask, &s->signal);
591 if (sigisemptyset(&m))
592 return 0;
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);
598 __sigqueue_free(q);
601 return 1;
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))
614 return 0;
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);
621 __sigqueue_free(q);
624 return 1;
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 at least 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 = current_cred(), *tcred;
646 struct pid *sid;
647 int error;
649 if (!valid_signal(sig))
650 return -EINVAL;
652 if (!si_fromuser(info))
653 return 0;
655 error = audit_signal_info(sig, t); /* Let audit system see the signal */
656 if (error)
657 return error;
659 tcred = __task_cred(t);
660 if ((cred->euid ^ tcred->suid) &&
661 (cred->euid ^ tcred->uid) &&
662 (cred->uid ^ tcred->suid) &&
663 (cred->uid ^ tcred->uid) &&
664 !capable(CAP_KILL)) {
665 switch (sig) {
666 case SIGCONT:
667 sid = task_session(t);
669 * We don't return the error if sid == NULL. The
670 * task was unhashed, the caller must notice this.
672 if (!sid || sid == task_session(current))
673 break;
674 default:
675 return -EPERM;
679 return security_task_kill(t, info, sig, 0);
683 * Handle magic process-wide effects of stop/continue signals. Unlike
684 * the signal actions, these happen immediately at signal-generation
685 * time regardless of blocking, ignoring, or handling. This does the
686 * actual continuing for SIGCONT, but not the actual stopping for stop
687 * signals. The process stop is done as a signal action for SIG_DFL.
689 * Returns true if the signal should be actually delivered, otherwise
690 * it should be dropped.
692 static int prepare_signal(int sig, struct task_struct *p, int from_ancestor_ns)
694 struct signal_struct *signal = p->signal;
695 struct task_struct *t;
697 if (unlikely(signal->flags & SIGNAL_GROUP_EXIT)) {
699 * The process is in the middle of dying, nothing to do.
701 } else if (sig_kernel_stop(sig)) {
703 * This is a stop signal. Remove SIGCONT from all queues.
705 rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
706 t = p;
707 do {
708 rm_from_queue(sigmask(SIGCONT), &t->pending);
709 } while_each_thread(p, t);
710 } else if (sig == SIGCONT) {
711 unsigned int why;
713 * Remove all stop signals from all queues,
714 * and wake all threads.
716 rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
717 t = p;
718 do {
719 unsigned int state;
720 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
722 * If there is a handler for SIGCONT, we must make
723 * sure that no thread returns to user mode before
724 * we post the signal, in case it was the only
725 * thread eligible to run the signal handler--then
726 * it must not do anything between resuming and
727 * running the handler. With the TIF_SIGPENDING
728 * flag set, the thread will pause and acquire the
729 * siglock that we hold now and until we've queued
730 * the pending signal.
732 * Wake up the stopped thread _after_ setting
733 * TIF_SIGPENDING
735 state = __TASK_STOPPED;
736 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
737 set_tsk_thread_flag(t, TIF_SIGPENDING);
738 state |= TASK_INTERRUPTIBLE;
740 wake_up_state(t, state);
741 } while_each_thread(p, t);
744 * Notify the parent with CLD_CONTINUED if we were stopped.
746 * If we were in the middle of a group stop, we pretend it
747 * was already finished, and then continued. Since SIGCHLD
748 * doesn't queue we report only CLD_STOPPED, as if the next
749 * CLD_CONTINUED was dropped.
751 why = 0;
752 if (signal->flags & SIGNAL_STOP_STOPPED)
753 why |= SIGNAL_CLD_CONTINUED;
754 else if (signal->group_stop_count)
755 why |= SIGNAL_CLD_STOPPED;
757 if (why) {
759 * The first thread which returns from do_signal_stop()
760 * will take ->siglock, notice SIGNAL_CLD_MASK, and
761 * notify its parent. See get_signal_to_deliver().
763 signal->flags = why | SIGNAL_STOP_CONTINUED;
764 signal->group_stop_count = 0;
765 signal->group_exit_code = 0;
766 } else {
768 * We are not stopped, but there could be a stop
769 * signal in the middle of being processed after
770 * being removed from the queue. Clear that too.
772 signal->flags &= ~SIGNAL_STOP_DEQUEUED;
776 return !sig_ignored(p, sig, from_ancestor_ns);
780 * Test if P wants to take SIG. After we've checked all threads with this,
781 * it's equivalent to finding no threads not blocking SIG. Any threads not
782 * blocking SIG were ruled out because they are not running and already
783 * have pending signals. Such threads will dequeue from the shared queue
784 * as soon as they're available, so putting the signal on the shared queue
785 * will be equivalent to sending it to one such thread.
787 static inline int wants_signal(int sig, struct task_struct *p)
789 if (sigismember(&p->blocked, sig))
790 return 0;
791 if (p->flags & PF_EXITING)
792 return 0;
793 if (sig == SIGKILL)
794 return 1;
795 if (task_is_stopped_or_traced(p))
796 return 0;
797 return task_curr(p) || !signal_pending(p);
800 static void complete_signal(int sig, struct task_struct *p, int group)
802 struct signal_struct *signal = p->signal;
803 struct task_struct *t;
806 * Now find a thread we can wake up to take the signal off the queue.
808 * If the main thread wants the signal, it gets first crack.
809 * Probably the least surprising to the average bear.
811 if (wants_signal(sig, p))
812 t = p;
813 else if (!group || thread_group_empty(p))
815 * There is just one thread and it does not need to be woken.
816 * It will dequeue unblocked signals before it runs again.
818 return;
819 else {
821 * Otherwise try to find a suitable thread.
823 t = signal->curr_target;
824 while (!wants_signal(sig, t)) {
825 t = next_thread(t);
826 if (t == signal->curr_target)
828 * No thread needs to be woken.
829 * Any eligible threads will see
830 * the signal in the queue soon.
832 return;
834 signal->curr_target = t;
838 * Found a killable thread. If the signal will be fatal,
839 * then start taking the whole group down immediately.
841 if (sig_fatal(p, sig) &&
842 !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
843 !sigismember(&t->real_blocked, sig) &&
844 (sig == SIGKILL ||
845 !tracehook_consider_fatal_signal(t, sig))) {
847 * This signal will be fatal to the whole group.
849 if (!sig_kernel_coredump(sig)) {
851 * Start a group exit and wake everybody up.
852 * This way we don't have other threads
853 * running and doing things after a slower
854 * thread has the fatal signal pending.
856 signal->flags = SIGNAL_GROUP_EXIT;
857 signal->group_exit_code = sig;
858 signal->group_stop_count = 0;
859 t = p;
860 do {
861 sigaddset(&t->pending.signal, SIGKILL);
862 signal_wake_up(t, 1);
863 } while_each_thread(p, t);
864 return;
869 * The signal is already in the shared-pending queue.
870 * Tell the chosen thread to wake up and dequeue it.
872 signal_wake_up(t, sig == SIGKILL);
873 return;
876 static inline int legacy_queue(struct sigpending *signals, int sig)
878 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
881 static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
882 int group, int from_ancestor_ns)
884 struct sigpending *pending;
885 struct sigqueue *q;
886 int override_rlimit;
888 trace_signal_generate(sig, info, t);
890 assert_spin_locked(&t->sighand->siglock);
892 if (!prepare_signal(sig, t, from_ancestor_ns))
893 return 0;
895 pending = group ? &t->signal->shared_pending : &t->pending;
897 * Short-circuit ignored signals and support queuing
898 * exactly one non-rt signal, so that we can get more
899 * detailed information about the cause of the signal.
901 if (legacy_queue(pending, sig))
902 return 0;
904 * fast-pathed signals for kernel-internal things like SIGSTOP
905 * or SIGKILL.
907 if (info == SEND_SIG_FORCED)
908 goto out_set;
910 /* Real-time signals must be queued if sent by sigqueue, or
911 some other real-time mechanism. It is implementation
912 defined whether kill() does so. We attempt to do so, on
913 the principle of least surprise, but since kill is not
914 allowed to fail with EAGAIN when low on memory we just
915 make sure at least one signal gets delivered and don't
916 pass on the info struct. */
918 if (sig < SIGRTMIN)
919 override_rlimit = (is_si_special(info) || info->si_code >= 0);
920 else
921 override_rlimit = 0;
923 q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
924 override_rlimit);
925 if (q) {
926 list_add_tail(&q->list, &pending->list);
927 switch ((unsigned long) info) {
928 case (unsigned long) SEND_SIG_NOINFO:
929 q->info.si_signo = sig;
930 q->info.si_errno = 0;
931 q->info.si_code = SI_USER;
932 q->info.si_pid = task_tgid_nr_ns(current,
933 task_active_pid_ns(t));
934 q->info.si_uid = current_uid();
935 break;
936 case (unsigned long) SEND_SIG_PRIV:
937 q->info.si_signo = sig;
938 q->info.si_errno = 0;
939 q->info.si_code = SI_KERNEL;
940 q->info.si_pid = 0;
941 q->info.si_uid = 0;
942 break;
943 default:
944 copy_siginfo(&q->info, info);
945 if (from_ancestor_ns)
946 q->info.si_pid = 0;
947 break;
949 } else if (!is_si_special(info)) {
950 if (sig >= SIGRTMIN && info->si_code != SI_USER) {
952 * Queue overflow, abort. We may abort if the
953 * signal was rt and sent by user using something
954 * other than kill().
956 trace_signal_overflow_fail(sig, group, info);
957 return -EAGAIN;
958 } else {
960 * This is a silent loss of information. We still
961 * send the signal, but the *info bits are lost.
963 trace_signal_lose_info(sig, group, info);
967 out_set:
968 signalfd_notify(t, sig);
969 sigaddset(&pending->signal, sig);
970 complete_signal(sig, t, group);
971 return 0;
974 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
975 int group)
977 int from_ancestor_ns = 0;
979 #ifdef CONFIG_PID_NS
980 from_ancestor_ns = si_fromuser(info) &&
981 !task_pid_nr_ns(current, task_active_pid_ns(t));
982 #endif
984 return __send_signal(sig, info, t, group, from_ancestor_ns);
987 static void print_fatal_signal(struct pt_regs *regs, int signr)
989 printk("%s/%d: potentially unexpected fatal signal %d.\n",
990 current->comm, task_pid_nr(current), signr);
992 #if defined(__i386__) && !defined(__arch_um__)
993 printk("code at %08lx: ", regs->ip);
995 int i;
996 for (i = 0; i < 16; i++) {
997 unsigned char insn;
999 if (get_user(insn, (unsigned char *)(regs->ip + i)))
1000 break;
1001 printk("%02x ", insn);
1004 #endif
1005 printk("\n");
1006 preempt_disable();
1007 show_regs(regs);
1008 preempt_enable();
1011 static int __init setup_print_fatal_signals(char *str)
1013 get_option (&str, &print_fatal_signals);
1015 return 1;
1018 __setup("print-fatal-signals=", setup_print_fatal_signals);
1021 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1023 return send_signal(sig, info, p, 1);
1026 static int
1027 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1029 return send_signal(sig, info, t, 0);
1032 int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
1033 bool group)
1035 unsigned long flags;
1036 int ret = -ESRCH;
1038 if (lock_task_sighand(p, &flags)) {
1039 ret = send_signal(sig, info, p, group);
1040 unlock_task_sighand(p, &flags);
1043 return ret;
1047 * Force a signal that the process can't ignore: if necessary
1048 * we unblock the signal and change any SIG_IGN to SIG_DFL.
1050 * Note: If we unblock the signal, we always reset it to SIG_DFL,
1051 * since we do not want to have a signal handler that was blocked
1052 * be invoked when user space had explicitly blocked it.
1054 * We don't want to have recursive SIGSEGV's etc, for example,
1055 * that is why we also clear SIGNAL_UNKILLABLE.
1058 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1060 unsigned long int flags;
1061 int ret, blocked, ignored;
1062 struct k_sigaction *action;
1064 spin_lock_irqsave(&t->sighand->siglock, flags);
1065 action = &t->sighand->action[sig-1];
1066 ignored = action->sa.sa_handler == SIG_IGN;
1067 blocked = sigismember(&t->blocked, sig);
1068 if (blocked || ignored) {
1069 action->sa.sa_handler = SIG_DFL;
1070 if (blocked) {
1071 sigdelset(&t->blocked, sig);
1072 recalc_sigpending_and_wake(t);
1075 if (action->sa.sa_handler == SIG_DFL)
1076 t->signal->flags &= ~SIGNAL_UNKILLABLE;
1077 ret = specific_send_sig_info(sig, info, t);
1078 spin_unlock_irqrestore(&t->sighand->siglock, flags);
1080 return ret;
1084 * Nuke all other threads in the group.
1086 void zap_other_threads(struct task_struct *p)
1088 struct task_struct *t;
1090 p->signal->group_stop_count = 0;
1092 for (t = next_thread(p); t != p; t = next_thread(t)) {
1094 * Don't bother with already dead threads
1096 if (t->exit_state)
1097 continue;
1099 /* SIGKILL will be handled before any pending SIGSTOP */
1100 sigaddset(&t->pending.signal, SIGKILL);
1101 signal_wake_up(t, 1);
1105 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
1107 struct sighand_struct *sighand;
1109 rcu_read_lock();
1110 for (;;) {
1111 sighand = rcu_dereference(tsk->sighand);
1112 if (unlikely(sighand == NULL))
1113 break;
1115 spin_lock_irqsave(&sighand->siglock, *flags);
1116 if (likely(sighand == tsk->sighand))
1117 break;
1118 spin_unlock_irqrestore(&sighand->siglock, *flags);
1120 rcu_read_unlock();
1122 return sighand;
1126 * send signal info to all the members of a group
1127 * - the caller must hold the RCU read lock at least
1129 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1131 int ret = check_kill_permission(sig, info, p);
1133 if (!ret && sig)
1134 ret = do_send_sig_info(sig, info, p, true);
1136 return ret;
1140 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1141 * control characters do (^C, ^Z etc)
1142 * - the caller must hold at least a readlock on tasklist_lock
1144 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1146 struct task_struct *p = NULL;
1147 int retval, success;
1149 success = 0;
1150 retval = -ESRCH;
1151 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1152 int err = group_send_sig_info(sig, info, p);
1153 success |= !err;
1154 retval = err;
1155 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1156 return success ? 0 : retval;
1159 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1161 int error = -ESRCH;
1162 struct task_struct *p;
1164 rcu_read_lock();
1165 retry:
1166 p = pid_task(pid, PIDTYPE_PID);
1167 if (p) {
1168 error = group_send_sig_info(sig, info, p);
1169 if (unlikely(error == -ESRCH))
1171 * The task was unhashed in between, try again.
1172 * If it is dead, pid_task() will return NULL,
1173 * if we race with de_thread() it will find the
1174 * new leader.
1176 goto retry;
1178 rcu_read_unlock();
1180 return error;
1184 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1186 int error;
1187 rcu_read_lock();
1188 error = kill_pid_info(sig, info, find_vpid(pid));
1189 rcu_read_unlock();
1190 return error;
1193 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1194 int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
1195 uid_t uid, uid_t euid, u32 secid)
1197 int ret = -EINVAL;
1198 struct task_struct *p;
1199 const struct cred *pcred;
1200 unsigned long flags;
1202 if (!valid_signal(sig))
1203 return ret;
1205 rcu_read_lock();
1206 p = pid_task(pid, PIDTYPE_PID);
1207 if (!p) {
1208 ret = -ESRCH;
1209 goto out_unlock;
1211 pcred = __task_cred(p);
1212 if (si_fromuser(info) &&
1213 euid != pcred->suid && euid != pcred->uid &&
1214 uid != pcred->suid && uid != pcred->uid) {
1215 ret = -EPERM;
1216 goto out_unlock;
1218 ret = security_task_kill(p, info, sig, secid);
1219 if (ret)
1220 goto out_unlock;
1222 if (sig) {
1223 if (lock_task_sighand(p, &flags)) {
1224 ret = __send_signal(sig, info, p, 1, 0);
1225 unlock_task_sighand(p, &flags);
1226 } else
1227 ret = -ESRCH;
1229 out_unlock:
1230 rcu_read_unlock();
1231 return ret;
1233 EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
1236 * kill_something_info() interprets pid in interesting ways just like kill(2).
1238 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1239 * is probably wrong. Should make it like BSD or SYSV.
1242 static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
1244 int ret;
1246 if (pid > 0) {
1247 rcu_read_lock();
1248 ret = kill_pid_info(sig, info, find_vpid(pid));
1249 rcu_read_unlock();
1250 return ret;
1253 read_lock(&tasklist_lock);
1254 if (pid != -1) {
1255 ret = __kill_pgrp_info(sig, info,
1256 pid ? find_vpid(-pid) : task_pgrp(current));
1257 } else {
1258 int retval = 0, count = 0;
1259 struct task_struct * p;
1261 for_each_process(p) {
1262 if (task_pid_vnr(p) > 1 &&
1263 !same_thread_group(p, current)) {
1264 int err = group_send_sig_info(sig, info, p);
1265 ++count;
1266 if (err != -EPERM)
1267 retval = err;
1270 ret = count ? retval : -ESRCH;
1272 read_unlock(&tasklist_lock);
1274 return ret;
1278 * These are for backward compatibility with the rest of the kernel source.
1282 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1285 * Make sure legacy kernel users don't send in bad values
1286 * (normal paths check this in check_kill_permission).
1288 if (!valid_signal(sig))
1289 return -EINVAL;
1291 return do_send_sig_info(sig, info, p, false);
1294 #define __si_special(priv) \
1295 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1298 send_sig(int sig, struct task_struct *p, int priv)
1300 return send_sig_info(sig, __si_special(priv), p);
1303 void
1304 force_sig(int sig, struct task_struct *p)
1306 force_sig_info(sig, SEND_SIG_PRIV, p);
1310 * When things go south during signal handling, we
1311 * will force a SIGSEGV. And if the signal that caused
1312 * the problem was already a SIGSEGV, we'll want to
1313 * make sure we don't even try to deliver the signal..
1316 force_sigsegv(int sig, struct task_struct *p)
1318 if (sig == SIGSEGV) {
1319 unsigned long flags;
1320 spin_lock_irqsave(&p->sighand->siglock, flags);
1321 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1322 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1324 force_sig(SIGSEGV, p);
1325 return 0;
1328 int kill_pgrp(struct pid *pid, int sig, int priv)
1330 int ret;
1332 read_lock(&tasklist_lock);
1333 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1334 read_unlock(&tasklist_lock);
1336 return ret;
1338 EXPORT_SYMBOL(kill_pgrp);
1340 int kill_pid(struct pid *pid, int sig, int priv)
1342 return kill_pid_info(sig, __si_special(priv), pid);
1344 EXPORT_SYMBOL(kill_pid);
1347 * These functions support sending signals using preallocated sigqueue
1348 * structures. This is needed "because realtime applications cannot
1349 * afford to lose notifications of asynchronous events, like timer
1350 * expirations or I/O completions". In the case of Posix Timers
1351 * we allocate the sigqueue structure from the timer_create. If this
1352 * allocation fails we are able to report the failure to the application
1353 * with an EAGAIN error.
1355 struct sigqueue *sigqueue_alloc(void)
1357 struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
1359 if (q)
1360 q->flags |= SIGQUEUE_PREALLOC;
1362 return q;
1365 void sigqueue_free(struct sigqueue *q)
1367 unsigned long flags;
1368 spinlock_t *lock = &current->sighand->siglock;
1370 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1372 * We must hold ->siglock while testing q->list
1373 * to serialize with collect_signal() or with
1374 * __exit_signal()->flush_sigqueue().
1376 spin_lock_irqsave(lock, flags);
1377 q->flags &= ~SIGQUEUE_PREALLOC;
1379 * If it is queued it will be freed when dequeued,
1380 * like the "regular" sigqueue.
1382 if (!list_empty(&q->list))
1383 q = NULL;
1384 spin_unlock_irqrestore(lock, flags);
1386 if (q)
1387 __sigqueue_free(q);
1390 int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1392 int sig = q->info.si_signo;
1393 struct sigpending *pending;
1394 unsigned long flags;
1395 int ret;
1397 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1399 ret = -1;
1400 if (!likely(lock_task_sighand(t, &flags)))
1401 goto ret;
1403 ret = 1; /* the signal is ignored */
1404 if (!prepare_signal(sig, t, 0))
1405 goto out;
1407 ret = 0;
1408 if (unlikely(!list_empty(&q->list))) {
1410 * If an SI_TIMER entry is already queue just increment
1411 * the overrun count.
1413 BUG_ON(q->info.si_code != SI_TIMER);
1414 q->info.si_overrun++;
1415 goto out;
1417 q->info.si_overrun = 0;
1419 signalfd_notify(t, sig);
1420 pending = group ? &t->signal->shared_pending : &t->pending;
1421 list_add_tail(&q->list, &pending->list);
1422 sigaddset(&pending->signal, sig);
1423 complete_signal(sig, t, group);
1424 out:
1425 unlock_task_sighand(t, &flags);
1426 ret:
1427 return ret;
1431 * Let a parent know about the death of a child.
1432 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1434 * Returns -1 if our parent ignored us and so we've switched to
1435 * self-reaping, or else @sig.
1437 int do_notify_parent(struct task_struct *tsk, int sig)
1439 struct siginfo info;
1440 unsigned long flags;
1441 struct sighand_struct *psig;
1442 int ret = sig;
1444 BUG_ON(sig == -1);
1446 /* do_notify_parent_cldstop should have been called instead. */
1447 BUG_ON(task_is_stopped_or_traced(tsk));
1449 BUG_ON(!task_ptrace(tsk) &&
1450 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1452 info.si_signo = sig;
1453 info.si_errno = 0;
1455 * we are under tasklist_lock here so our parent is tied to
1456 * us and cannot exit and release its namespace.
1458 * the only it can is to switch its nsproxy with sys_unshare,
1459 * bu uncharing pid namespaces is not allowed, so we'll always
1460 * see relevant namespace
1462 * write_lock() currently calls preempt_disable() which is the
1463 * same as rcu_read_lock(), but according to Oleg, this is not
1464 * correct to rely on this
1466 rcu_read_lock();
1467 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1468 info.si_uid = __task_cred(tsk)->uid;
1469 rcu_read_unlock();
1471 info.si_utime = cputime_to_clock_t(cputime_add(tsk->utime,
1472 tsk->signal->utime));
1473 info.si_stime = cputime_to_clock_t(cputime_add(tsk->stime,
1474 tsk->signal->stime));
1476 info.si_status = tsk->exit_code & 0x7f;
1477 if (tsk->exit_code & 0x80)
1478 info.si_code = CLD_DUMPED;
1479 else if (tsk->exit_code & 0x7f)
1480 info.si_code = CLD_KILLED;
1481 else {
1482 info.si_code = CLD_EXITED;
1483 info.si_status = tsk->exit_code >> 8;
1486 psig = tsk->parent->sighand;
1487 spin_lock_irqsave(&psig->siglock, flags);
1488 if (!task_ptrace(tsk) && sig == SIGCHLD &&
1489 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1490 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1492 * We are exiting and our parent doesn't care. POSIX.1
1493 * defines special semantics for setting SIGCHLD to SIG_IGN
1494 * or setting the SA_NOCLDWAIT flag: we should be reaped
1495 * automatically and not left for our parent's wait4 call.
1496 * Rather than having the parent do it as a magic kind of
1497 * signal handler, we just set this to tell do_exit that we
1498 * can be cleaned up without becoming a zombie. Note that
1499 * we still call __wake_up_parent in this case, because a
1500 * blocked sys_wait4 might now return -ECHILD.
1502 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1503 * is implementation-defined: we do (if you don't want
1504 * it, just use SIG_IGN instead).
1506 ret = tsk->exit_signal = -1;
1507 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1508 sig = -1;
1510 if (valid_signal(sig) && sig > 0)
1511 __group_send_sig_info(sig, &info, tsk->parent);
1512 __wake_up_parent(tsk, tsk->parent);
1513 spin_unlock_irqrestore(&psig->siglock, flags);
1515 return ret;
1518 static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
1520 struct siginfo info;
1521 unsigned long flags;
1522 struct task_struct *parent;
1523 struct sighand_struct *sighand;
1525 if (task_ptrace(tsk))
1526 parent = tsk->parent;
1527 else {
1528 tsk = tsk->group_leader;
1529 parent = tsk->real_parent;
1532 info.si_signo = SIGCHLD;
1533 info.si_errno = 0;
1535 * see comment in do_notify_parent() abot the following 3 lines
1537 rcu_read_lock();
1538 info.si_pid = task_pid_nr_ns(tsk, parent->nsproxy->pid_ns);
1539 info.si_uid = __task_cred(tsk)->uid;
1540 rcu_read_unlock();
1542 info.si_utime = cputime_to_clock_t(tsk->utime);
1543 info.si_stime = cputime_to_clock_t(tsk->stime);
1545 info.si_code = why;
1546 switch (why) {
1547 case CLD_CONTINUED:
1548 info.si_status = SIGCONT;
1549 break;
1550 case CLD_STOPPED:
1551 info.si_status = tsk->signal->group_exit_code & 0x7f;
1552 break;
1553 case CLD_TRAPPED:
1554 info.si_status = tsk->exit_code & 0x7f;
1555 break;
1556 default:
1557 BUG();
1560 sighand = parent->sighand;
1561 spin_lock_irqsave(&sighand->siglock, flags);
1562 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1563 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1564 __group_send_sig_info(SIGCHLD, &info, parent);
1566 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1568 __wake_up_parent(tsk, parent);
1569 spin_unlock_irqrestore(&sighand->siglock, flags);
1572 static inline int may_ptrace_stop(void)
1574 if (!likely(task_ptrace(current)))
1575 return 0;
1577 * Are we in the middle of do_coredump?
1578 * If so and our tracer is also part of the coredump stopping
1579 * is a deadlock situation, and pointless because our tracer
1580 * is dead so don't allow us to stop.
1581 * If SIGKILL was already sent before the caller unlocked
1582 * ->siglock we must see ->core_state != NULL. Otherwise it
1583 * is safe to enter schedule().
1585 if (unlikely(current->mm->core_state) &&
1586 unlikely(current->mm == current->parent->mm))
1587 return 0;
1589 return 1;
1593 * Return nonzero if there is a SIGKILL that should be waking us up.
1594 * Called with the siglock held.
1596 static int sigkill_pending(struct task_struct *tsk)
1598 return sigismember(&tsk->pending.signal, SIGKILL) ||
1599 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
1603 * This must be called with current->sighand->siglock held.
1605 * This should be the path for all ptrace stops.
1606 * We always set current->last_siginfo while stopped here.
1607 * That makes it a way to test a stopped process for
1608 * being ptrace-stopped vs being job-control-stopped.
1610 * If we actually decide not to stop at all because the tracer
1611 * is gone, we keep current->exit_code unless clear_code.
1613 static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
1615 if (arch_ptrace_stop_needed(exit_code, info)) {
1617 * The arch code has something special to do before a
1618 * ptrace stop. This is allowed to block, e.g. for faults
1619 * on user stack pages. We can't keep the siglock while
1620 * calling arch_ptrace_stop, so we must release it now.
1621 * To preserve proper semantics, we must do this before
1622 * any signal bookkeeping like checking group_stop_count.
1623 * Meanwhile, a SIGKILL could come in before we retake the
1624 * siglock. That must prevent us from sleeping in TASK_TRACED.
1625 * So after regaining the lock, we must check for SIGKILL.
1627 spin_unlock_irq(&current->sighand->siglock);
1628 arch_ptrace_stop(exit_code, info);
1629 spin_lock_irq(&current->sighand->siglock);
1630 if (sigkill_pending(current))
1631 return;
1635 * If there is a group stop in progress,
1636 * we must participate in the bookkeeping.
1638 if (current->signal->group_stop_count > 0)
1639 --current->signal->group_stop_count;
1641 current->last_siginfo = info;
1642 current->exit_code = exit_code;
1644 /* Let the debugger run. */
1645 __set_current_state(TASK_TRACED);
1646 spin_unlock_irq(&current->sighand->siglock);
1647 read_lock(&tasklist_lock);
1648 if (may_ptrace_stop()) {
1649 do_notify_parent_cldstop(current, CLD_TRAPPED);
1651 * Don't want to allow preemption here, because
1652 * sys_ptrace() needs this task to be inactive.
1654 * XXX: implement read_unlock_no_resched().
1656 preempt_disable();
1657 read_unlock(&tasklist_lock);
1658 preempt_enable_no_resched();
1659 schedule();
1660 } else {
1662 * By the time we got the lock, our tracer went away.
1663 * Don't drop the lock yet, another tracer may come.
1665 __set_current_state(TASK_RUNNING);
1666 if (clear_code)
1667 current->exit_code = 0;
1668 read_unlock(&tasklist_lock);
1672 * While in TASK_TRACED, we were considered "frozen enough".
1673 * Now that we woke up, it's crucial if we're supposed to be
1674 * frozen that we freeze now before running anything substantial.
1676 try_to_freeze();
1679 * We are back. Now reacquire the siglock before touching
1680 * last_siginfo, so that we are sure to have synchronized with
1681 * any signal-sending on another CPU that wants to examine it.
1683 spin_lock_irq(&current->sighand->siglock);
1684 current->last_siginfo = NULL;
1687 * Queued signals ignored us while we were stopped for tracing.
1688 * So check for any that we should take before resuming user mode.
1689 * This sets TIF_SIGPENDING, but never clears it.
1691 recalc_sigpending_tsk(current);
1694 void ptrace_notify(int exit_code)
1696 siginfo_t info;
1698 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1700 memset(&info, 0, sizeof info);
1701 info.si_signo = SIGTRAP;
1702 info.si_code = exit_code;
1703 info.si_pid = task_pid_vnr(current);
1704 info.si_uid = current_uid();
1706 /* Let the debugger run. */
1707 spin_lock_irq(&current->sighand->siglock);
1708 ptrace_stop(exit_code, 1, &info);
1709 spin_unlock_irq(&current->sighand->siglock);
1713 * This performs the stopping for SIGSTOP and other stop signals.
1714 * We have to stop all threads in the thread group.
1715 * Returns nonzero if we've actually stopped and released the siglock.
1716 * Returns zero if we didn't stop and still hold the siglock.
1718 static int do_signal_stop(int signr)
1720 struct signal_struct *sig = current->signal;
1721 int notify;
1723 if (!sig->group_stop_count) {
1724 struct task_struct *t;
1726 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED) ||
1727 unlikely(signal_group_exit(sig)))
1728 return 0;
1730 * There is no group stop already in progress.
1731 * We must initiate one now.
1733 sig->group_exit_code = signr;
1735 sig->group_stop_count = 1;
1736 for (t = next_thread(current); t != current; t = next_thread(t))
1738 * Setting state to TASK_STOPPED for a group
1739 * stop is always done with the siglock held,
1740 * so this check has no races.
1742 if (!(t->flags & PF_EXITING) &&
1743 !task_is_stopped_or_traced(t)) {
1744 sig->group_stop_count++;
1745 signal_wake_up(t, 0);
1749 * If there are no other threads in the group, or if there is
1750 * a group stop in progress and we are the last to stop, report
1751 * to the parent. When ptraced, every thread reports itself.
1753 notify = sig->group_stop_count == 1 ? CLD_STOPPED : 0;
1754 notify = tracehook_notify_jctl(notify, CLD_STOPPED);
1756 * tracehook_notify_jctl() can drop and reacquire siglock, so
1757 * we keep ->group_stop_count != 0 before the call. If SIGCONT
1758 * or SIGKILL comes in between ->group_stop_count == 0.
1760 if (sig->group_stop_count) {
1761 if (!--sig->group_stop_count)
1762 sig->flags = SIGNAL_STOP_STOPPED;
1763 current->exit_code = sig->group_exit_code;
1764 __set_current_state(TASK_STOPPED);
1766 spin_unlock_irq(&current->sighand->siglock);
1768 if (notify) {
1769 read_lock(&tasklist_lock);
1770 do_notify_parent_cldstop(current, notify);
1771 read_unlock(&tasklist_lock);
1774 /* Now we don't run again until woken by SIGCONT or SIGKILL */
1775 do {
1776 schedule();
1777 } while (try_to_freeze());
1779 tracehook_finish_jctl();
1780 current->exit_code = 0;
1782 return 1;
1785 static int ptrace_signal(int signr, siginfo_t *info,
1786 struct pt_regs *regs, void *cookie)
1788 if (!task_ptrace(current))
1789 return signr;
1791 ptrace_signal_deliver(regs, cookie);
1793 /* Let the debugger run. */
1794 ptrace_stop(signr, 0, info);
1796 /* We're back. Did the debugger cancel the sig? */
1797 signr = current->exit_code;
1798 if (signr == 0)
1799 return signr;
1801 current->exit_code = 0;
1803 /* Update the siginfo structure if the signal has
1804 changed. If the debugger wanted something
1805 specific in the siginfo structure then it should
1806 have updated *info via PTRACE_SETSIGINFO. */
1807 if (signr != info->si_signo) {
1808 info->si_signo = signr;
1809 info->si_errno = 0;
1810 info->si_code = SI_USER;
1811 info->si_pid = task_pid_vnr(current->parent);
1812 info->si_uid = task_uid(current->parent);
1815 /* If the (new) signal is now blocked, requeue it. */
1816 if (sigismember(&current->blocked, signr)) {
1817 specific_send_sig_info(signr, info, current);
1818 signr = 0;
1821 return signr;
1824 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1825 struct pt_regs *regs, void *cookie)
1827 struct sighand_struct *sighand = current->sighand;
1828 struct signal_struct *signal = current->signal;
1829 int signr;
1831 relock:
1833 * We'll jump back here after any time we were stopped in TASK_STOPPED.
1834 * While in TASK_STOPPED, we were considered "frozen enough".
1835 * Now that we woke up, it's crucial if we're supposed to be
1836 * frozen that we freeze now before running anything substantial.
1838 try_to_freeze();
1840 spin_lock_irq(&sighand->siglock);
1842 * Every stopped thread goes here after wakeup. Check to see if
1843 * we should notify the parent, prepare_signal(SIGCONT) encodes
1844 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
1846 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
1847 int why = (signal->flags & SIGNAL_STOP_CONTINUED)
1848 ? CLD_CONTINUED : CLD_STOPPED;
1849 signal->flags &= ~SIGNAL_CLD_MASK;
1851 why = tracehook_notify_jctl(why, CLD_CONTINUED);
1852 spin_unlock_irq(&sighand->siglock);
1854 if (why) {
1855 read_lock(&tasklist_lock);
1856 do_notify_parent_cldstop(current->group_leader, why);
1857 read_unlock(&tasklist_lock);
1859 goto relock;
1862 for (;;) {
1863 struct k_sigaction *ka;
1865 * Tracing can induce an artifical signal and choose sigaction.
1866 * The return value in @signr determines the default action,
1867 * but @info->si_signo is the signal number we will report.
1869 signr = tracehook_get_signal(current, regs, info, return_ka);
1870 if (unlikely(signr < 0))
1871 goto relock;
1872 if (unlikely(signr != 0))
1873 ka = return_ka;
1874 else {
1875 if (unlikely(signal->group_stop_count > 0) &&
1876 do_signal_stop(0))
1877 goto relock;
1879 signr = dequeue_signal(current, &current->blocked,
1880 info);
1882 if (!signr)
1883 break; /* will return 0 */
1885 if (signr != SIGKILL) {
1886 signr = ptrace_signal(signr, info,
1887 regs, cookie);
1888 if (!signr)
1889 continue;
1892 ka = &sighand->action[signr-1];
1895 /* Trace actually delivered signals. */
1896 trace_signal_deliver(signr, info, ka);
1898 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1899 continue;
1900 if (ka->sa.sa_handler != SIG_DFL) {
1901 /* Run the handler. */
1902 *return_ka = *ka;
1904 if (ka->sa.sa_flags & SA_ONESHOT)
1905 ka->sa.sa_handler = SIG_DFL;
1907 break; /* will return non-zero "signr" value */
1911 * Now we are doing the default action for this signal.
1913 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1914 continue;
1917 * Global init gets no signals it doesn't want.
1918 * Container-init gets no signals it doesn't want from same
1919 * container.
1921 * Note that if global/container-init sees a sig_kernel_only()
1922 * signal here, the signal must have been generated internally
1923 * or must have come from an ancestor namespace. In either
1924 * case, the signal cannot be dropped.
1926 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
1927 !sig_kernel_only(signr))
1928 continue;
1930 if (sig_kernel_stop(signr)) {
1932 * The default action is to stop all threads in
1933 * the thread group. The job control signals
1934 * do nothing in an orphaned pgrp, but SIGSTOP
1935 * always works. Note that siglock needs to be
1936 * dropped during the call to is_orphaned_pgrp()
1937 * because of lock ordering with tasklist_lock.
1938 * This allows an intervening SIGCONT to be posted.
1939 * We need to check for that and bail out if necessary.
1941 if (signr != SIGSTOP) {
1942 spin_unlock_irq(&sighand->siglock);
1944 /* signals can be posted during this window */
1946 if (is_current_pgrp_orphaned())
1947 goto relock;
1949 spin_lock_irq(&sighand->siglock);
1952 if (likely(do_signal_stop(info->si_signo))) {
1953 /* It released the siglock. */
1954 goto relock;
1958 * We didn't actually stop, due to a race
1959 * with SIGCONT or something like that.
1961 continue;
1964 spin_unlock_irq(&sighand->siglock);
1967 * Anything else is fatal, maybe with a core dump.
1969 current->flags |= PF_SIGNALED;
1971 if (sig_kernel_coredump(signr)) {
1972 if (print_fatal_signals)
1973 print_fatal_signal(regs, info->si_signo);
1975 * If it was able to dump core, this kills all
1976 * other threads in the group and synchronizes with
1977 * their demise. If we lost the race with another
1978 * thread getting here, it set group_exit_code
1979 * first and our do_group_exit call below will use
1980 * that value and ignore the one we pass it.
1982 do_coredump(info->si_signo, info->si_signo, regs);
1986 * Death signals, no core dump.
1988 do_group_exit(info->si_signo);
1989 /* NOTREACHED */
1991 spin_unlock_irq(&sighand->siglock);
1992 return signr;
1995 void exit_signals(struct task_struct *tsk)
1997 int group_stop = 0;
1998 struct task_struct *t;
2000 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
2001 tsk->flags |= PF_EXITING;
2002 return;
2005 spin_lock_irq(&tsk->sighand->siglock);
2007 * From now this task is not visible for group-wide signals,
2008 * see wants_signal(), do_signal_stop().
2010 tsk->flags |= PF_EXITING;
2011 if (!signal_pending(tsk))
2012 goto out;
2014 /* It could be that __group_complete_signal() choose us to
2015 * notify about group-wide signal. Another thread should be
2016 * woken now to take the signal since we will not.
2018 for (t = tsk; (t = next_thread(t)) != tsk; )
2019 if (!signal_pending(t) && !(t->flags & PF_EXITING))
2020 recalc_sigpending_and_wake(t);
2022 if (unlikely(tsk->signal->group_stop_count) &&
2023 !--tsk->signal->group_stop_count) {
2024 tsk->signal->flags = SIGNAL_STOP_STOPPED;
2025 group_stop = tracehook_notify_jctl(CLD_STOPPED, CLD_STOPPED);
2027 out:
2028 spin_unlock_irq(&tsk->sighand->siglock);
2030 if (unlikely(group_stop)) {
2031 read_lock(&tasklist_lock);
2032 do_notify_parent_cldstop(tsk, group_stop);
2033 read_unlock(&tasklist_lock);
2037 EXPORT_SYMBOL(recalc_sigpending);
2038 EXPORT_SYMBOL_GPL(dequeue_signal);
2039 EXPORT_SYMBOL(flush_signals);
2040 EXPORT_SYMBOL(force_sig);
2041 EXPORT_SYMBOL(send_sig);
2042 EXPORT_SYMBOL(send_sig_info);
2043 EXPORT_SYMBOL(sigprocmask);
2044 EXPORT_SYMBOL(block_all_signals);
2045 EXPORT_SYMBOL(unblock_all_signals);
2049 * System call entry points.
2052 SYSCALL_DEFINE0(restart_syscall)
2054 struct restart_block *restart = &current_thread_info()->restart_block;
2055 return restart->fn(restart);
2058 long do_no_restart_syscall(struct restart_block *param)
2060 return -EINTR;
2064 * We don't need to get the kernel lock - this is all local to this
2065 * particular thread.. (and that's good, because this is _heavily_
2066 * used by various programs)
2070 * This is also useful for kernel threads that want to temporarily
2071 * (or permanently) block certain signals.
2073 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2074 * interface happily blocks "unblockable" signals like SIGKILL
2075 * and friends.
2077 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2079 int error;
2081 spin_lock_irq(&current->sighand->siglock);
2082 if (oldset)
2083 *oldset = current->blocked;
2085 error = 0;
2086 switch (how) {
2087 case SIG_BLOCK:
2088 sigorsets(&current->blocked, &current->blocked, set);
2089 break;
2090 case SIG_UNBLOCK:
2091 signandsets(&current->blocked, &current->blocked, set);
2092 break;
2093 case SIG_SETMASK:
2094 current->blocked = *set;
2095 break;
2096 default:
2097 error = -EINVAL;
2099 recalc_sigpending();
2100 spin_unlock_irq(&current->sighand->siglock);
2102 return error;
2105 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, set,
2106 sigset_t __user *, oset, size_t, sigsetsize)
2108 int error = -EINVAL;
2109 sigset_t old_set, new_set;
2111 /* XXX: Don't preclude handling different sized sigset_t's. */
2112 if (sigsetsize != sizeof(sigset_t))
2113 goto out;
2115 if (set) {
2116 error = -EFAULT;
2117 if (copy_from_user(&new_set, set, sizeof(*set)))
2118 goto out;
2119 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2121 error = sigprocmask(how, &new_set, &old_set);
2122 if (error)
2123 goto out;
2124 if (oset)
2125 goto set_old;
2126 } else if (oset) {
2127 spin_lock_irq(&current->sighand->siglock);
2128 old_set = current->blocked;
2129 spin_unlock_irq(&current->sighand->siglock);
2131 set_old:
2132 error = -EFAULT;
2133 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2134 goto out;
2136 error = 0;
2137 out:
2138 return error;
2141 long do_sigpending(void __user *set, unsigned long sigsetsize)
2143 long error = -EINVAL;
2144 sigset_t pending;
2146 if (sigsetsize > sizeof(sigset_t))
2147 goto out;
2149 spin_lock_irq(&current->sighand->siglock);
2150 sigorsets(&pending, &current->pending.signal,
2151 &current->signal->shared_pending.signal);
2152 spin_unlock_irq(&current->sighand->siglock);
2154 /* Outside the lock because only this thread touches it. */
2155 sigandsets(&pending, &current->blocked, &pending);
2157 error = -EFAULT;
2158 if (!copy_to_user(set, &pending, sigsetsize))
2159 error = 0;
2161 out:
2162 return error;
2165 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, set, size_t, sigsetsize)
2167 return do_sigpending(set, sigsetsize);
2170 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2172 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2174 int err;
2176 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2177 return -EFAULT;
2178 if (from->si_code < 0)
2179 return __copy_to_user(to, from, sizeof(siginfo_t))
2180 ? -EFAULT : 0;
2182 * If you change siginfo_t structure, please be sure
2183 * this code is fixed accordingly.
2184 * Please remember to update the signalfd_copyinfo() function
2185 * inside fs/signalfd.c too, in case siginfo_t changes.
2186 * It should never copy any pad contained in the structure
2187 * to avoid security leaks, but must copy the generic
2188 * 3 ints plus the relevant union member.
2190 err = __put_user(from->si_signo, &to->si_signo);
2191 err |= __put_user(from->si_errno, &to->si_errno);
2192 err |= __put_user((short)from->si_code, &to->si_code);
2193 switch (from->si_code & __SI_MASK) {
2194 case __SI_KILL:
2195 err |= __put_user(from->si_pid, &to->si_pid);
2196 err |= __put_user(from->si_uid, &to->si_uid);
2197 break;
2198 case __SI_TIMER:
2199 err |= __put_user(from->si_tid, &to->si_tid);
2200 err |= __put_user(from->si_overrun, &to->si_overrun);
2201 err |= __put_user(from->si_ptr, &to->si_ptr);
2202 break;
2203 case __SI_POLL:
2204 err |= __put_user(from->si_band, &to->si_band);
2205 err |= __put_user(from->si_fd, &to->si_fd);
2206 break;
2207 case __SI_FAULT:
2208 err |= __put_user(from->si_addr, &to->si_addr);
2209 #ifdef __ARCH_SI_TRAPNO
2210 err |= __put_user(from->si_trapno, &to->si_trapno);
2211 #endif
2212 break;
2213 case __SI_CHLD:
2214 err |= __put_user(from->si_pid, &to->si_pid);
2215 err |= __put_user(from->si_uid, &to->si_uid);
2216 err |= __put_user(from->si_status, &to->si_status);
2217 err |= __put_user(from->si_utime, &to->si_utime);
2218 err |= __put_user(from->si_stime, &to->si_stime);
2219 break;
2220 case __SI_RT: /* This is not generated by the kernel as of now. */
2221 case __SI_MESGQ: /* But this is */
2222 err |= __put_user(from->si_pid, &to->si_pid);
2223 err |= __put_user(from->si_uid, &to->si_uid);
2224 err |= __put_user(from->si_ptr, &to->si_ptr);
2225 break;
2226 default: /* this is just in case for now ... */
2227 err |= __put_user(from->si_pid, &to->si_pid);
2228 err |= __put_user(from->si_uid, &to->si_uid);
2229 break;
2231 return err;
2234 #endif
2236 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
2237 siginfo_t __user *, uinfo, const struct timespec __user *, uts,
2238 size_t, sigsetsize)
2240 int ret, sig;
2241 sigset_t these;
2242 struct timespec ts;
2243 siginfo_t info;
2244 long timeout = 0;
2246 /* XXX: Don't preclude handling different sized sigset_t's. */
2247 if (sigsetsize != sizeof(sigset_t))
2248 return -EINVAL;
2250 if (copy_from_user(&these, uthese, sizeof(these)))
2251 return -EFAULT;
2254 * Invert the set of allowed signals to get those we
2255 * want to block.
2257 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2258 signotset(&these);
2260 if (uts) {
2261 if (copy_from_user(&ts, uts, sizeof(ts)))
2262 return -EFAULT;
2263 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2264 || ts.tv_sec < 0)
2265 return -EINVAL;
2268 spin_lock_irq(&current->sighand->siglock);
2269 sig = dequeue_signal(current, &these, &info);
2270 if (!sig) {
2271 timeout = MAX_SCHEDULE_TIMEOUT;
2272 if (uts)
2273 timeout = (timespec_to_jiffies(&ts)
2274 + (ts.tv_sec || ts.tv_nsec));
2276 if (timeout) {
2277 /* None ready -- temporarily unblock those we're
2278 * interested while we are sleeping in so that we'll
2279 * be awakened when they arrive. */
2280 current->real_blocked = current->blocked;
2281 sigandsets(&current->blocked, &current->blocked, &these);
2282 recalc_sigpending();
2283 spin_unlock_irq(&current->sighand->siglock);
2285 timeout = schedule_timeout_interruptible(timeout);
2287 spin_lock_irq(&current->sighand->siglock);
2288 sig = dequeue_signal(current, &these, &info);
2289 current->blocked = current->real_blocked;
2290 siginitset(&current->real_blocked, 0);
2291 recalc_sigpending();
2294 spin_unlock_irq(&current->sighand->siglock);
2296 if (sig) {
2297 ret = sig;
2298 if (uinfo) {
2299 if (copy_siginfo_to_user(uinfo, &info))
2300 ret = -EFAULT;
2302 } else {
2303 ret = -EAGAIN;
2304 if (timeout)
2305 ret = -EINTR;
2308 return ret;
2311 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
2313 struct siginfo info;
2315 info.si_signo = sig;
2316 info.si_errno = 0;
2317 info.si_code = SI_USER;
2318 info.si_pid = task_tgid_vnr(current);
2319 info.si_uid = current_uid();
2321 return kill_something_info(sig, &info, pid);
2324 static int
2325 do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
2327 struct task_struct *p;
2328 int error = -ESRCH;
2330 rcu_read_lock();
2331 p = find_task_by_vpid(pid);
2332 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2333 error = check_kill_permission(sig, info, p);
2335 * The null signal is a permissions and process existence
2336 * probe. No signal is actually delivered.
2338 if (!error && sig) {
2339 error = do_send_sig_info(sig, info, p, false);
2341 * If lock_task_sighand() failed we pretend the task
2342 * dies after receiving the signal. The window is tiny,
2343 * and the signal is private anyway.
2345 if (unlikely(error == -ESRCH))
2346 error = 0;
2349 rcu_read_unlock();
2351 return error;
2354 static int do_tkill(pid_t tgid, pid_t pid, int sig)
2356 struct siginfo info;
2358 info.si_signo = sig;
2359 info.si_errno = 0;
2360 info.si_code = SI_TKILL;
2361 info.si_pid = task_tgid_vnr(current);
2362 info.si_uid = current_uid();
2364 return do_send_specific(tgid, pid, sig, &info);
2368 * sys_tgkill - send signal to one specific thread
2369 * @tgid: the thread group ID of the thread
2370 * @pid: the PID of the thread
2371 * @sig: signal to be sent
2373 * This syscall also checks the @tgid and returns -ESRCH even if the PID
2374 * exists but it's not belonging to the target process anymore. This
2375 * method solves the problem of threads exiting and PIDs getting reused.
2377 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
2379 /* This is only valid for single tasks */
2380 if (pid <= 0 || tgid <= 0)
2381 return -EINVAL;
2383 return do_tkill(tgid, pid, sig);
2387 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2389 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
2391 /* This is only valid for single tasks */
2392 if (pid <= 0)
2393 return -EINVAL;
2395 return do_tkill(0, pid, sig);
2398 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
2399 siginfo_t __user *, uinfo)
2401 siginfo_t info;
2403 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2404 return -EFAULT;
2406 /* Not even root can pretend to send signals from the kernel.
2407 Nor can they impersonate a kill(), which adds source info. */
2408 if (info.si_code >= 0)
2409 return -EPERM;
2410 info.si_signo = sig;
2412 /* POSIX.1b doesn't mention process groups. */
2413 return kill_proc_info(sig, &info, pid);
2416 long do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
2418 /* This is only valid for single tasks */
2419 if (pid <= 0 || tgid <= 0)
2420 return -EINVAL;
2422 /* Not even root can pretend to send signals from the kernel.
2423 Nor can they impersonate a kill(), which adds source info. */
2424 if (info->si_code >= 0)
2425 return -EPERM;
2426 info->si_signo = sig;
2428 return do_send_specific(tgid, pid, sig, info);
2431 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
2432 siginfo_t __user *, uinfo)
2434 siginfo_t info;
2436 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2437 return -EFAULT;
2439 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
2442 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2444 struct task_struct *t = current;
2445 struct k_sigaction *k;
2446 sigset_t mask;
2448 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2449 return -EINVAL;
2451 k = &t->sighand->action[sig-1];
2453 spin_lock_irq(&current->sighand->siglock);
2454 if (oact)
2455 *oact = *k;
2457 if (act) {
2458 sigdelsetmask(&act->sa.sa_mask,
2459 sigmask(SIGKILL) | sigmask(SIGSTOP));
2460 *k = *act;
2462 * POSIX 3.3.1.3:
2463 * "Setting a signal action to SIG_IGN for a signal that is
2464 * pending shall cause the pending signal to be discarded,
2465 * whether or not it is blocked."
2467 * "Setting a signal action to SIG_DFL for a signal that is
2468 * pending and whose default action is to ignore the signal
2469 * (for example, SIGCHLD), shall cause the pending signal to
2470 * be discarded, whether or not it is blocked"
2472 if (sig_handler_ignored(sig_handler(t, sig), sig)) {
2473 sigemptyset(&mask);
2474 sigaddset(&mask, sig);
2475 rm_from_queue_full(&mask, &t->signal->shared_pending);
2476 do {
2477 rm_from_queue_full(&mask, &t->pending);
2478 t = next_thread(t);
2479 } while (t != current);
2483 spin_unlock_irq(&current->sighand->siglock);
2484 return 0;
2487 int
2488 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2490 stack_t oss;
2491 int error;
2493 oss.ss_sp = (void __user *) current->sas_ss_sp;
2494 oss.ss_size = current->sas_ss_size;
2495 oss.ss_flags = sas_ss_flags(sp);
2497 if (uss) {
2498 void __user *ss_sp;
2499 size_t ss_size;
2500 int ss_flags;
2502 error = -EFAULT;
2503 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
2504 goto out;
2505 error = __get_user(ss_sp, &uss->ss_sp) |
2506 __get_user(ss_flags, &uss->ss_flags) |
2507 __get_user(ss_size, &uss->ss_size);
2508 if (error)
2509 goto out;
2511 error = -EPERM;
2512 if (on_sig_stack(sp))
2513 goto out;
2515 error = -EINVAL;
2518 * Note - this code used to test ss_flags incorrectly
2519 * old code may have been written using ss_flags==0
2520 * to mean ss_flags==SS_ONSTACK (as this was the only
2521 * way that worked) - this fix preserves that older
2522 * mechanism
2524 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2525 goto out;
2527 if (ss_flags == SS_DISABLE) {
2528 ss_size = 0;
2529 ss_sp = NULL;
2530 } else {
2531 error = -ENOMEM;
2532 if (ss_size < MINSIGSTKSZ)
2533 goto out;
2536 current->sas_ss_sp = (unsigned long) ss_sp;
2537 current->sas_ss_size = ss_size;
2540 error = 0;
2541 if (uoss) {
2542 error = -EFAULT;
2543 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
2544 goto out;
2545 error = __put_user(oss.ss_sp, &uoss->ss_sp) |
2546 __put_user(oss.ss_size, &uoss->ss_size) |
2547 __put_user(oss.ss_flags, &uoss->ss_flags);
2550 out:
2551 return error;
2554 #ifdef __ARCH_WANT_SYS_SIGPENDING
2556 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
2558 return do_sigpending(set, sizeof(*set));
2561 #endif
2563 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2564 /* Some platforms have their own version with special arguments others
2565 support only sys_rt_sigprocmask. */
2567 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, set,
2568 old_sigset_t __user *, oset)
2570 int error;
2571 old_sigset_t old_set, new_set;
2573 if (set) {
2574 error = -EFAULT;
2575 if (copy_from_user(&new_set, set, sizeof(*set)))
2576 goto out;
2577 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2579 spin_lock_irq(&current->sighand->siglock);
2580 old_set = current->blocked.sig[0];
2582 error = 0;
2583 switch (how) {
2584 default:
2585 error = -EINVAL;
2586 break;
2587 case SIG_BLOCK:
2588 sigaddsetmask(&current->blocked, new_set);
2589 break;
2590 case SIG_UNBLOCK:
2591 sigdelsetmask(&current->blocked, new_set);
2592 break;
2593 case SIG_SETMASK:
2594 current->blocked.sig[0] = new_set;
2595 break;
2598 recalc_sigpending();
2599 spin_unlock_irq(&current->sighand->siglock);
2600 if (error)
2601 goto out;
2602 if (oset)
2603 goto set_old;
2604 } else if (oset) {
2605 old_set = current->blocked.sig[0];
2606 set_old:
2607 error = -EFAULT;
2608 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2609 goto out;
2611 error = 0;
2612 out:
2613 return error;
2615 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2617 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2618 SYSCALL_DEFINE4(rt_sigaction, int, sig,
2619 const struct sigaction __user *, act,
2620 struct sigaction __user *, oact,
2621 size_t, sigsetsize)
2623 struct k_sigaction new_sa, old_sa;
2624 int ret = -EINVAL;
2626 /* XXX: Don't preclude handling different sized sigset_t's. */
2627 if (sigsetsize != sizeof(sigset_t))
2628 goto out;
2630 if (act) {
2631 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2632 return -EFAULT;
2635 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2637 if (!ret && oact) {
2638 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2639 return -EFAULT;
2641 out:
2642 return ret;
2644 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2646 #ifdef __ARCH_WANT_SYS_SGETMASK
2649 * For backwards compatibility. Functionality superseded by sigprocmask.
2651 SYSCALL_DEFINE0(sgetmask)
2653 /* SMP safe */
2654 return current->blocked.sig[0];
2657 SYSCALL_DEFINE1(ssetmask, int, newmask)
2659 int old;
2661 spin_lock_irq(&current->sighand->siglock);
2662 old = current->blocked.sig[0];
2664 siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2665 sigmask(SIGSTOP)));
2666 recalc_sigpending();
2667 spin_unlock_irq(&current->sighand->siglock);
2669 return old;
2671 #endif /* __ARCH_WANT_SGETMASK */
2673 #ifdef __ARCH_WANT_SYS_SIGNAL
2675 * For backwards compatibility. Functionality superseded by sigaction.
2677 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
2679 struct k_sigaction new_sa, old_sa;
2680 int ret;
2682 new_sa.sa.sa_handler = handler;
2683 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2684 sigemptyset(&new_sa.sa.sa_mask);
2686 ret = do_sigaction(sig, &new_sa, &old_sa);
2688 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2690 #endif /* __ARCH_WANT_SYS_SIGNAL */
2692 #ifdef __ARCH_WANT_SYS_PAUSE
2694 SYSCALL_DEFINE0(pause)
2696 current->state = TASK_INTERRUPTIBLE;
2697 schedule();
2698 return -ERESTARTNOHAND;
2701 #endif
2703 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2704 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
2706 sigset_t newset;
2708 /* XXX: Don't preclude handling different sized sigset_t's. */
2709 if (sigsetsize != sizeof(sigset_t))
2710 return -EINVAL;
2712 if (copy_from_user(&newset, unewset, sizeof(newset)))
2713 return -EFAULT;
2714 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2716 spin_lock_irq(&current->sighand->siglock);
2717 current->saved_sigmask = current->blocked;
2718 current->blocked = newset;
2719 recalc_sigpending();
2720 spin_unlock_irq(&current->sighand->siglock);
2722 current->state = TASK_INTERRUPTIBLE;
2723 schedule();
2724 set_restore_sigmask();
2725 return -ERESTARTNOHAND;
2727 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2729 __attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2731 return NULL;
2734 void __init signals_init(void)
2736 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);