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