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