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