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