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