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