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