1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * linux/kernel/signal.c
4 *
5 * Copyright (C) 1991, 1992 Linus Torvalds
6 *
7 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
8 *
9 * 2003-06-02 Jim Houston - Concurrent Computer Corp.
10 * Changes to use preallocated sigqueue structures
11 * to allow signals to be sent reliably.
12 */
13
14 #include <linux/slab.h>
15 #include <linux/export.h>
16 #include <linux/init.h>
17 #include <linux/sched/mm.h>
18 #include <linux/sched/user.h>
19 #include <linux/sched/debug.h>
20 #include <linux/sched/task.h>
21 #include <linux/sched/task_stack.h>
22 #include <linux/sched/cputime.h>
23 #include <linux/file.h>
24 #include <linux/fs.h>
25 #include <linux/proc_fs.h>
26 #include <linux/tty.h>
27 #include <linux/binfmts.h>
28 #include <linux/coredump.h>
29 #include <linux/security.h>
30 #include <linux/syscalls.h>
31 #include <linux/ptrace.h>
32 #include <linux/signal.h>
33 #include <linux/signalfd.h>
34 #include <linux/ratelimit.h>
35 #include <linux/tracehook.h>
36 #include <linux/capability.h>
37 #include <linux/freezer.h>
38 #include <linux/pid_namespace.h>
39 #include <linux/nsproxy.h>
40 #include <linux/user_namespace.h>
41 #include <linux/uprobes.h>
42 #include <linux/compat.h>
43 #include <linux/cn_proc.h>
44 #include <linux/compiler.h>
45 #include <linux/posix-timers.h>
46 #include <linux/cgroup.h>
47 #include <linux/audit.h>
48
49 #define CREATE_TRACE_POINTS
50 #include <trace/events/signal.h>
51
52 #include <asm/param.h>
53 #include <linux/uaccess.h>
54 #include <asm/unistd.h>
55 #include <asm/siginfo.h>
56 #include <asm/cacheflush.h>
57
58 /*
59 * SLAB caches for signal bits.
60 */
61
62 static struct kmem_cache *sigqueue_cachep;
63
64 int print_fatal_signals __read_mostly;
65
sig_handler(struct task_struct * t,int sig)66 static void __user *sig_handler(struct task_struct *t, int sig)
67 {
68 return t->sighand->action[sig - 1].sa.sa_handler;
69 }
70
sig_handler_ignored(void __user * handler,int sig)71 static inline bool sig_handler_ignored(void __user *handler, int sig)
72 {
73 /* Is it explicitly or implicitly ignored? */
74 return handler == SIG_IGN ||
75 (handler == SIG_DFL && sig_kernel_ignore(sig));
76 }
77
sig_task_ignored(struct task_struct * t,int sig,bool force)78 static bool sig_task_ignored(struct task_struct *t, int sig, bool force)
79 {
80 void __user *handler;
81
82 handler = sig_handler(t, sig);
83
84 /* SIGKILL and SIGSTOP may not be sent to the global init */
85 if (unlikely(is_global_init(t) && sig_kernel_only(sig)))
86 return true;
87
88 if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
89 handler == SIG_DFL && !(force && sig_kernel_only(sig)))
90 return true;
91
92 /* Only allow kernel generated signals to this kthread */
93 if (unlikely((t->flags & PF_KTHREAD) &&
94 (handler == SIG_KTHREAD_KERNEL) && !force))
95 return true;
96
97 return sig_handler_ignored(handler, sig);
98 }
99
sig_ignored(struct task_struct * t,int sig,bool force)100 static bool sig_ignored(struct task_struct *t, int sig, bool force)
101 {
102 /*
103 * Blocked signals are never ignored, since the
104 * signal handler may change by the time it is
105 * unblocked.
106 */
107 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
108 return false;
109
110 /*
111 * Tracers may want to know about even ignored signal unless it
112 * is SIGKILL which can't be reported anyway but can be ignored
113 * by SIGNAL_UNKILLABLE task.
114 */
115 if (t->ptrace && sig != SIGKILL)
116 return false;
117
118 return sig_task_ignored(t, sig, force);
119 }
120
121 /*
122 * Re-calculate pending state from the set of locally pending
123 * signals, globally pending signals, and blocked signals.
124 */
has_pending_signals(sigset_t * signal,sigset_t * blocked)125 static inline bool has_pending_signals(sigset_t *signal, sigset_t *blocked)
126 {
127 unsigned long ready;
128 long i;
129
130 switch (_NSIG_WORDS) {
131 default:
132 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
133 ready |= signal->sig[i] &~ blocked->sig[i];
134 break;
135
136 case 4: ready = signal->sig[3] &~ blocked->sig[3];
137 ready |= signal->sig[2] &~ blocked->sig[2];
138 ready |= signal->sig[1] &~ blocked->sig[1];
139 ready |= signal->sig[0] &~ blocked->sig[0];
140 break;
141
142 case 2: ready = signal->sig[1] &~ blocked->sig[1];
143 ready |= signal->sig[0] &~ blocked->sig[0];
144 break;
145
146 case 1: ready = signal->sig[0] &~ blocked->sig[0];
147 }
148 return ready != 0;
149 }
150
151 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
152
recalc_sigpending_tsk(struct task_struct * t)153 static bool recalc_sigpending_tsk(struct task_struct *t)
154 {
155 if ((t->jobctl & (JOBCTL_PENDING_MASK | JOBCTL_TRAP_FREEZE)) ||
156 PENDING(&t->pending, &t->blocked) ||
157 PENDING(&t->signal->shared_pending, &t->blocked) ||
158 cgroup_task_frozen(t)) {
159 set_tsk_thread_flag(t, TIF_SIGPENDING);
160 return true;
161 }
162
163 /*
164 * We must never clear the flag in another thread, or in current
165 * when it's possible the current syscall is returning -ERESTART*.
166 * So we don't clear it here, and only callers who know they should do.
167 */
168 return false;
169 }
170
171 /*
172 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
173 * This is superfluous when called on current, the wakeup is a harmless no-op.
174 */
recalc_sigpending_and_wake(struct task_struct * t)175 void recalc_sigpending_and_wake(struct task_struct *t)
176 {
177 if (recalc_sigpending_tsk(t))
178 signal_wake_up(t, 0);
179 }
180
recalc_sigpending(void)181 void recalc_sigpending(void)
182 {
183 if (!recalc_sigpending_tsk(current) && !freezing(current))
184 clear_thread_flag(TIF_SIGPENDING);
185
186 }
187 EXPORT_SYMBOL(recalc_sigpending);
188
calculate_sigpending(void)189 void calculate_sigpending(void)
190 {
191 /* Have any signals or users of TIF_SIGPENDING been delayed
192 * until after fork?
193 */
194 spin_lock_irq(¤t->sighand->siglock);
195 set_tsk_thread_flag(current, TIF_SIGPENDING);
196 recalc_sigpending();
197 spin_unlock_irq(¤t->sighand->siglock);
198 }
199
200 /* Given the mask, find the first available signal that should be serviced. */
201
202 #define SYNCHRONOUS_MASK \
203 (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
204 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
205
next_signal(struct sigpending * pending,sigset_t * mask)206 int next_signal(struct sigpending *pending, sigset_t *mask)
207 {
208 unsigned long i, *s, *m, x;
209 int sig = 0;
210
211 s = pending->signal.sig;
212 m = mask->sig;
213
214 /*
215 * Handle the first word specially: it contains the
216 * synchronous signals that need to be dequeued first.
217 */
218 x = *s &~ *m;
219 if (x) {
220 if (x & SYNCHRONOUS_MASK)
221 x &= SYNCHRONOUS_MASK;
222 sig = ffz(~x) + 1;
223 return sig;
224 }
225
226 switch (_NSIG_WORDS) {
227 default:
228 for (i = 1; i < _NSIG_WORDS; ++i) {
229 x = *++s &~ *++m;
230 if (!x)
231 continue;
232 sig = ffz(~x) + i*_NSIG_BPW + 1;
233 break;
234 }
235 break;
236
237 case 2:
238 x = s[1] &~ m[1];
239 if (!x)
240 break;
241 sig = ffz(~x) + _NSIG_BPW + 1;
242 break;
243
244 case 1:
245 /* Nothing to do */
246 break;
247 }
248
249 return sig;
250 }
251
print_dropped_signal(int sig)252 static inline void print_dropped_signal(int sig)
253 {
254 static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
255
256 if (!print_fatal_signals)
257 return;
258
259 if (!__ratelimit(&ratelimit_state))
260 return;
261
262 pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
263 current->comm, current->pid, sig);
264 }
265
266 /**
267 * task_set_jobctl_pending - set jobctl pending bits
268 * @task: target task
269 * @mask: pending bits to set
270 *
271 * Clear @mask from @task->jobctl. @mask must be subset of
272 * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
273 * %JOBCTL_TRAPPING. If stop signo is being set, the existing signo is
274 * cleared. If @task is already being killed or exiting, this function
275 * becomes noop.
276 *
277 * CONTEXT:
278 * Must be called with @task->sighand->siglock held.
279 *
280 * RETURNS:
281 * %true if @mask is set, %false if made noop because @task was dying.
282 */
task_set_jobctl_pending(struct task_struct * task,unsigned long mask)283 bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
284 {
285 BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
286 JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
287 BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
288
289 if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
290 return false;
291
292 if (mask & JOBCTL_STOP_SIGMASK)
293 task->jobctl &= ~JOBCTL_STOP_SIGMASK;
294
295 task->jobctl |= mask;
296 return true;
297 }
298
299 /**
300 * task_clear_jobctl_trapping - clear jobctl trapping bit
301 * @task: target task
302 *
303 * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
304 * Clear it and wake up the ptracer. Note that we don't need any further
305 * locking. @task->siglock guarantees that @task->parent points to the
306 * ptracer.
307 *
308 * CONTEXT:
309 * Must be called with @task->sighand->siglock held.
310 */
task_clear_jobctl_trapping(struct task_struct * task)311 void task_clear_jobctl_trapping(struct task_struct *task)
312 {
313 if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
314 task->jobctl &= ~JOBCTL_TRAPPING;
315 smp_mb(); /* advised by wake_up_bit() */
316 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
317 }
318 }
319
320 /**
321 * task_clear_jobctl_pending - clear jobctl pending bits
322 * @task: target task
323 * @mask: pending bits to clear
324 *
325 * Clear @mask from @task->jobctl. @mask must be subset of
326 * %JOBCTL_PENDING_MASK. If %JOBCTL_STOP_PENDING is being cleared, other
327 * STOP bits are cleared together.
328 *
329 * If clearing of @mask leaves no stop or trap pending, this function calls
330 * task_clear_jobctl_trapping().
331 *
332 * CONTEXT:
333 * Must be called with @task->sighand->siglock held.
334 */
task_clear_jobctl_pending(struct task_struct * task,unsigned long mask)335 void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
336 {
337 BUG_ON(mask & ~JOBCTL_PENDING_MASK);
338
339 if (mask & JOBCTL_STOP_PENDING)
340 mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
341
342 task->jobctl &= ~mask;
343
344 if (!(task->jobctl & JOBCTL_PENDING_MASK))
345 task_clear_jobctl_trapping(task);
346 }
347
348 /**
349 * task_participate_group_stop - participate in a group stop
350 * @task: task participating in a group stop
351 *
352 * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
353 * Group stop states are cleared and the group stop count is consumed if
354 * %JOBCTL_STOP_CONSUME was set. If the consumption completes the group
355 * stop, the appropriate `SIGNAL_*` flags are set.
356 *
357 * CONTEXT:
358 * Must be called with @task->sighand->siglock held.
359 *
360 * RETURNS:
361 * %true if group stop completion should be notified to the parent, %false
362 * otherwise.
363 */
task_participate_group_stop(struct task_struct * task)364 static bool task_participate_group_stop(struct task_struct *task)
365 {
366 struct signal_struct *sig = task->signal;
367 bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
368
369 WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
370
371 task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
372
373 if (!consume)
374 return false;
375
376 if (!WARN_ON_ONCE(sig->group_stop_count == 0))
377 sig->group_stop_count--;
378
379 /*
380 * Tell the caller to notify completion iff we are entering into a
381 * fresh group stop. Read comment in do_signal_stop() for details.
382 */
383 if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
384 signal_set_stop_flags(sig, SIGNAL_STOP_STOPPED);
385 return true;
386 }
387 return false;
388 }
389
task_join_group_stop(struct task_struct * task)390 void task_join_group_stop(struct task_struct *task)
391 {
392 unsigned long mask = current->jobctl & JOBCTL_STOP_SIGMASK;
393 struct signal_struct *sig = current->signal;
394
395 if (sig->group_stop_count) {
396 sig->group_stop_count++;
397 mask |= JOBCTL_STOP_CONSUME;
398 } else if (!(sig->flags & SIGNAL_STOP_STOPPED))
399 return;
400
401 /* Have the new thread join an on-going signal group stop */
402 task_set_jobctl_pending(task, mask | JOBCTL_STOP_PENDING);
403 }
404
405 /*
406 * allocate a new signal queue record
407 * - this may be called without locks if and only if t == current, otherwise an
408 * appropriate lock must be held to stop the target task from exiting
409 */
410 static struct sigqueue *
__sigqueue_alloc(int sig,struct task_struct * t,gfp_t gfp_flags,int override_rlimit,const unsigned int sigqueue_flags)411 __sigqueue_alloc(int sig, struct task_struct *t, gfp_t gfp_flags,
412 int override_rlimit, const unsigned int sigqueue_flags)
413 {
414 struct sigqueue *q = NULL;
415 struct user_struct *user;
416 int sigpending;
417
418 /*
419 * Protect access to @t credentials. This can go away when all
420 * callers hold rcu read lock.
421 *
422 * NOTE! A pending signal will hold on to the user refcount,
423 * and we get/put the refcount only when the sigpending count
424 * changes from/to zero.
425 */
426 rcu_read_lock();
427 user = __task_cred(t)->user;
428 sigpending = atomic_inc_return(&user->sigpending);
429 if (sigpending == 1)
430 get_uid(user);
431 rcu_read_unlock();
432
433 if (override_rlimit || likely(sigpending <= task_rlimit(t, RLIMIT_SIGPENDING))) {
434 /*
435 * Preallocation does not hold sighand::siglock so it can't
436 * use the cache. The lockless caching requires that only
437 * one consumer and only one producer run at a time.
438 */
439 q = READ_ONCE(t->sigqueue_cache);
440 if (!q || sigqueue_flags)
441 q = kmem_cache_alloc(sigqueue_cachep, gfp_flags);
442 else
443 WRITE_ONCE(t->sigqueue_cache, NULL);
444 } else {
445 print_dropped_signal(sig);
446 }
447
448 if (unlikely(q == NULL)) {
449 if (atomic_dec_and_test(&user->sigpending))
450 free_uid(user);
451 } else {
452 INIT_LIST_HEAD(&q->list);
453 q->flags = sigqueue_flags;
454 q->user = user;
455 }
456
457 return q;
458 }
459
exit_task_sigqueue_cache(struct task_struct * tsk)460 void exit_task_sigqueue_cache(struct task_struct *tsk)
461 {
462 /* Race free because @tsk is mopped up */
463 struct sigqueue *q = tsk->sigqueue_cache;
464
465 if (q) {
466 tsk->sigqueue_cache = NULL;
467 /*
468 * Hand it back to the cache as the task might
469 * be self reaping which would leak the object.
470 */
471 kmem_cache_free(sigqueue_cachep, q);
472 }
473 }
474
sigqueue_cache_or_free(struct sigqueue * q)475 static void sigqueue_cache_or_free(struct sigqueue *q)
476 {
477 /*
478 * Cache one sigqueue per task. This pairs with the consumer side
479 * in __sigqueue_alloc() and needs READ/WRITE_ONCE() to prevent the
480 * compiler from store tearing and to tell KCSAN that the data race
481 * is intentional when run without holding current->sighand->siglock,
482 * which is fine as current obviously cannot run __sigqueue_free()
483 * concurrently.
484 */
485 if (!READ_ONCE(current->sigqueue_cache))
486 WRITE_ONCE(current->sigqueue_cache, q);
487 else
488 kmem_cache_free(sigqueue_cachep, q);
489 }
490
__sigqueue_free(struct sigqueue * q)491 static void __sigqueue_free(struct sigqueue *q)
492 {
493 if (q->flags & SIGQUEUE_PREALLOC)
494 return;
495 if (atomic_dec_and_test(&q->user->sigpending))
496 free_uid(q->user);
497 sigqueue_cache_or_free(q);
498 }
499
flush_sigqueue(struct sigpending * queue)500 void flush_sigqueue(struct sigpending *queue)
501 {
502 struct sigqueue *q;
503
504 sigemptyset(&queue->signal);
505 while (!list_empty(&queue->list)) {
506 q = list_entry(queue->list.next, struct sigqueue , list);
507 list_del_init(&q->list);
508 __sigqueue_free(q);
509 }
510 }
511
512 /*
513 * Flush all pending signals for this kthread.
514 */
flush_signals(struct task_struct * t)515 void flush_signals(struct task_struct *t)
516 {
517 unsigned long flags;
518
519 spin_lock_irqsave(&t->sighand->siglock, flags);
520 clear_tsk_thread_flag(t, TIF_SIGPENDING);
521 flush_sigqueue(&t->pending);
522 flush_sigqueue(&t->signal->shared_pending);
523 spin_unlock_irqrestore(&t->sighand->siglock, flags);
524 }
525 EXPORT_SYMBOL(flush_signals);
526
527 #ifdef CONFIG_POSIX_TIMERS
__flush_itimer_signals(struct sigpending * pending)528 static void __flush_itimer_signals(struct sigpending *pending)
529 {
530 sigset_t signal, retain;
531 struct sigqueue *q, *n;
532
533 signal = pending->signal;
534 sigemptyset(&retain);
535
536 list_for_each_entry_safe(q, n, &pending->list, list) {
537 int sig = q->info.si_signo;
538
539 if (likely(q->info.si_code != SI_TIMER)) {
540 sigaddset(&retain, sig);
541 } else {
542 sigdelset(&signal, sig);
543 list_del_init(&q->list);
544 __sigqueue_free(q);
545 }
546 }
547
548 sigorsets(&pending->signal, &signal, &retain);
549 }
550
flush_itimer_signals(void)551 void flush_itimer_signals(void)
552 {
553 struct task_struct *tsk = current;
554 unsigned long flags;
555
556 spin_lock_irqsave(&tsk->sighand->siglock, flags);
557 __flush_itimer_signals(&tsk->pending);
558 __flush_itimer_signals(&tsk->signal->shared_pending);
559 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
560 }
561 #endif
562
ignore_signals(struct task_struct * t)563 void ignore_signals(struct task_struct *t)
564 {
565 int i;
566
567 for (i = 0; i < _NSIG; ++i)
568 t->sighand->action[i].sa.sa_handler = SIG_IGN;
569
570 flush_signals(t);
571 }
572
573 /*
574 * Flush all handlers for a task.
575 */
576
577 void
flush_signal_handlers(struct task_struct * t,int force_default)578 flush_signal_handlers(struct task_struct *t, int force_default)
579 {
580 int i;
581 struct k_sigaction *ka = &t->sighand->action[0];
582 for (i = _NSIG ; i != 0 ; i--) {
583 if (force_default || ka->sa.sa_handler != SIG_IGN)
584 ka->sa.sa_handler = SIG_DFL;
585 ka->sa.sa_flags = 0;
586 #ifdef __ARCH_HAS_SA_RESTORER
587 ka->sa.sa_restorer = NULL;
588 #endif
589 sigemptyset(&ka->sa.sa_mask);
590 ka++;
591 }
592 }
593
unhandled_signal(struct task_struct * tsk,int sig)594 bool unhandled_signal(struct task_struct *tsk, int sig)
595 {
596 void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
597 if (is_global_init(tsk))
598 return true;
599
600 if (handler != SIG_IGN && handler != SIG_DFL)
601 return false;
602
603 /* if ptraced, let the tracer determine */
604 return !tsk->ptrace;
605 }
606
collect_signal(int sig,struct sigpending * list,kernel_siginfo_t * info,bool * resched_timer)607 static void collect_signal(int sig, struct sigpending *list, kernel_siginfo_t *info,
608 bool *resched_timer)
609 {
610 struct sigqueue *q, *first = NULL;
611
612 /*
613 * Collect the siginfo appropriate to this signal. Check if
614 * there is another siginfo for the same signal.
615 */
616 list_for_each_entry(q, &list->list, list) {
617 if (q->info.si_signo == sig) {
618 if (first)
619 goto still_pending;
620 first = q;
621 }
622 }
623
624 sigdelset(&list->signal, sig);
625
626 if (first) {
627 still_pending:
628 list_del_init(&first->list);
629 copy_siginfo(info, &first->info);
630
631 *resched_timer =
632 (first->flags & SIGQUEUE_PREALLOC) &&
633 (info->si_code == SI_TIMER) &&
634 (info->si_sys_private);
635
636 __sigqueue_free(first);
637 } else {
638 /*
639 * Ok, it wasn't in the queue. This must be
640 * a fast-pathed signal or we must have been
641 * out of queue space. So zero out the info.
642 */
643 clear_siginfo(info);
644 info->si_signo = sig;
645 info->si_errno = 0;
646 info->si_code = SI_USER;
647 info->si_pid = 0;
648 info->si_uid = 0;
649 }
650 }
651
__dequeue_signal(struct sigpending * pending,sigset_t * mask,kernel_siginfo_t * info,bool * resched_timer)652 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
653 kernel_siginfo_t *info, bool *resched_timer)
654 {
655 int sig = next_signal(pending, mask);
656
657 if (sig)
658 collect_signal(sig, pending, info, resched_timer);
659 return sig;
660 }
661
662 /*
663 * Dequeue a signal and return the element to the caller, which is
664 * expected to free it.
665 *
666 * All callers have to hold the siglock.
667 */
dequeue_signal(struct task_struct * tsk,sigset_t * mask,kernel_siginfo_t * info)668 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, kernel_siginfo_t *info)
669 {
670 bool resched_timer = false;
671 int signr;
672
673 /* We only dequeue private signals from ourselves, we don't let
674 * signalfd steal them
675 */
676 signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer);
677 if (!signr) {
678 signr = __dequeue_signal(&tsk->signal->shared_pending,
679 mask, info, &resched_timer);
680 #ifdef CONFIG_POSIX_TIMERS
681 /*
682 * itimer signal ?
683 *
684 * itimers are process shared and we restart periodic
685 * itimers in the signal delivery path to prevent DoS
686 * attacks in the high resolution timer case. This is
687 * compliant with the old way of self-restarting
688 * itimers, as the SIGALRM is a legacy signal and only
689 * queued once. Changing the restart behaviour to
690 * restart the timer in the signal dequeue path is
691 * reducing the timer noise on heavy loaded !highres
692 * systems too.
693 */
694 if (unlikely(signr == SIGALRM)) {
695 struct hrtimer *tmr = &tsk->signal->real_timer;
696
697 if (!hrtimer_is_queued(tmr) &&
698 tsk->signal->it_real_incr != 0) {
699 hrtimer_forward(tmr, tmr->base->get_time(),
700 tsk->signal->it_real_incr);
701 hrtimer_restart(tmr);
702 }
703 }
704 #endif
705 }
706
707 recalc_sigpending();
708 if (!signr)
709 return 0;
710
711 if (unlikely(sig_kernel_stop(signr))) {
712 /*
713 * Set a marker that we have dequeued a stop signal. Our
714 * caller might release the siglock and then the pending
715 * stop signal it is about to process is no longer in the
716 * pending bitmasks, but must still be cleared by a SIGCONT
717 * (and overruled by a SIGKILL). So those cases clear this
718 * shared flag after we've set it. Note that this flag may
719 * remain set after the signal we return is ignored or
720 * handled. That doesn't matter because its only purpose
721 * is to alert stop-signal processing code when another
722 * processor has come along and cleared the flag.
723 */
724 current->jobctl |= JOBCTL_STOP_DEQUEUED;
725 }
726 #ifdef CONFIG_POSIX_TIMERS
727 if (resched_timer) {
728 /*
729 * Release the siglock to ensure proper locking order
730 * of timer locks outside of siglocks. Note, we leave
731 * irqs disabled here, since the posix-timers code is
732 * about to disable them again anyway.
733 */
734 spin_unlock(&tsk->sighand->siglock);
735 posixtimer_rearm(info);
736 spin_lock(&tsk->sighand->siglock);
737
738 /* Don't expose the si_sys_private value to userspace */
739 info->si_sys_private = 0;
740 }
741 #endif
742 return signr;
743 }
744 EXPORT_SYMBOL_GPL(dequeue_signal);
745
dequeue_synchronous_signal(kernel_siginfo_t * info)746 static int dequeue_synchronous_signal(kernel_siginfo_t *info)
747 {
748 struct task_struct *tsk = current;
749 struct sigpending *pending = &tsk->pending;
750 struct sigqueue *q, *sync = NULL;
751
752 /*
753 * Might a synchronous signal be in the queue?
754 */
755 if (!((pending->signal.sig[0] & ~tsk->blocked.sig[0]) & SYNCHRONOUS_MASK))
756 return 0;
757
758 /*
759 * Return the first synchronous signal in the queue.
760 */
761 list_for_each_entry(q, &pending->list, list) {
762 /* Synchronous signals have a positive si_code */
763 if ((q->info.si_code > SI_USER) &&
764 (sigmask(q->info.si_signo) & SYNCHRONOUS_MASK)) {
765 sync = q;
766 goto next;
767 }
768 }
769 return 0;
770 next:
771 /*
772 * Check if there is another siginfo for the same signal.
773 */
774 list_for_each_entry_continue(q, &pending->list, list) {
775 if (q->info.si_signo == sync->info.si_signo)
776 goto still_pending;
777 }
778
779 sigdelset(&pending->signal, sync->info.si_signo);
780 recalc_sigpending();
781 still_pending:
782 list_del_init(&sync->list);
783 copy_siginfo(info, &sync->info);
784 __sigqueue_free(sync);
785 return info->si_signo;
786 }
787
788 /*
789 * Tell a process that it has a new active signal..
790 *
791 * NOTE! we rely on the previous spin_lock to
792 * lock interrupts for us! We can only be called with
793 * "siglock" held, and the local interrupt must
794 * have been disabled when that got acquired!
795 *
796 * No need to set need_resched since signal event passing
797 * goes through ->blocked
798 */
signal_wake_up_state(struct task_struct * t,unsigned int state)799 void signal_wake_up_state(struct task_struct *t, unsigned int state)
800 {
801 set_tsk_thread_flag(t, TIF_SIGPENDING);
802 /*
803 * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
804 * case. We don't check t->state here because there is a race with it
805 * executing another processor and just now entering stopped state.
806 * By using wake_up_state, we ensure the process will wake up and
807 * handle its death signal.
808 */
809 if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
810 kick_process(t);
811 }
812
813 /*
814 * Remove signals in mask from the pending set and queue.
815 * Returns 1 if any signals were found.
816 *
817 * All callers must be holding the siglock.
818 */
flush_sigqueue_mask(sigset_t * mask,struct sigpending * s)819 static void flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
820 {
821 struct sigqueue *q, *n;
822 sigset_t m;
823
824 sigandsets(&m, mask, &s->signal);
825 if (sigisemptyset(&m))
826 return;
827
828 sigandnsets(&s->signal, &s->signal, mask);
829 list_for_each_entry_safe(q, n, &s->list, list) {
830 if (sigismember(mask, q->info.si_signo)) {
831 list_del_init(&q->list);
832 __sigqueue_free(q);
833 }
834 }
835 }
836
is_si_special(const struct kernel_siginfo * info)837 static inline int is_si_special(const struct kernel_siginfo *info)
838 {
839 return info <= SEND_SIG_PRIV;
840 }
841
si_fromuser(const struct kernel_siginfo * info)842 static inline bool si_fromuser(const struct kernel_siginfo *info)
843 {
844 return info == SEND_SIG_NOINFO ||
845 (!is_si_special(info) && SI_FROMUSER(info));
846 }
847
848 /*
849 * called with RCU read lock from check_kill_permission()
850 */
kill_ok_by_cred(struct task_struct * t)851 static bool kill_ok_by_cred(struct task_struct *t)
852 {
853 const struct cred *cred = current_cred();
854 const struct cred *tcred = __task_cred(t);
855
856 return uid_eq(cred->euid, tcred->suid) ||
857 uid_eq(cred->euid, tcred->uid) ||
858 uid_eq(cred->uid, tcred->suid) ||
859 uid_eq(cred->uid, tcred->uid) ||
860 ns_capable(tcred->user_ns, CAP_KILL);
861 }
862
863 /*
864 * Bad permissions for sending the signal
865 * - the caller must hold the RCU read lock
866 */
check_kill_permission(int sig,struct kernel_siginfo * info,struct task_struct * t)867 static int check_kill_permission(int sig, struct kernel_siginfo *info,
868 struct task_struct *t)
869 {
870 struct pid *sid;
871 int error;
872
873 if (!valid_signal(sig))
874 return -EINVAL;
875
876 if (!si_fromuser(info))
877 return 0;
878
879 error = audit_signal_info(sig, t); /* Let audit system see the signal */
880 if (error)
881 return error;
882
883 if (!same_thread_group(current, t) &&
884 !kill_ok_by_cred(t)) {
885 switch (sig) {
886 case SIGCONT:
887 sid = task_session(t);
888 /*
889 * We don't return the error if sid == NULL. The
890 * task was unhashed, the caller must notice this.
891 */
892 if (!sid || sid == task_session(current))
893 break;
894 fallthrough;
895 default:
896 return -EPERM;
897 }
898 }
899
900 return security_task_kill(t, info, sig, NULL);
901 }
902
903 /**
904 * ptrace_trap_notify - schedule trap to notify ptracer
905 * @t: tracee wanting to notify tracer
906 *
907 * This function schedules sticky ptrace trap which is cleared on the next
908 * TRAP_STOP to notify ptracer of an event. @t must have been seized by
909 * ptracer.
910 *
911 * If @t is running, STOP trap will be taken. If trapped for STOP and
912 * ptracer is listening for events, tracee is woken up so that it can
913 * re-trap for the new event. If trapped otherwise, STOP trap will be
914 * eventually taken without returning to userland after the existing traps
915 * are finished by PTRACE_CONT.
916 *
917 * CONTEXT:
918 * Must be called with @task->sighand->siglock held.
919 */
ptrace_trap_notify(struct task_struct * t)920 static void ptrace_trap_notify(struct task_struct *t)
921 {
922 WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
923 assert_spin_locked(&t->sighand->siglock);
924
925 task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
926 ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
927 }
928
929 /*
930 * Handle magic process-wide effects of stop/continue signals. Unlike
931 * the signal actions, these happen immediately at signal-generation
932 * time regardless of blocking, ignoring, or handling. This does the
933 * actual continuing for SIGCONT, but not the actual stopping for stop
934 * signals. The process stop is done as a signal action for SIG_DFL.
935 *
936 * Returns true if the signal should be actually delivered, otherwise
937 * it should be dropped.
938 */
prepare_signal(int sig,struct task_struct * p,bool force)939 static bool prepare_signal(int sig, struct task_struct *p, bool force)
940 {
941 struct signal_struct *signal = p->signal;
942 struct task_struct *t;
943 sigset_t flush;
944
945 if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
946 if (!(signal->flags & SIGNAL_GROUP_EXIT))
947 return sig == SIGKILL;
948 /*
949 * The process is in the middle of dying, nothing to do.
950 */
951 } else if (sig_kernel_stop(sig)) {
952 /*
953 * This is a stop signal. Remove SIGCONT from all queues.
954 */
955 siginitset(&flush, sigmask(SIGCONT));
956 flush_sigqueue_mask(&flush, &signal->shared_pending);
957 for_each_thread(p, t)
958 flush_sigqueue_mask(&flush, &t->pending);
959 } else if (sig == SIGCONT) {
960 unsigned int why;
961 /*
962 * Remove all stop signals from all queues, wake all threads.
963 */
964 siginitset(&flush, SIG_KERNEL_STOP_MASK);
965 flush_sigqueue_mask(&flush, &signal->shared_pending);
966 for_each_thread(p, t) {
967 flush_sigqueue_mask(&flush, &t->pending);
968 task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
969 if (likely(!(t->ptrace & PT_SEIZED)))
970 wake_up_state(t, __TASK_STOPPED);
971 else
972 ptrace_trap_notify(t);
973 }
974
975 /*
976 * Notify the parent with CLD_CONTINUED if we were stopped.
977 *
978 * If we were in the middle of a group stop, we pretend it
979 * was already finished, and then continued. Since SIGCHLD
980 * doesn't queue we report only CLD_STOPPED, as if the next
981 * CLD_CONTINUED was dropped.
982 */
983 why = 0;
984 if (signal->flags & SIGNAL_STOP_STOPPED)
985 why |= SIGNAL_CLD_CONTINUED;
986 else if (signal->group_stop_count)
987 why |= SIGNAL_CLD_STOPPED;
988
989 if (why) {
990 /*
991 * The first thread which returns from do_signal_stop()
992 * will take ->siglock, notice SIGNAL_CLD_MASK, and
993 * notify its parent. See get_signal().
994 */
995 signal_set_stop_flags(signal, why | SIGNAL_STOP_CONTINUED);
996 signal->group_stop_count = 0;
997 signal->group_exit_code = 0;
998 }
999 }
1000
1001 return !sig_ignored(p, sig, force);
1002 }
1003
1004 /*
1005 * Test if P wants to take SIG. After we've checked all threads with this,
1006 * it's equivalent to finding no threads not blocking SIG. Any threads not
1007 * blocking SIG were ruled out because they are not running and already
1008 * have pending signals. Such threads will dequeue from the shared queue
1009 * as soon as they're available, so putting the signal on the shared queue
1010 * will be equivalent to sending it to one such thread.
1011 */
wants_signal(int sig,struct task_struct * p)1012 static inline bool wants_signal(int sig, struct task_struct *p)
1013 {
1014 if (sigismember(&p->blocked, sig))
1015 return false;
1016
1017 if (p->flags & PF_EXITING)
1018 return false;
1019
1020 if (sig == SIGKILL)
1021 return true;
1022
1023 if (task_is_stopped_or_traced(p))
1024 return false;
1025
1026 return task_curr(p) || !task_sigpending(p);
1027 }
1028
complete_signal(int sig,struct task_struct * p,enum pid_type type)1029 static void complete_signal(int sig, struct task_struct *p, enum pid_type type)
1030 {
1031 struct signal_struct *signal = p->signal;
1032 struct task_struct *t;
1033
1034 /*
1035 * Now find a thread we can wake up to take the signal off the queue.
1036 *
1037 * If the main thread wants the signal, it gets first crack.
1038 * Probably the least surprising to the average bear.
1039 */
1040 if (wants_signal(sig, p))
1041 t = p;
1042 else if ((type == PIDTYPE_PID) || thread_group_empty(p))
1043 /*
1044 * There is just one thread and it does not need to be woken.
1045 * It will dequeue unblocked signals before it runs again.
1046 */
1047 return;
1048 else {
1049 /*
1050 * Otherwise try to find a suitable thread.
1051 */
1052 t = signal->curr_target;
1053 while (!wants_signal(sig, t)) {
1054 t = next_thread(t);
1055 if (t == signal->curr_target)
1056 /*
1057 * No thread needs to be woken.
1058 * Any eligible threads will see
1059 * the signal in the queue soon.
1060 */
1061 return;
1062 }
1063 signal->curr_target = t;
1064 }
1065
1066 /*
1067 * Found a killable thread. If the signal will be fatal,
1068 * then start taking the whole group down immediately.
1069 */
1070 if (sig_fatal(p, sig) &&
1071 !(signal->flags & SIGNAL_GROUP_EXIT) &&
1072 !sigismember(&t->real_blocked, sig) &&
1073 (sig == SIGKILL || !p->ptrace)) {
1074 /*
1075 * This signal will be fatal to the whole group.
1076 */
1077 if (!sig_kernel_coredump(sig)) {
1078 /*
1079 * Start a group exit and wake everybody up.
1080 * This way we don't have other threads
1081 * running and doing things after a slower
1082 * thread has the fatal signal pending.
1083 */
1084 signal->flags = SIGNAL_GROUP_EXIT;
1085 signal->group_exit_code = sig;
1086 signal->group_stop_count = 0;
1087 t = p;
1088 do {
1089 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1090 sigaddset(&t->pending.signal, SIGKILL);
1091 signal_wake_up(t, 1);
1092 } while_each_thread(p, t);
1093 return;
1094 }
1095 }
1096
1097 /*
1098 * The signal is already in the shared-pending queue.
1099 * Tell the chosen thread to wake up and dequeue it.
1100 */
1101 signal_wake_up(t, sig == SIGKILL);
1102 return;
1103 }
1104
legacy_queue(struct sigpending * signals,int sig)1105 static inline bool legacy_queue(struct sigpending *signals, int sig)
1106 {
1107 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
1108 }
1109
__send_signal(int sig,struct kernel_siginfo * info,struct task_struct * t,enum pid_type type,bool force)1110 static int __send_signal(int sig, struct kernel_siginfo *info, struct task_struct *t,
1111 enum pid_type type, bool force)
1112 {
1113 struct sigpending *pending;
1114 struct sigqueue *q;
1115 int override_rlimit;
1116 int ret = 0, result;
1117
1118 assert_spin_locked(&t->sighand->siglock);
1119
1120 result = TRACE_SIGNAL_IGNORED;
1121 if (!prepare_signal(sig, t, force))
1122 goto ret;
1123
1124 pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending;
1125 /*
1126 * Short-circuit ignored signals and support queuing
1127 * exactly one non-rt signal, so that we can get more
1128 * detailed information about the cause of the signal.
1129 */
1130 result = TRACE_SIGNAL_ALREADY_PENDING;
1131 if (legacy_queue(pending, sig))
1132 goto ret;
1133
1134 result = TRACE_SIGNAL_DELIVERED;
1135 /*
1136 * Skip useless siginfo allocation for SIGKILL and kernel threads.
1137 */
1138 if ((sig == SIGKILL) || (t->flags & PF_KTHREAD))
1139 goto out_set;
1140
1141 /*
1142 * Real-time signals must be queued if sent by sigqueue, or
1143 * some other real-time mechanism. It is implementation
1144 * defined whether kill() does so. We attempt to do so, on
1145 * the principle of least surprise, but since kill is not
1146 * allowed to fail with EAGAIN when low on memory we just
1147 * make sure at least one signal gets delivered and don't
1148 * pass on the info struct.
1149 */
1150 if (sig < SIGRTMIN)
1151 override_rlimit = (is_si_special(info) || info->si_code >= 0);
1152 else
1153 override_rlimit = 0;
1154
1155 q = __sigqueue_alloc(sig, t, GFP_ATOMIC, override_rlimit, 0);
1156
1157 if (q) {
1158 list_add_tail(&q->list, &pending->list);
1159 switch ((unsigned long) info) {
1160 case (unsigned long) SEND_SIG_NOINFO:
1161 clear_siginfo(&q->info);
1162 q->info.si_signo = sig;
1163 q->info.si_errno = 0;
1164 q->info.si_code = SI_USER;
1165 q->info.si_pid = task_tgid_nr_ns(current,
1166 task_active_pid_ns(t));
1167 rcu_read_lock();
1168 q->info.si_uid =
1169 from_kuid_munged(task_cred_xxx(t, user_ns),
1170 current_uid());
1171 rcu_read_unlock();
1172 break;
1173 case (unsigned long) SEND_SIG_PRIV:
1174 clear_siginfo(&q->info);
1175 q->info.si_signo = sig;
1176 q->info.si_errno = 0;
1177 q->info.si_code = SI_KERNEL;
1178 q->info.si_pid = 0;
1179 q->info.si_uid = 0;
1180 break;
1181 default:
1182 copy_siginfo(&q->info, info);
1183 break;
1184 }
1185 } else if (!is_si_special(info) &&
1186 sig >= SIGRTMIN && info->si_code != SI_USER) {
1187 /*
1188 * Queue overflow, abort. We may abort if the
1189 * signal was rt and sent by user using something
1190 * other than kill().
1191 */
1192 result = TRACE_SIGNAL_OVERFLOW_FAIL;
1193 ret = -EAGAIN;
1194 goto ret;
1195 } else {
1196 /*
1197 * This is a silent loss of information. We still
1198 * send the signal, but the *info bits are lost.
1199 */
1200 result = TRACE_SIGNAL_LOSE_INFO;
1201 }
1202
1203 out_set:
1204 signalfd_notify(t, sig);
1205 sigaddset(&pending->signal, sig);
1206
1207 /* Let multiprocess signals appear after on-going forks */
1208 if (type > PIDTYPE_TGID) {
1209 struct multiprocess_signals *delayed;
1210 hlist_for_each_entry(delayed, &t->signal->multiprocess, node) {
1211 sigset_t *signal = &delayed->signal;
1212 /* Can't queue both a stop and a continue signal */
1213 if (sig == SIGCONT)
1214 sigdelsetmask(signal, SIG_KERNEL_STOP_MASK);
1215 else if (sig_kernel_stop(sig))
1216 sigdelset(signal, SIGCONT);
1217 sigaddset(signal, sig);
1218 }
1219 }
1220
1221 complete_signal(sig, t, type);
1222 ret:
1223 trace_signal_generate(sig, info, t, type != PIDTYPE_PID, result);
1224 return ret;
1225 }
1226
has_si_pid_and_uid(struct kernel_siginfo * info)1227 static inline bool has_si_pid_and_uid(struct kernel_siginfo *info)
1228 {
1229 bool ret = false;
1230 switch (siginfo_layout(info->si_signo, info->si_code)) {
1231 case SIL_KILL:
1232 case SIL_CHLD:
1233 case SIL_RT:
1234 ret = true;
1235 break;
1236 case SIL_TIMER:
1237 case SIL_POLL:
1238 case SIL_FAULT:
1239 case SIL_FAULT_MCEERR:
1240 case SIL_FAULT_BNDERR:
1241 case SIL_FAULT_PKUERR:
1242 case SIL_PERF_EVENT:
1243 case SIL_SYS:
1244 ret = false;
1245 break;
1246 }
1247 return ret;
1248 }
1249
send_signal(int sig,struct kernel_siginfo * info,struct task_struct * t,enum pid_type type)1250 static int send_signal(int sig, struct kernel_siginfo *info, struct task_struct *t,
1251 enum pid_type type)
1252 {
1253 /* Should SIGKILL or SIGSTOP be received by a pid namespace init? */
1254 bool force = false;
1255
1256 if (info == SEND_SIG_NOINFO) {
1257 /* Force if sent from an ancestor pid namespace */
1258 force = !task_pid_nr_ns(current, task_active_pid_ns(t));
1259 } else if (info == SEND_SIG_PRIV) {
1260 /* Don't ignore kernel generated signals */
1261 force = true;
1262 } else if (has_si_pid_and_uid(info)) {
1263 /* SIGKILL and SIGSTOP is special or has ids */
1264 struct user_namespace *t_user_ns;
1265
1266 rcu_read_lock();
1267 t_user_ns = task_cred_xxx(t, user_ns);
1268 if (current_user_ns() != t_user_ns) {
1269 kuid_t uid = make_kuid(current_user_ns(), info->si_uid);
1270 info->si_uid = from_kuid_munged(t_user_ns, uid);
1271 }
1272 rcu_read_unlock();
1273
1274 /* A kernel generated signal? */
1275 force = (info->si_code == SI_KERNEL);
1276
1277 /* From an ancestor pid namespace? */
1278 if (!task_pid_nr_ns(current, task_active_pid_ns(t))) {
1279 info->si_pid = 0;
1280 force = true;
1281 }
1282 }
1283 return __send_signal(sig, info, t, type, force);
1284 }
1285
print_fatal_signal(int signr)1286 static void print_fatal_signal(int signr)
1287 {
1288 struct pt_regs *regs = signal_pt_regs();
1289 pr_info("potentially unexpected fatal signal %d.\n", signr);
1290
1291 #if defined(__i386__) && !defined(__arch_um__)
1292 pr_info("code at %08lx: ", regs->ip);
1293 {
1294 int i;
1295 for (i = 0; i < 16; i++) {
1296 unsigned char insn;
1297
1298 if (get_user(insn, (unsigned char *)(regs->ip + i)))
1299 break;
1300 pr_cont("%02x ", insn);
1301 }
1302 }
1303 pr_cont("\n");
1304 #endif
1305 preempt_disable();
1306 show_regs(regs);
1307 preempt_enable();
1308 }
1309
setup_print_fatal_signals(char * str)1310 static int __init setup_print_fatal_signals(char *str)
1311 {
1312 get_option (&str, &print_fatal_signals);
1313
1314 return 1;
1315 }
1316
1317 __setup("print-fatal-signals=", setup_print_fatal_signals);
1318
1319 int
__group_send_sig_info(int sig,struct kernel_siginfo * info,struct task_struct * p)1320 __group_send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p)
1321 {
1322 return send_signal(sig, info, p, PIDTYPE_TGID);
1323 }
1324
do_send_sig_info(int sig,struct kernel_siginfo * info,struct task_struct * p,enum pid_type type)1325 int do_send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p,
1326 enum pid_type type)
1327 {
1328 unsigned long flags;
1329 int ret = -ESRCH;
1330
1331 if (lock_task_sighand(p, &flags)) {
1332 ret = send_signal(sig, info, p, type);
1333 unlock_task_sighand(p, &flags);
1334 }
1335
1336 return ret;
1337 }
1338
1339 /*
1340 * Force a signal that the process can't ignore: if necessary
1341 * we unblock the signal and change any SIG_IGN to SIG_DFL.
1342 *
1343 * Note: If we unblock the signal, we always reset it to SIG_DFL,
1344 * since we do not want to have a signal handler that was blocked
1345 * be invoked when user space had explicitly blocked it.
1346 *
1347 * We don't want to have recursive SIGSEGV's etc, for example,
1348 * that is why we also clear SIGNAL_UNKILLABLE.
1349 */
1350 static int
force_sig_info_to_task(struct kernel_siginfo * info,struct task_struct * t)1351 force_sig_info_to_task(struct kernel_siginfo *info, struct task_struct *t)
1352 {
1353 unsigned long int flags;
1354 int ret, blocked, ignored;
1355 struct k_sigaction *action;
1356 int sig = info->si_signo;
1357
1358 spin_lock_irqsave(&t->sighand->siglock, flags);
1359 action = &t->sighand->action[sig-1];
1360 ignored = action->sa.sa_handler == SIG_IGN;
1361 blocked = sigismember(&t->blocked, sig);
1362 if (blocked || ignored) {
1363 action->sa.sa_handler = SIG_DFL;
1364 if (blocked) {
1365 sigdelset(&t->blocked, sig);
1366 recalc_sigpending_and_wake(t);
1367 }
1368 }
1369 /*
1370 * Don't clear SIGNAL_UNKILLABLE for traced tasks, users won't expect
1371 * debugging to leave init killable.
1372 */
1373 if (action->sa.sa_handler == SIG_DFL && !t->ptrace)
1374 t->signal->flags &= ~SIGNAL_UNKILLABLE;
1375 ret = send_signal(sig, info, t, PIDTYPE_PID);
1376 spin_unlock_irqrestore(&t->sighand->siglock, flags);
1377
1378 return ret;
1379 }
1380
force_sig_info(struct kernel_siginfo * info)1381 int force_sig_info(struct kernel_siginfo *info)
1382 {
1383 return force_sig_info_to_task(info, current);
1384 }
1385
1386 /*
1387 * Nuke all other threads in the group.
1388 */
zap_other_threads(struct task_struct * p)1389 int zap_other_threads(struct task_struct *p)
1390 {
1391 struct task_struct *t = p;
1392 int count = 0;
1393
1394 p->signal->group_stop_count = 0;
1395
1396 while_each_thread(p, t) {
1397 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1398 count++;
1399
1400 /* Don't bother with already dead threads */
1401 if (t->exit_state)
1402 continue;
1403 sigaddset(&t->pending.signal, SIGKILL);
1404 signal_wake_up(t, 1);
1405 }
1406
1407 return count;
1408 }
1409
__lock_task_sighand(struct task_struct * tsk,unsigned long * flags)1410 struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
1411 unsigned long *flags)
1412 {
1413 struct sighand_struct *sighand;
1414
1415 rcu_read_lock();
1416 for (;;) {
1417 sighand = rcu_dereference(tsk->sighand);
1418 if (unlikely(sighand == NULL))
1419 break;
1420
1421 /*
1422 * This sighand can be already freed and even reused, but
1423 * we rely on SLAB_TYPESAFE_BY_RCU and sighand_ctor() which
1424 * initializes ->siglock: this slab can't go away, it has
1425 * the same object type, ->siglock can't be reinitialized.
1426 *
1427 * We need to ensure that tsk->sighand is still the same
1428 * after we take the lock, we can race with de_thread() or
1429 * __exit_signal(). In the latter case the next iteration
1430 * must see ->sighand == NULL.
1431 */
1432 spin_lock_irqsave(&sighand->siglock, *flags);
1433 if (likely(sighand == rcu_access_pointer(tsk->sighand)))
1434 break;
1435 spin_unlock_irqrestore(&sighand->siglock, *flags);
1436 }
1437 rcu_read_unlock();
1438
1439 return sighand;
1440 }
1441
1442 /*
1443 * send signal info to all the members of a group
1444 */
group_send_sig_info(int sig,struct kernel_siginfo * info,struct task_struct * p,enum pid_type type)1445 int group_send_sig_info(int sig, struct kernel_siginfo *info,
1446 struct task_struct *p, enum pid_type type)
1447 {
1448 int ret;
1449
1450 rcu_read_lock();
1451 ret = check_kill_permission(sig, info, p);
1452 rcu_read_unlock();
1453
1454 if (!ret && sig)
1455 ret = do_send_sig_info(sig, info, p, type);
1456
1457 return ret;
1458 }
1459
1460 /*
1461 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1462 * control characters do (^C, ^Z etc)
1463 * - the caller must hold at least a readlock on tasklist_lock
1464 */
__kill_pgrp_info(int sig,struct kernel_siginfo * info,struct pid * pgrp)1465 int __kill_pgrp_info(int sig, struct kernel_siginfo *info, struct pid *pgrp)
1466 {
1467 struct task_struct *p = NULL;
1468 int retval, success;
1469
1470 success = 0;
1471 retval = -ESRCH;
1472 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1473 int err = group_send_sig_info(sig, info, p, PIDTYPE_PGID);
1474 success |= !err;
1475 retval = err;
1476 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1477 return success ? 0 : retval;
1478 }
1479
kill_pid_info(int sig,struct kernel_siginfo * info,struct pid * pid)1480 int kill_pid_info(int sig, struct kernel_siginfo *info, struct pid *pid)
1481 {
1482 int error = -ESRCH;
1483 struct task_struct *p;
1484
1485 for (;;) {
1486 rcu_read_lock();
1487 p = pid_task(pid, PIDTYPE_PID);
1488 if (p)
1489 error = group_send_sig_info(sig, info, p, PIDTYPE_TGID);
1490 rcu_read_unlock();
1491 if (likely(!p || error != -ESRCH))
1492 return error;
1493
1494 /*
1495 * The task was unhashed in between, try again. If it
1496 * is dead, pid_task() will return NULL, if we race with
1497 * de_thread() it will find the new leader.
1498 */
1499 }
1500 }
1501
kill_proc_info(int sig,struct kernel_siginfo * info,pid_t pid)1502 static int kill_proc_info(int sig, struct kernel_siginfo *info, pid_t pid)
1503 {
1504 int error;
1505 rcu_read_lock();
1506 error = kill_pid_info(sig, info, find_vpid(pid));
1507 rcu_read_unlock();
1508 return error;
1509 }
1510
kill_as_cred_perm(const struct cred * cred,struct task_struct * target)1511 static inline bool kill_as_cred_perm(const struct cred *cred,
1512 struct task_struct *target)
1513 {
1514 const struct cred *pcred = __task_cred(target);
1515
1516 return uid_eq(cred->euid, pcred->suid) ||
1517 uid_eq(cred->euid, pcred->uid) ||
1518 uid_eq(cred->uid, pcred->suid) ||
1519 uid_eq(cred->uid, pcred->uid);
1520 }
1521
1522 /*
1523 * The usb asyncio usage of siginfo is wrong. The glibc support
1524 * for asyncio which uses SI_ASYNCIO assumes the layout is SIL_RT.
1525 * AKA after the generic fields:
1526 * kernel_pid_t si_pid;
1527 * kernel_uid32_t si_uid;
1528 * sigval_t si_value;
1529 *
1530 * Unfortunately when usb generates SI_ASYNCIO it assumes the layout
1531 * after the generic fields is:
1532 * void __user *si_addr;
1533 *
1534 * This is a practical problem when there is a 64bit big endian kernel
1535 * and a 32bit userspace. As the 32bit address will encoded in the low
1536 * 32bits of the pointer. Those low 32bits will be stored at higher
1537 * address than appear in a 32 bit pointer. So userspace will not
1538 * see the address it was expecting for it's completions.
1539 *
1540 * There is nothing in the encoding that can allow
1541 * copy_siginfo_to_user32 to detect this confusion of formats, so
1542 * handle this by requiring the caller of kill_pid_usb_asyncio to
1543 * notice when this situration takes place and to store the 32bit
1544 * pointer in sival_int, instead of sival_addr of the sigval_t addr
1545 * parameter.
1546 */
kill_pid_usb_asyncio(int sig,int errno,sigval_t addr,struct pid * pid,const struct cred * cred)1547 int kill_pid_usb_asyncio(int sig, int errno, sigval_t addr,
1548 struct pid *pid, const struct cred *cred)
1549 {
1550 struct kernel_siginfo info;
1551 struct task_struct *p;
1552 unsigned long flags;
1553 int ret = -EINVAL;
1554
1555 if (!valid_signal(sig))
1556 return ret;
1557
1558 clear_siginfo(&info);
1559 info.si_signo = sig;
1560 info.si_errno = errno;
1561 info.si_code = SI_ASYNCIO;
1562 *((sigval_t *)&info.si_pid) = addr;
1563
1564 rcu_read_lock();
1565 p = pid_task(pid, PIDTYPE_PID);
1566 if (!p) {
1567 ret = -ESRCH;
1568 goto out_unlock;
1569 }
1570 if (!kill_as_cred_perm(cred, p)) {
1571 ret = -EPERM;
1572 goto out_unlock;
1573 }
1574 ret = security_task_kill(p, &info, sig, cred);
1575 if (ret)
1576 goto out_unlock;
1577
1578 if (sig) {
1579 if (lock_task_sighand(p, &flags)) {
1580 ret = __send_signal(sig, &info, p, PIDTYPE_TGID, false);
1581 unlock_task_sighand(p, &flags);
1582 } else
1583 ret = -ESRCH;
1584 }
1585 out_unlock:
1586 rcu_read_unlock();
1587 return ret;
1588 }
1589 EXPORT_SYMBOL_GPL(kill_pid_usb_asyncio);
1590
1591 /*
1592 * kill_something_info() interprets pid in interesting ways just like kill(2).
1593 *
1594 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1595 * is probably wrong. Should make it like BSD or SYSV.
1596 */
1597
kill_something_info(int sig,struct kernel_siginfo * info,pid_t pid)1598 static int kill_something_info(int sig, struct kernel_siginfo *info, pid_t pid)
1599 {
1600 int ret;
1601
1602 if (pid > 0)
1603 return kill_proc_info(sig, info, pid);
1604
1605 /* -INT_MIN is undefined. Exclude this case to avoid a UBSAN warning */
1606 if (pid == INT_MIN)
1607 return -ESRCH;
1608
1609 read_lock(&tasklist_lock);
1610 if (pid != -1) {
1611 ret = __kill_pgrp_info(sig, info,
1612 pid ? find_vpid(-pid) : task_pgrp(current));
1613 } else {
1614 int retval = 0, count = 0;
1615 struct task_struct * p;
1616
1617 for_each_process(p) {
1618 if (task_pid_vnr(p) > 1 &&
1619 !same_thread_group(p, current)) {
1620 int err = group_send_sig_info(sig, info, p,
1621 PIDTYPE_MAX);
1622 ++count;
1623 if (err != -EPERM)
1624 retval = err;
1625 }
1626 }
1627 ret = count ? retval : -ESRCH;
1628 }
1629 read_unlock(&tasklist_lock);
1630
1631 return ret;
1632 }
1633
1634 /*
1635 * These are for backward compatibility with the rest of the kernel source.
1636 */
1637
send_sig_info(int sig,struct kernel_siginfo * info,struct task_struct * p)1638 int send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p)
1639 {
1640 /*
1641 * Make sure legacy kernel users don't send in bad values
1642 * (normal paths check this in check_kill_permission).
1643 */
1644 if (!valid_signal(sig))
1645 return -EINVAL;
1646
1647 return do_send_sig_info(sig, info, p, PIDTYPE_PID);
1648 }
1649 EXPORT_SYMBOL(send_sig_info);
1650
1651 #define __si_special(priv) \
1652 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1653
1654 int
send_sig(int sig,struct task_struct * p,int priv)1655 send_sig(int sig, struct task_struct *p, int priv)
1656 {
1657 return send_sig_info(sig, __si_special(priv), p);
1658 }
1659 EXPORT_SYMBOL(send_sig);
1660
force_sig(int sig)1661 void force_sig(int sig)
1662 {
1663 struct kernel_siginfo info;
1664
1665 clear_siginfo(&info);
1666 info.si_signo = sig;
1667 info.si_errno = 0;
1668 info.si_code = SI_KERNEL;
1669 info.si_pid = 0;
1670 info.si_uid = 0;
1671 force_sig_info(&info);
1672 }
1673 EXPORT_SYMBOL(force_sig);
1674
1675 /*
1676 * When things go south during signal handling, we
1677 * will force a SIGSEGV. And if the signal that caused
1678 * the problem was already a SIGSEGV, we'll want to
1679 * make sure we don't even try to deliver the signal..
1680 */
force_sigsegv(int sig)1681 void force_sigsegv(int sig)
1682 {
1683 struct task_struct *p = current;
1684
1685 if (sig == SIGSEGV) {
1686 unsigned long flags;
1687 spin_lock_irqsave(&p->sighand->siglock, flags);
1688 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1689 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1690 }
1691 force_sig(SIGSEGV);
1692 }
1693
force_sig_fault_to_task(int sig,int code,void __user * addr ___ARCH_SI_TRAPNO (int trapno)___ARCH_SI_IA64 (int imm,unsigned int flags,unsigned long isr),struct task_struct * t)1694 int force_sig_fault_to_task(int sig, int code, void __user *addr
1695 ___ARCH_SI_TRAPNO(int trapno)
1696 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
1697 , struct task_struct *t)
1698 {
1699 struct kernel_siginfo info;
1700
1701 clear_siginfo(&info);
1702 info.si_signo = sig;
1703 info.si_errno = 0;
1704 info.si_code = code;
1705 info.si_addr = addr;
1706 #ifdef __ARCH_SI_TRAPNO
1707 info.si_trapno = trapno;
1708 #endif
1709 #ifdef __ia64__
1710 info.si_imm = imm;
1711 info.si_flags = flags;
1712 info.si_isr = isr;
1713 #endif
1714 return force_sig_info_to_task(&info, t);
1715 }
1716
force_sig_fault(int sig,int code,void __user * addr ___ARCH_SI_TRAPNO (int trapno)___ARCH_SI_IA64 (int imm,unsigned int flags,unsigned long isr))1717 int force_sig_fault(int sig, int code, void __user *addr
1718 ___ARCH_SI_TRAPNO(int trapno)
1719 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr))
1720 {
1721 return force_sig_fault_to_task(sig, code, addr
1722 ___ARCH_SI_TRAPNO(trapno)
1723 ___ARCH_SI_IA64(imm, flags, isr), current);
1724 }
1725
send_sig_fault(int sig,int code,void __user * addr ___ARCH_SI_TRAPNO (int trapno)___ARCH_SI_IA64 (int imm,unsigned int flags,unsigned long isr),struct task_struct * t)1726 int send_sig_fault(int sig, int code, void __user *addr
1727 ___ARCH_SI_TRAPNO(int trapno)
1728 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
1729 , struct task_struct *t)
1730 {
1731 struct kernel_siginfo info;
1732
1733 clear_siginfo(&info);
1734 info.si_signo = sig;
1735 info.si_errno = 0;
1736 info.si_code = code;
1737 info.si_addr = addr;
1738 #ifdef __ARCH_SI_TRAPNO
1739 info.si_trapno = trapno;
1740 #endif
1741 #ifdef __ia64__
1742 info.si_imm = imm;
1743 info.si_flags = flags;
1744 info.si_isr = isr;
1745 #endif
1746 return send_sig_info(info.si_signo, &info, t);
1747 }
1748
force_sig_mceerr(int code,void __user * addr,short lsb)1749 int force_sig_mceerr(int code, void __user *addr, short lsb)
1750 {
1751 struct kernel_siginfo info;
1752
1753 WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
1754 clear_siginfo(&info);
1755 info.si_signo = SIGBUS;
1756 info.si_errno = 0;
1757 info.si_code = code;
1758 info.si_addr = addr;
1759 info.si_addr_lsb = lsb;
1760 return force_sig_info(&info);
1761 }
1762
send_sig_mceerr(int code,void __user * addr,short lsb,struct task_struct * t)1763 int send_sig_mceerr(int code, void __user *addr, short lsb, struct task_struct *t)
1764 {
1765 struct kernel_siginfo info;
1766
1767 WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
1768 clear_siginfo(&info);
1769 info.si_signo = SIGBUS;
1770 info.si_errno = 0;
1771 info.si_code = code;
1772 info.si_addr = addr;
1773 info.si_addr_lsb = lsb;
1774 return send_sig_info(info.si_signo, &info, t);
1775 }
1776 EXPORT_SYMBOL(send_sig_mceerr);
1777
force_sig_bnderr(void __user * addr,void __user * lower,void __user * upper)1778 int force_sig_bnderr(void __user *addr, void __user *lower, void __user *upper)
1779 {
1780 struct kernel_siginfo info;
1781
1782 clear_siginfo(&info);
1783 info.si_signo = SIGSEGV;
1784 info.si_errno = 0;
1785 info.si_code = SEGV_BNDERR;
1786 info.si_addr = addr;
1787 info.si_lower = lower;
1788 info.si_upper = upper;
1789 return force_sig_info(&info);
1790 }
1791
1792 #ifdef SEGV_PKUERR
force_sig_pkuerr(void __user * addr,u32 pkey)1793 int force_sig_pkuerr(void __user *addr, u32 pkey)
1794 {
1795 struct kernel_siginfo info;
1796
1797 clear_siginfo(&info);
1798 info.si_signo = SIGSEGV;
1799 info.si_errno = 0;
1800 info.si_code = SEGV_PKUERR;
1801 info.si_addr = addr;
1802 info.si_pkey = pkey;
1803 return force_sig_info(&info);
1804 }
1805 #endif
1806
1807 /* For the crazy architectures that include trap information in
1808 * the errno field, instead of an actual errno value.
1809 */
force_sig_ptrace_errno_trap(int errno,void __user * addr)1810 int force_sig_ptrace_errno_trap(int errno, void __user *addr)
1811 {
1812 struct kernel_siginfo info;
1813
1814 clear_siginfo(&info);
1815 info.si_signo = SIGTRAP;
1816 info.si_errno = errno;
1817 info.si_code = TRAP_HWBKPT;
1818 info.si_addr = addr;
1819 return force_sig_info(&info);
1820 }
1821
kill_pgrp(struct pid * pid,int sig,int priv)1822 int kill_pgrp(struct pid *pid, int sig, int priv)
1823 {
1824 int ret;
1825
1826 read_lock(&tasklist_lock);
1827 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1828 read_unlock(&tasklist_lock);
1829
1830 return ret;
1831 }
1832 EXPORT_SYMBOL(kill_pgrp);
1833
kill_pid(struct pid * pid,int sig,int priv)1834 int kill_pid(struct pid *pid, int sig, int priv)
1835 {
1836 return kill_pid_info(sig, __si_special(priv), pid);
1837 }
1838 EXPORT_SYMBOL(kill_pid);
1839
1840 /*
1841 * These functions support sending signals using preallocated sigqueue
1842 * structures. This is needed "because realtime applications cannot
1843 * afford to lose notifications of asynchronous events, like timer
1844 * expirations or I/O completions". In the case of POSIX Timers
1845 * we allocate the sigqueue structure from the timer_create. If this
1846 * allocation fails we are able to report the failure to the application
1847 * with an EAGAIN error.
1848 */
sigqueue_alloc(void)1849 struct sigqueue *sigqueue_alloc(void)
1850 {
1851 return __sigqueue_alloc(-1, current, GFP_KERNEL, 0, SIGQUEUE_PREALLOC);
1852 }
1853
sigqueue_free(struct sigqueue * q)1854 void sigqueue_free(struct sigqueue *q)
1855 {
1856 unsigned long flags;
1857 spinlock_t *lock = ¤t->sighand->siglock;
1858
1859 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1860 /*
1861 * We must hold ->siglock while testing q->list
1862 * to serialize with collect_signal() or with
1863 * __exit_signal()->flush_sigqueue().
1864 */
1865 spin_lock_irqsave(lock, flags);
1866 q->flags &= ~SIGQUEUE_PREALLOC;
1867 /*
1868 * If it is queued it will be freed when dequeued,
1869 * like the "regular" sigqueue.
1870 */
1871 if (!list_empty(&q->list))
1872 q = NULL;
1873 spin_unlock_irqrestore(lock, flags);
1874
1875 if (q)
1876 __sigqueue_free(q);
1877 }
1878
send_sigqueue(struct sigqueue * q,struct pid * pid,enum pid_type type)1879 int send_sigqueue(struct sigqueue *q, struct pid *pid, enum pid_type type)
1880 {
1881 int sig = q->info.si_signo;
1882 struct sigpending *pending;
1883 struct task_struct *t;
1884 unsigned long flags;
1885 int ret, result;
1886
1887 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1888
1889 ret = -1;
1890 rcu_read_lock();
1891 t = pid_task(pid, type);
1892 if (!t || !likely(lock_task_sighand(t, &flags)))
1893 goto ret;
1894
1895 ret = 1; /* the signal is ignored */
1896 result = TRACE_SIGNAL_IGNORED;
1897 if (!prepare_signal(sig, t, false))
1898 goto out;
1899
1900 ret = 0;
1901 if (unlikely(!list_empty(&q->list))) {
1902 /*
1903 * If an SI_TIMER entry is already queue just increment
1904 * the overrun count.
1905 */
1906 BUG_ON(q->info.si_code != SI_TIMER);
1907 q->info.si_overrun++;
1908 result = TRACE_SIGNAL_ALREADY_PENDING;
1909 goto out;
1910 }
1911 q->info.si_overrun = 0;
1912
1913 signalfd_notify(t, sig);
1914 pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending;
1915 list_add_tail(&q->list, &pending->list);
1916 sigaddset(&pending->signal, sig);
1917 complete_signal(sig, t, type);
1918 result = TRACE_SIGNAL_DELIVERED;
1919 out:
1920 trace_signal_generate(sig, &q->info, t, type != PIDTYPE_PID, result);
1921 unlock_task_sighand(t, &flags);
1922 ret:
1923 rcu_read_unlock();
1924 return ret;
1925 }
1926
do_notify_pidfd(struct task_struct * task)1927 static void do_notify_pidfd(struct task_struct *task)
1928 {
1929 struct pid *pid;
1930
1931 WARN_ON(task->exit_state == 0);
1932 pid = task_pid(task);
1933 wake_up_all(&pid->wait_pidfd);
1934 }
1935
1936 /*
1937 * Let a parent know about the death of a child.
1938 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1939 *
1940 * Returns true if our parent ignored us and so we've switched to
1941 * self-reaping.
1942 */
do_notify_parent(struct task_struct * tsk,int sig)1943 bool do_notify_parent(struct task_struct *tsk, int sig)
1944 {
1945 struct kernel_siginfo info;
1946 unsigned long flags;
1947 struct sighand_struct *psig;
1948 bool autoreap = false;
1949 u64 utime, stime;
1950
1951 BUG_ON(sig == -1);
1952
1953 /* do_notify_parent_cldstop should have been called instead. */
1954 BUG_ON(task_is_stopped_or_traced(tsk));
1955
1956 BUG_ON(!tsk->ptrace &&
1957 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1958
1959 /* Wake up all pidfd waiters */
1960 do_notify_pidfd(tsk);
1961
1962 if (sig != SIGCHLD) {
1963 /*
1964 * This is only possible if parent == real_parent.
1965 * Check if it has changed security domain.
1966 */
1967 if (tsk->parent_exec_id != READ_ONCE(tsk->parent->self_exec_id))
1968 sig = SIGCHLD;
1969 }
1970
1971 clear_siginfo(&info);
1972 info.si_signo = sig;
1973 info.si_errno = 0;
1974 /*
1975 * We are under tasklist_lock here so our parent is tied to
1976 * us and cannot change.
1977 *
1978 * task_active_pid_ns will always return the same pid namespace
1979 * until a task passes through release_task.
1980 *
1981 * write_lock() currently calls preempt_disable() which is the
1982 * same as rcu_read_lock(), but according to Oleg, this is not
1983 * correct to rely on this
1984 */
1985 rcu_read_lock();
1986 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1987 info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
1988 task_uid(tsk));
1989 rcu_read_unlock();
1990
1991 task_cputime(tsk, &utime, &stime);
1992 info.si_utime = nsec_to_clock_t(utime + tsk->signal->utime);
1993 info.si_stime = nsec_to_clock_t(stime + tsk->signal->stime);
1994
1995 info.si_status = tsk->exit_code & 0x7f;
1996 if (tsk->exit_code & 0x80)
1997 info.si_code = CLD_DUMPED;
1998 else if (tsk->exit_code & 0x7f)
1999 info.si_code = CLD_KILLED;
2000 else {
2001 info.si_code = CLD_EXITED;
2002 info.si_status = tsk->exit_code >> 8;
2003 }
2004
2005 psig = tsk->parent->sighand;
2006 spin_lock_irqsave(&psig->siglock, flags);
2007 if (!tsk->ptrace && sig == SIGCHLD &&
2008 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
2009 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
2010 /*
2011 * We are exiting and our parent doesn't care. POSIX.1
2012 * defines special semantics for setting SIGCHLD to SIG_IGN
2013 * or setting the SA_NOCLDWAIT flag: we should be reaped
2014 * automatically and not left for our parent's wait4 call.
2015 * Rather than having the parent do it as a magic kind of
2016 * signal handler, we just set this to tell do_exit that we
2017 * can be cleaned up without becoming a zombie. Note that
2018 * we still call __wake_up_parent in this case, because a
2019 * blocked sys_wait4 might now return -ECHILD.
2020 *
2021 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
2022 * is implementation-defined: we do (if you don't want
2023 * it, just use SIG_IGN instead).
2024 */
2025 autoreap = true;
2026 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
2027 sig = 0;
2028 }
2029 /*
2030 * Send with __send_signal as si_pid and si_uid are in the
2031 * parent's namespaces.
2032 */
2033 if (valid_signal(sig) && sig)
2034 __send_signal(sig, &info, tsk->parent, PIDTYPE_TGID, false);
2035 __wake_up_parent(tsk, tsk->parent);
2036 spin_unlock_irqrestore(&psig->siglock, flags);
2037
2038 return autoreap;
2039 }
2040
2041 /**
2042 * do_notify_parent_cldstop - notify parent of stopped/continued state change
2043 * @tsk: task reporting the state change
2044 * @for_ptracer: the notification is for ptracer
2045 * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
2046 *
2047 * Notify @tsk's parent that the stopped/continued state has changed. If
2048 * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
2049 * If %true, @tsk reports to @tsk->parent which should be the ptracer.
2050 *
2051 * CONTEXT:
2052 * Must be called with tasklist_lock at least read locked.
2053 */
do_notify_parent_cldstop(struct task_struct * tsk,bool for_ptracer,int why)2054 static void do_notify_parent_cldstop(struct task_struct *tsk,
2055 bool for_ptracer, int why)
2056 {
2057 struct kernel_siginfo info;
2058 unsigned long flags;
2059 struct task_struct *parent;
2060 struct sighand_struct *sighand;
2061 u64 utime, stime;
2062
2063 if (for_ptracer) {
2064 parent = tsk->parent;
2065 } else {
2066 tsk = tsk->group_leader;
2067 parent = tsk->real_parent;
2068 }
2069
2070 clear_siginfo(&info);
2071 info.si_signo = SIGCHLD;
2072 info.si_errno = 0;
2073 /*
2074 * see comment in do_notify_parent() about the following 4 lines
2075 */
2076 rcu_read_lock();
2077 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
2078 info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
2079 rcu_read_unlock();
2080
2081 task_cputime(tsk, &utime, &stime);
2082 info.si_utime = nsec_to_clock_t(utime);
2083 info.si_stime = nsec_to_clock_t(stime);
2084
2085 info.si_code = why;
2086 switch (why) {
2087 case CLD_CONTINUED:
2088 info.si_status = SIGCONT;
2089 break;
2090 case CLD_STOPPED:
2091 info.si_status = tsk->signal->group_exit_code & 0x7f;
2092 break;
2093 case CLD_TRAPPED:
2094 info.si_status = tsk->exit_code & 0x7f;
2095 break;
2096 default:
2097 BUG();
2098 }
2099
2100 sighand = parent->sighand;
2101 spin_lock_irqsave(&sighand->siglock, flags);
2102 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
2103 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
2104 __group_send_sig_info(SIGCHLD, &info, parent);
2105 /*
2106 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
2107 */
2108 __wake_up_parent(tsk, parent);
2109 spin_unlock_irqrestore(&sighand->siglock, flags);
2110 }
2111
may_ptrace_stop(void)2112 static inline bool may_ptrace_stop(void)
2113 {
2114 if (!likely(current->ptrace))
2115 return false;
2116 /*
2117 * Are we in the middle of do_coredump?
2118 * If so and our tracer is also part of the coredump stopping
2119 * is a deadlock situation, and pointless because our tracer
2120 * is dead so don't allow us to stop.
2121 * If SIGKILL was already sent before the caller unlocked
2122 * ->siglock we must see ->core_state != NULL. Otherwise it
2123 * is safe to enter schedule().
2124 *
2125 * This is almost outdated, a task with the pending SIGKILL can't
2126 * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported
2127 * after SIGKILL was already dequeued.
2128 */
2129 if (unlikely(current->mm->core_state) &&
2130 unlikely(current->mm == current->parent->mm))
2131 return false;
2132
2133 return true;
2134 }
2135
2136 /*
2137 * Return non-zero if there is a SIGKILL that should be waking us up.
2138 * Called with the siglock held.
2139 */
sigkill_pending(struct task_struct * tsk)2140 static bool sigkill_pending(struct task_struct *tsk)
2141 {
2142 return sigismember(&tsk->pending.signal, SIGKILL) ||
2143 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
2144 }
2145
2146 /*
2147 * This must be called with current->sighand->siglock held.
2148 *
2149 * This should be the path for all ptrace stops.
2150 * We always set current->last_siginfo while stopped here.
2151 * That makes it a way to test a stopped process for
2152 * being ptrace-stopped vs being job-control-stopped.
2153 *
2154 * If we actually decide not to stop at all because the tracer
2155 * is gone, we keep current->exit_code unless clear_code.
2156 */
ptrace_stop(int exit_code,int why,int clear_code,kernel_siginfo_t * info)2157 static void ptrace_stop(int exit_code, int why, int clear_code, kernel_siginfo_t *info)
2158 __releases(¤t->sighand->siglock)
2159 __acquires(¤t->sighand->siglock)
2160 {
2161 bool gstop_done = false;
2162
2163 if (arch_ptrace_stop_needed(exit_code, info)) {
2164 /*
2165 * The arch code has something special to do before a
2166 * ptrace stop. This is allowed to block, e.g. for faults
2167 * on user stack pages. We can't keep the siglock while
2168 * calling arch_ptrace_stop, so we must release it now.
2169 * To preserve proper semantics, we must do this before
2170 * any signal bookkeeping like checking group_stop_count.
2171 * Meanwhile, a SIGKILL could come in before we retake the
2172 * siglock. That must prevent us from sleeping in TASK_TRACED.
2173 * So after regaining the lock, we must check for SIGKILL.
2174 */
2175 spin_unlock_irq(¤t->sighand->siglock);
2176 arch_ptrace_stop(exit_code, info);
2177 spin_lock_irq(¤t->sighand->siglock);
2178 if (sigkill_pending(current))
2179 return;
2180 }
2181
2182 set_special_state(TASK_TRACED);
2183
2184 /*
2185 * We're committing to trapping. TRACED should be visible before
2186 * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
2187 * Also, transition to TRACED and updates to ->jobctl should be
2188 * atomic with respect to siglock and should be done after the arch
2189 * hook as siglock is released and regrabbed across it.
2190 *
2191 * TRACER TRACEE
2192 *
2193 * ptrace_attach()
2194 * [L] wait_on_bit(JOBCTL_TRAPPING) [S] set_special_state(TRACED)
2195 * do_wait()
2196 * set_current_state() smp_wmb();
2197 * ptrace_do_wait()
2198 * wait_task_stopped()
2199 * task_stopped_code()
2200 * [L] task_is_traced() [S] task_clear_jobctl_trapping();
2201 */
2202 smp_wmb();
2203
2204 current->last_siginfo = info;
2205 current->exit_code = exit_code;
2206
2207 /*
2208 * If @why is CLD_STOPPED, we're trapping to participate in a group
2209 * stop. Do the bookkeeping. Note that if SIGCONT was delievered
2210 * across siglock relocks since INTERRUPT was scheduled, PENDING
2211 * could be clear now. We act as if SIGCONT is received after
2212 * TASK_TRACED is entered - ignore it.
2213 */
2214 if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
2215 gstop_done = task_participate_group_stop(current);
2216
2217 /* any trap clears pending STOP trap, STOP trap clears NOTIFY */
2218 task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
2219 if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
2220 task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
2221
2222 /* entering a trap, clear TRAPPING */
2223 task_clear_jobctl_trapping(current);
2224
2225 spin_unlock_irq(¤t->sighand->siglock);
2226 read_lock(&tasklist_lock);
2227 if (may_ptrace_stop()) {
2228 /*
2229 * Notify parents of the stop.
2230 *
2231 * While ptraced, there are two parents - the ptracer and
2232 * the real_parent of the group_leader. The ptracer should
2233 * know about every stop while the real parent is only
2234 * interested in the completion of group stop. The states
2235 * for the two don't interact with each other. Notify
2236 * separately unless they're gonna be duplicates.
2237 */
2238 do_notify_parent_cldstop(current, true, why);
2239 if (gstop_done && ptrace_reparented(current))
2240 do_notify_parent_cldstop(current, false, why);
2241
2242 /*
2243 * Don't want to allow preemption here, because
2244 * sys_ptrace() needs this task to be inactive.
2245 *
2246 * XXX: implement read_unlock_no_resched().
2247 */
2248 preempt_disable();
2249 read_unlock(&tasklist_lock);
2250 cgroup_enter_frozen();
2251 preempt_enable_no_resched();
2252 freezable_schedule();
2253 cgroup_leave_frozen(true);
2254 } else {
2255 /*
2256 * By the time we got the lock, our tracer went away.
2257 * Don't drop the lock yet, another tracer may come.
2258 *
2259 * If @gstop_done, the ptracer went away between group stop
2260 * completion and here. During detach, it would have set
2261 * JOBCTL_STOP_PENDING on us and we'll re-enter
2262 * TASK_STOPPED in do_signal_stop() on return, so notifying
2263 * the real parent of the group stop completion is enough.
2264 */
2265 if (gstop_done)
2266 do_notify_parent_cldstop(current, false, why);
2267
2268 /* tasklist protects us from ptrace_freeze_traced() */
2269 __set_current_state(TASK_RUNNING);
2270 if (clear_code)
2271 current->exit_code = 0;
2272 read_unlock(&tasklist_lock);
2273 }
2274
2275 /*
2276 * We are back. Now reacquire the siglock before touching
2277 * last_siginfo, so that we are sure to have synchronized with
2278 * any signal-sending on another CPU that wants to examine it.
2279 */
2280 spin_lock_irq(¤t->sighand->siglock);
2281 current->last_siginfo = NULL;
2282
2283 /* LISTENING can be set only during STOP traps, clear it */
2284 current->jobctl &= ~JOBCTL_LISTENING;
2285
2286 /*
2287 * Queued signals ignored us while we were stopped for tracing.
2288 * So check for any that we should take before resuming user mode.
2289 * This sets TIF_SIGPENDING, but never clears it.
2290 */
2291 recalc_sigpending_tsk(current);
2292 }
2293
ptrace_do_notify(int signr,int exit_code,int why)2294 static void ptrace_do_notify(int signr, int exit_code, int why)
2295 {
2296 kernel_siginfo_t info;
2297
2298 clear_siginfo(&info);
2299 info.si_signo = signr;
2300 info.si_code = exit_code;
2301 info.si_pid = task_pid_vnr(current);
2302 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2303
2304 /* Let the debugger run. */
2305 ptrace_stop(exit_code, why, 1, &info);
2306 }
2307
ptrace_notify(int exit_code)2308 void ptrace_notify(int exit_code)
2309 {
2310 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
2311 if (unlikely(current->task_works))
2312 task_work_run();
2313
2314 spin_lock_irq(¤t->sighand->siglock);
2315 ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
2316 spin_unlock_irq(¤t->sighand->siglock);
2317 }
2318
2319 /**
2320 * do_signal_stop - handle group stop for SIGSTOP and other stop signals
2321 * @signr: signr causing group stop if initiating
2322 *
2323 * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
2324 * and participate in it. If already set, participate in the existing
2325 * group stop. If participated in a group stop (and thus slept), %true is
2326 * returned with siglock released.
2327 *
2328 * If ptraced, this function doesn't handle stop itself. Instead,
2329 * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
2330 * untouched. The caller must ensure that INTERRUPT trap handling takes
2331 * places afterwards.
2332 *
2333 * CONTEXT:
2334 * Must be called with @current->sighand->siglock held, which is released
2335 * on %true return.
2336 *
2337 * RETURNS:
2338 * %false if group stop is already cancelled or ptrace trap is scheduled.
2339 * %true if participated in group stop.
2340 */
do_signal_stop(int signr)2341 static bool do_signal_stop(int signr)
2342 __releases(¤t->sighand->siglock)
2343 {
2344 struct signal_struct *sig = current->signal;
2345
2346 if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
2347 unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
2348 struct task_struct *t;
2349
2350 /* signr will be recorded in task->jobctl for retries */
2351 WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
2352
2353 if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
2354 unlikely(signal_group_exit(sig)))
2355 return false;
2356 /*
2357 * There is no group stop already in progress. We must
2358 * initiate one now.
2359 *
2360 * While ptraced, a task may be resumed while group stop is
2361 * still in effect and then receive a stop signal and
2362 * initiate another group stop. This deviates from the
2363 * usual behavior as two consecutive stop signals can't
2364 * cause two group stops when !ptraced. That is why we
2365 * also check !task_is_stopped(t) below.
2366 *
2367 * The condition can be distinguished by testing whether
2368 * SIGNAL_STOP_STOPPED is already set. Don't generate
2369 * group_exit_code in such case.
2370 *
2371 * This is not necessary for SIGNAL_STOP_CONTINUED because
2372 * an intervening stop signal is required to cause two
2373 * continued events regardless of ptrace.
2374 */
2375 if (!(sig->flags & SIGNAL_STOP_STOPPED))
2376 sig->group_exit_code = signr;
2377
2378 sig->group_stop_count = 0;
2379
2380 if (task_set_jobctl_pending(current, signr | gstop))
2381 sig->group_stop_count++;
2382
2383 t = current;
2384 while_each_thread(current, t) {
2385 /*
2386 * Setting state to TASK_STOPPED for a group
2387 * stop is always done with the siglock held,
2388 * so this check has no races.
2389 */
2390 if (!task_is_stopped(t) &&
2391 task_set_jobctl_pending(t, signr | gstop)) {
2392 sig->group_stop_count++;
2393 if (likely(!(t->ptrace & PT_SEIZED)))
2394 signal_wake_up(t, 0);
2395 else
2396 ptrace_trap_notify(t);
2397 }
2398 }
2399 }
2400
2401 if (likely(!current->ptrace)) {
2402 int notify = 0;
2403
2404 /*
2405 * If there are no other threads in the group, or if there
2406 * is a group stop in progress and we are the last to stop,
2407 * report to the parent.
2408 */
2409 if (task_participate_group_stop(current))
2410 notify = CLD_STOPPED;
2411
2412 set_special_state(TASK_STOPPED);
2413 spin_unlock_irq(¤t->sighand->siglock);
2414
2415 /*
2416 * Notify the parent of the group stop completion. Because
2417 * we're not holding either the siglock or tasklist_lock
2418 * here, ptracer may attach inbetween; however, this is for
2419 * group stop and should always be delivered to the real
2420 * parent of the group leader. The new ptracer will get
2421 * its notification when this task transitions into
2422 * TASK_TRACED.
2423 */
2424 if (notify) {
2425 read_lock(&tasklist_lock);
2426 do_notify_parent_cldstop(current, false, notify);
2427 read_unlock(&tasklist_lock);
2428 }
2429
2430 /* Now we don't run again until woken by SIGCONT or SIGKILL */
2431 cgroup_enter_frozen();
2432 freezable_schedule();
2433 return true;
2434 } else {
2435 /*
2436 * While ptraced, group stop is handled by STOP trap.
2437 * Schedule it and let the caller deal with it.
2438 */
2439 task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
2440 return false;
2441 }
2442 }
2443
2444 /**
2445 * do_jobctl_trap - take care of ptrace jobctl traps
2446 *
2447 * When PT_SEIZED, it's used for both group stop and explicit
2448 * SEIZE/INTERRUPT traps. Both generate PTRACE_EVENT_STOP trap with
2449 * accompanying siginfo. If stopped, lower eight bits of exit_code contain
2450 * the stop signal; otherwise, %SIGTRAP.
2451 *
2452 * When !PT_SEIZED, it's used only for group stop trap with stop signal
2453 * number as exit_code and no siginfo.
2454 *
2455 * CONTEXT:
2456 * Must be called with @current->sighand->siglock held, which may be
2457 * released and re-acquired before returning with intervening sleep.
2458 */
do_jobctl_trap(void)2459 static void do_jobctl_trap(void)
2460 {
2461 struct signal_struct *signal = current->signal;
2462 int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2463
2464 if (current->ptrace & PT_SEIZED) {
2465 if (!signal->group_stop_count &&
2466 !(signal->flags & SIGNAL_STOP_STOPPED))
2467 signr = SIGTRAP;
2468 WARN_ON_ONCE(!signr);
2469 ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
2470 CLD_STOPPED);
2471 } else {
2472 WARN_ON_ONCE(!signr);
2473 ptrace_stop(signr, CLD_STOPPED, 0, NULL);
2474 current->exit_code = 0;
2475 }
2476 }
2477
2478 /**
2479 * do_freezer_trap - handle the freezer jobctl trap
2480 *
2481 * Puts the task into frozen state, if only the task is not about to quit.
2482 * In this case it drops JOBCTL_TRAP_FREEZE.
2483 *
2484 * CONTEXT:
2485 * Must be called with @current->sighand->siglock held,
2486 * which is always released before returning.
2487 */
do_freezer_trap(void)2488 static void do_freezer_trap(void)
2489 __releases(¤t->sighand->siglock)
2490 {
2491 /*
2492 * If there are other trap bits pending except JOBCTL_TRAP_FREEZE,
2493 * let's make another loop to give it a chance to be handled.
2494 * In any case, we'll return back.
2495 */
2496 if ((current->jobctl & (JOBCTL_PENDING_MASK | JOBCTL_TRAP_FREEZE)) !=
2497 JOBCTL_TRAP_FREEZE) {
2498 spin_unlock_irq(¤t->sighand->siglock);
2499 return;
2500 }
2501
2502 /*
2503 * Now we're sure that there is no pending fatal signal and no
2504 * pending traps. Clear TIF_SIGPENDING to not get out of schedule()
2505 * immediately (if there is a non-fatal signal pending), and
2506 * put the task into sleep.
2507 */
2508 __set_current_state(TASK_INTERRUPTIBLE);
2509 clear_thread_flag(TIF_SIGPENDING);
2510 spin_unlock_irq(¤t->sighand->siglock);
2511 cgroup_enter_frozen();
2512 freezable_schedule();
2513 }
2514
ptrace_signal(int signr,kernel_siginfo_t * info)2515 static int ptrace_signal(int signr, kernel_siginfo_t *info)
2516 {
2517 /*
2518 * We do not check sig_kernel_stop(signr) but set this marker
2519 * unconditionally because we do not know whether debugger will
2520 * change signr. This flag has no meaning unless we are going
2521 * to stop after return from ptrace_stop(). In this case it will
2522 * be checked in do_signal_stop(), we should only stop if it was
2523 * not cleared by SIGCONT while we were sleeping. See also the
2524 * comment in dequeue_signal().
2525 */
2526 current->jobctl |= JOBCTL_STOP_DEQUEUED;
2527 ptrace_stop(signr, CLD_TRAPPED, 0, info);
2528
2529 /* We're back. Did the debugger cancel the sig? */
2530 signr = current->exit_code;
2531 if (signr == 0)
2532 return signr;
2533
2534 current->exit_code = 0;
2535
2536 /*
2537 * Update the siginfo structure if the signal has
2538 * changed. If the debugger wanted something
2539 * specific in the siginfo structure then it should
2540 * have updated *info via PTRACE_SETSIGINFO.
2541 */
2542 if (signr != info->si_signo) {
2543 clear_siginfo(info);
2544 info->si_signo = signr;
2545 info->si_errno = 0;
2546 info->si_code = SI_USER;
2547 rcu_read_lock();
2548 info->si_pid = task_pid_vnr(current->parent);
2549 info->si_uid = from_kuid_munged(current_user_ns(),
2550 task_uid(current->parent));
2551 rcu_read_unlock();
2552 }
2553
2554 /* If the (new) signal is now blocked, requeue it. */
2555 if (sigismember(¤t->blocked, signr)) {
2556 send_signal(signr, info, current, PIDTYPE_PID);
2557 signr = 0;
2558 }
2559
2560 return signr;
2561 }
2562
hide_si_addr_tag_bits(struct ksignal * ksig)2563 static void hide_si_addr_tag_bits(struct ksignal *ksig)
2564 {
2565 switch (siginfo_layout(ksig->sig, ksig->info.si_code)) {
2566 case SIL_FAULT:
2567 case SIL_FAULT_MCEERR:
2568 case SIL_FAULT_BNDERR:
2569 case SIL_FAULT_PKUERR:
2570 case SIL_PERF_EVENT:
2571 ksig->info.si_addr = arch_untagged_si_addr(
2572 ksig->info.si_addr, ksig->sig, ksig->info.si_code);
2573 break;
2574 case SIL_KILL:
2575 case SIL_TIMER:
2576 case SIL_POLL:
2577 case SIL_CHLD:
2578 case SIL_RT:
2579 case SIL_SYS:
2580 break;
2581 }
2582 }
2583
get_signal(struct ksignal * ksig)2584 bool get_signal(struct ksignal *ksig)
2585 {
2586 struct sighand_struct *sighand = current->sighand;
2587 struct signal_struct *signal = current->signal;
2588 int signr;
2589
2590 if (unlikely(current->task_works))
2591 task_work_run();
2592
2593 /*
2594 * For non-generic architectures, check for TIF_NOTIFY_SIGNAL so
2595 * that the arch handlers don't all have to do it. If we get here
2596 * without TIF_SIGPENDING, just exit after running signal work.
2597 */
2598 if (!IS_ENABLED(CONFIG_GENERIC_ENTRY)) {
2599 if (test_thread_flag(TIF_NOTIFY_SIGNAL))
2600 tracehook_notify_signal();
2601 if (!task_sigpending(current))
2602 return false;
2603 }
2604
2605 if (unlikely(uprobe_deny_signal()))
2606 return false;
2607
2608 /*
2609 * Do this once, we can't return to user-mode if freezing() == T.
2610 * do_signal_stop() and ptrace_stop() do freezable_schedule() and
2611 * thus do not need another check after return.
2612 */
2613 try_to_freeze();
2614
2615 relock:
2616 spin_lock_irq(&sighand->siglock);
2617
2618 /*
2619 * Every stopped thread goes here after wakeup. Check to see if
2620 * we should notify the parent, prepare_signal(SIGCONT) encodes
2621 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
2622 */
2623 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2624 int why;
2625
2626 if (signal->flags & SIGNAL_CLD_CONTINUED)
2627 why = CLD_CONTINUED;
2628 else
2629 why = CLD_STOPPED;
2630
2631 signal->flags &= ~SIGNAL_CLD_MASK;
2632
2633 spin_unlock_irq(&sighand->siglock);
2634
2635 /*
2636 * Notify the parent that we're continuing. This event is
2637 * always per-process and doesn't make whole lot of sense
2638 * for ptracers, who shouldn't consume the state via
2639 * wait(2) either, but, for backward compatibility, notify
2640 * the ptracer of the group leader too unless it's gonna be
2641 * a duplicate.
2642 */
2643 read_lock(&tasklist_lock);
2644 do_notify_parent_cldstop(current, false, why);
2645
2646 if (ptrace_reparented(current->group_leader))
2647 do_notify_parent_cldstop(current->group_leader,
2648 true, why);
2649 read_unlock(&tasklist_lock);
2650
2651 goto relock;
2652 }
2653
2654 /* Has this task already been marked for death? */
2655 if (signal_group_exit(signal)) {
2656 ksig->info.si_signo = signr = SIGKILL;
2657 sigdelset(¤t->pending.signal, SIGKILL);
2658 trace_signal_deliver(SIGKILL, SEND_SIG_NOINFO,
2659 &sighand->action[SIGKILL - 1]);
2660 recalc_sigpending();
2661 goto fatal;
2662 }
2663
2664 for (;;) {
2665 struct k_sigaction *ka;
2666
2667 if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
2668 do_signal_stop(0))
2669 goto relock;
2670
2671 if (unlikely(current->jobctl &
2672 (JOBCTL_TRAP_MASK | JOBCTL_TRAP_FREEZE))) {
2673 if (current->jobctl & JOBCTL_TRAP_MASK) {
2674 do_jobctl_trap();
2675 spin_unlock_irq(&sighand->siglock);
2676 } else if (current->jobctl & JOBCTL_TRAP_FREEZE)
2677 do_freezer_trap();
2678
2679 goto relock;
2680 }
2681
2682 /*
2683 * If the task is leaving the frozen state, let's update
2684 * cgroup counters and reset the frozen bit.
2685 */
2686 if (unlikely(cgroup_task_frozen(current))) {
2687 spin_unlock_irq(&sighand->siglock);
2688 cgroup_leave_frozen(false);
2689 goto relock;
2690 }
2691
2692 /*
2693 * Signals generated by the execution of an instruction
2694 * need to be delivered before any other pending signals
2695 * so that the instruction pointer in the signal stack
2696 * frame points to the faulting instruction.
2697 */
2698 signr = dequeue_synchronous_signal(&ksig->info);
2699 if (!signr)
2700 signr = dequeue_signal(current, ¤t->blocked, &ksig->info);
2701
2702 if (!signr)
2703 break; /* will return 0 */
2704
2705 if (unlikely(current->ptrace) && signr != SIGKILL) {
2706 signr = ptrace_signal(signr, &ksig->info);
2707 if (!signr)
2708 continue;
2709 }
2710
2711 ka = &sighand->action[signr-1];
2712
2713 /* Trace actually delivered signals. */
2714 trace_signal_deliver(signr, &ksig->info, ka);
2715
2716 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
2717 continue;
2718 if (ka->sa.sa_handler != SIG_DFL) {
2719 /* Run the handler. */
2720 ksig->ka = *ka;
2721
2722 if (ka->sa.sa_flags & SA_ONESHOT)
2723 ka->sa.sa_handler = SIG_DFL;
2724
2725 break; /* will return non-zero "signr" value */
2726 }
2727
2728 /*
2729 * Now we are doing the default action for this signal.
2730 */
2731 if (sig_kernel_ignore(signr)) /* Default is nothing. */
2732 continue;
2733
2734 /*
2735 * Global init gets no signals it doesn't want.
2736 * Container-init gets no signals it doesn't want from same
2737 * container.
2738 *
2739 * Note that if global/container-init sees a sig_kernel_only()
2740 * signal here, the signal must have been generated internally
2741 * or must have come from an ancestor namespace. In either
2742 * case, the signal cannot be dropped.
2743 */
2744 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2745 !sig_kernel_only(signr))
2746 continue;
2747
2748 if (sig_kernel_stop(signr)) {
2749 /*
2750 * The default action is to stop all threads in
2751 * the thread group. The job control signals
2752 * do nothing in an orphaned pgrp, but SIGSTOP
2753 * always works. Note that siglock needs to be
2754 * dropped during the call to is_orphaned_pgrp()
2755 * because of lock ordering with tasklist_lock.
2756 * This allows an intervening SIGCONT to be posted.
2757 * We need to check for that and bail out if necessary.
2758 */
2759 if (signr != SIGSTOP) {
2760 spin_unlock_irq(&sighand->siglock);
2761
2762 /* signals can be posted during this window */
2763
2764 if (is_current_pgrp_orphaned())
2765 goto relock;
2766
2767 spin_lock_irq(&sighand->siglock);
2768 }
2769
2770 if (likely(do_signal_stop(ksig->info.si_signo))) {
2771 /* It released the siglock. */
2772 goto relock;
2773 }
2774
2775 /*
2776 * We didn't actually stop, due to a race
2777 * with SIGCONT or something like that.
2778 */
2779 continue;
2780 }
2781
2782 fatal:
2783 spin_unlock_irq(&sighand->siglock);
2784 if (unlikely(cgroup_task_frozen(current)))
2785 cgroup_leave_frozen(true);
2786
2787 /*
2788 * Anything else is fatal, maybe with a core dump.
2789 */
2790 current->flags |= PF_SIGNALED;
2791
2792 if (sig_kernel_coredump(signr)) {
2793 if (print_fatal_signals)
2794 print_fatal_signal(ksig->info.si_signo);
2795 proc_coredump_connector(current);
2796 /*
2797 * If it was able to dump core, this kills all
2798 * other threads in the group and synchronizes with
2799 * their demise. If we lost the race with another
2800 * thread getting here, it set group_exit_code
2801 * first and our do_group_exit call below will use
2802 * that value and ignore the one we pass it.
2803 */
2804 do_coredump(&ksig->info);
2805 }
2806
2807 /*
2808 * PF_IO_WORKER threads will catch and exit on fatal signals
2809 * themselves. They have cleanup that must be performed, so
2810 * we cannot call do_exit() on their behalf.
2811 */
2812 if (current->flags & PF_IO_WORKER)
2813 goto out;
2814
2815 /*
2816 * Death signals, no core dump.
2817 */
2818 do_group_exit(ksig->info.si_signo);
2819 /* NOTREACHED */
2820 }
2821 spin_unlock_irq(&sighand->siglock);
2822 out:
2823 ksig->sig = signr;
2824
2825 if (!(ksig->ka.sa.sa_flags & SA_EXPOSE_TAGBITS))
2826 hide_si_addr_tag_bits(ksig);
2827
2828 return ksig->sig > 0;
2829 }
2830
2831 /**
2832 * signal_delivered -
2833 * @ksig: kernel signal struct
2834 * @stepping: nonzero if debugger single-step or block-step in use
2835 *
2836 * This function should be called when a signal has successfully been
2837 * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
2838 * is always blocked, and the signal itself is blocked unless %SA_NODEFER
2839 * is set in @ksig->ka.sa.sa_flags. Tracing is notified.
2840 */
signal_delivered(struct ksignal * ksig,int stepping)2841 static void signal_delivered(struct ksignal *ksig, int stepping)
2842 {
2843 sigset_t blocked;
2844
2845 /* A signal was successfully delivered, and the
2846 saved sigmask was stored on the signal frame,
2847 and will be restored by sigreturn. So we can
2848 simply clear the restore sigmask flag. */
2849 clear_restore_sigmask();
2850
2851 sigorsets(&blocked, ¤t->blocked, &ksig->ka.sa.sa_mask);
2852 if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
2853 sigaddset(&blocked, ksig->sig);
2854 set_current_blocked(&blocked);
2855 tracehook_signal_handler(stepping);
2856 }
2857
signal_setup_done(int failed,struct ksignal * ksig,int stepping)2858 void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
2859 {
2860 if (failed)
2861 force_sigsegv(ksig->sig);
2862 else
2863 signal_delivered(ksig, stepping);
2864 }
2865
2866 /*
2867 * It could be that complete_signal() picked us to notify about the
2868 * group-wide signal. Other threads should be notified now to take
2869 * the shared signals in @which since we will not.
2870 */
retarget_shared_pending(struct task_struct * tsk,sigset_t * which)2871 static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2872 {
2873 sigset_t retarget;
2874 struct task_struct *t;
2875
2876 sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
2877 if (sigisemptyset(&retarget))
2878 return;
2879
2880 t = tsk;
2881 while_each_thread(tsk, t) {
2882 if (t->flags & PF_EXITING)
2883 continue;
2884
2885 if (!has_pending_signals(&retarget, &t->blocked))
2886 continue;
2887 /* Remove the signals this thread can handle. */
2888 sigandsets(&retarget, &retarget, &t->blocked);
2889
2890 if (!task_sigpending(t))
2891 signal_wake_up(t, 0);
2892
2893 if (sigisemptyset(&retarget))
2894 break;
2895 }
2896 }
2897
exit_signals(struct task_struct * tsk)2898 void exit_signals(struct task_struct *tsk)
2899 {
2900 int group_stop = 0;
2901 sigset_t unblocked;
2902
2903 /*
2904 * @tsk is about to have PF_EXITING set - lock out users which
2905 * expect stable threadgroup.
2906 */
2907 cgroup_threadgroup_change_begin(tsk);
2908
2909 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
2910 tsk->flags |= PF_EXITING;
2911 cgroup_threadgroup_change_end(tsk);
2912 return;
2913 }
2914
2915 spin_lock_irq(&tsk->sighand->siglock);
2916 /*
2917 * From now this task is not visible for group-wide signals,
2918 * see wants_signal(), do_signal_stop().
2919 */
2920 tsk->flags |= PF_EXITING;
2921
2922 cgroup_threadgroup_change_end(tsk);
2923
2924 if (!task_sigpending(tsk))
2925 goto out;
2926
2927 unblocked = tsk->blocked;
2928 signotset(&unblocked);
2929 retarget_shared_pending(tsk, &unblocked);
2930
2931 if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2932 task_participate_group_stop(tsk))
2933 group_stop = CLD_STOPPED;
2934 out:
2935 spin_unlock_irq(&tsk->sighand->siglock);
2936
2937 /*
2938 * If group stop has completed, deliver the notification. This
2939 * should always go to the real parent of the group leader.
2940 */
2941 if (unlikely(group_stop)) {
2942 read_lock(&tasklist_lock);
2943 do_notify_parent_cldstop(tsk, false, group_stop);
2944 read_unlock(&tasklist_lock);
2945 }
2946 }
2947
2948 /*
2949 * System call entry points.
2950 */
2951
2952 /**
2953 * sys_restart_syscall - restart a system call
2954 */
SYSCALL_DEFINE0(restart_syscall)2955 SYSCALL_DEFINE0(restart_syscall)
2956 {
2957 struct restart_block *restart = ¤t->restart_block;
2958 return restart->fn(restart);
2959 }
2960
do_no_restart_syscall(struct restart_block * param)2961 long do_no_restart_syscall(struct restart_block *param)
2962 {
2963 return -EINTR;
2964 }
2965
__set_task_blocked(struct task_struct * tsk,const sigset_t * newset)2966 static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
2967 {
2968 if (task_sigpending(tsk) && !thread_group_empty(tsk)) {
2969 sigset_t newblocked;
2970 /* A set of now blocked but previously unblocked signals. */
2971 sigandnsets(&newblocked, newset, ¤t->blocked);
2972 retarget_shared_pending(tsk, &newblocked);
2973 }
2974 tsk->blocked = *newset;
2975 recalc_sigpending();
2976 }
2977
2978 /**
2979 * set_current_blocked - change current->blocked mask
2980 * @newset: new mask
2981 *
2982 * It is wrong to change ->blocked directly, this helper should be used
2983 * to ensure the process can't miss a shared signal we are going to block.
2984 */
set_current_blocked(sigset_t * newset)2985 void set_current_blocked(sigset_t *newset)
2986 {
2987 sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2988 __set_current_blocked(newset);
2989 }
2990
__set_current_blocked(const sigset_t * newset)2991 void __set_current_blocked(const sigset_t *newset)
2992 {
2993 struct task_struct *tsk = current;
2994
2995 /*
2996 * In case the signal mask hasn't changed, there is nothing we need
2997 * to do. The current->blocked shouldn't be modified by other task.
2998 */
2999 if (sigequalsets(&tsk->blocked, newset))
3000 return;
3001
3002 spin_lock_irq(&tsk->sighand->siglock);
3003 __set_task_blocked(tsk, newset);
3004 spin_unlock_irq(&tsk->sighand->siglock);
3005 }
3006
3007 /*
3008 * This is also useful for kernel threads that want to temporarily
3009 * (or permanently) block certain signals.
3010 *
3011 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
3012 * interface happily blocks "unblockable" signals like SIGKILL
3013 * and friends.
3014 */
sigprocmask(int how,sigset_t * set,sigset_t * oldset)3015 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
3016 {
3017 struct task_struct *tsk = current;
3018 sigset_t newset;
3019
3020 /* Lockless, only current can change ->blocked, never from irq */
3021 if (oldset)
3022 *oldset = tsk->blocked;
3023
3024 switch (how) {
3025 case SIG_BLOCK:
3026 sigorsets(&newset, &tsk->blocked, set);
3027 break;
3028 case SIG_UNBLOCK:
3029 sigandnsets(&newset, &tsk->blocked, set);
3030 break;
3031 case SIG_SETMASK:
3032 newset = *set;
3033 break;
3034 default:
3035 return -EINVAL;
3036 }
3037
3038 __set_current_blocked(&newset);
3039 return 0;
3040 }
3041 EXPORT_SYMBOL(sigprocmask);
3042
3043 /*
3044 * The api helps set app-provided sigmasks.
3045 *
3046 * This is useful for syscalls such as ppoll, pselect, io_pgetevents and
3047 * epoll_pwait where a new sigmask is passed from userland for the syscalls.
3048 *
3049 * Note that it does set_restore_sigmask() in advance, so it must be always
3050 * paired with restore_saved_sigmask_unless() before return from syscall.
3051 */
set_user_sigmask(const sigset_t __user * umask,size_t sigsetsize)3052 int set_user_sigmask(const sigset_t __user *umask, size_t sigsetsize)
3053 {
3054 sigset_t kmask;
3055
3056 if (!umask)
3057 return 0;
3058 if (sigsetsize != sizeof(sigset_t))
3059 return -EINVAL;
3060 if (copy_from_user(&kmask, umask, sizeof(sigset_t)))
3061 return -EFAULT;
3062
3063 set_restore_sigmask();
3064 current->saved_sigmask = current->blocked;
3065 set_current_blocked(&kmask);
3066
3067 return 0;
3068 }
3069
3070 #ifdef CONFIG_COMPAT
set_compat_user_sigmask(const compat_sigset_t __user * umask,size_t sigsetsize)3071 int set_compat_user_sigmask(const compat_sigset_t __user *umask,
3072 size_t sigsetsize)
3073 {
3074 sigset_t kmask;
3075
3076 if (!umask)
3077 return 0;
3078 if (sigsetsize != sizeof(compat_sigset_t))
3079 return -EINVAL;
3080 if (get_compat_sigset(&kmask, umask))
3081 return -EFAULT;
3082
3083 set_restore_sigmask();
3084 current->saved_sigmask = current->blocked;
3085 set_current_blocked(&kmask);
3086
3087 return 0;
3088 }
3089 #endif
3090
3091 /**
3092 * sys_rt_sigprocmask - change the list of currently blocked signals
3093 * @how: whether to add, remove, or set signals
3094 * @nset: stores pending signals
3095 * @oset: previous value of signal mask if non-null
3096 * @sigsetsize: size of sigset_t type
3097 */
SYSCALL_DEFINE4(rt_sigprocmask,int,how,sigset_t __user *,nset,sigset_t __user *,oset,size_t,sigsetsize)3098 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
3099 sigset_t __user *, oset, size_t, sigsetsize)
3100 {
3101 sigset_t old_set, new_set;
3102 int error;
3103
3104 /* XXX: Don't preclude handling different sized sigset_t's. */
3105 if (sigsetsize != sizeof(sigset_t))
3106 return -EINVAL;
3107
3108 old_set = current->blocked;
3109
3110 if (nset) {
3111 if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
3112 return -EFAULT;
3113 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
3114
3115 error = sigprocmask(how, &new_set, NULL);
3116 if (error)
3117 return error;
3118 }
3119
3120 if (oset) {
3121 if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
3122 return -EFAULT;
3123 }
3124
3125 return 0;
3126 }
3127
3128 #ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE4(rt_sigprocmask,int,how,compat_sigset_t __user *,nset,compat_sigset_t __user *,oset,compat_size_t,sigsetsize)3129 COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
3130 compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
3131 {
3132 sigset_t old_set = current->blocked;
3133
3134 /* XXX: Don't preclude handling different sized sigset_t's. */
3135 if (sigsetsize != sizeof(sigset_t))
3136 return -EINVAL;
3137
3138 if (nset) {
3139 sigset_t new_set;
3140 int error;
3141 if (get_compat_sigset(&new_set, nset))
3142 return -EFAULT;
3143 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
3144
3145 error = sigprocmask(how, &new_set, NULL);
3146 if (error)
3147 return error;
3148 }
3149 return oset ? put_compat_sigset(oset, &old_set, sizeof(*oset)) : 0;
3150 }
3151 #endif
3152
do_sigpending(sigset_t * set)3153 static void do_sigpending(sigset_t *set)
3154 {
3155 spin_lock_irq(¤t->sighand->siglock);
3156 sigorsets(set, ¤t->pending.signal,
3157 ¤t->signal->shared_pending.signal);
3158 spin_unlock_irq(¤t->sighand->siglock);
3159
3160 /* Outside the lock because only this thread touches it. */
3161 sigandsets(set, ¤t->blocked, set);
3162 }
3163
3164 /**
3165 * sys_rt_sigpending - examine a pending signal that has been raised
3166 * while blocked
3167 * @uset: stores pending signals
3168 * @sigsetsize: size of sigset_t type or larger
3169 */
SYSCALL_DEFINE2(rt_sigpending,sigset_t __user *,uset,size_t,sigsetsize)3170 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
3171 {
3172 sigset_t set;
3173
3174 if (sigsetsize > sizeof(*uset))
3175 return -EINVAL;
3176
3177 do_sigpending(&set);
3178
3179 if (copy_to_user(uset, &set, sigsetsize))
3180 return -EFAULT;
3181
3182 return 0;
3183 }
3184
3185 #ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE2(rt_sigpending,compat_sigset_t __user *,uset,compat_size_t,sigsetsize)3186 COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
3187 compat_size_t, sigsetsize)
3188 {
3189 sigset_t set;
3190
3191 if (sigsetsize > sizeof(*uset))
3192 return -EINVAL;
3193
3194 do_sigpending(&set);
3195
3196 return put_compat_sigset(uset, &set, sigsetsize);
3197 }
3198 #endif
3199
3200 static const struct {
3201 unsigned char limit, layout;
3202 } sig_sicodes[] = {
3203 [SIGILL] = { NSIGILL, SIL_FAULT },
3204 [SIGFPE] = { NSIGFPE, SIL_FAULT },
3205 [SIGSEGV] = { NSIGSEGV, SIL_FAULT },
3206 [SIGBUS] = { NSIGBUS, SIL_FAULT },
3207 [SIGTRAP] = { NSIGTRAP, SIL_FAULT },
3208 #if defined(SIGEMT)
3209 [SIGEMT] = { NSIGEMT, SIL_FAULT },
3210 #endif
3211 [SIGCHLD] = { NSIGCHLD, SIL_CHLD },
3212 [SIGPOLL] = { NSIGPOLL, SIL_POLL },
3213 [SIGSYS] = { NSIGSYS, SIL_SYS },
3214 };
3215
known_siginfo_layout(unsigned sig,int si_code)3216 static bool known_siginfo_layout(unsigned sig, int si_code)
3217 {
3218 if (si_code == SI_KERNEL)
3219 return true;
3220 else if ((si_code > SI_USER)) {
3221 if (sig_specific_sicodes(sig)) {
3222 if (si_code <= sig_sicodes[sig].limit)
3223 return true;
3224 }
3225 else if (si_code <= NSIGPOLL)
3226 return true;
3227 }
3228 else if (si_code >= SI_DETHREAD)
3229 return true;
3230 else if (si_code == SI_ASYNCNL)
3231 return true;
3232 return false;
3233 }
3234
siginfo_layout(unsigned sig,int si_code)3235 enum siginfo_layout siginfo_layout(unsigned sig, int si_code)
3236 {
3237 enum siginfo_layout layout = SIL_KILL;
3238 if ((si_code > SI_USER) && (si_code < SI_KERNEL)) {
3239 if ((sig < ARRAY_SIZE(sig_sicodes)) &&
3240 (si_code <= sig_sicodes[sig].limit)) {
3241 layout = sig_sicodes[sig].layout;
3242 /* Handle the exceptions */
3243 if ((sig == SIGBUS) &&
3244 (si_code >= BUS_MCEERR_AR) && (si_code <= BUS_MCEERR_AO))
3245 layout = SIL_FAULT_MCEERR;
3246 else if ((sig == SIGSEGV) && (si_code == SEGV_BNDERR))
3247 layout = SIL_FAULT_BNDERR;
3248 #ifdef SEGV_PKUERR
3249 else if ((sig == SIGSEGV) && (si_code == SEGV_PKUERR))
3250 layout = SIL_FAULT_PKUERR;
3251 #endif
3252 else if ((sig == SIGTRAP) && (si_code == TRAP_PERF))
3253 layout = SIL_PERF_EVENT;
3254 }
3255 else if (si_code <= NSIGPOLL)
3256 layout = SIL_POLL;
3257 } else {
3258 if (si_code == SI_TIMER)
3259 layout = SIL_TIMER;
3260 else if (si_code == SI_SIGIO)
3261 layout = SIL_POLL;
3262 else if (si_code < 0)
3263 layout = SIL_RT;
3264 }
3265 return layout;
3266 }
3267
si_expansion(const siginfo_t __user * info)3268 static inline char __user *si_expansion(const siginfo_t __user *info)
3269 {
3270 return ((char __user *)info) + sizeof(struct kernel_siginfo);
3271 }
3272
copy_siginfo_to_user(siginfo_t __user * to,const kernel_siginfo_t * from)3273 int copy_siginfo_to_user(siginfo_t __user *to, const kernel_siginfo_t *from)
3274 {
3275 char __user *expansion = si_expansion(to);
3276 if (copy_to_user(to, from , sizeof(struct kernel_siginfo)))
3277 return -EFAULT;
3278 if (clear_user(expansion, SI_EXPANSION_SIZE))
3279 return -EFAULT;
3280 return 0;
3281 }
3282
post_copy_siginfo_from_user(kernel_siginfo_t * info,const siginfo_t __user * from)3283 static int post_copy_siginfo_from_user(kernel_siginfo_t *info,
3284 const siginfo_t __user *from)
3285 {
3286 if (unlikely(!known_siginfo_layout(info->si_signo, info->si_code))) {
3287 char __user *expansion = si_expansion(from);
3288 char buf[SI_EXPANSION_SIZE];
3289 int i;
3290 /*
3291 * An unknown si_code might need more than
3292 * sizeof(struct kernel_siginfo) bytes. Verify all of the
3293 * extra bytes are 0. This guarantees copy_siginfo_to_user
3294 * will return this data to userspace exactly.
3295 */
3296 if (copy_from_user(&buf, expansion, SI_EXPANSION_SIZE))
3297 return -EFAULT;
3298 for (i = 0; i < SI_EXPANSION_SIZE; i++) {
3299 if (buf[i] != 0)
3300 return -E2BIG;
3301 }
3302 }
3303 return 0;
3304 }
3305
__copy_siginfo_from_user(int signo,kernel_siginfo_t * to,const siginfo_t __user * from)3306 static int __copy_siginfo_from_user(int signo, kernel_siginfo_t *to,
3307 const siginfo_t __user *from)
3308 {
3309 if (copy_from_user(to, from, sizeof(struct kernel_siginfo)))
3310 return -EFAULT;
3311 to->si_signo = signo;
3312 return post_copy_siginfo_from_user(to, from);
3313 }
3314
copy_siginfo_from_user(kernel_siginfo_t * to,const siginfo_t __user * from)3315 int copy_siginfo_from_user(kernel_siginfo_t *to, const siginfo_t __user *from)
3316 {
3317 if (copy_from_user(to, from, sizeof(struct kernel_siginfo)))
3318 return -EFAULT;
3319 return post_copy_siginfo_from_user(to, from);
3320 }
3321
3322 #ifdef CONFIG_COMPAT
3323 /**
3324 * copy_siginfo_to_external32 - copy a kernel siginfo into a compat user siginfo
3325 * @to: compat siginfo destination
3326 * @from: kernel siginfo source
3327 *
3328 * Note: This function does not work properly for the SIGCHLD on x32, but
3329 * fortunately it doesn't have to. The only valid callers for this function are
3330 * copy_siginfo_to_user32, which is overriden for x32 and the coredump code.
3331 * The latter does not care because SIGCHLD will never cause a coredump.
3332 */
copy_siginfo_to_external32(struct compat_siginfo * to,const struct kernel_siginfo * from)3333 void copy_siginfo_to_external32(struct compat_siginfo *to,
3334 const struct kernel_siginfo *from)
3335 {
3336 memset(to, 0, sizeof(*to));
3337
3338 to->si_signo = from->si_signo;
3339 to->si_errno = from->si_errno;
3340 to->si_code = from->si_code;
3341 switch(siginfo_layout(from->si_signo, from->si_code)) {
3342 case SIL_KILL:
3343 to->si_pid = from->si_pid;
3344 to->si_uid = from->si_uid;
3345 break;
3346 case SIL_TIMER:
3347 to->si_tid = from->si_tid;
3348 to->si_overrun = from->si_overrun;
3349 to->si_int = from->si_int;
3350 break;
3351 case SIL_POLL:
3352 to->si_band = from->si_band;
3353 to->si_fd = from->si_fd;
3354 break;
3355 case SIL_FAULT:
3356 to->si_addr = ptr_to_compat(from->si_addr);
3357 #ifdef __ARCH_SI_TRAPNO
3358 to->si_trapno = from->si_trapno;
3359 #endif
3360 break;
3361 case SIL_FAULT_MCEERR:
3362 to->si_addr = ptr_to_compat(from->si_addr);
3363 #ifdef __ARCH_SI_TRAPNO
3364 to->si_trapno = from->si_trapno;
3365 #endif
3366 to->si_addr_lsb = from->si_addr_lsb;
3367 break;
3368 case SIL_FAULT_BNDERR:
3369 to->si_addr = ptr_to_compat(from->si_addr);
3370 #ifdef __ARCH_SI_TRAPNO
3371 to->si_trapno = from->si_trapno;
3372 #endif
3373 to->si_lower = ptr_to_compat(from->si_lower);
3374 to->si_upper = ptr_to_compat(from->si_upper);
3375 break;
3376 case SIL_FAULT_PKUERR:
3377 to->si_addr = ptr_to_compat(from->si_addr);
3378 #ifdef __ARCH_SI_TRAPNO
3379 to->si_trapno = from->si_trapno;
3380 #endif
3381 to->si_pkey = from->si_pkey;
3382 break;
3383 case SIL_PERF_EVENT:
3384 to->si_addr = ptr_to_compat(from->si_addr);
3385 to->si_perf = from->si_perf;
3386 break;
3387 case SIL_CHLD:
3388 to->si_pid = from->si_pid;
3389 to->si_uid = from->si_uid;
3390 to->si_status = from->si_status;
3391 to->si_utime = from->si_utime;
3392 to->si_stime = from->si_stime;
3393 break;
3394 case SIL_RT:
3395 to->si_pid = from->si_pid;
3396 to->si_uid = from->si_uid;
3397 to->si_int = from->si_int;
3398 break;
3399 case SIL_SYS:
3400 to->si_call_addr = ptr_to_compat(from->si_call_addr);
3401 to->si_syscall = from->si_syscall;
3402 to->si_arch = from->si_arch;
3403 break;
3404 }
3405 }
3406
__copy_siginfo_to_user32(struct compat_siginfo __user * to,const struct kernel_siginfo * from)3407 int __copy_siginfo_to_user32(struct compat_siginfo __user *to,
3408 const struct kernel_siginfo *from)
3409 {
3410 struct compat_siginfo new;
3411
3412 copy_siginfo_to_external32(&new, from);
3413 if (copy_to_user(to, &new, sizeof(struct compat_siginfo)))
3414 return -EFAULT;
3415 return 0;
3416 }
3417
post_copy_siginfo_from_user32(kernel_siginfo_t * to,const struct compat_siginfo * from)3418 static int post_copy_siginfo_from_user32(kernel_siginfo_t *to,
3419 const struct compat_siginfo *from)
3420 {
3421 clear_siginfo(to);
3422 to->si_signo = from->si_signo;
3423 to->si_errno = from->si_errno;
3424 to->si_code = from->si_code;
3425 switch(siginfo_layout(from->si_signo, from->si_code)) {
3426 case SIL_KILL:
3427 to->si_pid = from->si_pid;
3428 to->si_uid = from->si_uid;
3429 break;
3430 case SIL_TIMER:
3431 to->si_tid = from->si_tid;
3432 to->si_overrun = from->si_overrun;
3433 to->si_int = from->si_int;
3434 break;
3435 case SIL_POLL:
3436 to->si_band = from->si_band;
3437 to->si_fd = from->si_fd;
3438 break;
3439 case SIL_FAULT:
3440 to->si_addr = compat_ptr(from->si_addr);
3441 #ifdef __ARCH_SI_TRAPNO
3442 to->si_trapno = from->si_trapno;
3443 #endif
3444 break;
3445 case SIL_FAULT_MCEERR:
3446 to->si_addr = compat_ptr(from->si_addr);
3447 #ifdef __ARCH_SI_TRAPNO
3448 to->si_trapno = from->si_trapno;
3449 #endif
3450 to->si_addr_lsb = from->si_addr_lsb;
3451 break;
3452 case SIL_FAULT_BNDERR:
3453 to->si_addr = compat_ptr(from->si_addr);
3454 #ifdef __ARCH_SI_TRAPNO
3455 to->si_trapno = from->si_trapno;
3456 #endif
3457 to->si_lower = compat_ptr(from->si_lower);
3458 to->si_upper = compat_ptr(from->si_upper);
3459 break;
3460 case SIL_FAULT_PKUERR:
3461 to->si_addr = compat_ptr(from->si_addr);
3462 #ifdef __ARCH_SI_TRAPNO
3463 to->si_trapno = from->si_trapno;
3464 #endif
3465 to->si_pkey = from->si_pkey;
3466 break;
3467 case SIL_PERF_EVENT:
3468 to->si_addr = compat_ptr(from->si_addr);
3469 to->si_perf = from->si_perf;
3470 break;
3471 case SIL_CHLD:
3472 to->si_pid = from->si_pid;
3473 to->si_uid = from->si_uid;
3474 to->si_status = from->si_status;
3475 #ifdef CONFIG_X86_X32_ABI
3476 if (in_x32_syscall()) {
3477 to->si_utime = from->_sifields._sigchld_x32._utime;
3478 to->si_stime = from->_sifields._sigchld_x32._stime;
3479 } else
3480 #endif
3481 {
3482 to->si_utime = from->si_utime;
3483 to->si_stime = from->si_stime;
3484 }
3485 break;
3486 case SIL_RT:
3487 to->si_pid = from->si_pid;
3488 to->si_uid = from->si_uid;
3489 to->si_int = from->si_int;
3490 break;
3491 case SIL_SYS:
3492 to->si_call_addr = compat_ptr(from->si_call_addr);
3493 to->si_syscall = from->si_syscall;
3494 to->si_arch = from->si_arch;
3495 break;
3496 }
3497 return 0;
3498 }
3499
__copy_siginfo_from_user32(int signo,struct kernel_siginfo * to,const struct compat_siginfo __user * ufrom)3500 static int __copy_siginfo_from_user32(int signo, struct kernel_siginfo *to,
3501 const struct compat_siginfo __user *ufrom)
3502 {
3503 struct compat_siginfo from;
3504
3505 if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
3506 return -EFAULT;
3507
3508 from.si_signo = signo;
3509 return post_copy_siginfo_from_user32(to, &from);
3510 }
3511
copy_siginfo_from_user32(struct kernel_siginfo * to,const struct compat_siginfo __user * ufrom)3512 int copy_siginfo_from_user32(struct kernel_siginfo *to,
3513 const struct compat_siginfo __user *ufrom)
3514 {
3515 struct compat_siginfo from;
3516
3517 if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
3518 return -EFAULT;
3519
3520 return post_copy_siginfo_from_user32(to, &from);
3521 }
3522 #endif /* CONFIG_COMPAT */
3523
3524 /**
3525 * do_sigtimedwait - wait for queued signals specified in @which
3526 * @which: queued signals to wait for
3527 * @info: if non-null, the signal's siginfo is returned here
3528 * @ts: upper bound on process time suspension
3529 */
do_sigtimedwait(const sigset_t * which,kernel_siginfo_t * info,const struct timespec64 * ts)3530 static int do_sigtimedwait(const sigset_t *which, kernel_siginfo_t *info,
3531 const struct timespec64 *ts)
3532 {
3533 ktime_t *to = NULL, timeout = KTIME_MAX;
3534 struct task_struct *tsk = current;
3535 sigset_t mask = *which;
3536 int sig, ret = 0;
3537
3538 if (ts) {
3539 if (!timespec64_valid(ts))
3540 return -EINVAL;
3541 timeout = timespec64_to_ktime(*ts);
3542 to = &timeout;
3543 }
3544
3545 /*
3546 * Invert the set of allowed signals to get those we want to block.
3547 */
3548 sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
3549 signotset(&mask);
3550
3551 spin_lock_irq(&tsk->sighand->siglock);
3552 sig = dequeue_signal(tsk, &mask, info);
3553 if (!sig && timeout) {
3554 /*
3555 * None ready, temporarily unblock those we're interested
3556 * while we are sleeping in so that we'll be awakened when
3557 * they arrive. Unblocking is always fine, we can avoid
3558 * set_current_blocked().
3559 */
3560 tsk->real_blocked = tsk->blocked;
3561 sigandsets(&tsk->blocked, &tsk->blocked, &mask);
3562 recalc_sigpending();
3563 spin_unlock_irq(&tsk->sighand->siglock);
3564
3565 __set_current_state(TASK_INTERRUPTIBLE);
3566 ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns,
3567 HRTIMER_MODE_REL);
3568 spin_lock_irq(&tsk->sighand->siglock);
3569 __set_task_blocked(tsk, &tsk->real_blocked);
3570 sigemptyset(&tsk->real_blocked);
3571 sig = dequeue_signal(tsk, &mask, info);
3572 }
3573 spin_unlock_irq(&tsk->sighand->siglock);
3574
3575 if (sig)
3576 return sig;
3577 return ret ? -EINTR : -EAGAIN;
3578 }
3579
3580 /**
3581 * sys_rt_sigtimedwait - synchronously wait for queued signals specified
3582 * in @uthese
3583 * @uthese: queued signals to wait for
3584 * @uinfo: if non-null, the signal's siginfo is returned here
3585 * @uts: upper bound on process time suspension
3586 * @sigsetsize: size of sigset_t type
3587 */
SYSCALL_DEFINE4(rt_sigtimedwait,const sigset_t __user *,uthese,siginfo_t __user *,uinfo,const struct __kernel_timespec __user *,uts,size_t,sigsetsize)3588 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
3589 siginfo_t __user *, uinfo,
3590 const struct __kernel_timespec __user *, uts,
3591 size_t, sigsetsize)
3592 {
3593 sigset_t these;
3594 struct timespec64 ts;
3595 kernel_siginfo_t info;
3596 int ret;
3597
3598 /* XXX: Don't preclude handling different sized sigset_t's. */
3599 if (sigsetsize != sizeof(sigset_t))
3600 return -EINVAL;
3601
3602 if (copy_from_user(&these, uthese, sizeof(these)))
3603 return -EFAULT;
3604
3605 if (uts) {
3606 if (get_timespec64(&ts, uts))
3607 return -EFAULT;
3608 }
3609
3610 ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
3611
3612 if (ret > 0 && uinfo) {
3613 if (copy_siginfo_to_user(uinfo, &info))
3614 ret = -EFAULT;
3615 }
3616
3617 return ret;
3618 }
3619
3620 #ifdef CONFIG_COMPAT_32BIT_TIME
SYSCALL_DEFINE4(rt_sigtimedwait_time32,const sigset_t __user *,uthese,siginfo_t __user *,uinfo,const struct old_timespec32 __user *,uts,size_t,sigsetsize)3621 SYSCALL_DEFINE4(rt_sigtimedwait_time32, const sigset_t __user *, uthese,
3622 siginfo_t __user *, uinfo,
3623 const struct old_timespec32 __user *, uts,
3624 size_t, sigsetsize)
3625 {
3626 sigset_t these;
3627 struct timespec64 ts;
3628 kernel_siginfo_t info;
3629 int ret;
3630
3631 if (sigsetsize != sizeof(sigset_t))
3632 return -EINVAL;
3633
3634 if (copy_from_user(&these, uthese, sizeof(these)))
3635 return -EFAULT;
3636
3637 if (uts) {
3638 if (get_old_timespec32(&ts, uts))
3639 return -EFAULT;
3640 }
3641
3642 ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
3643
3644 if (ret > 0 && uinfo) {
3645 if (copy_siginfo_to_user(uinfo, &info))
3646 ret = -EFAULT;
3647 }
3648
3649 return ret;
3650 }
3651 #endif
3652
3653 #ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time64,compat_sigset_t __user *,uthese,struct compat_siginfo __user *,uinfo,struct __kernel_timespec __user *,uts,compat_size_t,sigsetsize)3654 COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time64, compat_sigset_t __user *, uthese,
3655 struct compat_siginfo __user *, uinfo,
3656 struct __kernel_timespec __user *, uts, compat_size_t, sigsetsize)
3657 {
3658 sigset_t s;
3659 struct timespec64 t;
3660 kernel_siginfo_t info;
3661 long ret;
3662
3663 if (sigsetsize != sizeof(sigset_t))
3664 return -EINVAL;
3665
3666 if (get_compat_sigset(&s, uthese))
3667 return -EFAULT;
3668
3669 if (uts) {
3670 if (get_timespec64(&t, uts))
3671 return -EFAULT;
3672 }
3673
3674 ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
3675
3676 if (ret > 0 && uinfo) {
3677 if (copy_siginfo_to_user32(uinfo, &info))
3678 ret = -EFAULT;
3679 }
3680
3681 return ret;
3682 }
3683
3684 #ifdef CONFIG_COMPAT_32BIT_TIME
COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time32,compat_sigset_t __user *,uthese,struct compat_siginfo __user *,uinfo,struct old_timespec32 __user *,uts,compat_size_t,sigsetsize)3685 COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time32, compat_sigset_t __user *, uthese,
3686 struct compat_siginfo __user *, uinfo,
3687 struct old_timespec32 __user *, uts, compat_size_t, sigsetsize)
3688 {
3689 sigset_t s;
3690 struct timespec64 t;
3691 kernel_siginfo_t info;
3692 long ret;
3693
3694 if (sigsetsize != sizeof(sigset_t))
3695 return -EINVAL;
3696
3697 if (get_compat_sigset(&s, uthese))
3698 return -EFAULT;
3699
3700 if (uts) {
3701 if (get_old_timespec32(&t, uts))
3702 return -EFAULT;
3703 }
3704
3705 ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
3706
3707 if (ret > 0 && uinfo) {
3708 if (copy_siginfo_to_user32(uinfo, &info))
3709 ret = -EFAULT;
3710 }
3711
3712 return ret;
3713 }
3714 #endif
3715 #endif
3716
prepare_kill_siginfo(int sig,struct kernel_siginfo * info)3717 static inline void prepare_kill_siginfo(int sig, struct kernel_siginfo *info)
3718 {
3719 clear_siginfo(info);
3720 info->si_signo = sig;
3721 info->si_errno = 0;
3722 info->si_code = SI_USER;
3723 info->si_pid = task_tgid_vnr(current);
3724 info->si_uid = from_kuid_munged(current_user_ns(), current_uid());
3725 }
3726
3727 /**
3728 * sys_kill - send a signal to a process
3729 * @pid: the PID of the process
3730 * @sig: signal to be sent
3731 */
SYSCALL_DEFINE2(kill,pid_t,pid,int,sig)3732 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
3733 {
3734 struct kernel_siginfo info;
3735
3736 prepare_kill_siginfo(sig, &info);
3737
3738 return kill_something_info(sig, &info, pid);
3739 }
3740
3741 /*
3742 * Verify that the signaler and signalee either are in the same pid namespace
3743 * or that the signaler's pid namespace is an ancestor of the signalee's pid
3744 * namespace.
3745 */
access_pidfd_pidns(struct pid * pid)3746 static bool access_pidfd_pidns(struct pid *pid)
3747 {
3748 struct pid_namespace *active = task_active_pid_ns(current);
3749 struct pid_namespace *p = ns_of_pid(pid);
3750
3751 for (;;) {
3752 if (!p)
3753 return false;
3754 if (p == active)
3755 break;
3756 p = p->parent;
3757 }
3758
3759 return true;
3760 }
3761
copy_siginfo_from_user_any(kernel_siginfo_t * kinfo,siginfo_t __user * info)3762 static int copy_siginfo_from_user_any(kernel_siginfo_t *kinfo,
3763 siginfo_t __user *info)
3764 {
3765 #ifdef CONFIG_COMPAT
3766 /*
3767 * Avoid hooking up compat syscalls and instead handle necessary
3768 * conversions here. Note, this is a stop-gap measure and should not be
3769 * considered a generic solution.
3770 */
3771 if (in_compat_syscall())
3772 return copy_siginfo_from_user32(
3773 kinfo, (struct compat_siginfo __user *)info);
3774 #endif
3775 return copy_siginfo_from_user(kinfo, info);
3776 }
3777
pidfd_to_pid(const struct file * file)3778 static struct pid *pidfd_to_pid(const struct file *file)
3779 {
3780 struct pid *pid;
3781
3782 pid = pidfd_pid(file);
3783 if (!IS_ERR(pid))
3784 return pid;
3785
3786 return tgid_pidfd_to_pid(file);
3787 }
3788
3789 /**
3790 * sys_pidfd_send_signal - Signal a process through a pidfd
3791 * @pidfd: file descriptor of the process
3792 * @sig: signal to send
3793 * @info: signal info
3794 * @flags: future flags
3795 *
3796 * The syscall currently only signals via PIDTYPE_PID which covers
3797 * kill(<positive-pid>, <signal>. It does not signal threads or process
3798 * groups.
3799 * In order to extend the syscall to threads and process groups the @flags
3800 * argument should be used. In essence, the @flags argument will determine
3801 * what is signaled and not the file descriptor itself. Put in other words,
3802 * grouping is a property of the flags argument not a property of the file
3803 * descriptor.
3804 *
3805 * Return: 0 on success, negative errno on failure
3806 */
SYSCALL_DEFINE4(pidfd_send_signal,int,pidfd,int,sig,siginfo_t __user *,info,unsigned int,flags)3807 SYSCALL_DEFINE4(pidfd_send_signal, int, pidfd, int, sig,
3808 siginfo_t __user *, info, unsigned int, flags)
3809 {
3810 int ret;
3811 struct fd f;
3812 struct pid *pid;
3813 kernel_siginfo_t kinfo;
3814
3815 /* Enforce flags be set to 0 until we add an extension. */
3816 if (flags)
3817 return -EINVAL;
3818
3819 f = fdget(pidfd);
3820 if (!f.file)
3821 return -EBADF;
3822
3823 /* Is this a pidfd? */
3824 pid = pidfd_to_pid(f.file);
3825 if (IS_ERR(pid)) {
3826 ret = PTR_ERR(pid);
3827 goto err;
3828 }
3829
3830 ret = -EINVAL;
3831 if (!access_pidfd_pidns(pid))
3832 goto err;
3833
3834 if (info) {
3835 ret = copy_siginfo_from_user_any(&kinfo, info);
3836 if (unlikely(ret))
3837 goto err;
3838
3839 ret = -EINVAL;
3840 if (unlikely(sig != kinfo.si_signo))
3841 goto err;
3842
3843 /* Only allow sending arbitrary signals to yourself. */
3844 ret = -EPERM;
3845 if ((task_pid(current) != pid) &&
3846 (kinfo.si_code >= 0 || kinfo.si_code == SI_TKILL))
3847 goto err;
3848 } else {
3849 prepare_kill_siginfo(sig, &kinfo);
3850 }
3851
3852 ret = kill_pid_info(sig, &kinfo, pid);
3853
3854 err:
3855 fdput(f);
3856 return ret;
3857 }
3858
3859 static int
do_send_specific(pid_t tgid,pid_t pid,int sig,struct kernel_siginfo * info)3860 do_send_specific(pid_t tgid, pid_t pid, int sig, struct kernel_siginfo *info)
3861 {
3862 struct task_struct *p;
3863 int error = -ESRCH;
3864
3865 rcu_read_lock();
3866 p = find_task_by_vpid(pid);
3867 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
3868 error = check_kill_permission(sig, info, p);
3869 /*
3870 * The null signal is a permissions and process existence
3871 * probe. No signal is actually delivered.
3872 */
3873 if (!error && sig) {
3874 error = do_send_sig_info(sig, info, p, PIDTYPE_PID);
3875 /*
3876 * If lock_task_sighand() failed we pretend the task
3877 * dies after receiving the signal. The window is tiny,
3878 * and the signal is private anyway.
3879 */
3880 if (unlikely(error == -ESRCH))
3881 error = 0;
3882 }
3883 }
3884 rcu_read_unlock();
3885
3886 return error;
3887 }
3888
do_tkill(pid_t tgid,pid_t pid,int sig)3889 static int do_tkill(pid_t tgid, pid_t pid, int sig)
3890 {
3891 struct kernel_siginfo info;
3892
3893 clear_siginfo(&info);
3894 info.si_signo = sig;
3895 info.si_errno = 0;
3896 info.si_code = SI_TKILL;
3897 info.si_pid = task_tgid_vnr(current);
3898 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
3899
3900 return do_send_specific(tgid, pid, sig, &info);
3901 }
3902
3903 /**
3904 * sys_tgkill - send signal to one specific thread
3905 * @tgid: the thread group ID of the thread
3906 * @pid: the PID of the thread
3907 * @sig: signal to be sent
3908 *
3909 * This syscall also checks the @tgid and returns -ESRCH even if the PID
3910 * exists but it's not belonging to the target process anymore. This
3911 * method solves the problem of threads exiting and PIDs getting reused.
3912 */
SYSCALL_DEFINE3(tgkill,pid_t,tgid,pid_t,pid,int,sig)3913 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
3914 {
3915 /* This is only valid for single tasks */
3916 if (pid <= 0 || tgid <= 0)
3917 return -EINVAL;
3918
3919 return do_tkill(tgid, pid, sig);
3920 }
3921
3922 /**
3923 * sys_tkill - send signal to one specific task
3924 * @pid: the PID of the task
3925 * @sig: signal to be sent
3926 *
3927 * Send a signal to only one task, even if it's a CLONE_THREAD task.
3928 */
SYSCALL_DEFINE2(tkill,pid_t,pid,int,sig)3929 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
3930 {
3931 /* This is only valid for single tasks */
3932 if (pid <= 0)
3933 return -EINVAL;
3934
3935 return do_tkill(0, pid, sig);
3936 }
3937
do_rt_sigqueueinfo(pid_t pid,int sig,kernel_siginfo_t * info)3938 static int do_rt_sigqueueinfo(pid_t pid, int sig, kernel_siginfo_t *info)
3939 {
3940 /* Not even root can pretend to send signals from the kernel.
3941 * Nor can they impersonate a kill()/tgkill(), which adds source info.
3942 */
3943 if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3944 (task_pid_vnr(current) != pid))
3945 return -EPERM;
3946
3947 /* POSIX.1b doesn't mention process groups. */
3948 return kill_proc_info(sig, info, pid);
3949 }
3950
3951 /**
3952 * sys_rt_sigqueueinfo - send signal information to a signal
3953 * @pid: the PID of the thread
3954 * @sig: signal to be sent
3955 * @uinfo: signal info to be sent
3956 */
SYSCALL_DEFINE3(rt_sigqueueinfo,pid_t,pid,int,sig,siginfo_t __user *,uinfo)3957 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
3958 siginfo_t __user *, uinfo)
3959 {
3960 kernel_siginfo_t info;
3961 int ret = __copy_siginfo_from_user(sig, &info, uinfo);
3962 if (unlikely(ret))
3963 return ret;
3964 return do_rt_sigqueueinfo(pid, sig, &info);
3965 }
3966
3967 #ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,compat_pid_t,pid,int,sig,struct compat_siginfo __user *,uinfo)3968 COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
3969 compat_pid_t, pid,
3970 int, sig,
3971 struct compat_siginfo __user *, uinfo)
3972 {
3973 kernel_siginfo_t info;
3974 int ret = __copy_siginfo_from_user32(sig, &info, uinfo);
3975 if (unlikely(ret))
3976 return ret;
3977 return do_rt_sigqueueinfo(pid, sig, &info);
3978 }
3979 #endif
3980
do_rt_tgsigqueueinfo(pid_t tgid,pid_t pid,int sig,kernel_siginfo_t * info)3981 static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, kernel_siginfo_t *info)
3982 {
3983 /* This is only valid for single tasks */
3984 if (pid <= 0 || tgid <= 0)
3985 return -EINVAL;
3986
3987 /* Not even root can pretend to send signals from the kernel.
3988 * Nor can they impersonate a kill()/tgkill(), which adds source info.
3989 */
3990 if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3991 (task_pid_vnr(current) != pid))
3992 return -EPERM;
3993
3994 return do_send_specific(tgid, pid, sig, info);
3995 }
3996
SYSCALL_DEFINE4(rt_tgsigqueueinfo,pid_t,tgid,pid_t,pid,int,sig,siginfo_t __user *,uinfo)3997 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
3998 siginfo_t __user *, uinfo)
3999 {
4000 kernel_siginfo_t info;
4001 int ret = __copy_siginfo_from_user(sig, &info, uinfo);
4002 if (unlikely(ret))
4003 return ret;
4004 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
4005 }
4006
4007 #ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,compat_pid_t,tgid,compat_pid_t,pid,int,sig,struct compat_siginfo __user *,uinfo)4008 COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
4009 compat_pid_t, tgid,
4010 compat_pid_t, pid,
4011 int, sig,
4012 struct compat_siginfo __user *, uinfo)
4013 {
4014 kernel_siginfo_t info;
4015 int ret = __copy_siginfo_from_user32(sig, &info, uinfo);
4016 if (unlikely(ret))
4017 return ret;
4018 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
4019 }
4020 #endif
4021
4022 /*
4023 * For kthreads only, must not be used if cloned with CLONE_SIGHAND
4024 */
kernel_sigaction(int sig,__sighandler_t action)4025 void kernel_sigaction(int sig, __sighandler_t action)
4026 {
4027 spin_lock_irq(¤t->sighand->siglock);
4028 current->sighand->action[sig - 1].sa.sa_handler = action;
4029 if (action == SIG_IGN) {
4030 sigset_t mask;
4031
4032 sigemptyset(&mask);
4033 sigaddset(&mask, sig);
4034
4035 flush_sigqueue_mask(&mask, ¤t->signal->shared_pending);
4036 flush_sigqueue_mask(&mask, ¤t->pending);
4037 recalc_sigpending();
4038 }
4039 spin_unlock_irq(¤t->sighand->siglock);
4040 }
4041 EXPORT_SYMBOL(kernel_sigaction);
4042
sigaction_compat_abi(struct k_sigaction * act,struct k_sigaction * oact)4043 void __weak sigaction_compat_abi(struct k_sigaction *act,
4044 struct k_sigaction *oact)
4045 {
4046 }
4047
do_sigaction(int sig,struct k_sigaction * act,struct k_sigaction * oact)4048 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
4049 {
4050 struct task_struct *p = current, *t;
4051 struct k_sigaction *k;
4052 sigset_t mask;
4053
4054 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
4055 return -EINVAL;
4056
4057 k = &p->sighand->action[sig-1];
4058
4059 spin_lock_irq(&p->sighand->siglock);
4060 if (oact)
4061 *oact = *k;
4062
4063 /*
4064 * Make sure that we never accidentally claim to support SA_UNSUPPORTED,
4065 * e.g. by having an architecture use the bit in their uapi.
4066 */
4067 BUILD_BUG_ON(UAPI_SA_FLAGS & SA_UNSUPPORTED);
4068
4069 /*
4070 * Clear unknown flag bits in order to allow userspace to detect missing
4071 * support for flag bits and to allow the kernel to use non-uapi bits
4072 * internally.
4073 */
4074 if (act)
4075 act->sa.sa_flags &= UAPI_SA_FLAGS;
4076 if (oact)
4077 oact->sa.sa_flags &= UAPI_SA_FLAGS;
4078
4079 sigaction_compat_abi(act, oact);
4080
4081 if (act) {
4082 sigdelsetmask(&act->sa.sa_mask,
4083 sigmask(SIGKILL) | sigmask(SIGSTOP));
4084 *k = *act;
4085 /*
4086 * POSIX 3.3.1.3:
4087 * "Setting a signal action to SIG_IGN for a signal that is
4088 * pending shall cause the pending signal to be discarded,
4089 * whether or not it is blocked."
4090 *
4091 * "Setting a signal action to SIG_DFL for a signal that is
4092 * pending and whose default action is to ignore the signal
4093 * (for example, SIGCHLD), shall cause the pending signal to
4094 * be discarded, whether or not it is blocked"
4095 */
4096 if (sig_handler_ignored(sig_handler(p, sig), sig)) {
4097 sigemptyset(&mask);
4098 sigaddset(&mask, sig);
4099 flush_sigqueue_mask(&mask, &p->signal->shared_pending);
4100 for_each_thread(p, t)
4101 flush_sigqueue_mask(&mask, &t->pending);
4102 }
4103 }
4104
4105 spin_unlock_irq(&p->sighand->siglock);
4106 return 0;
4107 }
4108
4109 static int
do_sigaltstack(const stack_t * ss,stack_t * oss,unsigned long sp,size_t min_ss_size)4110 do_sigaltstack (const stack_t *ss, stack_t *oss, unsigned long sp,
4111 size_t min_ss_size)
4112 {
4113 struct task_struct *t = current;
4114
4115 if (oss) {
4116 memset(oss, 0, sizeof(stack_t));
4117 oss->ss_sp = (void __user *) t->sas_ss_sp;
4118 oss->ss_size = t->sas_ss_size;
4119 oss->ss_flags = sas_ss_flags(sp) |
4120 (current->sas_ss_flags & SS_FLAG_BITS);
4121 }
4122
4123 if (ss) {
4124 void __user *ss_sp = ss->ss_sp;
4125 size_t ss_size = ss->ss_size;
4126 unsigned ss_flags = ss->ss_flags;
4127 int ss_mode;
4128
4129 if (unlikely(on_sig_stack(sp)))
4130 return -EPERM;
4131
4132 ss_mode = ss_flags & ~SS_FLAG_BITS;
4133 if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
4134 ss_mode != 0))
4135 return -EINVAL;
4136
4137 if (ss_mode == SS_DISABLE) {
4138 ss_size = 0;
4139 ss_sp = NULL;
4140 } else {
4141 if (unlikely(ss_size < min_ss_size))
4142 return -ENOMEM;
4143 }
4144
4145 t->sas_ss_sp = (unsigned long) ss_sp;
4146 t->sas_ss_size = ss_size;
4147 t->sas_ss_flags = ss_flags;
4148 }
4149 return 0;
4150 }
4151
SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss,stack_t __user *,uoss)4152 SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
4153 {
4154 stack_t new, old;
4155 int err;
4156 if (uss && copy_from_user(&new, uss, sizeof(stack_t)))
4157 return -EFAULT;
4158 err = do_sigaltstack(uss ? &new : NULL, uoss ? &old : NULL,
4159 current_user_stack_pointer(),
4160 MINSIGSTKSZ);
4161 if (!err && uoss && copy_to_user(uoss, &old, sizeof(stack_t)))
4162 err = -EFAULT;
4163 return err;
4164 }
4165
restore_altstack(const stack_t __user * uss)4166 int restore_altstack(const stack_t __user *uss)
4167 {
4168 stack_t new;
4169 if (copy_from_user(&new, uss, sizeof(stack_t)))
4170 return -EFAULT;
4171 (void)do_sigaltstack(&new, NULL, current_user_stack_pointer(),
4172 MINSIGSTKSZ);
4173 /* squash all but EFAULT for now */
4174 return 0;
4175 }
4176
__save_altstack(stack_t __user * uss,unsigned long sp)4177 int __save_altstack(stack_t __user *uss, unsigned long sp)
4178 {
4179 struct task_struct *t = current;
4180 int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
4181 __put_user(t->sas_ss_flags, &uss->ss_flags) |
4182 __put_user(t->sas_ss_size, &uss->ss_size);
4183 if (err)
4184 return err;
4185 if (t->sas_ss_flags & SS_AUTODISARM)
4186 sas_ss_reset(t);
4187 return 0;
4188 }
4189
4190 #ifdef CONFIG_COMPAT
do_compat_sigaltstack(const compat_stack_t __user * uss_ptr,compat_stack_t __user * uoss_ptr)4191 static int do_compat_sigaltstack(const compat_stack_t __user *uss_ptr,
4192 compat_stack_t __user *uoss_ptr)
4193 {
4194 stack_t uss, uoss;
4195 int ret;
4196
4197 if (uss_ptr) {
4198 compat_stack_t uss32;
4199 if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
4200 return -EFAULT;
4201 uss.ss_sp = compat_ptr(uss32.ss_sp);
4202 uss.ss_flags = uss32.ss_flags;
4203 uss.ss_size = uss32.ss_size;
4204 }
4205 ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss,
4206 compat_user_stack_pointer(),
4207 COMPAT_MINSIGSTKSZ);
4208 if (ret >= 0 && uoss_ptr) {
4209 compat_stack_t old;
4210 memset(&old, 0, sizeof(old));
4211 old.ss_sp = ptr_to_compat(uoss.ss_sp);
4212 old.ss_flags = uoss.ss_flags;
4213 old.ss_size = uoss.ss_size;
4214 if (copy_to_user(uoss_ptr, &old, sizeof(compat_stack_t)))
4215 ret = -EFAULT;
4216 }
4217 return ret;
4218 }
4219
COMPAT_SYSCALL_DEFINE2(sigaltstack,const compat_stack_t __user *,uss_ptr,compat_stack_t __user *,uoss_ptr)4220 COMPAT_SYSCALL_DEFINE2(sigaltstack,
4221 const compat_stack_t __user *, uss_ptr,
4222 compat_stack_t __user *, uoss_ptr)
4223 {
4224 return do_compat_sigaltstack(uss_ptr, uoss_ptr);
4225 }
4226
compat_restore_altstack(const compat_stack_t __user * uss)4227 int compat_restore_altstack(const compat_stack_t __user *uss)
4228 {
4229 int err = do_compat_sigaltstack(uss, NULL);
4230 /* squash all but -EFAULT for now */
4231 return err == -EFAULT ? err : 0;
4232 }
4233
__compat_save_altstack(compat_stack_t __user * uss,unsigned long sp)4234 int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
4235 {
4236 int err;
4237 struct task_struct *t = current;
4238 err = __put_user(ptr_to_compat((void __user *)t->sas_ss_sp),
4239 &uss->ss_sp) |
4240 __put_user(t->sas_ss_flags, &uss->ss_flags) |
4241 __put_user(t->sas_ss_size, &uss->ss_size);
4242 if (err)
4243 return err;
4244 if (t->sas_ss_flags & SS_AUTODISARM)
4245 sas_ss_reset(t);
4246 return 0;
4247 }
4248 #endif
4249
4250 #ifdef __ARCH_WANT_SYS_SIGPENDING
4251
4252 /**
4253 * sys_sigpending - examine pending signals
4254 * @uset: where mask of pending signal is returned
4255 */
SYSCALL_DEFINE1(sigpending,old_sigset_t __user *,uset)4256 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, uset)
4257 {
4258 sigset_t set;
4259
4260 if (sizeof(old_sigset_t) > sizeof(*uset))
4261 return -EINVAL;
4262
4263 do_sigpending(&set);
4264
4265 if (copy_to_user(uset, &set, sizeof(old_sigset_t)))
4266 return -EFAULT;
4267
4268 return 0;
4269 }
4270
4271 #ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE1(sigpending,compat_old_sigset_t __user *,set32)4272 COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set32)
4273 {
4274 sigset_t set;
4275
4276 do_sigpending(&set);
4277
4278 return put_user(set.sig[0], set32);
4279 }
4280 #endif
4281
4282 #endif
4283
4284 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
4285 /**
4286 * sys_sigprocmask - examine and change blocked signals
4287 * @how: whether to add, remove, or set signals
4288 * @nset: signals to add or remove (if non-null)
4289 * @oset: previous value of signal mask if non-null
4290 *
4291 * Some platforms have their own version with special arguments;
4292 * others support only sys_rt_sigprocmask.
4293 */
4294
SYSCALL_DEFINE3(sigprocmask,int,how,old_sigset_t __user *,nset,old_sigset_t __user *,oset)4295 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
4296 old_sigset_t __user *, oset)
4297 {
4298 old_sigset_t old_set, new_set;
4299 sigset_t new_blocked;
4300
4301 old_set = current->blocked.sig[0];
4302
4303 if (nset) {
4304 if (copy_from_user(&new_set, nset, sizeof(*nset)))
4305 return -EFAULT;
4306
4307 new_blocked = current->blocked;
4308
4309 switch (how) {
4310 case SIG_BLOCK:
4311 sigaddsetmask(&new_blocked, new_set);
4312 break;
4313 case SIG_UNBLOCK:
4314 sigdelsetmask(&new_blocked, new_set);
4315 break;
4316 case SIG_SETMASK:
4317 new_blocked.sig[0] = new_set;
4318 break;
4319 default:
4320 return -EINVAL;
4321 }
4322
4323 set_current_blocked(&new_blocked);
4324 }
4325
4326 if (oset) {
4327 if (copy_to_user(oset, &old_set, sizeof(*oset)))
4328 return -EFAULT;
4329 }
4330
4331 return 0;
4332 }
4333 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
4334
4335 #ifndef CONFIG_ODD_RT_SIGACTION
4336 /**
4337 * sys_rt_sigaction - alter an action taken by a process
4338 * @sig: signal to be sent
4339 * @act: new sigaction
4340 * @oact: used to save the previous sigaction
4341 * @sigsetsize: size of sigset_t type
4342 */
SYSCALL_DEFINE4(rt_sigaction,int,sig,const struct sigaction __user *,act,struct sigaction __user *,oact,size_t,sigsetsize)4343 SYSCALL_DEFINE4(rt_sigaction, int, sig,
4344 const struct sigaction __user *, act,
4345 struct sigaction __user *, oact,
4346 size_t, sigsetsize)
4347 {
4348 struct k_sigaction new_sa, old_sa;
4349 int ret;
4350
4351 /* XXX: Don't preclude handling different sized sigset_t's. */
4352 if (sigsetsize != sizeof(sigset_t))
4353 return -EINVAL;
4354
4355 if (act && copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
4356 return -EFAULT;
4357
4358 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
4359 if (ret)
4360 return ret;
4361
4362 if (oact && copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
4363 return -EFAULT;
4364
4365 return 0;
4366 }
4367 #ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE4(rt_sigaction,int,sig,const struct compat_sigaction __user *,act,struct compat_sigaction __user *,oact,compat_size_t,sigsetsize)4368 COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig,
4369 const struct compat_sigaction __user *, act,
4370 struct compat_sigaction __user *, oact,
4371 compat_size_t, sigsetsize)
4372 {
4373 struct k_sigaction new_ka, old_ka;
4374 #ifdef __ARCH_HAS_SA_RESTORER
4375 compat_uptr_t restorer;
4376 #endif
4377 int ret;
4378
4379 /* XXX: Don't preclude handling different sized sigset_t's. */
4380 if (sigsetsize != sizeof(compat_sigset_t))
4381 return -EINVAL;
4382
4383 if (act) {
4384 compat_uptr_t handler;
4385 ret = get_user(handler, &act->sa_handler);
4386 new_ka.sa.sa_handler = compat_ptr(handler);
4387 #ifdef __ARCH_HAS_SA_RESTORER
4388 ret |= get_user(restorer, &act->sa_restorer);
4389 new_ka.sa.sa_restorer = compat_ptr(restorer);
4390 #endif
4391 ret |= get_compat_sigset(&new_ka.sa.sa_mask, &act->sa_mask);
4392 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
4393 if (ret)
4394 return -EFAULT;
4395 }
4396
4397 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
4398 if (!ret && oact) {
4399 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler),
4400 &oact->sa_handler);
4401 ret |= put_compat_sigset(&oact->sa_mask, &old_ka.sa.sa_mask,
4402 sizeof(oact->sa_mask));
4403 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
4404 #ifdef __ARCH_HAS_SA_RESTORER
4405 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
4406 &oact->sa_restorer);
4407 #endif
4408 }
4409 return ret;
4410 }
4411 #endif
4412 #endif /* !CONFIG_ODD_RT_SIGACTION */
4413
4414 #ifdef CONFIG_OLD_SIGACTION
SYSCALL_DEFINE3(sigaction,int,sig,const struct old_sigaction __user *,act,struct old_sigaction __user *,oact)4415 SYSCALL_DEFINE3(sigaction, int, sig,
4416 const struct old_sigaction __user *, act,
4417 struct old_sigaction __user *, oact)
4418 {
4419 struct k_sigaction new_ka, old_ka;
4420 int ret;
4421
4422 if (act) {
4423 old_sigset_t mask;
4424 if (!access_ok(act, sizeof(*act)) ||
4425 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
4426 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
4427 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
4428 __get_user(mask, &act->sa_mask))
4429 return -EFAULT;
4430 #ifdef __ARCH_HAS_KA_RESTORER
4431 new_ka.ka_restorer = NULL;
4432 #endif
4433 siginitset(&new_ka.sa.sa_mask, mask);
4434 }
4435
4436 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
4437
4438 if (!ret && oact) {
4439 if (!access_ok(oact, sizeof(*oact)) ||
4440 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
4441 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
4442 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
4443 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
4444 return -EFAULT;
4445 }
4446
4447 return ret;
4448 }
4449 #endif
4450 #ifdef CONFIG_COMPAT_OLD_SIGACTION
COMPAT_SYSCALL_DEFINE3(sigaction,int,sig,const struct compat_old_sigaction __user *,act,struct compat_old_sigaction __user *,oact)4451 COMPAT_SYSCALL_DEFINE3(sigaction, int, sig,
4452 const struct compat_old_sigaction __user *, act,
4453 struct compat_old_sigaction __user *, oact)
4454 {
4455 struct k_sigaction new_ka, old_ka;
4456 int ret;
4457 compat_old_sigset_t mask;
4458 compat_uptr_t handler, restorer;
4459
4460 if (act) {
4461 if (!access_ok(act, sizeof(*act)) ||
4462 __get_user(handler, &act->sa_handler) ||
4463 __get_user(restorer, &act->sa_restorer) ||
4464 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
4465 __get_user(mask, &act->sa_mask))
4466 return -EFAULT;
4467
4468 #ifdef __ARCH_HAS_KA_RESTORER
4469 new_ka.ka_restorer = NULL;
4470 #endif
4471 new_ka.sa.sa_handler = compat_ptr(handler);
4472 new_ka.sa.sa_restorer = compat_ptr(restorer);
4473 siginitset(&new_ka.sa.sa_mask, mask);
4474 }
4475
4476 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
4477
4478 if (!ret && oact) {
4479 if (!access_ok(oact, sizeof(*oact)) ||
4480 __put_user(ptr_to_compat(old_ka.sa.sa_handler),
4481 &oact->sa_handler) ||
4482 __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
4483 &oact->sa_restorer) ||
4484 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
4485 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
4486 return -EFAULT;
4487 }
4488 return ret;
4489 }
4490 #endif
4491
4492 #ifdef CONFIG_SGETMASK_SYSCALL
4493
4494 /*
4495 * For backwards compatibility. Functionality superseded by sigprocmask.
4496 */
SYSCALL_DEFINE0(sgetmask)4497 SYSCALL_DEFINE0(sgetmask)
4498 {
4499 /* SMP safe */
4500 return current->blocked.sig[0];
4501 }
4502
SYSCALL_DEFINE1(ssetmask,int,newmask)4503 SYSCALL_DEFINE1(ssetmask, int, newmask)
4504 {
4505 int old = current->blocked.sig[0];
4506 sigset_t newset;
4507
4508 siginitset(&newset, newmask);
4509 set_current_blocked(&newset);
4510
4511 return old;
4512 }
4513 #endif /* CONFIG_SGETMASK_SYSCALL */
4514
4515 #ifdef __ARCH_WANT_SYS_SIGNAL
4516 /*
4517 * For backwards compatibility. Functionality superseded by sigaction.
4518 */
SYSCALL_DEFINE2(signal,int,sig,__sighandler_t,handler)4519 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
4520 {
4521 struct k_sigaction new_sa, old_sa;
4522 int ret;
4523
4524 new_sa.sa.sa_handler = handler;
4525 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
4526 sigemptyset(&new_sa.sa.sa_mask);
4527
4528 ret = do_sigaction(sig, &new_sa, &old_sa);
4529
4530 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
4531 }
4532 #endif /* __ARCH_WANT_SYS_SIGNAL */
4533
4534 #ifdef __ARCH_WANT_SYS_PAUSE
4535
SYSCALL_DEFINE0(pause)4536 SYSCALL_DEFINE0(pause)
4537 {
4538 while (!signal_pending(current)) {
4539 __set_current_state(TASK_INTERRUPTIBLE);
4540 schedule();
4541 }
4542 return -ERESTARTNOHAND;
4543 }
4544
4545 #endif
4546
sigsuspend(sigset_t * set)4547 static int sigsuspend(sigset_t *set)
4548 {
4549 current->saved_sigmask = current->blocked;
4550 set_current_blocked(set);
4551
4552 while (!signal_pending(current)) {
4553 __set_current_state(TASK_INTERRUPTIBLE);
4554 schedule();
4555 }
4556 set_restore_sigmask();
4557 return -ERESTARTNOHAND;
4558 }
4559
4560 /**
4561 * sys_rt_sigsuspend - replace the signal mask for a value with the
4562 * @unewset value until a signal is received
4563 * @unewset: new signal mask value
4564 * @sigsetsize: size of sigset_t type
4565 */
SYSCALL_DEFINE2(rt_sigsuspend,sigset_t __user *,unewset,size_t,sigsetsize)4566 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
4567 {
4568 sigset_t newset;
4569
4570 /* XXX: Don't preclude handling different sized sigset_t's. */
4571 if (sigsetsize != sizeof(sigset_t))
4572 return -EINVAL;
4573
4574 if (copy_from_user(&newset, unewset, sizeof(newset)))
4575 return -EFAULT;
4576 return sigsuspend(&newset);
4577 }
4578
4579 #ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE2(rt_sigsuspend,compat_sigset_t __user *,unewset,compat_size_t,sigsetsize)4580 COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
4581 {
4582 sigset_t newset;
4583
4584 /* XXX: Don't preclude handling different sized sigset_t's. */
4585 if (sigsetsize != sizeof(sigset_t))
4586 return -EINVAL;
4587
4588 if (get_compat_sigset(&newset, unewset))
4589 return -EFAULT;
4590 return sigsuspend(&newset);
4591 }
4592 #endif
4593
4594 #ifdef CONFIG_OLD_SIGSUSPEND
SYSCALL_DEFINE1(sigsuspend,old_sigset_t,mask)4595 SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
4596 {
4597 sigset_t blocked;
4598 siginitset(&blocked, mask);
4599 return sigsuspend(&blocked);
4600 }
4601 #endif
4602 #ifdef CONFIG_OLD_SIGSUSPEND3
SYSCALL_DEFINE3(sigsuspend,int,unused1,int,unused2,old_sigset_t,mask)4603 SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask)
4604 {
4605 sigset_t blocked;
4606 siginitset(&blocked, mask);
4607 return sigsuspend(&blocked);
4608 }
4609 #endif
4610
arch_vma_name(struct vm_area_struct * vma)4611 __weak const char *arch_vma_name(struct vm_area_struct *vma)
4612 {
4613 return NULL;
4614 }
4615
siginfo_buildtime_checks(void)4616 static inline void siginfo_buildtime_checks(void)
4617 {
4618 BUILD_BUG_ON(sizeof(struct siginfo) != SI_MAX_SIZE);
4619
4620 /* Verify the offsets in the two siginfos match */
4621 #define CHECK_OFFSET(field) \
4622 BUILD_BUG_ON(offsetof(siginfo_t, field) != offsetof(kernel_siginfo_t, field))
4623
4624 /* kill */
4625 CHECK_OFFSET(si_pid);
4626 CHECK_OFFSET(si_uid);
4627
4628 /* timer */
4629 CHECK_OFFSET(si_tid);
4630 CHECK_OFFSET(si_overrun);
4631 CHECK_OFFSET(si_value);
4632
4633 /* rt */
4634 CHECK_OFFSET(si_pid);
4635 CHECK_OFFSET(si_uid);
4636 CHECK_OFFSET(si_value);
4637
4638 /* sigchld */
4639 CHECK_OFFSET(si_pid);
4640 CHECK_OFFSET(si_uid);
4641 CHECK_OFFSET(si_status);
4642 CHECK_OFFSET(si_utime);
4643 CHECK_OFFSET(si_stime);
4644
4645 /* sigfault */
4646 CHECK_OFFSET(si_addr);
4647 CHECK_OFFSET(si_addr_lsb);
4648 CHECK_OFFSET(si_lower);
4649 CHECK_OFFSET(si_upper);
4650 CHECK_OFFSET(si_pkey);
4651 CHECK_OFFSET(si_perf);
4652
4653 /* sigpoll */
4654 CHECK_OFFSET(si_band);
4655 CHECK_OFFSET(si_fd);
4656
4657 /* sigsys */
4658 CHECK_OFFSET(si_call_addr);
4659 CHECK_OFFSET(si_syscall);
4660 CHECK_OFFSET(si_arch);
4661 #undef CHECK_OFFSET
4662
4663 /* usb asyncio */
4664 BUILD_BUG_ON(offsetof(struct siginfo, si_pid) !=
4665 offsetof(struct siginfo, si_addr));
4666 if (sizeof(int) == sizeof(void __user *)) {
4667 BUILD_BUG_ON(sizeof_field(struct siginfo, si_pid) !=
4668 sizeof(void __user *));
4669 } else {
4670 BUILD_BUG_ON((sizeof_field(struct siginfo, si_pid) +
4671 sizeof_field(struct siginfo, si_uid)) !=
4672 sizeof(void __user *));
4673 BUILD_BUG_ON(offsetofend(struct siginfo, si_pid) !=
4674 offsetof(struct siginfo, si_uid));
4675 }
4676 #ifdef CONFIG_COMPAT
4677 BUILD_BUG_ON(offsetof(struct compat_siginfo, si_pid) !=
4678 offsetof(struct compat_siginfo, si_addr));
4679 BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) !=
4680 sizeof(compat_uptr_t));
4681 BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) !=
4682 sizeof_field(struct siginfo, si_pid));
4683 #endif
4684 }
4685
signals_init(void)4686 void __init signals_init(void)
4687 {
4688 siginfo_buildtime_checks();
4689
4690 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
4691 }
4692
4693 #ifdef CONFIG_KGDB_KDB
4694 #include <linux/kdb.h>
4695 /*
4696 * kdb_send_sig - Allows kdb to send signals without exposing
4697 * signal internals. This function checks if the required locks are
4698 * available before calling the main signal code, to avoid kdb
4699 * deadlocks.
4700 */
kdb_send_sig(struct task_struct * t,int sig)4701 void kdb_send_sig(struct task_struct *t, int sig)
4702 {
4703 static struct task_struct *kdb_prev_t;
4704 int new_t, ret;
4705 if (!spin_trylock(&t->sighand->siglock)) {
4706 kdb_printf("Can't do kill command now.\n"
4707 "The sigmask lock is held somewhere else in "
4708 "kernel, try again later\n");
4709 return;
4710 }
4711 new_t = kdb_prev_t != t;
4712 kdb_prev_t = t;
4713 if (t->state != TASK_RUNNING && new_t) {
4714 spin_unlock(&t->sighand->siglock);
4715 kdb_printf("Process is not RUNNING, sending a signal from "
4716 "kdb risks deadlock\n"
4717 "on the run queue locks. "
4718 "The signal has _not_ been sent.\n"
4719 "Reissue the kill command if you want to risk "
4720 "the deadlock.\n");
4721 return;
4722 }
4723 ret = send_signal(sig, SEND_SIG_PRIV, t, PIDTYPE_PID);
4724 spin_unlock(&t->sighand->siglock);
4725 if (ret)
4726 kdb_printf("Fail to deliver Signal %d to process %d.\n",
4727 sig, t->pid);
4728 else
4729 kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
4730 }
4731 #endif /* CONFIG_KGDB_KDB */
4732