xref: /openbmc/linux/kernel/signal.c (revision 4da722ca)
1 /*
2  *  linux/kernel/signal.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  *
6  *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
7  *
8  *  2003-06-02  Jim Houston - Concurrent Computer Corp.
9  *		Changes to use preallocated sigqueue structures
10  *		to allow signals to be sent reliably.
11  */
12 
13 #include <linux/slab.h>
14 #include <linux/export.h>
15 #include <linux/init.h>
16 #include <linux/sched/mm.h>
17 #include <linux/sched/user.h>
18 #include <linux/sched/debug.h>
19 #include <linux/sched/task.h>
20 #include <linux/sched/task_stack.h>
21 #include <linux/sched/cputime.h>
22 #include <linux/fs.h>
23 #include <linux/tty.h>
24 #include <linux/binfmts.h>
25 #include <linux/coredump.h>
26 #include <linux/security.h>
27 #include <linux/syscalls.h>
28 #include <linux/ptrace.h>
29 #include <linux/signal.h>
30 #include <linux/signalfd.h>
31 #include <linux/ratelimit.h>
32 #include <linux/tracehook.h>
33 #include <linux/capability.h>
34 #include <linux/freezer.h>
35 #include <linux/pid_namespace.h>
36 #include <linux/nsproxy.h>
37 #include <linux/user_namespace.h>
38 #include <linux/uprobes.h>
39 #include <linux/compat.h>
40 #include <linux/cn_proc.h>
41 #include <linux/compiler.h>
42 #include <linux/posix-timers.h>
43 
44 #define CREATE_TRACE_POINTS
45 #include <trace/events/signal.h>
46 
47 #include <asm/param.h>
48 #include <linux/uaccess.h>
49 #include <asm/unistd.h>
50 #include <asm/siginfo.h>
51 #include <asm/cacheflush.h>
52 #include "audit.h"	/* audit_signal_info() */
53 
54 /*
55  * SLAB caches for signal bits.
56  */
57 
58 static struct kmem_cache *sigqueue_cachep;
59 
60 int print_fatal_signals __read_mostly;
61 
62 static void __user *sig_handler(struct task_struct *t, int sig)
63 {
64 	return t->sighand->action[sig - 1].sa.sa_handler;
65 }
66 
67 static int sig_handler_ignored(void __user *handler, int sig)
68 {
69 	/* Is it explicitly or implicitly ignored? */
70 	return handler == SIG_IGN ||
71 		(handler == SIG_DFL && sig_kernel_ignore(sig));
72 }
73 
74 static int sig_task_ignored(struct task_struct *t, int sig, bool force)
75 {
76 	void __user *handler;
77 
78 	handler = sig_handler(t, sig);
79 
80 	if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
81 			handler == SIG_DFL && !force)
82 		return 1;
83 
84 	return sig_handler_ignored(handler, sig);
85 }
86 
87 static int sig_ignored(struct task_struct *t, int sig, bool force)
88 {
89 	/*
90 	 * Blocked signals are never ignored, since the
91 	 * signal handler may change by the time it is
92 	 * unblocked.
93 	 */
94 	if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
95 		return 0;
96 
97 	if (!sig_task_ignored(t, sig, force))
98 		return 0;
99 
100 	/*
101 	 * Tracers may want to know about even ignored signals.
102 	 */
103 	return !t->ptrace;
104 }
105 
106 /*
107  * Re-calculate pending state from the set of locally pending
108  * signals, globally pending signals, and blocked signals.
109  */
110 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
111 {
112 	unsigned long ready;
113 	long i;
114 
115 	switch (_NSIG_WORDS) {
116 	default:
117 		for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
118 			ready |= signal->sig[i] &~ blocked->sig[i];
119 		break;
120 
121 	case 4: ready  = signal->sig[3] &~ blocked->sig[3];
122 		ready |= signal->sig[2] &~ blocked->sig[2];
123 		ready |= signal->sig[1] &~ blocked->sig[1];
124 		ready |= signal->sig[0] &~ blocked->sig[0];
125 		break;
126 
127 	case 2: ready  = signal->sig[1] &~ blocked->sig[1];
128 		ready |= signal->sig[0] &~ blocked->sig[0];
129 		break;
130 
131 	case 1: ready  = signal->sig[0] &~ blocked->sig[0];
132 	}
133 	return ready !=	0;
134 }
135 
136 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
137 
138 static int recalc_sigpending_tsk(struct task_struct *t)
139 {
140 	if ((t->jobctl & JOBCTL_PENDING_MASK) ||
141 	    PENDING(&t->pending, &t->blocked) ||
142 	    PENDING(&t->signal->shared_pending, &t->blocked)) {
143 		set_tsk_thread_flag(t, TIF_SIGPENDING);
144 		return 1;
145 	}
146 	/*
147 	 * We must never clear the flag in another thread, or in current
148 	 * when it's possible the current syscall is returning -ERESTART*.
149 	 * So we don't clear it here, and only callers who know they should do.
150 	 */
151 	return 0;
152 }
153 
154 /*
155  * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
156  * This is superfluous when called on current, the wakeup is a harmless no-op.
157  */
158 void recalc_sigpending_and_wake(struct task_struct *t)
159 {
160 	if (recalc_sigpending_tsk(t))
161 		signal_wake_up(t, 0);
162 }
163 
164 void recalc_sigpending(void)
165 {
166 	if (!recalc_sigpending_tsk(current) && !freezing(current))
167 		clear_thread_flag(TIF_SIGPENDING);
168 
169 }
170 
171 /* Given the mask, find the first available signal that should be serviced. */
172 
173 #define SYNCHRONOUS_MASK \
174 	(sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
175 	 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
176 
177 int next_signal(struct sigpending *pending, sigset_t *mask)
178 {
179 	unsigned long i, *s, *m, x;
180 	int sig = 0;
181 
182 	s = pending->signal.sig;
183 	m = mask->sig;
184 
185 	/*
186 	 * Handle the first word specially: it contains the
187 	 * synchronous signals that need to be dequeued first.
188 	 */
189 	x = *s &~ *m;
190 	if (x) {
191 		if (x & SYNCHRONOUS_MASK)
192 			x &= SYNCHRONOUS_MASK;
193 		sig = ffz(~x) + 1;
194 		return sig;
195 	}
196 
197 	switch (_NSIG_WORDS) {
198 	default:
199 		for (i = 1; i < _NSIG_WORDS; ++i) {
200 			x = *++s &~ *++m;
201 			if (!x)
202 				continue;
203 			sig = ffz(~x) + i*_NSIG_BPW + 1;
204 			break;
205 		}
206 		break;
207 
208 	case 2:
209 		x = s[1] &~ m[1];
210 		if (!x)
211 			break;
212 		sig = ffz(~x) + _NSIG_BPW + 1;
213 		break;
214 
215 	case 1:
216 		/* Nothing to do */
217 		break;
218 	}
219 
220 	return sig;
221 }
222 
223 static inline void print_dropped_signal(int sig)
224 {
225 	static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
226 
227 	if (!print_fatal_signals)
228 		return;
229 
230 	if (!__ratelimit(&ratelimit_state))
231 		return;
232 
233 	pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
234 				current->comm, current->pid, sig);
235 }
236 
237 /**
238  * task_set_jobctl_pending - set jobctl pending bits
239  * @task: target task
240  * @mask: pending bits to set
241  *
242  * Clear @mask from @task->jobctl.  @mask must be subset of
243  * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
244  * %JOBCTL_TRAPPING.  If stop signo is being set, the existing signo is
245  * cleared.  If @task is already being killed or exiting, this function
246  * becomes noop.
247  *
248  * CONTEXT:
249  * Must be called with @task->sighand->siglock held.
250  *
251  * RETURNS:
252  * %true if @mask is set, %false if made noop because @task was dying.
253  */
254 bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
255 {
256 	BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
257 			JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
258 	BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
259 
260 	if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
261 		return false;
262 
263 	if (mask & JOBCTL_STOP_SIGMASK)
264 		task->jobctl &= ~JOBCTL_STOP_SIGMASK;
265 
266 	task->jobctl |= mask;
267 	return true;
268 }
269 
270 /**
271  * task_clear_jobctl_trapping - clear jobctl trapping bit
272  * @task: target task
273  *
274  * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
275  * Clear it and wake up the ptracer.  Note that we don't need any further
276  * locking.  @task->siglock guarantees that @task->parent points to the
277  * ptracer.
278  *
279  * CONTEXT:
280  * Must be called with @task->sighand->siglock held.
281  */
282 void task_clear_jobctl_trapping(struct task_struct *task)
283 {
284 	if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
285 		task->jobctl &= ~JOBCTL_TRAPPING;
286 		smp_mb();	/* advised by wake_up_bit() */
287 		wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
288 	}
289 }
290 
291 /**
292  * task_clear_jobctl_pending - clear jobctl pending bits
293  * @task: target task
294  * @mask: pending bits to clear
295  *
296  * Clear @mask from @task->jobctl.  @mask must be subset of
297  * %JOBCTL_PENDING_MASK.  If %JOBCTL_STOP_PENDING is being cleared, other
298  * STOP bits are cleared together.
299  *
300  * If clearing of @mask leaves no stop or trap pending, this function calls
301  * task_clear_jobctl_trapping().
302  *
303  * CONTEXT:
304  * Must be called with @task->sighand->siglock held.
305  */
306 void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
307 {
308 	BUG_ON(mask & ~JOBCTL_PENDING_MASK);
309 
310 	if (mask & JOBCTL_STOP_PENDING)
311 		mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
312 
313 	task->jobctl &= ~mask;
314 
315 	if (!(task->jobctl & JOBCTL_PENDING_MASK))
316 		task_clear_jobctl_trapping(task);
317 }
318 
319 /**
320  * task_participate_group_stop - participate in a group stop
321  * @task: task participating in a group stop
322  *
323  * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
324  * Group stop states are cleared and the group stop count is consumed if
325  * %JOBCTL_STOP_CONSUME was set.  If the consumption completes the group
326  * stop, the appropriate %SIGNAL_* flags are set.
327  *
328  * CONTEXT:
329  * Must be called with @task->sighand->siglock held.
330  *
331  * RETURNS:
332  * %true if group stop completion should be notified to the parent, %false
333  * otherwise.
334  */
335 static bool task_participate_group_stop(struct task_struct *task)
336 {
337 	struct signal_struct *sig = task->signal;
338 	bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
339 
340 	WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
341 
342 	task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
343 
344 	if (!consume)
345 		return false;
346 
347 	if (!WARN_ON_ONCE(sig->group_stop_count == 0))
348 		sig->group_stop_count--;
349 
350 	/*
351 	 * Tell the caller to notify completion iff we are entering into a
352 	 * fresh group stop.  Read comment in do_signal_stop() for details.
353 	 */
354 	if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
355 		signal_set_stop_flags(sig, SIGNAL_STOP_STOPPED);
356 		return true;
357 	}
358 	return false;
359 }
360 
361 /*
362  * allocate a new signal queue record
363  * - this may be called without locks if and only if t == current, otherwise an
364  *   appropriate lock must be held to stop the target task from exiting
365  */
366 static struct sigqueue *
367 __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
368 {
369 	struct sigqueue *q = NULL;
370 	struct user_struct *user;
371 
372 	/*
373 	 * Protect access to @t credentials. This can go away when all
374 	 * callers hold rcu read lock.
375 	 */
376 	rcu_read_lock();
377 	user = get_uid(__task_cred(t)->user);
378 	atomic_inc(&user->sigpending);
379 	rcu_read_unlock();
380 
381 	if (override_rlimit ||
382 	    atomic_read(&user->sigpending) <=
383 			task_rlimit(t, RLIMIT_SIGPENDING)) {
384 		q = kmem_cache_alloc(sigqueue_cachep, flags);
385 	} else {
386 		print_dropped_signal(sig);
387 	}
388 
389 	if (unlikely(q == NULL)) {
390 		atomic_dec(&user->sigpending);
391 		free_uid(user);
392 	} else {
393 		INIT_LIST_HEAD(&q->list);
394 		q->flags = 0;
395 		q->user = user;
396 	}
397 
398 	return q;
399 }
400 
401 static void __sigqueue_free(struct sigqueue *q)
402 {
403 	if (q->flags & SIGQUEUE_PREALLOC)
404 		return;
405 	atomic_dec(&q->user->sigpending);
406 	free_uid(q->user);
407 	kmem_cache_free(sigqueue_cachep, q);
408 }
409 
410 void flush_sigqueue(struct sigpending *queue)
411 {
412 	struct sigqueue *q;
413 
414 	sigemptyset(&queue->signal);
415 	while (!list_empty(&queue->list)) {
416 		q = list_entry(queue->list.next, struct sigqueue , list);
417 		list_del_init(&q->list);
418 		__sigqueue_free(q);
419 	}
420 }
421 
422 /*
423  * Flush all pending signals for this kthread.
424  */
425 void flush_signals(struct task_struct *t)
426 {
427 	unsigned long flags;
428 
429 	spin_lock_irqsave(&t->sighand->siglock, flags);
430 	clear_tsk_thread_flag(t, TIF_SIGPENDING);
431 	flush_sigqueue(&t->pending);
432 	flush_sigqueue(&t->signal->shared_pending);
433 	spin_unlock_irqrestore(&t->sighand->siglock, flags);
434 }
435 
436 #ifdef CONFIG_POSIX_TIMERS
437 static void __flush_itimer_signals(struct sigpending *pending)
438 {
439 	sigset_t signal, retain;
440 	struct sigqueue *q, *n;
441 
442 	signal = pending->signal;
443 	sigemptyset(&retain);
444 
445 	list_for_each_entry_safe(q, n, &pending->list, list) {
446 		int sig = q->info.si_signo;
447 
448 		if (likely(q->info.si_code != SI_TIMER)) {
449 			sigaddset(&retain, sig);
450 		} else {
451 			sigdelset(&signal, sig);
452 			list_del_init(&q->list);
453 			__sigqueue_free(q);
454 		}
455 	}
456 
457 	sigorsets(&pending->signal, &signal, &retain);
458 }
459 
460 void flush_itimer_signals(void)
461 {
462 	struct task_struct *tsk = current;
463 	unsigned long flags;
464 
465 	spin_lock_irqsave(&tsk->sighand->siglock, flags);
466 	__flush_itimer_signals(&tsk->pending);
467 	__flush_itimer_signals(&tsk->signal->shared_pending);
468 	spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
469 }
470 #endif
471 
472 void ignore_signals(struct task_struct *t)
473 {
474 	int i;
475 
476 	for (i = 0; i < _NSIG; ++i)
477 		t->sighand->action[i].sa.sa_handler = SIG_IGN;
478 
479 	flush_signals(t);
480 }
481 
482 /*
483  * Flush all handlers for a task.
484  */
485 
486 void
487 flush_signal_handlers(struct task_struct *t, int force_default)
488 {
489 	int i;
490 	struct k_sigaction *ka = &t->sighand->action[0];
491 	for (i = _NSIG ; i != 0 ; i--) {
492 		if (force_default || ka->sa.sa_handler != SIG_IGN)
493 			ka->sa.sa_handler = SIG_DFL;
494 		ka->sa.sa_flags = 0;
495 #ifdef __ARCH_HAS_SA_RESTORER
496 		ka->sa.sa_restorer = NULL;
497 #endif
498 		sigemptyset(&ka->sa.sa_mask);
499 		ka++;
500 	}
501 }
502 
503 int unhandled_signal(struct task_struct *tsk, int sig)
504 {
505 	void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
506 	if (is_global_init(tsk))
507 		return 1;
508 	if (handler != SIG_IGN && handler != SIG_DFL)
509 		return 0;
510 	/* if ptraced, let the tracer determine */
511 	return !tsk->ptrace;
512 }
513 
514 static void collect_signal(int sig, struct sigpending *list, siginfo_t *info,
515 			   bool *resched_timer)
516 {
517 	struct sigqueue *q, *first = NULL;
518 
519 	/*
520 	 * Collect the siginfo appropriate to this signal.  Check if
521 	 * there is another siginfo for the same signal.
522 	*/
523 	list_for_each_entry(q, &list->list, list) {
524 		if (q->info.si_signo == sig) {
525 			if (first)
526 				goto still_pending;
527 			first = q;
528 		}
529 	}
530 
531 	sigdelset(&list->signal, sig);
532 
533 	if (first) {
534 still_pending:
535 		list_del_init(&first->list);
536 		copy_siginfo(info, &first->info);
537 
538 		*resched_timer =
539 			(first->flags & SIGQUEUE_PREALLOC) &&
540 			(info->si_code == SI_TIMER) &&
541 			(info->si_sys_private);
542 
543 		__sigqueue_free(first);
544 	} else {
545 		/*
546 		 * Ok, it wasn't in the queue.  This must be
547 		 * a fast-pathed signal or we must have been
548 		 * out of queue space.  So zero out the info.
549 		 */
550 		info->si_signo = sig;
551 		info->si_errno = 0;
552 		info->si_code = SI_USER;
553 		info->si_pid = 0;
554 		info->si_uid = 0;
555 	}
556 }
557 
558 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
559 			siginfo_t *info, bool *resched_timer)
560 {
561 	int sig = next_signal(pending, mask);
562 
563 	if (sig)
564 		collect_signal(sig, pending, info, resched_timer);
565 	return sig;
566 }
567 
568 /*
569  * Dequeue a signal and return the element to the caller, which is
570  * expected to free it.
571  *
572  * All callers have to hold the siglock.
573  */
574 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
575 {
576 	bool resched_timer = false;
577 	int signr;
578 
579 	/* We only dequeue private signals from ourselves, we don't let
580 	 * signalfd steal them
581 	 */
582 	signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer);
583 	if (!signr) {
584 		signr = __dequeue_signal(&tsk->signal->shared_pending,
585 					 mask, info, &resched_timer);
586 #ifdef CONFIG_POSIX_TIMERS
587 		/*
588 		 * itimer signal ?
589 		 *
590 		 * itimers are process shared and we restart periodic
591 		 * itimers in the signal delivery path to prevent DoS
592 		 * attacks in the high resolution timer case. This is
593 		 * compliant with the old way of self-restarting
594 		 * itimers, as the SIGALRM is a legacy signal and only
595 		 * queued once. Changing the restart behaviour to
596 		 * restart the timer in the signal dequeue path is
597 		 * reducing the timer noise on heavy loaded !highres
598 		 * systems too.
599 		 */
600 		if (unlikely(signr == SIGALRM)) {
601 			struct hrtimer *tmr = &tsk->signal->real_timer;
602 
603 			if (!hrtimer_is_queued(tmr) &&
604 			    tsk->signal->it_real_incr != 0) {
605 				hrtimer_forward(tmr, tmr->base->get_time(),
606 						tsk->signal->it_real_incr);
607 				hrtimer_restart(tmr);
608 			}
609 		}
610 #endif
611 	}
612 
613 	recalc_sigpending();
614 	if (!signr)
615 		return 0;
616 
617 	if (unlikely(sig_kernel_stop(signr))) {
618 		/*
619 		 * Set a marker that we have dequeued a stop signal.  Our
620 		 * caller might release the siglock and then the pending
621 		 * stop signal it is about to process is no longer in the
622 		 * pending bitmasks, but must still be cleared by a SIGCONT
623 		 * (and overruled by a SIGKILL).  So those cases clear this
624 		 * shared flag after we've set it.  Note that this flag may
625 		 * remain set after the signal we return is ignored or
626 		 * handled.  That doesn't matter because its only purpose
627 		 * is to alert stop-signal processing code when another
628 		 * processor has come along and cleared the flag.
629 		 */
630 		current->jobctl |= JOBCTL_STOP_DEQUEUED;
631 	}
632 #ifdef CONFIG_POSIX_TIMERS
633 	if (resched_timer) {
634 		/*
635 		 * Release the siglock to ensure proper locking order
636 		 * of timer locks outside of siglocks.  Note, we leave
637 		 * irqs disabled here, since the posix-timers code is
638 		 * about to disable them again anyway.
639 		 */
640 		spin_unlock(&tsk->sighand->siglock);
641 		posixtimer_rearm(info);
642 		spin_lock(&tsk->sighand->siglock);
643 	}
644 #endif
645 	return signr;
646 }
647 
648 /*
649  * Tell a process that it has a new active signal..
650  *
651  * NOTE! we rely on the previous spin_lock to
652  * lock interrupts for us! We can only be called with
653  * "siglock" held, and the local interrupt must
654  * have been disabled when that got acquired!
655  *
656  * No need to set need_resched since signal event passing
657  * goes through ->blocked
658  */
659 void signal_wake_up_state(struct task_struct *t, unsigned int state)
660 {
661 	set_tsk_thread_flag(t, TIF_SIGPENDING);
662 	/*
663 	 * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
664 	 * case. We don't check t->state here because there is a race with it
665 	 * executing another processor and just now entering stopped state.
666 	 * By using wake_up_state, we ensure the process will wake up and
667 	 * handle its death signal.
668 	 */
669 	if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
670 		kick_process(t);
671 }
672 
673 /*
674  * Remove signals in mask from the pending set and queue.
675  * Returns 1 if any signals were found.
676  *
677  * All callers must be holding the siglock.
678  */
679 static int flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
680 {
681 	struct sigqueue *q, *n;
682 	sigset_t m;
683 
684 	sigandsets(&m, mask, &s->signal);
685 	if (sigisemptyset(&m))
686 		return 0;
687 
688 	sigandnsets(&s->signal, &s->signal, mask);
689 	list_for_each_entry_safe(q, n, &s->list, list) {
690 		if (sigismember(mask, q->info.si_signo)) {
691 			list_del_init(&q->list);
692 			__sigqueue_free(q);
693 		}
694 	}
695 	return 1;
696 }
697 
698 static inline int is_si_special(const struct siginfo *info)
699 {
700 	return info <= SEND_SIG_FORCED;
701 }
702 
703 static inline bool si_fromuser(const struct siginfo *info)
704 {
705 	return info == SEND_SIG_NOINFO ||
706 		(!is_si_special(info) && SI_FROMUSER(info));
707 }
708 
709 /*
710  * called with RCU read lock from check_kill_permission()
711  */
712 static int kill_ok_by_cred(struct task_struct *t)
713 {
714 	const struct cred *cred = current_cred();
715 	const struct cred *tcred = __task_cred(t);
716 
717 	if (uid_eq(cred->euid, tcred->suid) ||
718 	    uid_eq(cred->euid, tcred->uid)  ||
719 	    uid_eq(cred->uid,  tcred->suid) ||
720 	    uid_eq(cred->uid,  tcred->uid))
721 		return 1;
722 
723 	if (ns_capable(tcred->user_ns, CAP_KILL))
724 		return 1;
725 
726 	return 0;
727 }
728 
729 /*
730  * Bad permissions for sending the signal
731  * - the caller must hold the RCU read lock
732  */
733 static int check_kill_permission(int sig, struct siginfo *info,
734 				 struct task_struct *t)
735 {
736 	struct pid *sid;
737 	int error;
738 
739 	if (!valid_signal(sig))
740 		return -EINVAL;
741 
742 	if (!si_fromuser(info))
743 		return 0;
744 
745 	error = audit_signal_info(sig, t); /* Let audit system see the signal */
746 	if (error)
747 		return error;
748 
749 	if (!same_thread_group(current, t) &&
750 	    !kill_ok_by_cred(t)) {
751 		switch (sig) {
752 		case SIGCONT:
753 			sid = task_session(t);
754 			/*
755 			 * We don't return the error if sid == NULL. The
756 			 * task was unhashed, the caller must notice this.
757 			 */
758 			if (!sid || sid == task_session(current))
759 				break;
760 		default:
761 			return -EPERM;
762 		}
763 	}
764 
765 	return security_task_kill(t, info, sig, 0);
766 }
767 
768 /**
769  * ptrace_trap_notify - schedule trap to notify ptracer
770  * @t: tracee wanting to notify tracer
771  *
772  * This function schedules sticky ptrace trap which is cleared on the next
773  * TRAP_STOP to notify ptracer of an event.  @t must have been seized by
774  * ptracer.
775  *
776  * If @t is running, STOP trap will be taken.  If trapped for STOP and
777  * ptracer is listening for events, tracee is woken up so that it can
778  * re-trap for the new event.  If trapped otherwise, STOP trap will be
779  * eventually taken without returning to userland after the existing traps
780  * are finished by PTRACE_CONT.
781  *
782  * CONTEXT:
783  * Must be called with @task->sighand->siglock held.
784  */
785 static void ptrace_trap_notify(struct task_struct *t)
786 {
787 	WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
788 	assert_spin_locked(&t->sighand->siglock);
789 
790 	task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
791 	ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
792 }
793 
794 /*
795  * Handle magic process-wide effects of stop/continue signals. Unlike
796  * the signal actions, these happen immediately at signal-generation
797  * time regardless of blocking, ignoring, or handling.  This does the
798  * actual continuing for SIGCONT, but not the actual stopping for stop
799  * signals. The process stop is done as a signal action for SIG_DFL.
800  *
801  * Returns true if the signal should be actually delivered, otherwise
802  * it should be dropped.
803  */
804 static bool prepare_signal(int sig, struct task_struct *p, bool force)
805 {
806 	struct signal_struct *signal = p->signal;
807 	struct task_struct *t;
808 	sigset_t flush;
809 
810 	if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
811 		if (!(signal->flags & SIGNAL_GROUP_EXIT))
812 			return sig == SIGKILL;
813 		/*
814 		 * The process is in the middle of dying, nothing to do.
815 		 */
816 	} else if (sig_kernel_stop(sig)) {
817 		/*
818 		 * This is a stop signal.  Remove SIGCONT from all queues.
819 		 */
820 		siginitset(&flush, sigmask(SIGCONT));
821 		flush_sigqueue_mask(&flush, &signal->shared_pending);
822 		for_each_thread(p, t)
823 			flush_sigqueue_mask(&flush, &t->pending);
824 	} else if (sig == SIGCONT) {
825 		unsigned int why;
826 		/*
827 		 * Remove all stop signals from all queues, wake all threads.
828 		 */
829 		siginitset(&flush, SIG_KERNEL_STOP_MASK);
830 		flush_sigqueue_mask(&flush, &signal->shared_pending);
831 		for_each_thread(p, t) {
832 			flush_sigqueue_mask(&flush, &t->pending);
833 			task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
834 			if (likely(!(t->ptrace & PT_SEIZED)))
835 				wake_up_state(t, __TASK_STOPPED);
836 			else
837 				ptrace_trap_notify(t);
838 		}
839 
840 		/*
841 		 * Notify the parent with CLD_CONTINUED if we were stopped.
842 		 *
843 		 * If we were in the middle of a group stop, we pretend it
844 		 * was already finished, and then continued. Since SIGCHLD
845 		 * doesn't queue we report only CLD_STOPPED, as if the next
846 		 * CLD_CONTINUED was dropped.
847 		 */
848 		why = 0;
849 		if (signal->flags & SIGNAL_STOP_STOPPED)
850 			why |= SIGNAL_CLD_CONTINUED;
851 		else if (signal->group_stop_count)
852 			why |= SIGNAL_CLD_STOPPED;
853 
854 		if (why) {
855 			/*
856 			 * The first thread which returns from do_signal_stop()
857 			 * will take ->siglock, notice SIGNAL_CLD_MASK, and
858 			 * notify its parent. See get_signal_to_deliver().
859 			 */
860 			signal_set_stop_flags(signal, why | SIGNAL_STOP_CONTINUED);
861 			signal->group_stop_count = 0;
862 			signal->group_exit_code = 0;
863 		}
864 	}
865 
866 	return !sig_ignored(p, sig, force);
867 }
868 
869 /*
870  * Test if P wants to take SIG.  After we've checked all threads with this,
871  * it's equivalent to finding no threads not blocking SIG.  Any threads not
872  * blocking SIG were ruled out because they are not running and already
873  * have pending signals.  Such threads will dequeue from the shared queue
874  * as soon as they're available, so putting the signal on the shared queue
875  * will be equivalent to sending it to one such thread.
876  */
877 static inline int wants_signal(int sig, struct task_struct *p)
878 {
879 	if (sigismember(&p->blocked, sig))
880 		return 0;
881 	if (p->flags & PF_EXITING)
882 		return 0;
883 	if (sig == SIGKILL)
884 		return 1;
885 	if (task_is_stopped_or_traced(p))
886 		return 0;
887 	return task_curr(p) || !signal_pending(p);
888 }
889 
890 static void complete_signal(int sig, struct task_struct *p, int group)
891 {
892 	struct signal_struct *signal = p->signal;
893 	struct task_struct *t;
894 
895 	/*
896 	 * Now find a thread we can wake up to take the signal off the queue.
897 	 *
898 	 * If the main thread wants the signal, it gets first crack.
899 	 * Probably the least surprising to the average bear.
900 	 */
901 	if (wants_signal(sig, p))
902 		t = p;
903 	else if (!group || thread_group_empty(p))
904 		/*
905 		 * There is just one thread and it does not need to be woken.
906 		 * It will dequeue unblocked signals before it runs again.
907 		 */
908 		return;
909 	else {
910 		/*
911 		 * Otherwise try to find a suitable thread.
912 		 */
913 		t = signal->curr_target;
914 		while (!wants_signal(sig, t)) {
915 			t = next_thread(t);
916 			if (t == signal->curr_target)
917 				/*
918 				 * No thread needs to be woken.
919 				 * Any eligible threads will see
920 				 * the signal in the queue soon.
921 				 */
922 				return;
923 		}
924 		signal->curr_target = t;
925 	}
926 
927 	/*
928 	 * Found a killable thread.  If the signal will be fatal,
929 	 * then start taking the whole group down immediately.
930 	 */
931 	if (sig_fatal(p, sig) &&
932 	    !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
933 	    !sigismember(&t->real_blocked, sig) &&
934 	    (sig == SIGKILL || !t->ptrace)) {
935 		/*
936 		 * This signal will be fatal to the whole group.
937 		 */
938 		if (!sig_kernel_coredump(sig)) {
939 			/*
940 			 * Start a group exit and wake everybody up.
941 			 * This way we don't have other threads
942 			 * running and doing things after a slower
943 			 * thread has the fatal signal pending.
944 			 */
945 			signal->flags = SIGNAL_GROUP_EXIT;
946 			signal->group_exit_code = sig;
947 			signal->group_stop_count = 0;
948 			t = p;
949 			do {
950 				task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
951 				sigaddset(&t->pending.signal, SIGKILL);
952 				signal_wake_up(t, 1);
953 			} while_each_thread(p, t);
954 			return;
955 		}
956 	}
957 
958 	/*
959 	 * The signal is already in the shared-pending queue.
960 	 * Tell the chosen thread to wake up and dequeue it.
961 	 */
962 	signal_wake_up(t, sig == SIGKILL);
963 	return;
964 }
965 
966 static inline int legacy_queue(struct sigpending *signals, int sig)
967 {
968 	return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
969 }
970 
971 #ifdef CONFIG_USER_NS
972 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
973 {
974 	if (current_user_ns() == task_cred_xxx(t, user_ns))
975 		return;
976 
977 	if (SI_FROMKERNEL(info))
978 		return;
979 
980 	rcu_read_lock();
981 	info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
982 					make_kuid(current_user_ns(), info->si_uid));
983 	rcu_read_unlock();
984 }
985 #else
986 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
987 {
988 	return;
989 }
990 #endif
991 
992 static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
993 			int group, int from_ancestor_ns)
994 {
995 	struct sigpending *pending;
996 	struct sigqueue *q;
997 	int override_rlimit;
998 	int ret = 0, result;
999 
1000 	assert_spin_locked(&t->sighand->siglock);
1001 
1002 	result = TRACE_SIGNAL_IGNORED;
1003 	if (!prepare_signal(sig, t,
1004 			from_ancestor_ns || (info == SEND_SIG_FORCED)))
1005 		goto ret;
1006 
1007 	pending = group ? &t->signal->shared_pending : &t->pending;
1008 	/*
1009 	 * Short-circuit ignored signals and support queuing
1010 	 * exactly one non-rt signal, so that we can get more
1011 	 * detailed information about the cause of the signal.
1012 	 */
1013 	result = TRACE_SIGNAL_ALREADY_PENDING;
1014 	if (legacy_queue(pending, sig))
1015 		goto ret;
1016 
1017 	result = TRACE_SIGNAL_DELIVERED;
1018 	/*
1019 	 * fast-pathed signals for kernel-internal things like SIGSTOP
1020 	 * or SIGKILL.
1021 	 */
1022 	if (info == SEND_SIG_FORCED)
1023 		goto out_set;
1024 
1025 	/*
1026 	 * Real-time signals must be queued if sent by sigqueue, or
1027 	 * some other real-time mechanism.  It is implementation
1028 	 * defined whether kill() does so.  We attempt to do so, on
1029 	 * the principle of least surprise, but since kill is not
1030 	 * allowed to fail with EAGAIN when low on memory we just
1031 	 * make sure at least one signal gets delivered and don't
1032 	 * pass on the info struct.
1033 	 */
1034 	if (sig < SIGRTMIN)
1035 		override_rlimit = (is_si_special(info) || info->si_code >= 0);
1036 	else
1037 		override_rlimit = 0;
1038 
1039 	q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
1040 		override_rlimit);
1041 	if (q) {
1042 		list_add_tail(&q->list, &pending->list);
1043 		switch ((unsigned long) info) {
1044 		case (unsigned long) SEND_SIG_NOINFO:
1045 			q->info.si_signo = sig;
1046 			q->info.si_errno = 0;
1047 			q->info.si_code = SI_USER;
1048 			q->info.si_pid = task_tgid_nr_ns(current,
1049 							task_active_pid_ns(t));
1050 			q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
1051 			break;
1052 		case (unsigned long) SEND_SIG_PRIV:
1053 			q->info.si_signo = sig;
1054 			q->info.si_errno = 0;
1055 			q->info.si_code = SI_KERNEL;
1056 			q->info.si_pid = 0;
1057 			q->info.si_uid = 0;
1058 			break;
1059 		default:
1060 			copy_siginfo(&q->info, info);
1061 			if (from_ancestor_ns)
1062 				q->info.si_pid = 0;
1063 			break;
1064 		}
1065 
1066 		userns_fixup_signal_uid(&q->info, t);
1067 
1068 	} else if (!is_si_special(info)) {
1069 		if (sig >= SIGRTMIN && info->si_code != SI_USER) {
1070 			/*
1071 			 * Queue overflow, abort.  We may abort if the
1072 			 * signal was rt and sent by user using something
1073 			 * other than kill().
1074 			 */
1075 			result = TRACE_SIGNAL_OVERFLOW_FAIL;
1076 			ret = -EAGAIN;
1077 			goto ret;
1078 		} else {
1079 			/*
1080 			 * This is a silent loss of information.  We still
1081 			 * send the signal, but the *info bits are lost.
1082 			 */
1083 			result = TRACE_SIGNAL_LOSE_INFO;
1084 		}
1085 	}
1086 
1087 out_set:
1088 	signalfd_notify(t, sig);
1089 	sigaddset(&pending->signal, sig);
1090 	complete_signal(sig, t, group);
1091 ret:
1092 	trace_signal_generate(sig, info, t, group, result);
1093 	return ret;
1094 }
1095 
1096 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
1097 			int group)
1098 {
1099 	int from_ancestor_ns = 0;
1100 
1101 #ifdef CONFIG_PID_NS
1102 	from_ancestor_ns = si_fromuser(info) &&
1103 			   !task_pid_nr_ns(current, task_active_pid_ns(t));
1104 #endif
1105 
1106 	return __send_signal(sig, info, t, group, from_ancestor_ns);
1107 }
1108 
1109 static void print_fatal_signal(int signr)
1110 {
1111 	struct pt_regs *regs = signal_pt_regs();
1112 	pr_info("potentially unexpected fatal signal %d.\n", signr);
1113 
1114 #if defined(__i386__) && !defined(__arch_um__)
1115 	pr_info("code at %08lx: ", regs->ip);
1116 	{
1117 		int i;
1118 		for (i = 0; i < 16; i++) {
1119 			unsigned char insn;
1120 
1121 			if (get_user(insn, (unsigned char *)(regs->ip + i)))
1122 				break;
1123 			pr_cont("%02x ", insn);
1124 		}
1125 	}
1126 	pr_cont("\n");
1127 #endif
1128 	preempt_disable();
1129 	show_regs(regs);
1130 	preempt_enable();
1131 }
1132 
1133 static int __init setup_print_fatal_signals(char *str)
1134 {
1135 	get_option (&str, &print_fatal_signals);
1136 
1137 	return 1;
1138 }
1139 
1140 __setup("print-fatal-signals=", setup_print_fatal_signals);
1141 
1142 int
1143 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1144 {
1145 	return send_signal(sig, info, p, 1);
1146 }
1147 
1148 static int
1149 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1150 {
1151 	return send_signal(sig, info, t, 0);
1152 }
1153 
1154 int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
1155 			bool group)
1156 {
1157 	unsigned long flags;
1158 	int ret = -ESRCH;
1159 
1160 	if (lock_task_sighand(p, &flags)) {
1161 		ret = send_signal(sig, info, p, group);
1162 		unlock_task_sighand(p, &flags);
1163 	}
1164 
1165 	return ret;
1166 }
1167 
1168 /*
1169  * Force a signal that the process can't ignore: if necessary
1170  * we unblock the signal and change any SIG_IGN to SIG_DFL.
1171  *
1172  * Note: If we unblock the signal, we always reset it to SIG_DFL,
1173  * since we do not want to have a signal handler that was blocked
1174  * be invoked when user space had explicitly blocked it.
1175  *
1176  * We don't want to have recursive SIGSEGV's etc, for example,
1177  * that is why we also clear SIGNAL_UNKILLABLE.
1178  */
1179 int
1180 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1181 {
1182 	unsigned long int flags;
1183 	int ret, blocked, ignored;
1184 	struct k_sigaction *action;
1185 
1186 	spin_lock_irqsave(&t->sighand->siglock, flags);
1187 	action = &t->sighand->action[sig-1];
1188 	ignored = action->sa.sa_handler == SIG_IGN;
1189 	blocked = sigismember(&t->blocked, sig);
1190 	if (blocked || ignored) {
1191 		action->sa.sa_handler = SIG_DFL;
1192 		if (blocked) {
1193 			sigdelset(&t->blocked, sig);
1194 			recalc_sigpending_and_wake(t);
1195 		}
1196 	}
1197 	if (action->sa.sa_handler == SIG_DFL)
1198 		t->signal->flags &= ~SIGNAL_UNKILLABLE;
1199 	ret = specific_send_sig_info(sig, info, t);
1200 	spin_unlock_irqrestore(&t->sighand->siglock, flags);
1201 
1202 	return ret;
1203 }
1204 
1205 /*
1206  * Nuke all other threads in the group.
1207  */
1208 int zap_other_threads(struct task_struct *p)
1209 {
1210 	struct task_struct *t = p;
1211 	int count = 0;
1212 
1213 	p->signal->group_stop_count = 0;
1214 
1215 	while_each_thread(p, t) {
1216 		task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1217 		count++;
1218 
1219 		/* Don't bother with already dead threads */
1220 		if (t->exit_state)
1221 			continue;
1222 		sigaddset(&t->pending.signal, SIGKILL);
1223 		signal_wake_up(t, 1);
1224 	}
1225 
1226 	return count;
1227 }
1228 
1229 struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
1230 					   unsigned long *flags)
1231 {
1232 	struct sighand_struct *sighand;
1233 
1234 	for (;;) {
1235 		/*
1236 		 * Disable interrupts early to avoid deadlocks.
1237 		 * See rcu_read_unlock() comment header for details.
1238 		 */
1239 		local_irq_save(*flags);
1240 		rcu_read_lock();
1241 		sighand = rcu_dereference(tsk->sighand);
1242 		if (unlikely(sighand == NULL)) {
1243 			rcu_read_unlock();
1244 			local_irq_restore(*flags);
1245 			break;
1246 		}
1247 		/*
1248 		 * This sighand can be already freed and even reused, but
1249 		 * we rely on SLAB_TYPESAFE_BY_RCU and sighand_ctor() which
1250 		 * initializes ->siglock: this slab can't go away, it has
1251 		 * the same object type, ->siglock can't be reinitialized.
1252 		 *
1253 		 * We need to ensure that tsk->sighand is still the same
1254 		 * after we take the lock, we can race with de_thread() or
1255 		 * __exit_signal(). In the latter case the next iteration
1256 		 * must see ->sighand == NULL.
1257 		 */
1258 		spin_lock(&sighand->siglock);
1259 		if (likely(sighand == tsk->sighand)) {
1260 			rcu_read_unlock();
1261 			break;
1262 		}
1263 		spin_unlock(&sighand->siglock);
1264 		rcu_read_unlock();
1265 		local_irq_restore(*flags);
1266 	}
1267 
1268 	return sighand;
1269 }
1270 
1271 /*
1272  * send signal info to all the members of a group
1273  */
1274 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1275 {
1276 	int ret;
1277 
1278 	rcu_read_lock();
1279 	ret = check_kill_permission(sig, info, p);
1280 	rcu_read_unlock();
1281 
1282 	if (!ret && sig)
1283 		ret = do_send_sig_info(sig, info, p, true);
1284 
1285 	return ret;
1286 }
1287 
1288 /*
1289  * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1290  * control characters do (^C, ^Z etc)
1291  * - the caller must hold at least a readlock on tasklist_lock
1292  */
1293 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1294 {
1295 	struct task_struct *p = NULL;
1296 	int retval, success;
1297 
1298 	success = 0;
1299 	retval = -ESRCH;
1300 	do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1301 		int err = group_send_sig_info(sig, info, p);
1302 		success |= !err;
1303 		retval = err;
1304 	} while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1305 	return success ? 0 : retval;
1306 }
1307 
1308 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1309 {
1310 	int error = -ESRCH;
1311 	struct task_struct *p;
1312 
1313 	for (;;) {
1314 		rcu_read_lock();
1315 		p = pid_task(pid, PIDTYPE_PID);
1316 		if (p)
1317 			error = group_send_sig_info(sig, info, p);
1318 		rcu_read_unlock();
1319 		if (likely(!p || error != -ESRCH))
1320 			return error;
1321 
1322 		/*
1323 		 * The task was unhashed in between, try again.  If it
1324 		 * is dead, pid_task() will return NULL, if we race with
1325 		 * de_thread() it will find the new leader.
1326 		 */
1327 	}
1328 }
1329 
1330 static int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1331 {
1332 	int error;
1333 	rcu_read_lock();
1334 	error = kill_pid_info(sig, info, find_vpid(pid));
1335 	rcu_read_unlock();
1336 	return error;
1337 }
1338 
1339 static int kill_as_cred_perm(const struct cred *cred,
1340 			     struct task_struct *target)
1341 {
1342 	const struct cred *pcred = __task_cred(target);
1343 	if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) &&
1344 	    !uid_eq(cred->uid,  pcred->suid) && !uid_eq(cred->uid,  pcred->uid))
1345 		return 0;
1346 	return 1;
1347 }
1348 
1349 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1350 int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid,
1351 			 const struct cred *cred, u32 secid)
1352 {
1353 	int ret = -EINVAL;
1354 	struct task_struct *p;
1355 	unsigned long flags;
1356 
1357 	if (!valid_signal(sig))
1358 		return ret;
1359 
1360 	rcu_read_lock();
1361 	p = pid_task(pid, PIDTYPE_PID);
1362 	if (!p) {
1363 		ret = -ESRCH;
1364 		goto out_unlock;
1365 	}
1366 	if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
1367 		ret = -EPERM;
1368 		goto out_unlock;
1369 	}
1370 	ret = security_task_kill(p, info, sig, secid);
1371 	if (ret)
1372 		goto out_unlock;
1373 
1374 	if (sig) {
1375 		if (lock_task_sighand(p, &flags)) {
1376 			ret = __send_signal(sig, info, p, 1, 0);
1377 			unlock_task_sighand(p, &flags);
1378 		} else
1379 			ret = -ESRCH;
1380 	}
1381 out_unlock:
1382 	rcu_read_unlock();
1383 	return ret;
1384 }
1385 EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
1386 
1387 /*
1388  * kill_something_info() interprets pid in interesting ways just like kill(2).
1389  *
1390  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1391  * is probably wrong.  Should make it like BSD or SYSV.
1392  */
1393 
1394 static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
1395 {
1396 	int ret;
1397 
1398 	if (pid > 0) {
1399 		rcu_read_lock();
1400 		ret = kill_pid_info(sig, info, find_vpid(pid));
1401 		rcu_read_unlock();
1402 		return ret;
1403 	}
1404 
1405 	/* -INT_MIN is undefined.  Exclude this case to avoid a UBSAN warning */
1406 	if (pid == INT_MIN)
1407 		return -ESRCH;
1408 
1409 	read_lock(&tasklist_lock);
1410 	if (pid != -1) {
1411 		ret = __kill_pgrp_info(sig, info,
1412 				pid ? find_vpid(-pid) : task_pgrp(current));
1413 	} else {
1414 		int retval = 0, count = 0;
1415 		struct task_struct * p;
1416 
1417 		for_each_process(p) {
1418 			if (task_pid_vnr(p) > 1 &&
1419 					!same_thread_group(p, current)) {
1420 				int err = group_send_sig_info(sig, info, p);
1421 				++count;
1422 				if (err != -EPERM)
1423 					retval = err;
1424 			}
1425 		}
1426 		ret = count ? retval : -ESRCH;
1427 	}
1428 	read_unlock(&tasklist_lock);
1429 
1430 	return ret;
1431 }
1432 
1433 /*
1434  * These are for backward compatibility with the rest of the kernel source.
1435  */
1436 
1437 int send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1438 {
1439 	/*
1440 	 * Make sure legacy kernel users don't send in bad values
1441 	 * (normal paths check this in check_kill_permission).
1442 	 */
1443 	if (!valid_signal(sig))
1444 		return -EINVAL;
1445 
1446 	return do_send_sig_info(sig, info, p, false);
1447 }
1448 
1449 #define __si_special(priv) \
1450 	((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1451 
1452 int
1453 send_sig(int sig, struct task_struct *p, int priv)
1454 {
1455 	return send_sig_info(sig, __si_special(priv), p);
1456 }
1457 
1458 void
1459 force_sig(int sig, struct task_struct *p)
1460 {
1461 	force_sig_info(sig, SEND_SIG_PRIV, p);
1462 }
1463 
1464 /*
1465  * When things go south during signal handling, we
1466  * will force a SIGSEGV. And if the signal that caused
1467  * the problem was already a SIGSEGV, we'll want to
1468  * make sure we don't even try to deliver the signal..
1469  */
1470 int
1471 force_sigsegv(int sig, struct task_struct *p)
1472 {
1473 	if (sig == SIGSEGV) {
1474 		unsigned long flags;
1475 		spin_lock_irqsave(&p->sighand->siglock, flags);
1476 		p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1477 		spin_unlock_irqrestore(&p->sighand->siglock, flags);
1478 	}
1479 	force_sig(SIGSEGV, p);
1480 	return 0;
1481 }
1482 
1483 int kill_pgrp(struct pid *pid, int sig, int priv)
1484 {
1485 	int ret;
1486 
1487 	read_lock(&tasklist_lock);
1488 	ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1489 	read_unlock(&tasklist_lock);
1490 
1491 	return ret;
1492 }
1493 EXPORT_SYMBOL(kill_pgrp);
1494 
1495 int kill_pid(struct pid *pid, int sig, int priv)
1496 {
1497 	return kill_pid_info(sig, __si_special(priv), pid);
1498 }
1499 EXPORT_SYMBOL(kill_pid);
1500 
1501 /*
1502  * These functions support sending signals using preallocated sigqueue
1503  * structures.  This is needed "because realtime applications cannot
1504  * afford to lose notifications of asynchronous events, like timer
1505  * expirations or I/O completions".  In the case of POSIX Timers
1506  * we allocate the sigqueue structure from the timer_create.  If this
1507  * allocation fails we are able to report the failure to the application
1508  * with an EAGAIN error.
1509  */
1510 struct sigqueue *sigqueue_alloc(void)
1511 {
1512 	struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
1513 
1514 	if (q)
1515 		q->flags |= SIGQUEUE_PREALLOC;
1516 
1517 	return q;
1518 }
1519 
1520 void sigqueue_free(struct sigqueue *q)
1521 {
1522 	unsigned long flags;
1523 	spinlock_t *lock = &current->sighand->siglock;
1524 
1525 	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1526 	/*
1527 	 * We must hold ->siglock while testing q->list
1528 	 * to serialize with collect_signal() or with
1529 	 * __exit_signal()->flush_sigqueue().
1530 	 */
1531 	spin_lock_irqsave(lock, flags);
1532 	q->flags &= ~SIGQUEUE_PREALLOC;
1533 	/*
1534 	 * If it is queued it will be freed when dequeued,
1535 	 * like the "regular" sigqueue.
1536 	 */
1537 	if (!list_empty(&q->list))
1538 		q = NULL;
1539 	spin_unlock_irqrestore(lock, flags);
1540 
1541 	if (q)
1542 		__sigqueue_free(q);
1543 }
1544 
1545 int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1546 {
1547 	int sig = q->info.si_signo;
1548 	struct sigpending *pending;
1549 	unsigned long flags;
1550 	int ret, result;
1551 
1552 	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1553 
1554 	ret = -1;
1555 	if (!likely(lock_task_sighand(t, &flags)))
1556 		goto ret;
1557 
1558 	ret = 1; /* the signal is ignored */
1559 	result = TRACE_SIGNAL_IGNORED;
1560 	if (!prepare_signal(sig, t, false))
1561 		goto out;
1562 
1563 	ret = 0;
1564 	if (unlikely(!list_empty(&q->list))) {
1565 		/*
1566 		 * If an SI_TIMER entry is already queue just increment
1567 		 * the overrun count.
1568 		 */
1569 		BUG_ON(q->info.si_code != SI_TIMER);
1570 		q->info.si_overrun++;
1571 		result = TRACE_SIGNAL_ALREADY_PENDING;
1572 		goto out;
1573 	}
1574 	q->info.si_overrun = 0;
1575 
1576 	signalfd_notify(t, sig);
1577 	pending = group ? &t->signal->shared_pending : &t->pending;
1578 	list_add_tail(&q->list, &pending->list);
1579 	sigaddset(&pending->signal, sig);
1580 	complete_signal(sig, t, group);
1581 	result = TRACE_SIGNAL_DELIVERED;
1582 out:
1583 	trace_signal_generate(sig, &q->info, t, group, result);
1584 	unlock_task_sighand(t, &flags);
1585 ret:
1586 	return ret;
1587 }
1588 
1589 /*
1590  * Let a parent know about the death of a child.
1591  * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1592  *
1593  * Returns true if our parent ignored us and so we've switched to
1594  * self-reaping.
1595  */
1596 bool do_notify_parent(struct task_struct *tsk, int sig)
1597 {
1598 	struct siginfo info;
1599 	unsigned long flags;
1600 	struct sighand_struct *psig;
1601 	bool autoreap = false;
1602 	u64 utime, stime;
1603 
1604 	BUG_ON(sig == -1);
1605 
1606  	/* do_notify_parent_cldstop should have been called instead.  */
1607  	BUG_ON(task_is_stopped_or_traced(tsk));
1608 
1609 	BUG_ON(!tsk->ptrace &&
1610 	       (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1611 
1612 	if (sig != SIGCHLD) {
1613 		/*
1614 		 * This is only possible if parent == real_parent.
1615 		 * Check if it has changed security domain.
1616 		 */
1617 		if (tsk->parent_exec_id != tsk->parent->self_exec_id)
1618 			sig = SIGCHLD;
1619 	}
1620 
1621 	info.si_signo = sig;
1622 	info.si_errno = 0;
1623 	/*
1624 	 * We are under tasklist_lock here so our parent is tied to
1625 	 * us and cannot change.
1626 	 *
1627 	 * task_active_pid_ns will always return the same pid namespace
1628 	 * until a task passes through release_task.
1629 	 *
1630 	 * write_lock() currently calls preempt_disable() which is the
1631 	 * same as rcu_read_lock(), but according to Oleg, this is not
1632 	 * correct to rely on this
1633 	 */
1634 	rcu_read_lock();
1635 	info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1636 	info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
1637 				       task_uid(tsk));
1638 	rcu_read_unlock();
1639 
1640 	task_cputime(tsk, &utime, &stime);
1641 	info.si_utime = nsec_to_clock_t(utime + tsk->signal->utime);
1642 	info.si_stime = nsec_to_clock_t(stime + tsk->signal->stime);
1643 
1644 	info.si_status = tsk->exit_code & 0x7f;
1645 	if (tsk->exit_code & 0x80)
1646 		info.si_code = CLD_DUMPED;
1647 	else if (tsk->exit_code & 0x7f)
1648 		info.si_code = CLD_KILLED;
1649 	else {
1650 		info.si_code = CLD_EXITED;
1651 		info.si_status = tsk->exit_code >> 8;
1652 	}
1653 
1654 	psig = tsk->parent->sighand;
1655 	spin_lock_irqsave(&psig->siglock, flags);
1656 	if (!tsk->ptrace && sig == SIGCHLD &&
1657 	    (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1658 	     (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1659 		/*
1660 		 * We are exiting and our parent doesn't care.  POSIX.1
1661 		 * defines special semantics for setting SIGCHLD to SIG_IGN
1662 		 * or setting the SA_NOCLDWAIT flag: we should be reaped
1663 		 * automatically and not left for our parent's wait4 call.
1664 		 * Rather than having the parent do it as a magic kind of
1665 		 * signal handler, we just set this to tell do_exit that we
1666 		 * can be cleaned up without becoming a zombie.  Note that
1667 		 * we still call __wake_up_parent in this case, because a
1668 		 * blocked sys_wait4 might now return -ECHILD.
1669 		 *
1670 		 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1671 		 * is implementation-defined: we do (if you don't want
1672 		 * it, just use SIG_IGN instead).
1673 		 */
1674 		autoreap = true;
1675 		if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1676 			sig = 0;
1677 	}
1678 	if (valid_signal(sig) && sig)
1679 		__group_send_sig_info(sig, &info, tsk->parent);
1680 	__wake_up_parent(tsk, tsk->parent);
1681 	spin_unlock_irqrestore(&psig->siglock, flags);
1682 
1683 	return autoreap;
1684 }
1685 
1686 /**
1687  * do_notify_parent_cldstop - notify parent of stopped/continued state change
1688  * @tsk: task reporting the state change
1689  * @for_ptracer: the notification is for ptracer
1690  * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
1691  *
1692  * Notify @tsk's parent that the stopped/continued state has changed.  If
1693  * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
1694  * If %true, @tsk reports to @tsk->parent which should be the ptracer.
1695  *
1696  * CONTEXT:
1697  * Must be called with tasklist_lock at least read locked.
1698  */
1699 static void do_notify_parent_cldstop(struct task_struct *tsk,
1700 				     bool for_ptracer, int why)
1701 {
1702 	struct siginfo info;
1703 	unsigned long flags;
1704 	struct task_struct *parent;
1705 	struct sighand_struct *sighand;
1706 	u64 utime, stime;
1707 
1708 	if (for_ptracer) {
1709 		parent = tsk->parent;
1710 	} else {
1711 		tsk = tsk->group_leader;
1712 		parent = tsk->real_parent;
1713 	}
1714 
1715 	info.si_signo = SIGCHLD;
1716 	info.si_errno = 0;
1717 	/*
1718 	 * see comment in do_notify_parent() about the following 4 lines
1719 	 */
1720 	rcu_read_lock();
1721 	info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
1722 	info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
1723 	rcu_read_unlock();
1724 
1725 	task_cputime(tsk, &utime, &stime);
1726 	info.si_utime = nsec_to_clock_t(utime);
1727 	info.si_stime = nsec_to_clock_t(stime);
1728 
1729  	info.si_code = why;
1730  	switch (why) {
1731  	case CLD_CONTINUED:
1732  		info.si_status = SIGCONT;
1733  		break;
1734  	case CLD_STOPPED:
1735  		info.si_status = tsk->signal->group_exit_code & 0x7f;
1736  		break;
1737  	case CLD_TRAPPED:
1738  		info.si_status = tsk->exit_code & 0x7f;
1739  		break;
1740  	default:
1741  		BUG();
1742  	}
1743 
1744 	sighand = parent->sighand;
1745 	spin_lock_irqsave(&sighand->siglock, flags);
1746 	if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1747 	    !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1748 		__group_send_sig_info(SIGCHLD, &info, parent);
1749 	/*
1750 	 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1751 	 */
1752 	__wake_up_parent(tsk, parent);
1753 	spin_unlock_irqrestore(&sighand->siglock, flags);
1754 }
1755 
1756 static inline int may_ptrace_stop(void)
1757 {
1758 	if (!likely(current->ptrace))
1759 		return 0;
1760 	/*
1761 	 * Are we in the middle of do_coredump?
1762 	 * If so and our tracer is also part of the coredump stopping
1763 	 * is a deadlock situation, and pointless because our tracer
1764 	 * is dead so don't allow us to stop.
1765 	 * If SIGKILL was already sent before the caller unlocked
1766 	 * ->siglock we must see ->core_state != NULL. Otherwise it
1767 	 * is safe to enter schedule().
1768 	 *
1769 	 * This is almost outdated, a task with the pending SIGKILL can't
1770 	 * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported
1771 	 * after SIGKILL was already dequeued.
1772 	 */
1773 	if (unlikely(current->mm->core_state) &&
1774 	    unlikely(current->mm == current->parent->mm))
1775 		return 0;
1776 
1777 	return 1;
1778 }
1779 
1780 /*
1781  * Return non-zero if there is a SIGKILL that should be waking us up.
1782  * Called with the siglock held.
1783  */
1784 static int sigkill_pending(struct task_struct *tsk)
1785 {
1786 	return	sigismember(&tsk->pending.signal, SIGKILL) ||
1787 		sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
1788 }
1789 
1790 /*
1791  * This must be called with current->sighand->siglock held.
1792  *
1793  * This should be the path for all ptrace stops.
1794  * We always set current->last_siginfo while stopped here.
1795  * That makes it a way to test a stopped process for
1796  * being ptrace-stopped vs being job-control-stopped.
1797  *
1798  * If we actually decide not to stop at all because the tracer
1799  * is gone, we keep current->exit_code unless clear_code.
1800  */
1801 static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
1802 	__releases(&current->sighand->siglock)
1803 	__acquires(&current->sighand->siglock)
1804 {
1805 	bool gstop_done = false;
1806 
1807 	if (arch_ptrace_stop_needed(exit_code, info)) {
1808 		/*
1809 		 * The arch code has something special to do before a
1810 		 * ptrace stop.  This is allowed to block, e.g. for faults
1811 		 * on user stack pages.  We can't keep the siglock while
1812 		 * calling arch_ptrace_stop, so we must release it now.
1813 		 * To preserve proper semantics, we must do this before
1814 		 * any signal bookkeeping like checking group_stop_count.
1815 		 * Meanwhile, a SIGKILL could come in before we retake the
1816 		 * siglock.  That must prevent us from sleeping in TASK_TRACED.
1817 		 * So after regaining the lock, we must check for SIGKILL.
1818 		 */
1819 		spin_unlock_irq(&current->sighand->siglock);
1820 		arch_ptrace_stop(exit_code, info);
1821 		spin_lock_irq(&current->sighand->siglock);
1822 		if (sigkill_pending(current))
1823 			return;
1824 	}
1825 
1826 	/*
1827 	 * We're committing to trapping.  TRACED should be visible before
1828 	 * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
1829 	 * Also, transition to TRACED and updates to ->jobctl should be
1830 	 * atomic with respect to siglock and should be done after the arch
1831 	 * hook as siglock is released and regrabbed across it.
1832 	 */
1833 	set_current_state(TASK_TRACED);
1834 
1835 	current->last_siginfo = info;
1836 	current->exit_code = exit_code;
1837 
1838 	/*
1839 	 * If @why is CLD_STOPPED, we're trapping to participate in a group
1840 	 * stop.  Do the bookkeeping.  Note that if SIGCONT was delievered
1841 	 * across siglock relocks since INTERRUPT was scheduled, PENDING
1842 	 * could be clear now.  We act as if SIGCONT is received after
1843 	 * TASK_TRACED is entered - ignore it.
1844 	 */
1845 	if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
1846 		gstop_done = task_participate_group_stop(current);
1847 
1848 	/* any trap clears pending STOP trap, STOP trap clears NOTIFY */
1849 	task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
1850 	if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
1851 		task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
1852 
1853 	/* entering a trap, clear TRAPPING */
1854 	task_clear_jobctl_trapping(current);
1855 
1856 	spin_unlock_irq(&current->sighand->siglock);
1857 	read_lock(&tasklist_lock);
1858 	if (may_ptrace_stop()) {
1859 		/*
1860 		 * Notify parents of the stop.
1861 		 *
1862 		 * While ptraced, there are two parents - the ptracer and
1863 		 * the real_parent of the group_leader.  The ptracer should
1864 		 * know about every stop while the real parent is only
1865 		 * interested in the completion of group stop.  The states
1866 		 * for the two don't interact with each other.  Notify
1867 		 * separately unless they're gonna be duplicates.
1868 		 */
1869 		do_notify_parent_cldstop(current, true, why);
1870 		if (gstop_done && ptrace_reparented(current))
1871 			do_notify_parent_cldstop(current, false, why);
1872 
1873 		/*
1874 		 * Don't want to allow preemption here, because
1875 		 * sys_ptrace() needs this task to be inactive.
1876 		 *
1877 		 * XXX: implement read_unlock_no_resched().
1878 		 */
1879 		preempt_disable();
1880 		read_unlock(&tasklist_lock);
1881 		preempt_enable_no_resched();
1882 		freezable_schedule();
1883 	} else {
1884 		/*
1885 		 * By the time we got the lock, our tracer went away.
1886 		 * Don't drop the lock yet, another tracer may come.
1887 		 *
1888 		 * If @gstop_done, the ptracer went away between group stop
1889 		 * completion and here.  During detach, it would have set
1890 		 * JOBCTL_STOP_PENDING on us and we'll re-enter
1891 		 * TASK_STOPPED in do_signal_stop() on return, so notifying
1892 		 * the real parent of the group stop completion is enough.
1893 		 */
1894 		if (gstop_done)
1895 			do_notify_parent_cldstop(current, false, why);
1896 
1897 		/* tasklist protects us from ptrace_freeze_traced() */
1898 		__set_current_state(TASK_RUNNING);
1899 		if (clear_code)
1900 			current->exit_code = 0;
1901 		read_unlock(&tasklist_lock);
1902 	}
1903 
1904 	/*
1905 	 * We are back.  Now reacquire the siglock before touching
1906 	 * last_siginfo, so that we are sure to have synchronized with
1907 	 * any signal-sending on another CPU that wants to examine it.
1908 	 */
1909 	spin_lock_irq(&current->sighand->siglock);
1910 	current->last_siginfo = NULL;
1911 
1912 	/* LISTENING can be set only during STOP traps, clear it */
1913 	current->jobctl &= ~JOBCTL_LISTENING;
1914 
1915 	/*
1916 	 * Queued signals ignored us while we were stopped for tracing.
1917 	 * So check for any that we should take before resuming user mode.
1918 	 * This sets TIF_SIGPENDING, but never clears it.
1919 	 */
1920 	recalc_sigpending_tsk(current);
1921 }
1922 
1923 static void ptrace_do_notify(int signr, int exit_code, int why)
1924 {
1925 	siginfo_t info;
1926 
1927 	memset(&info, 0, sizeof info);
1928 	info.si_signo = signr;
1929 	info.si_code = exit_code;
1930 	info.si_pid = task_pid_vnr(current);
1931 	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
1932 
1933 	/* Let the debugger run.  */
1934 	ptrace_stop(exit_code, why, 1, &info);
1935 }
1936 
1937 void ptrace_notify(int exit_code)
1938 {
1939 	BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1940 	if (unlikely(current->task_works))
1941 		task_work_run();
1942 
1943 	spin_lock_irq(&current->sighand->siglock);
1944 	ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
1945 	spin_unlock_irq(&current->sighand->siglock);
1946 }
1947 
1948 /**
1949  * do_signal_stop - handle group stop for SIGSTOP and other stop signals
1950  * @signr: signr causing group stop if initiating
1951  *
1952  * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
1953  * and participate in it.  If already set, participate in the existing
1954  * group stop.  If participated in a group stop (and thus slept), %true is
1955  * returned with siglock released.
1956  *
1957  * If ptraced, this function doesn't handle stop itself.  Instead,
1958  * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
1959  * untouched.  The caller must ensure that INTERRUPT trap handling takes
1960  * places afterwards.
1961  *
1962  * CONTEXT:
1963  * Must be called with @current->sighand->siglock held, which is released
1964  * on %true return.
1965  *
1966  * RETURNS:
1967  * %false if group stop is already cancelled or ptrace trap is scheduled.
1968  * %true if participated in group stop.
1969  */
1970 static bool do_signal_stop(int signr)
1971 	__releases(&current->sighand->siglock)
1972 {
1973 	struct signal_struct *sig = current->signal;
1974 
1975 	if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
1976 		unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
1977 		struct task_struct *t;
1978 
1979 		/* signr will be recorded in task->jobctl for retries */
1980 		WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
1981 
1982 		if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
1983 		    unlikely(signal_group_exit(sig)))
1984 			return false;
1985 		/*
1986 		 * There is no group stop already in progress.  We must
1987 		 * initiate one now.
1988 		 *
1989 		 * While ptraced, a task may be resumed while group stop is
1990 		 * still in effect and then receive a stop signal and
1991 		 * initiate another group stop.  This deviates from the
1992 		 * usual behavior as two consecutive stop signals can't
1993 		 * cause two group stops when !ptraced.  That is why we
1994 		 * also check !task_is_stopped(t) below.
1995 		 *
1996 		 * The condition can be distinguished by testing whether
1997 		 * SIGNAL_STOP_STOPPED is already set.  Don't generate
1998 		 * group_exit_code in such case.
1999 		 *
2000 		 * This is not necessary for SIGNAL_STOP_CONTINUED because
2001 		 * an intervening stop signal is required to cause two
2002 		 * continued events regardless of ptrace.
2003 		 */
2004 		if (!(sig->flags & SIGNAL_STOP_STOPPED))
2005 			sig->group_exit_code = signr;
2006 
2007 		sig->group_stop_count = 0;
2008 
2009 		if (task_set_jobctl_pending(current, signr | gstop))
2010 			sig->group_stop_count++;
2011 
2012 		t = current;
2013 		while_each_thread(current, t) {
2014 			/*
2015 			 * Setting state to TASK_STOPPED for a group
2016 			 * stop is always done with the siglock held,
2017 			 * so this check has no races.
2018 			 */
2019 			if (!task_is_stopped(t) &&
2020 			    task_set_jobctl_pending(t, signr | gstop)) {
2021 				sig->group_stop_count++;
2022 				if (likely(!(t->ptrace & PT_SEIZED)))
2023 					signal_wake_up(t, 0);
2024 				else
2025 					ptrace_trap_notify(t);
2026 			}
2027 		}
2028 	}
2029 
2030 	if (likely(!current->ptrace)) {
2031 		int notify = 0;
2032 
2033 		/*
2034 		 * If there are no other threads in the group, or if there
2035 		 * is a group stop in progress and we are the last to stop,
2036 		 * report to the parent.
2037 		 */
2038 		if (task_participate_group_stop(current))
2039 			notify = CLD_STOPPED;
2040 
2041 		__set_current_state(TASK_STOPPED);
2042 		spin_unlock_irq(&current->sighand->siglock);
2043 
2044 		/*
2045 		 * Notify the parent of the group stop completion.  Because
2046 		 * we're not holding either the siglock or tasklist_lock
2047 		 * here, ptracer may attach inbetween; however, this is for
2048 		 * group stop and should always be delivered to the real
2049 		 * parent of the group leader.  The new ptracer will get
2050 		 * its notification when this task transitions into
2051 		 * TASK_TRACED.
2052 		 */
2053 		if (notify) {
2054 			read_lock(&tasklist_lock);
2055 			do_notify_parent_cldstop(current, false, notify);
2056 			read_unlock(&tasklist_lock);
2057 		}
2058 
2059 		/* Now we don't run again until woken by SIGCONT or SIGKILL */
2060 		freezable_schedule();
2061 		return true;
2062 	} else {
2063 		/*
2064 		 * While ptraced, group stop is handled by STOP trap.
2065 		 * Schedule it and let the caller deal with it.
2066 		 */
2067 		task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
2068 		return false;
2069 	}
2070 }
2071 
2072 /**
2073  * do_jobctl_trap - take care of ptrace jobctl traps
2074  *
2075  * When PT_SEIZED, it's used for both group stop and explicit
2076  * SEIZE/INTERRUPT traps.  Both generate PTRACE_EVENT_STOP trap with
2077  * accompanying siginfo.  If stopped, lower eight bits of exit_code contain
2078  * the stop signal; otherwise, %SIGTRAP.
2079  *
2080  * When !PT_SEIZED, it's used only for group stop trap with stop signal
2081  * number as exit_code and no siginfo.
2082  *
2083  * CONTEXT:
2084  * Must be called with @current->sighand->siglock held, which may be
2085  * released and re-acquired before returning with intervening sleep.
2086  */
2087 static void do_jobctl_trap(void)
2088 {
2089 	struct signal_struct *signal = current->signal;
2090 	int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2091 
2092 	if (current->ptrace & PT_SEIZED) {
2093 		if (!signal->group_stop_count &&
2094 		    !(signal->flags & SIGNAL_STOP_STOPPED))
2095 			signr = SIGTRAP;
2096 		WARN_ON_ONCE(!signr);
2097 		ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
2098 				 CLD_STOPPED);
2099 	} else {
2100 		WARN_ON_ONCE(!signr);
2101 		ptrace_stop(signr, CLD_STOPPED, 0, NULL);
2102 		current->exit_code = 0;
2103 	}
2104 }
2105 
2106 static int ptrace_signal(int signr, siginfo_t *info)
2107 {
2108 	/*
2109 	 * We do not check sig_kernel_stop(signr) but set this marker
2110 	 * unconditionally because we do not know whether debugger will
2111 	 * change signr. This flag has no meaning unless we are going
2112 	 * to stop after return from ptrace_stop(). In this case it will
2113 	 * be checked in do_signal_stop(), we should only stop if it was
2114 	 * not cleared by SIGCONT while we were sleeping. See also the
2115 	 * comment in dequeue_signal().
2116 	 */
2117 	current->jobctl |= JOBCTL_STOP_DEQUEUED;
2118 	ptrace_stop(signr, CLD_TRAPPED, 0, info);
2119 
2120 	/* We're back.  Did the debugger cancel the sig?  */
2121 	signr = current->exit_code;
2122 	if (signr == 0)
2123 		return signr;
2124 
2125 	current->exit_code = 0;
2126 
2127 	/*
2128 	 * Update the siginfo structure if the signal has
2129 	 * changed.  If the debugger wanted something
2130 	 * specific in the siginfo structure then it should
2131 	 * have updated *info via PTRACE_SETSIGINFO.
2132 	 */
2133 	if (signr != info->si_signo) {
2134 		info->si_signo = signr;
2135 		info->si_errno = 0;
2136 		info->si_code = SI_USER;
2137 		rcu_read_lock();
2138 		info->si_pid = task_pid_vnr(current->parent);
2139 		info->si_uid = from_kuid_munged(current_user_ns(),
2140 						task_uid(current->parent));
2141 		rcu_read_unlock();
2142 	}
2143 
2144 	/* If the (new) signal is now blocked, requeue it.  */
2145 	if (sigismember(&current->blocked, signr)) {
2146 		specific_send_sig_info(signr, info, current);
2147 		signr = 0;
2148 	}
2149 
2150 	return signr;
2151 }
2152 
2153 int get_signal(struct ksignal *ksig)
2154 {
2155 	struct sighand_struct *sighand = current->sighand;
2156 	struct signal_struct *signal = current->signal;
2157 	int signr;
2158 
2159 	if (unlikely(current->task_works))
2160 		task_work_run();
2161 
2162 	if (unlikely(uprobe_deny_signal()))
2163 		return 0;
2164 
2165 	/*
2166 	 * Do this once, we can't return to user-mode if freezing() == T.
2167 	 * do_signal_stop() and ptrace_stop() do freezable_schedule() and
2168 	 * thus do not need another check after return.
2169 	 */
2170 	try_to_freeze();
2171 
2172 relock:
2173 	spin_lock_irq(&sighand->siglock);
2174 	/*
2175 	 * Every stopped thread goes here after wakeup. Check to see if
2176 	 * we should notify the parent, prepare_signal(SIGCONT) encodes
2177 	 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
2178 	 */
2179 	if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2180 		int why;
2181 
2182 		if (signal->flags & SIGNAL_CLD_CONTINUED)
2183 			why = CLD_CONTINUED;
2184 		else
2185 			why = CLD_STOPPED;
2186 
2187 		signal->flags &= ~SIGNAL_CLD_MASK;
2188 
2189 		spin_unlock_irq(&sighand->siglock);
2190 
2191 		/*
2192 		 * Notify the parent that we're continuing.  This event is
2193 		 * always per-process and doesn't make whole lot of sense
2194 		 * for ptracers, who shouldn't consume the state via
2195 		 * wait(2) either, but, for backward compatibility, notify
2196 		 * the ptracer of the group leader too unless it's gonna be
2197 		 * a duplicate.
2198 		 */
2199 		read_lock(&tasklist_lock);
2200 		do_notify_parent_cldstop(current, false, why);
2201 
2202 		if (ptrace_reparented(current->group_leader))
2203 			do_notify_parent_cldstop(current->group_leader,
2204 						true, why);
2205 		read_unlock(&tasklist_lock);
2206 
2207 		goto relock;
2208 	}
2209 
2210 	for (;;) {
2211 		struct k_sigaction *ka;
2212 
2213 		if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
2214 		    do_signal_stop(0))
2215 			goto relock;
2216 
2217 		if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
2218 			do_jobctl_trap();
2219 			spin_unlock_irq(&sighand->siglock);
2220 			goto relock;
2221 		}
2222 
2223 		signr = dequeue_signal(current, &current->blocked, &ksig->info);
2224 
2225 		if (!signr)
2226 			break; /* will return 0 */
2227 
2228 		if (unlikely(current->ptrace) && signr != SIGKILL) {
2229 			signr = ptrace_signal(signr, &ksig->info);
2230 			if (!signr)
2231 				continue;
2232 		}
2233 
2234 		ka = &sighand->action[signr-1];
2235 
2236 		/* Trace actually delivered signals. */
2237 		trace_signal_deliver(signr, &ksig->info, ka);
2238 
2239 		if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
2240 			continue;
2241 		if (ka->sa.sa_handler != SIG_DFL) {
2242 			/* Run the handler.  */
2243 			ksig->ka = *ka;
2244 
2245 			if (ka->sa.sa_flags & SA_ONESHOT)
2246 				ka->sa.sa_handler = SIG_DFL;
2247 
2248 			break; /* will return non-zero "signr" value */
2249 		}
2250 
2251 		/*
2252 		 * Now we are doing the default action for this signal.
2253 		 */
2254 		if (sig_kernel_ignore(signr)) /* Default is nothing. */
2255 			continue;
2256 
2257 		/*
2258 		 * Global init gets no signals it doesn't want.
2259 		 * Container-init gets no signals it doesn't want from same
2260 		 * container.
2261 		 *
2262 		 * Note that if global/container-init sees a sig_kernel_only()
2263 		 * signal here, the signal must have been generated internally
2264 		 * or must have come from an ancestor namespace. In either
2265 		 * case, the signal cannot be dropped.
2266 		 */
2267 		if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2268 				!sig_kernel_only(signr))
2269 			continue;
2270 
2271 		if (sig_kernel_stop(signr)) {
2272 			/*
2273 			 * The default action is to stop all threads in
2274 			 * the thread group.  The job control signals
2275 			 * do nothing in an orphaned pgrp, but SIGSTOP
2276 			 * always works.  Note that siglock needs to be
2277 			 * dropped during the call to is_orphaned_pgrp()
2278 			 * because of lock ordering with tasklist_lock.
2279 			 * This allows an intervening SIGCONT to be posted.
2280 			 * We need to check for that and bail out if necessary.
2281 			 */
2282 			if (signr != SIGSTOP) {
2283 				spin_unlock_irq(&sighand->siglock);
2284 
2285 				/* signals can be posted during this window */
2286 
2287 				if (is_current_pgrp_orphaned())
2288 					goto relock;
2289 
2290 				spin_lock_irq(&sighand->siglock);
2291 			}
2292 
2293 			if (likely(do_signal_stop(ksig->info.si_signo))) {
2294 				/* It released the siglock.  */
2295 				goto relock;
2296 			}
2297 
2298 			/*
2299 			 * We didn't actually stop, due to a race
2300 			 * with SIGCONT or something like that.
2301 			 */
2302 			continue;
2303 		}
2304 
2305 		spin_unlock_irq(&sighand->siglock);
2306 
2307 		/*
2308 		 * Anything else is fatal, maybe with a core dump.
2309 		 */
2310 		current->flags |= PF_SIGNALED;
2311 
2312 		if (sig_kernel_coredump(signr)) {
2313 			if (print_fatal_signals)
2314 				print_fatal_signal(ksig->info.si_signo);
2315 			proc_coredump_connector(current);
2316 			/*
2317 			 * If it was able to dump core, this kills all
2318 			 * other threads in the group and synchronizes with
2319 			 * their demise.  If we lost the race with another
2320 			 * thread getting here, it set group_exit_code
2321 			 * first and our do_group_exit call below will use
2322 			 * that value and ignore the one we pass it.
2323 			 */
2324 			do_coredump(&ksig->info);
2325 		}
2326 
2327 		/*
2328 		 * Death signals, no core dump.
2329 		 */
2330 		do_group_exit(ksig->info.si_signo);
2331 		/* NOTREACHED */
2332 	}
2333 	spin_unlock_irq(&sighand->siglock);
2334 
2335 	ksig->sig = signr;
2336 	return ksig->sig > 0;
2337 }
2338 
2339 /**
2340  * signal_delivered -
2341  * @ksig:		kernel signal struct
2342  * @stepping:		nonzero if debugger single-step or block-step in use
2343  *
2344  * This function should be called when a signal has successfully been
2345  * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
2346  * is always blocked, and the signal itself is blocked unless %SA_NODEFER
2347  * is set in @ksig->ka.sa.sa_flags.  Tracing is notified.
2348  */
2349 static void signal_delivered(struct ksignal *ksig, int stepping)
2350 {
2351 	sigset_t blocked;
2352 
2353 	/* A signal was successfully delivered, and the
2354 	   saved sigmask was stored on the signal frame,
2355 	   and will be restored by sigreturn.  So we can
2356 	   simply clear the restore sigmask flag.  */
2357 	clear_restore_sigmask();
2358 
2359 	sigorsets(&blocked, &current->blocked, &ksig->ka.sa.sa_mask);
2360 	if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
2361 		sigaddset(&blocked, ksig->sig);
2362 	set_current_blocked(&blocked);
2363 	tracehook_signal_handler(stepping);
2364 }
2365 
2366 void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
2367 {
2368 	if (failed)
2369 		force_sigsegv(ksig->sig, current);
2370 	else
2371 		signal_delivered(ksig, stepping);
2372 }
2373 
2374 /*
2375  * It could be that complete_signal() picked us to notify about the
2376  * group-wide signal. Other threads should be notified now to take
2377  * the shared signals in @which since we will not.
2378  */
2379 static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2380 {
2381 	sigset_t retarget;
2382 	struct task_struct *t;
2383 
2384 	sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
2385 	if (sigisemptyset(&retarget))
2386 		return;
2387 
2388 	t = tsk;
2389 	while_each_thread(tsk, t) {
2390 		if (t->flags & PF_EXITING)
2391 			continue;
2392 
2393 		if (!has_pending_signals(&retarget, &t->blocked))
2394 			continue;
2395 		/* Remove the signals this thread can handle. */
2396 		sigandsets(&retarget, &retarget, &t->blocked);
2397 
2398 		if (!signal_pending(t))
2399 			signal_wake_up(t, 0);
2400 
2401 		if (sigisemptyset(&retarget))
2402 			break;
2403 	}
2404 }
2405 
2406 void exit_signals(struct task_struct *tsk)
2407 {
2408 	int group_stop = 0;
2409 	sigset_t unblocked;
2410 
2411 	/*
2412 	 * @tsk is about to have PF_EXITING set - lock out users which
2413 	 * expect stable threadgroup.
2414 	 */
2415 	cgroup_threadgroup_change_begin(tsk);
2416 
2417 	if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
2418 		tsk->flags |= PF_EXITING;
2419 		cgroup_threadgroup_change_end(tsk);
2420 		return;
2421 	}
2422 
2423 	spin_lock_irq(&tsk->sighand->siglock);
2424 	/*
2425 	 * From now this task is not visible for group-wide signals,
2426 	 * see wants_signal(), do_signal_stop().
2427 	 */
2428 	tsk->flags |= PF_EXITING;
2429 
2430 	cgroup_threadgroup_change_end(tsk);
2431 
2432 	if (!signal_pending(tsk))
2433 		goto out;
2434 
2435 	unblocked = tsk->blocked;
2436 	signotset(&unblocked);
2437 	retarget_shared_pending(tsk, &unblocked);
2438 
2439 	if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2440 	    task_participate_group_stop(tsk))
2441 		group_stop = CLD_STOPPED;
2442 out:
2443 	spin_unlock_irq(&tsk->sighand->siglock);
2444 
2445 	/*
2446 	 * If group stop has completed, deliver the notification.  This
2447 	 * should always go to the real parent of the group leader.
2448 	 */
2449 	if (unlikely(group_stop)) {
2450 		read_lock(&tasklist_lock);
2451 		do_notify_parent_cldstop(tsk, false, group_stop);
2452 		read_unlock(&tasklist_lock);
2453 	}
2454 }
2455 
2456 EXPORT_SYMBOL(recalc_sigpending);
2457 EXPORT_SYMBOL_GPL(dequeue_signal);
2458 EXPORT_SYMBOL(flush_signals);
2459 EXPORT_SYMBOL(force_sig);
2460 EXPORT_SYMBOL(send_sig);
2461 EXPORT_SYMBOL(send_sig_info);
2462 EXPORT_SYMBOL(sigprocmask);
2463 
2464 /*
2465  * System call entry points.
2466  */
2467 
2468 /**
2469  *  sys_restart_syscall - restart a system call
2470  */
2471 SYSCALL_DEFINE0(restart_syscall)
2472 {
2473 	struct restart_block *restart = &current->restart_block;
2474 	return restart->fn(restart);
2475 }
2476 
2477 long do_no_restart_syscall(struct restart_block *param)
2478 {
2479 	return -EINTR;
2480 }
2481 
2482 static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
2483 {
2484 	if (signal_pending(tsk) && !thread_group_empty(tsk)) {
2485 		sigset_t newblocked;
2486 		/* A set of now blocked but previously unblocked signals. */
2487 		sigandnsets(&newblocked, newset, &current->blocked);
2488 		retarget_shared_pending(tsk, &newblocked);
2489 	}
2490 	tsk->blocked = *newset;
2491 	recalc_sigpending();
2492 }
2493 
2494 /**
2495  * set_current_blocked - change current->blocked mask
2496  * @newset: new mask
2497  *
2498  * It is wrong to change ->blocked directly, this helper should be used
2499  * to ensure the process can't miss a shared signal we are going to block.
2500  */
2501 void set_current_blocked(sigset_t *newset)
2502 {
2503 	sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2504 	__set_current_blocked(newset);
2505 }
2506 
2507 void __set_current_blocked(const sigset_t *newset)
2508 {
2509 	struct task_struct *tsk = current;
2510 
2511 	/*
2512 	 * In case the signal mask hasn't changed, there is nothing we need
2513 	 * to do. The current->blocked shouldn't be modified by other task.
2514 	 */
2515 	if (sigequalsets(&tsk->blocked, newset))
2516 		return;
2517 
2518 	spin_lock_irq(&tsk->sighand->siglock);
2519 	__set_task_blocked(tsk, newset);
2520 	spin_unlock_irq(&tsk->sighand->siglock);
2521 }
2522 
2523 /*
2524  * This is also useful for kernel threads that want to temporarily
2525  * (or permanently) block certain signals.
2526  *
2527  * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2528  * interface happily blocks "unblockable" signals like SIGKILL
2529  * and friends.
2530  */
2531 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2532 {
2533 	struct task_struct *tsk = current;
2534 	sigset_t newset;
2535 
2536 	/* Lockless, only current can change ->blocked, never from irq */
2537 	if (oldset)
2538 		*oldset = tsk->blocked;
2539 
2540 	switch (how) {
2541 	case SIG_BLOCK:
2542 		sigorsets(&newset, &tsk->blocked, set);
2543 		break;
2544 	case SIG_UNBLOCK:
2545 		sigandnsets(&newset, &tsk->blocked, set);
2546 		break;
2547 	case SIG_SETMASK:
2548 		newset = *set;
2549 		break;
2550 	default:
2551 		return -EINVAL;
2552 	}
2553 
2554 	__set_current_blocked(&newset);
2555 	return 0;
2556 }
2557 
2558 /**
2559  *  sys_rt_sigprocmask - change the list of currently blocked signals
2560  *  @how: whether to add, remove, or set signals
2561  *  @nset: stores pending signals
2562  *  @oset: previous value of signal mask if non-null
2563  *  @sigsetsize: size of sigset_t type
2564  */
2565 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
2566 		sigset_t __user *, oset, size_t, sigsetsize)
2567 {
2568 	sigset_t old_set, new_set;
2569 	int error;
2570 
2571 	/* XXX: Don't preclude handling different sized sigset_t's.  */
2572 	if (sigsetsize != sizeof(sigset_t))
2573 		return -EINVAL;
2574 
2575 	old_set = current->blocked;
2576 
2577 	if (nset) {
2578 		if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
2579 			return -EFAULT;
2580 		sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2581 
2582 		error = sigprocmask(how, &new_set, NULL);
2583 		if (error)
2584 			return error;
2585 	}
2586 
2587 	if (oset) {
2588 		if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
2589 			return -EFAULT;
2590 	}
2591 
2592 	return 0;
2593 }
2594 
2595 #ifdef CONFIG_COMPAT
2596 COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
2597 		compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
2598 {
2599 #ifdef __BIG_ENDIAN
2600 	sigset_t old_set = current->blocked;
2601 
2602 	/* XXX: Don't preclude handling different sized sigset_t's.  */
2603 	if (sigsetsize != sizeof(sigset_t))
2604 		return -EINVAL;
2605 
2606 	if (nset) {
2607 		compat_sigset_t new32;
2608 		sigset_t new_set;
2609 		int error;
2610 		if (copy_from_user(&new32, nset, sizeof(compat_sigset_t)))
2611 			return -EFAULT;
2612 
2613 		sigset_from_compat(&new_set, &new32);
2614 		sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2615 
2616 		error = sigprocmask(how, &new_set, NULL);
2617 		if (error)
2618 			return error;
2619 	}
2620 	if (oset) {
2621 		compat_sigset_t old32;
2622 		sigset_to_compat(&old32, &old_set);
2623 		if (copy_to_user(oset, &old32, sizeof(compat_sigset_t)))
2624 			return -EFAULT;
2625 	}
2626 	return 0;
2627 #else
2628 	return sys_rt_sigprocmask(how, (sigset_t __user *)nset,
2629 				  (sigset_t __user *)oset, sigsetsize);
2630 #endif
2631 }
2632 #endif
2633 
2634 static int do_sigpending(void *set, unsigned long sigsetsize)
2635 {
2636 	if (sigsetsize > sizeof(sigset_t))
2637 		return -EINVAL;
2638 
2639 	spin_lock_irq(&current->sighand->siglock);
2640 	sigorsets(set, &current->pending.signal,
2641 		  &current->signal->shared_pending.signal);
2642 	spin_unlock_irq(&current->sighand->siglock);
2643 
2644 	/* Outside the lock because only this thread touches it.  */
2645 	sigandsets(set, &current->blocked, set);
2646 	return 0;
2647 }
2648 
2649 /**
2650  *  sys_rt_sigpending - examine a pending signal that has been raised
2651  *			while blocked
2652  *  @uset: stores pending signals
2653  *  @sigsetsize: size of sigset_t type or larger
2654  */
2655 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
2656 {
2657 	sigset_t set;
2658 	int err = do_sigpending(&set, sigsetsize);
2659 	if (!err && copy_to_user(uset, &set, sigsetsize))
2660 		err = -EFAULT;
2661 	return err;
2662 }
2663 
2664 #ifdef CONFIG_COMPAT
2665 COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
2666 		compat_size_t, sigsetsize)
2667 {
2668 #ifdef __BIG_ENDIAN
2669 	sigset_t set;
2670 	int err = do_sigpending(&set, sigsetsize);
2671 	if (!err) {
2672 		compat_sigset_t set32;
2673 		sigset_to_compat(&set32, &set);
2674 		/* we can get here only if sigsetsize <= sizeof(set) */
2675 		if (copy_to_user(uset, &set32, sigsetsize))
2676 			err = -EFAULT;
2677 	}
2678 	return err;
2679 #else
2680 	return sys_rt_sigpending((sigset_t __user *)uset, sigsetsize);
2681 #endif
2682 }
2683 #endif
2684 
2685 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2686 
2687 int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
2688 {
2689 	int err;
2690 
2691 	if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2692 		return -EFAULT;
2693 	if (from->si_code < 0)
2694 		return __copy_to_user(to, from, sizeof(siginfo_t))
2695 			? -EFAULT : 0;
2696 	/*
2697 	 * If you change siginfo_t structure, please be sure
2698 	 * this code is fixed accordingly.
2699 	 * Please remember to update the signalfd_copyinfo() function
2700 	 * inside fs/signalfd.c too, in case siginfo_t changes.
2701 	 * It should never copy any pad contained in the structure
2702 	 * to avoid security leaks, but must copy the generic
2703 	 * 3 ints plus the relevant union member.
2704 	 */
2705 	err = __put_user(from->si_signo, &to->si_signo);
2706 	err |= __put_user(from->si_errno, &to->si_errno);
2707 	err |= __put_user((short)from->si_code, &to->si_code);
2708 	switch (from->si_code & __SI_MASK) {
2709 	case __SI_KILL:
2710 		err |= __put_user(from->si_pid, &to->si_pid);
2711 		err |= __put_user(from->si_uid, &to->si_uid);
2712 		break;
2713 	case __SI_TIMER:
2714 		 err |= __put_user(from->si_tid, &to->si_tid);
2715 		 err |= __put_user(from->si_overrun, &to->si_overrun);
2716 		 err |= __put_user(from->si_ptr, &to->si_ptr);
2717 		break;
2718 	case __SI_POLL:
2719 		err |= __put_user(from->si_band, &to->si_band);
2720 		err |= __put_user(from->si_fd, &to->si_fd);
2721 		break;
2722 	case __SI_FAULT:
2723 		err |= __put_user(from->si_addr, &to->si_addr);
2724 #ifdef __ARCH_SI_TRAPNO
2725 		err |= __put_user(from->si_trapno, &to->si_trapno);
2726 #endif
2727 #ifdef BUS_MCEERR_AO
2728 		/*
2729 		 * Other callers might not initialize the si_lsb field,
2730 		 * so check explicitly for the right codes here.
2731 		 */
2732 		if (from->si_signo == SIGBUS &&
2733 		    (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO))
2734 			err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
2735 #endif
2736 #ifdef SEGV_BNDERR
2737 		if (from->si_signo == SIGSEGV && from->si_code == SEGV_BNDERR) {
2738 			err |= __put_user(from->si_lower, &to->si_lower);
2739 			err |= __put_user(from->si_upper, &to->si_upper);
2740 		}
2741 #endif
2742 #ifdef SEGV_PKUERR
2743 		if (from->si_signo == SIGSEGV && from->si_code == SEGV_PKUERR)
2744 			err |= __put_user(from->si_pkey, &to->si_pkey);
2745 #endif
2746 		break;
2747 	case __SI_CHLD:
2748 		err |= __put_user(from->si_pid, &to->si_pid);
2749 		err |= __put_user(from->si_uid, &to->si_uid);
2750 		err |= __put_user(from->si_status, &to->si_status);
2751 		err |= __put_user(from->si_utime, &to->si_utime);
2752 		err |= __put_user(from->si_stime, &to->si_stime);
2753 		break;
2754 	case __SI_RT: /* This is not generated by the kernel as of now. */
2755 	case __SI_MESGQ: /* But this is */
2756 		err |= __put_user(from->si_pid, &to->si_pid);
2757 		err |= __put_user(from->si_uid, &to->si_uid);
2758 		err |= __put_user(from->si_ptr, &to->si_ptr);
2759 		break;
2760 #ifdef __ARCH_SIGSYS
2761 	case __SI_SYS:
2762 		err |= __put_user(from->si_call_addr, &to->si_call_addr);
2763 		err |= __put_user(from->si_syscall, &to->si_syscall);
2764 		err |= __put_user(from->si_arch, &to->si_arch);
2765 		break;
2766 #endif
2767 	default: /* this is just in case for now ... */
2768 		err |= __put_user(from->si_pid, &to->si_pid);
2769 		err |= __put_user(from->si_uid, &to->si_uid);
2770 		break;
2771 	}
2772 	return err;
2773 }
2774 
2775 #endif
2776 
2777 /**
2778  *  do_sigtimedwait - wait for queued signals specified in @which
2779  *  @which: queued signals to wait for
2780  *  @info: if non-null, the signal's siginfo is returned here
2781  *  @ts: upper bound on process time suspension
2782  */
2783 static int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
2784 		    const struct timespec *ts)
2785 {
2786 	ktime_t *to = NULL, timeout = KTIME_MAX;
2787 	struct task_struct *tsk = current;
2788 	sigset_t mask = *which;
2789 	int sig, ret = 0;
2790 
2791 	if (ts) {
2792 		if (!timespec_valid(ts))
2793 			return -EINVAL;
2794 		timeout = timespec_to_ktime(*ts);
2795 		to = &timeout;
2796 	}
2797 
2798 	/*
2799 	 * Invert the set of allowed signals to get those we want to block.
2800 	 */
2801 	sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
2802 	signotset(&mask);
2803 
2804 	spin_lock_irq(&tsk->sighand->siglock);
2805 	sig = dequeue_signal(tsk, &mask, info);
2806 	if (!sig && timeout) {
2807 		/*
2808 		 * None ready, temporarily unblock those we're interested
2809 		 * while we are sleeping in so that we'll be awakened when
2810 		 * they arrive. Unblocking is always fine, we can avoid
2811 		 * set_current_blocked().
2812 		 */
2813 		tsk->real_blocked = tsk->blocked;
2814 		sigandsets(&tsk->blocked, &tsk->blocked, &mask);
2815 		recalc_sigpending();
2816 		spin_unlock_irq(&tsk->sighand->siglock);
2817 
2818 		__set_current_state(TASK_INTERRUPTIBLE);
2819 		ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns,
2820 							 HRTIMER_MODE_REL);
2821 		spin_lock_irq(&tsk->sighand->siglock);
2822 		__set_task_blocked(tsk, &tsk->real_blocked);
2823 		sigemptyset(&tsk->real_blocked);
2824 		sig = dequeue_signal(tsk, &mask, info);
2825 	}
2826 	spin_unlock_irq(&tsk->sighand->siglock);
2827 
2828 	if (sig)
2829 		return sig;
2830 	return ret ? -EINTR : -EAGAIN;
2831 }
2832 
2833 /**
2834  *  sys_rt_sigtimedwait - synchronously wait for queued signals specified
2835  *			in @uthese
2836  *  @uthese: queued signals to wait for
2837  *  @uinfo: if non-null, the signal's siginfo is returned here
2838  *  @uts: upper bound on process time suspension
2839  *  @sigsetsize: size of sigset_t type
2840  */
2841 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
2842 		siginfo_t __user *, uinfo, const struct timespec __user *, uts,
2843 		size_t, sigsetsize)
2844 {
2845 	sigset_t these;
2846 	struct timespec ts;
2847 	siginfo_t info;
2848 	int ret;
2849 
2850 	/* XXX: Don't preclude handling different sized sigset_t's.  */
2851 	if (sigsetsize != sizeof(sigset_t))
2852 		return -EINVAL;
2853 
2854 	if (copy_from_user(&these, uthese, sizeof(these)))
2855 		return -EFAULT;
2856 
2857 	if (uts) {
2858 		if (copy_from_user(&ts, uts, sizeof(ts)))
2859 			return -EFAULT;
2860 	}
2861 
2862 	ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
2863 
2864 	if (ret > 0 && uinfo) {
2865 		if (copy_siginfo_to_user(uinfo, &info))
2866 			ret = -EFAULT;
2867 	}
2868 
2869 	return ret;
2870 }
2871 
2872 #ifdef CONFIG_COMPAT
2873 COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait, compat_sigset_t __user *, uthese,
2874 		struct compat_siginfo __user *, uinfo,
2875 		struct compat_timespec __user *, uts, compat_size_t, sigsetsize)
2876 {
2877 	compat_sigset_t s32;
2878 	sigset_t s;
2879 	struct timespec t;
2880 	siginfo_t info;
2881 	long ret;
2882 
2883 	if (sigsetsize != sizeof(sigset_t))
2884 		return -EINVAL;
2885 
2886 	if (copy_from_user(&s32, uthese, sizeof(compat_sigset_t)))
2887 		return -EFAULT;
2888 	sigset_from_compat(&s, &s32);
2889 
2890 	if (uts) {
2891 		if (compat_get_timespec(&t, uts))
2892 			return -EFAULT;
2893 	}
2894 
2895 	ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
2896 
2897 	if (ret > 0 && uinfo) {
2898 		if (copy_siginfo_to_user32(uinfo, &info))
2899 			ret = -EFAULT;
2900 	}
2901 
2902 	return ret;
2903 }
2904 #endif
2905 
2906 /**
2907  *  sys_kill - send a signal to a process
2908  *  @pid: the PID of the process
2909  *  @sig: signal to be sent
2910  */
2911 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
2912 {
2913 	struct siginfo info;
2914 
2915 	info.si_signo = sig;
2916 	info.si_errno = 0;
2917 	info.si_code = SI_USER;
2918 	info.si_pid = task_tgid_vnr(current);
2919 	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2920 
2921 	return kill_something_info(sig, &info, pid);
2922 }
2923 
2924 static int
2925 do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
2926 {
2927 	struct task_struct *p;
2928 	int error = -ESRCH;
2929 
2930 	rcu_read_lock();
2931 	p = find_task_by_vpid(pid);
2932 	if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2933 		error = check_kill_permission(sig, info, p);
2934 		/*
2935 		 * The null signal is a permissions and process existence
2936 		 * probe.  No signal is actually delivered.
2937 		 */
2938 		if (!error && sig) {
2939 			error = do_send_sig_info(sig, info, p, false);
2940 			/*
2941 			 * If lock_task_sighand() failed we pretend the task
2942 			 * dies after receiving the signal. The window is tiny,
2943 			 * and the signal is private anyway.
2944 			 */
2945 			if (unlikely(error == -ESRCH))
2946 				error = 0;
2947 		}
2948 	}
2949 	rcu_read_unlock();
2950 
2951 	return error;
2952 }
2953 
2954 static int do_tkill(pid_t tgid, pid_t pid, int sig)
2955 {
2956 	struct siginfo info = {};
2957 
2958 	info.si_signo = sig;
2959 	info.si_errno = 0;
2960 	info.si_code = SI_TKILL;
2961 	info.si_pid = task_tgid_vnr(current);
2962 	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2963 
2964 	return do_send_specific(tgid, pid, sig, &info);
2965 }
2966 
2967 /**
2968  *  sys_tgkill - send signal to one specific thread
2969  *  @tgid: the thread group ID of the thread
2970  *  @pid: the PID of the thread
2971  *  @sig: signal to be sent
2972  *
2973  *  This syscall also checks the @tgid and returns -ESRCH even if the PID
2974  *  exists but it's not belonging to the target process anymore. This
2975  *  method solves the problem of threads exiting and PIDs getting reused.
2976  */
2977 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
2978 {
2979 	/* This is only valid for single tasks */
2980 	if (pid <= 0 || tgid <= 0)
2981 		return -EINVAL;
2982 
2983 	return do_tkill(tgid, pid, sig);
2984 }
2985 
2986 /**
2987  *  sys_tkill - send signal to one specific task
2988  *  @pid: the PID of the task
2989  *  @sig: signal to be sent
2990  *
2991  *  Send a signal to only one task, even if it's a CLONE_THREAD task.
2992  */
2993 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
2994 {
2995 	/* This is only valid for single tasks */
2996 	if (pid <= 0)
2997 		return -EINVAL;
2998 
2999 	return do_tkill(0, pid, sig);
3000 }
3001 
3002 static int do_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t *info)
3003 {
3004 	/* Not even root can pretend to send signals from the kernel.
3005 	 * Nor can they impersonate a kill()/tgkill(), which adds source info.
3006 	 */
3007 	if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3008 	    (task_pid_vnr(current) != pid))
3009 		return -EPERM;
3010 
3011 	info->si_signo = sig;
3012 
3013 	/* POSIX.1b doesn't mention process groups.  */
3014 	return kill_proc_info(sig, info, pid);
3015 }
3016 
3017 /**
3018  *  sys_rt_sigqueueinfo - send signal information to a signal
3019  *  @pid: the PID of the thread
3020  *  @sig: signal to be sent
3021  *  @uinfo: signal info to be sent
3022  */
3023 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
3024 		siginfo_t __user *, uinfo)
3025 {
3026 	siginfo_t info;
3027 	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3028 		return -EFAULT;
3029 	return do_rt_sigqueueinfo(pid, sig, &info);
3030 }
3031 
3032 #ifdef CONFIG_COMPAT
3033 COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
3034 			compat_pid_t, pid,
3035 			int, sig,
3036 			struct compat_siginfo __user *, uinfo)
3037 {
3038 	siginfo_t info = {};
3039 	int ret = copy_siginfo_from_user32(&info, uinfo);
3040 	if (unlikely(ret))
3041 		return ret;
3042 	return do_rt_sigqueueinfo(pid, sig, &info);
3043 }
3044 #endif
3045 
3046 static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
3047 {
3048 	/* This is only valid for single tasks */
3049 	if (pid <= 0 || tgid <= 0)
3050 		return -EINVAL;
3051 
3052 	/* Not even root can pretend to send signals from the kernel.
3053 	 * Nor can they impersonate a kill()/tgkill(), which adds source info.
3054 	 */
3055 	if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3056 	    (task_pid_vnr(current) != pid))
3057 		return -EPERM;
3058 
3059 	info->si_signo = sig;
3060 
3061 	return do_send_specific(tgid, pid, sig, info);
3062 }
3063 
3064 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
3065 		siginfo_t __user *, uinfo)
3066 {
3067 	siginfo_t info;
3068 
3069 	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3070 		return -EFAULT;
3071 
3072 	return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3073 }
3074 
3075 #ifdef CONFIG_COMPAT
3076 COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
3077 			compat_pid_t, tgid,
3078 			compat_pid_t, pid,
3079 			int, sig,
3080 			struct compat_siginfo __user *, uinfo)
3081 {
3082 	siginfo_t info = {};
3083 
3084 	if (copy_siginfo_from_user32(&info, uinfo))
3085 		return -EFAULT;
3086 	return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3087 }
3088 #endif
3089 
3090 /*
3091  * For kthreads only, must not be used if cloned with CLONE_SIGHAND
3092  */
3093 void kernel_sigaction(int sig, __sighandler_t action)
3094 {
3095 	spin_lock_irq(&current->sighand->siglock);
3096 	current->sighand->action[sig - 1].sa.sa_handler = action;
3097 	if (action == SIG_IGN) {
3098 		sigset_t mask;
3099 
3100 		sigemptyset(&mask);
3101 		sigaddset(&mask, sig);
3102 
3103 		flush_sigqueue_mask(&mask, &current->signal->shared_pending);
3104 		flush_sigqueue_mask(&mask, &current->pending);
3105 		recalc_sigpending();
3106 	}
3107 	spin_unlock_irq(&current->sighand->siglock);
3108 }
3109 EXPORT_SYMBOL(kernel_sigaction);
3110 
3111 void __weak sigaction_compat_abi(struct k_sigaction *act,
3112 		struct k_sigaction *oact)
3113 {
3114 }
3115 
3116 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
3117 {
3118 	struct task_struct *p = current, *t;
3119 	struct k_sigaction *k;
3120 	sigset_t mask;
3121 
3122 	if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
3123 		return -EINVAL;
3124 
3125 	k = &p->sighand->action[sig-1];
3126 
3127 	spin_lock_irq(&p->sighand->siglock);
3128 	if (oact)
3129 		*oact = *k;
3130 
3131 	sigaction_compat_abi(act, oact);
3132 
3133 	if (act) {
3134 		sigdelsetmask(&act->sa.sa_mask,
3135 			      sigmask(SIGKILL) | sigmask(SIGSTOP));
3136 		*k = *act;
3137 		/*
3138 		 * POSIX 3.3.1.3:
3139 		 *  "Setting a signal action to SIG_IGN for a signal that is
3140 		 *   pending shall cause the pending signal to be discarded,
3141 		 *   whether or not it is blocked."
3142 		 *
3143 		 *  "Setting a signal action to SIG_DFL for a signal that is
3144 		 *   pending and whose default action is to ignore the signal
3145 		 *   (for example, SIGCHLD), shall cause the pending signal to
3146 		 *   be discarded, whether or not it is blocked"
3147 		 */
3148 		if (sig_handler_ignored(sig_handler(p, sig), sig)) {
3149 			sigemptyset(&mask);
3150 			sigaddset(&mask, sig);
3151 			flush_sigqueue_mask(&mask, &p->signal->shared_pending);
3152 			for_each_thread(p, t)
3153 				flush_sigqueue_mask(&mask, &t->pending);
3154 		}
3155 	}
3156 
3157 	spin_unlock_irq(&p->sighand->siglock);
3158 	return 0;
3159 }
3160 
3161 static int
3162 do_sigaltstack (const stack_t *ss, stack_t *oss, unsigned long sp)
3163 {
3164 	struct task_struct *t = current;
3165 
3166 	if (oss) {
3167 		memset(oss, 0, sizeof(stack_t));
3168 		oss->ss_sp = (void __user *) t->sas_ss_sp;
3169 		oss->ss_size = t->sas_ss_size;
3170 		oss->ss_flags = sas_ss_flags(sp) |
3171 			(current->sas_ss_flags & SS_FLAG_BITS);
3172 	}
3173 
3174 	if (ss) {
3175 		void __user *ss_sp = ss->ss_sp;
3176 		size_t ss_size = ss->ss_size;
3177 		unsigned ss_flags = ss->ss_flags;
3178 		int ss_mode;
3179 
3180 		if (unlikely(on_sig_stack(sp)))
3181 			return -EPERM;
3182 
3183 		ss_mode = ss_flags & ~SS_FLAG_BITS;
3184 		if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
3185 				ss_mode != 0))
3186 			return -EINVAL;
3187 
3188 		if (ss_mode == SS_DISABLE) {
3189 			ss_size = 0;
3190 			ss_sp = NULL;
3191 		} else {
3192 			if (unlikely(ss_size < MINSIGSTKSZ))
3193 				return -ENOMEM;
3194 		}
3195 
3196 		t->sas_ss_sp = (unsigned long) ss_sp;
3197 		t->sas_ss_size = ss_size;
3198 		t->sas_ss_flags = ss_flags;
3199 	}
3200 	return 0;
3201 }
3202 
3203 SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
3204 {
3205 	stack_t new, old;
3206 	int err;
3207 	if (uss && copy_from_user(&new, uss, sizeof(stack_t)))
3208 		return -EFAULT;
3209 	err = do_sigaltstack(uss ? &new : NULL, uoss ? &old : NULL,
3210 			      current_user_stack_pointer());
3211 	if (!err && uoss && copy_to_user(uoss, &old, sizeof(stack_t)))
3212 		err = -EFAULT;
3213 	return err;
3214 }
3215 
3216 int restore_altstack(const stack_t __user *uss)
3217 {
3218 	stack_t new;
3219 	if (copy_from_user(&new, uss, sizeof(stack_t)))
3220 		return -EFAULT;
3221 	(void)do_sigaltstack(&new, NULL, current_user_stack_pointer());
3222 	/* squash all but EFAULT for now */
3223 	return 0;
3224 }
3225 
3226 int __save_altstack(stack_t __user *uss, unsigned long sp)
3227 {
3228 	struct task_struct *t = current;
3229 	int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
3230 		__put_user(t->sas_ss_flags, &uss->ss_flags) |
3231 		__put_user(t->sas_ss_size, &uss->ss_size);
3232 	if (err)
3233 		return err;
3234 	if (t->sas_ss_flags & SS_AUTODISARM)
3235 		sas_ss_reset(t);
3236 	return 0;
3237 }
3238 
3239 #ifdef CONFIG_COMPAT
3240 COMPAT_SYSCALL_DEFINE2(sigaltstack,
3241 			const compat_stack_t __user *, uss_ptr,
3242 			compat_stack_t __user *, uoss_ptr)
3243 {
3244 	stack_t uss, uoss;
3245 	int ret;
3246 
3247 	if (uss_ptr) {
3248 		compat_stack_t uss32;
3249 		if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
3250 			return -EFAULT;
3251 		uss.ss_sp = compat_ptr(uss32.ss_sp);
3252 		uss.ss_flags = uss32.ss_flags;
3253 		uss.ss_size = uss32.ss_size;
3254 	}
3255 	ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss,
3256 			     compat_user_stack_pointer());
3257 	if (ret >= 0 && uoss_ptr)  {
3258 		compat_stack_t old;
3259 		memset(&old, 0, sizeof(old));
3260 		old.ss_sp = ptr_to_compat(uoss.ss_sp);
3261 		old.ss_flags = uoss.ss_flags;
3262 		old.ss_size = uoss.ss_size;
3263 		if (copy_to_user(uoss_ptr, &old, sizeof(compat_stack_t)))
3264 			ret = -EFAULT;
3265 	}
3266 	return ret;
3267 }
3268 
3269 int compat_restore_altstack(const compat_stack_t __user *uss)
3270 {
3271 	int err = compat_sys_sigaltstack(uss, NULL);
3272 	/* squash all but -EFAULT for now */
3273 	return err == -EFAULT ? err : 0;
3274 }
3275 
3276 int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
3277 {
3278 	int err;
3279 	struct task_struct *t = current;
3280 	err = __put_user(ptr_to_compat((void __user *)t->sas_ss_sp),
3281 			 &uss->ss_sp) |
3282 		__put_user(t->sas_ss_flags, &uss->ss_flags) |
3283 		__put_user(t->sas_ss_size, &uss->ss_size);
3284 	if (err)
3285 		return err;
3286 	if (t->sas_ss_flags & SS_AUTODISARM)
3287 		sas_ss_reset(t);
3288 	return 0;
3289 }
3290 #endif
3291 
3292 #ifdef __ARCH_WANT_SYS_SIGPENDING
3293 
3294 /**
3295  *  sys_sigpending - examine pending signals
3296  *  @set: where mask of pending signal is returned
3297  */
3298 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
3299 {
3300 	return sys_rt_sigpending((sigset_t __user *)set, sizeof(old_sigset_t));
3301 }
3302 
3303 #ifdef CONFIG_COMPAT
3304 COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set32)
3305 {
3306 	sigset_t set;
3307 	int err = do_sigpending(&set, sizeof(old_sigset_t));
3308 	if (err == 0)
3309 		if (copy_to_user(set32, &set, sizeof(old_sigset_t)))
3310 			err = -EFAULT;
3311 	return err;
3312 }
3313 #endif
3314 
3315 #endif
3316 
3317 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
3318 /**
3319  *  sys_sigprocmask - examine and change blocked signals
3320  *  @how: whether to add, remove, or set signals
3321  *  @nset: signals to add or remove (if non-null)
3322  *  @oset: previous value of signal mask if non-null
3323  *
3324  * Some platforms have their own version with special arguments;
3325  * others support only sys_rt_sigprocmask.
3326  */
3327 
3328 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
3329 		old_sigset_t __user *, oset)
3330 {
3331 	old_sigset_t old_set, new_set;
3332 	sigset_t new_blocked;
3333 
3334 	old_set = current->blocked.sig[0];
3335 
3336 	if (nset) {
3337 		if (copy_from_user(&new_set, nset, sizeof(*nset)))
3338 			return -EFAULT;
3339 
3340 		new_blocked = current->blocked;
3341 
3342 		switch (how) {
3343 		case SIG_BLOCK:
3344 			sigaddsetmask(&new_blocked, new_set);
3345 			break;
3346 		case SIG_UNBLOCK:
3347 			sigdelsetmask(&new_blocked, new_set);
3348 			break;
3349 		case SIG_SETMASK:
3350 			new_blocked.sig[0] = new_set;
3351 			break;
3352 		default:
3353 			return -EINVAL;
3354 		}
3355 
3356 		set_current_blocked(&new_blocked);
3357 	}
3358 
3359 	if (oset) {
3360 		if (copy_to_user(oset, &old_set, sizeof(*oset)))
3361 			return -EFAULT;
3362 	}
3363 
3364 	return 0;
3365 }
3366 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
3367 
3368 #ifndef CONFIG_ODD_RT_SIGACTION
3369 /**
3370  *  sys_rt_sigaction - alter an action taken by a process
3371  *  @sig: signal to be sent
3372  *  @act: new sigaction
3373  *  @oact: used to save the previous sigaction
3374  *  @sigsetsize: size of sigset_t type
3375  */
3376 SYSCALL_DEFINE4(rt_sigaction, int, sig,
3377 		const struct sigaction __user *, act,
3378 		struct sigaction __user *, oact,
3379 		size_t, sigsetsize)
3380 {
3381 	struct k_sigaction new_sa, old_sa;
3382 	int ret = -EINVAL;
3383 
3384 	/* XXX: Don't preclude handling different sized sigset_t's.  */
3385 	if (sigsetsize != sizeof(sigset_t))
3386 		goto out;
3387 
3388 	if (act) {
3389 		if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
3390 			return -EFAULT;
3391 	}
3392 
3393 	ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
3394 
3395 	if (!ret && oact) {
3396 		if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
3397 			return -EFAULT;
3398 	}
3399 out:
3400 	return ret;
3401 }
3402 #ifdef CONFIG_COMPAT
3403 COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig,
3404 		const struct compat_sigaction __user *, act,
3405 		struct compat_sigaction __user *, oact,
3406 		compat_size_t, sigsetsize)
3407 {
3408 	struct k_sigaction new_ka, old_ka;
3409 	compat_sigset_t mask;
3410 #ifdef __ARCH_HAS_SA_RESTORER
3411 	compat_uptr_t restorer;
3412 #endif
3413 	int ret;
3414 
3415 	/* XXX: Don't preclude handling different sized sigset_t's.  */
3416 	if (sigsetsize != sizeof(compat_sigset_t))
3417 		return -EINVAL;
3418 
3419 	if (act) {
3420 		compat_uptr_t handler;
3421 		ret = get_user(handler, &act->sa_handler);
3422 		new_ka.sa.sa_handler = compat_ptr(handler);
3423 #ifdef __ARCH_HAS_SA_RESTORER
3424 		ret |= get_user(restorer, &act->sa_restorer);
3425 		new_ka.sa.sa_restorer = compat_ptr(restorer);
3426 #endif
3427 		ret |= copy_from_user(&mask, &act->sa_mask, sizeof(mask));
3428 		ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
3429 		if (ret)
3430 			return -EFAULT;
3431 		sigset_from_compat(&new_ka.sa.sa_mask, &mask);
3432 	}
3433 
3434 	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3435 	if (!ret && oact) {
3436 		sigset_to_compat(&mask, &old_ka.sa.sa_mask);
3437 		ret = put_user(ptr_to_compat(old_ka.sa.sa_handler),
3438 			       &oact->sa_handler);
3439 		ret |= copy_to_user(&oact->sa_mask, &mask, sizeof(mask));
3440 		ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
3441 #ifdef __ARCH_HAS_SA_RESTORER
3442 		ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3443 				&oact->sa_restorer);
3444 #endif
3445 	}
3446 	return ret;
3447 }
3448 #endif
3449 #endif /* !CONFIG_ODD_RT_SIGACTION */
3450 
3451 #ifdef CONFIG_OLD_SIGACTION
3452 SYSCALL_DEFINE3(sigaction, int, sig,
3453 		const struct old_sigaction __user *, act,
3454 	        struct old_sigaction __user *, oact)
3455 {
3456 	struct k_sigaction new_ka, old_ka;
3457 	int ret;
3458 
3459 	if (act) {
3460 		old_sigset_t mask;
3461 		if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3462 		    __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
3463 		    __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
3464 		    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3465 		    __get_user(mask, &act->sa_mask))
3466 			return -EFAULT;
3467 #ifdef __ARCH_HAS_KA_RESTORER
3468 		new_ka.ka_restorer = NULL;
3469 #endif
3470 		siginitset(&new_ka.sa.sa_mask, mask);
3471 	}
3472 
3473 	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3474 
3475 	if (!ret && oact) {
3476 		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3477 		    __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
3478 		    __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
3479 		    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3480 		    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3481 			return -EFAULT;
3482 	}
3483 
3484 	return ret;
3485 }
3486 #endif
3487 #ifdef CONFIG_COMPAT_OLD_SIGACTION
3488 COMPAT_SYSCALL_DEFINE3(sigaction, int, sig,
3489 		const struct compat_old_sigaction __user *, act,
3490 	        struct compat_old_sigaction __user *, oact)
3491 {
3492 	struct k_sigaction new_ka, old_ka;
3493 	int ret;
3494 	compat_old_sigset_t mask;
3495 	compat_uptr_t handler, restorer;
3496 
3497 	if (act) {
3498 		if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3499 		    __get_user(handler, &act->sa_handler) ||
3500 		    __get_user(restorer, &act->sa_restorer) ||
3501 		    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3502 		    __get_user(mask, &act->sa_mask))
3503 			return -EFAULT;
3504 
3505 #ifdef __ARCH_HAS_KA_RESTORER
3506 		new_ka.ka_restorer = NULL;
3507 #endif
3508 		new_ka.sa.sa_handler = compat_ptr(handler);
3509 		new_ka.sa.sa_restorer = compat_ptr(restorer);
3510 		siginitset(&new_ka.sa.sa_mask, mask);
3511 	}
3512 
3513 	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3514 
3515 	if (!ret && oact) {
3516 		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3517 		    __put_user(ptr_to_compat(old_ka.sa.sa_handler),
3518 			       &oact->sa_handler) ||
3519 		    __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3520 			       &oact->sa_restorer) ||
3521 		    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3522 		    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3523 			return -EFAULT;
3524 	}
3525 	return ret;
3526 }
3527 #endif
3528 
3529 #ifdef CONFIG_SGETMASK_SYSCALL
3530 
3531 /*
3532  * For backwards compatibility.  Functionality superseded by sigprocmask.
3533  */
3534 SYSCALL_DEFINE0(sgetmask)
3535 {
3536 	/* SMP safe */
3537 	return current->blocked.sig[0];
3538 }
3539 
3540 SYSCALL_DEFINE1(ssetmask, int, newmask)
3541 {
3542 	int old = current->blocked.sig[0];
3543 	sigset_t newset;
3544 
3545 	siginitset(&newset, newmask);
3546 	set_current_blocked(&newset);
3547 
3548 	return old;
3549 }
3550 #endif /* CONFIG_SGETMASK_SYSCALL */
3551 
3552 #ifdef __ARCH_WANT_SYS_SIGNAL
3553 /*
3554  * For backwards compatibility.  Functionality superseded by sigaction.
3555  */
3556 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
3557 {
3558 	struct k_sigaction new_sa, old_sa;
3559 	int ret;
3560 
3561 	new_sa.sa.sa_handler = handler;
3562 	new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
3563 	sigemptyset(&new_sa.sa.sa_mask);
3564 
3565 	ret = do_sigaction(sig, &new_sa, &old_sa);
3566 
3567 	return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
3568 }
3569 #endif /* __ARCH_WANT_SYS_SIGNAL */
3570 
3571 #ifdef __ARCH_WANT_SYS_PAUSE
3572 
3573 SYSCALL_DEFINE0(pause)
3574 {
3575 	while (!signal_pending(current)) {
3576 		__set_current_state(TASK_INTERRUPTIBLE);
3577 		schedule();
3578 	}
3579 	return -ERESTARTNOHAND;
3580 }
3581 
3582 #endif
3583 
3584 static int sigsuspend(sigset_t *set)
3585 {
3586 	current->saved_sigmask = current->blocked;
3587 	set_current_blocked(set);
3588 
3589 	while (!signal_pending(current)) {
3590 		__set_current_state(TASK_INTERRUPTIBLE);
3591 		schedule();
3592 	}
3593 	set_restore_sigmask();
3594 	return -ERESTARTNOHAND;
3595 }
3596 
3597 /**
3598  *  sys_rt_sigsuspend - replace the signal mask for a value with the
3599  *	@unewset value until a signal is received
3600  *  @unewset: new signal mask value
3601  *  @sigsetsize: size of sigset_t type
3602  */
3603 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
3604 {
3605 	sigset_t newset;
3606 
3607 	/* XXX: Don't preclude handling different sized sigset_t's.  */
3608 	if (sigsetsize != sizeof(sigset_t))
3609 		return -EINVAL;
3610 
3611 	if (copy_from_user(&newset, unewset, sizeof(newset)))
3612 		return -EFAULT;
3613 	return sigsuspend(&newset);
3614 }
3615 
3616 #ifdef CONFIG_COMPAT
3617 COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
3618 {
3619 #ifdef __BIG_ENDIAN
3620 	sigset_t newset;
3621 	compat_sigset_t newset32;
3622 
3623 	/* XXX: Don't preclude handling different sized sigset_t's.  */
3624 	if (sigsetsize != sizeof(sigset_t))
3625 		return -EINVAL;
3626 
3627 	if (copy_from_user(&newset32, unewset, sizeof(compat_sigset_t)))
3628 		return -EFAULT;
3629 	sigset_from_compat(&newset, &newset32);
3630 	return sigsuspend(&newset);
3631 #else
3632 	/* on little-endian bitmaps don't care about granularity */
3633 	return sys_rt_sigsuspend((sigset_t __user *)unewset, sigsetsize);
3634 #endif
3635 }
3636 #endif
3637 
3638 #ifdef CONFIG_OLD_SIGSUSPEND
3639 SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
3640 {
3641 	sigset_t blocked;
3642 	siginitset(&blocked, mask);
3643 	return sigsuspend(&blocked);
3644 }
3645 #endif
3646 #ifdef CONFIG_OLD_SIGSUSPEND3
3647 SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask)
3648 {
3649 	sigset_t blocked;
3650 	siginitset(&blocked, mask);
3651 	return sigsuspend(&blocked);
3652 }
3653 #endif
3654 
3655 __weak const char *arch_vma_name(struct vm_area_struct *vma)
3656 {
3657 	return NULL;
3658 }
3659 
3660 void __init signals_init(void)
3661 {
3662 	/* If this check fails, the __ARCH_SI_PREAMBLE_SIZE value is wrong! */
3663 	BUILD_BUG_ON(__ARCH_SI_PREAMBLE_SIZE
3664 		!= offsetof(struct siginfo, _sifields._pad));
3665 
3666 	sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
3667 }
3668 
3669 #ifdef CONFIG_KGDB_KDB
3670 #include <linux/kdb.h>
3671 /*
3672  * kdb_send_sig_info - Allows kdb to send signals without exposing
3673  * signal internals.  This function checks if the required locks are
3674  * available before calling the main signal code, to avoid kdb
3675  * deadlocks.
3676  */
3677 void
3678 kdb_send_sig_info(struct task_struct *t, struct siginfo *info)
3679 {
3680 	static struct task_struct *kdb_prev_t;
3681 	int sig, new_t;
3682 	if (!spin_trylock(&t->sighand->siglock)) {
3683 		kdb_printf("Can't do kill command now.\n"
3684 			   "The sigmask lock is held somewhere else in "
3685 			   "kernel, try again later\n");
3686 		return;
3687 	}
3688 	spin_unlock(&t->sighand->siglock);
3689 	new_t = kdb_prev_t != t;
3690 	kdb_prev_t = t;
3691 	if (t->state != TASK_RUNNING && new_t) {
3692 		kdb_printf("Process is not RUNNING, sending a signal from "
3693 			   "kdb risks deadlock\n"
3694 			   "on the run queue locks. "
3695 			   "The signal has _not_ been sent.\n"
3696 			   "Reissue the kill command if you want to risk "
3697 			   "the deadlock.\n");
3698 		return;
3699 	}
3700 	sig = info->si_signo;
3701 	if (send_sig_info(sig, info, t))
3702 		kdb_printf("Fail to deliver Signal %d to process %d.\n",
3703 			   sig, t->pid);
3704 	else
3705 		kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
3706 }
3707 #endif	/* CONFIG_KGDB_KDB */
3708