blob: aa1fb9f905dbc5d66194218df339c467f04b2f9a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/slab.h>
Paul Gortmaker9984de12011-05-23 14:51:41 -040014#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/init.h>
Ingo Molnar589ee622017-02-04 00:16:44 +010016#include <linux/sched/mm.h>
Ingo Molnar8703e8a2017-02-08 18:51:30 +010017#include <linux/sched/user.h>
Ingo Molnarb17b0152017-02-08 18:51:35 +010018#include <linux/sched/debug.h>
Ingo Molnar29930022017-02-08 18:51:36 +010019#include <linux/sched/task.h>
Ingo Molnar68db0cf2017-02-08 18:51:37 +010020#include <linux/sched/task_stack.h>
Ingo Molnar32ef5512017-02-05 11:48:36 +010021#include <linux/sched/cputime.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/fs.h>
23#include <linux/tty.h>
24#include <linux/binfmts.h>
Alex Kelly179899f2012-10-04 17:15:24 -070025#include <linux/coredump.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/security.h>
27#include <linux/syscalls.h>
28#include <linux/ptrace.h>
Jesper Juhl7ed20e12005-05-01 08:59:14 -070029#include <linux/signal.h>
Davide Libenzifba2afa2007-05-10 22:23:13 -070030#include <linux/signalfd.h>
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +090031#include <linux/ratelimit.h>
Roland McGrath35de2542008-07-25 19:45:51 -070032#include <linux/tracehook.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080033#include <linux/capability.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080034#include <linux/freezer.h>
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -080035#include <linux/pid_namespace.h>
36#include <linux/nsproxy.h>
Serge E. Hallyn6b550f92012-01-10 15:11:37 -080037#include <linux/user_namespace.h>
Srikar Dronamraju0326f5a2012-03-13 23:30:11 +053038#include <linux/uprobes.h>
Al Viro90268432012-12-14 14:47:53 -050039#include <linux/compat.h>
Jesper Derehag2b5faa42013-03-19 20:50:05 +000040#include <linux/cn_proc.h>
Gideon Israel Dsouza52f5684c2014-04-07 15:39:20 -070041#include <linux/compiler.h>
Christoph Hellwig31ea70e2017-06-03 21:01:00 +020042#include <linux/posix-timers.h>
Gideon Israel Dsouza52f5684c2014-04-07 15:39:20 -070043
Masami Hiramatsud1eb6502009-11-24 16:56:45 -050044#define CREATE_TRACE_POINTS
45#include <trace/events/signal.h>
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -080046
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include <asm/param.h>
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080048#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include <asm/unistd.h>
50#include <asm/siginfo.h>
David Howellsd550bbd2012-03-28 18:30:03 +010051#include <asm/cacheflush.h>
Al Viroe1396062006-05-25 10:19:47 -040052#include "audit.h" /* audit_signal_info() */
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
54/*
55 * SLAB caches for signal bits.
56 */
57
Christoph Lametere18b8902006-12-06 20:33:20 -080058static struct kmem_cache *sigqueue_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +090060int print_fatal_signals __read_mostly;
61
Roland McGrath35de2542008-07-25 19:45:51 -070062static void __user *sig_handler(struct task_struct *t, int sig)
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070063{
Roland McGrath35de2542008-07-25 19:45:51 -070064 return t->sighand->action[sig - 1].sa.sa_handler;
65}
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070066
Roland McGrath35de2542008-07-25 19:45:51 -070067static int sig_handler_ignored(void __user *handler, int sig)
68{
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070069 /* Is it explicitly or implicitly ignored? */
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070070 return handler == SIG_IGN ||
71 (handler == SIG_DFL && sig_kernel_ignore(sig));
72}
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
Oleg Nesterovdef8cf72012-03-23 15:02:45 -070074static int sig_task_ignored(struct task_struct *t, int sig, bool force)
Linus Torvalds1da177e2005-04-16 15:20:36 -070075{
Roland McGrath35de2542008-07-25 19:45:51 -070076 void __user *handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Oleg Nesterovf008faf2009-04-02 16:58:02 -070078 handler = sig_handler(t, sig);
79
80 if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
Oleg Nesterovdef8cf72012-03-23 15:02:45 -070081 handler == SIG_DFL && !force)
Oleg Nesterovf008faf2009-04-02 16:58:02 -070082 return 1;
83
84 return sig_handler_ignored(handler, sig);
85}
86
Oleg Nesterovdef8cf72012-03-23 15:02:45 -070087static int sig_ignored(struct task_struct *t, int sig, bool force)
Oleg Nesterovf008faf2009-04-02 16:58:02 -070088{
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 /*
90 * Blocked signals are never ignored, since the
91 * signal handler may change by the time it is
92 * unblocked.
93 */
Roland McGrath325d22d2007-11-12 15:41:55 -080094 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 return 0;
96
Oleg Nesterovdef8cf72012-03-23 15:02:45 -070097 if (!sig_task_ignored(t, sig, force))
Roland McGrath35de2542008-07-25 19:45:51 -070098 return 0;
99
100 /*
101 * Tracers may want to know about even ignored signals.
102 */
Tejun Heoa288eec2011-06-17 16:50:37 +0200103 return !t->ptrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104}
105
106/*
107 * Re-calculate pending state from the set of locally pending
108 * signals, globally pending signals, and blocked signals.
109 */
110static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
111{
112 unsigned long ready;
113 long i;
114
115 switch (_NSIG_WORDS) {
116 default:
117 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
118 ready |= signal->sig[i] &~ blocked->sig[i];
119 break;
120
121 case 4: ready = signal->sig[3] &~ blocked->sig[3];
122 ready |= signal->sig[2] &~ blocked->sig[2];
123 ready |= signal->sig[1] &~ blocked->sig[1];
124 ready |= signal->sig[0] &~ blocked->sig[0];
125 break;
126
127 case 2: ready = signal->sig[1] &~ blocked->sig[1];
128 ready |= signal->sig[0] &~ blocked->sig[0];
129 break;
130
131 case 1: ready = signal->sig[0] &~ blocked->sig[0];
132 }
133 return ready != 0;
134}
135
136#define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
137
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700138static int recalc_sigpending_tsk(struct task_struct *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139{
Tejun Heo3759a0d2011-06-02 11:14:00 +0200140 if ((t->jobctl & JOBCTL_PENDING_MASK) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 PENDING(&t->pending, &t->blocked) ||
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700142 PENDING(&t->signal->shared_pending, &t->blocked)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 set_tsk_thread_flag(t, TIF_SIGPENDING);
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700144 return 1;
145 }
Roland McGrathb74d0de2007-06-06 03:59:00 -0700146 /*
147 * We must never clear the flag in another thread, or in current
148 * when it's possible the current syscall is returning -ERESTART*.
149 * So we don't clear it here, and only callers who know they should do.
150 */
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700151 return 0;
152}
153
154/*
155 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
156 * This is superfluous when called on current, the wakeup is a harmless no-op.
157 */
158void recalc_sigpending_and_wake(struct task_struct *t)
159{
160 if (recalc_sigpending_tsk(t))
161 signal_wake_up(t, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162}
163
164void recalc_sigpending(void)
165{
Tejun Heodd1d6772011-06-02 11:14:00 +0200166 if (!recalc_sigpending_tsk(current) && !freezing(current))
Roland McGrathb74d0de2007-06-06 03:59:00 -0700167 clear_thread_flag(TIF_SIGPENDING);
168
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169}
170
171/* Given the mask, find the first available signal that should be serviced. */
172
Linus Torvaldsa27341c2010-03-02 08:36:46 -0800173#define SYNCHRONOUS_MASK \
174 (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
Will Drewrya0727e82012-04-12 16:48:00 -0500175 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
Linus Torvaldsa27341c2010-03-02 08:36:46 -0800176
Davide Libenzifba2afa2007-05-10 22:23:13 -0700177int next_signal(struct sigpending *pending, sigset_t *mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178{
179 unsigned long i, *s, *m, x;
180 int sig = 0;
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +0900181
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 s = pending->signal.sig;
183 m = mask->sig;
Linus Torvaldsa27341c2010-03-02 08:36:46 -0800184
185 /*
186 * Handle the first word specially: it contains the
187 * synchronous signals that need to be dequeued first.
188 */
189 x = *s &~ *m;
190 if (x) {
191 if (x & SYNCHRONOUS_MASK)
192 x &= SYNCHRONOUS_MASK;
193 sig = ffz(~x) + 1;
194 return sig;
195 }
196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 switch (_NSIG_WORDS) {
198 default:
Linus Torvaldsa27341c2010-03-02 08:36:46 -0800199 for (i = 1; i < _NSIG_WORDS; ++i) {
200 x = *++s &~ *++m;
201 if (!x)
202 continue;
203 sig = ffz(~x) + i*_NSIG_BPW + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 break;
Linus Torvaldsa27341c2010-03-02 08:36:46 -0800205 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 break;
207
Linus Torvaldsa27341c2010-03-02 08:36:46 -0800208 case 2:
209 x = s[1] &~ m[1];
210 if (!x)
211 break;
212 sig = ffz(~x) + _NSIG_BPW + 1;
213 break;
214
215 case 1:
216 /* Nothing to do */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 break;
218 }
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +0900219
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 return sig;
221}
222
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +0900223static inline void print_dropped_signal(int sig)
224{
225 static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
226
227 if (!print_fatal_signals)
228 return;
229
230 if (!__ratelimit(&ratelimit_state))
231 return;
232
Wang Xiaoqiang747800e2016-05-23 16:23:59 -0700233 pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +0900234 current->comm, current->pid, sig);
235}
236
Tejun Heoe5c1902e2011-03-23 10:37:00 +0100237/**
Tejun Heo7dd3db52011-06-02 11:14:00 +0200238 * task_set_jobctl_pending - set jobctl pending bits
239 * @task: target task
240 * @mask: pending bits to set
241 *
242 * Clear @mask from @task->jobctl. @mask must be subset of
243 * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
244 * %JOBCTL_TRAPPING. If stop signo is being set, the existing signo is
245 * cleared. If @task is already being killed or exiting, this function
246 * becomes noop.
247 *
248 * CONTEXT:
249 * Must be called with @task->sighand->siglock held.
250 *
251 * RETURNS:
252 * %true if @mask is set, %false if made noop because @task was dying.
253 */
Palmer Dabbeltb76808e2015-04-30 21:19:57 -0700254bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
Tejun Heo7dd3db52011-06-02 11:14:00 +0200255{
256 BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
257 JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
258 BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
259
260 if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
261 return false;
262
263 if (mask & JOBCTL_STOP_SIGMASK)
264 task->jobctl &= ~JOBCTL_STOP_SIGMASK;
265
266 task->jobctl |= mask;
267 return true;
268}
269
270/**
Tejun Heoa8f072c2011-06-02 11:13:59 +0200271 * task_clear_jobctl_trapping - clear jobctl trapping bit
Tejun Heod79fdd62011-03-23 10:37:00 +0100272 * @task: target task
273 *
Tejun Heoa8f072c2011-06-02 11:13:59 +0200274 * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
275 * Clear it and wake up the ptracer. Note that we don't need any further
276 * locking. @task->siglock guarantees that @task->parent points to the
277 * ptracer.
Tejun Heod79fdd62011-03-23 10:37:00 +0100278 *
279 * CONTEXT:
280 * Must be called with @task->sighand->siglock held.
281 */
Tejun Heo73ddff22011-06-14 11:20:14 +0200282void task_clear_jobctl_trapping(struct task_struct *task)
Tejun Heod79fdd62011-03-23 10:37:00 +0100283{
Tejun Heoa8f072c2011-06-02 11:13:59 +0200284 if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
285 task->jobctl &= ~JOBCTL_TRAPPING;
Oleg Nesterov650226b2014-06-06 14:36:44 -0700286 smp_mb(); /* advised by wake_up_bit() */
Tejun Heo62c124f2011-06-02 11:14:00 +0200287 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
Tejun Heod79fdd62011-03-23 10:37:00 +0100288 }
289}
290
291/**
Tejun Heo3759a0d2011-06-02 11:14:00 +0200292 * task_clear_jobctl_pending - clear jobctl pending bits
Tejun Heoe5c1902e2011-03-23 10:37:00 +0100293 * @task: target task
Tejun Heo3759a0d2011-06-02 11:14:00 +0200294 * @mask: pending bits to clear
Tejun Heoe5c1902e2011-03-23 10:37:00 +0100295 *
Tejun Heo3759a0d2011-06-02 11:14:00 +0200296 * Clear @mask from @task->jobctl. @mask must be subset of
297 * %JOBCTL_PENDING_MASK. If %JOBCTL_STOP_PENDING is being cleared, other
298 * STOP bits are cleared together.
Tejun Heoe5c1902e2011-03-23 10:37:00 +0100299 *
Tejun Heo6dfca322011-06-02 11:14:00 +0200300 * If clearing of @mask leaves no stop or trap pending, this function calls
301 * task_clear_jobctl_trapping().
Tejun Heoe5c1902e2011-03-23 10:37:00 +0100302 *
303 * CONTEXT:
304 * Must be called with @task->sighand->siglock held.
305 */
Palmer Dabbeltb76808e2015-04-30 21:19:57 -0700306void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
Tejun Heoe5c1902e2011-03-23 10:37:00 +0100307{
Tejun Heo3759a0d2011-06-02 11:14:00 +0200308 BUG_ON(mask & ~JOBCTL_PENDING_MASK);
309
310 if (mask & JOBCTL_STOP_PENDING)
311 mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
312
313 task->jobctl &= ~mask;
Tejun Heo6dfca322011-06-02 11:14:00 +0200314
315 if (!(task->jobctl & JOBCTL_PENDING_MASK))
316 task_clear_jobctl_trapping(task);
Tejun Heoe5c1902e2011-03-23 10:37:00 +0100317}
318
319/**
320 * task_participate_group_stop - participate in a group stop
321 * @task: task participating in a group stop
322 *
Tejun Heoa8f072c2011-06-02 11:13:59 +0200323 * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
Tejun Heo39efa3e2011-03-23 10:37:00 +0100324 * Group stop states are cleared and the group stop count is consumed if
Tejun Heoa8f072c2011-06-02 11:13:59 +0200325 * %JOBCTL_STOP_CONSUME was set. If the consumption completes the group
Tejun Heo39efa3e2011-03-23 10:37:00 +0100326 * stop, the appropriate %SIGNAL_* flags are set.
Tejun Heoe5c1902e2011-03-23 10:37:00 +0100327 *
328 * CONTEXT:
329 * Must be called with @task->sighand->siglock held.
Tejun Heo244056f2011-03-23 10:37:01 +0100330 *
331 * RETURNS:
332 * %true if group stop completion should be notified to the parent, %false
333 * otherwise.
Tejun Heoe5c1902e2011-03-23 10:37:00 +0100334 */
335static bool task_participate_group_stop(struct task_struct *task)
336{
337 struct signal_struct *sig = task->signal;
Tejun Heoa8f072c2011-06-02 11:13:59 +0200338 bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
Tejun Heoe5c1902e2011-03-23 10:37:00 +0100339
Tejun Heoa8f072c2011-06-02 11:13:59 +0200340 WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
Tejun Heo39efa3e2011-03-23 10:37:00 +0100341
Tejun Heo3759a0d2011-06-02 11:14:00 +0200342 task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
Tejun Heoe5c1902e2011-03-23 10:37:00 +0100343
344 if (!consume)
345 return false;
346
347 if (!WARN_ON_ONCE(sig->group_stop_count == 0))
348 sig->group_stop_count--;
349
Tejun Heo244056f2011-03-23 10:37:01 +0100350 /*
351 * Tell the caller to notify completion iff we are entering into a
352 * fresh group stop. Read comment in do_signal_stop() for details.
353 */
354 if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
Jamie Iles2d39b3c2017-01-10 16:57:54 -0800355 signal_set_stop_flags(sig, SIGNAL_STOP_STOPPED);
Tejun Heoe5c1902e2011-03-23 10:37:00 +0100356 return true;
357 }
358 return false;
359}
360
David Howellsc69e8d92008-11-14 10:39:19 +1100361/*
362 * allocate a new signal queue record
363 * - this may be called without locks if and only if t == current, otherwise an
Randy Dunlap5aba0852011-04-04 14:59:31 -0700364 * appropriate lock must be held to stop the target task from exiting
David Howellsc69e8d92008-11-14 10:39:19 +1100365 */
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +0900366static struct sigqueue *
367__sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368{
369 struct sigqueue *q = NULL;
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800370 struct user_struct *user;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800372 /*
Thomas Gleixner7cf7db82009-12-10 00:53:21 +0000373 * Protect access to @t credentials. This can go away when all
374 * callers hold rcu read lock.
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800375 */
Thomas Gleixner7cf7db82009-12-10 00:53:21 +0000376 rcu_read_lock();
David Howellsd84f4f92008-11-14 10:39:23 +1100377 user = get_uid(__task_cred(t)->user);
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800378 atomic_inc(&user->sigpending);
Thomas Gleixner7cf7db82009-12-10 00:53:21 +0000379 rcu_read_unlock();
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +0900380
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 if (override_rlimit ||
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800382 atomic_read(&user->sigpending) <=
Jiri Slaby78d7d402010-03-05 13:42:54 -0800383 task_rlimit(t, RLIMIT_SIGPENDING)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 q = kmem_cache_alloc(sigqueue_cachep, flags);
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +0900385 } else {
386 print_dropped_signal(sig);
387 }
388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 if (unlikely(q == NULL)) {
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800390 atomic_dec(&user->sigpending);
David Howellsd84f4f92008-11-14 10:39:23 +1100391 free_uid(user);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 } else {
393 INIT_LIST_HEAD(&q->list);
394 q->flags = 0;
David Howellsd84f4f92008-11-14 10:39:23 +1100395 q->user = user;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 }
David Howellsd84f4f92008-11-14 10:39:23 +1100397
398 return q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399}
400
Andrew Morton514a01b2006-02-03 03:04:41 -0800401static void __sigqueue_free(struct sigqueue *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402{
403 if (q->flags & SIGQUEUE_PREALLOC)
404 return;
405 atomic_dec(&q->user->sigpending);
406 free_uid(q->user);
407 kmem_cache_free(sigqueue_cachep, q);
408}
409
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800410void flush_sigqueue(struct sigpending *queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411{
412 struct sigqueue *q;
413
414 sigemptyset(&queue->signal);
415 while (!list_empty(&queue->list)) {
416 q = list_entry(queue->list.next, struct sigqueue , list);
417 list_del_init(&q->list);
418 __sigqueue_free(q);
419 }
420}
421
422/*
Oleg Nesterov9e7c8f82015-06-04 16:22:16 -0400423 * Flush all pending signals for this kthread.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 */
Oleg Nesterovc81addc2006-03-28 16:11:17 -0800425void flush_signals(struct task_struct *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426{
427 unsigned long flags;
428
429 spin_lock_irqsave(&t->sighand->siglock, flags);
Oleg Nesterov9e7c8f82015-06-04 16:22:16 -0400430 clear_tsk_thread_flag(t, TIF_SIGPENDING);
431 flush_sigqueue(&t->pending);
432 flush_sigqueue(&t->signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 spin_unlock_irqrestore(&t->sighand->siglock, flags);
434}
435
Nicolas Pitrebaa73d92016-11-11 00:10:10 -0500436#ifdef CONFIG_POSIX_TIMERS
Oleg Nesterovcbaffba2008-05-26 20:55:42 +0400437static void __flush_itimer_signals(struct sigpending *pending)
438{
439 sigset_t signal, retain;
440 struct sigqueue *q, *n;
441
442 signal = pending->signal;
443 sigemptyset(&retain);
444
445 list_for_each_entry_safe(q, n, &pending->list, list) {
446 int sig = q->info.si_signo;
447
448 if (likely(q->info.si_code != SI_TIMER)) {
449 sigaddset(&retain, sig);
450 } else {
451 sigdelset(&signal, sig);
452 list_del_init(&q->list);
453 __sigqueue_free(q);
454 }
455 }
456
457 sigorsets(&pending->signal, &signal, &retain);
458}
459
460void flush_itimer_signals(void)
461{
462 struct task_struct *tsk = current;
463 unsigned long flags;
464
465 spin_lock_irqsave(&tsk->sighand->siglock, flags);
466 __flush_itimer_signals(&tsk->pending);
467 __flush_itimer_signals(&tsk->signal->shared_pending);
468 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
469}
Nicolas Pitrebaa73d92016-11-11 00:10:10 -0500470#endif
Oleg Nesterovcbaffba2008-05-26 20:55:42 +0400471
Oleg Nesterov10ab8252007-05-09 02:34:37 -0700472void ignore_signals(struct task_struct *t)
473{
474 int i;
475
476 for (i = 0; i < _NSIG; ++i)
477 t->sighand->action[i].sa.sa_handler = SIG_IGN;
478
479 flush_signals(t);
480}
481
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 * Flush all handlers for a task.
484 */
485
486void
487flush_signal_handlers(struct task_struct *t, int force_default)
488{
489 int i;
490 struct k_sigaction *ka = &t->sighand->action[0];
491 for (i = _NSIG ; i != 0 ; i--) {
492 if (force_default || ka->sa.sa_handler != SIG_IGN)
493 ka->sa.sa_handler = SIG_DFL;
494 ka->sa.sa_flags = 0;
Andrew Morton522cff12013-03-13 14:59:34 -0700495#ifdef __ARCH_HAS_SA_RESTORER
Kees Cook2ca39522013-03-13 14:59:33 -0700496 ka->sa.sa_restorer = NULL;
497#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 sigemptyset(&ka->sa.sa_mask);
499 ka++;
500 }
501}
502
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200503int unhandled_signal(struct task_struct *tsk, int sig)
504{
Roland McGrath445a91d2008-07-25 19:45:52 -0700505 void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
Serge E. Hallynb460cbc2007-10-18 23:39:52 -0700506 if (is_global_init(tsk))
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200507 return 1;
Roland McGrath445a91d2008-07-25 19:45:52 -0700508 if (handler != SIG_IGN && handler != SIG_DFL)
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200509 return 0;
Tejun Heoa288eec2011-06-17 16:50:37 +0200510 /* if ptraced, let the tracer determine */
511 return !tsk->ptrace;
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200512}
513
Eric W. Biederman57db7e42017-06-13 04:31:16 -0500514static void collect_signal(int sig, struct sigpending *list, siginfo_t *info,
515 bool *resched_timer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516{
517 struct sigqueue *q, *first = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 /*
520 * Collect the siginfo appropriate to this signal. Check if
521 * there is another siginfo for the same signal.
522 */
523 list_for_each_entry(q, &list->list, list) {
524 if (q->info.si_signo == sig) {
Oleg Nesterovd4434202008-07-25 01:47:28 -0700525 if (first)
526 goto still_pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 first = q;
528 }
529 }
Oleg Nesterovd4434202008-07-25 01:47:28 -0700530
531 sigdelset(&list->signal, sig);
532
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 if (first) {
Oleg Nesterovd4434202008-07-25 01:47:28 -0700534still_pending:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 list_del_init(&first->list);
536 copy_siginfo(info, &first->info);
Eric W. Biederman57db7e42017-06-13 04:31:16 -0500537
538 *resched_timer =
539 (first->flags & SIGQUEUE_PREALLOC) &&
540 (info->si_code == SI_TIMER) &&
541 (info->si_sys_private);
542
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 __sigqueue_free(first);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 } else {
Randy Dunlap5aba0852011-04-04 14:59:31 -0700545 /*
546 * Ok, it wasn't in the queue. This must be
547 * a fast-pathed signal or we must have been
548 * out of queue space. So zero out the info.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 info->si_signo = sig;
551 info->si_errno = 0;
Oleg Nesterov7486e5d2009-12-15 16:47:24 -0800552 info->si_code = SI_USER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 info->si_pid = 0;
554 info->si_uid = 0;
555 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556}
557
558static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
Eric W. Biederman57db7e42017-06-13 04:31:16 -0500559 siginfo_t *info, bool *resched_timer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560{
Roland McGrath27d91e02006-09-29 02:00:31 -0700561 int sig = next_signal(pending, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
Oleg Nesterov2e01fab2015-11-06 16:32:19 -0800563 if (sig)
Eric W. Biederman57db7e42017-06-13 04:31:16 -0500564 collect_signal(sig, pending, info, resched_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 return sig;
566}
567
568/*
Randy Dunlap5aba0852011-04-04 14:59:31 -0700569 * Dequeue a signal and return the element to the caller, which is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 * expected to free it.
571 *
572 * All callers have to hold the siglock.
573 */
574int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
575{
Eric W. Biederman57db7e42017-06-13 04:31:16 -0500576 bool resched_timer = false;
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700577 int signr;
Benjamin Herrenschmidtcaec4e82007-06-12 08:16:18 +1000578
579 /* We only dequeue private signals from ourselves, we don't let
580 * signalfd steal them
581 */
Eric W. Biederman57db7e42017-06-13 04:31:16 -0500582 signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer);
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800583 if (!signr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 signr = __dequeue_signal(&tsk->signal->shared_pending,
Eric W. Biederman57db7e42017-06-13 04:31:16 -0500585 mask, info, &resched_timer);
Nicolas Pitrebaa73d92016-11-11 00:10:10 -0500586#ifdef CONFIG_POSIX_TIMERS
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800587 /*
588 * itimer signal ?
589 *
590 * itimers are process shared and we restart periodic
591 * itimers in the signal delivery path to prevent DoS
592 * attacks in the high resolution timer case. This is
Randy Dunlap5aba0852011-04-04 14:59:31 -0700593 * compliant with the old way of self-restarting
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800594 * itimers, as the SIGALRM is a legacy signal and only
595 * queued once. Changing the restart behaviour to
596 * restart the timer in the signal dequeue path is
597 * reducing the timer noise on heavy loaded !highres
598 * systems too.
599 */
600 if (unlikely(signr == SIGALRM)) {
601 struct hrtimer *tmr = &tsk->signal->real_timer;
602
603 if (!hrtimer_is_queued(tmr) &&
Thomas Gleixner2456e852016-12-25 11:38:40 +0100604 tsk->signal->it_real_incr != 0) {
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800605 hrtimer_forward(tmr, tmr->base->get_time(),
606 tsk->signal->it_real_incr);
607 hrtimer_restart(tmr);
608 }
609 }
Nicolas Pitrebaa73d92016-11-11 00:10:10 -0500610#endif
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800611 }
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700612
Davide Libenzib8fceee2007-09-20 12:40:16 -0700613 recalc_sigpending();
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700614 if (!signr)
615 return 0;
616
617 if (unlikely(sig_kernel_stop(signr))) {
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800618 /*
619 * Set a marker that we have dequeued a stop signal. Our
620 * caller might release the siglock and then the pending
621 * stop signal it is about to process is no longer in the
622 * pending bitmasks, but must still be cleared by a SIGCONT
623 * (and overruled by a SIGKILL). So those cases clear this
624 * shared flag after we've set it. Note that this flag may
625 * remain set after the signal we return is ignored or
626 * handled. That doesn't matter because its only purpose
627 * is to alert stop-signal processing code when another
628 * processor has come along and cleared the flag.
629 */
Tejun Heoa8f072c2011-06-02 11:13:59 +0200630 current->jobctl |= JOBCTL_STOP_DEQUEUED;
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800631 }
Nicolas Pitrebaa73d92016-11-11 00:10:10 -0500632#ifdef CONFIG_POSIX_TIMERS
Eric W. Biederman57db7e42017-06-13 04:31:16 -0500633 if (resched_timer) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 /*
635 * Release the siglock to ensure proper locking order
636 * of timer locks outside of siglocks. Note, we leave
637 * irqs disabled here, since the posix-timers code is
638 * about to disable them again anyway.
639 */
640 spin_unlock(&tsk->sighand->siglock);
Thomas Gleixner96fe3b02017-05-30 23:15:46 +0200641 posixtimer_rearm(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 spin_lock(&tsk->sighand->siglock);
643 }
Nicolas Pitrebaa73d92016-11-11 00:10:10 -0500644#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 return signr;
646}
647
648/*
649 * Tell a process that it has a new active signal..
650 *
651 * NOTE! we rely on the previous spin_lock to
652 * lock interrupts for us! We can only be called with
653 * "siglock" held, and the local interrupt must
654 * have been disabled when that got acquired!
655 *
656 * No need to set need_resched since signal event passing
657 * goes through ->blocked
658 */
Oleg Nesterov910ffdb2013-01-21 20:47:41 +0100659void signal_wake_up_state(struct task_struct *t, unsigned int state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 set_tsk_thread_flag(t, TIF_SIGPENDING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 /*
Oleg Nesterov910ffdb2013-01-21 20:47:41 +0100663 * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500664 * case. We don't check t->state here because there is a race with it
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 * executing another processor and just now entering stopped state.
666 * By using wake_up_state, we ensure the process will wake up and
667 * handle its death signal.
668 */
Oleg Nesterov910ffdb2013-01-21 20:47:41 +0100669 if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 kick_process(t);
671}
672
673/*
674 * Remove signals in mask from the pending set and queue.
675 * Returns 1 if any signals were found.
676 *
677 * All callers must be holding the siglock.
George Anzinger71fabd5e2006-01-08 01:02:48 -0800678 */
Oleg Nesterovc09c1442014-06-06 14:36:50 -0700679static int flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
George Anzinger71fabd5e2006-01-08 01:02:48 -0800680{
681 struct sigqueue *q, *n;
682 sigset_t m;
683
684 sigandsets(&m, mask, &s->signal);
685 if (sigisemptyset(&m))
686 return 0;
687
Oleg Nesterov702a5072011-04-27 22:01:27 +0200688 sigandnsets(&s->signal, &s->signal, mask);
George Anzinger71fabd5e2006-01-08 01:02:48 -0800689 list_for_each_entry_safe(q, n, &s->list, list) {
690 if (sigismember(mask, q->info.si_signo)) {
691 list_del_init(&q->list);
692 __sigqueue_free(q);
693 }
694 }
695 return 1;
696}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
Oleg Nesterov614c5172009-12-15 16:47:22 -0800698static inline int is_si_special(const struct siginfo *info)
699{
700 return info <= SEND_SIG_FORCED;
701}
702
703static inline bool si_fromuser(const struct siginfo *info)
704{
705 return info == SEND_SIG_NOINFO ||
706 (!is_si_special(info) && SI_FROMUSER(info));
707}
708
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709/*
Serge E. Hallyn39fd3392011-03-23 16:43:19 -0700710 * called with RCU read lock from check_kill_permission()
711 */
712static int kill_ok_by_cred(struct task_struct *t)
713{
714 const struct cred *cred = current_cred();
715 const struct cred *tcred = __task_cred(t);
716
Eric W. Biederman5af66202012-03-03 20:21:47 -0800717 if (uid_eq(cred->euid, tcred->suid) ||
718 uid_eq(cred->euid, tcred->uid) ||
719 uid_eq(cred->uid, tcred->suid) ||
720 uid_eq(cred->uid, tcred->uid))
Serge E. Hallyn39fd3392011-03-23 16:43:19 -0700721 return 1;
722
Eric W. Biedermanc4a4d602011-11-16 23:15:31 -0800723 if (ns_capable(tcred->user_ns, CAP_KILL))
Serge E. Hallyn39fd3392011-03-23 16:43:19 -0700724 return 1;
725
726 return 0;
727}
728
729/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 * Bad permissions for sending the signal
David Howells694f6902010-08-04 16:59:14 +0100731 * - the caller must hold the RCU read lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 */
733static int check_kill_permission(int sig, struct siginfo *info,
734 struct task_struct *t)
735{
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700736 struct pid *sid;
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700737 int error;
738
Jesper Juhl7ed20e12005-05-01 08:59:14 -0700739 if (!valid_signal(sig))
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700740 return -EINVAL;
741
Oleg Nesterov614c5172009-12-15 16:47:22 -0800742 if (!si_fromuser(info))
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700743 return 0;
744
745 error = audit_signal_info(sig, t); /* Let audit system see the signal */
746 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 return error;
Amy Griffise54dc242007-03-29 18:01:04 -0400748
Oleg Nesterov065add32010-05-26 14:42:54 -0700749 if (!same_thread_group(current, t) &&
Serge E. Hallyn39fd3392011-03-23 16:43:19 -0700750 !kill_ok_by_cred(t)) {
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700751 switch (sig) {
752 case SIGCONT:
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700753 sid = task_session(t);
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700754 /*
755 * We don't return the error if sid == NULL. The
756 * task was unhashed, the caller must notice this.
757 */
758 if (!sid || sid == task_session(current))
759 break;
760 default:
761 return -EPERM;
762 }
763 }
Steve Grubbc2f0c7c2005-05-06 12:38:39 +0100764
Amy Griffise54dc242007-03-29 18:01:04 -0400765 return security_task_kill(t, info, sig, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766}
767
Tejun Heofb1d9102011-06-14 11:20:17 +0200768/**
769 * ptrace_trap_notify - schedule trap to notify ptracer
770 * @t: tracee wanting to notify tracer
771 *
772 * This function schedules sticky ptrace trap which is cleared on the next
773 * TRAP_STOP to notify ptracer of an event. @t must have been seized by
774 * ptracer.
775 *
Tejun Heo544b2c92011-06-14 11:20:18 +0200776 * If @t is running, STOP trap will be taken. If trapped for STOP and
777 * ptracer is listening for events, tracee is woken up so that it can
778 * re-trap for the new event. If trapped otherwise, STOP trap will be
779 * eventually taken without returning to userland after the existing traps
780 * are finished by PTRACE_CONT.
Tejun Heofb1d9102011-06-14 11:20:17 +0200781 *
782 * CONTEXT:
783 * Must be called with @task->sighand->siglock held.
784 */
785static void ptrace_trap_notify(struct task_struct *t)
786{
787 WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
788 assert_spin_locked(&t->sighand->siglock);
789
790 task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
Oleg Nesterov910ffdb2013-01-21 20:47:41 +0100791 ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
Tejun Heofb1d9102011-06-14 11:20:17 +0200792}
793
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794/*
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700795 * Handle magic process-wide effects of stop/continue signals. Unlike
796 * the signal actions, these happen immediately at signal-generation
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 * time regardless of blocking, ignoring, or handling. This does the
798 * actual continuing for SIGCONT, but not the actual stopping for stop
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700799 * signals. The process stop is done as a signal action for SIG_DFL.
800 *
801 * Returns true if the signal should be actually delivered, otherwise
802 * it should be dropped.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 */
Oleg Nesterov403bad72013-04-30 15:28:10 -0700804static bool prepare_signal(int sig, struct task_struct *p, bool force)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805{
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700806 struct signal_struct *signal = p->signal;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 struct task_struct *t;
Oleg Nesterov9490592f2014-06-06 14:36:48 -0700808 sigset_t flush;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
Oleg Nesterov403bad72013-04-30 15:28:10 -0700810 if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
Oleg Nesterov5fa534c2015-11-06 16:32:31 -0800811 if (!(signal->flags & SIGNAL_GROUP_EXIT))
Oleg Nesterov403bad72013-04-30 15:28:10 -0700812 return sig == SIGKILL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 /*
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700814 * The process is in the middle of dying, nothing to do.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 */
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700816 } else if (sig_kernel_stop(sig)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 /*
818 * This is a stop signal. Remove SIGCONT from all queues.
819 */
Oleg Nesterov9490592f2014-06-06 14:36:48 -0700820 siginitset(&flush, sigmask(SIGCONT));
Oleg Nesterovc09c1442014-06-06 14:36:50 -0700821 flush_sigqueue_mask(&flush, &signal->shared_pending);
Oleg Nesterov9490592f2014-06-06 14:36:48 -0700822 for_each_thread(p, t)
Oleg Nesterovc09c1442014-06-06 14:36:50 -0700823 flush_sigqueue_mask(&flush, &t->pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 } else if (sig == SIGCONT) {
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700825 unsigned int why;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 /*
Oleg Nesterov1deac632011-04-01 20:11:50 +0200827 * Remove all stop signals from all queues, wake all threads.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 */
Oleg Nesterov9490592f2014-06-06 14:36:48 -0700829 siginitset(&flush, SIG_KERNEL_STOP_MASK);
Oleg Nesterovc09c1442014-06-06 14:36:50 -0700830 flush_sigqueue_mask(&flush, &signal->shared_pending);
Oleg Nesterov9490592f2014-06-06 14:36:48 -0700831 for_each_thread(p, t) {
Oleg Nesterovc09c1442014-06-06 14:36:50 -0700832 flush_sigqueue_mask(&flush, &t->pending);
Tejun Heo3759a0d2011-06-02 11:14:00 +0200833 task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
Tejun Heofb1d9102011-06-14 11:20:17 +0200834 if (likely(!(t->ptrace & PT_SEIZED)))
835 wake_up_state(t, __TASK_STOPPED);
836 else
837 ptrace_trap_notify(t);
Oleg Nesterov9490592f2014-06-06 14:36:48 -0700838 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700840 /*
841 * Notify the parent with CLD_CONTINUED if we were stopped.
842 *
843 * If we were in the middle of a group stop, we pretend it
844 * was already finished, and then continued. Since SIGCHLD
845 * doesn't queue we report only CLD_STOPPED, as if the next
846 * CLD_CONTINUED was dropped.
847 */
848 why = 0;
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700849 if (signal->flags & SIGNAL_STOP_STOPPED)
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700850 why |= SIGNAL_CLD_CONTINUED;
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700851 else if (signal->group_stop_count)
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700852 why |= SIGNAL_CLD_STOPPED;
853
854 if (why) {
Oleg Nesterov021e1ae2008-04-30 00:53:00 -0700855 /*
Roland McGrathae6d2ed2009-09-23 15:56:53 -0700856 * The first thread which returns from do_signal_stop()
Oleg Nesterov021e1ae2008-04-30 00:53:00 -0700857 * will take ->siglock, notice SIGNAL_CLD_MASK, and
858 * notify its parent. See get_signal_to_deliver().
859 */
Jamie Iles2d39b3c2017-01-10 16:57:54 -0800860 signal_set_stop_flags(signal, why | SIGNAL_STOP_CONTINUED);
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700861 signal->group_stop_count = 0;
862 signal->group_exit_code = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 }
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700865
Oleg Nesterovdef8cf72012-03-23 15:02:45 -0700866 return !sig_ignored(p, sig, force);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867}
868
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700869/*
870 * Test if P wants to take SIG. After we've checked all threads with this,
871 * it's equivalent to finding no threads not blocking SIG. Any threads not
872 * blocking SIG were ruled out because they are not running and already
873 * have pending signals. Such threads will dequeue from the shared queue
874 * as soon as they're available, so putting the signal on the shared queue
875 * will be equivalent to sending it to one such thread.
876 */
877static inline int wants_signal(int sig, struct task_struct *p)
878{
879 if (sigismember(&p->blocked, sig))
880 return 0;
881 if (p->flags & PF_EXITING)
882 return 0;
883 if (sig == SIGKILL)
884 return 1;
885 if (task_is_stopped_or_traced(p))
886 return 0;
887 return task_curr(p) || !signal_pending(p);
888}
889
Oleg Nesterov5fcd8352008-04-30 00:52:55 -0700890static void complete_signal(int sig, struct task_struct *p, int group)
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700891{
892 struct signal_struct *signal = p->signal;
893 struct task_struct *t;
894
895 /*
896 * Now find a thread we can wake up to take the signal off the queue.
897 *
898 * If the main thread wants the signal, it gets first crack.
899 * Probably the least surprising to the average bear.
900 */
901 if (wants_signal(sig, p))
902 t = p;
Oleg Nesterov5fcd8352008-04-30 00:52:55 -0700903 else if (!group || thread_group_empty(p))
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700904 /*
905 * There is just one thread and it does not need to be woken.
906 * It will dequeue unblocked signals before it runs again.
907 */
908 return;
909 else {
910 /*
911 * Otherwise try to find a suitable thread.
912 */
913 t = signal->curr_target;
914 while (!wants_signal(sig, t)) {
915 t = next_thread(t);
916 if (t == signal->curr_target)
917 /*
918 * No thread needs to be woken.
919 * Any eligible threads will see
920 * the signal in the queue soon.
921 */
922 return;
923 }
924 signal->curr_target = t;
925 }
926
927 /*
928 * Found a killable thread. If the signal will be fatal,
929 * then start taking the whole group down immediately.
930 */
Oleg Nesterovfae5fa42008-04-30 00:53:03 -0700931 if (sig_fatal(p, sig) &&
932 !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700933 !sigismember(&t->real_blocked, sig) &&
Tejun Heoa288eec2011-06-17 16:50:37 +0200934 (sig == SIGKILL || !t->ptrace)) {
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700935 /*
936 * This signal will be fatal to the whole group.
937 */
938 if (!sig_kernel_coredump(sig)) {
939 /*
940 * Start a group exit and wake everybody up.
941 * This way we don't have other threads
942 * running and doing things after a slower
943 * thread has the fatal signal pending.
944 */
945 signal->flags = SIGNAL_GROUP_EXIT;
946 signal->group_exit_code = sig;
947 signal->group_stop_count = 0;
948 t = p;
949 do {
Tejun Heo6dfca322011-06-02 11:14:00 +0200950 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700951 sigaddset(&t->pending.signal, SIGKILL);
952 signal_wake_up(t, 1);
953 } while_each_thread(p, t);
954 return;
955 }
956 }
957
958 /*
959 * The signal is already in the shared-pending queue.
960 * Tell the chosen thread to wake up and dequeue it.
961 */
962 signal_wake_up(t, sig == SIGKILL);
963 return;
964}
965
Pavel Emelyanovaf7fff92008-04-30 00:52:34 -0700966static inline int legacy_queue(struct sigpending *signals, int sig)
967{
968 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
969}
970
Serge E. Hallyn6b550f92012-01-10 15:11:37 -0800971#ifdef CONFIG_USER_NS
972static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
973{
974 if (current_user_ns() == task_cred_xxx(t, user_ns))
975 return;
976
977 if (SI_FROMKERNEL(info))
978 return;
979
Eric W. Biederman078de5f2012-02-08 07:00:08 -0800980 rcu_read_lock();
981 info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
982 make_kuid(current_user_ns(), info->si_uid));
983 rcu_read_unlock();
Serge E. Hallyn6b550f92012-01-10 15:11:37 -0800984}
985#else
986static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
987{
988 return;
989}
990#endif
991
Sukadev Bhattiprolu7978b562009-04-02 16:58:04 -0700992static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
993 int group, int from_ancestor_ns)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994{
Oleg Nesterov2ca35152008-04-30 00:52:54 -0700995 struct sigpending *pending;
Oleg Nesterov6e65acb2008-04-30 00:52:50 -0700996 struct sigqueue *q;
Vegard Nossum7a0aeb12009-05-16 11:28:33 +0200997 int override_rlimit;
Oleg Nesterov6c303d32011-11-22 21:13:48 +0100998 int ret = 0, result;
Mathieu Desnoyers0a16b602008-07-18 12:16:17 -0400999
Oleg Nesterov6e65acb2008-04-30 00:52:50 -07001000 assert_spin_locked(&t->sighand->siglock);
Sukadev Bhattiprolu921cf9f2009-04-02 16:58:05 -07001001
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001002 result = TRACE_SIGNAL_IGNORED;
Oleg Nesterov629d3622012-03-23 15:02:44 -07001003 if (!prepare_signal(sig, t,
1004 from_ancestor_ns || (info == SEND_SIG_FORCED)))
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001005 goto ret;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001006
1007 pending = group ? &t->signal->shared_pending : &t->pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 /*
Pavel Emelyanov2acb0242008-04-30 00:52:35 -07001009 * Short-circuit ignored signals and support queuing
1010 * exactly one non-rt signal, so that we can get more
1011 * detailed information about the cause of the signal.
1012 */
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001013 result = TRACE_SIGNAL_ALREADY_PENDING;
Oleg Nesterov7e695a52008-04-30 00:52:59 -07001014 if (legacy_queue(pending, sig))
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001015 goto ret;
1016
1017 result = TRACE_SIGNAL_DELIVERED;
Davide Libenzifba2afa2007-05-10 22:23:13 -07001018 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 * fast-pathed signals for kernel-internal things like SIGSTOP
1020 * or SIGKILL.
1021 */
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001022 if (info == SEND_SIG_FORCED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 goto out_set;
1024
Randy Dunlap5aba0852011-04-04 14:59:31 -07001025 /*
1026 * Real-time signals must be queued if sent by sigqueue, or
1027 * some other real-time mechanism. It is implementation
1028 * defined whether kill() does so. We attempt to do so, on
1029 * the principle of least surprise, but since kill is not
1030 * allowed to fail with EAGAIN when low on memory we just
1031 * make sure at least one signal gets delivered and don't
1032 * pass on the info struct.
1033 */
Vegard Nossum7a0aeb12009-05-16 11:28:33 +02001034 if (sig < SIGRTMIN)
1035 override_rlimit = (is_si_special(info) || info->si_code >= 0);
1036 else
1037 override_rlimit = 0;
1038
Levin, Alexander (Sasha Levin)75f296d2017-11-15 17:35:54 -08001039 q = __sigqueue_alloc(sig, t, GFP_ATOMIC, override_rlimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 if (q) {
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001041 list_add_tail(&q->list, &pending->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 switch ((unsigned long) info) {
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001043 case (unsigned long) SEND_SIG_NOINFO:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 q->info.si_signo = sig;
1045 q->info.si_errno = 0;
1046 q->info.si_code = SI_USER;
Sukadev Bhattiprolu9cd4fd12009-01-06 14:42:46 -08001047 q->info.si_pid = task_tgid_nr_ns(current,
Sukadev Bhattiprolu09bca052009-01-06 14:42:45 -08001048 task_active_pid_ns(t));
Eric W. Biederman078de5f2012-02-08 07:00:08 -08001049 q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 break;
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001051 case (unsigned long) SEND_SIG_PRIV:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 q->info.si_signo = sig;
1053 q->info.si_errno = 0;
1054 q->info.si_code = SI_KERNEL;
1055 q->info.si_pid = 0;
1056 q->info.si_uid = 0;
1057 break;
1058 default:
1059 copy_siginfo(&q->info, info);
Sukadev Bhattiprolu6588c1e2009-04-02 16:58:09 -07001060 if (from_ancestor_ns)
1061 q->info.si_pid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 break;
1063 }
Serge E. Hallyn6b550f92012-01-10 15:11:37 -08001064
1065 userns_fixup_signal_uid(&q->info, t);
1066
Oleg Nesterov621d3122005-10-30 15:03:45 -08001067 } else if (!is_si_special(info)) {
Masami Hiramatsuba005e12009-11-24 16:56:58 -05001068 if (sig >= SIGRTMIN && info->si_code != SI_USER) {
1069 /*
1070 * Queue overflow, abort. We may abort if the
1071 * signal was rt and sent by user using something
1072 * other than kill().
1073 */
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001074 result = TRACE_SIGNAL_OVERFLOW_FAIL;
1075 ret = -EAGAIN;
1076 goto ret;
Masami Hiramatsuba005e12009-11-24 16:56:58 -05001077 } else {
1078 /*
1079 * This is a silent loss of information. We still
1080 * send the signal, but the *info bits are lost.
1081 */
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001082 result = TRACE_SIGNAL_LOSE_INFO;
Masami Hiramatsuba005e12009-11-24 16:56:58 -05001083 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 }
1085
1086out_set:
Oleg Nesterov53c30332008-04-30 00:53:00 -07001087 signalfd_notify(t, sig);
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001088 sigaddset(&pending->signal, sig);
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001089 complete_signal(sig, t, group);
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001090ret:
1091 trace_signal_generate(sig, info, t, group, result);
1092 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093}
1094
Sukadev Bhattiprolu7978b562009-04-02 16:58:04 -07001095static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
1096 int group)
1097{
Sukadev Bhattiprolu921cf9f2009-04-02 16:58:05 -07001098 int from_ancestor_ns = 0;
1099
1100#ifdef CONFIG_PID_NS
Oleg Nesterovdd342002009-12-15 16:47:24 -08001101 from_ancestor_ns = si_fromuser(info) &&
1102 !task_pid_nr_ns(current, task_active_pid_ns(t));
Sukadev Bhattiprolu921cf9f2009-04-02 16:58:05 -07001103#endif
1104
1105 return __send_signal(sig, info, t, group, from_ancestor_ns);
Sukadev Bhattiprolu7978b562009-04-02 16:58:04 -07001106}
1107
Al Viro4aaefee2012-11-05 13:09:56 -05001108static void print_fatal_signal(int signr)
Ingo Molnar45807a12007-07-15 23:40:10 -07001109{
Al Viro4aaefee2012-11-05 13:09:56 -05001110 struct pt_regs *regs = signal_pt_regs();
Wang Xiaoqiang747800e2016-05-23 16:23:59 -07001111 pr_info("potentially unexpected fatal signal %d.\n", signr);
Ingo Molnar45807a12007-07-15 23:40:10 -07001112
Al Viroca5cd872007-10-29 04:31:16 +00001113#if defined(__i386__) && !defined(__arch_um__)
Wang Xiaoqiang747800e2016-05-23 16:23:59 -07001114 pr_info("code at %08lx: ", regs->ip);
Ingo Molnar45807a12007-07-15 23:40:10 -07001115 {
1116 int i;
1117 for (i = 0; i < 16; i++) {
1118 unsigned char insn;
1119
Andi Kleenb45c6e72010-01-08 14:42:52 -08001120 if (get_user(insn, (unsigned char *)(regs->ip + i)))
1121 break;
Wang Xiaoqiang747800e2016-05-23 16:23:59 -07001122 pr_cont("%02x ", insn);
Ingo Molnar45807a12007-07-15 23:40:10 -07001123 }
1124 }
Wang Xiaoqiang747800e2016-05-23 16:23:59 -07001125 pr_cont("\n");
Ingo Molnar45807a12007-07-15 23:40:10 -07001126#endif
Ed Swierk3a9f84d2009-01-26 15:33:31 -08001127 preempt_disable();
Ingo Molnar45807a12007-07-15 23:40:10 -07001128 show_regs(regs);
Ed Swierk3a9f84d2009-01-26 15:33:31 -08001129 preempt_enable();
Ingo Molnar45807a12007-07-15 23:40:10 -07001130}
1131
1132static int __init setup_print_fatal_signals(char *str)
1133{
1134 get_option (&str, &print_fatal_signals);
1135
1136 return 1;
1137}
1138
1139__setup("print-fatal-signals=", setup_print_fatal_signals);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001141int
1142__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1143{
1144 return send_signal(sig, info, p, 1);
1145}
1146
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147static int
1148specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1149{
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001150 return send_signal(sig, info, t, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151}
1152
Oleg Nesterov4a30deb2009-09-23 15:57:00 -07001153int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
1154 bool group)
1155{
1156 unsigned long flags;
1157 int ret = -ESRCH;
1158
1159 if (lock_task_sighand(p, &flags)) {
1160 ret = send_signal(sig, info, p, group);
1161 unlock_task_sighand(p, &flags);
1162 }
1163
1164 return ret;
1165}
1166
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167/*
1168 * Force a signal that the process can't ignore: if necessary
1169 * we unblock the signal and change any SIG_IGN to SIG_DFL.
Linus Torvaldsae74c3b2006-08-02 20:17:49 -07001170 *
1171 * Note: If we unblock the signal, we always reset it to SIG_DFL,
1172 * since we do not want to have a signal handler that was blocked
1173 * be invoked when user space had explicitly blocked it.
1174 *
Oleg Nesterov80fe7282008-04-30 00:53:05 -07001175 * We don't want to have recursive SIGSEGV's etc, for example,
1176 * that is why we also clear SIGNAL_UNKILLABLE.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178int
1179force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1180{
1181 unsigned long int flags;
Linus Torvaldsae74c3b2006-08-02 20:17:49 -07001182 int ret, blocked, ignored;
1183 struct k_sigaction *action;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184
1185 spin_lock_irqsave(&t->sighand->siglock, flags);
Linus Torvaldsae74c3b2006-08-02 20:17:49 -07001186 action = &t->sighand->action[sig-1];
1187 ignored = action->sa.sa_handler == SIG_IGN;
1188 blocked = sigismember(&t->blocked, sig);
1189 if (blocked || ignored) {
1190 action->sa.sa_handler = SIG_DFL;
1191 if (blocked) {
1192 sigdelset(&t->blocked, sig);
Roland McGrath7bb44ad2007-05-23 13:57:44 -07001193 recalc_sigpending_and_wake(t);
Linus Torvaldsae74c3b2006-08-02 20:17:49 -07001194 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 }
Jamie Ileseb61b592017-08-18 15:16:18 -07001196 /*
1197 * Don't clear SIGNAL_UNKILLABLE for traced tasks, users won't expect
1198 * debugging to leave init killable.
1199 */
1200 if (action->sa.sa_handler == SIG_DFL && !t->ptrace)
Oleg Nesterov80fe7282008-04-30 00:53:05 -07001201 t->signal->flags &= ~SIGNAL_UNKILLABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 ret = specific_send_sig_info(sig, info, t);
1203 spin_unlock_irqrestore(&t->sighand->siglock, flags);
1204
1205 return ret;
1206}
1207
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208/*
1209 * Nuke all other threads in the group.
1210 */
Oleg Nesterov09faef12010-05-26 14:43:11 -07001211int zap_other_threads(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212{
Oleg Nesterov09faef12010-05-26 14:43:11 -07001213 struct task_struct *t = p;
1214 int count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 p->signal->group_stop_count = 0;
1217
Oleg Nesterov09faef12010-05-26 14:43:11 -07001218 while_each_thread(p, t) {
Tejun Heo6dfca322011-06-02 11:14:00 +02001219 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
Oleg Nesterov09faef12010-05-26 14:43:11 -07001220 count++;
1221
1222 /* Don't bother with already dead threads */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 if (t->exit_state)
1224 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 sigaddset(&t->pending.signal, SIGKILL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 signal_wake_up(t, 1);
1227 }
Oleg Nesterov09faef12010-05-26 14:43:11 -07001228
1229 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230}
1231
Namhyung Kimb8ed3742010-10-27 15:34:06 -07001232struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
1233 unsigned long *flags)
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001234{
1235 struct sighand_struct *sighand;
1236
1237 for (;;) {
Paul E. McKenneyc41247e2014-05-05 08:18:30 -07001238 /*
1239 * Disable interrupts early to avoid deadlocks.
1240 * See rcu_read_unlock() comment header for details.
1241 */
Paul E. McKenneya8417962011-07-19 03:25:36 -07001242 local_irq_save(*flags);
1243 rcu_read_lock();
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001244 sighand = rcu_dereference(tsk->sighand);
Paul E. McKenneya8417962011-07-19 03:25:36 -07001245 if (unlikely(sighand == NULL)) {
1246 rcu_read_unlock();
1247 local_irq_restore(*flags);
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001248 break;
Paul E. McKenneya8417962011-07-19 03:25:36 -07001249 }
Oleg Nesterov392809b2014-09-28 23:44:18 +02001250 /*
1251 * This sighand can be already freed and even reused, but
Paul E. McKenney5f0d5a32017-01-18 02:53:44 -08001252 * we rely on SLAB_TYPESAFE_BY_RCU and sighand_ctor() which
Oleg Nesterov392809b2014-09-28 23:44:18 +02001253 * initializes ->siglock: this slab can't go away, it has
1254 * the same object type, ->siglock can't be reinitialized.
1255 *
1256 * We need to ensure that tsk->sighand is still the same
1257 * after we take the lock, we can race with de_thread() or
1258 * __exit_signal(). In the latter case the next iteration
1259 * must see ->sighand == NULL.
1260 */
Paul E. McKenneya8417962011-07-19 03:25:36 -07001261 spin_lock(&sighand->siglock);
1262 if (likely(sighand == tsk->sighand)) {
1263 rcu_read_unlock();
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001264 break;
Paul E. McKenneya8417962011-07-19 03:25:36 -07001265 }
1266 spin_unlock(&sighand->siglock);
1267 rcu_read_unlock();
1268 local_irq_restore(*flags);
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001269 }
1270
1271 return sighand;
1272}
1273
David Howellsc69e8d92008-11-14 10:39:19 +11001274/*
1275 * send signal info to all the members of a group
David Howellsc69e8d92008-11-14 10:39:19 +11001276 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1278{
David Howells694f6902010-08-04 16:59:14 +01001279 int ret;
1280
1281 rcu_read_lock();
1282 ret = check_kill_permission(sig, info, p);
1283 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284
Oleg Nesterov4a30deb2009-09-23 15:57:00 -07001285 if (!ret && sig)
1286 ret = do_send_sig_info(sig, info, p, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287
1288 return ret;
1289}
1290
1291/*
Pavel Emelyanov146a5052008-02-08 04:19:22 -08001292 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 * control characters do (^C, ^Z etc)
David Howellsc69e8d92008-11-14 10:39:19 +11001294 * - the caller must hold at least a readlock on tasklist_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 */
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001296int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297{
1298 struct task_struct *p = NULL;
1299 int retval, success;
1300
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 success = 0;
1302 retval = -ESRCH;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001303 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 int err = group_send_sig_info(sig, info, p);
1305 success |= !err;
1306 retval = err;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001307 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 return success ? 0 : retval;
1309}
1310
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001311int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312{
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001313 int error = -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 struct task_struct *p;
1315
Paul E. McKenneyeca1a082014-10-23 11:41:22 -07001316 for (;;) {
1317 rcu_read_lock();
1318 p = pid_task(pid, PIDTYPE_PID);
1319 if (p)
1320 error = group_send_sig_info(sig, info, p);
1321 rcu_read_unlock();
1322 if (likely(!p || error != -ESRCH))
1323 return error;
Oleg Nesterov6ca25b52008-04-30 00:52:45 -07001324
Paul E. McKenneyeca1a082014-10-23 11:41:22 -07001325 /*
1326 * The task was unhashed in between, try again. If it
1327 * is dead, pid_task() will return NULL, if we race with
1328 * de_thread() it will find the new leader.
1329 */
1330 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331}
1332
Eric W. Biederman6c478ae2017-04-17 22:10:04 -05001333static int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001334{
1335 int error;
1336 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001337 error = kill_pid_info(sig, info, find_vpid(pid));
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001338 rcu_read_unlock();
1339 return error;
1340}
1341
Serge Hallynd178bc32011-09-26 10:45:18 -05001342static int kill_as_cred_perm(const struct cred *cred,
1343 struct task_struct *target)
1344{
1345 const struct cred *pcred = __task_cred(target);
Eric W. Biederman5af66202012-03-03 20:21:47 -08001346 if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) &&
1347 !uid_eq(cred->uid, pcred->suid) && !uid_eq(cred->uid, pcred->uid))
Serge Hallynd178bc32011-09-26 10:45:18 -05001348 return 0;
1349 return 1;
1350}
1351
Eric W. Biederman2425c082006-10-02 02:17:28 -07001352/* like kill_pid_info(), but doesn't use uid/euid of "current" */
Serge Hallynd178bc32011-09-26 10:45:18 -05001353int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid,
1354 const struct cred *cred, u32 secid)
Harald Welte46113832005-10-10 19:44:29 +02001355{
1356 int ret = -EINVAL;
1357 struct task_struct *p;
Thomas Gleixner14d8c9f2009-12-10 00:53:17 +00001358 unsigned long flags;
Harald Welte46113832005-10-10 19:44:29 +02001359
1360 if (!valid_signal(sig))
1361 return ret;
1362
Thomas Gleixner14d8c9f2009-12-10 00:53:17 +00001363 rcu_read_lock();
Eric W. Biederman2425c082006-10-02 02:17:28 -07001364 p = pid_task(pid, PIDTYPE_PID);
Harald Welte46113832005-10-10 19:44:29 +02001365 if (!p) {
1366 ret = -ESRCH;
1367 goto out_unlock;
1368 }
Serge Hallynd178bc32011-09-26 10:45:18 -05001369 if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
Harald Welte46113832005-10-10 19:44:29 +02001370 ret = -EPERM;
1371 goto out_unlock;
1372 }
David Quigley8f95dc52006-06-30 01:55:47 -07001373 ret = security_task_kill(p, info, sig, secid);
1374 if (ret)
1375 goto out_unlock;
Thomas Gleixner14d8c9f2009-12-10 00:53:17 +00001376
1377 if (sig) {
1378 if (lock_task_sighand(p, &flags)) {
1379 ret = __send_signal(sig, info, p, 1, 0);
1380 unlock_task_sighand(p, &flags);
1381 } else
1382 ret = -ESRCH;
Harald Welte46113832005-10-10 19:44:29 +02001383 }
1384out_unlock:
Thomas Gleixner14d8c9f2009-12-10 00:53:17 +00001385 rcu_read_unlock();
Harald Welte46113832005-10-10 19:44:29 +02001386 return ret;
1387}
Serge Hallynd178bc32011-09-26 10:45:18 -05001388EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389
1390/*
1391 * kill_something_info() interprets pid in interesting ways just like kill(2).
1392 *
1393 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1394 * is probably wrong. Should make it like BSD or SYSV.
1395 */
1396
Gustavo Fernando Padovanbc64efd2008-07-25 01:47:33 -07001397static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398{
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001399 int ret;
Pavel Emelyanovd5df7632008-02-08 04:19:22 -08001400
1401 if (pid > 0) {
1402 rcu_read_lock();
1403 ret = kill_pid_info(sig, info, find_vpid(pid));
1404 rcu_read_unlock();
1405 return ret;
1406 }
1407
zhongjiang4ea77012017-07-10 15:52:57 -07001408 /* -INT_MIN is undefined. Exclude this case to avoid a UBSAN warning */
1409 if (pid == INT_MIN)
1410 return -ESRCH;
1411
Pavel Emelyanovd5df7632008-02-08 04:19:22 -08001412 read_lock(&tasklist_lock);
1413 if (pid != -1) {
1414 ret = __kill_pgrp_info(sig, info,
1415 pid ? find_vpid(-pid) : task_pgrp(current));
1416 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 int retval = 0, count = 0;
1418 struct task_struct * p;
1419
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 for_each_process(p) {
Sukadev Bhattiprolud25141a2008-10-29 14:01:11 -07001421 if (task_pid_vnr(p) > 1 &&
1422 !same_thread_group(p, current)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 int err = group_send_sig_info(sig, info, p);
1424 ++count;
1425 if (err != -EPERM)
1426 retval = err;
1427 }
1428 }
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001429 ret = count ? retval : -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 }
Pavel Emelyanovd5df7632008-02-08 04:19:22 -08001431 read_unlock(&tasklist_lock);
1432
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001433 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434}
1435
1436/*
1437 * These are for backward compatibility with the rest of the kernel source.
1438 */
1439
Randy Dunlap5aba0852011-04-04 14:59:31 -07001440int send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 /*
1443 * Make sure legacy kernel users don't send in bad values
1444 * (normal paths check this in check_kill_permission).
1445 */
Jesper Juhl7ed20e12005-05-01 08:59:14 -07001446 if (!valid_signal(sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 return -EINVAL;
1448
Oleg Nesterov4a30deb2009-09-23 15:57:00 -07001449 return do_send_sig_info(sig, info, p, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450}
1451
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001452#define __si_special(priv) \
1453 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1454
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455int
1456send_sig(int sig, struct task_struct *p, int priv)
1457{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001458 return send_sig_info(sig, __si_special(priv), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459}
1460
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461void
1462force_sig(int sig, struct task_struct *p)
1463{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001464 force_sig_info(sig, SEND_SIG_PRIV, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465}
1466
1467/*
1468 * When things go south during signal handling, we
1469 * will force a SIGSEGV. And if the signal that caused
1470 * the problem was already a SIGSEGV, we'll want to
1471 * make sure we don't even try to deliver the signal..
1472 */
1473int
1474force_sigsegv(int sig, struct task_struct *p)
1475{
1476 if (sig == SIGSEGV) {
1477 unsigned long flags;
1478 spin_lock_irqsave(&p->sighand->siglock, flags);
1479 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1480 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1481 }
1482 force_sig(SIGSEGV, p);
1483 return 0;
1484}
1485
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001486int kill_pgrp(struct pid *pid, int sig, int priv)
1487{
Pavel Emelyanov146a5052008-02-08 04:19:22 -08001488 int ret;
1489
1490 read_lock(&tasklist_lock);
1491 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1492 read_unlock(&tasklist_lock);
1493
1494 return ret;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001495}
1496EXPORT_SYMBOL(kill_pgrp);
1497
1498int kill_pid(struct pid *pid, int sig, int priv)
1499{
1500 return kill_pid_info(sig, __si_special(priv), pid);
1501}
1502EXPORT_SYMBOL(kill_pid);
1503
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504/*
1505 * These functions support sending signals using preallocated sigqueue
1506 * structures. This is needed "because realtime applications cannot
1507 * afford to lose notifications of asynchronous events, like timer
Randy Dunlap5aba0852011-04-04 14:59:31 -07001508 * expirations or I/O completions". In the case of POSIX Timers
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 * we allocate the sigqueue structure from the timer_create. If this
1510 * allocation fails we are able to report the failure to the application
1511 * with an EAGAIN error.
1512 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513struct sigqueue *sigqueue_alloc(void)
1514{
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +09001515 struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +09001517 if (q)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 q->flags |= SIGQUEUE_PREALLOC;
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +09001519
1520 return q;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521}
1522
1523void sigqueue_free(struct sigqueue *q)
1524{
1525 unsigned long flags;
Oleg Nesterov60187d22007-08-30 23:56:35 -07001526 spinlock_t *lock = &current->sighand->siglock;
1527
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1529 /*
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001530 * We must hold ->siglock while testing q->list
1531 * to serialize with collect_signal() or with
Oleg Nesterovda7978b2008-05-23 13:04:41 -07001532 * __exit_signal()->flush_sigqueue().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 */
Oleg Nesterov60187d22007-08-30 23:56:35 -07001534 spin_lock_irqsave(lock, flags);
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001535 q->flags &= ~SIGQUEUE_PREALLOC;
1536 /*
1537 * If it is queued it will be freed when dequeued,
1538 * like the "regular" sigqueue.
1539 */
Oleg Nesterov60187d22007-08-30 23:56:35 -07001540 if (!list_empty(&q->list))
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001541 q = NULL;
Oleg Nesterov60187d22007-08-30 23:56:35 -07001542 spin_unlock_irqrestore(lock, flags);
1543
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001544 if (q)
1545 __sigqueue_free(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546}
1547
Oleg Nesterovac5c2152008-04-30 00:52:57 -07001548int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001549{
Oleg Nesterove62e6652008-04-30 00:52:56 -07001550 int sig = q->info.si_signo;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001551 struct sigpending *pending;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001552 unsigned long flags;
Oleg Nesterov163566f2011-11-22 21:37:41 +01001553 int ret, result;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001554
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001555 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
Oleg Nesterove62e6652008-04-30 00:52:56 -07001556
1557 ret = -1;
1558 if (!likely(lock_task_sighand(t, &flags)))
1559 goto ret;
1560
Oleg Nesterov7e695a52008-04-30 00:52:59 -07001561 ret = 1; /* the signal is ignored */
Oleg Nesterov163566f2011-11-22 21:37:41 +01001562 result = TRACE_SIGNAL_IGNORED;
Oleg Nesterovdef8cf72012-03-23 15:02:45 -07001563 if (!prepare_signal(sig, t, false))
Oleg Nesterove62e6652008-04-30 00:52:56 -07001564 goto out;
1565
1566 ret = 0;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001567 if (unlikely(!list_empty(&q->list))) {
1568 /*
1569 * If an SI_TIMER entry is already queue just increment
1570 * the overrun count.
1571 */
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001572 BUG_ON(q->info.si_code != SI_TIMER);
1573 q->info.si_overrun++;
Oleg Nesterov163566f2011-11-22 21:37:41 +01001574 result = TRACE_SIGNAL_ALREADY_PENDING;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001575 goto out;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001576 }
Oleg Nesterovba661292008-07-23 20:52:05 +04001577 q->info.si_overrun = 0;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001578
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001579 signalfd_notify(t, sig);
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001580 pending = group ? &t->signal->shared_pending : &t->pending;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001581 list_add_tail(&q->list, &pending->list);
1582 sigaddset(&pending->signal, sig);
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001583 complete_signal(sig, t, group);
Oleg Nesterov163566f2011-11-22 21:37:41 +01001584 result = TRACE_SIGNAL_DELIVERED;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001585out:
Oleg Nesterov163566f2011-11-22 21:37:41 +01001586 trace_signal_generate(sig, &q->info, t, group, result);
Oleg Nesterove62e6652008-04-30 00:52:56 -07001587 unlock_task_sighand(t, &flags);
1588ret:
1589 return ret;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001590}
1591
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 * Let a parent know about the death of a child.
1594 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
Roland McGrath2b2a1ff2008-07-25 19:45:54 -07001595 *
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001596 * Returns true if our parent ignored us and so we've switched to
1597 * self-reaping.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 */
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001599bool do_notify_parent(struct task_struct *tsk, int sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600{
1601 struct siginfo info;
1602 unsigned long flags;
1603 struct sighand_struct *psig;
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001604 bool autoreap = false;
Frederic Weisbeckerbde82852017-01-31 04:09:31 +01001605 u64 utime, stime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606
1607 BUG_ON(sig == -1);
1608
1609 /* do_notify_parent_cldstop should have been called instead. */
Matthew Wilcoxe1abb392007-12-06 11:07:35 -05001610 BUG_ON(task_is_stopped_or_traced(tsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611
Tejun Heod21142e2011-06-17 16:50:34 +02001612 BUG_ON(!tsk->ptrace &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1614
Oleg Nesterovb6e238d2012-03-19 17:03:41 +01001615 if (sig != SIGCHLD) {
1616 /*
1617 * This is only possible if parent == real_parent.
1618 * Check if it has changed security domain.
1619 */
1620 if (tsk->parent_exec_id != tsk->parent->self_exec_id)
1621 sig = SIGCHLD;
1622 }
1623
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 info.si_signo = sig;
1625 info.si_errno = 0;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001626 /*
Eric W. Biederman32084502012-05-31 16:26:39 -07001627 * We are under tasklist_lock here so our parent is tied to
1628 * us and cannot change.
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001629 *
Eric W. Biederman32084502012-05-31 16:26:39 -07001630 * task_active_pid_ns will always return the same pid namespace
1631 * until a task passes through release_task.
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001632 *
1633 * write_lock() currently calls preempt_disable() which is the
1634 * same as rcu_read_lock(), but according to Oleg, this is not
1635 * correct to rely on this
1636 */
1637 rcu_read_lock();
Eric W. Biederman32084502012-05-31 16:26:39 -07001638 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
Eric W. Biederman54ba47e2012-03-13 16:04:35 -07001639 info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
1640 task_uid(tsk));
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001641 rcu_read_unlock();
1642
Frederic Weisbeckerbde82852017-01-31 04:09:31 +01001643 task_cputime(tsk, &utime, &stime);
1644 info.si_utime = nsec_to_clock_t(utime + tsk->signal->utime);
1645 info.si_stime = nsec_to_clock_t(stime + tsk->signal->stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
1647 info.si_status = tsk->exit_code & 0x7f;
1648 if (tsk->exit_code & 0x80)
1649 info.si_code = CLD_DUMPED;
1650 else if (tsk->exit_code & 0x7f)
1651 info.si_code = CLD_KILLED;
1652 else {
1653 info.si_code = CLD_EXITED;
1654 info.si_status = tsk->exit_code >> 8;
1655 }
1656
1657 psig = tsk->parent->sighand;
1658 spin_lock_irqsave(&psig->siglock, flags);
Tejun Heod21142e2011-06-17 16:50:34 +02001659 if (!tsk->ptrace && sig == SIGCHLD &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1661 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1662 /*
1663 * We are exiting and our parent doesn't care. POSIX.1
1664 * defines special semantics for setting SIGCHLD to SIG_IGN
1665 * or setting the SA_NOCLDWAIT flag: we should be reaped
1666 * automatically and not left for our parent's wait4 call.
1667 * Rather than having the parent do it as a magic kind of
1668 * signal handler, we just set this to tell do_exit that we
1669 * can be cleaned up without becoming a zombie. Note that
1670 * we still call __wake_up_parent in this case, because a
1671 * blocked sys_wait4 might now return -ECHILD.
1672 *
1673 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1674 * is implementation-defined: we do (if you don't want
1675 * it, just use SIG_IGN instead).
1676 */
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001677 autoreap = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001679 sig = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 }
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001681 if (valid_signal(sig) && sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 __group_send_sig_info(sig, &info, tsk->parent);
1683 __wake_up_parent(tsk, tsk->parent);
1684 spin_unlock_irqrestore(&psig->siglock, flags);
Roland McGrath2b2a1ff2008-07-25 19:45:54 -07001685
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001686 return autoreap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687}
1688
Tejun Heo75b95952011-03-23 10:37:01 +01001689/**
1690 * do_notify_parent_cldstop - notify parent of stopped/continued state change
1691 * @tsk: task reporting the state change
1692 * @for_ptracer: the notification is for ptracer
1693 * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
1694 *
1695 * Notify @tsk's parent that the stopped/continued state has changed. If
1696 * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
1697 * If %true, @tsk reports to @tsk->parent which should be the ptracer.
1698 *
1699 * CONTEXT:
1700 * Must be called with tasklist_lock at least read locked.
1701 */
1702static void do_notify_parent_cldstop(struct task_struct *tsk,
1703 bool for_ptracer, int why)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704{
1705 struct siginfo info;
1706 unsigned long flags;
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001707 struct task_struct *parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 struct sighand_struct *sighand;
Frederic Weisbeckerbde82852017-01-31 04:09:31 +01001709 u64 utime, stime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710
Tejun Heo75b95952011-03-23 10:37:01 +01001711 if (for_ptracer) {
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001712 parent = tsk->parent;
Tejun Heo75b95952011-03-23 10:37:01 +01001713 } else {
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001714 tsk = tsk->group_leader;
1715 parent = tsk->real_parent;
1716 }
1717
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 info.si_signo = SIGCHLD;
1719 info.si_errno = 0;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001720 /*
Randy Dunlap5aba0852011-04-04 14:59:31 -07001721 * see comment in do_notify_parent() about the following 4 lines
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001722 */
1723 rcu_read_lock();
Eric W. Biederman17cf22c2010-03-02 14:51:53 -08001724 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
Eric W. Biederman54ba47e2012-03-13 16:04:35 -07001725 info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001726 rcu_read_unlock();
1727
Frederic Weisbeckerbde82852017-01-31 04:09:31 +01001728 task_cputime(tsk, &utime, &stime);
1729 info.si_utime = nsec_to_clock_t(utime);
1730 info.si_stime = nsec_to_clock_t(stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731
1732 info.si_code = why;
1733 switch (why) {
1734 case CLD_CONTINUED:
1735 info.si_status = SIGCONT;
1736 break;
1737 case CLD_STOPPED:
1738 info.si_status = tsk->signal->group_exit_code & 0x7f;
1739 break;
1740 case CLD_TRAPPED:
1741 info.si_status = tsk->exit_code & 0x7f;
1742 break;
1743 default:
1744 BUG();
1745 }
1746
1747 sighand = parent->sighand;
1748 spin_lock_irqsave(&sighand->siglock, flags);
1749 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1750 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1751 __group_send_sig_info(SIGCHLD, &info, parent);
1752 /*
1753 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1754 */
1755 __wake_up_parent(tsk, parent);
1756 spin_unlock_irqrestore(&sighand->siglock, flags);
1757}
1758
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001759static inline int may_ptrace_stop(void)
1760{
Tejun Heod21142e2011-06-17 16:50:34 +02001761 if (!likely(current->ptrace))
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001762 return 0;
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001763 /*
1764 * Are we in the middle of do_coredump?
1765 * If so and our tracer is also part of the coredump stopping
1766 * is a deadlock situation, and pointless because our tracer
1767 * is dead so don't allow us to stop.
1768 * If SIGKILL was already sent before the caller unlocked
Oleg Nesterov999d9fc2008-07-25 01:47:41 -07001769 * ->siglock we must see ->core_state != NULL. Otherwise it
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001770 * is safe to enter schedule().
Oleg Nesterov9899d112013-01-21 20:48:00 +01001771 *
1772 * This is almost outdated, a task with the pending SIGKILL can't
1773 * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported
1774 * after SIGKILL was already dequeued.
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001775 */
Oleg Nesterov999d9fc2008-07-25 01:47:41 -07001776 if (unlikely(current->mm->core_state) &&
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001777 unlikely(current->mm == current->parent->mm))
1778 return 0;
1779
1780 return 1;
1781}
1782
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783/*
Randy Dunlap5aba0852011-04-04 14:59:31 -07001784 * Return non-zero if there is a SIGKILL that should be waking us up.
Roland McGrath1a669c22008-02-06 01:37:37 -08001785 * Called with the siglock held.
1786 */
1787static int sigkill_pending(struct task_struct *tsk)
1788{
Oleg Nesterov3d749b92008-07-25 01:47:37 -07001789 return sigismember(&tsk->pending.signal, SIGKILL) ||
1790 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
Roland McGrath1a669c22008-02-06 01:37:37 -08001791}
1792
1793/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 * This must be called with current->sighand->siglock held.
1795 *
1796 * This should be the path for all ptrace stops.
1797 * We always set current->last_siginfo while stopped here.
1798 * That makes it a way to test a stopped process for
1799 * being ptrace-stopped vs being job-control-stopped.
1800 *
Oleg Nesterov20686a32008-02-08 04:19:03 -08001801 * If we actually decide not to stop at all because the tracer
1802 * is gone, we keep current->exit_code unless clear_code.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 */
Tejun Heofe1bc6a2011-03-23 10:37:00 +01001804static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
Namhyung Kimb8401152010-10-27 15:34:07 -07001805 __releases(&current->sighand->siglock)
1806 __acquires(&current->sighand->siglock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807{
Tejun Heoceb6bd62011-03-23 10:37:01 +01001808 bool gstop_done = false;
1809
Roland McGrath1a669c22008-02-06 01:37:37 -08001810 if (arch_ptrace_stop_needed(exit_code, info)) {
1811 /*
1812 * The arch code has something special to do before a
1813 * ptrace stop. This is allowed to block, e.g. for faults
1814 * on user stack pages. We can't keep the siglock while
1815 * calling arch_ptrace_stop, so we must release it now.
1816 * To preserve proper semantics, we must do this before
1817 * any signal bookkeeping like checking group_stop_count.
1818 * Meanwhile, a SIGKILL could come in before we retake the
1819 * siglock. That must prevent us from sleeping in TASK_TRACED.
1820 * So after regaining the lock, we must check for SIGKILL.
1821 */
1822 spin_unlock_irq(&current->sighand->siglock);
1823 arch_ptrace_stop(exit_code, info);
1824 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterov3d749b92008-07-25 01:47:37 -07001825 if (sigkill_pending(current))
1826 return;
Roland McGrath1a669c22008-02-06 01:37:37 -08001827 }
1828
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 /*
Tejun Heo81be24b2011-06-02 11:13:59 +02001830 * We're committing to trapping. TRACED should be visible before
1831 * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
1832 * Also, transition to TRACED and updates to ->jobctl should be
1833 * atomic with respect to siglock and should be done after the arch
1834 * hook as siglock is released and regrabbed across it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 */
Tejun Heo81be24b2011-06-02 11:13:59 +02001836 set_current_state(TASK_TRACED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837
1838 current->last_siginfo = info;
1839 current->exit_code = exit_code;
1840
Tejun Heod79fdd62011-03-23 10:37:00 +01001841 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 * If @why is CLD_STOPPED, we're trapping to participate in a group
1843 * stop. Do the bookkeeping. Note that if SIGCONT was delievered
Tejun Heo73ddff22011-06-14 11:20:14 +02001844 * across siglock relocks since INTERRUPT was scheduled, PENDING
1845 * could be clear now. We act as if SIGCONT is received after
1846 * TASK_TRACED is entered - ignore it.
Tejun Heod79fdd62011-03-23 10:37:00 +01001847 */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001848 if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 gstop_done = task_participate_group_stop(current);
Tejun Heod79fdd62011-03-23 10:37:00 +01001850
Tejun Heofb1d9102011-06-14 11:20:17 +02001851 /* any trap clears pending STOP trap, STOP trap clears NOTIFY */
Tejun Heo73ddff22011-06-14 11:20:14 +02001852 task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
Tejun Heofb1d9102011-06-14 11:20:17 +02001853 if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
1854 task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
Tejun Heo73ddff22011-06-14 11:20:14 +02001855
Tejun Heo81be24b2011-06-02 11:13:59 +02001856 /* entering a trap, clear TRAPPING */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001857 task_clear_jobctl_trapping(current);
Tejun Heod79fdd62011-03-23 10:37:00 +01001858
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 spin_unlock_irq(&current->sighand->siglock);
1860 read_lock(&tasklist_lock);
Oleg Nesterov3d749b92008-07-25 01:47:37 -07001861 if (may_ptrace_stop()) {
Tejun Heoceb6bd62011-03-23 10:37:01 +01001862 /*
1863 * Notify parents of the stop.
1864 *
1865 * While ptraced, there are two parents - the ptracer and
1866 * the real_parent of the group_leader. The ptracer should
1867 * know about every stop while the real parent is only
1868 * interested in the completion of group stop. The states
1869 * for the two don't interact with each other. Notify
1870 * separately unless they're gonna be duplicates.
1871 */
1872 do_notify_parent_cldstop(current, true, why);
Oleg Nesterovbb3696d2011-06-24 17:34:23 +02001873 if (gstop_done && ptrace_reparented(current))
Tejun Heoceb6bd62011-03-23 10:37:01 +01001874 do_notify_parent_cldstop(current, false, why);
1875
Miklos Szeredi53da1d92009-03-23 16:07:24 +01001876 /*
1877 * Don't want to allow preemption here, because
1878 * sys_ptrace() needs this task to be inactive.
1879 *
1880 * XXX: implement read_unlock_no_resched().
1881 */
1882 preempt_disable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 read_unlock(&tasklist_lock);
Miklos Szeredi53da1d92009-03-23 16:07:24 +01001884 preempt_enable_no_resched();
Oleg Nesterov5d8f72b2012-10-26 19:46:06 +02001885 freezable_schedule();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 } else {
1887 /*
1888 * By the time we got the lock, our tracer went away.
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001889 * Don't drop the lock yet, another tracer may come.
Tejun Heoceb6bd62011-03-23 10:37:01 +01001890 *
1891 * If @gstop_done, the ptracer went away between group stop
1892 * completion and here. During detach, it would have set
Tejun Heoa8f072c2011-06-02 11:13:59 +02001893 * JOBCTL_STOP_PENDING on us and we'll re-enter
1894 * TASK_STOPPED in do_signal_stop() on return, so notifying
1895 * the real parent of the group stop completion is enough.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 */
Tejun Heoceb6bd62011-03-23 10:37:01 +01001897 if (gstop_done)
1898 do_notify_parent_cldstop(current, false, why);
1899
Oleg Nesterov9899d112013-01-21 20:48:00 +01001900 /* tasklist protects us from ptrace_freeze_traced() */
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001901 __set_current_state(TASK_RUNNING);
Oleg Nesterov20686a32008-02-08 04:19:03 -08001902 if (clear_code)
1903 current->exit_code = 0;
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001904 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 }
1906
1907 /*
1908 * We are back. Now reacquire the siglock before touching
1909 * last_siginfo, so that we are sure to have synchronized with
1910 * any signal-sending on another CPU that wants to examine it.
1911 */
1912 spin_lock_irq(&current->sighand->siglock);
1913 current->last_siginfo = NULL;
1914
Tejun Heo544b2c92011-06-14 11:20:18 +02001915 /* LISTENING can be set only during STOP traps, clear it */
1916 current->jobctl &= ~JOBCTL_LISTENING;
1917
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 /*
1919 * Queued signals ignored us while we were stopped for tracing.
1920 * So check for any that we should take before resuming user mode.
Roland McGrathb74d0de2007-06-06 03:59:00 -07001921 * This sets TIF_SIGPENDING, but never clears it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 */
Roland McGrathb74d0de2007-06-06 03:59:00 -07001923 recalc_sigpending_tsk(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924}
1925
Tejun Heo3544d722011-06-14 11:20:15 +02001926static void ptrace_do_notify(int signr, int exit_code, int why)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927{
1928 siginfo_t info;
1929
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 memset(&info, 0, sizeof info);
Tejun Heo3544d722011-06-14 11:20:15 +02001931 info.si_signo = signr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 info.si_code = exit_code;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001933 info.si_pid = task_pid_vnr(current);
Eric W. Biederman078de5f2012-02-08 07:00:08 -08001934 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935
1936 /* Let the debugger run. */
Tejun Heo3544d722011-06-14 11:20:15 +02001937 ptrace_stop(exit_code, why, 1, &info);
1938}
1939
1940void ptrace_notify(int exit_code)
1941{
1942 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
Oleg Nesterovf784e8a2012-08-26 21:12:17 +02001943 if (unlikely(current->task_works))
1944 task_work_run();
Tejun Heo3544d722011-06-14 11:20:15 +02001945
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 spin_lock_irq(&current->sighand->siglock);
Tejun Heo3544d722011-06-14 11:20:15 +02001947 ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 spin_unlock_irq(&current->sighand->siglock);
1949}
1950
Tejun Heo73ddff22011-06-14 11:20:14 +02001951/**
1952 * do_signal_stop - handle group stop for SIGSTOP and other stop signals
1953 * @signr: signr causing group stop if initiating
1954 *
1955 * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
1956 * and participate in it. If already set, participate in the existing
1957 * group stop. If participated in a group stop (and thus slept), %true is
1958 * returned with siglock released.
1959 *
1960 * If ptraced, this function doesn't handle stop itself. Instead,
1961 * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
1962 * untouched. The caller must ensure that INTERRUPT trap handling takes
1963 * places afterwards.
1964 *
1965 * CONTEXT:
1966 * Must be called with @current->sighand->siglock held, which is released
1967 * on %true return.
1968 *
1969 * RETURNS:
1970 * %false if group stop is already cancelled or ptrace trap is scheduled.
1971 * %true if participated in group stop.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 */
Tejun Heo73ddff22011-06-14 11:20:14 +02001973static bool do_signal_stop(int signr)
1974 __releases(&current->sighand->siglock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975{
1976 struct signal_struct *sig = current->signal;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977
Tejun Heoa8f072c2011-06-02 11:13:59 +02001978 if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
Palmer Dabbeltb76808e2015-04-30 21:19:57 -07001979 unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08001980 struct task_struct *t;
1981
Tejun Heoa8f072c2011-06-02 11:13:59 +02001982 /* signr will be recorded in task->jobctl for retries */
1983 WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
Tejun Heod79fdd62011-03-23 10:37:00 +01001984
Tejun Heoa8f072c2011-06-02 11:13:59 +02001985 if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
Oleg Nesterov573cf9a2008-04-30 00:52:36 -07001986 unlikely(signal_group_exit(sig)))
Tejun Heo73ddff22011-06-14 11:20:14 +02001987 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 /*
Tejun Heo408a37d2011-03-23 10:37:01 +01001989 * There is no group stop already in progress. We must
1990 * initiate one now.
1991 *
1992 * While ptraced, a task may be resumed while group stop is
1993 * still in effect and then receive a stop signal and
1994 * initiate another group stop. This deviates from the
1995 * usual behavior as two consecutive stop signals can't
Oleg Nesterov780006eac2011-04-01 20:12:16 +02001996 * cause two group stops when !ptraced. That is why we
1997 * also check !task_is_stopped(t) below.
Tejun Heo408a37d2011-03-23 10:37:01 +01001998 *
1999 * The condition can be distinguished by testing whether
2000 * SIGNAL_STOP_STOPPED is already set. Don't generate
2001 * group_exit_code in such case.
2002 *
2003 * This is not necessary for SIGNAL_STOP_CONTINUED because
2004 * an intervening stop signal is required to cause two
2005 * continued events regardless of ptrace.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 */
Tejun Heo408a37d2011-03-23 10:37:01 +01002007 if (!(sig->flags & SIGNAL_STOP_STOPPED))
2008 sig->group_exit_code = signr;
Oleg Nesterova122b342006-03-28 16:11:22 -08002009
Tejun Heo7dd3db52011-06-02 11:14:00 +02002010 sig->group_stop_count = 0;
2011
2012 if (task_set_jobctl_pending(current, signr | gstop))
2013 sig->group_stop_count++;
2014
Oleg Nesterov8d38f202014-01-23 15:55:56 -08002015 t = current;
2016 while_each_thread(current, t) {
Oleg Nesterova122b342006-03-28 16:11:22 -08002017 /*
2018 * Setting state to TASK_STOPPED for a group
2019 * stop is always done with the siglock held,
2020 * so this check has no races.
2021 */
Tejun Heo7dd3db52011-06-02 11:14:00 +02002022 if (!task_is_stopped(t) &&
2023 task_set_jobctl_pending(t, signr | gstop)) {
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002024 sig->group_stop_count++;
Tejun Heofb1d9102011-06-14 11:20:17 +02002025 if (likely(!(t->ptrace & PT_SEIZED)))
2026 signal_wake_up(t, 0);
2027 else
2028 ptrace_trap_notify(t);
Oleg Nesterova122b342006-03-28 16:11:22 -08002029 }
Tejun Heod79fdd62011-03-23 10:37:00 +01002030 }
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002031 }
Tejun Heo73ddff22011-06-14 11:20:14 +02002032
Tejun Heod21142e2011-06-17 16:50:34 +02002033 if (likely(!current->ptrace)) {
Tejun Heo5224fa32011-03-23 10:37:00 +01002034 int notify = 0;
2035
2036 /*
2037 * If there are no other threads in the group, or if there
2038 * is a group stop in progress and we are the last to stop,
2039 * report to the parent.
2040 */
2041 if (task_participate_group_stop(current))
2042 notify = CLD_STOPPED;
2043
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002044 __set_current_state(TASK_STOPPED);
Tejun Heo5224fa32011-03-23 10:37:00 +01002045 spin_unlock_irq(&current->sighand->siglock);
2046
Tejun Heo62bcf9d2011-03-23 10:37:01 +01002047 /*
2048 * Notify the parent of the group stop completion. Because
2049 * we're not holding either the siglock or tasklist_lock
2050 * here, ptracer may attach inbetween; however, this is for
2051 * group stop and should always be delivered to the real
2052 * parent of the group leader. The new ptracer will get
2053 * its notification when this task transitions into
2054 * TASK_TRACED.
2055 */
Tejun Heo5224fa32011-03-23 10:37:00 +01002056 if (notify) {
2057 read_lock(&tasklist_lock);
Tejun Heo62bcf9d2011-03-23 10:37:01 +01002058 do_notify_parent_cldstop(current, false, notify);
Tejun Heo5224fa32011-03-23 10:37:00 +01002059 read_unlock(&tasklist_lock);
2060 }
2061
2062 /* Now we don't run again until woken by SIGCONT or SIGKILL */
Oleg Nesterov5d8f72b2012-10-26 19:46:06 +02002063 freezable_schedule();
Tejun Heo73ddff22011-06-14 11:20:14 +02002064 return true;
Tejun Heod79fdd62011-03-23 10:37:00 +01002065 } else {
Tejun Heo73ddff22011-06-14 11:20:14 +02002066 /*
2067 * While ptraced, group stop is handled by STOP trap.
2068 * Schedule it and let the caller deal with it.
2069 */
2070 task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
2071 return false;
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002072 }
Tejun Heo73ddff22011-06-14 11:20:14 +02002073}
Tejun Heod79fdd62011-03-23 10:37:00 +01002074
Tejun Heo73ddff22011-06-14 11:20:14 +02002075/**
2076 * do_jobctl_trap - take care of ptrace jobctl traps
2077 *
Tejun Heo3544d722011-06-14 11:20:15 +02002078 * When PT_SEIZED, it's used for both group stop and explicit
2079 * SEIZE/INTERRUPT traps. Both generate PTRACE_EVENT_STOP trap with
2080 * accompanying siginfo. If stopped, lower eight bits of exit_code contain
2081 * the stop signal; otherwise, %SIGTRAP.
2082 *
2083 * When !PT_SEIZED, it's used only for group stop trap with stop signal
2084 * number as exit_code and no siginfo.
Tejun Heo73ddff22011-06-14 11:20:14 +02002085 *
2086 * CONTEXT:
2087 * Must be called with @current->sighand->siglock held, which may be
2088 * released and re-acquired before returning with intervening sleep.
2089 */
2090static void do_jobctl_trap(void)
2091{
Tejun Heo3544d722011-06-14 11:20:15 +02002092 struct signal_struct *signal = current->signal;
Tejun Heo73ddff22011-06-14 11:20:14 +02002093 int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
Tejun Heod79fdd62011-03-23 10:37:00 +01002094
Tejun Heo3544d722011-06-14 11:20:15 +02002095 if (current->ptrace & PT_SEIZED) {
2096 if (!signal->group_stop_count &&
2097 !(signal->flags & SIGNAL_STOP_STOPPED))
2098 signr = SIGTRAP;
2099 WARN_ON_ONCE(!signr);
2100 ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
2101 CLD_STOPPED);
2102 } else {
2103 WARN_ON_ONCE(!signr);
2104 ptrace_stop(signr, CLD_STOPPED, 0, NULL);
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002105 current->exit_code = 0;
2106 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107}
2108
Al Viro94eb22d2012-11-05 13:08:06 -05002109static int ptrace_signal(int signr, siginfo_t *info)
Roland McGrath18c98b62008-04-17 18:44:38 -07002110{
Oleg Nesterov8a352412011-07-21 17:06:53 +02002111 /*
2112 * We do not check sig_kernel_stop(signr) but set this marker
2113 * unconditionally because we do not know whether debugger will
2114 * change signr. This flag has no meaning unless we are going
2115 * to stop after return from ptrace_stop(). In this case it will
2116 * be checked in do_signal_stop(), we should only stop if it was
2117 * not cleared by SIGCONT while we were sleeping. See also the
2118 * comment in dequeue_signal().
2119 */
2120 current->jobctl |= JOBCTL_STOP_DEQUEUED;
Tejun Heofe1bc6a2011-03-23 10:37:00 +01002121 ptrace_stop(signr, CLD_TRAPPED, 0, info);
Roland McGrath18c98b62008-04-17 18:44:38 -07002122
2123 /* We're back. Did the debugger cancel the sig? */
2124 signr = current->exit_code;
2125 if (signr == 0)
2126 return signr;
2127
2128 current->exit_code = 0;
2129
Randy Dunlap5aba0852011-04-04 14:59:31 -07002130 /*
2131 * Update the siginfo structure if the signal has
2132 * changed. If the debugger wanted something
2133 * specific in the siginfo structure then it should
2134 * have updated *info via PTRACE_SETSIGINFO.
2135 */
Roland McGrath18c98b62008-04-17 18:44:38 -07002136 if (signr != info->si_signo) {
2137 info->si_signo = signr;
2138 info->si_errno = 0;
2139 info->si_code = SI_USER;
Serge E. Hallyn6b550f92012-01-10 15:11:37 -08002140 rcu_read_lock();
Roland McGrath18c98b62008-04-17 18:44:38 -07002141 info->si_pid = task_pid_vnr(current->parent);
Eric W. Biederman54ba47e2012-03-13 16:04:35 -07002142 info->si_uid = from_kuid_munged(current_user_ns(),
2143 task_uid(current->parent));
Serge E. Hallyn6b550f92012-01-10 15:11:37 -08002144 rcu_read_unlock();
Roland McGrath18c98b62008-04-17 18:44:38 -07002145 }
2146
2147 /* If the (new) signal is now blocked, requeue it. */
2148 if (sigismember(&current->blocked, signr)) {
2149 specific_send_sig_info(signr, info, current);
2150 signr = 0;
2151 }
2152
2153 return signr;
2154}
2155
Richard Weinberger828b1f62013-10-07 15:26:57 +02002156int get_signal(struct ksignal *ksig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157{
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002158 struct sighand_struct *sighand = current->sighand;
2159 struct signal_struct *signal = current->signal;
2160 int signr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161
Oleg Nesterovf784e8a2012-08-26 21:12:17 +02002162 if (unlikely(current->task_works))
2163 task_work_run();
Al Viro72667022012-07-15 14:10:52 +04002164
Srikar Dronamraju0326f5a2012-03-13 23:30:11 +05302165 if (unlikely(uprobe_deny_signal()))
2166 return 0;
2167
Roland McGrath13b1c3d2008-03-03 20:22:05 -08002168 /*
Oleg Nesterov5d8f72b2012-10-26 19:46:06 +02002169 * Do this once, we can't return to user-mode if freezing() == T.
2170 * do_signal_stop() and ptrace_stop() do freezable_schedule() and
2171 * thus do not need another check after return.
Roland McGrath13b1c3d2008-03-03 20:22:05 -08002172 */
Rafael J. Wysockifc558a72006-03-23 03:00:05 -08002173 try_to_freeze();
2174
Oleg Nesterov5d8f72b2012-10-26 19:46:06 +02002175relock:
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002176 spin_lock_irq(&sighand->siglock);
Oleg Nesterov021e1ae2008-04-30 00:53:00 -07002177 /*
2178 * Every stopped thread goes here after wakeup. Check to see if
2179 * we should notify the parent, prepare_signal(SIGCONT) encodes
2180 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
2181 */
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002182 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
Tejun Heoc672af32011-03-23 10:36:59 +01002183 int why;
2184
2185 if (signal->flags & SIGNAL_CLD_CONTINUED)
2186 why = CLD_CONTINUED;
2187 else
2188 why = CLD_STOPPED;
2189
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002190 signal->flags &= ~SIGNAL_CLD_MASK;
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002191
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002192 spin_unlock_irq(&sighand->siglock);
Oleg Nesterove4420552008-04-30 00:52:44 -07002193
Tejun Heoceb6bd62011-03-23 10:37:01 +01002194 /*
2195 * Notify the parent that we're continuing. This event is
2196 * always per-process and doesn't make whole lot of sense
2197 * for ptracers, who shouldn't consume the state via
2198 * wait(2) either, but, for backward compatibility, notify
2199 * the ptracer of the group leader too unless it's gonna be
2200 * a duplicate.
2201 */
Tejun Heoedf2ed12011-03-23 10:37:00 +01002202 read_lock(&tasklist_lock);
Tejun Heoceb6bd62011-03-23 10:37:01 +01002203 do_notify_parent_cldstop(current, false, why);
2204
Oleg Nesterovbb3696d2011-06-24 17:34:23 +02002205 if (ptrace_reparented(current->group_leader))
2206 do_notify_parent_cldstop(current->group_leader,
2207 true, why);
Tejun Heoedf2ed12011-03-23 10:37:00 +01002208 read_unlock(&tasklist_lock);
Tejun Heoceb6bd62011-03-23 10:37:01 +01002209
Oleg Nesterove4420552008-04-30 00:52:44 -07002210 goto relock;
2211 }
2212
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213 for (;;) {
2214 struct k_sigaction *ka;
Tejun Heodd1d6772011-06-02 11:14:00 +02002215
2216 if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
2217 do_signal_stop(0))
Roland McGrath7bcf6a22008-07-25 19:45:53 -07002218 goto relock;
Oleg Nesterov1be53962009-12-15 16:47:26 -08002219
Tejun Heo73ddff22011-06-14 11:20:14 +02002220 if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
2221 do_jobctl_trap();
2222 spin_unlock_irq(&sighand->siglock);
2223 goto relock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224 }
2225
Richard Weinberger828b1f62013-10-07 15:26:57 +02002226 signr = dequeue_signal(current, &current->blocked, &ksig->info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227
Tejun Heodd1d6772011-06-02 11:14:00 +02002228 if (!signr)
2229 break; /* will return 0 */
2230
Oleg Nesterov8a352412011-07-21 17:06:53 +02002231 if (unlikely(current->ptrace) && signr != SIGKILL) {
Richard Weinberger828b1f62013-10-07 15:26:57 +02002232 signr = ptrace_signal(signr, &ksig->info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 if (!signr)
Tejun Heodd1d6772011-06-02 11:14:00 +02002234 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 }
2236
Tejun Heodd1d6772011-06-02 11:14:00 +02002237 ka = &sighand->action[signr-1];
2238
Masami Hiramatsuf9d42572009-11-24 16:56:51 -05002239 /* Trace actually delivered signals. */
Richard Weinberger828b1f62013-10-07 15:26:57 +02002240 trace_signal_deliver(signr, &ksig->info, ka);
Masami Hiramatsuf9d42572009-11-24 16:56:51 -05002241
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
2243 continue;
2244 if (ka->sa.sa_handler != SIG_DFL) {
2245 /* Run the handler. */
Richard Weinberger828b1f62013-10-07 15:26:57 +02002246 ksig->ka = *ka;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247
2248 if (ka->sa.sa_flags & SA_ONESHOT)
2249 ka->sa.sa_handler = SIG_DFL;
2250
2251 break; /* will return non-zero "signr" value */
2252 }
2253
2254 /*
2255 * Now we are doing the default action for this signal.
2256 */
2257 if (sig_kernel_ignore(signr)) /* Default is nothing. */
2258 continue;
2259
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -08002260 /*
Sukadev Bhattiprolu0fbc26a2007-10-18 23:40:13 -07002261 * Global init gets no signals it doesn't want.
Sukadev Bhattiprolub3bfa0c2009-04-02 16:58:08 -07002262 * Container-init gets no signals it doesn't want from same
2263 * container.
2264 *
2265 * Note that if global/container-init sees a sig_kernel_only()
2266 * signal here, the signal must have been generated internally
2267 * or must have come from an ancestor namespace. In either
2268 * case, the signal cannot be dropped.
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -08002269 */
Oleg Nesterovfae5fa42008-04-30 00:53:03 -07002270 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
Sukadev Bhattiprolub3bfa0c2009-04-02 16:58:08 -07002271 !sig_kernel_only(signr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 continue;
2273
2274 if (sig_kernel_stop(signr)) {
2275 /*
2276 * The default action is to stop all threads in
2277 * the thread group. The job control signals
2278 * do nothing in an orphaned pgrp, but SIGSTOP
2279 * always works. Note that siglock needs to be
2280 * dropped during the call to is_orphaned_pgrp()
2281 * because of lock ordering with tasklist_lock.
2282 * This allows an intervening SIGCONT to be posted.
2283 * We need to check for that and bail out if necessary.
2284 */
2285 if (signr != SIGSTOP) {
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002286 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287
2288 /* signals can be posted during this window */
2289
Eric W. Biederman3e7cd6c2007-02-12 00:52:58 -08002290 if (is_current_pgrp_orphaned())
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 goto relock;
2292
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002293 spin_lock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 }
2295
Richard Weinberger828b1f62013-10-07 15:26:57 +02002296 if (likely(do_signal_stop(ksig->info.si_signo))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297 /* It released the siglock. */
2298 goto relock;
2299 }
2300
2301 /*
2302 * We didn't actually stop, due to a race
2303 * with SIGCONT or something like that.
2304 */
2305 continue;
2306 }
2307
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002308 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309
2310 /*
2311 * Anything else is fatal, maybe with a core dump.
2312 */
2313 current->flags |= PF_SIGNALED;
Oleg Nesterov2dce81b2008-04-30 00:52:58 -07002314
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 if (sig_kernel_coredump(signr)) {
Oleg Nesterov2dce81b2008-04-30 00:52:58 -07002316 if (print_fatal_signals)
Richard Weinberger828b1f62013-10-07 15:26:57 +02002317 print_fatal_signal(ksig->info.si_signo);
Jesper Derehag2b5faa42013-03-19 20:50:05 +00002318 proc_coredump_connector(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319 /*
2320 * If it was able to dump core, this kills all
2321 * other threads in the group and synchronizes with
2322 * their demise. If we lost the race with another
2323 * thread getting here, it set group_exit_code
2324 * first and our do_group_exit call below will use
2325 * that value and ignore the one we pass it.
2326 */
Richard Weinberger828b1f62013-10-07 15:26:57 +02002327 do_coredump(&ksig->info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328 }
2329
2330 /*
2331 * Death signals, no core dump.
2332 */
Richard Weinberger828b1f62013-10-07 15:26:57 +02002333 do_group_exit(ksig->info.si_signo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 /* NOTREACHED */
2335 }
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002336 spin_unlock_irq(&sighand->siglock);
Richard Weinberger828b1f62013-10-07 15:26:57 +02002337
2338 ksig->sig = signr;
2339 return ksig->sig > 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340}
2341
Matt Fleming5e6292c2012-01-10 15:11:17 -08002342/**
Al Viroefee9842012-04-28 02:04:15 -04002343 * signal_delivered -
Richard Weinberger10b1c7a2014-07-13 13:36:04 +02002344 * @ksig: kernel signal struct
Al Viroefee9842012-04-28 02:04:15 -04002345 * @stepping: nonzero if debugger single-step or block-step in use
Matt Fleming5e6292c2012-01-10 15:11:17 -08002346 *
Masanari Iidae2278672014-02-18 22:54:36 +09002347 * This function should be called when a signal has successfully been
Richard Weinberger10b1c7a2014-07-13 13:36:04 +02002348 * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
Al Viroefee9842012-04-28 02:04:15 -04002349 * is always blocked, and the signal itself is blocked unless %SA_NODEFER
Richard Weinberger10b1c7a2014-07-13 13:36:04 +02002350 * is set in @ksig->ka.sa.sa_flags. Tracing is notified.
Matt Fleming5e6292c2012-01-10 15:11:17 -08002351 */
Richard Weinberger10b1c7a2014-07-13 13:36:04 +02002352static void signal_delivered(struct ksignal *ksig, int stepping)
Matt Fleming5e6292c2012-01-10 15:11:17 -08002353{
2354 sigset_t blocked;
2355
Al Viroa610d6e2012-05-21 23:42:15 -04002356 /* A signal was successfully delivered, and the
2357 saved sigmask was stored on the signal frame,
2358 and will be restored by sigreturn. So we can
2359 simply clear the restore sigmask flag. */
2360 clear_restore_sigmask();
2361
Richard Weinberger10b1c7a2014-07-13 13:36:04 +02002362 sigorsets(&blocked, &current->blocked, &ksig->ka.sa.sa_mask);
2363 if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
2364 sigaddset(&blocked, ksig->sig);
Matt Fleming5e6292c2012-01-10 15:11:17 -08002365 set_current_blocked(&blocked);
Richard Weinbergerdf5601f2013-10-07 15:37:19 +02002366 tracehook_signal_handler(stepping);
Matt Fleming5e6292c2012-01-10 15:11:17 -08002367}
2368
Al Viro2ce5da12012-11-07 15:11:25 -05002369void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
2370{
2371 if (failed)
2372 force_sigsegv(ksig->sig, current);
2373 else
Richard Weinberger10b1c7a2014-07-13 13:36:04 +02002374 signal_delivered(ksig, stepping);
Al Viro2ce5da12012-11-07 15:11:25 -05002375}
2376
Oleg Nesterov0edceb7bc2011-04-27 19:17:37 +02002377/*
2378 * It could be that complete_signal() picked us to notify about the
Oleg Nesterovfec99932011-04-27 19:50:21 +02002379 * group-wide signal. Other threads should be notified now to take
2380 * the shared signals in @which since we will not.
Oleg Nesterov0edceb7bc2011-04-27 19:17:37 +02002381 */
Oleg Nesterovf646e222011-04-27 19:18:39 +02002382static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
Oleg Nesterov0edceb7bc2011-04-27 19:17:37 +02002383{
Oleg Nesterovf646e222011-04-27 19:18:39 +02002384 sigset_t retarget;
Oleg Nesterov0edceb7bc2011-04-27 19:17:37 +02002385 struct task_struct *t;
2386
Oleg Nesterovf646e222011-04-27 19:18:39 +02002387 sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
2388 if (sigisemptyset(&retarget))
2389 return;
2390
Oleg Nesterov0edceb7bc2011-04-27 19:17:37 +02002391 t = tsk;
2392 while_each_thread(tsk, t) {
Oleg Nesterovfec99932011-04-27 19:50:21 +02002393 if (t->flags & PF_EXITING)
2394 continue;
2395
2396 if (!has_pending_signals(&retarget, &t->blocked))
2397 continue;
2398 /* Remove the signals this thread can handle. */
2399 sigandsets(&retarget, &retarget, &t->blocked);
2400
2401 if (!signal_pending(t))
2402 signal_wake_up(t, 0);
2403
2404 if (sigisemptyset(&retarget))
2405 break;
Oleg Nesterov0edceb7bc2011-04-27 19:17:37 +02002406 }
2407}
2408
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002409void exit_signals(struct task_struct *tsk)
2410{
2411 int group_stop = 0;
Oleg Nesterovf646e222011-04-27 19:18:39 +02002412 sigset_t unblocked;
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002413
Tejun Heo77e4ef92011-12-12 18:12:21 -08002414 /*
2415 * @tsk is about to have PF_EXITING set - lock out users which
2416 * expect stable threadgroup.
2417 */
Ingo Molnar780de9d2017-02-02 11:50:56 +01002418 cgroup_threadgroup_change_begin(tsk);
Tejun Heo77e4ef92011-12-12 18:12:21 -08002419
Oleg Nesterov5dee1702008-02-08 04:19:13 -08002420 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
2421 tsk->flags |= PF_EXITING;
Ingo Molnar780de9d2017-02-02 11:50:56 +01002422 cgroup_threadgroup_change_end(tsk);
Oleg Nesterov5dee1702008-02-08 04:19:13 -08002423 return;
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002424 }
2425
Oleg Nesterov5dee1702008-02-08 04:19:13 -08002426 spin_lock_irq(&tsk->sighand->siglock);
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002427 /*
2428 * From now this task is not visible for group-wide signals,
2429 * see wants_signal(), do_signal_stop().
2430 */
2431 tsk->flags |= PF_EXITING;
Tejun Heo77e4ef92011-12-12 18:12:21 -08002432
Ingo Molnar780de9d2017-02-02 11:50:56 +01002433 cgroup_threadgroup_change_end(tsk);
Tejun Heo77e4ef92011-12-12 18:12:21 -08002434
Oleg Nesterov5dee1702008-02-08 04:19:13 -08002435 if (!signal_pending(tsk))
2436 goto out;
2437
Oleg Nesterovf646e222011-04-27 19:18:39 +02002438 unblocked = tsk->blocked;
2439 signotset(&unblocked);
2440 retarget_shared_pending(tsk, &unblocked);
Oleg Nesterov5dee1702008-02-08 04:19:13 -08002441
Tejun Heoa8f072c2011-06-02 11:13:59 +02002442 if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
Tejun Heoe5c1902e2011-03-23 10:37:00 +01002443 task_participate_group_stop(tsk))
Tejun Heoedf2ed12011-03-23 10:37:00 +01002444 group_stop = CLD_STOPPED;
Oleg Nesterov5dee1702008-02-08 04:19:13 -08002445out:
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002446 spin_unlock_irq(&tsk->sighand->siglock);
2447
Tejun Heo62bcf9d2011-03-23 10:37:01 +01002448 /*
2449 * If group stop has completed, deliver the notification. This
2450 * should always go to the real parent of the group leader.
2451 */
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002452 if (unlikely(group_stop)) {
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002453 read_lock(&tasklist_lock);
Tejun Heo62bcf9d2011-03-23 10:37:01 +01002454 do_notify_parent_cldstop(tsk, false, group_stop);
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002455 read_unlock(&tasklist_lock);
2456 }
2457}
2458
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459EXPORT_SYMBOL(recalc_sigpending);
2460EXPORT_SYMBOL_GPL(dequeue_signal);
2461EXPORT_SYMBOL(flush_signals);
2462EXPORT_SYMBOL(force_sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463EXPORT_SYMBOL(send_sig);
2464EXPORT_SYMBOL(send_sig_info);
2465EXPORT_SYMBOL(sigprocmask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466
2467/*
2468 * System call entry points.
2469 */
2470
Randy Dunlap41c57892011-04-04 15:00:26 -07002471/**
2472 * sys_restart_syscall - restart a system call
2473 */
Heiko Carstens754fe8d2009-01-14 14:14:09 +01002474SYSCALL_DEFINE0(restart_syscall)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475{
Andy Lutomirskif56141e2015-02-12 15:01:14 -08002476 struct restart_block *restart = &current->restart_block;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 return restart->fn(restart);
2478}
2479
2480long do_no_restart_syscall(struct restart_block *param)
2481{
2482 return -EINTR;
2483}
2484
Oleg Nesterovb1828012011-04-27 21:56:14 +02002485static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
2486{
2487 if (signal_pending(tsk) && !thread_group_empty(tsk)) {
2488 sigset_t newblocked;
2489 /* A set of now blocked but previously unblocked signals. */
Oleg Nesterov702a5072011-04-27 22:01:27 +02002490 sigandnsets(&newblocked, newset, &current->blocked);
Oleg Nesterovb1828012011-04-27 21:56:14 +02002491 retarget_shared_pending(tsk, &newblocked);
2492 }
2493 tsk->blocked = *newset;
2494 recalc_sigpending();
2495}
2496
Oleg Nesterove6fa16a2011-04-27 20:59:41 +02002497/**
2498 * set_current_blocked - change current->blocked mask
2499 * @newset: new mask
2500 *
2501 * It is wrong to change ->blocked directly, this helper should be used
2502 * to ensure the process can't miss a shared signal we are going to block.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503 */
Al Viro77097ae2012-04-27 13:58:59 -04002504void set_current_blocked(sigset_t *newset)
2505{
Al Viro77097ae2012-04-27 13:58:59 -04002506 sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
Oleg Nesterov0c4a8422013-01-05 19:13:29 +01002507 __set_current_blocked(newset);
Al Viro77097ae2012-04-27 13:58:59 -04002508}
2509
2510void __set_current_blocked(const sigset_t *newset)
Oleg Nesterove6fa16a2011-04-27 20:59:41 +02002511{
2512 struct task_struct *tsk = current;
2513
Waiman Longc7be96a2016-12-14 15:04:10 -08002514 /*
2515 * In case the signal mask hasn't changed, there is nothing we need
2516 * to do. The current->blocked shouldn't be modified by other task.
2517 */
2518 if (sigequalsets(&tsk->blocked, newset))
2519 return;
2520
Oleg Nesterove6fa16a2011-04-27 20:59:41 +02002521 spin_lock_irq(&tsk->sighand->siglock);
Oleg Nesterovb1828012011-04-27 21:56:14 +02002522 __set_task_blocked(tsk, newset);
Oleg Nesterove6fa16a2011-04-27 20:59:41 +02002523 spin_unlock_irq(&tsk->sighand->siglock);
2524}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525
2526/*
2527 * This is also useful for kernel threads that want to temporarily
2528 * (or permanently) block certain signals.
2529 *
2530 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2531 * interface happily blocks "unblockable" signals like SIGKILL
2532 * and friends.
2533 */
2534int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2535{
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002536 struct task_struct *tsk = current;
2537 sigset_t newset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002539 /* Lockless, only current can change ->blocked, never from irq */
Oleg Nesterova26fd332006-03-23 03:00:49 -08002540 if (oldset)
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002541 *oldset = tsk->blocked;
Oleg Nesterova26fd332006-03-23 03:00:49 -08002542
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543 switch (how) {
2544 case SIG_BLOCK:
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002545 sigorsets(&newset, &tsk->blocked, set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546 break;
2547 case SIG_UNBLOCK:
Oleg Nesterov702a5072011-04-27 22:01:27 +02002548 sigandnsets(&newset, &tsk->blocked, set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549 break;
2550 case SIG_SETMASK:
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002551 newset = *set;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552 break;
2553 default:
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002554 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 }
Oleg Nesterova26fd332006-03-23 03:00:49 -08002556
Al Viro77097ae2012-04-27 13:58:59 -04002557 __set_current_blocked(&newset);
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002558 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559}
2560
Randy Dunlap41c57892011-04-04 15:00:26 -07002561/**
2562 * sys_rt_sigprocmask - change the list of currently blocked signals
2563 * @how: whether to add, remove, or set signals
Randy Dunlapada9c932011-06-14 15:50:11 -07002564 * @nset: stores pending signals
Randy Dunlap41c57892011-04-04 15:00:26 -07002565 * @oset: previous value of signal mask if non-null
2566 * @sigsetsize: size of sigset_t type
2567 */
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002568SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
Heiko Carstens17da2bd2009-01-14 14:14:10 +01002569 sigset_t __user *, oset, size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571 sigset_t old_set, new_set;
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002572 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573
2574 /* XXX: Don't preclude handling different sized sigset_t's. */
2575 if (sigsetsize != sizeof(sigset_t))
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002576 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002578 old_set = current->blocked;
2579
2580 if (nset) {
2581 if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
2582 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2584
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002585 error = sigprocmask(how, &new_set, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586 if (error)
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002587 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 }
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002589
2590 if (oset) {
2591 if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
2592 return -EFAULT;
2593 }
2594
2595 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596}
2597
Al Viro322a56c2012-12-25 13:32:58 -05002598#ifdef CONFIG_COMPAT
Al Viro322a56c2012-12-25 13:32:58 -05002599COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
2600 compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601{
Al Viro322a56c2012-12-25 13:32:58 -05002602#ifdef __BIG_ENDIAN
2603 sigset_t old_set = current->blocked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604
Al Viro322a56c2012-12-25 13:32:58 -05002605 /* XXX: Don't preclude handling different sized sigset_t's. */
2606 if (sigsetsize != sizeof(sigset_t))
2607 return -EINVAL;
2608
2609 if (nset) {
2610 compat_sigset_t new32;
2611 sigset_t new_set;
2612 int error;
2613 if (copy_from_user(&new32, nset, sizeof(compat_sigset_t)))
2614 return -EFAULT;
2615
2616 sigset_from_compat(&new_set, &new32);
2617 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2618
2619 error = sigprocmask(how, &new_set, NULL);
2620 if (error)
2621 return error;
2622 }
2623 if (oset) {
2624 compat_sigset_t old32;
2625 sigset_to_compat(&old32, &old_set);
Al Virodb61ec22013-03-02 20:39:15 -05002626 if (copy_to_user(oset, &old32, sizeof(compat_sigset_t)))
Al Viro322a56c2012-12-25 13:32:58 -05002627 return -EFAULT;
2628 }
2629 return 0;
2630#else
2631 return sys_rt_sigprocmask(how, (sigset_t __user *)nset,
2632 (sigset_t __user *)oset, sigsetsize);
2633#endif
2634}
2635#endif
Al Viro322a56c2012-12-25 13:32:58 -05002636
Al Virofe9c1db2012-12-25 14:31:38 -05002637static int do_sigpending(void *set, unsigned long sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639 if (sigsetsize > sizeof(sigset_t))
Al Virofe9c1db2012-12-25 14:31:38 -05002640 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641
2642 spin_lock_irq(&current->sighand->siglock);
Al Virofe9c1db2012-12-25 14:31:38 -05002643 sigorsets(set, &current->pending.signal,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002644 &current->signal->shared_pending.signal);
2645 spin_unlock_irq(&current->sighand->siglock);
2646
2647 /* Outside the lock because only this thread touches it. */
Al Virofe9c1db2012-12-25 14:31:38 -05002648 sigandsets(set, &current->blocked, set);
2649 return 0;
Randy Dunlap5aba0852011-04-04 14:59:31 -07002650}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002651
Randy Dunlap41c57892011-04-04 15:00:26 -07002652/**
2653 * sys_rt_sigpending - examine a pending signal that has been raised
2654 * while blocked
Randy Dunlap20f22ab2013-03-04 14:32:59 -08002655 * @uset: stores pending signals
Randy Dunlap41c57892011-04-04 15:00:26 -07002656 * @sigsetsize: size of sigset_t type or larger
2657 */
Al Virofe9c1db2012-12-25 14:31:38 -05002658SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659{
Al Virofe9c1db2012-12-25 14:31:38 -05002660 sigset_t set;
2661 int err = do_sigpending(&set, sigsetsize);
2662 if (!err && copy_to_user(uset, &set, sigsetsize))
2663 err = -EFAULT;
2664 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002665}
2666
Al Virofe9c1db2012-12-25 14:31:38 -05002667#ifdef CONFIG_COMPAT
Al Virofe9c1db2012-12-25 14:31:38 -05002668COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
2669 compat_size_t, sigsetsize)
2670{
2671#ifdef __BIG_ENDIAN
2672 sigset_t set;
2673 int err = do_sigpending(&set, sigsetsize);
2674 if (!err) {
2675 compat_sigset_t set32;
2676 sigset_to_compat(&set32, &set);
2677 /* we can get here only if sigsetsize <= sizeof(set) */
2678 if (copy_to_user(uset, &set32, sigsetsize))
2679 err = -EFAULT;
2680 }
2681 return err;
2682#else
2683 return sys_rt_sigpending((sigset_t __user *)uset, sigsetsize);
2684#endif
2685}
2686#endif
Al Virofe9c1db2012-12-25 14:31:38 -05002687
Eric W. Biedermancc731522017-07-16 22:36:59 -05002688enum siginfo_layout siginfo_layout(int sig, int si_code)
2689{
2690 enum siginfo_layout layout = SIL_KILL;
2691 if ((si_code > SI_USER) && (si_code < SI_KERNEL)) {
2692 static const struct {
2693 unsigned char limit, layout;
2694 } filter[] = {
2695 [SIGILL] = { NSIGILL, SIL_FAULT },
2696 [SIGFPE] = { NSIGFPE, SIL_FAULT },
2697 [SIGSEGV] = { NSIGSEGV, SIL_FAULT },
2698 [SIGBUS] = { NSIGBUS, SIL_FAULT },
2699 [SIGTRAP] = { NSIGTRAP, SIL_FAULT },
Andrew Claytonc3aff082017-11-01 15:49:59 +00002700#if defined(SIGEMT) && defined(NSIGEMT)
Eric W. Biedermancc731522017-07-16 22:36:59 -05002701 [SIGEMT] = { NSIGEMT, SIL_FAULT },
2702#endif
2703 [SIGCHLD] = { NSIGCHLD, SIL_CHLD },
2704 [SIGPOLL] = { NSIGPOLL, SIL_POLL },
2705#ifdef __ARCH_SIGSYS
2706 [SIGSYS] = { NSIGSYS, SIL_SYS },
2707#endif
2708 };
2709 if ((sig < ARRAY_SIZE(filter)) && (si_code <= filter[sig].limit))
2710 layout = filter[sig].layout;
2711 else if (si_code <= NSIGPOLL)
2712 layout = SIL_POLL;
2713 } else {
2714 if (si_code == SI_TIMER)
2715 layout = SIL_TIMER;
2716 else if (si_code == SI_SIGIO)
2717 layout = SIL_POLL;
2718 else if (si_code < 0)
2719 layout = SIL_RT;
2720 /* Tests to support buggy kernel ABIs */
2721#ifdef TRAP_FIXME
2722 if ((sig == SIGTRAP) && (si_code == TRAP_FIXME))
2723 layout = SIL_FAULT;
2724#endif
2725#ifdef FPE_FIXME
2726 if ((sig == SIGFPE) && (si_code == FPE_FIXME))
2727 layout = SIL_FAULT;
2728#endif
2729 }
2730 return layout;
2731}
2732
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733#ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2734
Al Viroce395962013-10-13 17:23:53 -04002735int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736{
2737 int err;
2738
2739 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2740 return -EFAULT;
2741 if (from->si_code < 0)
2742 return __copy_to_user(to, from, sizeof(siginfo_t))
2743 ? -EFAULT : 0;
2744 /*
2745 * If you change siginfo_t structure, please be sure
2746 * this code is fixed accordingly.
Davide Libenzifba2afa2007-05-10 22:23:13 -07002747 * Please remember to update the signalfd_copyinfo() function
2748 * inside fs/signalfd.c too, in case siginfo_t changes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749 * It should never copy any pad contained in the structure
2750 * to avoid security leaks, but must copy the generic
2751 * 3 ints plus the relevant union member.
2752 */
2753 err = __put_user(from->si_signo, &to->si_signo);
2754 err |= __put_user(from->si_errno, &to->si_errno);
Eric W. Biedermancc731522017-07-16 22:36:59 -05002755 err |= __put_user(from->si_code, &to->si_code);
2756 switch (siginfo_layout(from->si_signo, from->si_code)) {
2757 case SIL_KILL:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758 err |= __put_user(from->si_pid, &to->si_pid);
2759 err |= __put_user(from->si_uid, &to->si_uid);
2760 break;
Eric W. Biedermancc731522017-07-16 22:36:59 -05002761 case SIL_TIMER:
2762 /* Unreached SI_TIMER is negative */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763 break;
Eric W. Biedermancc731522017-07-16 22:36:59 -05002764 case SIL_POLL:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002765 err |= __put_user(from->si_band, &to->si_band);
2766 err |= __put_user(from->si_fd, &to->si_fd);
2767 break;
Eric W. Biedermancc731522017-07-16 22:36:59 -05002768 case SIL_FAULT:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769 err |= __put_user(from->si_addr, &to->si_addr);
2770#ifdef __ARCH_SI_TRAPNO
2771 err |= __put_user(from->si_trapno, &to->si_trapno);
2772#endif
Andi Kleena337fda2010-09-27 20:32:19 +02002773#ifdef BUS_MCEERR_AO
Randy Dunlap5aba0852011-04-04 14:59:31 -07002774 /*
Andi Kleena337fda2010-09-27 20:32:19 +02002775 * Other callers might not initialize the si_lsb field,
Randy Dunlap5aba0852011-04-04 14:59:31 -07002776 * so check explicitly for the right codes here.
Andi Kleena337fda2010-09-27 20:32:19 +02002777 */
Amanieu d'Antras26135022015-08-06 15:46:29 -07002778 if (from->si_signo == SIGBUS &&
2779 (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO))
Andi Kleena337fda2010-09-27 20:32:19 +02002780 err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
2781#endif
Qiaowei Renee1b58d2014-11-14 07:18:19 -08002782#ifdef SEGV_BNDERR
Amanieu d'Antras26135022015-08-06 15:46:29 -07002783 if (from->si_signo == SIGSEGV && from->si_code == SEGV_BNDERR) {
2784 err |= __put_user(from->si_lower, &to->si_lower);
2785 err |= __put_user(from->si_upper, &to->si_upper);
2786 }
Qiaowei Renee1b58d2014-11-14 07:18:19 -08002787#endif
Dave Hansencd0ea352016-02-12 13:02:12 -08002788#ifdef SEGV_PKUERR
2789 if (from->si_signo == SIGSEGV && from->si_code == SEGV_PKUERR)
2790 err |= __put_user(from->si_pkey, &to->si_pkey);
2791#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792 break;
Eric W. Biedermancc731522017-07-16 22:36:59 -05002793 case SIL_CHLD:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794 err |= __put_user(from->si_pid, &to->si_pid);
2795 err |= __put_user(from->si_uid, &to->si_uid);
2796 err |= __put_user(from->si_status, &to->si_status);
2797 err |= __put_user(from->si_utime, &to->si_utime);
2798 err |= __put_user(from->si_stime, &to->si_stime);
2799 break;
Eric W. Biedermancc731522017-07-16 22:36:59 -05002800 case SIL_RT:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801 err |= __put_user(from->si_pid, &to->si_pid);
2802 err |= __put_user(from->si_uid, &to->si_uid);
2803 err |= __put_user(from->si_ptr, &to->si_ptr);
2804 break;
Will Drewrya0727e82012-04-12 16:48:00 -05002805#ifdef __ARCH_SIGSYS
Eric W. Biedermancc731522017-07-16 22:36:59 -05002806 case SIL_SYS:
Will Drewrya0727e82012-04-12 16:48:00 -05002807 err |= __put_user(from->si_call_addr, &to->si_call_addr);
2808 err |= __put_user(from->si_syscall, &to->si_syscall);
2809 err |= __put_user(from->si_arch, &to->si_arch);
2810 break;
2811#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812 }
2813 return err;
2814}
2815
2816#endif
2817
Randy Dunlap41c57892011-04-04 15:00:26 -07002818/**
Oleg Nesterov943df142011-04-27 21:44:14 +02002819 * do_sigtimedwait - wait for queued signals specified in @which
2820 * @which: queued signals to wait for
2821 * @info: if non-null, the signal's siginfo is returned here
2822 * @ts: upper bound on process time suspension
2823 */
Al Viro1b3c8722017-05-31 04:46:17 -04002824static int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
Thomas Gleixner2b1ecc32016-07-04 09:50:25 +00002825 const struct timespec *ts)
Oleg Nesterov943df142011-04-27 21:44:14 +02002826{
Thomas Gleixner2456e852016-12-25 11:38:40 +01002827 ktime_t *to = NULL, timeout = KTIME_MAX;
Oleg Nesterov943df142011-04-27 21:44:14 +02002828 struct task_struct *tsk = current;
Oleg Nesterov943df142011-04-27 21:44:14 +02002829 sigset_t mask = *which;
Thomas Gleixner2b1ecc32016-07-04 09:50:25 +00002830 int sig, ret = 0;
Oleg Nesterov943df142011-04-27 21:44:14 +02002831
2832 if (ts) {
2833 if (!timespec_valid(ts))
2834 return -EINVAL;
Thomas Gleixner2b1ecc32016-07-04 09:50:25 +00002835 timeout = timespec_to_ktime(*ts);
2836 to = &timeout;
Oleg Nesterov943df142011-04-27 21:44:14 +02002837 }
2838
2839 /*
2840 * Invert the set of allowed signals to get those we want to block.
2841 */
2842 sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
2843 signotset(&mask);
2844
2845 spin_lock_irq(&tsk->sighand->siglock);
2846 sig = dequeue_signal(tsk, &mask, info);
Thomas Gleixner2456e852016-12-25 11:38:40 +01002847 if (!sig && timeout) {
Oleg Nesterov943df142011-04-27 21:44:14 +02002848 /*
2849 * None ready, temporarily unblock those we're interested
2850 * while we are sleeping in so that we'll be awakened when
Oleg Nesterovb1828012011-04-27 21:56:14 +02002851 * they arrive. Unblocking is always fine, we can avoid
2852 * set_current_blocked().
Oleg Nesterov943df142011-04-27 21:44:14 +02002853 */
2854 tsk->real_blocked = tsk->blocked;
2855 sigandsets(&tsk->blocked, &tsk->blocked, &mask);
2856 recalc_sigpending();
2857 spin_unlock_irq(&tsk->sighand->siglock);
2858
Thomas Gleixner2b1ecc32016-07-04 09:50:25 +00002859 __set_current_state(TASK_INTERRUPTIBLE);
2860 ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns,
2861 HRTIMER_MODE_REL);
Oleg Nesterov943df142011-04-27 21:44:14 +02002862 spin_lock_irq(&tsk->sighand->siglock);
Oleg Nesterovb1828012011-04-27 21:56:14 +02002863 __set_task_blocked(tsk, &tsk->real_blocked);
Oleg Nesterov61140412014-06-06 14:36:46 -07002864 sigemptyset(&tsk->real_blocked);
Oleg Nesterovb1828012011-04-27 21:56:14 +02002865 sig = dequeue_signal(tsk, &mask, info);
Oleg Nesterov943df142011-04-27 21:44:14 +02002866 }
2867 spin_unlock_irq(&tsk->sighand->siglock);
2868
2869 if (sig)
2870 return sig;
Thomas Gleixner2b1ecc32016-07-04 09:50:25 +00002871 return ret ? -EINTR : -EAGAIN;
Oleg Nesterov943df142011-04-27 21:44:14 +02002872}
2873
2874/**
Randy Dunlap41c57892011-04-04 15:00:26 -07002875 * sys_rt_sigtimedwait - synchronously wait for queued signals specified
2876 * in @uthese
2877 * @uthese: queued signals to wait for
2878 * @uinfo: if non-null, the signal's siginfo is returned here
2879 * @uts: upper bound on process time suspension
2880 * @sigsetsize: size of sigset_t type
2881 */
Heiko Carstens17da2bd2009-01-14 14:14:10 +01002882SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
2883 siginfo_t __user *, uinfo, const struct timespec __user *, uts,
2884 size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886 sigset_t these;
2887 struct timespec ts;
2888 siginfo_t info;
Oleg Nesterov943df142011-04-27 21:44:14 +02002889 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890
2891 /* XXX: Don't preclude handling different sized sigset_t's. */
2892 if (sigsetsize != sizeof(sigset_t))
2893 return -EINVAL;
2894
2895 if (copy_from_user(&these, uthese, sizeof(these)))
2896 return -EFAULT;
Randy Dunlap5aba0852011-04-04 14:59:31 -07002897
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898 if (uts) {
2899 if (copy_from_user(&ts, uts, sizeof(ts)))
2900 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901 }
2902
Oleg Nesterov943df142011-04-27 21:44:14 +02002903 ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002904
Oleg Nesterov943df142011-04-27 21:44:14 +02002905 if (ret > 0 && uinfo) {
2906 if (copy_siginfo_to_user(uinfo, &info))
2907 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002908 }
2909
2910 return ret;
2911}
2912
Al Viro1b3c8722017-05-31 04:46:17 -04002913#ifdef CONFIG_COMPAT
2914COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait, compat_sigset_t __user *, uthese,
2915 struct compat_siginfo __user *, uinfo,
2916 struct compat_timespec __user *, uts, compat_size_t, sigsetsize)
2917{
2918 compat_sigset_t s32;
2919 sigset_t s;
2920 struct timespec t;
2921 siginfo_t info;
2922 long ret;
2923
2924 if (sigsetsize != sizeof(sigset_t))
2925 return -EINVAL;
2926
2927 if (copy_from_user(&s32, uthese, sizeof(compat_sigset_t)))
2928 return -EFAULT;
2929 sigset_from_compat(&s, &s32);
2930
2931 if (uts) {
2932 if (compat_get_timespec(&t, uts))
2933 return -EFAULT;
2934 }
2935
2936 ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
2937
2938 if (ret > 0 && uinfo) {
2939 if (copy_siginfo_to_user32(uinfo, &info))
2940 ret = -EFAULT;
2941 }
2942
2943 return ret;
2944}
2945#endif
2946
Randy Dunlap41c57892011-04-04 15:00:26 -07002947/**
2948 * sys_kill - send a signal to a process
2949 * @pid: the PID of the process
2950 * @sig: signal to be sent
2951 */
Heiko Carstens17da2bd2009-01-14 14:14:10 +01002952SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002953{
2954 struct siginfo info;
2955
2956 info.si_signo = sig;
2957 info.si_errno = 0;
2958 info.si_code = SI_USER;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002959 info.si_pid = task_tgid_vnr(current);
Eric W. Biederman078de5f2012-02-08 07:00:08 -08002960 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961
2962 return kill_something_info(sig, &info, pid);
2963}
2964
Thomas Gleixner30b4ae82009-04-04 21:01:01 +00002965static int
2966do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002967{
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002968 struct task_struct *p;
Thomas Gleixner30b4ae82009-04-04 21:01:01 +00002969 int error = -ESRCH;
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002970
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002971 rcu_read_lock();
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -07002972 p = find_task_by_vpid(pid);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002973 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
Thomas Gleixner30b4ae82009-04-04 21:01:01 +00002974 error = check_kill_permission(sig, info, p);
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002975 /*
2976 * The null signal is a permissions and process existence
2977 * probe. No signal is actually delivered.
2978 */
Oleg Nesterov4a30deb2009-09-23 15:57:00 -07002979 if (!error && sig) {
2980 error = do_send_sig_info(sig, info, p, false);
2981 /*
2982 * If lock_task_sighand() failed we pretend the task
2983 * dies after receiving the signal. The window is tiny,
2984 * and the signal is private anyway.
2985 */
2986 if (unlikely(error == -ESRCH))
2987 error = 0;
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002988 }
2989 }
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002990 rcu_read_unlock();
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002991
2992 return error;
2993}
2994
Thomas Gleixner30b4ae82009-04-04 21:01:01 +00002995static int do_tkill(pid_t tgid, pid_t pid, int sig)
2996{
Emese Revfyb9e146d2013-04-17 15:58:36 -07002997 struct siginfo info = {};
Thomas Gleixner30b4ae82009-04-04 21:01:01 +00002998
2999 info.si_signo = sig;
3000 info.si_errno = 0;
3001 info.si_code = SI_TKILL;
3002 info.si_pid = task_tgid_vnr(current);
Eric W. Biederman078de5f2012-02-08 07:00:08 -08003003 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
Thomas Gleixner30b4ae82009-04-04 21:01:01 +00003004
3005 return do_send_specific(tgid, pid, sig, &info);
3006}
3007
Linus Torvalds1da177e2005-04-16 15:20:36 -07003008/**
3009 * sys_tgkill - send signal to one specific thread
3010 * @tgid: the thread group ID of the thread
3011 * @pid: the PID of the thread
3012 * @sig: signal to be sent
3013 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08003014 * This syscall also checks the @tgid and returns -ESRCH even if the PID
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015 * exists but it's not belonging to the target process anymore. This
3016 * method solves the problem of threads exiting and PIDs getting reused.
3017 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01003018SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003020 /* This is only valid for single tasks */
3021 if (pid <= 0 || tgid <= 0)
3022 return -EINVAL;
3023
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08003024 return do_tkill(tgid, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003025}
3026
Randy Dunlap41c57892011-04-04 15:00:26 -07003027/**
3028 * sys_tkill - send signal to one specific task
3029 * @pid: the PID of the task
3030 * @sig: signal to be sent
3031 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 * Send a signal to only one task, even if it's a CLONE_THREAD task.
3033 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01003034SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036 /* This is only valid for single tasks */
3037 if (pid <= 0)
3038 return -EINVAL;
3039
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08003040 return do_tkill(0, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003041}
3042
Al Viro75907d42012-12-25 15:19:12 -05003043static int do_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t *info)
3044{
3045 /* Not even root can pretend to send signals from the kernel.
3046 * Nor can they impersonate a kill()/tgkill(), which adds source info.
3047 */
Andrey Vagin66dd34a2013-02-27 17:03:12 -08003048 if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
Vladimir Davydov69828dc2015-04-16 12:47:35 -07003049 (task_pid_vnr(current) != pid))
Al Viro75907d42012-12-25 15:19:12 -05003050 return -EPERM;
Vladimir Davydov69828dc2015-04-16 12:47:35 -07003051
Al Viro75907d42012-12-25 15:19:12 -05003052 info->si_signo = sig;
3053
3054 /* POSIX.1b doesn't mention process groups. */
3055 return kill_proc_info(sig, info, pid);
3056}
3057
Randy Dunlap41c57892011-04-04 15:00:26 -07003058/**
3059 * sys_rt_sigqueueinfo - send signal information to a signal
3060 * @pid: the PID of the thread
3061 * @sig: signal to be sent
3062 * @uinfo: signal info to be sent
3063 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01003064SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
3065 siginfo_t __user *, uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003066{
3067 siginfo_t info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003068 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3069 return -EFAULT;
Al Viro75907d42012-12-25 15:19:12 -05003070 return do_rt_sigqueueinfo(pid, sig, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003071}
3072
Al Viro75907d42012-12-25 15:19:12 -05003073#ifdef CONFIG_COMPAT
Al Viro75907d42012-12-25 15:19:12 -05003074COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
3075 compat_pid_t, pid,
3076 int, sig,
3077 struct compat_siginfo __user *, uinfo)
3078{
Amanieu d'Antras3c00cb52015-08-06 15:46:26 -07003079 siginfo_t info = {};
Al Viro75907d42012-12-25 15:19:12 -05003080 int ret = copy_siginfo_from_user32(&info, uinfo);
3081 if (unlikely(ret))
3082 return ret;
3083 return do_rt_sigqueueinfo(pid, sig, &info);
3084}
3085#endif
Al Viro75907d42012-12-25 15:19:12 -05003086
Al Viro9aae8fc2012-12-24 23:12:04 -05003087static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
Thomas Gleixner62ab4502009-04-04 21:01:06 +00003088{
3089 /* This is only valid for single tasks */
3090 if (pid <= 0 || tgid <= 0)
3091 return -EINVAL;
3092
3093 /* Not even root can pretend to send signals from the kernel.
Julien Tinnesda485242011-03-18 15:05:21 -07003094 * Nor can they impersonate a kill()/tgkill(), which adds source info.
3095 */
Vladimir Davydov69828dc2015-04-16 12:47:35 -07003096 if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3097 (task_pid_vnr(current) != pid))
Thomas Gleixner62ab4502009-04-04 21:01:06 +00003098 return -EPERM;
Vladimir Davydov69828dc2015-04-16 12:47:35 -07003099
Thomas Gleixner62ab4502009-04-04 21:01:06 +00003100 info->si_signo = sig;
3101
3102 return do_send_specific(tgid, pid, sig, info);
3103}
3104
3105SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
3106 siginfo_t __user *, uinfo)
3107{
3108 siginfo_t info;
3109
3110 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3111 return -EFAULT;
3112
3113 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3114}
3115
Al Viro9aae8fc2012-12-24 23:12:04 -05003116#ifdef CONFIG_COMPAT
3117COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
3118 compat_pid_t, tgid,
3119 compat_pid_t, pid,
3120 int, sig,
3121 struct compat_siginfo __user *, uinfo)
3122{
Amanieu d'Antras3c00cb52015-08-06 15:46:26 -07003123 siginfo_t info = {};
Al Viro9aae8fc2012-12-24 23:12:04 -05003124
3125 if (copy_siginfo_from_user32(&info, uinfo))
3126 return -EFAULT;
3127 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3128}
3129#endif
3130
Oleg Nesterov03417292014-06-06 14:36:53 -07003131/*
Oleg Nesterovb4e74262014-06-06 14:37:00 -07003132 * For kthreads only, must not be used if cloned with CLONE_SIGHAND
Oleg Nesterov03417292014-06-06 14:36:53 -07003133 */
Oleg Nesterovb4e74262014-06-06 14:37:00 -07003134void kernel_sigaction(int sig, __sighandler_t action)
Oleg Nesterov03417292014-06-06 14:36:53 -07003135{
Oleg Nesterovec5955b2014-06-06 14:36:57 -07003136 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterovb4e74262014-06-06 14:37:00 -07003137 current->sighand->action[sig - 1].sa.sa_handler = action;
3138 if (action == SIG_IGN) {
3139 sigset_t mask;
3140
3141 sigemptyset(&mask);
3142 sigaddset(&mask, sig);
3143
3144 flush_sigqueue_mask(&mask, &current->signal->shared_pending);
3145 flush_sigqueue_mask(&mask, &current->pending);
3146 recalc_sigpending();
3147 }
Oleg Nesterov03417292014-06-06 14:36:53 -07003148 spin_unlock_irq(&current->sighand->siglock);
3149}
Oleg Nesterovb4e74262014-06-06 14:37:00 -07003150EXPORT_SYMBOL(kernel_sigaction);
Oleg Nesterov03417292014-06-06 14:36:53 -07003151
Dmitry Safonov68463512016-09-05 16:33:08 +03003152void __weak sigaction_compat_abi(struct k_sigaction *act,
3153 struct k_sigaction *oact)
3154{
3155}
3156
Oleg Nesterov88531f72006-03-28 16:11:24 -08003157int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158{
Oleg Nesterovafe2b032014-06-06 14:36:51 -07003159 struct task_struct *p = current, *t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003160 struct k_sigaction *k;
George Anzinger71fabd5e2006-01-08 01:02:48 -08003161 sigset_t mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003162
Jesper Juhl7ed20e12005-05-01 08:59:14 -07003163 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003164 return -EINVAL;
3165
Oleg Nesterovafe2b032014-06-06 14:36:51 -07003166 k = &p->sighand->action[sig-1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167
Oleg Nesterovafe2b032014-06-06 14:36:51 -07003168 spin_lock_irq(&p->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169 if (oact)
3170 *oact = *k;
3171
Dmitry Safonov68463512016-09-05 16:33:08 +03003172 sigaction_compat_abi(act, oact);
3173
Linus Torvalds1da177e2005-04-16 15:20:36 -07003174 if (act) {
Oleg Nesterov9ac95f22006-02-09 22:41:50 +03003175 sigdelsetmask(&act->sa.sa_mask,
3176 sigmask(SIGKILL) | sigmask(SIGSTOP));
Oleg Nesterov88531f72006-03-28 16:11:24 -08003177 *k = *act;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003178 /*
3179 * POSIX 3.3.1.3:
3180 * "Setting a signal action to SIG_IGN for a signal that is
3181 * pending shall cause the pending signal to be discarded,
3182 * whether or not it is blocked."
3183 *
3184 * "Setting a signal action to SIG_DFL for a signal that is
3185 * pending and whose default action is to ignore the signal
3186 * (for example, SIGCHLD), shall cause the pending signal to
3187 * be discarded, whether or not it is blocked"
3188 */
Oleg Nesterovafe2b032014-06-06 14:36:51 -07003189 if (sig_handler_ignored(sig_handler(p, sig), sig)) {
George Anzinger71fabd5e2006-01-08 01:02:48 -08003190 sigemptyset(&mask);
3191 sigaddset(&mask, sig);
Oleg Nesterovafe2b032014-06-06 14:36:51 -07003192 flush_sigqueue_mask(&mask, &p->signal->shared_pending);
3193 for_each_thread(p, t)
Oleg Nesterovc09c1442014-06-06 14:36:50 -07003194 flush_sigqueue_mask(&mask, &t->pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003195 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003196 }
3197
Oleg Nesterovafe2b032014-06-06 14:36:51 -07003198 spin_unlock_irq(&p->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003199 return 0;
3200}
3201
Oleg Nesterovc09c1442014-06-06 14:36:50 -07003202static int
Al Virobcfe8ad2017-05-27 00:29:34 -04003203do_sigaltstack (const stack_t *ss, stack_t *oss, unsigned long sp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204{
Al Virobcfe8ad2017-05-27 00:29:34 -04003205 struct task_struct *t = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206
Al Virobcfe8ad2017-05-27 00:29:34 -04003207 if (oss) {
3208 memset(oss, 0, sizeof(stack_t));
3209 oss->ss_sp = (void __user *) t->sas_ss_sp;
3210 oss->ss_size = t->sas_ss_size;
3211 oss->ss_flags = sas_ss_flags(sp) |
3212 (current->sas_ss_flags & SS_FLAG_BITS);
3213 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003214
Al Virobcfe8ad2017-05-27 00:29:34 -04003215 if (ss) {
3216 void __user *ss_sp = ss->ss_sp;
3217 size_t ss_size = ss->ss_size;
3218 unsigned ss_flags = ss->ss_flags;
Stas Sergeev407bc162016-04-14 23:20:03 +03003219 int ss_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003220
Al Virobcfe8ad2017-05-27 00:29:34 -04003221 if (unlikely(on_sig_stack(sp)))
3222 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003223
Stas Sergeev407bc162016-04-14 23:20:03 +03003224 ss_mode = ss_flags & ~SS_FLAG_BITS;
Al Virobcfe8ad2017-05-27 00:29:34 -04003225 if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
3226 ss_mode != 0))
3227 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003228
Stas Sergeev407bc162016-04-14 23:20:03 +03003229 if (ss_mode == SS_DISABLE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003230 ss_size = 0;
3231 ss_sp = NULL;
3232 } else {
Al Virobcfe8ad2017-05-27 00:29:34 -04003233 if (unlikely(ss_size < MINSIGSTKSZ))
3234 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235 }
3236
Al Virobcfe8ad2017-05-27 00:29:34 -04003237 t->sas_ss_sp = (unsigned long) ss_sp;
3238 t->sas_ss_size = ss_size;
3239 t->sas_ss_flags = ss_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003240 }
Al Virobcfe8ad2017-05-27 00:29:34 -04003241 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003242}
Al Virobcfe8ad2017-05-27 00:29:34 -04003243
Al Viro6bf9adf2012-12-14 14:09:47 -05003244SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
3245{
Al Virobcfe8ad2017-05-27 00:29:34 -04003246 stack_t new, old;
3247 int err;
3248 if (uss && copy_from_user(&new, uss, sizeof(stack_t)))
3249 return -EFAULT;
3250 err = do_sigaltstack(uss ? &new : NULL, uoss ? &old : NULL,
3251 current_user_stack_pointer());
3252 if (!err && uoss && copy_to_user(uoss, &old, sizeof(stack_t)))
3253 err = -EFAULT;
3254 return err;
Al Viro6bf9adf2012-12-14 14:09:47 -05003255}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003256
Al Viro5c495742012-11-18 15:29:16 -05003257int restore_altstack(const stack_t __user *uss)
3258{
Al Virobcfe8ad2017-05-27 00:29:34 -04003259 stack_t new;
3260 if (copy_from_user(&new, uss, sizeof(stack_t)))
3261 return -EFAULT;
3262 (void)do_sigaltstack(&new, NULL, current_user_stack_pointer());
Al Viro5c495742012-11-18 15:29:16 -05003263 /* squash all but EFAULT for now */
Al Virobcfe8ad2017-05-27 00:29:34 -04003264 return 0;
Al Viro5c495742012-11-18 15:29:16 -05003265}
3266
Al Viroc40702c2012-11-20 14:24:26 -05003267int __save_altstack(stack_t __user *uss, unsigned long sp)
3268{
3269 struct task_struct *t = current;
Stas Sergeev2a742132016-04-14 23:20:04 +03003270 int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
3271 __put_user(t->sas_ss_flags, &uss->ss_flags) |
Al Viroc40702c2012-11-20 14:24:26 -05003272 __put_user(t->sas_ss_size, &uss->ss_size);
Stas Sergeev2a742132016-04-14 23:20:04 +03003273 if (err)
3274 return err;
3275 if (t->sas_ss_flags & SS_AUTODISARM)
3276 sas_ss_reset(t);
3277 return 0;
Al Viroc40702c2012-11-20 14:24:26 -05003278}
3279
Al Viro90268432012-12-14 14:47:53 -05003280#ifdef CONFIG_COMPAT
Al Viro90228fc2012-12-23 03:33:38 -05003281COMPAT_SYSCALL_DEFINE2(sigaltstack,
3282 const compat_stack_t __user *, uss_ptr,
3283 compat_stack_t __user *, uoss_ptr)
Al Viro90268432012-12-14 14:47:53 -05003284{
3285 stack_t uss, uoss;
3286 int ret;
Al Viro90268432012-12-14 14:47:53 -05003287
3288 if (uss_ptr) {
3289 compat_stack_t uss32;
Al Viro90268432012-12-14 14:47:53 -05003290 if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
3291 return -EFAULT;
3292 uss.ss_sp = compat_ptr(uss32.ss_sp);
3293 uss.ss_flags = uss32.ss_flags;
3294 uss.ss_size = uss32.ss_size;
3295 }
Al Virobcfe8ad2017-05-27 00:29:34 -04003296 ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss,
Al Viro90268432012-12-14 14:47:53 -05003297 compat_user_stack_pointer());
Al Viro90268432012-12-14 14:47:53 -05003298 if (ret >= 0 && uoss_ptr) {
Al Virobcfe8ad2017-05-27 00:29:34 -04003299 compat_stack_t old;
3300 memset(&old, 0, sizeof(old));
3301 old.ss_sp = ptr_to_compat(uoss.ss_sp);
3302 old.ss_flags = uoss.ss_flags;
3303 old.ss_size = uoss.ss_size;
3304 if (copy_to_user(uoss_ptr, &old, sizeof(compat_stack_t)))
Al Viro90268432012-12-14 14:47:53 -05003305 ret = -EFAULT;
3306 }
3307 return ret;
3308}
3309
3310int compat_restore_altstack(const compat_stack_t __user *uss)
3311{
3312 int err = compat_sys_sigaltstack(uss, NULL);
3313 /* squash all but -EFAULT for now */
3314 return err == -EFAULT ? err : 0;
3315}
Al Viroc40702c2012-11-20 14:24:26 -05003316
3317int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
3318{
Stas Sergeev441398d2017-02-27 14:27:25 -08003319 int err;
Al Viroc40702c2012-11-20 14:24:26 -05003320 struct task_struct *t = current;
Stas Sergeev441398d2017-02-27 14:27:25 -08003321 err = __put_user(ptr_to_compat((void __user *)t->sas_ss_sp),
3322 &uss->ss_sp) |
3323 __put_user(t->sas_ss_flags, &uss->ss_flags) |
Al Viroc40702c2012-11-20 14:24:26 -05003324 __put_user(t->sas_ss_size, &uss->ss_size);
Stas Sergeev441398d2017-02-27 14:27:25 -08003325 if (err)
3326 return err;
3327 if (t->sas_ss_flags & SS_AUTODISARM)
3328 sas_ss_reset(t);
3329 return 0;
Al Viroc40702c2012-11-20 14:24:26 -05003330}
Al Viro90268432012-12-14 14:47:53 -05003331#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003332
3333#ifdef __ARCH_WANT_SYS_SIGPENDING
3334
Randy Dunlap41c57892011-04-04 15:00:26 -07003335/**
3336 * sys_sigpending - examine pending signals
3337 * @set: where mask of pending signal is returned
3338 */
Heiko Carstensb290ebe2009-01-14 14:14:06 +01003339SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003340{
Al Virofe9c1db2012-12-25 14:31:38 -05003341 return sys_rt_sigpending((sigset_t __user *)set, sizeof(old_sigset_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003342}
3343
Al Viro8f136212017-05-31 04:42:07 -04003344#ifdef CONFIG_COMPAT
3345COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set32)
3346{
Dmitry V. Levinfbb77612017-08-05 23:00:50 +03003347#ifdef __BIG_ENDIAN
Al Viro8f136212017-05-31 04:42:07 -04003348 sigset_t set;
Dmitry V. Levinfbb77612017-08-05 23:00:50 +03003349 int err = do_sigpending(&set, sizeof(set.sig[0]));
3350 if (!err)
3351 err = put_user(set.sig[0], set32);
Al Viro8f136212017-05-31 04:42:07 -04003352 return err;
Dmitry V. Levinfbb77612017-08-05 23:00:50 +03003353#else
3354 return sys_rt_sigpending((sigset_t __user *)set32, sizeof(*set32));
3355#endif
Al Viro8f136212017-05-31 04:42:07 -04003356}
3357#endif
3358
Linus Torvalds1da177e2005-04-16 15:20:36 -07003359#endif
3360
3361#ifdef __ARCH_WANT_SYS_SIGPROCMASK
Randy Dunlap41c57892011-04-04 15:00:26 -07003362/**
3363 * sys_sigprocmask - examine and change blocked signals
3364 * @how: whether to add, remove, or set signals
Oleg Nesterovb013c392011-04-28 11:36:20 +02003365 * @nset: signals to add or remove (if non-null)
Randy Dunlap41c57892011-04-04 15:00:26 -07003366 * @oset: previous value of signal mask if non-null
3367 *
Randy Dunlap5aba0852011-04-04 14:59:31 -07003368 * Some platforms have their own version with special arguments;
3369 * others support only sys_rt_sigprocmask.
3370 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003371
Oleg Nesterovb013c392011-04-28 11:36:20 +02003372SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
Heiko Carstensb290ebe2009-01-14 14:14:06 +01003373 old_sigset_t __user *, oset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003374{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003375 old_sigset_t old_set, new_set;
Oleg Nesterov2e4f7c72011-05-09 13:48:56 +02003376 sigset_t new_blocked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003377
Oleg Nesterovb013c392011-04-28 11:36:20 +02003378 old_set = current->blocked.sig[0];
3379
3380 if (nset) {
3381 if (copy_from_user(&new_set, nset, sizeof(*nset)))
3382 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003383
Oleg Nesterov2e4f7c72011-05-09 13:48:56 +02003384 new_blocked = current->blocked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003385
Linus Torvalds1da177e2005-04-16 15:20:36 -07003386 switch (how) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003387 case SIG_BLOCK:
Oleg Nesterov2e4f7c72011-05-09 13:48:56 +02003388 sigaddsetmask(&new_blocked, new_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003389 break;
3390 case SIG_UNBLOCK:
Oleg Nesterov2e4f7c72011-05-09 13:48:56 +02003391 sigdelsetmask(&new_blocked, new_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003392 break;
3393 case SIG_SETMASK:
Oleg Nesterov2e4f7c72011-05-09 13:48:56 +02003394 new_blocked.sig[0] = new_set;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003395 break;
Oleg Nesterov2e4f7c72011-05-09 13:48:56 +02003396 default:
3397 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003398 }
3399
Oleg Nesterov0c4a8422013-01-05 19:13:29 +01003400 set_current_blocked(&new_blocked);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003401 }
Oleg Nesterovb013c392011-04-28 11:36:20 +02003402
3403 if (oset) {
3404 if (copy_to_user(oset, &old_set, sizeof(*oset)))
3405 return -EFAULT;
3406 }
3407
3408 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003409}
3410#endif /* __ARCH_WANT_SYS_SIGPROCMASK */
3411
Al Viroeaca6ea2012-11-25 23:12:10 -05003412#ifndef CONFIG_ODD_RT_SIGACTION
Randy Dunlap41c57892011-04-04 15:00:26 -07003413/**
3414 * sys_rt_sigaction - alter an action taken by a process
3415 * @sig: signal to be sent
Randy Dunlapf9fa0bc2011-04-08 10:53:46 -07003416 * @act: new sigaction
3417 * @oact: used to save the previous sigaction
Randy Dunlap41c57892011-04-04 15:00:26 -07003418 * @sigsetsize: size of sigset_t type
3419 */
Heiko Carstensd4e82042009-01-14 14:14:34 +01003420SYSCALL_DEFINE4(rt_sigaction, int, sig,
3421 const struct sigaction __user *, act,
3422 struct sigaction __user *, oact,
3423 size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003424{
3425 struct k_sigaction new_sa, old_sa;
3426 int ret = -EINVAL;
3427
3428 /* XXX: Don't preclude handling different sized sigset_t's. */
3429 if (sigsetsize != sizeof(sigset_t))
3430 goto out;
3431
3432 if (act) {
3433 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
3434 return -EFAULT;
3435 }
3436
3437 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
3438
3439 if (!ret && oact) {
3440 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
3441 return -EFAULT;
3442 }
3443out:
3444 return ret;
3445}
Al Viro08d32fe2012-12-25 18:38:15 -05003446#ifdef CONFIG_COMPAT
Al Viro08d32fe2012-12-25 18:38:15 -05003447COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig,
3448 const struct compat_sigaction __user *, act,
3449 struct compat_sigaction __user *, oact,
3450 compat_size_t, sigsetsize)
3451{
3452 struct k_sigaction new_ka, old_ka;
3453 compat_sigset_t mask;
3454#ifdef __ARCH_HAS_SA_RESTORER
3455 compat_uptr_t restorer;
3456#endif
3457 int ret;
3458
3459 /* XXX: Don't preclude handling different sized sigset_t's. */
3460 if (sigsetsize != sizeof(compat_sigset_t))
3461 return -EINVAL;
3462
3463 if (act) {
3464 compat_uptr_t handler;
3465 ret = get_user(handler, &act->sa_handler);
3466 new_ka.sa.sa_handler = compat_ptr(handler);
3467#ifdef __ARCH_HAS_SA_RESTORER
3468 ret |= get_user(restorer, &act->sa_restorer);
3469 new_ka.sa.sa_restorer = compat_ptr(restorer);
3470#endif
3471 ret |= copy_from_user(&mask, &act->sa_mask, sizeof(mask));
Mathieu Desnoyers3ddc5b42013-09-11 14:23:18 -07003472 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
Al Viro08d32fe2012-12-25 18:38:15 -05003473 if (ret)
3474 return -EFAULT;
3475 sigset_from_compat(&new_ka.sa.sa_mask, &mask);
3476 }
3477
3478 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3479 if (!ret && oact) {
3480 sigset_to_compat(&mask, &old_ka.sa.sa_mask);
3481 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler),
3482 &oact->sa_handler);
3483 ret |= copy_to_user(&oact->sa_mask, &mask, sizeof(mask));
Mathieu Desnoyers3ddc5b42013-09-11 14:23:18 -07003484 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
Al Viro08d32fe2012-12-25 18:38:15 -05003485#ifdef __ARCH_HAS_SA_RESTORER
3486 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3487 &oact->sa_restorer);
3488#endif
3489 }
3490 return ret;
3491}
3492#endif
Al Viroeaca6ea2012-11-25 23:12:10 -05003493#endif /* !CONFIG_ODD_RT_SIGACTION */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003494
Al Viro495dfbf2012-12-25 19:09:45 -05003495#ifdef CONFIG_OLD_SIGACTION
3496SYSCALL_DEFINE3(sigaction, int, sig,
3497 const struct old_sigaction __user *, act,
3498 struct old_sigaction __user *, oact)
3499{
3500 struct k_sigaction new_ka, old_ka;
3501 int ret;
3502
3503 if (act) {
3504 old_sigset_t mask;
3505 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3506 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
3507 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
3508 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3509 __get_user(mask, &act->sa_mask))
3510 return -EFAULT;
3511#ifdef __ARCH_HAS_KA_RESTORER
3512 new_ka.ka_restorer = NULL;
3513#endif
3514 siginitset(&new_ka.sa.sa_mask, mask);
3515 }
3516
3517 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3518
3519 if (!ret && oact) {
3520 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3521 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
3522 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
3523 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3524 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3525 return -EFAULT;
3526 }
3527
3528 return ret;
3529}
3530#endif
3531#ifdef CONFIG_COMPAT_OLD_SIGACTION
3532COMPAT_SYSCALL_DEFINE3(sigaction, int, sig,
3533 const struct compat_old_sigaction __user *, act,
3534 struct compat_old_sigaction __user *, oact)
3535{
3536 struct k_sigaction new_ka, old_ka;
3537 int ret;
3538 compat_old_sigset_t mask;
3539 compat_uptr_t handler, restorer;
3540
3541 if (act) {
3542 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3543 __get_user(handler, &act->sa_handler) ||
3544 __get_user(restorer, &act->sa_restorer) ||
3545 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3546 __get_user(mask, &act->sa_mask))
3547 return -EFAULT;
3548
3549#ifdef __ARCH_HAS_KA_RESTORER
3550 new_ka.ka_restorer = NULL;
3551#endif
3552 new_ka.sa.sa_handler = compat_ptr(handler);
3553 new_ka.sa.sa_restorer = compat_ptr(restorer);
3554 siginitset(&new_ka.sa.sa_mask, mask);
3555 }
3556
3557 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3558
3559 if (!ret && oact) {
3560 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3561 __put_user(ptr_to_compat(old_ka.sa.sa_handler),
3562 &oact->sa_handler) ||
3563 __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3564 &oact->sa_restorer) ||
3565 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3566 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3567 return -EFAULT;
3568 }
3569 return ret;
3570}
3571#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003572
Fabian Frederickf6187762014-06-04 16:11:12 -07003573#ifdef CONFIG_SGETMASK_SYSCALL
Linus Torvalds1da177e2005-04-16 15:20:36 -07003574
3575/*
3576 * For backwards compatibility. Functionality superseded by sigprocmask.
3577 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01003578SYSCALL_DEFINE0(sgetmask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003579{
3580 /* SMP safe */
3581 return current->blocked.sig[0];
3582}
3583
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01003584SYSCALL_DEFINE1(ssetmask, int, newmask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003585{
Oleg Nesterovc1095c62011-07-27 12:49:44 -07003586 int old = current->blocked.sig[0];
3587 sigset_t newset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003588
Oleg Nesterov5ba53ff2013-01-05 19:13:13 +01003589 siginitset(&newset, newmask);
Oleg Nesterovc1095c62011-07-27 12:49:44 -07003590 set_current_blocked(&newset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003591
3592 return old;
3593}
Fabian Frederickf6187762014-06-04 16:11:12 -07003594#endif /* CONFIG_SGETMASK_SYSCALL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003595
3596#ifdef __ARCH_WANT_SYS_SIGNAL
3597/*
3598 * For backwards compatibility. Functionality superseded by sigaction.
3599 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01003600SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003601{
3602 struct k_sigaction new_sa, old_sa;
3603 int ret;
3604
3605 new_sa.sa.sa_handler = handler;
3606 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
Oleg Nesterovc70d3d702006-02-09 22:41:41 +03003607 sigemptyset(&new_sa.sa.sa_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003608
3609 ret = do_sigaction(sig, &new_sa, &old_sa);
3610
3611 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
3612}
3613#endif /* __ARCH_WANT_SYS_SIGNAL */
3614
3615#ifdef __ARCH_WANT_SYS_PAUSE
3616
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01003617SYSCALL_DEFINE0(pause)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003618{
Oleg Nesterovd92fcf02011-05-25 19:22:27 +02003619 while (!signal_pending(current)) {
Davidlohr Bueso1df01352015-02-17 13:45:41 -08003620 __set_current_state(TASK_INTERRUPTIBLE);
Oleg Nesterovd92fcf02011-05-25 19:22:27 +02003621 schedule();
3622 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003623 return -ERESTARTNOHAND;
3624}
3625
3626#endif
3627
Richard Weinberger9d8a7652015-11-20 15:57:21 -08003628static int sigsuspend(sigset_t *set)
Al Viro68f3f162012-05-21 21:42:32 -04003629{
Al Viro68f3f162012-05-21 21:42:32 -04003630 current->saved_sigmask = current->blocked;
3631 set_current_blocked(set);
3632
Sasha Levin823dd322016-02-05 15:36:05 -08003633 while (!signal_pending(current)) {
3634 __set_current_state(TASK_INTERRUPTIBLE);
3635 schedule();
3636 }
Al Viro68f3f162012-05-21 21:42:32 -04003637 set_restore_sigmask();
3638 return -ERESTARTNOHAND;
3639}
Al Viro68f3f162012-05-21 21:42:32 -04003640
Randy Dunlap41c57892011-04-04 15:00:26 -07003641/**
3642 * sys_rt_sigsuspend - replace the signal mask for a value with the
3643 * @unewset value until a signal is received
3644 * @unewset: new signal mask value
3645 * @sigsetsize: size of sigset_t type
3646 */
Heiko Carstensd4e82042009-01-14 14:14:34 +01003647SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
David Woodhouse150256d2006-01-18 17:43:57 -08003648{
3649 sigset_t newset;
3650
3651 /* XXX: Don't preclude handling different sized sigset_t's. */
3652 if (sigsetsize != sizeof(sigset_t))
3653 return -EINVAL;
3654
3655 if (copy_from_user(&newset, unewset, sizeof(newset)))
3656 return -EFAULT;
Al Viro68f3f162012-05-21 21:42:32 -04003657 return sigsuspend(&newset);
David Woodhouse150256d2006-01-18 17:43:57 -08003658}
Al Viroad4b65a2012-12-24 21:43:56 -05003659
3660#ifdef CONFIG_COMPAT
3661COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
3662{
3663#ifdef __BIG_ENDIAN
3664 sigset_t newset;
3665 compat_sigset_t newset32;
3666
3667 /* XXX: Don't preclude handling different sized sigset_t's. */
3668 if (sigsetsize != sizeof(sigset_t))
3669 return -EINVAL;
3670
3671 if (copy_from_user(&newset32, unewset, sizeof(compat_sigset_t)))
3672 return -EFAULT;
3673 sigset_from_compat(&newset, &newset32);
3674 return sigsuspend(&newset);
3675#else
3676 /* on little-endian bitmaps don't care about granularity */
3677 return sys_rt_sigsuspend((sigset_t __user *)unewset, sigsetsize);
3678#endif
3679}
3680#endif
David Woodhouse150256d2006-01-18 17:43:57 -08003681
Al Viro0a0e8cd2012-12-25 16:04:12 -05003682#ifdef CONFIG_OLD_SIGSUSPEND
3683SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
3684{
3685 sigset_t blocked;
3686 siginitset(&blocked, mask);
3687 return sigsuspend(&blocked);
3688}
3689#endif
3690#ifdef CONFIG_OLD_SIGSUSPEND3
3691SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask)
3692{
3693 sigset_t blocked;
3694 siginitset(&blocked, mask);
3695 return sigsuspend(&blocked);
3696}
3697#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003698
Gideon Israel Dsouza52f5684c2014-04-07 15:39:20 -07003699__weak const char *arch_vma_name(struct vm_area_struct *vma)
David Howellsf269fdd2006-09-27 01:50:23 -07003700{
3701 return NULL;
3702}
3703
Linus Torvalds1da177e2005-04-16 15:20:36 -07003704void __init signals_init(void)
3705{
Helge Deller41b27152016-03-22 14:27:54 -07003706 /* If this check fails, the __ARCH_SI_PREAMBLE_SIZE value is wrong! */
3707 BUILD_BUG_ON(__ARCH_SI_PREAMBLE_SIZE
3708 != offsetof(struct siginfo, _sifields._pad));
3709
Christoph Lameter0a31bd52007-05-06 14:49:57 -07003710 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003711}
Jason Wessel67fc4e02010-05-20 21:04:21 -05003712
3713#ifdef CONFIG_KGDB_KDB
3714#include <linux/kdb.h>
3715/*
3716 * kdb_send_sig_info - Allows kdb to send signals without exposing
3717 * signal internals. This function checks if the required locks are
3718 * available before calling the main signal code, to avoid kdb
3719 * deadlocks.
3720 */
3721void
3722kdb_send_sig_info(struct task_struct *t, struct siginfo *info)
3723{
3724 static struct task_struct *kdb_prev_t;
3725 int sig, new_t;
3726 if (!spin_trylock(&t->sighand->siglock)) {
3727 kdb_printf("Can't do kill command now.\n"
3728 "The sigmask lock is held somewhere else in "
3729 "kernel, try again later\n");
3730 return;
3731 }
3732 spin_unlock(&t->sighand->siglock);
3733 new_t = kdb_prev_t != t;
3734 kdb_prev_t = t;
3735 if (t->state != TASK_RUNNING && new_t) {
3736 kdb_printf("Process is not RUNNING, sending a signal from "
3737 "kdb risks deadlock\n"
3738 "on the run queue locks. "
3739 "The signal has _not_ been sent.\n"
3740 "Reissue the kill command if you want to risk "
3741 "the deadlock.\n");
3742 return;
3743 }
3744 sig = info->si_signo;
3745 if (send_sig_info(sig, info, t))
3746 kdb_printf("Fail to deliver Signal %d to process %d.\n",
3747 sig, t->pid);
3748 else
3749 kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
3750}
3751#endif /* CONFIG_KGDB_KDB */