1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/slab.h>
14#include <linux/export.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/coredump.h>
21#include <linux/security.h>
22#include <linux/syscalls.h>
23#include <linux/ptrace.h>
24#include <linux/signal.h>
25#include <linux/signalfd.h>
26#include <linux/ratelimit.h>
27#include <linux/tracehook.h>
28#include <linux/capability.h>
29#include <linux/freezer.h>
30#include <linux/pid_namespace.h>
31#include <linux/nsproxy.h>
32#include <linux/user_namespace.h>
33#include <linux/uprobes.h>
34#include <linux/compat.h>
35#include <linux/cn_proc.h>
36#include <linux/compiler.h>
37
38#define CREATE_TRACE_POINTS
39#include <trace/events/signal.h>
40
41#include <asm/param.h>
42#include <asm/uaccess.h>
43#include <asm/unistd.h>
44#include <asm/siginfo.h>
45#include <asm/cacheflush.h>
46#include "audit.h"
47
48
49
50
51
52static struct kmem_cache *sigqueue_cachep;
53
54int print_fatal_signals __read_mostly;
55
56static void __user *sig_handler(struct task_struct *t, int sig)
57{
58 return t->sighand->action[sig - 1].sa.sa_handler;
59}
60
61static int sig_handler_ignored(void __user *handler, int sig)
62{
63
64 return handler == SIG_IGN ||
65 (handler == SIG_DFL && sig_kernel_ignore(sig));
66}
67
68static int sig_task_ignored(struct task_struct *t, int sig, bool force)
69{
70 void __user *handler;
71
72 handler = sig_handler(t, sig);
73
74 if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
75 handler == SIG_DFL && !force)
76 return 1;
77
78 return sig_handler_ignored(handler, sig);
79}
80
81static int sig_ignored(struct task_struct *t, int sig, bool force)
82{
83
84
85
86
87
88 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
89 return 0;
90
91 if (!sig_task_ignored(t, sig, force))
92 return 0;
93
94
95
96
97 return !t->ptrace;
98}
99
100
101
102
103
104static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
105{
106 unsigned long ready;
107 long i;
108
109 switch (_NSIG_WORDS) {
110 default:
111 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
112 ready |= signal->sig[i] &~ blocked->sig[i];
113 break;
114
115 case 4: ready = signal->sig[3] &~ blocked->sig[3];
116 ready |= signal->sig[2] &~ blocked->sig[2];
117 ready |= signal->sig[1] &~ blocked->sig[1];
118 ready |= signal->sig[0] &~ blocked->sig[0];
119 break;
120
121 case 2: ready = signal->sig[1] &~ blocked->sig[1];
122 ready |= signal->sig[0] &~ blocked->sig[0];
123 break;
124
125 case 1: ready = signal->sig[0] &~ blocked->sig[0];
126 }
127 return ready != 0;
128}
129
130#define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
131
132static int recalc_sigpending_tsk(struct task_struct *t)
133{
134 if ((t->jobctl & JOBCTL_PENDING_MASK) ||
135 PENDING(&t->pending, &t->blocked) ||
136 PENDING(&t->signal->shared_pending, &t->blocked)) {
137 set_tsk_thread_flag(t, TIF_SIGPENDING);
138 return 1;
139 }
140
141
142
143
144
145 return 0;
146}
147
148
149
150
151
152void recalc_sigpending_and_wake(struct task_struct *t)
153{
154 if (recalc_sigpending_tsk(t))
155 signal_wake_up(t, 0);
156}
157
158void recalc_sigpending(void)
159{
160 if (!recalc_sigpending_tsk(current) && !freezing(current))
161 clear_thread_flag(TIF_SIGPENDING);
162
163}
164
165
166
167#define SYNCHRONOUS_MASK \
168 (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
169 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
170
171int next_signal(struct sigpending *pending, sigset_t *mask)
172{
173 unsigned long i, *s, *m, x;
174 int sig = 0;
175
176 s = pending->signal.sig;
177 m = mask->sig;
178
179
180
181
182
183 x = *s &~ *m;
184 if (x) {
185 if (x & SYNCHRONOUS_MASK)
186 x &= SYNCHRONOUS_MASK;
187 sig = ffz(~x) + 1;
188 return sig;
189 }
190
191 switch (_NSIG_WORDS) {
192 default:
193 for (i = 1; i < _NSIG_WORDS; ++i) {
194 x = *++s &~ *++m;
195 if (!x)
196 continue;
197 sig = ffz(~x) + i*_NSIG_BPW + 1;
198 break;
199 }
200 break;
201
202 case 2:
203 x = s[1] &~ m[1];
204 if (!x)
205 break;
206 sig = ffz(~x) + _NSIG_BPW + 1;
207 break;
208
209 case 1:
210
211 break;
212 }
213
214 return sig;
215}
216
217static inline void print_dropped_signal(int sig)
218{
219 static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
220
221 if (!print_fatal_signals)
222 return;
223
224 if (!__ratelimit(&ratelimit_state))
225 return;
226
227 printk(KERN_INFO "%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
228 current->comm, current->pid, sig);
229}
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
249{
250 BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
251 JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
252 BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
253
254 if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
255 return false;
256
257 if (mask & JOBCTL_STOP_SIGMASK)
258 task->jobctl &= ~JOBCTL_STOP_SIGMASK;
259
260 task->jobctl |= mask;
261 return true;
262}
263
264
265
266
267
268
269
270
271
272
273
274
275
276void task_clear_jobctl_trapping(struct task_struct *task)
277{
278 if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
279 task->jobctl &= ~JOBCTL_TRAPPING;
280 smp_mb();
281 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
282 }
283}
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
301{
302 BUG_ON(mask & ~JOBCTL_PENDING_MASK);
303
304 if (mask & JOBCTL_STOP_PENDING)
305 mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
306
307 task->jobctl &= ~mask;
308
309 if (!(task->jobctl & JOBCTL_PENDING_MASK))
310 task_clear_jobctl_trapping(task);
311}
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329static bool task_participate_group_stop(struct task_struct *task)
330{
331 struct signal_struct *sig = task->signal;
332 bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
333
334 WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
335
336 task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
337
338 if (!consume)
339 return false;
340
341 if (!WARN_ON_ONCE(sig->group_stop_count == 0))
342 sig->group_stop_count--;
343
344
345
346
347
348 if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
349 sig->flags = SIGNAL_STOP_STOPPED;
350 return true;
351 }
352 return false;
353}
354
355
356
357
358
359
360static struct sigqueue *
361__sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
362{
363 struct sigqueue *q = NULL;
364 struct user_struct *user;
365
366
367
368
369
370 rcu_read_lock();
371 user = get_uid(__task_cred(t)->user);
372 atomic_inc(&user->sigpending);
373 rcu_read_unlock();
374
375 if (override_rlimit ||
376 atomic_read(&user->sigpending) <=
377 task_rlimit(t, RLIMIT_SIGPENDING)) {
378 q = kmem_cache_alloc(sigqueue_cachep, flags);
379 } else {
380 print_dropped_signal(sig);
381 }
382
383 if (unlikely(q == NULL)) {
384 atomic_dec(&user->sigpending);
385 free_uid(user);
386 } else {
387 INIT_LIST_HEAD(&q->list);
388 q->flags = 0;
389 q->user = user;
390 }
391
392 return q;
393}
394
395static void __sigqueue_free(struct sigqueue *q)
396{
397 if (q->flags & SIGQUEUE_PREALLOC)
398 return;
399 atomic_dec(&q->user->sigpending);
400 free_uid(q->user);
401 kmem_cache_free(sigqueue_cachep, q);
402}
403
404void flush_sigqueue(struct sigpending *queue)
405{
406 struct sigqueue *q;
407
408 sigemptyset(&queue->signal);
409 while (!list_empty(&queue->list)) {
410 q = list_entry(queue->list.next, struct sigqueue , list);
411 list_del_init(&q->list);
412 __sigqueue_free(q);
413 }
414}
415
416
417
418
419void flush_signals(struct task_struct *t)
420{
421 unsigned long flags;
422
423 spin_lock_irqsave(&t->sighand->siglock, flags);
424 clear_tsk_thread_flag(t, TIF_SIGPENDING);
425 flush_sigqueue(&t->pending);
426 flush_sigqueue(&t->signal->shared_pending);
427 spin_unlock_irqrestore(&t->sighand->siglock, flags);
428}
429
430static void __flush_itimer_signals(struct sigpending *pending)
431{
432 sigset_t signal, retain;
433 struct sigqueue *q, *n;
434
435 signal = pending->signal;
436 sigemptyset(&retain);
437
438 list_for_each_entry_safe(q, n, &pending->list, list) {
439 int sig = q->info.si_signo;
440
441 if (likely(q->info.si_code != SI_TIMER)) {
442 sigaddset(&retain, sig);
443 } else {
444 sigdelset(&signal, sig);
445 list_del_init(&q->list);
446 __sigqueue_free(q);
447 }
448 }
449
450 sigorsets(&pending->signal, &signal, &retain);
451}
452
453void flush_itimer_signals(void)
454{
455 struct task_struct *tsk = current;
456 unsigned long flags;
457
458 spin_lock_irqsave(&tsk->sighand->siglock, flags);
459 __flush_itimer_signals(&tsk->pending);
460 __flush_itimer_signals(&tsk->signal->shared_pending);
461 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
462}
463
464void ignore_signals(struct task_struct *t)
465{
466 int i;
467
468 for (i = 0; i < _NSIG; ++i)
469 t->sighand->action[i].sa.sa_handler = SIG_IGN;
470
471 flush_signals(t);
472}
473
474
475
476
477
478void
479flush_signal_handlers(struct task_struct *t, int force_default)
480{
481 int i;
482 struct k_sigaction *ka = &t->sighand->action[0];
483 for (i = _NSIG ; i != 0 ; i--) {
484 if (force_default || ka->sa.sa_handler != SIG_IGN)
485 ka->sa.sa_handler = SIG_DFL;
486 ka->sa.sa_flags = 0;
487#ifdef __ARCH_HAS_SA_RESTORER
488 ka->sa.sa_restorer = NULL;
489#endif
490 sigemptyset(&ka->sa.sa_mask);
491 ka++;
492 }
493}
494
495int unhandled_signal(struct task_struct *tsk, int sig)
496{
497 void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
498 if (is_global_init(tsk))
499 return 1;
500 if (handler != SIG_IGN && handler != SIG_DFL)
501 return 0;
502
503 return !tsk->ptrace;
504}
505
506static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
507{
508 struct sigqueue *q, *first = NULL;
509
510
511
512
513
514 list_for_each_entry(q, &list->list, list) {
515 if (q->info.si_signo == sig) {
516 if (first)
517 goto still_pending;
518 first = q;
519 }
520 }
521
522 sigdelset(&list->signal, sig);
523
524 if (first) {
525still_pending:
526 list_del_init(&first->list);
527 copy_siginfo(info, &first->info);
528 __sigqueue_free(first);
529 } else {
530
531
532
533
534
535 info->si_signo = sig;
536 info->si_errno = 0;
537 info->si_code = SI_USER;
538 info->si_pid = 0;
539 info->si_uid = 0;
540 }
541}
542
543static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
544 siginfo_t *info)
545{
546 int sig = next_signal(pending, mask);
547
548 if (sig)
549 collect_signal(sig, pending, info);
550 return sig;
551}
552
553
554
555
556
557
558
559int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
560{
561 int signr;
562
563
564
565
566 signr = __dequeue_signal(&tsk->pending, mask, info);
567 if (!signr) {
568 signr = __dequeue_signal(&tsk->signal->shared_pending,
569 mask, info);
570
571
572
573
574
575
576
577
578
579
580
581
582
583 if (unlikely(signr == SIGALRM)) {
584 struct hrtimer *tmr = &tsk->signal->real_timer;
585
586 if (!hrtimer_is_queued(tmr) &&
587 tsk->signal->it_real_incr.tv64 != 0) {
588 hrtimer_forward(tmr, tmr->base->get_time(),
589 tsk->signal->it_real_incr);
590 hrtimer_restart(tmr);
591 }
592 }
593 }
594
595 recalc_sigpending();
596 if (!signr)
597 return 0;
598
599 if (unlikely(sig_kernel_stop(signr))) {
600
601
602
603
604
605
606
607
608
609
610
611
612 current->jobctl |= JOBCTL_STOP_DEQUEUED;
613 }
614 if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
615
616
617
618
619
620
621 spin_unlock(&tsk->sighand->siglock);
622 do_schedule_next_timer(info);
623 spin_lock(&tsk->sighand->siglock);
624 }
625 return signr;
626}
627
628
629
630
631
632
633
634
635
636
637
638
639void signal_wake_up_state(struct task_struct *t, unsigned int state)
640{
641 set_tsk_thread_flag(t, TIF_SIGPENDING);
642
643
644
645
646
647
648
649 if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
650 kick_process(t);
651}
652
653
654
655
656
657
658
659static int flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
660{
661 struct sigqueue *q, *n;
662 sigset_t m;
663
664 sigandsets(&m, mask, &s->signal);
665 if (sigisemptyset(&m))
666 return 0;
667
668 sigandnsets(&s->signal, &s->signal, mask);
669 list_for_each_entry_safe(q, n, &s->list, list) {
670 if (sigismember(mask, q->info.si_signo)) {
671 list_del_init(&q->list);
672 __sigqueue_free(q);
673 }
674 }
675 return 1;
676}
677
678static inline int is_si_special(const struct siginfo *info)
679{
680 return info <= SEND_SIG_FORCED;
681}
682
683static inline bool si_fromuser(const struct siginfo *info)
684{
685 return info == SEND_SIG_NOINFO ||
686 (!is_si_special(info) && SI_FROMUSER(info));
687}
688
689
690
691
692static int kill_ok_by_cred(struct task_struct *t)
693{
694 const struct cred *cred = current_cred();
695 const struct cred *tcred = __task_cred(t);
696
697 if (uid_eq(cred->euid, tcred->suid) ||
698 uid_eq(cred->euid, tcred->uid) ||
699 uid_eq(cred->uid, tcred->suid) ||
700 uid_eq(cred->uid, tcred->uid))
701 return 1;
702
703 if (ns_capable(tcred->user_ns, CAP_KILL))
704 return 1;
705
706 return 0;
707}
708
709
710
711
712
713static int check_kill_permission(int sig, struct siginfo *info,
714 struct task_struct *t)
715{
716 struct pid *sid;
717 int error;
718
719 if (!valid_signal(sig))
720 return -EINVAL;
721
722 if (!si_fromuser(info))
723 return 0;
724
725 error = audit_signal_info(sig, t);
726 if (error)
727 return error;
728
729 if (!same_thread_group(current, t) &&
730 !kill_ok_by_cred(t)) {
731 switch (sig) {
732 case SIGCONT:
733 sid = task_session(t);
734
735
736
737
738 if (!sid || sid == task_session(current))
739 break;
740 default:
741 return -EPERM;
742 }
743 }
744
745 return security_task_kill(t, info, sig, 0);
746}
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765static void ptrace_trap_notify(struct task_struct *t)
766{
767 WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
768 assert_spin_locked(&t->sighand->siglock);
769
770 task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
771 ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
772}
773
774
775
776
777
778
779
780
781
782
783
784static bool prepare_signal(int sig, struct task_struct *p, bool force)
785{
786 struct signal_struct *signal = p->signal;
787 struct task_struct *t;
788 sigset_t flush;
789
790 if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
791 if (!(signal->flags & SIGNAL_GROUP_EXIT))
792 return sig == SIGKILL;
793
794
795
796 } else if (sig_kernel_stop(sig)) {
797
798
799
800 siginitset(&flush, sigmask(SIGCONT));
801 flush_sigqueue_mask(&flush, &signal->shared_pending);
802 for_each_thread(p, t)
803 flush_sigqueue_mask(&flush, &t->pending);
804 } else if (sig == SIGCONT) {
805 unsigned int why;
806
807
808
809 siginitset(&flush, SIG_KERNEL_STOP_MASK);
810 flush_sigqueue_mask(&flush, &signal->shared_pending);
811 for_each_thread(p, t) {
812 flush_sigqueue_mask(&flush, &t->pending);
813 task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
814 if (likely(!(t->ptrace & PT_SEIZED)))
815 wake_up_state(t, __TASK_STOPPED);
816 else
817 ptrace_trap_notify(t);
818 }
819
820
821
822
823
824
825
826
827
828 why = 0;
829 if (signal->flags & SIGNAL_STOP_STOPPED)
830 why |= SIGNAL_CLD_CONTINUED;
831 else if (signal->group_stop_count)
832 why |= SIGNAL_CLD_STOPPED;
833
834 if (why) {
835
836
837
838
839
840 signal->flags = why | SIGNAL_STOP_CONTINUED;
841 signal->group_stop_count = 0;
842 signal->group_exit_code = 0;
843 }
844 }
845
846 return !sig_ignored(p, sig, force);
847}
848
849
850
851
852
853
854
855
856
857static inline int wants_signal(int sig, struct task_struct *p)
858{
859 if (sigismember(&p->blocked, sig))
860 return 0;
861 if (p->flags & PF_EXITING)
862 return 0;
863 if (sig == SIGKILL)
864 return 1;
865 if (task_is_stopped_or_traced(p))
866 return 0;
867 return task_curr(p) || !signal_pending(p);
868}
869
870static void complete_signal(int sig, struct task_struct *p, int group)
871{
872 struct signal_struct *signal = p->signal;
873 struct task_struct *t;
874
875
876
877
878
879
880
881 if (wants_signal(sig, p))
882 t = p;
883 else if (!group || thread_group_empty(p))
884
885
886
887
888 return;
889 else {
890
891
892
893 t = signal->curr_target;
894 while (!wants_signal(sig, t)) {
895 t = next_thread(t);
896 if (t == signal->curr_target)
897
898
899
900
901
902 return;
903 }
904 signal->curr_target = t;
905 }
906
907
908
909
910
911 if (sig_fatal(p, sig) &&
912 !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
913 !sigismember(&t->real_blocked, sig) &&
914 (sig == SIGKILL || !t->ptrace)) {
915
916
917
918 if (!sig_kernel_coredump(sig)) {
919
920
921
922
923
924
925 signal->flags = SIGNAL_GROUP_EXIT;
926 signal->group_exit_code = sig;
927 signal->group_stop_count = 0;
928 t = p;
929 do {
930 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
931 sigaddset(&t->pending.signal, SIGKILL);
932 signal_wake_up(t, 1);
933 } while_each_thread(p, t);
934 return;
935 }
936 }
937
938
939
940
941
942 signal_wake_up(t, sig == SIGKILL);
943 return;
944}
945
946static inline int legacy_queue(struct sigpending *signals, int sig)
947{
948 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
949}
950
951#ifdef CONFIG_USER_NS
952static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
953{
954 if (current_user_ns() == task_cred_xxx(t, user_ns))
955 return;
956
957 if (SI_FROMKERNEL(info))
958 return;
959
960 rcu_read_lock();
961 info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
962 make_kuid(current_user_ns(), info->si_uid));
963 rcu_read_unlock();
964}
965#else
966static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
967{
968 return;
969}
970#endif
971
972static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
973 int group, int from_ancestor_ns)
974{
975 struct sigpending *pending;
976 struct sigqueue *q;
977 int override_rlimit;
978 int ret = 0, result;
979
980 assert_spin_locked(&t->sighand->siglock);
981
982 result = TRACE_SIGNAL_IGNORED;
983 if (!prepare_signal(sig, t,
984 from_ancestor_ns || (info == SEND_SIG_FORCED)))
985 goto ret;
986
987 pending = group ? &t->signal->shared_pending : &t->pending;
988
989
990
991
992
993 result = TRACE_SIGNAL_ALREADY_PENDING;
994 if (legacy_queue(pending, sig))
995 goto ret;
996
997 result = TRACE_SIGNAL_DELIVERED;
998
999
1000
1001
1002 if (info == SEND_SIG_FORCED)
1003 goto out_set;
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014 if (sig < SIGRTMIN)
1015 override_rlimit = (is_si_special(info) || info->si_code >= 0);
1016 else
1017 override_rlimit = 0;
1018
1019 q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
1020 override_rlimit);
1021 if (q) {
1022 list_add_tail(&q->list, &pending->list);
1023 switch ((unsigned long) info) {
1024 case (unsigned long) SEND_SIG_NOINFO:
1025 q->info.si_signo = sig;
1026 q->info.si_errno = 0;
1027 q->info.si_code = SI_USER;
1028 q->info.si_pid = task_tgid_nr_ns(current,
1029 task_active_pid_ns(t));
1030 q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
1031 break;
1032 case (unsigned long) SEND_SIG_PRIV:
1033 q->info.si_signo = sig;
1034 q->info.si_errno = 0;
1035 q->info.si_code = SI_KERNEL;
1036 q->info.si_pid = 0;
1037 q->info.si_uid = 0;
1038 break;
1039 default:
1040 copy_siginfo(&q->info, info);
1041 if (from_ancestor_ns)
1042 q->info.si_pid = 0;
1043 break;
1044 }
1045
1046 userns_fixup_signal_uid(&q->info, t);
1047
1048 } else if (!is_si_special(info)) {
1049 if (sig >= SIGRTMIN && info->si_code != SI_USER) {
1050
1051
1052
1053
1054
1055 result = TRACE_SIGNAL_OVERFLOW_FAIL;
1056 ret = -EAGAIN;
1057 goto ret;
1058 } else {
1059
1060
1061
1062
1063 result = TRACE_SIGNAL_LOSE_INFO;
1064 }
1065 }
1066
1067out_set:
1068 signalfd_notify(t, sig);
1069 sigaddset(&pending->signal, sig);
1070 complete_signal(sig, t, group);
1071ret:
1072 trace_signal_generate(sig, info, t, group, result);
1073 return ret;
1074}
1075
1076static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
1077 int group)
1078{
1079 int from_ancestor_ns = 0;
1080
1081#ifdef CONFIG_PID_NS
1082 from_ancestor_ns = si_fromuser(info) &&
1083 !task_pid_nr_ns(current, task_active_pid_ns(t));
1084#endif
1085
1086 return __send_signal(sig, info, t, group, from_ancestor_ns);
1087}
1088
1089static void print_fatal_signal(int signr)
1090{
1091 struct pt_regs *regs = signal_pt_regs();
1092 printk(KERN_INFO "potentially unexpected fatal signal %d.\n", signr);
1093
1094#if defined(__i386__) && !defined(__arch_um__)
1095 printk(KERN_INFO "code at %08lx: ", regs->ip);
1096 {
1097 int i;
1098 for (i = 0; i < 16; i++) {
1099 unsigned char insn;
1100
1101 if (get_user(insn, (unsigned char *)(regs->ip + i)))
1102 break;
1103 printk(KERN_CONT "%02x ", insn);
1104 }
1105 }
1106 printk(KERN_CONT "\n");
1107#endif
1108 preempt_disable();
1109 show_regs(regs);
1110 preempt_enable();
1111}
1112
1113static int __init setup_print_fatal_signals(char *str)
1114{
1115 get_option (&str, &print_fatal_signals);
1116
1117 return 1;
1118}
1119
1120__setup("print-fatal-signals=", setup_print_fatal_signals);
1121
1122int
1123__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1124{
1125 return send_signal(sig, info, p, 1);
1126}
1127
1128static int
1129specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1130{
1131 return send_signal(sig, info, t, 0);
1132}
1133
1134int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
1135 bool group)
1136{
1137 unsigned long flags;
1138 int ret = -ESRCH;
1139
1140 if (lock_task_sighand(p, &flags)) {
1141 ret = send_signal(sig, info, p, group);
1142 unlock_task_sighand(p, &flags);
1143 }
1144
1145 return ret;
1146}
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159int
1160force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1161{
1162 unsigned long int flags;
1163 int ret, blocked, ignored;
1164 struct k_sigaction *action;
1165
1166 spin_lock_irqsave(&t->sighand->siglock, flags);
1167 action = &t->sighand->action[sig-1];
1168 ignored = action->sa.sa_handler == SIG_IGN;
1169 blocked = sigismember(&t->blocked, sig);
1170 if (blocked || ignored) {
1171 action->sa.sa_handler = SIG_DFL;
1172 if (blocked) {
1173 sigdelset(&t->blocked, sig);
1174 recalc_sigpending_and_wake(t);
1175 }
1176 }
1177 if (action->sa.sa_handler == SIG_DFL)
1178 t->signal->flags &= ~SIGNAL_UNKILLABLE;
1179 ret = specific_send_sig_info(sig, info, t);
1180 spin_unlock_irqrestore(&t->sighand->siglock, flags);
1181
1182 return ret;
1183}
1184
1185
1186
1187
1188int zap_other_threads(struct task_struct *p)
1189{
1190 struct task_struct *t = p;
1191 int count = 0;
1192
1193 p->signal->group_stop_count = 0;
1194
1195 while_each_thread(p, t) {
1196 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1197 count++;
1198
1199
1200 if (t->exit_state)
1201 continue;
1202 sigaddset(&t->pending.signal, SIGKILL);
1203 signal_wake_up(t, 1);
1204 }
1205
1206 return count;
1207}
1208
1209struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
1210 unsigned long *flags)
1211{
1212 struct sighand_struct *sighand;
1213
1214 for (;;) {
1215
1216
1217
1218
1219 local_irq_save(*flags);
1220 rcu_read_lock();
1221 sighand = rcu_dereference(tsk->sighand);
1222 if (unlikely(sighand == NULL)) {
1223 rcu_read_unlock();
1224 local_irq_restore(*flags);
1225 break;
1226 }
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238 spin_lock(&sighand->siglock);
1239 if (likely(sighand == tsk->sighand)) {
1240 rcu_read_unlock();
1241 break;
1242 }
1243 spin_unlock(&sighand->siglock);
1244 rcu_read_unlock();
1245 local_irq_restore(*flags);
1246 }
1247
1248 return sighand;
1249}
1250
1251
1252
1253
1254int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1255{
1256 int ret;
1257
1258 rcu_read_lock();
1259 ret = check_kill_permission(sig, info, p);
1260 rcu_read_unlock();
1261
1262 if (!ret && sig)
1263 ret = do_send_sig_info(sig, info, p, true);
1264
1265 return ret;
1266}
1267
1268
1269
1270
1271
1272
1273int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1274{
1275 struct task_struct *p = NULL;
1276 int retval, success;
1277
1278 success = 0;
1279 retval = -ESRCH;
1280 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1281 int err = group_send_sig_info(sig, info, p);
1282 success |= !err;
1283 retval = err;
1284 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1285 return success ? 0 : retval;
1286}
1287
1288int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1289{
1290 int error = -ESRCH;
1291 struct task_struct *p;
1292
1293 for (;;) {
1294 rcu_read_lock();
1295 p = pid_task(pid, PIDTYPE_PID);
1296 if (p)
1297 error = group_send_sig_info(sig, info, p);
1298 rcu_read_unlock();
1299 if (likely(!p || error != -ESRCH))
1300 return error;
1301
1302
1303
1304
1305
1306
1307 }
1308}
1309
1310int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1311{
1312 int error;
1313 rcu_read_lock();
1314 error = kill_pid_info(sig, info, find_vpid(pid));
1315 rcu_read_unlock();
1316 return error;
1317}
1318
1319static int kill_as_cred_perm(const struct cred *cred,
1320 struct task_struct *target)
1321{
1322 const struct cred *pcred = __task_cred(target);
1323 if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) &&
1324 !uid_eq(cred->uid, pcred->suid) && !uid_eq(cred->uid, pcred->uid))
1325 return 0;
1326 return 1;
1327}
1328
1329
1330int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid,
1331 const struct cred *cred, u32 secid)
1332{
1333 int ret = -EINVAL;
1334 struct task_struct *p;
1335 unsigned long flags;
1336
1337 if (!valid_signal(sig))
1338 return ret;
1339
1340 rcu_read_lock();
1341 p = pid_task(pid, PIDTYPE_PID);
1342 if (!p) {
1343 ret = -ESRCH;
1344 goto out_unlock;
1345 }
1346 if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
1347 ret = -EPERM;
1348 goto out_unlock;
1349 }
1350 ret = security_task_kill(p, info, sig, secid);
1351 if (ret)
1352 goto out_unlock;
1353
1354 if (sig) {
1355 if (lock_task_sighand(p, &flags)) {
1356 ret = __send_signal(sig, info, p, 1, 0);
1357 unlock_task_sighand(p, &flags);
1358 } else
1359 ret = -ESRCH;
1360 }
1361out_unlock:
1362 rcu_read_unlock();
1363 return ret;
1364}
1365EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
1366
1367
1368
1369
1370
1371
1372
1373
1374static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
1375{
1376 int ret;
1377
1378 if (pid > 0) {
1379 rcu_read_lock();
1380 ret = kill_pid_info(sig, info, find_vpid(pid));
1381 rcu_read_unlock();
1382 return ret;
1383 }
1384
1385 read_lock(&tasklist_lock);
1386 if (pid != -1) {
1387 ret = __kill_pgrp_info(sig, info,
1388 pid ? find_vpid(-pid) : task_pgrp(current));
1389 } else {
1390 int retval = 0, count = 0;
1391 struct task_struct * p;
1392
1393 for_each_process(p) {
1394 if (task_pid_vnr(p) > 1 &&
1395 !same_thread_group(p, current)) {
1396 int err = group_send_sig_info(sig, info, p);
1397 ++count;
1398 if (err != -EPERM)
1399 retval = err;
1400 }
1401 }
1402 ret = count ? retval : -ESRCH;
1403 }
1404 read_unlock(&tasklist_lock);
1405
1406 return ret;
1407}
1408
1409
1410
1411
1412
1413int send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1414{
1415
1416
1417
1418
1419 if (!valid_signal(sig))
1420 return -EINVAL;
1421
1422 return do_send_sig_info(sig, info, p, false);
1423}
1424
1425#define __si_special(priv) \
1426 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1427
1428int
1429send_sig(int sig, struct task_struct *p, int priv)
1430{
1431 return send_sig_info(sig, __si_special(priv), p);
1432}
1433
1434void
1435force_sig(int sig, struct task_struct *p)
1436{
1437 force_sig_info(sig, SEND_SIG_PRIV, p);
1438}
1439
1440
1441
1442
1443
1444
1445
1446int
1447force_sigsegv(int sig, struct task_struct *p)
1448{
1449 if (sig == SIGSEGV) {
1450 unsigned long flags;
1451 spin_lock_irqsave(&p->sighand->siglock, flags);
1452 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1453 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1454 }
1455 force_sig(SIGSEGV, p);
1456 return 0;
1457}
1458
1459int kill_pgrp(struct pid *pid, int sig, int priv)
1460{
1461 int ret;
1462
1463 read_lock(&tasklist_lock);
1464 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1465 read_unlock(&tasklist_lock);
1466
1467 return ret;
1468}
1469EXPORT_SYMBOL(kill_pgrp);
1470
1471int kill_pid(struct pid *pid, int sig, int priv)
1472{
1473 return kill_pid_info(sig, __si_special(priv), pid);
1474}
1475EXPORT_SYMBOL(kill_pid);
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486struct sigqueue *sigqueue_alloc(void)
1487{
1488 struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
1489
1490 if (q)
1491 q->flags |= SIGQUEUE_PREALLOC;
1492
1493 return q;
1494}
1495
1496void sigqueue_free(struct sigqueue *q)
1497{
1498 unsigned long flags;
1499 spinlock_t *lock = ¤t->sighand->siglock;
1500
1501 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1502
1503
1504
1505
1506
1507 spin_lock_irqsave(lock, flags);
1508 q->flags &= ~SIGQUEUE_PREALLOC;
1509
1510
1511
1512
1513 if (!list_empty(&q->list))
1514 q = NULL;
1515 spin_unlock_irqrestore(lock, flags);
1516
1517 if (q)
1518 __sigqueue_free(q);
1519}
1520
1521int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1522{
1523 int sig = q->info.si_signo;
1524 struct sigpending *pending;
1525 unsigned long flags;
1526 int ret, result;
1527
1528 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1529
1530 ret = -1;
1531 if (!likely(lock_task_sighand(t, &flags)))
1532 goto ret;
1533
1534 ret = 1;
1535 result = TRACE_SIGNAL_IGNORED;
1536 if (!prepare_signal(sig, t, false))
1537 goto out;
1538
1539 ret = 0;
1540 if (unlikely(!list_empty(&q->list))) {
1541
1542
1543
1544
1545 BUG_ON(q->info.si_code != SI_TIMER);
1546 q->info.si_overrun++;
1547 result = TRACE_SIGNAL_ALREADY_PENDING;
1548 goto out;
1549 }
1550 q->info.si_overrun = 0;
1551
1552 signalfd_notify(t, sig);
1553 pending = group ? &t->signal->shared_pending : &t->pending;
1554 list_add_tail(&q->list, &pending->list);
1555 sigaddset(&pending->signal, sig);
1556 complete_signal(sig, t, group);
1557 result = TRACE_SIGNAL_DELIVERED;
1558out:
1559 trace_signal_generate(sig, &q->info, t, group, result);
1560 unlock_task_sighand(t, &flags);
1561ret:
1562 return ret;
1563}
1564
1565
1566
1567
1568
1569
1570
1571
1572bool do_notify_parent(struct task_struct *tsk, int sig)
1573{
1574 struct siginfo info;
1575 unsigned long flags;
1576 struct sighand_struct *psig;
1577 bool autoreap = false;
1578 cputime_t utime, stime;
1579
1580 BUG_ON(sig == -1);
1581
1582
1583 BUG_ON(task_is_stopped_or_traced(tsk));
1584
1585 BUG_ON(!tsk->ptrace &&
1586 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1587
1588 if (sig != SIGCHLD) {
1589
1590
1591
1592
1593 if (tsk->parent_exec_id != tsk->parent->self_exec_id)
1594 sig = SIGCHLD;
1595 }
1596
1597 info.si_signo = sig;
1598 info.si_errno = 0;
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610 rcu_read_lock();
1611 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1612 info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
1613 task_uid(tsk));
1614 rcu_read_unlock();
1615
1616 task_cputime(tsk, &utime, &stime);
1617 info.si_utime = cputime_to_clock_t(utime + tsk->signal->utime);
1618 info.si_stime = cputime_to_clock_t(stime + tsk->signal->stime);
1619
1620 info.si_status = tsk->exit_code & 0x7f;
1621 if (tsk->exit_code & 0x80)
1622 info.si_code = CLD_DUMPED;
1623 else if (tsk->exit_code & 0x7f)
1624 info.si_code = CLD_KILLED;
1625 else {
1626 info.si_code = CLD_EXITED;
1627 info.si_status = tsk->exit_code >> 8;
1628 }
1629
1630 psig = tsk->parent->sighand;
1631 spin_lock_irqsave(&psig->siglock, flags);
1632 if (!tsk->ptrace && sig == SIGCHLD &&
1633 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1634 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650 autoreap = true;
1651 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1652 sig = 0;
1653 }
1654 if (valid_signal(sig) && sig)
1655 __group_send_sig_info(sig, &info, tsk->parent);
1656 __wake_up_parent(tsk, tsk->parent);
1657 spin_unlock_irqrestore(&psig->siglock, flags);
1658
1659 return autoreap;
1660}
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675static void do_notify_parent_cldstop(struct task_struct *tsk,
1676 bool for_ptracer, int why)
1677{
1678 struct siginfo info;
1679 unsigned long flags;
1680 struct task_struct *parent;
1681 struct sighand_struct *sighand;
1682 cputime_t utime, stime;
1683
1684 if (for_ptracer) {
1685 parent = tsk->parent;
1686 } else {
1687 tsk = tsk->group_leader;
1688 parent = tsk->real_parent;
1689 }
1690
1691 info.si_signo = SIGCHLD;
1692 info.si_errno = 0;
1693
1694
1695
1696 rcu_read_lock();
1697 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
1698 info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
1699 rcu_read_unlock();
1700
1701 task_cputime(tsk, &utime, &stime);
1702 info.si_utime = cputime_to_clock_t(utime);
1703 info.si_stime = cputime_to_clock_t(stime);
1704
1705 info.si_code = why;
1706 switch (why) {
1707 case CLD_CONTINUED:
1708 info.si_status = SIGCONT;
1709 break;
1710 case CLD_STOPPED:
1711 info.si_status = tsk->signal->group_exit_code & 0x7f;
1712 break;
1713 case CLD_TRAPPED:
1714 info.si_status = tsk->exit_code & 0x7f;
1715 break;
1716 default:
1717 BUG();
1718 }
1719
1720 sighand = parent->sighand;
1721 spin_lock_irqsave(&sighand->siglock, flags);
1722 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1723 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1724 __group_send_sig_info(SIGCHLD, &info, parent);
1725
1726
1727
1728 __wake_up_parent(tsk, parent);
1729 spin_unlock_irqrestore(&sighand->siglock, flags);
1730}
1731
1732static inline int may_ptrace_stop(void)
1733{
1734 if (!likely(current->ptrace))
1735 return 0;
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749 if (unlikely(current->mm->core_state) &&
1750 unlikely(current->mm == current->parent->mm))
1751 return 0;
1752
1753 return 1;
1754}
1755
1756
1757
1758
1759
1760static int sigkill_pending(struct task_struct *tsk)
1761{
1762 return sigismember(&tsk->pending.signal, SIGKILL) ||
1763 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
1764}
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
1778 __releases(¤t->sighand->siglock)
1779 __acquires(¤t->sighand->siglock)
1780{
1781 bool gstop_done = false;
1782
1783 if (arch_ptrace_stop_needed(exit_code, info)) {
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795 spin_unlock_irq(¤t->sighand->siglock);
1796 arch_ptrace_stop(exit_code, info);
1797 spin_lock_irq(¤t->sighand->siglock);
1798 if (sigkill_pending(current))
1799 return;
1800 }
1801
1802
1803
1804
1805
1806
1807
1808
1809 set_current_state(TASK_TRACED);
1810
1811 current->last_siginfo = info;
1812 current->exit_code = exit_code;
1813
1814
1815
1816
1817
1818
1819
1820
1821 if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
1822 gstop_done = task_participate_group_stop(current);
1823
1824
1825 task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
1826 if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
1827 task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
1828
1829
1830 task_clear_jobctl_trapping(current);
1831
1832 spin_unlock_irq(¤t->sighand->siglock);
1833 read_lock(&tasklist_lock);
1834 if (may_ptrace_stop()) {
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845 do_notify_parent_cldstop(current, true, why);
1846 if (gstop_done && ptrace_reparented(current))
1847 do_notify_parent_cldstop(current, false, why);
1848
1849
1850
1851
1852
1853
1854
1855 preempt_disable();
1856 read_unlock(&tasklist_lock);
1857 preempt_enable_no_resched();
1858 freezable_schedule();
1859 } else {
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870 if (gstop_done)
1871 do_notify_parent_cldstop(current, false, why);
1872
1873
1874 __set_current_state(TASK_RUNNING);
1875 if (clear_code)
1876 current->exit_code = 0;
1877 read_unlock(&tasklist_lock);
1878 }
1879
1880
1881
1882
1883
1884
1885 spin_lock_irq(¤t->sighand->siglock);
1886 current->last_siginfo = NULL;
1887
1888
1889 current->jobctl &= ~JOBCTL_LISTENING;
1890
1891
1892
1893
1894
1895
1896 recalc_sigpending_tsk(current);
1897}
1898
1899static void ptrace_do_notify(int signr, int exit_code, int why)
1900{
1901 siginfo_t info;
1902
1903 memset(&info, 0, sizeof info);
1904 info.si_signo = signr;
1905 info.si_code = exit_code;
1906 info.si_pid = task_pid_vnr(current);
1907 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
1908
1909
1910 ptrace_stop(exit_code, why, 1, &info);
1911}
1912
1913void ptrace_notify(int exit_code)
1914{
1915 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1916 if (unlikely(current->task_works))
1917 task_work_run();
1918
1919 spin_lock_irq(¤t->sighand->siglock);
1920 ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
1921 spin_unlock_irq(¤t->sighand->siglock);
1922}
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946static bool do_signal_stop(int signr)
1947 __releases(¤t->sighand->siglock)
1948{
1949 struct signal_struct *sig = current->signal;
1950
1951 if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
1952 unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
1953 struct task_struct *t;
1954
1955
1956 WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
1957
1958 if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
1959 unlikely(signal_group_exit(sig)))
1960 return false;
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980 if (!(sig->flags & SIGNAL_STOP_STOPPED))
1981 sig->group_exit_code = signr;
1982
1983 sig->group_stop_count = 0;
1984
1985 if (task_set_jobctl_pending(current, signr | gstop))
1986 sig->group_stop_count++;
1987
1988 t = current;
1989 while_each_thread(current, t) {
1990
1991
1992
1993
1994
1995 if (!task_is_stopped(t) &&
1996 task_set_jobctl_pending(t, signr | gstop)) {
1997 sig->group_stop_count++;
1998 if (likely(!(t->ptrace & PT_SEIZED)))
1999 signal_wake_up(t, 0);
2000 else
2001 ptrace_trap_notify(t);
2002 }
2003 }
2004 }
2005
2006 if (likely(!current->ptrace)) {
2007 int notify = 0;
2008
2009
2010
2011
2012
2013
2014 if (task_participate_group_stop(current))
2015 notify = CLD_STOPPED;
2016
2017 __set_current_state(TASK_STOPPED);
2018 spin_unlock_irq(¤t->sighand->siglock);
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029 if (notify) {
2030 read_lock(&tasklist_lock);
2031 do_notify_parent_cldstop(current, false, notify);
2032 read_unlock(&tasklist_lock);
2033 }
2034
2035
2036 freezable_schedule();
2037 return true;
2038 } else {
2039
2040
2041
2042
2043 task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
2044 return false;
2045 }
2046}
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063static void do_jobctl_trap(void)
2064{
2065 struct signal_struct *signal = current->signal;
2066 int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2067
2068 if (current->ptrace & PT_SEIZED) {
2069 if (!signal->group_stop_count &&
2070 !(signal->flags & SIGNAL_STOP_STOPPED))
2071 signr = SIGTRAP;
2072 WARN_ON_ONCE(!signr);
2073 ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
2074 CLD_STOPPED);
2075 } else {
2076 WARN_ON_ONCE(!signr);
2077 ptrace_stop(signr, CLD_STOPPED, 0, NULL);
2078 current->exit_code = 0;
2079 }
2080}
2081
2082static int ptrace_signal(int signr, siginfo_t *info)
2083{
2084 ptrace_signal_deliver();
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094 current->jobctl |= JOBCTL_STOP_DEQUEUED;
2095 ptrace_stop(signr, CLD_TRAPPED, 0, info);
2096
2097
2098 signr = current->exit_code;
2099 if (signr == 0)
2100 return signr;
2101
2102 current->exit_code = 0;
2103
2104
2105
2106
2107
2108
2109
2110 if (signr != info->si_signo) {
2111 info->si_signo = signr;
2112 info->si_errno = 0;
2113 info->si_code = SI_USER;
2114 rcu_read_lock();
2115 info->si_pid = task_pid_vnr(current->parent);
2116 info->si_uid = from_kuid_munged(current_user_ns(),
2117 task_uid(current->parent));
2118 rcu_read_unlock();
2119 }
2120
2121
2122 if (sigismember(¤t->blocked, signr)) {
2123 specific_send_sig_info(signr, info, current);
2124 signr = 0;
2125 }
2126
2127 return signr;
2128}
2129
2130int get_signal(struct ksignal *ksig)
2131{
2132 struct sighand_struct *sighand = current->sighand;
2133 struct signal_struct *signal = current->signal;
2134 int signr;
2135
2136 if (unlikely(current->task_works))
2137 task_work_run();
2138
2139 if (unlikely(uprobe_deny_signal()))
2140 return 0;
2141
2142
2143
2144
2145
2146
2147 try_to_freeze();
2148
2149relock:
2150 spin_lock_irq(&sighand->siglock);
2151
2152
2153
2154
2155
2156 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2157 int why;
2158
2159 if (signal->flags & SIGNAL_CLD_CONTINUED)
2160 why = CLD_CONTINUED;
2161 else
2162 why = CLD_STOPPED;
2163
2164 signal->flags &= ~SIGNAL_CLD_MASK;
2165
2166 spin_unlock_irq(&sighand->siglock);
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176 read_lock(&tasklist_lock);
2177 do_notify_parent_cldstop(current, false, why);
2178
2179 if (ptrace_reparented(current->group_leader))
2180 do_notify_parent_cldstop(current->group_leader,
2181 true, why);
2182 read_unlock(&tasklist_lock);
2183
2184 goto relock;
2185 }
2186
2187 for (;;) {
2188 struct k_sigaction *ka;
2189
2190 if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
2191 do_signal_stop(0))
2192 goto relock;
2193
2194 if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
2195 do_jobctl_trap();
2196 spin_unlock_irq(&sighand->siglock);
2197 goto relock;
2198 }
2199
2200 signr = dequeue_signal(current, ¤t->blocked, &ksig->info);
2201
2202 if (!signr)
2203 break;
2204
2205 if (unlikely(current->ptrace) && signr != SIGKILL) {
2206 signr = ptrace_signal(signr, &ksig->info);
2207 if (!signr)
2208 continue;
2209 }
2210
2211 ka = &sighand->action[signr-1];
2212
2213
2214 trace_signal_deliver(signr, &ksig->info, ka);
2215
2216 if (ka->sa.sa_handler == SIG_IGN)
2217 continue;
2218 if (ka->sa.sa_handler != SIG_DFL) {
2219
2220 ksig->ka = *ka;
2221
2222 if (ka->sa.sa_flags & SA_ONESHOT)
2223 ka->sa.sa_handler = SIG_DFL;
2224
2225 break;
2226 }
2227
2228
2229
2230
2231 if (sig_kernel_ignore(signr))
2232 continue;
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2245 !sig_kernel_only(signr))
2246 continue;
2247
2248 if (sig_kernel_stop(signr)) {
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259 if (signr != SIGSTOP) {
2260 spin_unlock_irq(&sighand->siglock);
2261
2262
2263
2264 if (is_current_pgrp_orphaned())
2265 goto relock;
2266
2267 spin_lock_irq(&sighand->siglock);
2268 }
2269
2270 if (likely(do_signal_stop(ksig->info.si_signo))) {
2271
2272 goto relock;
2273 }
2274
2275
2276
2277
2278
2279 continue;
2280 }
2281
2282 spin_unlock_irq(&sighand->siglock);
2283
2284
2285
2286
2287 current->flags |= PF_SIGNALED;
2288
2289 if (sig_kernel_coredump(signr)) {
2290 if (print_fatal_signals)
2291 print_fatal_signal(ksig->info.si_signo);
2292 proc_coredump_connector(current);
2293
2294
2295
2296
2297
2298
2299
2300
2301 do_coredump(&ksig->info);
2302 }
2303
2304
2305
2306
2307 do_group_exit(ksig->info.si_signo);
2308
2309 }
2310 spin_unlock_irq(&sighand->siglock);
2311
2312 ksig->sig = signr;
2313 return ksig->sig > 0;
2314}
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326static void signal_delivered(struct ksignal *ksig, int stepping)
2327{
2328 sigset_t blocked;
2329
2330
2331
2332
2333
2334 clear_restore_sigmask();
2335
2336 sigorsets(&blocked, ¤t->blocked, &ksig->ka.sa.sa_mask);
2337 if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
2338 sigaddset(&blocked, ksig->sig);
2339 set_current_blocked(&blocked);
2340 tracehook_signal_handler(stepping);
2341}
2342
2343void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
2344{
2345 if (failed)
2346 force_sigsegv(ksig->sig, current);
2347 else
2348 signal_delivered(ksig, stepping);
2349}
2350
2351
2352
2353
2354
2355
2356static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2357{
2358 sigset_t retarget;
2359 struct task_struct *t;
2360
2361 sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
2362 if (sigisemptyset(&retarget))
2363 return;
2364
2365 t = tsk;
2366 while_each_thread(tsk, t) {
2367 if (t->flags & PF_EXITING)
2368 continue;
2369
2370 if (!has_pending_signals(&retarget, &t->blocked))
2371 continue;
2372
2373 sigandsets(&retarget, &retarget, &t->blocked);
2374
2375 if (!signal_pending(t))
2376 signal_wake_up(t, 0);
2377
2378 if (sigisemptyset(&retarget))
2379 break;
2380 }
2381}
2382
2383void exit_signals(struct task_struct *tsk)
2384{
2385 int group_stop = 0;
2386 sigset_t unblocked;
2387
2388
2389
2390
2391
2392 threadgroup_change_begin(tsk);
2393
2394 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
2395 tsk->flags |= PF_EXITING;
2396 threadgroup_change_end(tsk);
2397 return;
2398 }
2399
2400 spin_lock_irq(&tsk->sighand->siglock);
2401
2402
2403
2404
2405 tsk->flags |= PF_EXITING;
2406
2407 threadgroup_change_end(tsk);
2408
2409 if (!signal_pending(tsk))
2410 goto out;
2411
2412 unblocked = tsk->blocked;
2413 signotset(&unblocked);
2414 retarget_shared_pending(tsk, &unblocked);
2415
2416 if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2417 task_participate_group_stop(tsk))
2418 group_stop = CLD_STOPPED;
2419out:
2420 spin_unlock_irq(&tsk->sighand->siglock);
2421
2422
2423
2424
2425
2426 if (unlikely(group_stop)) {
2427 read_lock(&tasklist_lock);
2428 do_notify_parent_cldstop(tsk, false, group_stop);
2429 read_unlock(&tasklist_lock);
2430 }
2431}
2432
2433EXPORT_SYMBOL(recalc_sigpending);
2434EXPORT_SYMBOL_GPL(dequeue_signal);
2435EXPORT_SYMBOL(flush_signals);
2436EXPORT_SYMBOL(force_sig);
2437EXPORT_SYMBOL(send_sig);
2438EXPORT_SYMBOL(send_sig_info);
2439EXPORT_SYMBOL(sigprocmask);
2440
2441
2442
2443
2444
2445
2446
2447
2448SYSCALL_DEFINE0(restart_syscall)
2449{
2450 struct restart_block *restart = ¤t->restart_block;
2451 return restart->fn(restart);
2452}
2453
2454long do_no_restart_syscall(struct restart_block *param)
2455{
2456 return -EINTR;
2457}
2458
2459static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
2460{
2461 if (signal_pending(tsk) && !thread_group_empty(tsk)) {
2462 sigset_t newblocked;
2463
2464 sigandnsets(&newblocked, newset, ¤t->blocked);
2465 retarget_shared_pending(tsk, &newblocked);
2466 }
2467 tsk->blocked = *newset;
2468 recalc_sigpending();
2469}
2470
2471
2472
2473
2474
2475
2476
2477
2478void set_current_blocked(sigset_t *newset)
2479{
2480 sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2481 __set_current_blocked(newset);
2482}
2483
2484void __set_current_blocked(const sigset_t *newset)
2485{
2486 struct task_struct *tsk = current;
2487
2488 spin_lock_irq(&tsk->sighand->siglock);
2489 __set_task_blocked(tsk, newset);
2490 spin_unlock_irq(&tsk->sighand->siglock);
2491}
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2502{
2503 struct task_struct *tsk = current;
2504 sigset_t newset;
2505
2506
2507 if (oldset)
2508 *oldset = tsk->blocked;
2509
2510 switch (how) {
2511 case SIG_BLOCK:
2512 sigorsets(&newset, &tsk->blocked, set);
2513 break;
2514 case SIG_UNBLOCK:
2515 sigandnsets(&newset, &tsk->blocked, set);
2516 break;
2517 case SIG_SETMASK:
2518 newset = *set;
2519 break;
2520 default:
2521 return -EINVAL;
2522 }
2523
2524 __set_current_blocked(&newset);
2525 return 0;
2526}
2527
2528
2529
2530
2531
2532
2533
2534
2535SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
2536 sigset_t __user *, oset, size_t, sigsetsize)
2537{
2538 sigset_t old_set, new_set;
2539 int error;
2540
2541
2542 if (sigsetsize != sizeof(sigset_t))
2543 return -EINVAL;
2544
2545 old_set = current->blocked;
2546
2547 if (nset) {
2548 if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
2549 return -EFAULT;
2550 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2551
2552 error = sigprocmask(how, &new_set, NULL);
2553 if (error)
2554 return error;
2555 }
2556
2557 if (oset) {
2558 if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
2559 return -EFAULT;
2560 }
2561
2562 return 0;
2563}
2564
2565#ifdef CONFIG_COMPAT
2566COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
2567 compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
2568{
2569#ifdef __BIG_ENDIAN
2570 sigset_t old_set = current->blocked;
2571
2572
2573 if (sigsetsize != sizeof(sigset_t))
2574 return -EINVAL;
2575
2576 if (nset) {
2577 compat_sigset_t new32;
2578 sigset_t new_set;
2579 int error;
2580 if (copy_from_user(&new32, nset, sizeof(compat_sigset_t)))
2581 return -EFAULT;
2582
2583 sigset_from_compat(&new_set, &new32);
2584 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2585
2586 error = sigprocmask(how, &new_set, NULL);
2587 if (error)
2588 return error;
2589 }
2590 if (oset) {
2591 compat_sigset_t old32;
2592 sigset_to_compat(&old32, &old_set);
2593 if (copy_to_user(oset, &old32, sizeof(compat_sigset_t)))
2594 return -EFAULT;
2595 }
2596 return 0;
2597#else
2598 return sys_rt_sigprocmask(how, (sigset_t __user *)nset,
2599 (sigset_t __user *)oset, sigsetsize);
2600#endif
2601}
2602#endif
2603
2604static int do_sigpending(void *set, unsigned long sigsetsize)
2605{
2606 if (sigsetsize > sizeof(sigset_t))
2607 return -EINVAL;
2608
2609 spin_lock_irq(¤t->sighand->siglock);
2610 sigorsets(set, ¤t->pending.signal,
2611 ¤t->signal->shared_pending.signal);
2612 spin_unlock_irq(¤t->sighand->siglock);
2613
2614
2615 sigandsets(set, ¤t->blocked, set);
2616 return 0;
2617}
2618
2619
2620
2621
2622
2623
2624
2625SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
2626{
2627 sigset_t set;
2628 int err = do_sigpending(&set, sigsetsize);
2629 if (!err && copy_to_user(uset, &set, sigsetsize))
2630 err = -EFAULT;
2631 return err;
2632}
2633
2634#ifdef CONFIG_COMPAT
2635COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
2636 compat_size_t, sigsetsize)
2637{
2638#ifdef __BIG_ENDIAN
2639 sigset_t set;
2640 int err = do_sigpending(&set, sigsetsize);
2641 if (!err) {
2642 compat_sigset_t set32;
2643 sigset_to_compat(&set32, &set);
2644
2645 if (copy_to_user(uset, &set32, sigsetsize))
2646 err = -EFAULT;
2647 }
2648 return err;
2649#else
2650 return sys_rt_sigpending((sigset_t __user *)uset, sigsetsize);
2651#endif
2652}
2653#endif
2654
2655#ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2656
2657int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
2658{
2659 int err;
2660
2661 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2662 return -EFAULT;
2663 if (from->si_code < 0)
2664 return __copy_to_user(to, from, sizeof(siginfo_t))
2665 ? -EFAULT : 0;
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675 err = __put_user(from->si_signo, &to->si_signo);
2676 err |= __put_user(from->si_errno, &to->si_errno);
2677 err |= __put_user((short)from->si_code, &to->si_code);
2678 switch (from->si_code & __SI_MASK) {
2679 case __SI_KILL:
2680 err |= __put_user(from->si_pid, &to->si_pid);
2681 err |= __put_user(from->si_uid, &to->si_uid);
2682 break;
2683 case __SI_TIMER:
2684 err |= __put_user(from->si_tid, &to->si_tid);
2685 err |= __put_user(from->si_overrun, &to->si_overrun);
2686 err |= __put_user(from->si_ptr, &to->si_ptr);
2687 break;
2688 case __SI_POLL:
2689 err |= __put_user(from->si_band, &to->si_band);
2690 err |= __put_user(from->si_fd, &to->si_fd);
2691 break;
2692 case __SI_FAULT:
2693 err |= __put_user(from->si_addr, &to->si_addr);
2694#ifdef __ARCH_SI_TRAPNO
2695 err |= __put_user(from->si_trapno, &to->si_trapno);
2696#endif
2697#ifdef BUS_MCEERR_AO
2698
2699
2700
2701
2702 if (from->si_signo == SIGBUS &&
2703 (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO))
2704 err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
2705#endif
2706#ifdef SEGV_BNDERR
2707 if (from->si_signo == SIGSEGV && from->si_code == SEGV_BNDERR) {
2708 err |= __put_user(from->si_lower, &to->si_lower);
2709 err |= __put_user(from->si_upper, &to->si_upper);
2710 }
2711#endif
2712#ifdef SEGV_PKUERR
2713 if (from->si_signo == SIGSEGV && from->si_code == SEGV_PKUERR)
2714 err |= __put_user(from->si_pkey, &to->si_pkey);
2715#endif
2716 break;
2717 case __SI_CHLD:
2718 err |= __put_user(from->si_pid, &to->si_pid);
2719 err |= __put_user(from->si_uid, &to->si_uid);
2720 err |= __put_user(from->si_status, &to->si_status);
2721 err |= __put_user(from->si_utime, &to->si_utime);
2722 err |= __put_user(from->si_stime, &to->si_stime);
2723 break;
2724 case __SI_RT:
2725 case __SI_MESGQ:
2726 err |= __put_user(from->si_pid, &to->si_pid);
2727 err |= __put_user(from->si_uid, &to->si_uid);
2728 err |= __put_user(from->si_ptr, &to->si_ptr);
2729 break;
2730#ifdef __ARCH_SIGSYS
2731 case __SI_SYS:
2732 err |= __put_user(from->si_call_addr, &to->si_call_addr);
2733 err |= __put_user(from->si_syscall, &to->si_syscall);
2734 err |= __put_user(from->si_arch, &to->si_arch);
2735 break;
2736#endif
2737 default:
2738 err |= __put_user(from->si_pid, &to->si_pid);
2739 err |= __put_user(from->si_uid, &to->si_uid);
2740 break;
2741 }
2742 return err;
2743}
2744
2745#endif
2746
2747
2748
2749
2750
2751
2752
2753int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
2754 const struct timespec *ts)
2755{
2756 struct task_struct *tsk = current;
2757 long timeout = MAX_SCHEDULE_TIMEOUT;
2758 sigset_t mask = *which;
2759 int sig;
2760
2761 if (ts) {
2762 if (!timespec_valid(ts))
2763 return -EINVAL;
2764 timeout = timespec_to_jiffies(ts);
2765
2766
2767
2768
2769 if (ts->tv_sec || ts->tv_nsec)
2770 timeout++;
2771 }
2772
2773
2774
2775
2776 sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
2777 signotset(&mask);
2778
2779 spin_lock_irq(&tsk->sighand->siglock);
2780 sig = dequeue_signal(tsk, &mask, info);
2781 if (!sig && timeout) {
2782
2783
2784
2785
2786
2787
2788 tsk->real_blocked = tsk->blocked;
2789 sigandsets(&tsk->blocked, &tsk->blocked, &mask);
2790 recalc_sigpending();
2791 spin_unlock_irq(&tsk->sighand->siglock);
2792
2793 timeout = freezable_schedule_timeout_interruptible(timeout);
2794
2795 spin_lock_irq(&tsk->sighand->siglock);
2796 __set_task_blocked(tsk, &tsk->real_blocked);
2797 sigemptyset(&tsk->real_blocked);
2798 sig = dequeue_signal(tsk, &mask, info);
2799 }
2800 spin_unlock_irq(&tsk->sighand->siglock);
2801
2802 if (sig)
2803 return sig;
2804 return timeout ? -EINTR : -EAGAIN;
2805}
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
2816 siginfo_t __user *, uinfo, const struct timespec __user *, uts,
2817 size_t, sigsetsize)
2818{
2819 sigset_t these;
2820 struct timespec ts;
2821 siginfo_t info;
2822 int ret;
2823
2824
2825 if (sigsetsize != sizeof(sigset_t))
2826 return -EINVAL;
2827
2828 if (copy_from_user(&these, uthese, sizeof(these)))
2829 return -EFAULT;
2830
2831 if (uts) {
2832 if (copy_from_user(&ts, uts, sizeof(ts)))
2833 return -EFAULT;
2834 }
2835
2836 ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
2837
2838 if (ret > 0 && uinfo) {
2839 if (copy_siginfo_to_user(uinfo, &info))
2840 ret = -EFAULT;
2841 }
2842
2843 return ret;
2844}
2845
2846
2847
2848
2849
2850
2851SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
2852{
2853 struct siginfo info;
2854
2855 info.si_signo = sig;
2856 info.si_errno = 0;
2857 info.si_code = SI_USER;
2858 info.si_pid = task_tgid_vnr(current);
2859 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2860
2861 return kill_something_info(sig, &info, pid);
2862}
2863
2864static int
2865do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
2866{
2867 struct task_struct *p;
2868 int error = -ESRCH;
2869
2870 rcu_read_lock();
2871 p = find_task_by_vpid(pid);
2872 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2873 error = check_kill_permission(sig, info, p);
2874
2875
2876
2877
2878 if (!error && sig) {
2879 error = do_send_sig_info(sig, info, p, false);
2880
2881
2882
2883
2884
2885 if (unlikely(error == -ESRCH))
2886 error = 0;
2887 }
2888 }
2889 rcu_read_unlock();
2890
2891 return error;
2892}
2893
2894static int do_tkill(pid_t tgid, pid_t pid, int sig)
2895{
2896 struct siginfo info = {};
2897
2898 info.si_signo = sig;
2899 info.si_errno = 0;
2900 info.si_code = SI_TKILL;
2901 info.si_pid = task_tgid_vnr(current);
2902 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2903
2904 return do_send_specific(tgid, pid, sig, &info);
2905}
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
2918{
2919
2920 if (pid <= 0 || tgid <= 0)
2921 return -EINVAL;
2922
2923 return do_tkill(tgid, pid, sig);
2924}
2925
2926
2927
2928
2929
2930
2931
2932
2933SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
2934{
2935
2936 if (pid <= 0)
2937 return -EINVAL;
2938
2939 return do_tkill(0, pid, sig);
2940}
2941
2942static int do_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t *info)
2943{
2944
2945
2946
2947 if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
2948 (task_pid_vnr(current) != pid))
2949 return -EPERM;
2950
2951 info->si_signo = sig;
2952
2953
2954 return kill_proc_info(sig, info, pid);
2955}
2956
2957
2958
2959
2960
2961
2962
2963SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
2964 siginfo_t __user *, uinfo)
2965{
2966 siginfo_t info;
2967 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2968 return -EFAULT;
2969 return do_rt_sigqueueinfo(pid, sig, &info);
2970}
2971
2972#ifdef CONFIG_COMPAT
2973COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
2974 compat_pid_t, pid,
2975 int, sig,
2976 struct compat_siginfo __user *, uinfo)
2977{
2978 siginfo_t info = {};
2979 int ret = copy_siginfo_from_user32(&info, uinfo);
2980 if (unlikely(ret))
2981 return ret;
2982 return do_rt_sigqueueinfo(pid, sig, &info);
2983}
2984#endif
2985
2986static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
2987{
2988
2989 if (pid <= 0 || tgid <= 0)
2990 return -EINVAL;
2991
2992
2993
2994
2995 if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
2996 (task_pid_vnr(current) != pid))
2997 return -EPERM;
2998
2999 info->si_signo = sig;
3000
3001 return do_send_specific(tgid, pid, sig, info);
3002}
3003
3004SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
3005 siginfo_t __user *, uinfo)
3006{
3007 siginfo_t info;
3008
3009 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3010 return -EFAULT;
3011
3012 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3013}
3014
3015#ifdef CONFIG_COMPAT
3016COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
3017 compat_pid_t, tgid,
3018 compat_pid_t, pid,
3019 int, sig,
3020 struct compat_siginfo __user *, uinfo)
3021{
3022 siginfo_t info = {};
3023
3024 if (copy_siginfo_from_user32(&info, uinfo))
3025 return -EFAULT;
3026 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3027}
3028#endif
3029
3030
3031
3032
3033void kernel_sigaction(int sig, __sighandler_t action)
3034{
3035 spin_lock_irq(¤t->sighand->siglock);
3036 current->sighand->action[sig - 1].sa.sa_handler = action;
3037 if (action == SIG_IGN) {
3038 sigset_t mask;
3039
3040 sigemptyset(&mask);
3041 sigaddset(&mask, sig);
3042
3043 flush_sigqueue_mask(&mask, ¤t->signal->shared_pending);
3044 flush_sigqueue_mask(&mask, ¤t->pending);
3045 recalc_sigpending();
3046 }
3047 spin_unlock_irq(¤t->sighand->siglock);
3048}
3049EXPORT_SYMBOL(kernel_sigaction);
3050
3051int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
3052{
3053 struct task_struct *p = current, *t;
3054 struct k_sigaction *k;
3055 sigset_t mask;
3056
3057 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
3058 return -EINVAL;
3059
3060 k = &p->sighand->action[sig-1];
3061
3062 spin_lock_irq(&p->sighand->siglock);
3063 if (oact)
3064 *oact = *k;
3065
3066 if (act) {
3067 sigdelsetmask(&act->sa.sa_mask,
3068 sigmask(SIGKILL) | sigmask(SIGSTOP));
3069 *k = *act;
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081 if (sig_handler_ignored(sig_handler(p, sig), sig)) {
3082 sigemptyset(&mask);
3083 sigaddset(&mask, sig);
3084 flush_sigqueue_mask(&mask, &p->signal->shared_pending);
3085 for_each_thread(p, t)
3086 flush_sigqueue_mask(&mask, &t->pending);
3087 }
3088 }
3089
3090 spin_unlock_irq(&p->sighand->siglock);
3091 return 0;
3092}
3093
3094static int
3095do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
3096{
3097 stack_t oss;
3098 int error;
3099
3100 oss.ss_sp = (void __user *) current->sas_ss_sp;
3101 oss.ss_size = current->sas_ss_size;
3102 oss.ss_flags = sas_ss_flags(sp);
3103
3104 if (uss) {
3105 void __user *ss_sp;
3106 size_t ss_size;
3107 int ss_flags;
3108
3109 error = -EFAULT;
3110 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
3111 goto out;
3112 error = __get_user(ss_sp, &uss->ss_sp) |
3113 __get_user(ss_flags, &uss->ss_flags) |
3114 __get_user(ss_size, &uss->ss_size);
3115 if (error)
3116 goto out;
3117
3118 error = -EPERM;
3119 if (on_sig_stack(sp))
3120 goto out;
3121
3122 error = -EINVAL;
3123
3124
3125
3126
3127
3128
3129
3130 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
3131 goto out;
3132
3133 if (ss_flags == SS_DISABLE) {
3134 ss_size = 0;
3135 ss_sp = NULL;
3136 } else {
3137 error = -ENOMEM;
3138 if (ss_size < MINSIGSTKSZ)
3139 goto out;
3140 }
3141
3142 current->sas_ss_sp = (unsigned long) ss_sp;
3143 current->sas_ss_size = ss_size;
3144 }
3145
3146 error = 0;
3147 if (uoss) {
3148 error = -EFAULT;
3149 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
3150 goto out;
3151 error = __put_user(oss.ss_sp, &uoss->ss_sp) |
3152 __put_user(oss.ss_size, &uoss->ss_size) |
3153 __put_user(oss.ss_flags, &uoss->ss_flags);
3154 }
3155
3156out:
3157 return error;
3158}
3159SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
3160{
3161 return do_sigaltstack(uss, uoss, current_user_stack_pointer());
3162}
3163
3164int restore_altstack(const stack_t __user *uss)
3165{
3166 int err = do_sigaltstack(uss, NULL, current_user_stack_pointer());
3167
3168 return err == -EFAULT ? err : 0;
3169}
3170
3171int __save_altstack(stack_t __user *uss, unsigned long sp)
3172{
3173 struct task_struct *t = current;
3174 return __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
3175 __put_user(sas_ss_flags(sp), &uss->ss_flags) |
3176 __put_user(t->sas_ss_size, &uss->ss_size);
3177}
3178
3179#ifdef CONFIG_COMPAT
3180COMPAT_SYSCALL_DEFINE2(sigaltstack,
3181 const compat_stack_t __user *, uss_ptr,
3182 compat_stack_t __user *, uoss_ptr)
3183{
3184 stack_t uss, uoss;
3185 int ret;
3186 mm_segment_t seg;
3187
3188 if (uss_ptr) {
3189 compat_stack_t uss32;
3190
3191 memset(&uss, 0, sizeof(stack_t));
3192 if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
3193 return -EFAULT;
3194 uss.ss_sp = compat_ptr(uss32.ss_sp);
3195 uss.ss_flags = uss32.ss_flags;
3196 uss.ss_size = uss32.ss_size;
3197 }
3198 seg = get_fs();
3199 set_fs(KERNEL_DS);
3200 ret = do_sigaltstack((stack_t __force __user *) (uss_ptr ? &uss : NULL),
3201 (stack_t __force __user *) &uoss,
3202 compat_user_stack_pointer());
3203 set_fs(seg);
3204 if (ret >= 0 && uoss_ptr) {
3205 if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(compat_stack_t)) ||
3206 __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
3207 __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
3208 __put_user(uoss.ss_size, &uoss_ptr->ss_size))
3209 ret = -EFAULT;
3210 }
3211 return ret;
3212}
3213
3214int compat_restore_altstack(const compat_stack_t __user *uss)
3215{
3216 int err = compat_sys_sigaltstack(uss, NULL);
3217
3218 return err == -EFAULT ? err : 0;
3219}
3220
3221int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
3222{
3223 struct task_struct *t = current;
3224 return __put_user(ptr_to_compat((void __user *)t->sas_ss_sp), &uss->ss_sp) |
3225 __put_user(sas_ss_flags(sp), &uss->ss_flags) |
3226 __put_user(t->sas_ss_size, &uss->ss_size);
3227}
3228#endif
3229
3230#ifdef __ARCH_WANT_SYS_SIGPENDING
3231
3232
3233
3234
3235
3236SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
3237{
3238 return sys_rt_sigpending((sigset_t __user *)set, sizeof(old_sigset_t));
3239}
3240
3241#endif
3242
3243#ifdef __ARCH_WANT_SYS_SIGPROCMASK
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
3255 old_sigset_t __user *, oset)
3256{
3257 old_sigset_t old_set, new_set;
3258 sigset_t new_blocked;
3259
3260 old_set = current->blocked.sig[0];
3261
3262 if (nset) {
3263 if (copy_from_user(&new_set, nset, sizeof(*nset)))
3264 return -EFAULT;
3265
3266 new_blocked = current->blocked;
3267
3268 switch (how) {
3269 case SIG_BLOCK:
3270 sigaddsetmask(&new_blocked, new_set);
3271 break;
3272 case SIG_UNBLOCK:
3273 sigdelsetmask(&new_blocked, new_set);
3274 break;
3275 case SIG_SETMASK:
3276 new_blocked.sig[0] = new_set;
3277 break;
3278 default:
3279 return -EINVAL;
3280 }
3281
3282 set_current_blocked(&new_blocked);
3283 }
3284
3285 if (oset) {
3286 if (copy_to_user(oset, &old_set, sizeof(*oset)))
3287 return -EFAULT;
3288 }
3289
3290 return 0;
3291}
3292#endif
3293
3294#ifndef CONFIG_ODD_RT_SIGACTION
3295
3296
3297
3298
3299
3300
3301
3302SYSCALL_DEFINE4(rt_sigaction, int, sig,
3303 const struct sigaction __user *, act,
3304 struct sigaction __user *, oact,
3305 size_t, sigsetsize)
3306{
3307 struct k_sigaction new_sa, old_sa;
3308 int ret = -EINVAL;
3309
3310
3311 if (sigsetsize != sizeof(sigset_t))
3312 goto out;
3313
3314 if (act) {
3315 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
3316 return -EFAULT;
3317 }
3318
3319 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
3320
3321 if (!ret && oact) {
3322 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
3323 return -EFAULT;
3324 }
3325out:
3326 return ret;
3327}
3328#ifdef CONFIG_COMPAT
3329COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig,
3330 const struct compat_sigaction __user *, act,
3331 struct compat_sigaction __user *, oact,
3332 compat_size_t, sigsetsize)
3333{
3334 struct k_sigaction new_ka, old_ka;
3335 compat_sigset_t mask;
3336#ifdef __ARCH_HAS_SA_RESTORER
3337 compat_uptr_t restorer;
3338#endif
3339 int ret;
3340
3341
3342 if (sigsetsize != sizeof(compat_sigset_t))
3343 return -EINVAL;
3344
3345 if (act) {
3346 compat_uptr_t handler;
3347 ret = get_user(handler, &act->sa_handler);
3348 new_ka.sa.sa_handler = compat_ptr(handler);
3349#ifdef __ARCH_HAS_SA_RESTORER
3350 ret |= get_user(restorer, &act->sa_restorer);
3351 new_ka.sa.sa_restorer = compat_ptr(restorer);
3352#endif
3353 ret |= copy_from_user(&mask, &act->sa_mask, sizeof(mask));
3354 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
3355 if (ret)
3356 return -EFAULT;
3357 sigset_from_compat(&new_ka.sa.sa_mask, &mask);
3358 }
3359
3360 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3361 if (!ret && oact) {
3362 sigset_to_compat(&mask, &old_ka.sa.sa_mask);
3363 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler),
3364 &oact->sa_handler);
3365 ret |= copy_to_user(&oact->sa_mask, &mask, sizeof(mask));
3366 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
3367#ifdef __ARCH_HAS_SA_RESTORER
3368 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3369 &oact->sa_restorer);
3370#endif
3371 }
3372 return ret;
3373}
3374#endif
3375#endif
3376
3377#ifdef CONFIG_OLD_SIGACTION
3378SYSCALL_DEFINE3(sigaction, int, sig,
3379 const struct old_sigaction __user *, act,
3380 struct old_sigaction __user *, oact)
3381{
3382 struct k_sigaction new_ka, old_ka;
3383 int ret;
3384
3385 if (act) {
3386 old_sigset_t mask;
3387 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3388 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
3389 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
3390 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3391 __get_user(mask, &act->sa_mask))
3392 return -EFAULT;
3393#ifdef __ARCH_HAS_KA_RESTORER
3394 new_ka.ka_restorer = NULL;
3395#endif
3396 siginitset(&new_ka.sa.sa_mask, mask);
3397 }
3398
3399 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3400
3401 if (!ret && oact) {
3402 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3403 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
3404 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
3405 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3406 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3407 return -EFAULT;
3408 }
3409
3410 return ret;
3411}
3412#endif
3413#ifdef CONFIG_COMPAT_OLD_SIGACTION
3414COMPAT_SYSCALL_DEFINE3(sigaction, int, sig,
3415 const struct compat_old_sigaction __user *, act,
3416 struct compat_old_sigaction __user *, oact)
3417{
3418 struct k_sigaction new_ka, old_ka;
3419 int ret;
3420 compat_old_sigset_t mask;
3421 compat_uptr_t handler, restorer;
3422
3423 if (act) {
3424 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3425 __get_user(handler, &act->sa_handler) ||
3426 __get_user(restorer, &act->sa_restorer) ||
3427 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3428 __get_user(mask, &act->sa_mask))
3429 return -EFAULT;
3430
3431#ifdef __ARCH_HAS_KA_RESTORER
3432 new_ka.ka_restorer = NULL;
3433#endif
3434 new_ka.sa.sa_handler = compat_ptr(handler);
3435 new_ka.sa.sa_restorer = compat_ptr(restorer);
3436 siginitset(&new_ka.sa.sa_mask, mask);
3437 }
3438
3439 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3440
3441 if (!ret && oact) {
3442 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3443 __put_user(ptr_to_compat(old_ka.sa.sa_handler),
3444 &oact->sa_handler) ||
3445 __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3446 &oact->sa_restorer) ||
3447 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3448 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3449 return -EFAULT;
3450 }
3451 return ret;
3452}
3453#endif
3454
3455#ifdef CONFIG_SGETMASK_SYSCALL
3456
3457
3458
3459
3460SYSCALL_DEFINE0(sgetmask)
3461{
3462
3463 return current->blocked.sig[0];
3464}
3465
3466SYSCALL_DEFINE1(ssetmask, int, newmask)
3467{
3468 int old = current->blocked.sig[0];
3469 sigset_t newset;
3470
3471 siginitset(&newset, newmask);
3472 set_current_blocked(&newset);
3473
3474 return old;
3475}
3476#endif
3477
3478#ifdef __ARCH_WANT_SYS_SIGNAL
3479
3480
3481
3482SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
3483{
3484 struct k_sigaction new_sa, old_sa;
3485 int ret;
3486
3487 new_sa.sa.sa_handler = handler;
3488 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
3489 sigemptyset(&new_sa.sa.sa_mask);
3490
3491 ret = do_sigaction(sig, &new_sa, &old_sa);
3492
3493 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
3494}
3495#endif
3496
3497#ifdef __ARCH_WANT_SYS_PAUSE
3498
3499SYSCALL_DEFINE0(pause)
3500{
3501 while (!signal_pending(current)) {
3502 __set_current_state(TASK_INTERRUPTIBLE);
3503 schedule();
3504 }
3505 return -ERESTARTNOHAND;
3506}
3507
3508#endif
3509
3510static int sigsuspend(sigset_t *set)
3511{
3512 current->saved_sigmask = current->blocked;
3513 set_current_blocked(set);
3514
3515 while (!signal_pending(current)) {
3516 __set_current_state(TASK_INTERRUPTIBLE);
3517 schedule();
3518 }
3519 set_restore_sigmask();
3520 return -ERESTARTNOHAND;
3521}
3522
3523
3524
3525
3526
3527
3528
3529SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
3530{
3531 sigset_t newset;
3532
3533
3534 if (sigsetsize != sizeof(sigset_t))
3535 return -EINVAL;
3536
3537 if (copy_from_user(&newset, unewset, sizeof(newset)))
3538 return -EFAULT;
3539 return sigsuspend(&newset);
3540}
3541
3542#ifdef CONFIG_COMPAT
3543COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
3544{
3545#ifdef __BIG_ENDIAN
3546 sigset_t newset;
3547 compat_sigset_t newset32;
3548
3549
3550 if (sigsetsize != sizeof(sigset_t))
3551 return -EINVAL;
3552
3553 if (copy_from_user(&newset32, unewset, sizeof(compat_sigset_t)))
3554 return -EFAULT;
3555 sigset_from_compat(&newset, &newset32);
3556 return sigsuspend(&newset);
3557#else
3558
3559 return sys_rt_sigsuspend((sigset_t __user *)unewset, sigsetsize);
3560#endif
3561}
3562#endif
3563
3564#ifdef CONFIG_OLD_SIGSUSPEND
3565SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
3566{
3567 sigset_t blocked;
3568 siginitset(&blocked, mask);
3569 return sigsuspend(&blocked);
3570}
3571#endif
3572#ifdef CONFIG_OLD_SIGSUSPEND3
3573SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask)
3574{
3575 sigset_t blocked;
3576 siginitset(&blocked, mask);
3577 return sigsuspend(&blocked);
3578}
3579#endif
3580
3581__weak const char *arch_vma_name(struct vm_area_struct *vma)
3582{
3583 return NULL;
3584}
3585
3586void __init signals_init(void)
3587{
3588
3589 BUILD_BUG_ON(__ARCH_SI_PREAMBLE_SIZE
3590 != offsetof(struct siginfo, _sifields._pad));
3591
3592 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
3593}
3594
3595#ifdef CONFIG_KGDB_KDB
3596#include <linux/kdb.h>
3597
3598
3599
3600
3601
3602
3603void
3604kdb_send_sig_info(struct task_struct *t, struct siginfo *info)
3605{
3606 static struct task_struct *kdb_prev_t;
3607 int sig, new_t;
3608 if (!spin_trylock(&t->sighand->siglock)) {
3609 kdb_printf("Can't do kill command now.\n"
3610 "The sigmask lock is held somewhere else in "
3611 "kernel, try again later\n");
3612 return;
3613 }
3614 spin_unlock(&t->sighand->siglock);
3615 new_t = kdb_prev_t != t;
3616 kdb_prev_t = t;
3617 if (t->state != TASK_RUNNING && new_t) {
3618 kdb_printf("Process is not RUNNING, sending a signal from "
3619 "kdb risks deadlock\n"
3620 "on the run queue locks. "
3621 "The signal has _not_ been sent.\n"
3622 "Reissue the kill command if you want to risk "
3623 "the deadlock.\n");
3624 return;
3625 }
3626 sig = info->si_signo;
3627 if (send_sig_info(sig, info, t))
3628 kdb_printf("Fail to deliver Signal %d to process %d.\n",
3629 sig, t->pid);
3630 else
3631 kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
3632}
3633#endif
3634