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