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