blob: 113411bfe8b1205ad0f26556776f2a317e06eb0c [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>
16#include <linux/sched.h>
17#include <linux/fs.h>
18#include <linux/tty.h>
19#include <linux/binfmts.h>
Alex Kelly179899f2012-10-04 17:15:24 -070020#include <linux/coredump.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/security.h>
22#include <linux/syscalls.h>
23#include <linux/ptrace.h>
Jesper Juhl7ed20e12005-05-01 08:59:14 -070024#include <linux/signal.h>
Davide Libenzifba2afa2007-05-10 22:23:13 -070025#include <linux/signalfd.h>
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +090026#include <linux/ratelimit.h>
Roland McGrath35de2542008-07-25 19:45:51 -070027#include <linux/tracehook.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080028#include <linux/capability.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080029#include <linux/freezer.h>
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -080030#include <linux/pid_namespace.h>
31#include <linux/nsproxy.h>
Serge E. Hallyn6b550f92012-01-10 15:11:37 -080032#include <linux/user_namespace.h>
Srikar Dronamraju0326f5a2012-03-13 23:30:11 +053033#include <linux/uprobes.h>
Al Viro90268432012-12-14 14:47:53 -050034#include <linux/compat.h>
Jesper Derehag2b5faa42013-03-19 20:50:05 +000035#include <linux/cn_proc.h>
Masami Hiramatsud1eb6502009-11-24 16:56:45 -050036#define CREATE_TRACE_POINTS
37#include <trace/events/signal.h>
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -080038
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <asm/param.h>
40#include <asm/uaccess.h>
41#include <asm/unistd.h>
42#include <asm/siginfo.h>
David Howellsd550bbd2012-03-28 18:30:03 +010043#include <asm/cacheflush.h>
Al Viroe1396062006-05-25 10:19:47 -040044#include "audit.h" /* audit_signal_info() */
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46/*
47 * SLAB caches for signal bits.
48 */
49
Christoph Lametere18b8902006-12-06 20:33:20 -080050static struct kmem_cache *sigqueue_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +090052int print_fatal_signals __read_mostly;
53
Roland McGrath35de2542008-07-25 19:45:51 -070054static void __user *sig_handler(struct task_struct *t, int sig)
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070055{
Roland McGrath35de2542008-07-25 19:45:51 -070056 return t->sighand->action[sig - 1].sa.sa_handler;
57}
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070058
Roland McGrath35de2542008-07-25 19:45:51 -070059static int sig_handler_ignored(void __user *handler, int sig)
60{
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070061 /* Is it explicitly or implicitly ignored? */
Pavel Emelyanov93585ee2008-04-30 00:52:39 -070062 return handler == SIG_IGN ||
63 (handler == SIG_DFL && sig_kernel_ignore(sig));
64}
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Oleg Nesterovdef8cf72012-03-23 15:02:45 -070066static int sig_task_ignored(struct task_struct *t, int sig, bool force)
Linus Torvalds1da177e2005-04-16 15:20:36 -070067{
Roland McGrath35de2542008-07-25 19:45:51 -070068 void __user *handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
Oleg Nesterovf008faf2009-04-02 16:58:02 -070070 handler = sig_handler(t, sig);
71
72 if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
Oleg Nesterovdef8cf72012-03-23 15:02:45 -070073 handler == SIG_DFL && !force)
Oleg Nesterovf008faf2009-04-02 16:58:02 -070074 return 1;
75
76 return sig_handler_ignored(handler, sig);
77}
78
Oleg Nesterovdef8cf72012-03-23 15:02:45 -070079static int sig_ignored(struct task_struct *t, int sig, bool force)
Oleg Nesterovf008faf2009-04-02 16:58:02 -070080{
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 /*
82 * Blocked signals are never ignored, since the
83 * signal handler may change by the time it is
84 * unblocked.
85 */
Roland McGrath325d22d2007-11-12 15:41:55 -080086 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 return 0;
88
Oleg Nesterovdef8cf72012-03-23 15:02:45 -070089 if (!sig_task_ignored(t, sig, force))
Roland McGrath35de2542008-07-25 19:45:51 -070090 return 0;
91
92 /*
93 * Tracers may want to know about even ignored signals.
94 */
Tejun Heoa288eec2011-06-17 16:50:37 +020095 return !t->ptrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096}
97
98/*
99 * Re-calculate pending state from the set of locally pending
100 * signals, globally pending signals, and blocked signals.
101 */
102static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
103{
104 unsigned long ready;
105 long i;
106
107 switch (_NSIG_WORDS) {
108 default:
109 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
110 ready |= signal->sig[i] &~ blocked->sig[i];
111 break;
112
113 case 4: ready = signal->sig[3] &~ blocked->sig[3];
114 ready |= signal->sig[2] &~ blocked->sig[2];
115 ready |= signal->sig[1] &~ blocked->sig[1];
116 ready |= signal->sig[0] &~ blocked->sig[0];
117 break;
118
119 case 2: ready = signal->sig[1] &~ blocked->sig[1];
120 ready |= signal->sig[0] &~ blocked->sig[0];
121 break;
122
123 case 1: ready = signal->sig[0] &~ blocked->sig[0];
124 }
125 return ready != 0;
126}
127
128#define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
129
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700130static int recalc_sigpending_tsk(struct task_struct *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131{
Tejun Heo3759a0d2011-06-02 11:14:00 +0200132 if ((t->jobctl & JOBCTL_PENDING_MASK) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 PENDING(&t->pending, &t->blocked) ||
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700134 PENDING(&t->signal->shared_pending, &t->blocked)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 set_tsk_thread_flag(t, TIF_SIGPENDING);
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700136 return 1;
137 }
Roland McGrathb74d0de2007-06-06 03:59:00 -0700138 /*
139 * We must never clear the flag in another thread, or in current
140 * when it's possible the current syscall is returning -ERESTART*.
141 * So we don't clear it here, and only callers who know they should do.
142 */
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700143 return 0;
144}
145
146/*
147 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
148 * This is superfluous when called on current, the wakeup is a harmless no-op.
149 */
150void recalc_sigpending_and_wake(struct task_struct *t)
151{
152 if (recalc_sigpending_tsk(t))
153 signal_wake_up(t, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154}
155
156void recalc_sigpending(void)
157{
Tejun Heodd1d6772011-06-02 11:14:00 +0200158 if (!recalc_sigpending_tsk(current) && !freezing(current))
Roland McGrathb74d0de2007-06-06 03:59:00 -0700159 clear_thread_flag(TIF_SIGPENDING);
160
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161}
162
163/* Given the mask, find the first available signal that should be serviced. */
164
Linus Torvaldsa27341c2010-03-02 08:36:46 -0800165#define SYNCHRONOUS_MASK \
166 (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
Will Drewrya0727e82012-04-12 16:48:00 -0500167 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
Linus Torvaldsa27341c2010-03-02 08:36:46 -0800168
Davide Libenzifba2afa2007-05-10 22:23:13 -0700169int next_signal(struct sigpending *pending, sigset_t *mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170{
171 unsigned long i, *s, *m, x;
172 int sig = 0;
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +0900173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 s = pending->signal.sig;
175 m = mask->sig;
Linus Torvaldsa27341c2010-03-02 08:36:46 -0800176
177 /*
178 * Handle the first word specially: it contains the
179 * synchronous signals that need to be dequeued first.
180 */
181 x = *s &~ *m;
182 if (x) {
183 if (x & SYNCHRONOUS_MASK)
184 x &= SYNCHRONOUS_MASK;
185 sig = ffz(~x) + 1;
186 return sig;
187 }
188
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 switch (_NSIG_WORDS) {
190 default:
Linus Torvaldsa27341c2010-03-02 08:36:46 -0800191 for (i = 1; i < _NSIG_WORDS; ++i) {
192 x = *++s &~ *++m;
193 if (!x)
194 continue;
195 sig = ffz(~x) + i*_NSIG_BPW + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 break;
Linus Torvaldsa27341c2010-03-02 08:36:46 -0800197 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 break;
199
Linus Torvaldsa27341c2010-03-02 08:36:46 -0800200 case 2:
201 x = s[1] &~ m[1];
202 if (!x)
203 break;
204 sig = ffz(~x) + _NSIG_BPW + 1;
205 break;
206
207 case 1:
208 /* Nothing to do */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 break;
210 }
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +0900211
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 return sig;
213}
214
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +0900215static inline void print_dropped_signal(int sig)
216{
217 static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
218
219 if (!print_fatal_signals)
220 return;
221
222 if (!__ratelimit(&ratelimit_state))
223 return;
224
225 printk(KERN_INFO "%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
226 current->comm, current->pid, sig);
227}
228
Tejun Heoe5c19022011-03-23 10:37:00 +0100229/**
Tejun Heo7dd3db52011-06-02 11:14:00 +0200230 * task_set_jobctl_pending - set jobctl pending bits
231 * @task: target task
232 * @mask: pending bits to set
233 *
234 * Clear @mask from @task->jobctl. @mask must be subset of
235 * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
236 * %JOBCTL_TRAPPING. If stop signo is being set, the existing signo is
237 * cleared. If @task is already being killed or exiting, this function
238 * becomes noop.
239 *
240 * CONTEXT:
241 * Must be called with @task->sighand->siglock held.
242 *
243 * RETURNS:
244 * %true if @mask is set, %false if made noop because @task was dying.
245 */
246bool task_set_jobctl_pending(struct task_struct *task, unsigned int mask)
247{
248 BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
249 JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
250 BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
251
252 if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
253 return false;
254
255 if (mask & JOBCTL_STOP_SIGMASK)
256 task->jobctl &= ~JOBCTL_STOP_SIGMASK;
257
258 task->jobctl |= mask;
259 return true;
260}
261
262/**
Tejun Heoa8f072c2011-06-02 11:13:59 +0200263 * task_clear_jobctl_trapping - clear jobctl trapping bit
Tejun Heod79fdd62011-03-23 10:37:00 +0100264 * @task: target task
265 *
Tejun Heoa8f072c2011-06-02 11:13:59 +0200266 * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
267 * Clear it and wake up the ptracer. Note that we don't need any further
268 * locking. @task->siglock guarantees that @task->parent points to the
269 * ptracer.
Tejun Heod79fdd62011-03-23 10:37:00 +0100270 *
271 * CONTEXT:
272 * Must be called with @task->sighand->siglock held.
273 */
Tejun Heo73ddff22011-06-14 11:20:14 +0200274void task_clear_jobctl_trapping(struct task_struct *task)
Tejun Heod79fdd62011-03-23 10:37:00 +0100275{
Tejun Heoa8f072c2011-06-02 11:13:59 +0200276 if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
277 task->jobctl &= ~JOBCTL_TRAPPING;
Tejun Heo62c124f2011-06-02 11:14:00 +0200278 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
Tejun Heod79fdd62011-03-23 10:37:00 +0100279 }
280}
281
282/**
Tejun Heo3759a0d2011-06-02 11:14:00 +0200283 * task_clear_jobctl_pending - clear jobctl pending bits
Tejun Heoe5c19022011-03-23 10:37:00 +0100284 * @task: target task
Tejun Heo3759a0d2011-06-02 11:14:00 +0200285 * @mask: pending bits to clear
Tejun Heoe5c19022011-03-23 10:37:00 +0100286 *
Tejun Heo3759a0d2011-06-02 11:14:00 +0200287 * Clear @mask from @task->jobctl. @mask must be subset of
288 * %JOBCTL_PENDING_MASK. If %JOBCTL_STOP_PENDING is being cleared, other
289 * STOP bits are cleared together.
Tejun Heoe5c19022011-03-23 10:37:00 +0100290 *
Tejun Heo6dfca322011-06-02 11:14:00 +0200291 * If clearing of @mask leaves no stop or trap pending, this function calls
292 * task_clear_jobctl_trapping().
Tejun Heoe5c19022011-03-23 10:37:00 +0100293 *
294 * CONTEXT:
295 * Must be called with @task->sighand->siglock held.
296 */
Tejun Heo3759a0d2011-06-02 11:14:00 +0200297void task_clear_jobctl_pending(struct task_struct *task, unsigned int mask)
Tejun Heoe5c19022011-03-23 10:37:00 +0100298{
Tejun Heo3759a0d2011-06-02 11:14:00 +0200299 BUG_ON(mask & ~JOBCTL_PENDING_MASK);
300
301 if (mask & JOBCTL_STOP_PENDING)
302 mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
303
304 task->jobctl &= ~mask;
Tejun Heo6dfca322011-06-02 11:14:00 +0200305
306 if (!(task->jobctl & JOBCTL_PENDING_MASK))
307 task_clear_jobctl_trapping(task);
Tejun Heoe5c19022011-03-23 10:37:00 +0100308}
309
310/**
311 * task_participate_group_stop - participate in a group stop
312 * @task: task participating in a group stop
313 *
Tejun Heoa8f072c2011-06-02 11:13:59 +0200314 * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
Tejun Heo39efa3e2011-03-23 10:37:00 +0100315 * Group stop states are cleared and the group stop count is consumed if
Tejun Heoa8f072c2011-06-02 11:13:59 +0200316 * %JOBCTL_STOP_CONSUME was set. If the consumption completes the group
Tejun Heo39efa3e2011-03-23 10:37:00 +0100317 * stop, the appropriate %SIGNAL_* flags are set.
Tejun Heoe5c19022011-03-23 10:37:00 +0100318 *
319 * CONTEXT:
320 * Must be called with @task->sighand->siglock held.
Tejun Heo244056f2011-03-23 10:37:01 +0100321 *
322 * RETURNS:
323 * %true if group stop completion should be notified to the parent, %false
324 * otherwise.
Tejun Heoe5c19022011-03-23 10:37:00 +0100325 */
326static bool task_participate_group_stop(struct task_struct *task)
327{
328 struct signal_struct *sig = task->signal;
Tejun Heoa8f072c2011-06-02 11:13:59 +0200329 bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
Tejun Heoe5c19022011-03-23 10:37:00 +0100330
Tejun Heoa8f072c2011-06-02 11:13:59 +0200331 WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
Tejun Heo39efa3e2011-03-23 10:37:00 +0100332
Tejun Heo3759a0d2011-06-02 11:14:00 +0200333 task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
Tejun Heoe5c19022011-03-23 10:37:00 +0100334
335 if (!consume)
336 return false;
337
338 if (!WARN_ON_ONCE(sig->group_stop_count == 0))
339 sig->group_stop_count--;
340
Tejun Heo244056f2011-03-23 10:37:01 +0100341 /*
342 * Tell the caller to notify completion iff we are entering into a
343 * fresh group stop. Read comment in do_signal_stop() for details.
344 */
345 if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
Tejun Heoe5c19022011-03-23 10:37:00 +0100346 sig->flags = SIGNAL_STOP_STOPPED;
347 return true;
348 }
349 return false;
350}
351
David Howellsc69e8d92008-11-14 10:39:19 +1100352/*
353 * allocate a new signal queue record
354 * - this may be called without locks if and only if t == current, otherwise an
Randy Dunlap5aba0852011-04-04 14:59:31 -0700355 * appropriate lock must be held to stop the target task from exiting
David Howellsc69e8d92008-11-14 10:39:19 +1100356 */
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +0900357static struct sigqueue *
358__sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
360 struct sigqueue *q = NULL;
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800361 struct user_struct *user;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800363 /*
Thomas Gleixner7cf7db82009-12-10 00:53:21 +0000364 * Protect access to @t credentials. This can go away when all
365 * callers hold rcu read lock.
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800366 */
Thomas Gleixner7cf7db82009-12-10 00:53:21 +0000367 rcu_read_lock();
David Howellsd84f4f92008-11-14 10:39:23 +1100368 user = get_uid(__task_cred(t)->user);
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800369 atomic_inc(&user->sigpending);
Thomas Gleixner7cf7db82009-12-10 00:53:21 +0000370 rcu_read_unlock();
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +0900371
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 if (override_rlimit ||
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800373 atomic_read(&user->sigpending) <=
Jiri Slaby78d7d402010-03-05 13:42:54 -0800374 task_rlimit(t, RLIMIT_SIGPENDING)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 q = kmem_cache_alloc(sigqueue_cachep, flags);
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +0900376 } else {
377 print_dropped_signal(sig);
378 }
379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 if (unlikely(q == NULL)) {
Linus Torvalds10b1fbd2006-11-04 13:03:00 -0800381 atomic_dec(&user->sigpending);
David Howellsd84f4f92008-11-14 10:39:23 +1100382 free_uid(user);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 } else {
384 INIT_LIST_HEAD(&q->list);
385 q->flags = 0;
David Howellsd84f4f92008-11-14 10:39:23 +1100386 q->user = user;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 }
David Howellsd84f4f92008-11-14 10:39:23 +1100388
389 return q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390}
391
Andrew Morton514a01b2006-02-03 03:04:41 -0800392static void __sigqueue_free(struct sigqueue *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393{
394 if (q->flags & SIGQUEUE_PREALLOC)
395 return;
396 atomic_dec(&q->user->sigpending);
397 free_uid(q->user);
398 kmem_cache_free(sigqueue_cachep, q);
399}
400
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800401void flush_sigqueue(struct sigpending *queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402{
403 struct sigqueue *q;
404
405 sigemptyset(&queue->signal);
406 while (!list_empty(&queue->list)) {
407 q = list_entry(queue->list.next, struct sigqueue , list);
408 list_del_init(&q->list);
409 __sigqueue_free(q);
410 }
411}
412
413/*
414 * Flush all pending signals for a task.
415 */
David Howells3bcac022009-04-29 13:45:05 +0100416void __flush_signals(struct task_struct *t)
417{
418 clear_tsk_thread_flag(t, TIF_SIGPENDING);
419 flush_sigqueue(&t->pending);
420 flush_sigqueue(&t->signal->shared_pending);
421}
422
Oleg Nesterovc81addc2006-03-28 16:11:17 -0800423void flush_signals(struct task_struct *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424{
425 unsigned long flags;
426
427 spin_lock_irqsave(&t->sighand->siglock, flags);
David Howells3bcac022009-04-29 13:45:05 +0100428 __flush_signals(t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 spin_unlock_irqrestore(&t->sighand->siglock, flags);
430}
431
Oleg Nesterovcbaffba2008-05-26 20:55:42 +0400432static void __flush_itimer_signals(struct sigpending *pending)
433{
434 sigset_t signal, retain;
435 struct sigqueue *q, *n;
436
437 signal = pending->signal;
438 sigemptyset(&retain);
439
440 list_for_each_entry_safe(q, n, &pending->list, list) {
441 int sig = q->info.si_signo;
442
443 if (likely(q->info.si_code != SI_TIMER)) {
444 sigaddset(&retain, sig);
445 } else {
446 sigdelset(&signal, sig);
447 list_del_init(&q->list);
448 __sigqueue_free(q);
449 }
450 }
451
452 sigorsets(&pending->signal, &signal, &retain);
453}
454
455void flush_itimer_signals(void)
456{
457 struct task_struct *tsk = current;
458 unsigned long flags;
459
460 spin_lock_irqsave(&tsk->sighand->siglock, flags);
461 __flush_itimer_signals(&tsk->pending);
462 __flush_itimer_signals(&tsk->signal->shared_pending);
463 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
464}
465
Oleg Nesterov10ab8252007-05-09 02:34:37 -0700466void ignore_signals(struct task_struct *t)
467{
468 int i;
469
470 for (i = 0; i < _NSIG; ++i)
471 t->sighand->action[i].sa.sa_handler = SIG_IGN;
472
473 flush_signals(t);
474}
475
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 * Flush all handlers for a task.
478 */
479
480void
481flush_signal_handlers(struct task_struct *t, int force_default)
482{
483 int i;
484 struct k_sigaction *ka = &t->sighand->action[0];
485 for (i = _NSIG ; i != 0 ; i--) {
486 if (force_default || ka->sa.sa_handler != SIG_IGN)
487 ka->sa.sa_handler = SIG_DFL;
488 ka->sa.sa_flags = 0;
Andrew Morton522cff12013-03-13 14:59:34 -0700489#ifdef __ARCH_HAS_SA_RESTORER
Kees Cook2ca39522013-03-13 14:59:33 -0700490 ka->sa.sa_restorer = NULL;
491#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 sigemptyset(&ka->sa.sa_mask);
493 ka++;
494 }
495}
496
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200497int unhandled_signal(struct task_struct *tsk, int sig)
498{
Roland McGrath445a91d2008-07-25 19:45:52 -0700499 void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
Serge E. Hallynb460cbc2007-10-18 23:39:52 -0700500 if (is_global_init(tsk))
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200501 return 1;
Roland McGrath445a91d2008-07-25 19:45:52 -0700502 if (handler != SIG_IGN && handler != SIG_DFL)
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200503 return 0;
Tejun Heoa288eec2011-06-17 16:50:37 +0200504 /* if ptraced, let the tracer determine */
505 return !tsk->ptrace;
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +0200506}
507
Randy Dunlap5aba0852011-04-04 14:59:31 -0700508/*
509 * Notify the system that a driver wants to block all signals for this
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 * process, and wants to be notified if any signals at all were to be
511 * sent/acted upon. If the notifier routine returns non-zero, then the
512 * signal will be acted upon after all. If the notifier routine returns 0,
513 * then then signal will be blocked. Only one block per process is
514 * allowed. priv is a pointer to private data that the notifier routine
Randy Dunlap5aba0852011-04-04 14:59:31 -0700515 * can use to determine if the signal should be blocked or not.
516 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517void
518block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
519{
520 unsigned long flags;
521
522 spin_lock_irqsave(&current->sighand->siglock, flags);
523 current->notifier_mask = mask;
524 current->notifier_data = priv;
525 current->notifier = notifier;
526 spin_unlock_irqrestore(&current->sighand->siglock, flags);
527}
528
529/* Notify the system that blocking has ended. */
530
531void
532unblock_all_signals(void)
533{
534 unsigned long flags;
535
536 spin_lock_irqsave(&current->sighand->siglock, flags);
537 current->notifier = NULL;
538 current->notifier_data = NULL;
539 recalc_sigpending();
540 spin_unlock_irqrestore(&current->sighand->siglock, flags);
541}
542
Oleg Nesterov100360f2008-07-25 01:47:29 -0700543static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544{
545 struct sigqueue *q, *first = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 /*
548 * Collect the siginfo appropriate to this signal. Check if
549 * there is another siginfo for the same signal.
550 */
551 list_for_each_entry(q, &list->list, list) {
552 if (q->info.si_signo == sig) {
Oleg Nesterovd4434202008-07-25 01:47:28 -0700553 if (first)
554 goto still_pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 first = q;
556 }
557 }
Oleg Nesterovd4434202008-07-25 01:47:28 -0700558
559 sigdelset(&list->signal, sig);
560
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 if (first) {
Oleg Nesterovd4434202008-07-25 01:47:28 -0700562still_pending:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 list_del_init(&first->list);
564 copy_siginfo(info, &first->info);
565 __sigqueue_free(first);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 } else {
Randy Dunlap5aba0852011-04-04 14:59:31 -0700567 /*
568 * Ok, it wasn't in the queue. This must be
569 * a fast-pathed signal or we must have been
570 * out of queue space. So zero out the info.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 info->si_signo = sig;
573 info->si_errno = 0;
Oleg Nesterov7486e5d2009-12-15 16:47:24 -0800574 info->si_code = SI_USER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 info->si_pid = 0;
576 info->si_uid = 0;
577 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578}
579
580static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
581 siginfo_t *info)
582{
Roland McGrath27d91e02006-09-29 02:00:31 -0700583 int sig = next_signal(pending, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 if (sig) {
586 if (current->notifier) {
587 if (sigismember(current->notifier_mask, sig)) {
588 if (!(current->notifier)(current->notifier_data)) {
589 clear_thread_flag(TIF_SIGPENDING);
590 return 0;
591 }
592 }
593 }
594
Oleg Nesterov100360f2008-07-25 01:47:29 -0700595 collect_signal(sig, pending, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
598 return sig;
599}
600
601/*
Randy Dunlap5aba0852011-04-04 14:59:31 -0700602 * Dequeue a signal and return the element to the caller, which is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 * expected to free it.
604 *
605 * All callers have to hold the siglock.
606 */
607int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
608{
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700609 int signr;
Benjamin Herrenschmidtcaec4e82007-06-12 08:16:18 +1000610
611 /* We only dequeue private signals from ourselves, we don't let
612 * signalfd steal them
613 */
Davide Libenzib8fceee2007-09-20 12:40:16 -0700614 signr = __dequeue_signal(&tsk->pending, mask, info);
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800615 if (!signr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 signr = __dequeue_signal(&tsk->signal->shared_pending,
617 mask, info);
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800618 /*
619 * itimer signal ?
620 *
621 * itimers are process shared and we restart periodic
622 * itimers in the signal delivery path to prevent DoS
623 * attacks in the high resolution timer case. This is
Randy Dunlap5aba0852011-04-04 14:59:31 -0700624 * compliant with the old way of self-restarting
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800625 * itimers, as the SIGALRM is a legacy signal and only
626 * queued once. Changing the restart behaviour to
627 * restart the timer in the signal dequeue path is
628 * reducing the timer noise on heavy loaded !highres
629 * systems too.
630 */
631 if (unlikely(signr == SIGALRM)) {
632 struct hrtimer *tmr = &tsk->signal->real_timer;
633
634 if (!hrtimer_is_queued(tmr) &&
635 tsk->signal->it_real_incr.tv64 != 0) {
636 hrtimer_forward(tmr, tmr->base->get_time(),
637 tsk->signal->it_real_incr);
638 hrtimer_restart(tmr);
639 }
640 }
641 }
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700642
Davide Libenzib8fceee2007-09-20 12:40:16 -0700643 recalc_sigpending();
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700644 if (!signr)
645 return 0;
646
647 if (unlikely(sig_kernel_stop(signr))) {
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800648 /*
649 * Set a marker that we have dequeued a stop signal. Our
650 * caller might release the siglock and then the pending
651 * stop signal it is about to process is no longer in the
652 * pending bitmasks, but must still be cleared by a SIGCONT
653 * (and overruled by a SIGKILL). So those cases clear this
654 * shared flag after we've set it. Note that this flag may
655 * remain set after the signal we return is ignored or
656 * handled. That doesn't matter because its only purpose
657 * is to alert stop-signal processing code when another
658 * processor has come along and cleared the flag.
659 */
Tejun Heoa8f072c2011-06-02 11:13:59 +0200660 current->jobctl |= JOBCTL_STOP_DEQUEUED;
Thomas Gleixner8bfd9a72007-02-16 01:28:12 -0800661 }
Pavel Emelyanovc5363d02008-04-30 00:52:40 -0700662 if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 /*
664 * Release the siglock to ensure proper locking order
665 * of timer locks outside of siglocks. Note, we leave
666 * irqs disabled here, since the posix-timers code is
667 * about to disable them again anyway.
668 */
669 spin_unlock(&tsk->sighand->siglock);
670 do_schedule_next_timer(info);
671 spin_lock(&tsk->sighand->siglock);
672 }
673 return signr;
674}
675
676/*
677 * Tell a process that it has a new active signal..
678 *
679 * NOTE! we rely on the previous spin_lock to
680 * lock interrupts for us! We can only be called with
681 * "siglock" held, and the local interrupt must
682 * have been disabled when that got acquired!
683 *
684 * No need to set need_resched since signal event passing
685 * goes through ->blocked
686 */
Oleg Nesterov910ffdb2013-01-21 20:47:41 +0100687void signal_wake_up_state(struct task_struct *t, unsigned int state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 set_tsk_thread_flag(t, TIF_SIGPENDING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 /*
Oleg Nesterov910ffdb2013-01-21 20:47:41 +0100691 * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500692 * case. We don't check t->state here because there is a race with it
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 * executing another processor and just now entering stopped state.
694 * By using wake_up_state, we ensure the process will wake up and
695 * handle its death signal.
696 */
Oleg Nesterov910ffdb2013-01-21 20:47:41 +0100697 if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 kick_process(t);
699}
700
701/*
702 * Remove signals in mask from the pending set and queue.
703 * Returns 1 if any signals were found.
704 *
705 * All callers must be holding the siglock.
George Anzinger71fabd52006-01-08 01:02:48 -0800706 *
707 * This version takes a sigset mask and looks at all signals,
708 * not just those in the first mask word.
709 */
710static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
711{
712 struct sigqueue *q, *n;
713 sigset_t m;
714
715 sigandsets(&m, mask, &s->signal);
716 if (sigisemptyset(&m))
717 return 0;
718
Oleg Nesterov702a5072011-04-27 22:01:27 +0200719 sigandnsets(&s->signal, &s->signal, mask);
George Anzinger71fabd52006-01-08 01:02:48 -0800720 list_for_each_entry_safe(q, n, &s->list, list) {
721 if (sigismember(mask, q->info.si_signo)) {
722 list_del_init(&q->list);
723 __sigqueue_free(q);
724 }
725 }
726 return 1;
727}
728/*
729 * Remove signals in mask from the pending set and queue.
730 * Returns 1 if any signals were found.
731 *
732 * All callers must be holding the siglock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 */
734static int rm_from_queue(unsigned long mask, struct sigpending *s)
735{
736 struct sigqueue *q, *n;
737
738 if (!sigtestsetmask(&s->signal, mask))
739 return 0;
740
741 sigdelsetmask(&s->signal, mask);
742 list_for_each_entry_safe(q, n, &s->list, list) {
743 if (q->info.si_signo < SIGRTMIN &&
744 (mask & sigmask(q->info.si_signo))) {
745 list_del_init(&q->list);
746 __sigqueue_free(q);
747 }
748 }
749 return 1;
750}
751
Oleg Nesterov614c5172009-12-15 16:47:22 -0800752static inline int is_si_special(const struct siginfo *info)
753{
754 return info <= SEND_SIG_FORCED;
755}
756
757static inline bool si_fromuser(const struct siginfo *info)
758{
759 return info == SEND_SIG_NOINFO ||
760 (!is_si_special(info) && SI_FROMUSER(info));
761}
762
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763/*
Serge E. Hallyn39fd3392011-03-23 16:43:19 -0700764 * called with RCU read lock from check_kill_permission()
765 */
766static int kill_ok_by_cred(struct task_struct *t)
767{
768 const struct cred *cred = current_cred();
769 const struct cred *tcred = __task_cred(t);
770
Eric W. Biederman5af66202012-03-03 20:21:47 -0800771 if (uid_eq(cred->euid, tcred->suid) ||
772 uid_eq(cred->euid, tcred->uid) ||
773 uid_eq(cred->uid, tcred->suid) ||
774 uid_eq(cred->uid, tcred->uid))
Serge E. Hallyn39fd3392011-03-23 16:43:19 -0700775 return 1;
776
Eric W. Biedermanc4a4d602011-11-16 23:15:31 -0800777 if (ns_capable(tcred->user_ns, CAP_KILL))
Serge E. Hallyn39fd3392011-03-23 16:43:19 -0700778 return 1;
779
780 return 0;
781}
782
783/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 * Bad permissions for sending the signal
David Howells694f6902010-08-04 16:59:14 +0100785 * - the caller must hold the RCU read lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 */
787static int check_kill_permission(int sig, struct siginfo *info,
788 struct task_struct *t)
789{
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700790 struct pid *sid;
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700791 int error;
792
Jesper Juhl7ed20e12005-05-01 08:59:14 -0700793 if (!valid_signal(sig))
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700794 return -EINVAL;
795
Oleg Nesterov614c5172009-12-15 16:47:22 -0800796 if (!si_fromuser(info))
Oleg Nesterov3b5e9e52008-04-30 00:52:42 -0700797 return 0;
798
799 error = audit_signal_info(sig, t); /* Let audit system see the signal */
800 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 return error;
Amy Griffise54dc242007-03-29 18:01:04 -0400802
Oleg Nesterov065add32010-05-26 14:42:54 -0700803 if (!same_thread_group(current, t) &&
Serge E. Hallyn39fd3392011-03-23 16:43:19 -0700804 !kill_ok_by_cred(t)) {
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700805 switch (sig) {
806 case SIGCONT:
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700807 sid = task_session(t);
Oleg Nesterov2e2ba222008-04-30 00:53:01 -0700808 /*
809 * We don't return the error if sid == NULL. The
810 * task was unhashed, the caller must notice this.
811 */
812 if (!sid || sid == task_session(current))
813 break;
814 default:
815 return -EPERM;
816 }
817 }
Steve Grubbc2f0c7c2005-05-06 12:38:39 +0100818
Amy Griffise54dc242007-03-29 18:01:04 -0400819 return security_task_kill(t, info, sig, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820}
821
Tejun Heofb1d9102011-06-14 11:20:17 +0200822/**
823 * ptrace_trap_notify - schedule trap to notify ptracer
824 * @t: tracee wanting to notify tracer
825 *
826 * This function schedules sticky ptrace trap which is cleared on the next
827 * TRAP_STOP to notify ptracer of an event. @t must have been seized by
828 * ptracer.
829 *
Tejun Heo544b2c92011-06-14 11:20:18 +0200830 * If @t is running, STOP trap will be taken. If trapped for STOP and
831 * ptracer is listening for events, tracee is woken up so that it can
832 * re-trap for the new event. If trapped otherwise, STOP trap will be
833 * eventually taken without returning to userland after the existing traps
834 * are finished by PTRACE_CONT.
Tejun Heofb1d9102011-06-14 11:20:17 +0200835 *
836 * CONTEXT:
837 * Must be called with @task->sighand->siglock held.
838 */
839static void ptrace_trap_notify(struct task_struct *t)
840{
841 WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
842 assert_spin_locked(&t->sighand->siglock);
843
844 task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
Oleg Nesterov910ffdb2013-01-21 20:47:41 +0100845 ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
Tejun Heofb1d9102011-06-14 11:20:17 +0200846}
847
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848/*
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700849 * Handle magic process-wide effects of stop/continue signals. Unlike
850 * the signal actions, these happen immediately at signal-generation
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 * time regardless of blocking, ignoring, or handling. This does the
852 * actual continuing for SIGCONT, but not the actual stopping for stop
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700853 * signals. The process stop is done as a signal action for SIG_DFL.
854 *
855 * Returns true if the signal should be actually delivered, otherwise
856 * it should be dropped.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 */
Oleg Nesterov403bad72013-04-30 15:28:10 -0700858static bool prepare_signal(int sig, struct task_struct *p, bool force)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859{
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700860 struct signal_struct *signal = p->signal;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 struct task_struct *t;
862
Oleg Nesterov403bad72013-04-30 15:28:10 -0700863 if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
864 if (signal->flags & SIGNAL_GROUP_COREDUMP)
865 return sig == SIGKILL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 /*
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700867 * The process is in the middle of dying, nothing to do.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 */
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700869 } else if (sig_kernel_stop(sig)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 /*
871 * This is a stop signal. Remove SIGCONT from all queues.
872 */
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700873 rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 t = p;
875 do {
876 rm_from_queue(sigmask(SIGCONT), &t->pending);
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700877 } while_each_thread(p, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 } else if (sig == SIGCONT) {
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700879 unsigned int why;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 /*
Oleg Nesterov1deac632011-04-01 20:11:50 +0200881 * Remove all stop signals from all queues, wake all threads.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 */
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700883 rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 t = p;
885 do {
Tejun Heo3759a0d2011-06-02 11:14:00 +0200886 task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
Tejun Heofb1d9102011-06-14 11:20:17 +0200888 if (likely(!(t->ptrace & PT_SEIZED)))
889 wake_up_state(t, __TASK_STOPPED);
890 else
891 ptrace_trap_notify(t);
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700892 } while_each_thread(p, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700894 /*
895 * Notify the parent with CLD_CONTINUED if we were stopped.
896 *
897 * If we were in the middle of a group stop, we pretend it
898 * was already finished, and then continued. Since SIGCHLD
899 * doesn't queue we report only CLD_STOPPED, as if the next
900 * CLD_CONTINUED was dropped.
901 */
902 why = 0;
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700903 if (signal->flags & SIGNAL_STOP_STOPPED)
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700904 why |= SIGNAL_CLD_CONTINUED;
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700905 else if (signal->group_stop_count)
Oleg Nesterovfc321d22008-04-30 00:52:46 -0700906 why |= SIGNAL_CLD_STOPPED;
907
908 if (why) {
Oleg Nesterov021e1ae2008-04-30 00:53:00 -0700909 /*
Roland McGrathae6d2ed2009-09-23 15:56:53 -0700910 * The first thread which returns from do_signal_stop()
Oleg Nesterov021e1ae2008-04-30 00:53:00 -0700911 * will take ->siglock, notice SIGNAL_CLD_MASK, and
912 * notify its parent. See get_signal_to_deliver().
913 */
Oleg Nesterovad16a4602008-04-30 00:52:46 -0700914 signal->flags = why | SIGNAL_STOP_CONTINUED;
915 signal->group_stop_count = 0;
916 signal->group_exit_code = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 }
Oleg Nesterov7e695a52008-04-30 00:52:59 -0700919
Oleg Nesterovdef8cf72012-03-23 15:02:45 -0700920 return !sig_ignored(p, sig, force);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921}
922
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700923/*
924 * Test if P wants to take SIG. After we've checked all threads with this,
925 * it's equivalent to finding no threads not blocking SIG. Any threads not
926 * blocking SIG were ruled out because they are not running and already
927 * have pending signals. Such threads will dequeue from the shared queue
928 * as soon as they're available, so putting the signal on the shared queue
929 * will be equivalent to sending it to one such thread.
930 */
931static inline int wants_signal(int sig, struct task_struct *p)
932{
933 if (sigismember(&p->blocked, sig))
934 return 0;
935 if (p->flags & PF_EXITING)
936 return 0;
937 if (sig == SIGKILL)
938 return 1;
939 if (task_is_stopped_or_traced(p))
940 return 0;
941 return task_curr(p) || !signal_pending(p);
942}
943
Oleg Nesterov5fcd8352008-04-30 00:52:55 -0700944static void complete_signal(int sig, struct task_struct *p, int group)
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700945{
946 struct signal_struct *signal = p->signal;
947 struct task_struct *t;
948
949 /*
950 * Now find a thread we can wake up to take the signal off the queue.
951 *
952 * If the main thread wants the signal, it gets first crack.
953 * Probably the least surprising to the average bear.
954 */
955 if (wants_signal(sig, p))
956 t = p;
Oleg Nesterov5fcd8352008-04-30 00:52:55 -0700957 else if (!group || thread_group_empty(p))
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700958 /*
959 * There is just one thread and it does not need to be woken.
960 * It will dequeue unblocked signals before it runs again.
961 */
962 return;
963 else {
964 /*
965 * Otherwise try to find a suitable thread.
966 */
967 t = signal->curr_target;
968 while (!wants_signal(sig, t)) {
969 t = next_thread(t);
970 if (t == signal->curr_target)
971 /*
972 * No thread needs to be woken.
973 * Any eligible threads will see
974 * the signal in the queue soon.
975 */
976 return;
977 }
978 signal->curr_target = t;
979 }
980
981 /*
982 * Found a killable thread. If the signal will be fatal,
983 * then start taking the whole group down immediately.
984 */
Oleg Nesterovfae5fa42008-04-30 00:53:03 -0700985 if (sig_fatal(p, sig) &&
986 !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700987 !sigismember(&t->real_blocked, sig) &&
Tejun Heoa288eec2011-06-17 16:50:37 +0200988 (sig == SIGKILL || !t->ptrace)) {
Oleg Nesterov71f11dc2008-04-30 00:52:53 -0700989 /*
990 * This signal will be fatal to the whole group.
991 */
992 if (!sig_kernel_coredump(sig)) {
993 /*
994 * Start a group exit and wake everybody up.
995 * This way we don't have other threads
996 * running and doing things after a slower
997 * thread has the fatal signal pending.
998 */
999 signal->flags = SIGNAL_GROUP_EXIT;
1000 signal->group_exit_code = sig;
1001 signal->group_stop_count = 0;
1002 t = p;
1003 do {
Tejun Heo6dfca322011-06-02 11:14:00 +02001004 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
Oleg Nesterov71f11dc2008-04-30 00:52:53 -07001005 sigaddset(&t->pending.signal, SIGKILL);
1006 signal_wake_up(t, 1);
1007 } while_each_thread(p, t);
1008 return;
1009 }
1010 }
1011
1012 /*
1013 * The signal is already in the shared-pending queue.
1014 * Tell the chosen thread to wake up and dequeue it.
1015 */
1016 signal_wake_up(t, sig == SIGKILL);
1017 return;
1018}
1019
Pavel Emelyanovaf7fff92008-04-30 00:52:34 -07001020static inline int legacy_queue(struct sigpending *signals, int sig)
1021{
1022 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
1023}
1024
Serge E. Hallyn6b550f92012-01-10 15:11:37 -08001025#ifdef CONFIG_USER_NS
1026static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
1027{
1028 if (current_user_ns() == task_cred_xxx(t, user_ns))
1029 return;
1030
1031 if (SI_FROMKERNEL(info))
1032 return;
1033
Eric W. Biederman078de5f2012-02-08 07:00:08 -08001034 rcu_read_lock();
1035 info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
1036 make_kuid(current_user_ns(), info->si_uid));
1037 rcu_read_unlock();
Serge E. Hallyn6b550f92012-01-10 15:11:37 -08001038}
1039#else
1040static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
1041{
1042 return;
1043}
1044#endif
1045
Sukadev Bhattiprolu7978b562009-04-02 16:58:04 -07001046static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
1047 int group, int from_ancestor_ns)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048{
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001049 struct sigpending *pending;
Oleg Nesterov6e65acb2008-04-30 00:52:50 -07001050 struct sigqueue *q;
Vegard Nossum7a0aeb12009-05-16 11:28:33 +02001051 int override_rlimit;
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001052 int ret = 0, result;
Mathieu Desnoyers0a16b602008-07-18 12:16:17 -04001053
Oleg Nesterov6e65acb2008-04-30 00:52:50 -07001054 assert_spin_locked(&t->sighand->siglock);
Sukadev Bhattiprolu921cf9f2009-04-02 16:58:05 -07001055
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001056 result = TRACE_SIGNAL_IGNORED;
Oleg Nesterov629d3622012-03-23 15:02:44 -07001057 if (!prepare_signal(sig, t,
1058 from_ancestor_ns || (info == SEND_SIG_FORCED)))
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001059 goto ret;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001060
1061 pending = group ? &t->signal->shared_pending : &t->pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 /*
Pavel Emelyanov2acb0242008-04-30 00:52:35 -07001063 * Short-circuit ignored signals and support queuing
1064 * exactly one non-rt signal, so that we can get more
1065 * detailed information about the cause of the signal.
1066 */
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001067 result = TRACE_SIGNAL_ALREADY_PENDING;
Oleg Nesterov7e695a52008-04-30 00:52:59 -07001068 if (legacy_queue(pending, sig))
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001069 goto ret;
1070
1071 result = TRACE_SIGNAL_DELIVERED;
Davide Libenzifba2afa2007-05-10 22:23:13 -07001072 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 * fast-pathed signals for kernel-internal things like SIGSTOP
1074 * or SIGKILL.
1075 */
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001076 if (info == SEND_SIG_FORCED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 goto out_set;
1078
Randy Dunlap5aba0852011-04-04 14:59:31 -07001079 /*
1080 * Real-time signals must be queued if sent by sigqueue, or
1081 * some other real-time mechanism. It is implementation
1082 * defined whether kill() does so. We attempt to do so, on
1083 * the principle of least surprise, but since kill is not
1084 * allowed to fail with EAGAIN when low on memory we just
1085 * make sure at least one signal gets delivered and don't
1086 * pass on the info struct.
1087 */
Vegard Nossum7a0aeb12009-05-16 11:28:33 +02001088 if (sig < SIGRTMIN)
1089 override_rlimit = (is_si_special(info) || info->si_code >= 0);
1090 else
1091 override_rlimit = 0;
1092
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +09001093 q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
Vegard Nossum7a0aeb12009-05-16 11:28:33 +02001094 override_rlimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 if (q) {
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001096 list_add_tail(&q->list, &pending->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 switch ((unsigned long) info) {
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001098 case (unsigned long) SEND_SIG_NOINFO:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 q->info.si_signo = sig;
1100 q->info.si_errno = 0;
1101 q->info.si_code = SI_USER;
Sukadev Bhattiprolu9cd4fd12009-01-06 14:42:46 -08001102 q->info.si_pid = task_tgid_nr_ns(current,
Sukadev Bhattiprolu09bca052009-01-06 14:42:45 -08001103 task_active_pid_ns(t));
Eric W. Biederman078de5f2012-02-08 07:00:08 -08001104 q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 break;
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001106 case (unsigned long) SEND_SIG_PRIV:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 q->info.si_signo = sig;
1108 q->info.si_errno = 0;
1109 q->info.si_code = SI_KERNEL;
1110 q->info.si_pid = 0;
1111 q->info.si_uid = 0;
1112 break;
1113 default:
1114 copy_siginfo(&q->info, info);
Sukadev Bhattiprolu6588c1e2009-04-02 16:58:09 -07001115 if (from_ancestor_ns)
1116 q->info.si_pid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 break;
1118 }
Serge E. Hallyn6b550f92012-01-10 15:11:37 -08001119
1120 userns_fixup_signal_uid(&q->info, t);
1121
Oleg Nesterov621d3122005-10-30 15:03:45 -08001122 } else if (!is_si_special(info)) {
Masami Hiramatsuba005e12009-11-24 16:56:58 -05001123 if (sig >= SIGRTMIN && info->si_code != SI_USER) {
1124 /*
1125 * Queue overflow, abort. We may abort if the
1126 * signal was rt and sent by user using something
1127 * other than kill().
1128 */
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001129 result = TRACE_SIGNAL_OVERFLOW_FAIL;
1130 ret = -EAGAIN;
1131 goto ret;
Masami Hiramatsuba005e12009-11-24 16:56:58 -05001132 } else {
1133 /*
1134 * This is a silent loss of information. We still
1135 * send the signal, but the *info bits are lost.
1136 */
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001137 result = TRACE_SIGNAL_LOSE_INFO;
Masami Hiramatsuba005e12009-11-24 16:56:58 -05001138 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 }
1140
1141out_set:
Oleg Nesterov53c30332008-04-30 00:53:00 -07001142 signalfd_notify(t, sig);
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001143 sigaddset(&pending->signal, sig);
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001144 complete_signal(sig, t, group);
Oleg Nesterov6c303d32011-11-22 21:13:48 +01001145ret:
1146 trace_signal_generate(sig, info, t, group, result);
1147 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148}
1149
Sukadev Bhattiprolu7978b562009-04-02 16:58:04 -07001150static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
1151 int group)
1152{
Sukadev Bhattiprolu921cf9f2009-04-02 16:58:05 -07001153 int from_ancestor_ns = 0;
1154
1155#ifdef CONFIG_PID_NS
Oleg Nesterovdd342002009-12-15 16:47:24 -08001156 from_ancestor_ns = si_fromuser(info) &&
1157 !task_pid_nr_ns(current, task_active_pid_ns(t));
Sukadev Bhattiprolu921cf9f2009-04-02 16:58:05 -07001158#endif
1159
1160 return __send_signal(sig, info, t, group, from_ancestor_ns);
Sukadev Bhattiprolu7978b562009-04-02 16:58:04 -07001161}
1162
Al Viro4aaefee2012-11-05 13:09:56 -05001163static void print_fatal_signal(int signr)
Ingo Molnar45807a12007-07-15 23:40:10 -07001164{
Al Viro4aaefee2012-11-05 13:09:56 -05001165 struct pt_regs *regs = signal_pt_regs();
Vineet Gupta681a90f2013-04-30 15:27:19 -07001166 printk(KERN_INFO "potentially unexpected fatal signal %d.\n", signr);
Ingo Molnar45807a12007-07-15 23:40:10 -07001167
Al Viroca5cd872007-10-29 04:31:16 +00001168#if defined(__i386__) && !defined(__arch_um__)
Valdis Kletnieks5d1fadc2013-02-27 17:03:13 -08001169 printk(KERN_INFO "code at %08lx: ", regs->ip);
Ingo Molnar45807a12007-07-15 23:40:10 -07001170 {
1171 int i;
1172 for (i = 0; i < 16; i++) {
1173 unsigned char insn;
1174
Andi Kleenb45c6e72010-01-08 14:42:52 -08001175 if (get_user(insn, (unsigned char *)(regs->ip + i)))
1176 break;
Valdis Kletnieks5d1fadc2013-02-27 17:03:13 -08001177 printk(KERN_CONT "%02x ", insn);
Ingo Molnar45807a12007-07-15 23:40:10 -07001178 }
1179 }
Valdis Kletnieks5d1fadc2013-02-27 17:03:13 -08001180 printk(KERN_CONT "\n");
Ingo Molnar45807a12007-07-15 23:40:10 -07001181#endif
Ed Swierk3a9f84d2009-01-26 15:33:31 -08001182 preempt_disable();
Ingo Molnar45807a12007-07-15 23:40:10 -07001183 show_regs(regs);
Ed Swierk3a9f84d2009-01-26 15:33:31 -08001184 preempt_enable();
Ingo Molnar45807a12007-07-15 23:40:10 -07001185}
1186
1187static int __init setup_print_fatal_signals(char *str)
1188{
1189 get_option (&str, &print_fatal_signals);
1190
1191 return 1;
1192}
1193
1194__setup("print-fatal-signals=", setup_print_fatal_signals);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001196int
1197__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1198{
1199 return send_signal(sig, info, p, 1);
1200}
1201
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202static int
1203specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1204{
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001205 return send_signal(sig, info, t, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206}
1207
Oleg Nesterov4a30deb2009-09-23 15:57:00 -07001208int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
1209 bool group)
1210{
1211 unsigned long flags;
1212 int ret = -ESRCH;
1213
1214 if (lock_task_sighand(p, &flags)) {
1215 ret = send_signal(sig, info, p, group);
1216 unlock_task_sighand(p, &flags);
1217 }
1218
1219 return ret;
1220}
1221
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222/*
1223 * Force a signal that the process can't ignore: if necessary
1224 * we unblock the signal and change any SIG_IGN to SIG_DFL.
Linus Torvaldsae74c3b2006-08-02 20:17:49 -07001225 *
1226 * Note: If we unblock the signal, we always reset it to SIG_DFL,
1227 * since we do not want to have a signal handler that was blocked
1228 * be invoked when user space had explicitly blocked it.
1229 *
Oleg Nesterov80fe7282008-04-30 00:53:05 -07001230 * We don't want to have recursive SIGSEGV's etc, for example,
1231 * that is why we also clear SIGNAL_UNKILLABLE.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233int
1234force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1235{
1236 unsigned long int flags;
Linus Torvaldsae74c3b2006-08-02 20:17:49 -07001237 int ret, blocked, ignored;
1238 struct k_sigaction *action;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239
1240 spin_lock_irqsave(&t->sighand->siglock, flags);
Linus Torvaldsae74c3b2006-08-02 20:17:49 -07001241 action = &t->sighand->action[sig-1];
1242 ignored = action->sa.sa_handler == SIG_IGN;
1243 blocked = sigismember(&t->blocked, sig);
1244 if (blocked || ignored) {
1245 action->sa.sa_handler = SIG_DFL;
1246 if (blocked) {
1247 sigdelset(&t->blocked, sig);
Roland McGrath7bb44ad2007-05-23 13:57:44 -07001248 recalc_sigpending_and_wake(t);
Linus Torvaldsae74c3b2006-08-02 20:17:49 -07001249 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 }
Oleg Nesterov80fe7282008-04-30 00:53:05 -07001251 if (action->sa.sa_handler == SIG_DFL)
1252 t->signal->flags &= ~SIGNAL_UNKILLABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 ret = specific_send_sig_info(sig, info, t);
1254 spin_unlock_irqrestore(&t->sighand->siglock, flags);
1255
1256 return ret;
1257}
1258
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259/*
1260 * Nuke all other threads in the group.
1261 */
Oleg Nesterov09faef12010-05-26 14:43:11 -07001262int zap_other_threads(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263{
Oleg Nesterov09faef12010-05-26 14:43:11 -07001264 struct task_struct *t = p;
1265 int count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 p->signal->group_stop_count = 0;
1268
Oleg Nesterov09faef12010-05-26 14:43:11 -07001269 while_each_thread(p, t) {
Tejun Heo6dfca322011-06-02 11:14:00 +02001270 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
Oleg Nesterov09faef12010-05-26 14:43:11 -07001271 count++;
1272
1273 /* Don't bother with already dead threads */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 if (t->exit_state)
1275 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 sigaddset(&t->pending.signal, SIGKILL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 signal_wake_up(t, 1);
1278 }
Oleg Nesterov09faef12010-05-26 14:43:11 -07001279
1280 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281}
1282
Namhyung Kimb8ed3742010-10-27 15:34:06 -07001283struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
1284 unsigned long *flags)
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001285{
1286 struct sighand_struct *sighand;
1287
1288 for (;;) {
Paul E. McKenneya8417962011-07-19 03:25:36 -07001289 local_irq_save(*flags);
1290 rcu_read_lock();
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001291 sighand = rcu_dereference(tsk->sighand);
Paul E. McKenneya8417962011-07-19 03:25:36 -07001292 if (unlikely(sighand == NULL)) {
1293 rcu_read_unlock();
1294 local_irq_restore(*flags);
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001295 break;
Paul E. McKenneya8417962011-07-19 03:25:36 -07001296 }
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001297
Paul E. McKenneya8417962011-07-19 03:25:36 -07001298 spin_lock(&sighand->siglock);
1299 if (likely(sighand == tsk->sighand)) {
1300 rcu_read_unlock();
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001301 break;
Paul E. McKenneya8417962011-07-19 03:25:36 -07001302 }
1303 spin_unlock(&sighand->siglock);
1304 rcu_read_unlock();
1305 local_irq_restore(*flags);
Oleg Nesterovf63ee722006-03-28 16:11:13 -08001306 }
1307
1308 return sighand;
1309}
1310
David Howellsc69e8d92008-11-14 10:39:19 +11001311/*
1312 * send signal info to all the members of a group
David Howellsc69e8d92008-11-14 10:39:19 +11001313 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1315{
David Howells694f6902010-08-04 16:59:14 +01001316 int ret;
1317
1318 rcu_read_lock();
1319 ret = check_kill_permission(sig, info, p);
1320 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321
Oleg Nesterov4a30deb2009-09-23 15:57:00 -07001322 if (!ret && sig)
1323 ret = do_send_sig_info(sig, info, p, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
1325 return ret;
1326}
1327
1328/*
Pavel Emelyanov146a5052008-02-08 04:19:22 -08001329 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 * control characters do (^C, ^Z etc)
David Howellsc69e8d92008-11-14 10:39:19 +11001331 * - the caller must hold at least a readlock on tasklist_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 */
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001333int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334{
1335 struct task_struct *p = NULL;
1336 int retval, success;
1337
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 success = 0;
1339 retval = -ESRCH;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001340 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 int err = group_send_sig_info(sig, info, p);
1342 success |= !err;
1343 retval = err;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001344 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 return success ? 0 : retval;
1346}
1347
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001348int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349{
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001350 int error = -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 struct task_struct *p;
1352
Ingo Molnare56d0902006-01-08 01:01:37 -08001353 rcu_read_lock();
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001354retry:
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001355 p = pid_task(pid, PIDTYPE_PID);
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001356 if (p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 error = group_send_sig_info(sig, info, p);
Oleg Nesterovd36174b2008-02-08 04:19:18 -08001358 if (unlikely(error == -ESRCH))
1359 /*
1360 * The task was unhashed in between, try again.
1361 * If it is dead, pid_task() will return NULL,
1362 * if we race with de_thread() it will find the
1363 * new leader.
1364 */
1365 goto retry;
1366 }
Ingo Molnare56d0902006-01-08 01:01:37 -08001367 rcu_read_unlock();
Oleg Nesterov6ca25b52008-04-30 00:52:45 -07001368
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 return error;
1370}
1371
Randy Dunlap5aba0852011-04-04 14:59:31 -07001372int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001373{
1374 int error;
1375 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001376 error = kill_pid_info(sig, info, find_vpid(pid));
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001377 rcu_read_unlock();
1378 return error;
1379}
1380
Serge Hallynd178bc32011-09-26 10:45:18 -05001381static int kill_as_cred_perm(const struct cred *cred,
1382 struct task_struct *target)
1383{
1384 const struct cred *pcred = __task_cred(target);
Eric W. Biederman5af66202012-03-03 20:21:47 -08001385 if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) &&
1386 !uid_eq(cred->uid, pcred->suid) && !uid_eq(cred->uid, pcred->uid))
Serge Hallynd178bc32011-09-26 10:45:18 -05001387 return 0;
1388 return 1;
1389}
1390
Eric W. Biederman2425c082006-10-02 02:17:28 -07001391/* like kill_pid_info(), but doesn't use uid/euid of "current" */
Serge Hallynd178bc32011-09-26 10:45:18 -05001392int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid,
1393 const struct cred *cred, u32 secid)
Harald Welte46113832005-10-10 19:44:29 +02001394{
1395 int ret = -EINVAL;
1396 struct task_struct *p;
Thomas Gleixner14d8c9f2009-12-10 00:53:17 +00001397 unsigned long flags;
Harald Welte46113832005-10-10 19:44:29 +02001398
1399 if (!valid_signal(sig))
1400 return ret;
1401
Thomas Gleixner14d8c9f2009-12-10 00:53:17 +00001402 rcu_read_lock();
Eric W. Biederman2425c082006-10-02 02:17:28 -07001403 p = pid_task(pid, PIDTYPE_PID);
Harald Welte46113832005-10-10 19:44:29 +02001404 if (!p) {
1405 ret = -ESRCH;
1406 goto out_unlock;
1407 }
Serge Hallynd178bc32011-09-26 10:45:18 -05001408 if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
Harald Welte46113832005-10-10 19:44:29 +02001409 ret = -EPERM;
1410 goto out_unlock;
1411 }
David Quigley8f95dc52006-06-30 01:55:47 -07001412 ret = security_task_kill(p, info, sig, secid);
1413 if (ret)
1414 goto out_unlock;
Thomas Gleixner14d8c9f2009-12-10 00:53:17 +00001415
1416 if (sig) {
1417 if (lock_task_sighand(p, &flags)) {
1418 ret = __send_signal(sig, info, p, 1, 0);
1419 unlock_task_sighand(p, &flags);
1420 } else
1421 ret = -ESRCH;
Harald Welte46113832005-10-10 19:44:29 +02001422 }
1423out_unlock:
Thomas Gleixner14d8c9f2009-12-10 00:53:17 +00001424 rcu_read_unlock();
Harald Welte46113832005-10-10 19:44:29 +02001425 return ret;
1426}
Serge Hallynd178bc32011-09-26 10:45:18 -05001427EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428
1429/*
1430 * kill_something_info() interprets pid in interesting ways just like kill(2).
1431 *
1432 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1433 * is probably wrong. Should make it like BSD or SYSV.
1434 */
1435
Gustavo Fernando Padovanbc64efd2008-07-25 01:47:33 -07001436static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437{
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001438 int ret;
Pavel Emelyanovd5df7632008-02-08 04:19:22 -08001439
1440 if (pid > 0) {
1441 rcu_read_lock();
1442 ret = kill_pid_info(sig, info, find_vpid(pid));
1443 rcu_read_unlock();
1444 return ret;
1445 }
1446
1447 read_lock(&tasklist_lock);
1448 if (pid != -1) {
1449 ret = __kill_pgrp_info(sig, info,
1450 pid ? find_vpid(-pid) : task_pgrp(current));
1451 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 int retval = 0, count = 0;
1453 struct task_struct * p;
1454
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 for_each_process(p) {
Sukadev Bhattiprolud25141a2008-10-29 14:01:11 -07001456 if (task_pid_vnr(p) > 1 &&
1457 !same_thread_group(p, current)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 int err = group_send_sig_info(sig, info, p);
1459 ++count;
1460 if (err != -EPERM)
1461 retval = err;
1462 }
1463 }
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001464 ret = count ? retval : -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 }
Pavel Emelyanovd5df7632008-02-08 04:19:22 -08001466 read_unlock(&tasklist_lock);
1467
Eric W. Biederman8d42db182007-02-12 00:52:55 -08001468 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469}
1470
1471/*
1472 * These are for backward compatibility with the rest of the kernel source.
1473 */
1474
Randy Dunlap5aba0852011-04-04 14:59:31 -07001475int send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 /*
1478 * Make sure legacy kernel users don't send in bad values
1479 * (normal paths check this in check_kill_permission).
1480 */
Jesper Juhl7ed20e12005-05-01 08:59:14 -07001481 if (!valid_signal(sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 return -EINVAL;
1483
Oleg Nesterov4a30deb2009-09-23 15:57:00 -07001484 return do_send_sig_info(sig, info, p, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485}
1486
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001487#define __si_special(priv) \
1488 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1489
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490int
1491send_sig(int sig, struct task_struct *p, int priv)
1492{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001493 return send_sig_info(sig, __si_special(priv), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494}
1495
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496void
1497force_sig(int sig, struct task_struct *p)
1498{
Oleg Nesterovb67a1b92005-10-30 15:03:44 -08001499 force_sig_info(sig, SEND_SIG_PRIV, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500}
1501
1502/*
1503 * When things go south during signal handling, we
1504 * will force a SIGSEGV. And if the signal that caused
1505 * the problem was already a SIGSEGV, we'll want to
1506 * make sure we don't even try to deliver the signal..
1507 */
1508int
1509force_sigsegv(int sig, struct task_struct *p)
1510{
1511 if (sig == SIGSEGV) {
1512 unsigned long flags;
1513 spin_lock_irqsave(&p->sighand->siglock, flags);
1514 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1515 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1516 }
1517 force_sig(SIGSEGV, p);
1518 return 0;
1519}
1520
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001521int kill_pgrp(struct pid *pid, int sig, int priv)
1522{
Pavel Emelyanov146a5052008-02-08 04:19:22 -08001523 int ret;
1524
1525 read_lock(&tasklist_lock);
1526 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1527 read_unlock(&tasklist_lock);
1528
1529 return ret;
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07001530}
1531EXPORT_SYMBOL(kill_pgrp);
1532
1533int kill_pid(struct pid *pid, int sig, int priv)
1534{
1535 return kill_pid_info(sig, __si_special(priv), pid);
1536}
1537EXPORT_SYMBOL(kill_pid);
1538
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539/*
1540 * These functions support sending signals using preallocated sigqueue
1541 * structures. This is needed "because realtime applications cannot
1542 * afford to lose notifications of asynchronous events, like timer
Randy Dunlap5aba0852011-04-04 14:59:31 -07001543 * expirations or I/O completions". In the case of POSIX Timers
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 * we allocate the sigqueue structure from the timer_create. If this
1545 * allocation fails we are able to report the failure to the application
1546 * with an EAGAIN error.
1547 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548struct sigqueue *sigqueue_alloc(void)
1549{
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +09001550 struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +09001552 if (q)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 q->flags |= SIGQUEUE_PREALLOC;
Naohiro Ooiwaf84d49b2009-11-09 00:46:42 +09001554
1555 return q;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556}
1557
1558void sigqueue_free(struct sigqueue *q)
1559{
1560 unsigned long flags;
Oleg Nesterov60187d22007-08-30 23:56:35 -07001561 spinlock_t *lock = &current->sighand->siglock;
1562
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1564 /*
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001565 * We must hold ->siglock while testing q->list
1566 * to serialize with collect_signal() or with
Oleg Nesterovda7978b2008-05-23 13:04:41 -07001567 * __exit_signal()->flush_sigqueue().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 */
Oleg Nesterov60187d22007-08-30 23:56:35 -07001569 spin_lock_irqsave(lock, flags);
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001570 q->flags &= ~SIGQUEUE_PREALLOC;
1571 /*
1572 * If it is queued it will be freed when dequeued,
1573 * like the "regular" sigqueue.
1574 */
Oleg Nesterov60187d22007-08-30 23:56:35 -07001575 if (!list_empty(&q->list))
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001576 q = NULL;
Oleg Nesterov60187d22007-08-30 23:56:35 -07001577 spin_unlock_irqrestore(lock, flags);
1578
Oleg Nesterovc8e85b4f2008-05-26 20:55:42 +04001579 if (q)
1580 __sigqueue_free(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581}
1582
Oleg Nesterovac5c2152008-04-30 00:52:57 -07001583int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001584{
Oleg Nesterove62e6652008-04-30 00:52:56 -07001585 int sig = q->info.si_signo;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001586 struct sigpending *pending;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001587 unsigned long flags;
Oleg Nesterov163566f2011-11-22 21:37:41 +01001588 int ret, result;
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001589
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001590 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
Oleg Nesterove62e6652008-04-30 00:52:56 -07001591
1592 ret = -1;
1593 if (!likely(lock_task_sighand(t, &flags)))
1594 goto ret;
1595
Oleg Nesterov7e695a52008-04-30 00:52:59 -07001596 ret = 1; /* the signal is ignored */
Oleg Nesterov163566f2011-11-22 21:37:41 +01001597 result = TRACE_SIGNAL_IGNORED;
Oleg Nesterovdef8cf72012-03-23 15:02:45 -07001598 if (!prepare_signal(sig, t, false))
Oleg Nesterove62e6652008-04-30 00:52:56 -07001599 goto out;
1600
1601 ret = 0;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001602 if (unlikely(!list_empty(&q->list))) {
1603 /*
1604 * If an SI_TIMER entry is already queue just increment
1605 * the overrun count.
1606 */
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001607 BUG_ON(q->info.si_code != SI_TIMER);
1608 q->info.si_overrun++;
Oleg Nesterov163566f2011-11-22 21:37:41 +01001609 result = TRACE_SIGNAL_ALREADY_PENDING;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001610 goto out;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001611 }
Oleg Nesterovba661292008-07-23 20:52:05 +04001612 q->info.si_overrun = 0;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001613
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001614 signalfd_notify(t, sig);
Oleg Nesterov2ca35152008-04-30 00:52:54 -07001615 pending = group ? &t->signal->shared_pending : &t->pending;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001616 list_add_tail(&q->list, &pending->list);
1617 sigaddset(&pending->signal, sig);
Pavel Emelyanov4cd4b6d2008-04-30 00:52:55 -07001618 complete_signal(sig, t, group);
Oleg Nesterov163566f2011-11-22 21:37:41 +01001619 result = TRACE_SIGNAL_DELIVERED;
Oleg Nesterove62e6652008-04-30 00:52:56 -07001620out:
Oleg Nesterov163566f2011-11-22 21:37:41 +01001621 trace_signal_generate(sig, &q->info, t, group, result);
Oleg Nesterove62e6652008-04-30 00:52:56 -07001622 unlock_task_sighand(t, &flags);
1623ret:
1624 return ret;
Pavel Emelyanov9e3bd6c2008-04-30 00:52:41 -07001625}
1626
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 * Let a parent know about the death of a child.
1629 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
Roland McGrath2b2a1ff2008-07-25 19:45:54 -07001630 *
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001631 * Returns true if our parent ignored us and so we've switched to
1632 * self-reaping.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 */
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001634bool do_notify_parent(struct task_struct *tsk, int sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635{
1636 struct siginfo info;
1637 unsigned long flags;
1638 struct sighand_struct *psig;
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001639 bool autoreap = false;
Frederic Weisbecker6fac4822012-11-13 14:20:55 +01001640 cputime_t utime, stime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641
1642 BUG_ON(sig == -1);
1643
1644 /* do_notify_parent_cldstop should have been called instead. */
Matthew Wilcoxe1abb392007-12-06 11:07:35 -05001645 BUG_ON(task_is_stopped_or_traced(tsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
Tejun Heod21142e2011-06-17 16:50:34 +02001647 BUG_ON(!tsk->ptrace &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1649
Oleg Nesterovb6e238d2012-03-19 17:03:41 +01001650 if (sig != SIGCHLD) {
1651 /*
1652 * This is only possible if parent == real_parent.
1653 * Check if it has changed security domain.
1654 */
1655 if (tsk->parent_exec_id != tsk->parent->self_exec_id)
1656 sig = SIGCHLD;
1657 }
1658
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 info.si_signo = sig;
1660 info.si_errno = 0;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001661 /*
Eric W. Biederman32084502012-05-31 16:26:39 -07001662 * We are under tasklist_lock here so our parent is tied to
1663 * us and cannot change.
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001664 *
Eric W. Biederman32084502012-05-31 16:26:39 -07001665 * task_active_pid_ns will always return the same pid namespace
1666 * until a task passes through release_task.
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001667 *
1668 * write_lock() currently calls preempt_disable() which is the
1669 * same as rcu_read_lock(), but according to Oleg, this is not
1670 * correct to rely on this
1671 */
1672 rcu_read_lock();
Eric W. Biederman32084502012-05-31 16:26:39 -07001673 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
Eric W. Biederman54ba47e2012-03-13 16:04:35 -07001674 info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
1675 task_uid(tsk));
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001676 rcu_read_unlock();
1677
Frederic Weisbecker6fac4822012-11-13 14:20:55 +01001678 task_cputime(tsk, &utime, &stime);
1679 info.si_utime = cputime_to_clock_t(utime + tsk->signal->utime);
1680 info.si_stime = cputime_to_clock_t(stime + tsk->signal->stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681
1682 info.si_status = tsk->exit_code & 0x7f;
1683 if (tsk->exit_code & 0x80)
1684 info.si_code = CLD_DUMPED;
1685 else if (tsk->exit_code & 0x7f)
1686 info.si_code = CLD_KILLED;
1687 else {
1688 info.si_code = CLD_EXITED;
1689 info.si_status = tsk->exit_code >> 8;
1690 }
1691
1692 psig = tsk->parent->sighand;
1693 spin_lock_irqsave(&psig->siglock, flags);
Tejun Heod21142e2011-06-17 16:50:34 +02001694 if (!tsk->ptrace && sig == SIGCHLD &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1696 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1697 /*
1698 * We are exiting and our parent doesn't care. POSIX.1
1699 * defines special semantics for setting SIGCHLD to SIG_IGN
1700 * or setting the SA_NOCLDWAIT flag: we should be reaped
1701 * automatically and not left for our parent's wait4 call.
1702 * Rather than having the parent do it as a magic kind of
1703 * signal handler, we just set this to tell do_exit that we
1704 * can be cleaned up without becoming a zombie. Note that
1705 * we still call __wake_up_parent in this case, because a
1706 * blocked sys_wait4 might now return -ECHILD.
1707 *
1708 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1709 * is implementation-defined: we do (if you don't want
1710 * it, just use SIG_IGN instead).
1711 */
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001712 autoreap = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001714 sig = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 }
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001716 if (valid_signal(sig) && sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 __group_send_sig_info(sig, &info, tsk->parent);
1718 __wake_up_parent(tsk, tsk->parent);
1719 spin_unlock_irqrestore(&psig->siglock, flags);
Roland McGrath2b2a1ff2008-07-25 19:45:54 -07001720
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02001721 return autoreap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722}
1723
Tejun Heo75b95952011-03-23 10:37:01 +01001724/**
1725 * do_notify_parent_cldstop - notify parent of stopped/continued state change
1726 * @tsk: task reporting the state change
1727 * @for_ptracer: the notification is for ptracer
1728 * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
1729 *
1730 * Notify @tsk's parent that the stopped/continued state has changed. If
1731 * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
1732 * If %true, @tsk reports to @tsk->parent which should be the ptracer.
1733 *
1734 * CONTEXT:
1735 * Must be called with tasklist_lock at least read locked.
1736 */
1737static void do_notify_parent_cldstop(struct task_struct *tsk,
1738 bool for_ptracer, int why)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739{
1740 struct siginfo info;
1741 unsigned long flags;
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001742 struct task_struct *parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 struct sighand_struct *sighand;
Frederic Weisbecker6fac4822012-11-13 14:20:55 +01001744 cputime_t utime, stime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745
Tejun Heo75b95952011-03-23 10:37:01 +01001746 if (for_ptracer) {
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001747 parent = tsk->parent;
Tejun Heo75b95952011-03-23 10:37:01 +01001748 } else {
Oleg Nesterovbc505a42005-09-06 15:17:32 -07001749 tsk = tsk->group_leader;
1750 parent = tsk->real_parent;
1751 }
1752
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 info.si_signo = SIGCHLD;
1754 info.si_errno = 0;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001755 /*
Randy Dunlap5aba0852011-04-04 14:59:31 -07001756 * see comment in do_notify_parent() about the following 4 lines
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001757 */
1758 rcu_read_lock();
Eric W. Biederman17cf22c2010-03-02 14:51:53 -08001759 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
Eric W. Biederman54ba47e2012-03-13 16:04:35 -07001760 info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001761 rcu_read_unlock();
1762
Frederic Weisbecker6fac4822012-11-13 14:20:55 +01001763 task_cputime(tsk, &utime, &stime);
1764 info.si_utime = cputime_to_clock_t(utime);
1765 info.si_stime = cputime_to_clock_t(stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766
1767 info.si_code = why;
1768 switch (why) {
1769 case CLD_CONTINUED:
1770 info.si_status = SIGCONT;
1771 break;
1772 case CLD_STOPPED:
1773 info.si_status = tsk->signal->group_exit_code & 0x7f;
1774 break;
1775 case CLD_TRAPPED:
1776 info.si_status = tsk->exit_code & 0x7f;
1777 break;
1778 default:
1779 BUG();
1780 }
1781
1782 sighand = parent->sighand;
1783 spin_lock_irqsave(&sighand->siglock, flags);
1784 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1785 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1786 __group_send_sig_info(SIGCHLD, &info, parent);
1787 /*
1788 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1789 */
1790 __wake_up_parent(tsk, parent);
1791 spin_unlock_irqrestore(&sighand->siglock, flags);
1792}
1793
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001794static inline int may_ptrace_stop(void)
1795{
Tejun Heod21142e2011-06-17 16:50:34 +02001796 if (!likely(current->ptrace))
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001797 return 0;
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001798 /*
1799 * Are we in the middle of do_coredump?
1800 * If so and our tracer is also part of the coredump stopping
1801 * is a deadlock situation, and pointless because our tracer
1802 * is dead so don't allow us to stop.
1803 * If SIGKILL was already sent before the caller unlocked
Oleg Nesterov999d9fc2008-07-25 01:47:41 -07001804 * ->siglock we must see ->core_state != NULL. Otherwise it
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001805 * is safe to enter schedule().
Oleg Nesterov9899d112013-01-21 20:48:00 +01001806 *
1807 * This is almost outdated, a task with the pending SIGKILL can't
1808 * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported
1809 * after SIGKILL was already dequeued.
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001810 */
Oleg Nesterov999d9fc2008-07-25 01:47:41 -07001811 if (unlikely(current->mm->core_state) &&
Oleg Nesterovd5f70c02006-06-26 00:26:07 -07001812 unlikely(current->mm == current->parent->mm))
1813 return 0;
1814
1815 return 1;
1816}
1817
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818/*
Randy Dunlap5aba0852011-04-04 14:59:31 -07001819 * Return non-zero if there is a SIGKILL that should be waking us up.
Roland McGrath1a669c22008-02-06 01:37:37 -08001820 * Called with the siglock held.
1821 */
1822static int sigkill_pending(struct task_struct *tsk)
1823{
Oleg Nesterov3d749b92008-07-25 01:47:37 -07001824 return sigismember(&tsk->pending.signal, SIGKILL) ||
1825 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
Roland McGrath1a669c22008-02-06 01:37:37 -08001826}
1827
1828/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 * This must be called with current->sighand->siglock held.
1830 *
1831 * This should be the path for all ptrace stops.
1832 * We always set current->last_siginfo while stopped here.
1833 * That makes it a way to test a stopped process for
1834 * being ptrace-stopped vs being job-control-stopped.
1835 *
Oleg Nesterov20686a32008-02-08 04:19:03 -08001836 * If we actually decide not to stop at all because the tracer
1837 * is gone, we keep current->exit_code unless clear_code.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 */
Tejun Heofe1bc6a2011-03-23 10:37:00 +01001839static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
Namhyung Kimb8401152010-10-27 15:34:07 -07001840 __releases(&current->sighand->siglock)
1841 __acquires(&current->sighand->siglock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842{
Tejun Heoceb6bd62011-03-23 10:37:01 +01001843 bool gstop_done = false;
1844
Roland McGrath1a669c22008-02-06 01:37:37 -08001845 if (arch_ptrace_stop_needed(exit_code, info)) {
1846 /*
1847 * The arch code has something special to do before a
1848 * ptrace stop. This is allowed to block, e.g. for faults
1849 * on user stack pages. We can't keep the siglock while
1850 * calling arch_ptrace_stop, so we must release it now.
1851 * To preserve proper semantics, we must do this before
1852 * any signal bookkeeping like checking group_stop_count.
1853 * Meanwhile, a SIGKILL could come in before we retake the
1854 * siglock. That must prevent us from sleeping in TASK_TRACED.
1855 * So after regaining the lock, we must check for SIGKILL.
1856 */
1857 spin_unlock_irq(&current->sighand->siglock);
1858 arch_ptrace_stop(exit_code, info);
1859 spin_lock_irq(&current->sighand->siglock);
Oleg Nesterov3d749b92008-07-25 01:47:37 -07001860 if (sigkill_pending(current))
1861 return;
Roland McGrath1a669c22008-02-06 01:37:37 -08001862 }
1863
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 /*
Tejun Heo81be24b2011-06-02 11:13:59 +02001865 * We're committing to trapping. TRACED should be visible before
1866 * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
1867 * Also, transition to TRACED and updates to ->jobctl should be
1868 * atomic with respect to siglock and should be done after the arch
1869 * hook as siglock is released and regrabbed across it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 */
Tejun Heo81be24b2011-06-02 11:13:59 +02001871 set_current_state(TASK_TRACED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872
1873 current->last_siginfo = info;
1874 current->exit_code = exit_code;
1875
Tejun Heod79fdd62011-03-23 10:37:00 +01001876 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 * If @why is CLD_STOPPED, we're trapping to participate in a group
1878 * stop. Do the bookkeeping. Note that if SIGCONT was delievered
Tejun Heo73ddff22011-06-14 11:20:14 +02001879 * across siglock relocks since INTERRUPT was scheduled, PENDING
1880 * could be clear now. We act as if SIGCONT is received after
1881 * TASK_TRACED is entered - ignore it.
Tejun Heod79fdd62011-03-23 10:37:00 +01001882 */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001883 if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 gstop_done = task_participate_group_stop(current);
Tejun Heod79fdd62011-03-23 10:37:00 +01001885
Tejun Heofb1d9102011-06-14 11:20:17 +02001886 /* any trap clears pending STOP trap, STOP trap clears NOTIFY */
Tejun Heo73ddff22011-06-14 11:20:14 +02001887 task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
Tejun Heofb1d9102011-06-14 11:20:17 +02001888 if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
1889 task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
Tejun Heo73ddff22011-06-14 11:20:14 +02001890
Tejun Heo81be24b2011-06-02 11:13:59 +02001891 /* entering a trap, clear TRAPPING */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001892 task_clear_jobctl_trapping(current);
Tejun Heod79fdd62011-03-23 10:37:00 +01001893
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 spin_unlock_irq(&current->sighand->siglock);
1895 read_lock(&tasklist_lock);
Oleg Nesterov3d749b92008-07-25 01:47:37 -07001896 if (may_ptrace_stop()) {
Tejun Heoceb6bd62011-03-23 10:37:01 +01001897 /*
1898 * Notify parents of the stop.
1899 *
1900 * While ptraced, there are two parents - the ptracer and
1901 * the real_parent of the group_leader. The ptracer should
1902 * know about every stop while the real parent is only
1903 * interested in the completion of group stop. The states
1904 * for the two don't interact with each other. Notify
1905 * separately unless they're gonna be duplicates.
1906 */
1907 do_notify_parent_cldstop(current, true, why);
Oleg Nesterovbb3696d2011-06-24 17:34:23 +02001908 if (gstop_done && ptrace_reparented(current))
Tejun Heoceb6bd62011-03-23 10:37:01 +01001909 do_notify_parent_cldstop(current, false, why);
1910
Miklos Szeredi53da1d92009-03-23 16:07:24 +01001911 /*
1912 * Don't want to allow preemption here, because
1913 * sys_ptrace() needs this task to be inactive.
1914 *
1915 * XXX: implement read_unlock_no_resched().
1916 */
1917 preempt_disable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 read_unlock(&tasklist_lock);
Miklos Szeredi53da1d92009-03-23 16:07:24 +01001919 preempt_enable_no_resched();
Oleg Nesterov5d8f72b2012-10-26 19:46:06 +02001920 freezable_schedule();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 } else {
1922 /*
1923 * By the time we got the lock, our tracer went away.
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001924 * Don't drop the lock yet, another tracer may come.
Tejun Heoceb6bd62011-03-23 10:37:01 +01001925 *
1926 * If @gstop_done, the ptracer went away between group stop
1927 * completion and here. During detach, it would have set
Tejun Heoa8f072c2011-06-02 11:13:59 +02001928 * JOBCTL_STOP_PENDING on us and we'll re-enter
1929 * TASK_STOPPED in do_signal_stop() on return, so notifying
1930 * the real parent of the group stop completion is enough.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 */
Tejun Heoceb6bd62011-03-23 10:37:01 +01001932 if (gstop_done)
1933 do_notify_parent_cldstop(current, false, why);
1934
Oleg Nesterov9899d112013-01-21 20:48:00 +01001935 /* tasklist protects us from ptrace_freeze_traced() */
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001936 __set_current_state(TASK_RUNNING);
Oleg Nesterov20686a32008-02-08 04:19:03 -08001937 if (clear_code)
1938 current->exit_code = 0;
Oleg Nesterov6405f7f2008-02-08 04:19:00 -08001939 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 }
1941
1942 /*
1943 * We are back. Now reacquire the siglock before touching
1944 * last_siginfo, so that we are sure to have synchronized with
1945 * any signal-sending on another CPU that wants to examine it.
1946 */
1947 spin_lock_irq(&current->sighand->siglock);
1948 current->last_siginfo = NULL;
1949
Tejun Heo544b2c92011-06-14 11:20:18 +02001950 /* LISTENING can be set only during STOP traps, clear it */
1951 current->jobctl &= ~JOBCTL_LISTENING;
1952
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 /*
1954 * Queued signals ignored us while we were stopped for tracing.
1955 * So check for any that we should take before resuming user mode.
Roland McGrathb74d0de2007-06-06 03:59:00 -07001956 * This sets TIF_SIGPENDING, but never clears it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 */
Roland McGrathb74d0de2007-06-06 03:59:00 -07001958 recalc_sigpending_tsk(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959}
1960
Tejun Heo3544d722011-06-14 11:20:15 +02001961static void ptrace_do_notify(int signr, int exit_code, int why)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962{
1963 siginfo_t info;
1964
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 memset(&info, 0, sizeof info);
Tejun Heo3544d722011-06-14 11:20:15 +02001966 info.si_signo = signr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 info.si_code = exit_code;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001968 info.si_pid = task_pid_vnr(current);
Eric W. Biederman078de5f2012-02-08 07:00:08 -08001969 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970
1971 /* Let the debugger run. */
Tejun Heo3544d722011-06-14 11:20:15 +02001972 ptrace_stop(exit_code, why, 1, &info);
1973}
1974
1975void ptrace_notify(int exit_code)
1976{
1977 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
Oleg Nesterovf784e8a2012-08-26 21:12:17 +02001978 if (unlikely(current->task_works))
1979 task_work_run();
Tejun Heo3544d722011-06-14 11:20:15 +02001980
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 spin_lock_irq(&current->sighand->siglock);
Tejun Heo3544d722011-06-14 11:20:15 +02001982 ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 spin_unlock_irq(&current->sighand->siglock);
1984}
1985
Tejun Heo73ddff22011-06-14 11:20:14 +02001986/**
1987 * do_signal_stop - handle group stop for SIGSTOP and other stop signals
1988 * @signr: signr causing group stop if initiating
1989 *
1990 * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
1991 * and participate in it. If already set, participate in the existing
1992 * group stop. If participated in a group stop (and thus slept), %true is
1993 * returned with siglock released.
1994 *
1995 * If ptraced, this function doesn't handle stop itself. Instead,
1996 * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
1997 * untouched. The caller must ensure that INTERRUPT trap handling takes
1998 * places afterwards.
1999 *
2000 * CONTEXT:
2001 * Must be called with @current->sighand->siglock held, which is released
2002 * on %true return.
2003 *
2004 * RETURNS:
2005 * %false if group stop is already cancelled or ptrace trap is scheduled.
2006 * %true if participated in group stop.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 */
Tejun Heo73ddff22011-06-14 11:20:14 +02002008static bool do_signal_stop(int signr)
2009 __releases(&current->sighand->siglock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010{
2011 struct signal_struct *sig = current->signal;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012
Tejun Heoa8f072c2011-06-02 11:13:59 +02002013 if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
2014 unsigned int gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
Oleg Nesterovf558b7e2008-02-04 22:27:24 -08002015 struct task_struct *t;
2016
Tejun Heoa8f072c2011-06-02 11:13:59 +02002017 /* signr will be recorded in task->jobctl for retries */
2018 WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
Tejun Heod79fdd62011-03-23 10:37:00 +01002019
Tejun Heoa8f072c2011-06-02 11:13:59 +02002020 if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
Oleg Nesterov573cf9a2008-04-30 00:52:36 -07002021 unlikely(signal_group_exit(sig)))
Tejun Heo73ddff22011-06-14 11:20:14 +02002022 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023 /*
Tejun Heo408a37d2011-03-23 10:37:01 +01002024 * There is no group stop already in progress. We must
2025 * initiate one now.
2026 *
2027 * While ptraced, a task may be resumed while group stop is
2028 * still in effect and then receive a stop signal and
2029 * initiate another group stop. This deviates from the
2030 * usual behavior as two consecutive stop signals can't
Oleg Nesterov780006eac2011-04-01 20:12:16 +02002031 * cause two group stops when !ptraced. That is why we
2032 * also check !task_is_stopped(t) below.
Tejun Heo408a37d2011-03-23 10:37:01 +01002033 *
2034 * The condition can be distinguished by testing whether
2035 * SIGNAL_STOP_STOPPED is already set. Don't generate
2036 * group_exit_code in such case.
2037 *
2038 * This is not necessary for SIGNAL_STOP_CONTINUED because
2039 * an intervening stop signal is required to cause two
2040 * continued events regardless of ptrace.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 */
Tejun Heo408a37d2011-03-23 10:37:01 +01002042 if (!(sig->flags & SIGNAL_STOP_STOPPED))
2043 sig->group_exit_code = signr;
Oleg Nesterova122b342006-03-28 16:11:22 -08002044
Tejun Heo7dd3db52011-06-02 11:14:00 +02002045 sig->group_stop_count = 0;
2046
2047 if (task_set_jobctl_pending(current, signr | gstop))
2048 sig->group_stop_count++;
2049
Tejun Heod79fdd62011-03-23 10:37:00 +01002050 for (t = next_thread(current); t != current;
2051 t = next_thread(t)) {
Oleg Nesterova122b342006-03-28 16:11:22 -08002052 /*
2053 * Setting state to TASK_STOPPED for a group
2054 * stop is always done with the siglock held,
2055 * so this check has no races.
2056 */
Tejun Heo7dd3db52011-06-02 11:14:00 +02002057 if (!task_is_stopped(t) &&
2058 task_set_jobctl_pending(t, signr | gstop)) {
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002059 sig->group_stop_count++;
Tejun Heofb1d9102011-06-14 11:20:17 +02002060 if (likely(!(t->ptrace & PT_SEIZED)))
2061 signal_wake_up(t, 0);
2062 else
2063 ptrace_trap_notify(t);
Oleg Nesterova122b342006-03-28 16:11:22 -08002064 }
Tejun Heod79fdd62011-03-23 10:37:00 +01002065 }
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002066 }
Tejun Heo73ddff22011-06-14 11:20:14 +02002067
Tejun Heod21142e2011-06-17 16:50:34 +02002068 if (likely(!current->ptrace)) {
Tejun Heo5224fa32011-03-23 10:37:00 +01002069 int notify = 0;
2070
2071 /*
2072 * If there are no other threads in the group, or if there
2073 * is a group stop in progress and we are the last to stop,
2074 * report to the parent.
2075 */
2076 if (task_participate_group_stop(current))
2077 notify = CLD_STOPPED;
2078
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002079 __set_current_state(TASK_STOPPED);
Tejun Heo5224fa32011-03-23 10:37:00 +01002080 spin_unlock_irq(&current->sighand->siglock);
2081
Tejun Heo62bcf9d2011-03-23 10:37:01 +01002082 /*
2083 * Notify the parent of the group stop completion. Because
2084 * we're not holding either the siglock or tasklist_lock
2085 * here, ptracer may attach inbetween; however, this is for
2086 * group stop and should always be delivered to the real
2087 * parent of the group leader. The new ptracer will get
2088 * its notification when this task transitions into
2089 * TASK_TRACED.
2090 */
Tejun Heo5224fa32011-03-23 10:37:00 +01002091 if (notify) {
2092 read_lock(&tasklist_lock);
Tejun Heo62bcf9d2011-03-23 10:37:01 +01002093 do_notify_parent_cldstop(current, false, notify);
Tejun Heo5224fa32011-03-23 10:37:00 +01002094 read_unlock(&tasklist_lock);
2095 }
2096
2097 /* Now we don't run again until woken by SIGCONT or SIGKILL */
Oleg Nesterov5d8f72b2012-10-26 19:46:06 +02002098 freezable_schedule();
Tejun Heo73ddff22011-06-14 11:20:14 +02002099 return true;
Tejun Heod79fdd62011-03-23 10:37:00 +01002100 } else {
Tejun Heo73ddff22011-06-14 11:20:14 +02002101 /*
2102 * While ptraced, group stop is handled by STOP trap.
2103 * Schedule it and let the caller deal with it.
2104 */
2105 task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
2106 return false;
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002107 }
Tejun Heo73ddff22011-06-14 11:20:14 +02002108}
Tejun Heod79fdd62011-03-23 10:37:00 +01002109
Tejun Heo73ddff22011-06-14 11:20:14 +02002110/**
2111 * do_jobctl_trap - take care of ptrace jobctl traps
2112 *
Tejun Heo3544d722011-06-14 11:20:15 +02002113 * When PT_SEIZED, it's used for both group stop and explicit
2114 * SEIZE/INTERRUPT traps. Both generate PTRACE_EVENT_STOP trap with
2115 * accompanying siginfo. If stopped, lower eight bits of exit_code contain
2116 * the stop signal; otherwise, %SIGTRAP.
2117 *
2118 * When !PT_SEIZED, it's used only for group stop trap with stop signal
2119 * number as exit_code and no siginfo.
Tejun Heo73ddff22011-06-14 11:20:14 +02002120 *
2121 * CONTEXT:
2122 * Must be called with @current->sighand->siglock held, which may be
2123 * released and re-acquired before returning with intervening sleep.
2124 */
2125static void do_jobctl_trap(void)
2126{
Tejun Heo3544d722011-06-14 11:20:15 +02002127 struct signal_struct *signal = current->signal;
Tejun Heo73ddff22011-06-14 11:20:14 +02002128 int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
Tejun Heod79fdd62011-03-23 10:37:00 +01002129
Tejun Heo3544d722011-06-14 11:20:15 +02002130 if (current->ptrace & PT_SEIZED) {
2131 if (!signal->group_stop_count &&
2132 !(signal->flags & SIGNAL_STOP_STOPPED))
2133 signr = SIGTRAP;
2134 WARN_ON_ONCE(!signr);
2135 ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
2136 CLD_STOPPED);
2137 } else {
2138 WARN_ON_ONCE(!signr);
2139 ptrace_stop(signr, CLD_STOPPED, 0, NULL);
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002140 current->exit_code = 0;
2141 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142}
2143
Al Viro94eb22d2012-11-05 13:08:06 -05002144static int ptrace_signal(int signr, siginfo_t *info)
Roland McGrath18c98b62008-04-17 18:44:38 -07002145{
Al Virob7f95912012-11-05 13:06:22 -05002146 ptrace_signal_deliver();
Oleg Nesterov8a352412011-07-21 17:06:53 +02002147 /*
2148 * We do not check sig_kernel_stop(signr) but set this marker
2149 * unconditionally because we do not know whether debugger will
2150 * change signr. This flag has no meaning unless we are going
2151 * to stop after return from ptrace_stop(). In this case it will
2152 * be checked in do_signal_stop(), we should only stop if it was
2153 * not cleared by SIGCONT while we were sleeping. See also the
2154 * comment in dequeue_signal().
2155 */
2156 current->jobctl |= JOBCTL_STOP_DEQUEUED;
Tejun Heofe1bc6a2011-03-23 10:37:00 +01002157 ptrace_stop(signr, CLD_TRAPPED, 0, info);
Roland McGrath18c98b62008-04-17 18:44:38 -07002158
2159 /* We're back. Did the debugger cancel the sig? */
2160 signr = current->exit_code;
2161 if (signr == 0)
2162 return signr;
2163
2164 current->exit_code = 0;
2165
Randy Dunlap5aba0852011-04-04 14:59:31 -07002166 /*
2167 * Update the siginfo structure if the signal has
2168 * changed. If the debugger wanted something
2169 * specific in the siginfo structure then it should
2170 * have updated *info via PTRACE_SETSIGINFO.
2171 */
Roland McGrath18c98b62008-04-17 18:44:38 -07002172 if (signr != info->si_signo) {
2173 info->si_signo = signr;
2174 info->si_errno = 0;
2175 info->si_code = SI_USER;
Serge E. Hallyn6b550f92012-01-10 15:11:37 -08002176 rcu_read_lock();
Roland McGrath18c98b62008-04-17 18:44:38 -07002177 info->si_pid = task_pid_vnr(current->parent);
Eric W. Biederman54ba47e2012-03-13 16:04:35 -07002178 info->si_uid = from_kuid_munged(current_user_ns(),
2179 task_uid(current->parent));
Serge E. Hallyn6b550f92012-01-10 15:11:37 -08002180 rcu_read_unlock();
Roland McGrath18c98b62008-04-17 18:44:38 -07002181 }
2182
2183 /* If the (new) signal is now blocked, requeue it. */
2184 if (sigismember(&current->blocked, signr)) {
2185 specific_send_sig_info(signr, info, current);
2186 signr = 0;
2187 }
2188
2189 return signr;
2190}
2191
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
2193 struct pt_regs *regs, void *cookie)
2194{
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002195 struct sighand_struct *sighand = current->sighand;
2196 struct signal_struct *signal = current->signal;
2197 int signr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198
Oleg Nesterovf784e8a2012-08-26 21:12:17 +02002199 if (unlikely(current->task_works))
2200 task_work_run();
Al Viro72667022012-07-15 14:10:52 +04002201
Srikar Dronamraju0326f5a2012-03-13 23:30:11 +05302202 if (unlikely(uprobe_deny_signal()))
2203 return 0;
2204
Roland McGrath13b1c3d2008-03-03 20:22:05 -08002205 /*
Oleg Nesterov5d8f72b2012-10-26 19:46:06 +02002206 * Do this once, we can't return to user-mode if freezing() == T.
2207 * do_signal_stop() and ptrace_stop() do freezable_schedule() and
2208 * thus do not need another check after return.
Roland McGrath13b1c3d2008-03-03 20:22:05 -08002209 */
Rafael J. Wysockifc558a72006-03-23 03:00:05 -08002210 try_to_freeze();
2211
Oleg Nesterov5d8f72b2012-10-26 19:46:06 +02002212relock:
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002213 spin_lock_irq(&sighand->siglock);
Oleg Nesterov021e1ae2008-04-30 00:53:00 -07002214 /*
2215 * Every stopped thread goes here after wakeup. Check to see if
2216 * we should notify the parent, prepare_signal(SIGCONT) encodes
2217 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
2218 */
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002219 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
Tejun Heoc672af32011-03-23 10:36:59 +01002220 int why;
2221
2222 if (signal->flags & SIGNAL_CLD_CONTINUED)
2223 why = CLD_CONTINUED;
2224 else
2225 why = CLD_STOPPED;
2226
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002227 signal->flags &= ~SIGNAL_CLD_MASK;
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002228
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002229 spin_unlock_irq(&sighand->siglock);
Oleg Nesterove4420552008-04-30 00:52:44 -07002230
Tejun Heoceb6bd62011-03-23 10:37:01 +01002231 /*
2232 * Notify the parent that we're continuing. This event is
2233 * always per-process and doesn't make whole lot of sense
2234 * for ptracers, who shouldn't consume the state via
2235 * wait(2) either, but, for backward compatibility, notify
2236 * the ptracer of the group leader too unless it's gonna be
2237 * a duplicate.
2238 */
Tejun Heoedf2ed12011-03-23 10:37:00 +01002239 read_lock(&tasklist_lock);
Tejun Heoceb6bd62011-03-23 10:37:01 +01002240 do_notify_parent_cldstop(current, false, why);
2241
Oleg Nesterovbb3696d2011-06-24 17:34:23 +02002242 if (ptrace_reparented(current->group_leader))
2243 do_notify_parent_cldstop(current->group_leader,
2244 true, why);
Tejun Heoedf2ed12011-03-23 10:37:00 +01002245 read_unlock(&tasklist_lock);
Tejun Heoceb6bd62011-03-23 10:37:01 +01002246
Oleg Nesterove4420552008-04-30 00:52:44 -07002247 goto relock;
2248 }
2249
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 for (;;) {
2251 struct k_sigaction *ka;
Tejun Heodd1d6772011-06-02 11:14:00 +02002252
2253 if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
2254 do_signal_stop(0))
Roland McGrath7bcf6a22008-07-25 19:45:53 -07002255 goto relock;
Oleg Nesterov1be53962009-12-15 16:47:26 -08002256
Tejun Heo73ddff22011-06-14 11:20:14 +02002257 if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
2258 do_jobctl_trap();
2259 spin_unlock_irq(&sighand->siglock);
2260 goto relock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261 }
2262
Tejun Heodd1d6772011-06-02 11:14:00 +02002263 signr = dequeue_signal(current, &current->blocked, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264
Tejun Heodd1d6772011-06-02 11:14:00 +02002265 if (!signr)
2266 break; /* will return 0 */
2267
Oleg Nesterov8a352412011-07-21 17:06:53 +02002268 if (unlikely(current->ptrace) && signr != SIGKILL) {
Al Viro94eb22d2012-11-05 13:08:06 -05002269 signr = ptrace_signal(signr, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 if (!signr)
Tejun Heodd1d6772011-06-02 11:14:00 +02002271 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 }
2273
Tejun Heodd1d6772011-06-02 11:14:00 +02002274 ka = &sighand->action[signr-1];
2275
Masami Hiramatsuf9d42572009-11-24 16:56:51 -05002276 /* Trace actually delivered signals. */
2277 trace_signal_deliver(signr, info, ka);
2278
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
2280 continue;
2281 if (ka->sa.sa_handler != SIG_DFL) {
2282 /* Run the handler. */
2283 *return_ka = *ka;
2284
2285 if (ka->sa.sa_flags & SA_ONESHOT)
2286 ka->sa.sa_handler = SIG_DFL;
2287
2288 break; /* will return non-zero "signr" value */
2289 }
2290
2291 /*
2292 * Now we are doing the default action for this signal.
2293 */
2294 if (sig_kernel_ignore(signr)) /* Default is nothing. */
2295 continue;
2296
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -08002297 /*
Sukadev Bhattiprolu0fbc26a2007-10-18 23:40:13 -07002298 * Global init gets no signals it doesn't want.
Sukadev Bhattiprolub3bfa0c2009-04-02 16:58:08 -07002299 * Container-init gets no signals it doesn't want from same
2300 * container.
2301 *
2302 * Note that if global/container-init sees a sig_kernel_only()
2303 * signal here, the signal must have been generated internally
2304 * or must have come from an ancestor namespace. In either
2305 * case, the signal cannot be dropped.
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -08002306 */
Oleg Nesterovfae5fa42008-04-30 00:53:03 -07002307 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
Sukadev Bhattiprolub3bfa0c2009-04-02 16:58:08 -07002308 !sig_kernel_only(signr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 continue;
2310
2311 if (sig_kernel_stop(signr)) {
2312 /*
2313 * The default action is to stop all threads in
2314 * the thread group. The job control signals
2315 * do nothing in an orphaned pgrp, but SIGSTOP
2316 * always works. Note that siglock needs to be
2317 * dropped during the call to is_orphaned_pgrp()
2318 * because of lock ordering with tasklist_lock.
2319 * This allows an intervening SIGCONT to be posted.
2320 * We need to check for that and bail out if necessary.
2321 */
2322 if (signr != SIGSTOP) {
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002323 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324
2325 /* signals can be posted during this window */
2326
Eric W. Biederman3e7cd6c2007-02-12 00:52:58 -08002327 if (is_current_pgrp_orphaned())
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328 goto relock;
2329
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002330 spin_lock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 }
2332
Roland McGrath7bcf6a22008-07-25 19:45:53 -07002333 if (likely(do_signal_stop(info->si_signo))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 /* It released the siglock. */
2335 goto relock;
2336 }
2337
2338 /*
2339 * We didn't actually stop, due to a race
2340 * with SIGCONT or something like that.
2341 */
2342 continue;
2343 }
2344
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002345 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346
2347 /*
2348 * Anything else is fatal, maybe with a core dump.
2349 */
2350 current->flags |= PF_SIGNALED;
Oleg Nesterov2dce81b2008-04-30 00:52:58 -07002351
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352 if (sig_kernel_coredump(signr)) {
Oleg Nesterov2dce81b2008-04-30 00:52:58 -07002353 if (print_fatal_signals)
Al Viro4aaefee2012-11-05 13:09:56 -05002354 print_fatal_signal(info->si_signo);
Jesper Derehag2b5faa42013-03-19 20:50:05 +00002355 proc_coredump_connector(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356 /*
2357 * If it was able to dump core, this kills all
2358 * other threads in the group and synchronizes with
2359 * their demise. If we lost the race with another
2360 * thread getting here, it set group_exit_code
2361 * first and our do_group_exit call below will use
2362 * that value and ignore the one we pass it.
2363 */
Al Viro541880d2012-11-05 13:11:26 -05002364 do_coredump(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365 }
2366
2367 /*
2368 * Death signals, no core dump.
2369 */
Roland McGrath7bcf6a22008-07-25 19:45:53 -07002370 do_group_exit(info->si_signo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 /* NOTREACHED */
2372 }
Oleg Nesterovf6b76d42008-04-30 00:52:47 -07002373 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 return signr;
2375}
2376
Matt Fleming5e6292c2012-01-10 15:11:17 -08002377/**
Al Viroefee9842012-04-28 02:04:15 -04002378 * signal_delivered -
2379 * @sig: number of signal being delivered
2380 * @info: siginfo_t of signal being delivered
2381 * @ka: sigaction setting that chose the handler
2382 * @regs: user register state
2383 * @stepping: nonzero if debugger single-step or block-step in use
Matt Fleming5e6292c2012-01-10 15:11:17 -08002384 *
2385 * This function should be called when a signal has succesfully been
Al Viroefee9842012-04-28 02:04:15 -04002386 * delivered. It updates the blocked signals accordingly (@ka->sa.sa_mask
2387 * is always blocked, and the signal itself is blocked unless %SA_NODEFER
2388 * is set in @ka->sa.sa_flags. Tracing is notified.
Matt Fleming5e6292c2012-01-10 15:11:17 -08002389 */
Al Viroefee9842012-04-28 02:04:15 -04002390void signal_delivered(int sig, siginfo_t *info, struct k_sigaction *ka,
2391 struct pt_regs *regs, int stepping)
Matt Fleming5e6292c2012-01-10 15:11:17 -08002392{
2393 sigset_t blocked;
2394
Al Viroa610d6e2012-05-21 23:42:15 -04002395 /* A signal was successfully delivered, and the
2396 saved sigmask was stored on the signal frame,
2397 and will be restored by sigreturn. So we can
2398 simply clear the restore sigmask flag. */
2399 clear_restore_sigmask();
2400
Matt Fleming5e6292c2012-01-10 15:11:17 -08002401 sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask);
2402 if (!(ka->sa.sa_flags & SA_NODEFER))
Al Viroefee9842012-04-28 02:04:15 -04002403 sigaddset(&blocked, sig);
Matt Fleming5e6292c2012-01-10 15:11:17 -08002404 set_current_blocked(&blocked);
Al Viroefee9842012-04-28 02:04:15 -04002405 tracehook_signal_handler(sig, info, ka, regs, stepping);
Matt Fleming5e6292c2012-01-10 15:11:17 -08002406}
2407
Al Viro2ce5da12012-11-07 15:11:25 -05002408void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
2409{
2410 if (failed)
2411 force_sigsegv(ksig->sig, current);
2412 else
2413 signal_delivered(ksig->sig, &ksig->info, &ksig->ka,
2414 signal_pt_regs(), stepping);
2415}
2416
Oleg Nesterov0edceb7bc2011-04-27 19:17:37 +02002417/*
2418 * It could be that complete_signal() picked us to notify about the
Oleg Nesterovfec99932011-04-27 19:50:21 +02002419 * group-wide signal. Other threads should be notified now to take
2420 * the shared signals in @which since we will not.
Oleg Nesterov0edceb7bc2011-04-27 19:17:37 +02002421 */
Oleg Nesterovf646e222011-04-27 19:18:39 +02002422static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
Oleg Nesterov0edceb7bc2011-04-27 19:17:37 +02002423{
Oleg Nesterovf646e222011-04-27 19:18:39 +02002424 sigset_t retarget;
Oleg Nesterov0edceb7bc2011-04-27 19:17:37 +02002425 struct task_struct *t;
2426
Oleg Nesterovf646e222011-04-27 19:18:39 +02002427 sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
2428 if (sigisemptyset(&retarget))
2429 return;
2430
Oleg Nesterov0edceb7bc2011-04-27 19:17:37 +02002431 t = tsk;
2432 while_each_thread(tsk, t) {
Oleg Nesterovfec99932011-04-27 19:50:21 +02002433 if (t->flags & PF_EXITING)
2434 continue;
2435
2436 if (!has_pending_signals(&retarget, &t->blocked))
2437 continue;
2438 /* Remove the signals this thread can handle. */
2439 sigandsets(&retarget, &retarget, &t->blocked);
2440
2441 if (!signal_pending(t))
2442 signal_wake_up(t, 0);
2443
2444 if (sigisemptyset(&retarget))
2445 break;
Oleg Nesterov0edceb7bc2011-04-27 19:17:37 +02002446 }
2447}
2448
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002449void exit_signals(struct task_struct *tsk)
2450{
2451 int group_stop = 0;
Oleg Nesterovf646e222011-04-27 19:18:39 +02002452 sigset_t unblocked;
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002453
Tejun Heo77e4ef92011-12-12 18:12:21 -08002454 /*
2455 * @tsk is about to have PF_EXITING set - lock out users which
2456 * expect stable threadgroup.
2457 */
2458 threadgroup_change_begin(tsk);
2459
Oleg Nesterov5dee1702008-02-08 04:19:13 -08002460 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
2461 tsk->flags |= PF_EXITING;
Tejun Heo77e4ef92011-12-12 18:12:21 -08002462 threadgroup_change_end(tsk);
Oleg Nesterov5dee1702008-02-08 04:19:13 -08002463 return;
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002464 }
2465
Oleg Nesterov5dee1702008-02-08 04:19:13 -08002466 spin_lock_irq(&tsk->sighand->siglock);
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002467 /*
2468 * From now this task is not visible for group-wide signals,
2469 * see wants_signal(), do_signal_stop().
2470 */
2471 tsk->flags |= PF_EXITING;
Tejun Heo77e4ef92011-12-12 18:12:21 -08002472
2473 threadgroup_change_end(tsk);
2474
Oleg Nesterov5dee1702008-02-08 04:19:13 -08002475 if (!signal_pending(tsk))
2476 goto out;
2477
Oleg Nesterovf646e222011-04-27 19:18:39 +02002478 unblocked = tsk->blocked;
2479 signotset(&unblocked);
2480 retarget_shared_pending(tsk, &unblocked);
Oleg Nesterov5dee1702008-02-08 04:19:13 -08002481
Tejun Heoa8f072c2011-06-02 11:13:59 +02002482 if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
Tejun Heoe5c19022011-03-23 10:37:00 +01002483 task_participate_group_stop(tsk))
Tejun Heoedf2ed12011-03-23 10:37:00 +01002484 group_stop = CLD_STOPPED;
Oleg Nesterov5dee1702008-02-08 04:19:13 -08002485out:
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002486 spin_unlock_irq(&tsk->sighand->siglock);
2487
Tejun Heo62bcf9d2011-03-23 10:37:01 +01002488 /*
2489 * If group stop has completed, deliver the notification. This
2490 * should always go to the real parent of the group leader.
2491 */
Roland McGrathae6d2ed2009-09-23 15:56:53 -07002492 if (unlikely(group_stop)) {
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002493 read_lock(&tasklist_lock);
Tejun Heo62bcf9d2011-03-23 10:37:01 +01002494 do_notify_parent_cldstop(tsk, false, group_stop);
Oleg Nesterovd12619b2008-02-08 04:19:12 -08002495 read_unlock(&tasklist_lock);
2496 }
2497}
2498
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499EXPORT_SYMBOL(recalc_sigpending);
2500EXPORT_SYMBOL_GPL(dequeue_signal);
2501EXPORT_SYMBOL(flush_signals);
2502EXPORT_SYMBOL(force_sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503EXPORT_SYMBOL(send_sig);
2504EXPORT_SYMBOL(send_sig_info);
2505EXPORT_SYMBOL(sigprocmask);
2506EXPORT_SYMBOL(block_all_signals);
2507EXPORT_SYMBOL(unblock_all_signals);
2508
2509
2510/*
2511 * System call entry points.
2512 */
2513
Randy Dunlap41c57892011-04-04 15:00:26 -07002514/**
2515 * sys_restart_syscall - restart a system call
2516 */
Heiko Carstens754fe8d2009-01-14 14:14:09 +01002517SYSCALL_DEFINE0(restart_syscall)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002518{
2519 struct restart_block *restart = &current_thread_info()->restart_block;
2520 return restart->fn(restart);
2521}
2522
2523long do_no_restart_syscall(struct restart_block *param)
2524{
2525 return -EINTR;
2526}
2527
Oleg Nesterovb1828012011-04-27 21:56:14 +02002528static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
2529{
2530 if (signal_pending(tsk) && !thread_group_empty(tsk)) {
2531 sigset_t newblocked;
2532 /* A set of now blocked but previously unblocked signals. */
Oleg Nesterov702a5072011-04-27 22:01:27 +02002533 sigandnsets(&newblocked, newset, &current->blocked);
Oleg Nesterovb1828012011-04-27 21:56:14 +02002534 retarget_shared_pending(tsk, &newblocked);
2535 }
2536 tsk->blocked = *newset;
2537 recalc_sigpending();
2538}
2539
Oleg Nesterove6fa16a2011-04-27 20:59:41 +02002540/**
2541 * set_current_blocked - change current->blocked mask
2542 * @newset: new mask
2543 *
2544 * It is wrong to change ->blocked directly, this helper should be used
2545 * to ensure the process can't miss a shared signal we are going to block.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546 */
Al Viro77097ae2012-04-27 13:58:59 -04002547void set_current_blocked(sigset_t *newset)
2548{
Al Viro77097ae2012-04-27 13:58:59 -04002549 sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
Oleg Nesterov0c4a8422013-01-05 19:13:29 +01002550 __set_current_blocked(newset);
Al Viro77097ae2012-04-27 13:58:59 -04002551}
2552
2553void __set_current_blocked(const sigset_t *newset)
Oleg Nesterove6fa16a2011-04-27 20:59:41 +02002554{
2555 struct task_struct *tsk = current;
2556
2557 spin_lock_irq(&tsk->sighand->siglock);
Oleg Nesterovb1828012011-04-27 21:56:14 +02002558 __set_task_blocked(tsk, newset);
Oleg Nesterove6fa16a2011-04-27 20:59:41 +02002559 spin_unlock_irq(&tsk->sighand->siglock);
2560}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561
2562/*
2563 * This is also useful for kernel threads that want to temporarily
2564 * (or permanently) block certain signals.
2565 *
2566 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2567 * interface happily blocks "unblockable" signals like SIGKILL
2568 * and friends.
2569 */
2570int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2571{
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002572 struct task_struct *tsk = current;
2573 sigset_t newset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002575 /* Lockless, only current can change ->blocked, never from irq */
Oleg Nesterova26fd332006-03-23 03:00:49 -08002576 if (oldset)
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002577 *oldset = tsk->blocked;
Oleg Nesterova26fd332006-03-23 03:00:49 -08002578
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579 switch (how) {
2580 case SIG_BLOCK:
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002581 sigorsets(&newset, &tsk->blocked, set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582 break;
2583 case SIG_UNBLOCK:
Oleg Nesterov702a5072011-04-27 22:01:27 +02002584 sigandnsets(&newset, &tsk->blocked, set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002585 break;
2586 case SIG_SETMASK:
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002587 newset = *set;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 break;
2589 default:
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002590 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591 }
Oleg Nesterova26fd332006-03-23 03:00:49 -08002592
Al Viro77097ae2012-04-27 13:58:59 -04002593 __set_current_blocked(&newset);
Oleg Nesterov73ef4ae2011-04-27 19:54:20 +02002594 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002595}
2596
Randy Dunlap41c57892011-04-04 15:00:26 -07002597/**
2598 * sys_rt_sigprocmask - change the list of currently blocked signals
2599 * @how: whether to add, remove, or set signals
Randy Dunlapada9c932011-06-14 15:50:11 -07002600 * @nset: stores pending signals
Randy Dunlap41c57892011-04-04 15:00:26 -07002601 * @oset: previous value of signal mask if non-null
2602 * @sigsetsize: size of sigset_t type
2603 */
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002604SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
Heiko Carstens17da2bd2009-01-14 14:14:10 +01002605 sigset_t __user *, oset, size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002607 sigset_t old_set, new_set;
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002608 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002609
2610 /* XXX: Don't preclude handling different sized sigset_t's. */
2611 if (sigsetsize != sizeof(sigset_t))
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002612 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002613
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002614 old_set = current->blocked;
2615
2616 if (nset) {
2617 if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
2618 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2620
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002621 error = sigprocmask(how, &new_set, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622 if (error)
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002623 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624 }
Oleg Nesterovbb7efee2011-04-27 21:18:10 +02002625
2626 if (oset) {
2627 if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
2628 return -EFAULT;
2629 }
2630
2631 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632}
2633
Al Viro322a56c2012-12-25 13:32:58 -05002634#ifdef CONFIG_COMPAT
Al Viro322a56c2012-12-25 13:32:58 -05002635COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
2636 compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637{
Al Viro322a56c2012-12-25 13:32:58 -05002638#ifdef __BIG_ENDIAN
2639 sigset_t old_set = current->blocked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640
Al Viro322a56c2012-12-25 13:32:58 -05002641 /* XXX: Don't preclude handling different sized sigset_t's. */
2642 if (sigsetsize != sizeof(sigset_t))
2643 return -EINVAL;
2644
2645 if (nset) {
2646 compat_sigset_t new32;
2647 sigset_t new_set;
2648 int error;
2649 if (copy_from_user(&new32, nset, sizeof(compat_sigset_t)))
2650 return -EFAULT;
2651
2652 sigset_from_compat(&new_set, &new32);
2653 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2654
2655 error = sigprocmask(how, &new_set, NULL);
2656 if (error)
2657 return error;
2658 }
2659 if (oset) {
2660 compat_sigset_t old32;
2661 sigset_to_compat(&old32, &old_set);
Al Virodb61ec22013-03-02 20:39:15 -05002662 if (copy_to_user(oset, &old32, sizeof(compat_sigset_t)))
Al Viro322a56c2012-12-25 13:32:58 -05002663 return -EFAULT;
2664 }
2665 return 0;
2666#else
2667 return sys_rt_sigprocmask(how, (sigset_t __user *)nset,
2668 (sigset_t __user *)oset, sigsetsize);
2669#endif
2670}
2671#endif
Al Viro322a56c2012-12-25 13:32:58 -05002672
Al Virofe9c1db2012-12-25 14:31:38 -05002673static int do_sigpending(void *set, unsigned long sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675 if (sigsetsize > sizeof(sigset_t))
Al Virofe9c1db2012-12-25 14:31:38 -05002676 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002677
2678 spin_lock_irq(&current->sighand->siglock);
Al Virofe9c1db2012-12-25 14:31:38 -05002679 sigorsets(set, &current->pending.signal,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680 &current->signal->shared_pending.signal);
2681 spin_unlock_irq(&current->sighand->siglock);
2682
2683 /* Outside the lock because only this thread touches it. */
Al Virofe9c1db2012-12-25 14:31:38 -05002684 sigandsets(set, &current->blocked, set);
2685 return 0;
Randy Dunlap5aba0852011-04-04 14:59:31 -07002686}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687
Randy Dunlap41c57892011-04-04 15:00:26 -07002688/**
2689 * sys_rt_sigpending - examine a pending signal that has been raised
2690 * while blocked
Randy Dunlap20f22ab2013-03-04 14:32:59 -08002691 * @uset: stores pending signals
Randy Dunlap41c57892011-04-04 15:00:26 -07002692 * @sigsetsize: size of sigset_t type or larger
2693 */
Al Virofe9c1db2012-12-25 14:31:38 -05002694SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002695{
Al Virofe9c1db2012-12-25 14:31:38 -05002696 sigset_t set;
2697 int err = do_sigpending(&set, sigsetsize);
2698 if (!err && copy_to_user(uset, &set, sigsetsize))
2699 err = -EFAULT;
2700 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701}
2702
Al Virofe9c1db2012-12-25 14:31:38 -05002703#ifdef CONFIG_COMPAT
Al Virofe9c1db2012-12-25 14:31:38 -05002704COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
2705 compat_size_t, sigsetsize)
2706{
2707#ifdef __BIG_ENDIAN
2708 sigset_t set;
2709 int err = do_sigpending(&set, sigsetsize);
2710 if (!err) {
2711 compat_sigset_t set32;
2712 sigset_to_compat(&set32, &set);
2713 /* we can get here only if sigsetsize <= sizeof(set) */
2714 if (copy_to_user(uset, &set32, sigsetsize))
2715 err = -EFAULT;
2716 }
2717 return err;
2718#else
2719 return sys_rt_sigpending((sigset_t __user *)uset, sigsetsize);
2720#endif
2721}
2722#endif
Al Virofe9c1db2012-12-25 14:31:38 -05002723
Linus Torvalds1da177e2005-04-16 15:20:36 -07002724#ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2725
2726int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2727{
2728 int err;
2729
2730 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2731 return -EFAULT;
2732 if (from->si_code < 0)
2733 return __copy_to_user(to, from, sizeof(siginfo_t))
2734 ? -EFAULT : 0;
2735 /*
2736 * If you change siginfo_t structure, please be sure
2737 * this code is fixed accordingly.
Davide Libenzifba2afa2007-05-10 22:23:13 -07002738 * Please remember to update the signalfd_copyinfo() function
2739 * inside fs/signalfd.c too, in case siginfo_t changes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002740 * It should never copy any pad contained in the structure
2741 * to avoid security leaks, but must copy the generic
2742 * 3 ints plus the relevant union member.
2743 */
2744 err = __put_user(from->si_signo, &to->si_signo);
2745 err |= __put_user(from->si_errno, &to->si_errno);
2746 err |= __put_user((short)from->si_code, &to->si_code);
2747 switch (from->si_code & __SI_MASK) {
2748 case __SI_KILL:
2749 err |= __put_user(from->si_pid, &to->si_pid);
2750 err |= __put_user(from->si_uid, &to->si_uid);
2751 break;
2752 case __SI_TIMER:
2753 err |= __put_user(from->si_tid, &to->si_tid);
2754 err |= __put_user(from->si_overrun, &to->si_overrun);
2755 err |= __put_user(from->si_ptr, &to->si_ptr);
2756 break;
2757 case __SI_POLL:
2758 err |= __put_user(from->si_band, &to->si_band);
2759 err |= __put_user(from->si_fd, &to->si_fd);
2760 break;
2761 case __SI_FAULT:
2762 err |= __put_user(from->si_addr, &to->si_addr);
2763#ifdef __ARCH_SI_TRAPNO
2764 err |= __put_user(from->si_trapno, &to->si_trapno);
2765#endif
Andi Kleena337fda2010-09-27 20:32:19 +02002766#ifdef BUS_MCEERR_AO
Randy Dunlap5aba0852011-04-04 14:59:31 -07002767 /*
Andi Kleena337fda2010-09-27 20:32:19 +02002768 * Other callers might not initialize the si_lsb field,
Randy Dunlap5aba0852011-04-04 14:59:31 -07002769 * so check explicitly for the right codes here.
Andi Kleena337fda2010-09-27 20:32:19 +02002770 */
2771 if (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO)
2772 err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
2773#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774 break;
2775 case __SI_CHLD:
2776 err |= __put_user(from->si_pid, &to->si_pid);
2777 err |= __put_user(from->si_uid, &to->si_uid);
2778 err |= __put_user(from->si_status, &to->si_status);
2779 err |= __put_user(from->si_utime, &to->si_utime);
2780 err |= __put_user(from->si_stime, &to->si_stime);
2781 break;
2782 case __SI_RT: /* This is not generated by the kernel as of now. */
2783 case __SI_MESGQ: /* But this is */
2784 err |= __put_user(from->si_pid, &to->si_pid);
2785 err |= __put_user(from->si_uid, &to->si_uid);
2786 err |= __put_user(from->si_ptr, &to->si_ptr);
2787 break;
Will Drewrya0727e82012-04-12 16:48:00 -05002788#ifdef __ARCH_SIGSYS
2789 case __SI_SYS:
2790 err |= __put_user(from->si_call_addr, &to->si_call_addr);
2791 err |= __put_user(from->si_syscall, &to->si_syscall);
2792 err |= __put_user(from->si_arch, &to->si_arch);
2793 break;
2794#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795 default: /* this is just in case for now ... */
2796 err |= __put_user(from->si_pid, &to->si_pid);
2797 err |= __put_user(from->si_uid, &to->si_uid);
2798 break;
2799 }
2800 return err;
2801}
2802
2803#endif
2804
Randy Dunlap41c57892011-04-04 15:00:26 -07002805/**
Oleg Nesterov943df142011-04-27 21:44:14 +02002806 * do_sigtimedwait - wait for queued signals specified in @which
2807 * @which: queued signals to wait for
2808 * @info: if non-null, the signal's siginfo is returned here
2809 * @ts: upper bound on process time suspension
2810 */
2811int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
2812 const struct timespec *ts)
2813{
2814 struct task_struct *tsk = current;
2815 long timeout = MAX_SCHEDULE_TIMEOUT;
2816 sigset_t mask = *which;
2817 int sig;
2818
2819 if (ts) {
2820 if (!timespec_valid(ts))
2821 return -EINVAL;
2822 timeout = timespec_to_jiffies(ts);
2823 /*
2824 * We can be close to the next tick, add another one
2825 * to ensure we will wait at least the time asked for.
2826 */
2827 if (ts->tv_sec || ts->tv_nsec)
2828 timeout++;
2829 }
2830
2831 /*
2832 * Invert the set of allowed signals to get those we want to block.
2833 */
2834 sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
2835 signotset(&mask);
2836
2837 spin_lock_irq(&tsk->sighand->siglock);
2838 sig = dequeue_signal(tsk, &mask, info);
2839 if (!sig && timeout) {
2840 /*
2841 * None ready, temporarily unblock those we're interested
2842 * while we are sleeping in so that we'll be awakened when
Oleg Nesterovb1828012011-04-27 21:56:14 +02002843 * they arrive. Unblocking is always fine, we can avoid
2844 * set_current_blocked().
Oleg Nesterov943df142011-04-27 21:44:14 +02002845 */
2846 tsk->real_blocked = tsk->blocked;
2847 sigandsets(&tsk->blocked, &tsk->blocked, &mask);
2848 recalc_sigpending();
2849 spin_unlock_irq(&tsk->sighand->siglock);
2850
2851 timeout = schedule_timeout_interruptible(timeout);
2852
2853 spin_lock_irq(&tsk->sighand->siglock);
Oleg Nesterovb1828012011-04-27 21:56:14 +02002854 __set_task_blocked(tsk, &tsk->real_blocked);
Oleg Nesterov943df142011-04-27 21:44:14 +02002855 siginitset(&tsk->real_blocked, 0);
Oleg Nesterovb1828012011-04-27 21:56:14 +02002856 sig = dequeue_signal(tsk, &mask, info);
Oleg Nesterov943df142011-04-27 21:44:14 +02002857 }
2858 spin_unlock_irq(&tsk->sighand->siglock);
2859
2860 if (sig)
2861 return sig;
2862 return timeout ? -EINTR : -EAGAIN;
2863}
2864
2865/**
Randy Dunlap41c57892011-04-04 15:00:26 -07002866 * sys_rt_sigtimedwait - synchronously wait for queued signals specified
2867 * in @uthese
2868 * @uthese: queued signals to wait for
2869 * @uinfo: if non-null, the signal's siginfo is returned here
2870 * @uts: upper bound on process time suspension
2871 * @sigsetsize: size of sigset_t type
2872 */
Heiko Carstens17da2bd2009-01-14 14:14:10 +01002873SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
2874 siginfo_t __user *, uinfo, const struct timespec __user *, uts,
2875 size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002876{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877 sigset_t these;
2878 struct timespec ts;
2879 siginfo_t info;
Oleg Nesterov943df142011-04-27 21:44:14 +02002880 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881
2882 /* XXX: Don't preclude handling different sized sigset_t's. */
2883 if (sigsetsize != sizeof(sigset_t))
2884 return -EINVAL;
2885
2886 if (copy_from_user(&these, uthese, sizeof(these)))
2887 return -EFAULT;
Randy Dunlap5aba0852011-04-04 14:59:31 -07002888
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889 if (uts) {
2890 if (copy_from_user(&ts, uts, sizeof(ts)))
2891 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002892 }
2893
Oleg Nesterov943df142011-04-27 21:44:14 +02002894 ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895
Oleg Nesterov943df142011-04-27 21:44:14 +02002896 if (ret > 0 && uinfo) {
2897 if (copy_siginfo_to_user(uinfo, &info))
2898 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899 }
2900
2901 return ret;
2902}
2903
Randy Dunlap41c57892011-04-04 15:00:26 -07002904/**
2905 * sys_kill - send a signal to a process
2906 * @pid: the PID of the process
2907 * @sig: signal to be sent
2908 */
Heiko Carstens17da2bd2009-01-14 14:14:10 +01002909SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910{
2911 struct siginfo info;
2912
2913 info.si_signo = sig;
2914 info.si_errno = 0;
2915 info.si_code = SI_USER;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002916 info.si_pid = task_tgid_vnr(current);
Eric W. Biederman078de5f2012-02-08 07:00:08 -08002917 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918
2919 return kill_something_info(sig, &info, pid);
2920}
2921
Thomas Gleixner30b4ae82009-04-04 21:01:01 +00002922static int
2923do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002924{
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002925 struct task_struct *p;
Thomas Gleixner30b4ae82009-04-04 21:01:01 +00002926 int error = -ESRCH;
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002927
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002928 rcu_read_lock();
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -07002929 p = find_task_by_vpid(pid);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002930 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
Thomas Gleixner30b4ae82009-04-04 21:01:01 +00002931 error = check_kill_permission(sig, info, p);
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002932 /*
2933 * The null signal is a permissions and process existence
2934 * probe. No signal is actually delivered.
2935 */
Oleg Nesterov4a30deb2009-09-23 15:57:00 -07002936 if (!error && sig) {
2937 error = do_send_sig_info(sig, info, p, false);
2938 /*
2939 * If lock_task_sighand() failed we pretend the task
2940 * dies after receiving the signal. The window is tiny,
2941 * and the signal is private anyway.
2942 */
2943 if (unlikely(error == -ESRCH))
2944 error = 0;
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002945 }
2946 }
Oleg Nesterov3547ff32008-04-30 00:52:51 -07002947 rcu_read_unlock();
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002948
2949 return error;
2950}
2951
Thomas Gleixner30b4ae82009-04-04 21:01:01 +00002952static int do_tkill(pid_t tgid, pid_t pid, int sig)
2953{
Emese Revfyb9e146d2013-04-17 15:58:36 -07002954 struct siginfo info = {};
Thomas Gleixner30b4ae82009-04-04 21:01:01 +00002955
2956 info.si_signo = sig;
2957 info.si_errno = 0;
2958 info.si_code = SI_TKILL;
2959 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());
Thomas Gleixner30b4ae82009-04-04 21:01:01 +00002961
2962 return do_send_specific(tgid, pid, sig, &info);
2963}
2964
Linus Torvalds1da177e2005-04-16 15:20:36 -07002965/**
2966 * sys_tgkill - send signal to one specific thread
2967 * @tgid: the thread group ID of the thread
2968 * @pid: the PID of the thread
2969 * @sig: signal to be sent
2970 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08002971 * This syscall also checks the @tgid and returns -ESRCH even if the PID
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972 * exists but it's not belonging to the target process anymore. This
2973 * method solves the problem of threads exiting and PIDs getting reused.
2974 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01002975SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002976{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002977 /* This is only valid for single tasks */
2978 if (pid <= 0 || tgid <= 0)
2979 return -EINVAL;
2980
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002981 return do_tkill(tgid, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002982}
2983
Randy Dunlap41c57892011-04-04 15:00:26 -07002984/**
2985 * sys_tkill - send signal to one specific task
2986 * @pid: the PID of the task
2987 * @sig: signal to be sent
2988 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002989 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2990 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01002991SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002992{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993 /* This is only valid for single tasks */
2994 if (pid <= 0)
2995 return -EINVAL;
2996
Vadim Lobanov6dd69f12005-10-30 15:02:18 -08002997 return do_tkill(0, pid, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998}
2999
Al Viro75907d42012-12-25 15:19:12 -05003000static int do_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t *info)
3001{
3002 /* Not even root can pretend to send signals from the kernel.
3003 * Nor can they impersonate a kill()/tgkill(), which adds source info.
3004 */
Andrey Vagin66dd34a2013-02-27 17:03:12 -08003005 if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3006 (task_pid_vnr(current) != pid)) {
Al Viro75907d42012-12-25 15:19:12 -05003007 /* We used to allow any < 0 si_code */
3008 WARN_ON_ONCE(info->si_code < 0);
3009 return -EPERM;
3010 }
3011 info->si_signo = sig;
3012
3013 /* POSIX.1b doesn't mention process groups. */
3014 return kill_proc_info(sig, info, pid);
3015}
3016
Randy Dunlap41c57892011-04-04 15:00:26 -07003017/**
3018 * sys_rt_sigqueueinfo - send signal information to a signal
3019 * @pid: the PID of the thread
3020 * @sig: signal to be sent
3021 * @uinfo: signal info to be sent
3022 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01003023SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
3024 siginfo_t __user *, uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003025{
3026 siginfo_t info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003027 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3028 return -EFAULT;
Al Viro75907d42012-12-25 15:19:12 -05003029 return do_rt_sigqueueinfo(pid, sig, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030}
3031
Al Viro75907d42012-12-25 15:19:12 -05003032#ifdef CONFIG_COMPAT
Al Viro75907d42012-12-25 15:19:12 -05003033COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
3034 compat_pid_t, pid,
3035 int, sig,
3036 struct compat_siginfo __user *, uinfo)
3037{
3038 siginfo_t info;
3039 int ret = copy_siginfo_from_user32(&info, uinfo);
3040 if (unlikely(ret))
3041 return ret;
3042 return do_rt_sigqueueinfo(pid, sig, &info);
3043}
3044#endif
Al Viro75907d42012-12-25 15:19:12 -05003045
Al Viro9aae8fc2012-12-24 23:12:04 -05003046static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
Thomas Gleixner62ab4502009-04-04 21:01:06 +00003047{
3048 /* This is only valid for single tasks */
3049 if (pid <= 0 || tgid <= 0)
3050 return -EINVAL;
3051
3052 /* Not even root can pretend to send signals from the kernel.
Julien Tinnesda485242011-03-18 15:05:21 -07003053 * Nor can they impersonate a kill()/tgkill(), which adds source info.
3054 */
Andrey Vagin66dd34a2013-02-27 17:03:12 -08003055 if (((info->si_code >= 0 || info->si_code == SI_TKILL)) &&
3056 (task_pid_vnr(current) != pid)) {
Julien Tinnesda485242011-03-18 15:05:21 -07003057 /* We used to allow any < 0 si_code */
3058 WARN_ON_ONCE(info->si_code < 0);
Thomas Gleixner62ab4502009-04-04 21:01:06 +00003059 return -EPERM;
Julien Tinnesda485242011-03-18 15:05:21 -07003060 }
Thomas Gleixner62ab4502009-04-04 21:01:06 +00003061 info->si_signo = sig;
3062
3063 return do_send_specific(tgid, pid, sig, info);
3064}
3065
3066SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
3067 siginfo_t __user *, uinfo)
3068{
3069 siginfo_t info;
3070
3071 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3072 return -EFAULT;
3073
3074 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3075}
3076
Al Viro9aae8fc2012-12-24 23:12:04 -05003077#ifdef CONFIG_COMPAT
3078COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
3079 compat_pid_t, tgid,
3080 compat_pid_t, pid,
3081 int, sig,
3082 struct compat_siginfo __user *, uinfo)
3083{
3084 siginfo_t info;
3085
3086 if (copy_siginfo_from_user32(&info, uinfo))
3087 return -EFAULT;
3088 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3089}
3090#endif
3091
Oleg Nesterov88531f72006-03-28 16:11:24 -08003092int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003093{
Pavel Emelyanov93585ee2008-04-30 00:52:39 -07003094 struct task_struct *t = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095 struct k_sigaction *k;
George Anzinger71fabd52006-01-08 01:02:48 -08003096 sigset_t mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003097
Jesper Juhl7ed20e12005-05-01 08:59:14 -07003098 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003099 return -EINVAL;
3100
Pavel Emelyanov93585ee2008-04-30 00:52:39 -07003101 k = &t->sighand->action[sig-1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003102
3103 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003104 if (oact)
3105 *oact = *k;
3106
3107 if (act) {
Oleg Nesterov9ac95f22006-02-09 22:41:50 +03003108 sigdelsetmask(&act->sa.sa_mask,
3109 sigmask(SIGKILL) | sigmask(SIGSTOP));
Oleg Nesterov88531f72006-03-28 16:11:24 -08003110 *k = *act;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003111 /*
3112 * POSIX 3.3.1.3:
3113 * "Setting a signal action to SIG_IGN for a signal that is
3114 * pending shall cause the pending signal to be discarded,
3115 * whether or not it is blocked."
3116 *
3117 * "Setting a signal action to SIG_DFL for a signal that is
3118 * pending and whose default action is to ignore the signal
3119 * (for example, SIGCHLD), shall cause the pending signal to
3120 * be discarded, whether or not it is blocked"
3121 */
Roland McGrath35de2542008-07-25 19:45:51 -07003122 if (sig_handler_ignored(sig_handler(t, sig), sig)) {
George Anzinger71fabd52006-01-08 01:02:48 -08003123 sigemptyset(&mask);
3124 sigaddset(&mask, sig);
3125 rm_from_queue_full(&mask, &t->signal->shared_pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003126 do {
George Anzinger71fabd52006-01-08 01:02:48 -08003127 rm_from_queue_full(&mask, &t->pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003128 t = next_thread(t);
3129 } while (t != current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003130 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003131 }
3132
3133 spin_unlock_irq(&current->sighand->siglock);
3134 return 0;
3135}
3136
Al Viroe9b04b52012-11-20 11:14:10 -05003137static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
3139{
3140 stack_t oss;
3141 int error;
3142
Linus Torvalds0083fc22009-08-01 10:34:56 -07003143 oss.ss_sp = (void __user *) current->sas_ss_sp;
3144 oss.ss_size = current->sas_ss_size;
3145 oss.ss_flags = sas_ss_flags(sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003146
3147 if (uss) {
3148 void __user *ss_sp;
3149 size_t ss_size;
3150 int ss_flags;
3151
3152 error = -EFAULT;
Linus Torvalds0dd84862009-08-01 11:18:56 -07003153 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
3154 goto out;
3155 error = __get_user(ss_sp, &uss->ss_sp) |
3156 __get_user(ss_flags, &uss->ss_flags) |
3157 __get_user(ss_size, &uss->ss_size);
3158 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003159 goto out;
3160
3161 error = -EPERM;
3162 if (on_sig_stack(sp))
3163 goto out;
3164
3165 error = -EINVAL;
3166 /*
Randy Dunlap5aba0852011-04-04 14:59:31 -07003167 * Note - this code used to test ss_flags incorrectly:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003168 * old code may have been written using ss_flags==0
3169 * to mean ss_flags==SS_ONSTACK (as this was the only
3170 * way that worked) - this fix preserves that older
Randy Dunlap5aba0852011-04-04 14:59:31 -07003171 * mechanism.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003172 */
3173 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
3174 goto out;
3175
3176 if (ss_flags == SS_DISABLE) {
3177 ss_size = 0;
3178 ss_sp = NULL;
3179 } else {
3180 error = -ENOMEM;
3181 if (ss_size < MINSIGSTKSZ)
3182 goto out;
3183 }
3184
3185 current->sas_ss_sp = (unsigned long) ss_sp;
3186 current->sas_ss_size = ss_size;
3187 }
3188
Linus Torvalds0083fc22009-08-01 10:34:56 -07003189 error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003190 if (uoss) {
3191 error = -EFAULT;
Linus Torvalds0083fc22009-08-01 10:34:56 -07003192 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003193 goto out;
Linus Torvalds0083fc22009-08-01 10:34:56 -07003194 error = __put_user(oss.ss_sp, &uoss->ss_sp) |
3195 __put_user(oss.ss_size, &uoss->ss_size) |
3196 __put_user(oss.ss_flags, &uoss->ss_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003197 }
3198
Linus Torvalds1da177e2005-04-16 15:20:36 -07003199out:
3200 return error;
3201}
Al Viro6bf9adf2012-12-14 14:09:47 -05003202SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
3203{
3204 return do_sigaltstack(uss, uoss, current_user_stack_pointer());
3205}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206
Al Viro5c495742012-11-18 15:29:16 -05003207int restore_altstack(const stack_t __user *uss)
3208{
3209 int err = do_sigaltstack(uss, NULL, current_user_stack_pointer());
3210 /* squash all but EFAULT for now */
3211 return err == -EFAULT ? err : 0;
3212}
3213
Al Viroc40702c2012-11-20 14:24:26 -05003214int __save_altstack(stack_t __user *uss, unsigned long sp)
3215{
3216 struct task_struct *t = current;
3217 return __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
3218 __put_user(sas_ss_flags(sp), &uss->ss_flags) |
3219 __put_user(t->sas_ss_size, &uss->ss_size);
3220}
3221
Al Viro90268432012-12-14 14:47:53 -05003222#ifdef CONFIG_COMPAT
Al Viro90228fc2012-12-23 03:33:38 -05003223COMPAT_SYSCALL_DEFINE2(sigaltstack,
3224 const compat_stack_t __user *, uss_ptr,
3225 compat_stack_t __user *, uoss_ptr)
Al Viro90268432012-12-14 14:47:53 -05003226{
3227 stack_t uss, uoss;
3228 int ret;
3229 mm_segment_t seg;
3230
3231 if (uss_ptr) {
3232 compat_stack_t uss32;
3233
3234 memset(&uss, 0, sizeof(stack_t));
3235 if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
3236 return -EFAULT;
3237 uss.ss_sp = compat_ptr(uss32.ss_sp);
3238 uss.ss_flags = uss32.ss_flags;
3239 uss.ss_size = uss32.ss_size;
3240 }
3241 seg = get_fs();
3242 set_fs(KERNEL_DS);
3243 ret = do_sigaltstack((stack_t __force __user *) (uss_ptr ? &uss : NULL),
3244 (stack_t __force __user *) &uoss,
3245 compat_user_stack_pointer());
3246 set_fs(seg);
3247 if (ret >= 0 && uoss_ptr) {
3248 if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(compat_stack_t)) ||
3249 __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
3250 __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
3251 __put_user(uoss.ss_size, &uoss_ptr->ss_size))
3252 ret = -EFAULT;
3253 }
3254 return ret;
3255}
3256
3257int compat_restore_altstack(const compat_stack_t __user *uss)
3258{
3259 int err = compat_sys_sigaltstack(uss, NULL);
3260 /* squash all but -EFAULT for now */
3261 return err == -EFAULT ? err : 0;
3262}
Al Viroc40702c2012-11-20 14:24:26 -05003263
3264int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
3265{
3266 struct task_struct *t = current;
3267 return __put_user(ptr_to_compat((void __user *)t->sas_ss_sp), &uss->ss_sp) |
3268 __put_user(sas_ss_flags(sp), &uss->ss_flags) |
3269 __put_user(t->sas_ss_size, &uss->ss_size);
3270}
Al Viro90268432012-12-14 14:47:53 -05003271#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003272
3273#ifdef __ARCH_WANT_SYS_SIGPENDING
3274
Randy Dunlap41c57892011-04-04 15:00:26 -07003275/**
3276 * sys_sigpending - examine pending signals
3277 * @set: where mask of pending signal is returned
3278 */
Heiko Carstensb290ebe2009-01-14 14:14:06 +01003279SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003280{
Al Virofe9c1db2012-12-25 14:31:38 -05003281 return sys_rt_sigpending((sigset_t __user *)set, sizeof(old_sigset_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003282}
3283
3284#endif
3285
3286#ifdef __ARCH_WANT_SYS_SIGPROCMASK
Randy Dunlap41c57892011-04-04 15:00:26 -07003287/**
3288 * sys_sigprocmask - examine and change blocked signals
3289 * @how: whether to add, remove, or set signals
Oleg Nesterovb013c392011-04-28 11:36:20 +02003290 * @nset: signals to add or remove (if non-null)
Randy Dunlap41c57892011-04-04 15:00:26 -07003291 * @oset: previous value of signal mask if non-null
3292 *
Randy Dunlap5aba0852011-04-04 14:59:31 -07003293 * Some platforms have their own version with special arguments;
3294 * others support only sys_rt_sigprocmask.
3295 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003296
Oleg Nesterovb013c392011-04-28 11:36:20 +02003297SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
Heiko Carstensb290ebe2009-01-14 14:14:06 +01003298 old_sigset_t __user *, oset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003299{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003300 old_sigset_t old_set, new_set;
Oleg Nesterov2e4f7c72011-05-09 13:48:56 +02003301 sigset_t new_blocked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003302
Oleg Nesterovb013c392011-04-28 11:36:20 +02003303 old_set = current->blocked.sig[0];
3304
3305 if (nset) {
3306 if (copy_from_user(&new_set, nset, sizeof(*nset)))
3307 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003308
Oleg Nesterov2e4f7c72011-05-09 13:48:56 +02003309 new_blocked = current->blocked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310
Linus Torvalds1da177e2005-04-16 15:20:36 -07003311 switch (how) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003312 case SIG_BLOCK:
Oleg Nesterov2e4f7c72011-05-09 13:48:56 +02003313 sigaddsetmask(&new_blocked, new_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314 break;
3315 case SIG_UNBLOCK:
Oleg Nesterov2e4f7c72011-05-09 13:48:56 +02003316 sigdelsetmask(&new_blocked, new_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003317 break;
3318 case SIG_SETMASK:
Oleg Nesterov2e4f7c72011-05-09 13:48:56 +02003319 new_blocked.sig[0] = new_set;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003320 break;
Oleg Nesterov2e4f7c72011-05-09 13:48:56 +02003321 default:
3322 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003323 }
3324
Oleg Nesterov0c4a8422013-01-05 19:13:29 +01003325 set_current_blocked(&new_blocked);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003326 }
Oleg Nesterovb013c392011-04-28 11:36:20 +02003327
3328 if (oset) {
3329 if (copy_to_user(oset, &old_set, sizeof(*oset)))
3330 return -EFAULT;
3331 }
3332
3333 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003334}
3335#endif /* __ARCH_WANT_SYS_SIGPROCMASK */
3336
Al Viroeaca6ea2012-11-25 23:12:10 -05003337#ifndef CONFIG_ODD_RT_SIGACTION
Randy Dunlap41c57892011-04-04 15:00:26 -07003338/**
3339 * sys_rt_sigaction - alter an action taken by a process
3340 * @sig: signal to be sent
Randy Dunlapf9fa0bc2011-04-08 10:53:46 -07003341 * @act: new sigaction
3342 * @oact: used to save the previous sigaction
Randy Dunlap41c57892011-04-04 15:00:26 -07003343 * @sigsetsize: size of sigset_t type
3344 */
Heiko Carstensd4e82042009-01-14 14:14:34 +01003345SYSCALL_DEFINE4(rt_sigaction, int, sig,
3346 const struct sigaction __user *, act,
3347 struct sigaction __user *, oact,
3348 size_t, sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003349{
3350 struct k_sigaction new_sa, old_sa;
3351 int ret = -EINVAL;
3352
3353 /* XXX: Don't preclude handling different sized sigset_t's. */
3354 if (sigsetsize != sizeof(sigset_t))
3355 goto out;
3356
3357 if (act) {
3358 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
3359 return -EFAULT;
3360 }
3361
3362 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
3363
3364 if (!ret && oact) {
3365 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
3366 return -EFAULT;
3367 }
3368out:
3369 return ret;
3370}
Al Viro08d32fe2012-12-25 18:38:15 -05003371#ifdef CONFIG_COMPAT
Al Viro08d32fe2012-12-25 18:38:15 -05003372COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig,
3373 const struct compat_sigaction __user *, act,
3374 struct compat_sigaction __user *, oact,
3375 compat_size_t, sigsetsize)
3376{
3377 struct k_sigaction new_ka, old_ka;
3378 compat_sigset_t mask;
3379#ifdef __ARCH_HAS_SA_RESTORER
3380 compat_uptr_t restorer;
3381#endif
3382 int ret;
3383
3384 /* XXX: Don't preclude handling different sized sigset_t's. */
3385 if (sigsetsize != sizeof(compat_sigset_t))
3386 return -EINVAL;
3387
3388 if (act) {
3389 compat_uptr_t handler;
3390 ret = get_user(handler, &act->sa_handler);
3391 new_ka.sa.sa_handler = compat_ptr(handler);
3392#ifdef __ARCH_HAS_SA_RESTORER
3393 ret |= get_user(restorer, &act->sa_restorer);
3394 new_ka.sa.sa_restorer = compat_ptr(restorer);
3395#endif
3396 ret |= copy_from_user(&mask, &act->sa_mask, sizeof(mask));
3397 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
3398 if (ret)
3399 return -EFAULT;
3400 sigset_from_compat(&new_ka.sa.sa_mask, &mask);
3401 }
3402
3403 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3404 if (!ret && oact) {
3405 sigset_to_compat(&mask, &old_ka.sa.sa_mask);
3406 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler),
3407 &oact->sa_handler);
3408 ret |= copy_to_user(&oact->sa_mask, &mask, sizeof(mask));
3409 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
3410#ifdef __ARCH_HAS_SA_RESTORER
3411 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3412 &oact->sa_restorer);
3413#endif
3414 }
3415 return ret;
3416}
3417#endif
Al Viroeaca6ea2012-11-25 23:12:10 -05003418#endif /* !CONFIG_ODD_RT_SIGACTION */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003419
Al Viro495dfbf2012-12-25 19:09:45 -05003420#ifdef CONFIG_OLD_SIGACTION
3421SYSCALL_DEFINE3(sigaction, int, sig,
3422 const struct old_sigaction __user *, act,
3423 struct old_sigaction __user *, oact)
3424{
3425 struct k_sigaction new_ka, old_ka;
3426 int ret;
3427
3428 if (act) {
3429 old_sigset_t mask;
3430 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3431 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
3432 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
3433 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3434 __get_user(mask, &act->sa_mask))
3435 return -EFAULT;
3436#ifdef __ARCH_HAS_KA_RESTORER
3437 new_ka.ka_restorer = NULL;
3438#endif
3439 siginitset(&new_ka.sa.sa_mask, mask);
3440 }
3441
3442 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3443
3444 if (!ret && oact) {
3445 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3446 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
3447 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
3448 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3449 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3450 return -EFAULT;
3451 }
3452
3453 return ret;
3454}
3455#endif
3456#ifdef CONFIG_COMPAT_OLD_SIGACTION
3457COMPAT_SYSCALL_DEFINE3(sigaction, int, sig,
3458 const struct compat_old_sigaction __user *, act,
3459 struct compat_old_sigaction __user *, oact)
3460{
3461 struct k_sigaction new_ka, old_ka;
3462 int ret;
3463 compat_old_sigset_t mask;
3464 compat_uptr_t handler, restorer;
3465
3466 if (act) {
3467 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3468 __get_user(handler, &act->sa_handler) ||
3469 __get_user(restorer, &act->sa_restorer) ||
3470 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3471 __get_user(mask, &act->sa_mask))
3472 return -EFAULT;
3473
3474#ifdef __ARCH_HAS_KA_RESTORER
3475 new_ka.ka_restorer = NULL;
3476#endif
3477 new_ka.sa.sa_handler = compat_ptr(handler);
3478 new_ka.sa.sa_restorer = compat_ptr(restorer);
3479 siginitset(&new_ka.sa.sa_mask, mask);
3480 }
3481
3482 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3483
3484 if (!ret && oact) {
3485 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3486 __put_user(ptr_to_compat(old_ka.sa.sa_handler),
3487 &oact->sa_handler) ||
3488 __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3489 &oact->sa_restorer) ||
3490 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3491 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3492 return -EFAULT;
3493 }
3494 return ret;
3495}
3496#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003497
3498#ifdef __ARCH_WANT_SYS_SGETMASK
3499
3500/*
3501 * For backwards compatibility. Functionality superseded by sigprocmask.
3502 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01003503SYSCALL_DEFINE0(sgetmask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003504{
3505 /* SMP safe */
3506 return current->blocked.sig[0];
3507}
3508
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01003509SYSCALL_DEFINE1(ssetmask, int, newmask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003510{
Oleg Nesterovc1095c62011-07-27 12:49:44 -07003511 int old = current->blocked.sig[0];
3512 sigset_t newset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003513
Oleg Nesterov5ba53ff2013-01-05 19:13:13 +01003514 siginitset(&newset, newmask);
Oleg Nesterovc1095c62011-07-27 12:49:44 -07003515 set_current_blocked(&newset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003516
3517 return old;
3518}
3519#endif /* __ARCH_WANT_SGETMASK */
3520
3521#ifdef __ARCH_WANT_SYS_SIGNAL
3522/*
3523 * For backwards compatibility. Functionality superseded by sigaction.
3524 */
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01003525SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003526{
3527 struct k_sigaction new_sa, old_sa;
3528 int ret;
3529
3530 new_sa.sa.sa_handler = handler;
3531 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
Oleg Nesterovc70d3d702006-02-09 22:41:41 +03003532 sigemptyset(&new_sa.sa.sa_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003533
3534 ret = do_sigaction(sig, &new_sa, &old_sa);
3535
3536 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
3537}
3538#endif /* __ARCH_WANT_SYS_SIGNAL */
3539
3540#ifdef __ARCH_WANT_SYS_PAUSE
3541
Heiko Carstensa5f8fa92009-01-14 14:14:11 +01003542SYSCALL_DEFINE0(pause)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003543{
Oleg Nesterovd92fcf02011-05-25 19:22:27 +02003544 while (!signal_pending(current)) {
3545 current->state = TASK_INTERRUPTIBLE;
3546 schedule();
3547 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003548 return -ERESTARTNOHAND;
3549}
3550
3551#endif
3552
Al Viro68f3f162012-05-21 21:42:32 -04003553int sigsuspend(sigset_t *set)
3554{
Al Viro68f3f162012-05-21 21:42:32 -04003555 current->saved_sigmask = current->blocked;
3556 set_current_blocked(set);
3557
3558 current->state = TASK_INTERRUPTIBLE;
3559 schedule();
3560 set_restore_sigmask();
3561 return -ERESTARTNOHAND;
3562}
Al Viro68f3f162012-05-21 21:42:32 -04003563
Randy Dunlap41c57892011-04-04 15:00:26 -07003564/**
3565 * sys_rt_sigsuspend - replace the signal mask for a value with the
3566 * @unewset value until a signal is received
3567 * @unewset: new signal mask value
3568 * @sigsetsize: size of sigset_t type
3569 */
Heiko Carstensd4e82042009-01-14 14:14:34 +01003570SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
David Woodhouse150256d2006-01-18 17:43:57 -08003571{
3572 sigset_t newset;
3573
3574 /* XXX: Don't preclude handling different sized sigset_t's. */
3575 if (sigsetsize != sizeof(sigset_t))
3576 return -EINVAL;
3577
3578 if (copy_from_user(&newset, unewset, sizeof(newset)))
3579 return -EFAULT;
Al Viro68f3f162012-05-21 21:42:32 -04003580 return sigsuspend(&newset);
David Woodhouse150256d2006-01-18 17:43:57 -08003581}
Al Viroad4b65a2012-12-24 21:43:56 -05003582
3583#ifdef CONFIG_COMPAT
3584COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
3585{
3586#ifdef __BIG_ENDIAN
3587 sigset_t newset;
3588 compat_sigset_t newset32;
3589
3590 /* XXX: Don't preclude handling different sized sigset_t's. */
3591 if (sigsetsize != sizeof(sigset_t))
3592 return -EINVAL;
3593
3594 if (copy_from_user(&newset32, unewset, sizeof(compat_sigset_t)))
3595 return -EFAULT;
3596 sigset_from_compat(&newset, &newset32);
3597 return sigsuspend(&newset);
3598#else
3599 /* on little-endian bitmaps don't care about granularity */
3600 return sys_rt_sigsuspend((sigset_t __user *)unewset, sigsetsize);
3601#endif
3602}
3603#endif
David Woodhouse150256d2006-01-18 17:43:57 -08003604
Al Viro0a0e8cd2012-12-25 16:04:12 -05003605#ifdef CONFIG_OLD_SIGSUSPEND
3606SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
3607{
3608 sigset_t blocked;
3609 siginitset(&blocked, mask);
3610 return sigsuspend(&blocked);
3611}
3612#endif
3613#ifdef CONFIG_OLD_SIGSUSPEND3
3614SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask)
3615{
3616 sigset_t blocked;
3617 siginitset(&blocked, mask);
3618 return sigsuspend(&blocked);
3619}
3620#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003621
David Howellsf269fdd2006-09-27 01:50:23 -07003622__attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
3623{
3624 return NULL;
3625}
3626
Linus Torvalds1da177e2005-04-16 15:20:36 -07003627void __init signals_init(void)
3628{
Christoph Lameter0a31bd52007-05-06 14:49:57 -07003629 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003630}
Jason Wessel67fc4e02010-05-20 21:04:21 -05003631
3632#ifdef CONFIG_KGDB_KDB
3633#include <linux/kdb.h>
3634/*
3635 * kdb_send_sig_info - Allows kdb to send signals without exposing
3636 * signal internals. This function checks if the required locks are
3637 * available before calling the main signal code, to avoid kdb
3638 * deadlocks.
3639 */
3640void
3641kdb_send_sig_info(struct task_struct *t, struct siginfo *info)
3642{
3643 static struct task_struct *kdb_prev_t;
3644 int sig, new_t;
3645 if (!spin_trylock(&t->sighand->siglock)) {
3646 kdb_printf("Can't do kill command now.\n"
3647 "The sigmask lock is held somewhere else in "
3648 "kernel, try again later\n");
3649 return;
3650 }
3651 spin_unlock(&t->sighand->siglock);
3652 new_t = kdb_prev_t != t;
3653 kdb_prev_t = t;
3654 if (t->state != TASK_RUNNING && new_t) {
3655 kdb_printf("Process is not RUNNING, sending a signal from "
3656 "kdb risks deadlock\n"
3657 "on the run queue locks. "
3658 "The signal has _not_ been sent.\n"
3659 "Reissue the kill command if you want to risk "
3660 "the deadlock.\n");
3661 return;
3662 }
3663 sig = info->si_signo;
3664 if (send_sig_info(sig, info, t))
3665 kdb_printf("Fail to deliver Signal %d to process %d.\n",
3666 sig, t->pid);
3667 else
3668 kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
3669}
3670#endif /* CONFIG_KGDB_KDB */