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