signal.c 101.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 *  linux/kernel/signal.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
 *
 *  2003-06-02  Jim Houston - Concurrent Computer Corp.
 *		Changes to use preallocated sigqueue structures
 *		to allow signals to be sent reliably.
 */

#include <linux/slab.h>
14
#include <linux/export.h>
L
Linus Torvalds 已提交
15
#include <linux/init.h>
16
#include <linux/sched/mm.h>
17
#include <linux/sched/user.h>
18
#include <linux/sched/debug.h>
19
#include <linux/sched/task.h>
20
#include <linux/sched/task_stack.h>
21
#include <linux/sched/cputime.h>
L
Linus Torvalds 已提交
22 23 24
#include <linux/fs.h>
#include <linux/tty.h>
#include <linux/binfmts.h>
25
#include <linux/coredump.h>
L
Linus Torvalds 已提交
26 27 28
#include <linux/security.h>
#include <linux/syscalls.h>
#include <linux/ptrace.h>
29
#include <linux/signal.h>
30
#include <linux/signalfd.h>
31
#include <linux/ratelimit.h>
32
#include <linux/tracehook.h>
33
#include <linux/capability.h>
34
#include <linux/freezer.h>
35 36
#include <linux/pid_namespace.h>
#include <linux/nsproxy.h>
37
#include <linux/user_namespace.h>
38
#include <linux/uprobes.h>
A
Al Viro 已提交
39
#include <linux/compat.h>
40
#include <linux/cn_proc.h>
41
#include <linux/compiler.h>
42
#include <linux/posix-timers.h>
43
#include <linux/livepatch.h>
44

45 46
#define CREATE_TRACE_POINTS
#include <trace/events/signal.h>
47

L
Linus Torvalds 已提交
48
#include <asm/param.h>
49
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
50 51
#include <asm/unistd.h>
#include <asm/siginfo.h>
52
#include <asm/cacheflush.h>
53
#include "audit.h"	/* audit_signal_info() */
L
Linus Torvalds 已提交
54 55 56 57 58

/*
 * SLAB caches for signal bits.
 */

59
static struct kmem_cache *sigqueue_cachep;
L
Linus Torvalds 已提交
60

61 62
int print_fatal_signals __read_mostly;

63
static void __user *sig_handler(struct task_struct *t, int sig)
64
{
65 66
	return t->sighand->action[sig - 1].sa.sa_handler;
}
67

68
static inline bool sig_handler_ignored(void __user *handler, int sig)
69
{
70 71
	/* Is it explicitly or implicitly ignored? */
	return handler == SIG_IGN ||
72
	       (handler == SIG_DFL && sig_kernel_ignore(sig));
73
}
L
Linus Torvalds 已提交
74

75
static int sig_task_ignored(struct task_struct *t, int sig, bool force)
L
Linus Torvalds 已提交
76
{
77
	void __user *handler;
L
Linus Torvalds 已提交
78

79 80 81
	handler = sig_handler(t, sig);

	if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
82
	    handler == SIG_DFL && !(force && sig_kernel_only(sig)))
83 84 85 86 87
		return 1;

	return sig_handler_ignored(handler, sig);
}

88
static int sig_ignored(struct task_struct *t, int sig, bool force)
89
{
L
Linus Torvalds 已提交
90 91 92 93 94
	/*
	 * Blocked signals are never ignored, since the
	 * signal handler may change by the time it is
	 * unblocked.
	 */
95
	if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
L
Linus Torvalds 已提交
96 97
		return 0;

98
	/*
99 100 101
	 * Tracers may want to know about even ignored signal unless it
	 * is SIGKILL which can't be reported anyway but can be ignored
	 * by SIGNAL_UNKILLABLE task.
102
	 */
103 104 105 106
	if (t->ptrace && sig != SIGKILL)
		return 0;

	return sig_task_ignored(t, sig, force);
L
Linus Torvalds 已提交
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
}

/*
 * Re-calculate pending state from the set of locally pending
 * signals, globally pending signals, and blocked signals.
 */
static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
{
	unsigned long ready;
	long i;

	switch (_NSIG_WORDS) {
	default:
		for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
			ready |= signal->sig[i] &~ blocked->sig[i];
		break;

	case 4: ready  = signal->sig[3] &~ blocked->sig[3];
		ready |= signal->sig[2] &~ blocked->sig[2];
		ready |= signal->sig[1] &~ blocked->sig[1];
		ready |= signal->sig[0] &~ blocked->sig[0];
		break;

	case 2: ready  = signal->sig[1] &~ blocked->sig[1];
		ready |= signal->sig[0] &~ blocked->sig[0];
		break;

	case 1: ready  = signal->sig[0] &~ blocked->sig[0];
	}
	return ready !=	0;
}

#define PENDING(p,b) has_pending_signals(&(p)->signal, (b))

R
Roland McGrath 已提交
141
static int recalc_sigpending_tsk(struct task_struct *t)
L
Linus Torvalds 已提交
142
{
143
	if ((t->jobctl & JOBCTL_PENDING_MASK) ||
L
Linus Torvalds 已提交
144
	    PENDING(&t->pending, &t->blocked) ||
R
Roland McGrath 已提交
145
	    PENDING(&t->signal->shared_pending, &t->blocked)) {
L
Linus Torvalds 已提交
146
		set_tsk_thread_flag(t, TIF_SIGPENDING);
R
Roland McGrath 已提交
147 148
		return 1;
	}
149 150 151 152 153
	/*
	 * We must never clear the flag in another thread, or in current
	 * when it's possible the current syscall is returning -ERESTART*.
	 * So we don't clear it here, and only callers who know they should do.
	 */
R
Roland McGrath 已提交
154 155 156 157 158 159 160 161 162 163 164
	return 0;
}

/*
 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
 * This is superfluous when called on current, the wakeup is a harmless no-op.
 */
void recalc_sigpending_and_wake(struct task_struct *t)
{
	if (recalc_sigpending_tsk(t))
		signal_wake_up(t, 0);
L
Linus Torvalds 已提交
165 166 167 168
}

void recalc_sigpending(void)
{
169 170
	if (!recalc_sigpending_tsk(current) && !freezing(current) &&
	    !klp_patch_pending(current))
171 172
		clear_thread_flag(TIF_SIGPENDING);

L
Linus Torvalds 已提交
173 174 175 176
}

/* Given the mask, find the first available signal that should be serviced. */

177 178
#define SYNCHRONOUS_MASK \
	(sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
179
	 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
180

181
int next_signal(struct sigpending *pending, sigset_t *mask)
L
Linus Torvalds 已提交
182 183 184
{
	unsigned long i, *s, *m, x;
	int sig = 0;
185

L
Linus Torvalds 已提交
186 187
	s = pending->signal.sig;
	m = mask->sig;
188 189 190 191 192 193 194 195 196 197 198 199 200

	/*
	 * Handle the first word specially: it contains the
	 * synchronous signals that need to be dequeued first.
	 */
	x = *s &~ *m;
	if (x) {
		if (x & SYNCHRONOUS_MASK)
			x &= SYNCHRONOUS_MASK;
		sig = ffz(~x) + 1;
		return sig;
	}

L
Linus Torvalds 已提交
201 202
	switch (_NSIG_WORDS) {
	default:
203 204 205 206 207 208 209
		for (i = 1; i < _NSIG_WORDS; ++i) {
			x = *++s &~ *++m;
			if (!x)
				continue;
			sig = ffz(~x) + i*_NSIG_BPW + 1;
			break;
		}
L
Linus Torvalds 已提交
210 211
		break;

212 213 214
	case 2:
		x = s[1] &~ m[1];
		if (!x)
L
Linus Torvalds 已提交
215
			break;
216
		sig = ffz(~x) + _NSIG_BPW + 1;
L
Linus Torvalds 已提交
217 218
		break;

219 220
	case 1:
		/* Nothing to do */
L
Linus Torvalds 已提交
221 222
		break;
	}
223

L
Linus Torvalds 已提交
224 225 226
	return sig;
}

227 228 229 230 231 232 233 234 235 236
static inline void print_dropped_signal(int sig)
{
	static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);

	if (!print_fatal_signals)
		return;

	if (!__ratelimit(&ratelimit_state))
		return;

237
	pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
238 239 240
				current->comm, current->pid, sig);
}

241
/**
242
 * task_set_jobctl_pending - set jobctl pending bits
243
 * @task: target task
244
 * @mask: pending bits to set
245
 *
246 247 248 249 250 251 252 253 254 255 256 257
 * Clear @mask from @task->jobctl.  @mask must be subset of
 * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
 * %JOBCTL_TRAPPING.  If stop signo is being set, the existing signo is
 * cleared.  If @task is already being killed or exiting, this function
 * becomes noop.
 *
 * CONTEXT:
 * Must be called with @task->sighand->siglock held.
 *
 * RETURNS:
 * %true if @mask is set, %false if made noop because @task was dying.
 */
258
bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
{
	BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
			JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
	BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));

	if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
		return false;

	if (mask & JOBCTL_STOP_SIGMASK)
		task->jobctl &= ~JOBCTL_STOP_SIGMASK;

	task->jobctl |= mask;
	return true;
}

274
/**
275
 * task_clear_jobctl_trapping - clear jobctl trapping bit
276 277
 * @task: target task
 *
278 279 280 281
 * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
 * Clear it and wake up the ptracer.  Note that we don't need any further
 * locking.  @task->siglock guarantees that @task->parent points to the
 * ptracer.
282 283 284 285
 *
 * CONTEXT:
 * Must be called with @task->sighand->siglock held.
 */
286
void task_clear_jobctl_trapping(struct task_struct *task)
287
{
288 289
	if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
		task->jobctl &= ~JOBCTL_TRAPPING;
290
		smp_mb();	/* advised by wake_up_bit() */
291
		wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
292 293 294
	}
}

295
/**
296
 * task_clear_jobctl_pending - clear jobctl pending bits
297
 * @task: target task
298
 * @mask: pending bits to clear
299
 *
300 301 302
 * Clear @mask from @task->jobctl.  @mask must be subset of
 * %JOBCTL_PENDING_MASK.  If %JOBCTL_STOP_PENDING is being cleared, other
 * STOP bits are cleared together.
303
 *
304 305
 * If clearing of @mask leaves no stop or trap pending, this function calls
 * task_clear_jobctl_trapping().
306 307 308 309
 *
 * CONTEXT:
 * Must be called with @task->sighand->siglock held.
 */
310
void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
311
{
312 313 314 315 316 317
	BUG_ON(mask & ~JOBCTL_PENDING_MASK);

	if (mask & JOBCTL_STOP_PENDING)
		mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;

	task->jobctl &= ~mask;
318 319 320

	if (!(task->jobctl & JOBCTL_PENDING_MASK))
		task_clear_jobctl_trapping(task);
321 322 323 324 325 326
}

/**
 * task_participate_group_stop - participate in a group stop
 * @task: task participating in a group stop
 *
327
 * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
328
 * Group stop states are cleared and the group stop count is consumed if
329
 * %JOBCTL_STOP_CONSUME was set.  If the consumption completes the group
330
 * stop, the appropriate %SIGNAL_* flags are set.
331 332 333
 *
 * CONTEXT:
 * Must be called with @task->sighand->siglock held.
334 335 336 337
 *
 * RETURNS:
 * %true if group stop completion should be notified to the parent, %false
 * otherwise.
338 339 340 341
 */
static bool task_participate_group_stop(struct task_struct *task)
{
	struct signal_struct *sig = task->signal;
342
	bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
343

344
	WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
345

346
	task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
347 348 349 350 351 352 353

	if (!consume)
		return false;

	if (!WARN_ON_ONCE(sig->group_stop_count == 0))
		sig->group_stop_count--;

354 355 356 357 358
	/*
	 * Tell the caller to notify completion iff we are entering into a
	 * fresh group stop.  Read comment in do_signal_stop() for details.
	 */
	if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
359
		signal_set_stop_flags(sig, SIGNAL_STOP_STOPPED);
360 361 362 363 364
		return true;
	}
	return false;
}

365 366 367
/*
 * allocate a new signal queue record
 * - this may be called without locks if and only if t == current, otherwise an
368
 *   appropriate lock must be held to stop the target task from exiting
369
 */
370 371
static struct sigqueue *
__sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
L
Linus Torvalds 已提交
372 373
{
	struct sigqueue *q = NULL;
374
	struct user_struct *user;
L
Linus Torvalds 已提交
375

376
	/*
377 378
	 * Protect access to @t credentials. This can go away when all
	 * callers hold rcu read lock.
379
	 */
380
	rcu_read_lock();
D
David Howells 已提交
381
	user = get_uid(__task_cred(t)->user);
382
	atomic_inc(&user->sigpending);
383
	rcu_read_unlock();
384

L
Linus Torvalds 已提交
385
	if (override_rlimit ||
386
	    atomic_read(&user->sigpending) <=
387
			task_rlimit(t, RLIMIT_SIGPENDING)) {
L
Linus Torvalds 已提交
388
		q = kmem_cache_alloc(sigqueue_cachep, flags);
389 390 391 392
	} else {
		print_dropped_signal(sig);
	}

L
Linus Torvalds 已提交
393
	if (unlikely(q == NULL)) {
394
		atomic_dec(&user->sigpending);
D
David Howells 已提交
395
		free_uid(user);
L
Linus Torvalds 已提交
396 397 398
	} else {
		INIT_LIST_HEAD(&q->list);
		q->flags = 0;
D
David Howells 已提交
399
		q->user = user;
L
Linus Torvalds 已提交
400
	}
D
David Howells 已提交
401 402

	return q;
L
Linus Torvalds 已提交
403 404
}

405
static void __sigqueue_free(struct sigqueue *q)
L
Linus Torvalds 已提交
406 407 408 409 410 411 412 413
{
	if (q->flags & SIGQUEUE_PREALLOC)
		return;
	atomic_dec(&q->user->sigpending);
	free_uid(q->user);
	kmem_cache_free(sigqueue_cachep, q);
}

414
void flush_sigqueue(struct sigpending *queue)
L
Linus Torvalds 已提交
415 416 417 418 419 420 421 422 423 424 425 426
{
	struct sigqueue *q;

	sigemptyset(&queue->signal);
	while (!list_empty(&queue->list)) {
		q = list_entry(queue->list.next, struct sigqueue , list);
		list_del_init(&q->list);
		__sigqueue_free(q);
	}
}

/*
427
 * Flush all pending signals for this kthread.
L
Linus Torvalds 已提交
428
 */
429
void flush_signals(struct task_struct *t)
L
Linus Torvalds 已提交
430 431 432 433
{
	unsigned long flags;

	spin_lock_irqsave(&t->sighand->siglock, flags);
434 435 436
	clear_tsk_thread_flag(t, TIF_SIGPENDING);
	flush_sigqueue(&t->pending);
	flush_sigqueue(&t->signal->shared_pending);
L
Linus Torvalds 已提交
437 438 439
	spin_unlock_irqrestore(&t->sighand->siglock, flags);
}

440
#ifdef CONFIG_POSIX_TIMERS
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473
static void __flush_itimer_signals(struct sigpending *pending)
{
	sigset_t signal, retain;
	struct sigqueue *q, *n;

	signal = pending->signal;
	sigemptyset(&retain);

	list_for_each_entry_safe(q, n, &pending->list, list) {
		int sig = q->info.si_signo;

		if (likely(q->info.si_code != SI_TIMER)) {
			sigaddset(&retain, sig);
		} else {
			sigdelset(&signal, sig);
			list_del_init(&q->list);
			__sigqueue_free(q);
		}
	}

	sigorsets(&pending->signal, &signal, &retain);
}

void flush_itimer_signals(void)
{
	struct task_struct *tsk = current;
	unsigned long flags;

	spin_lock_irqsave(&tsk->sighand->siglock, flags);
	__flush_itimer_signals(&tsk->pending);
	__flush_itimer_signals(&tsk->signal->shared_pending);
	spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
}
474
#endif
475

476 477 478 479 480 481 482 483 484 485
void ignore_signals(struct task_struct *t)
{
	int i;

	for (i = 0; i < _NSIG; ++i)
		t->sighand->action[i].sa.sa_handler = SIG_IGN;

	flush_signals(t);
}

L
Linus Torvalds 已提交
486 487 488 489 490 491 492 493 494 495 496 497 498
/*
 * Flush all handlers for a task.
 */

void
flush_signal_handlers(struct task_struct *t, int force_default)
{
	int i;
	struct k_sigaction *ka = &t->sighand->action[0];
	for (i = _NSIG ; i != 0 ; i--) {
		if (force_default || ka->sa.sa_handler != SIG_IGN)
			ka->sa.sa_handler = SIG_DFL;
		ka->sa.sa_flags = 0;
499
#ifdef __ARCH_HAS_SA_RESTORER
500 501
		ka->sa.sa_restorer = NULL;
#endif
L
Linus Torvalds 已提交
502 503 504 505 506
		sigemptyset(&ka->sa.sa_mask);
		ka++;
	}
}

507 508
int unhandled_signal(struct task_struct *tsk, int sig)
{
509
	void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
510
	if (is_global_init(tsk))
511
		return 1;
512
	if (handler != SIG_IGN && handler != SIG_DFL)
513
		return 0;
T
Tejun Heo 已提交
514 515
	/* if ptraced, let the tracer determine */
	return !tsk->ptrace;
516 517
}

518 519
static void collect_signal(int sig, struct sigpending *list, siginfo_t *info,
			   bool *resched_timer)
L
Linus Torvalds 已提交
520 521 522 523 524 525 526 527 528
{
	struct sigqueue *q, *first = NULL;

	/*
	 * Collect the siginfo appropriate to this signal.  Check if
	 * there is another siginfo for the same signal.
	*/
	list_for_each_entry(q, &list->list, list) {
		if (q->info.si_signo == sig) {
529 530
			if (first)
				goto still_pending;
L
Linus Torvalds 已提交
531 532 533
			first = q;
		}
	}
534 535 536

	sigdelset(&list->signal, sig);

L
Linus Torvalds 已提交
537
	if (first) {
538
still_pending:
L
Linus Torvalds 已提交
539 540
		list_del_init(&first->list);
		copy_siginfo(info, &first->info);
541 542 543 544 545 546

		*resched_timer =
			(first->flags & SIGQUEUE_PREALLOC) &&
			(info->si_code == SI_TIMER) &&
			(info->si_sys_private);

L
Linus Torvalds 已提交
547 548
		__sigqueue_free(first);
	} else {
549 550 551 552
		/*
		 * Ok, it wasn't in the queue.  This must be
		 * a fast-pathed signal or we must have been
		 * out of queue space.  So zero out the info.
L
Linus Torvalds 已提交
553
		 */
554
		clear_siginfo(info);
L
Linus Torvalds 已提交
555 556
		info->si_signo = sig;
		info->si_errno = 0;
557
		info->si_code = SI_USER;
L
Linus Torvalds 已提交
558 559 560 561 562 563
		info->si_pid = 0;
		info->si_uid = 0;
	}
}

static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
564
			siginfo_t *info, bool *resched_timer)
L
Linus Torvalds 已提交
565
{
566
	int sig = next_signal(pending, mask);
L
Linus Torvalds 已提交
567

568
	if (sig)
569
		collect_signal(sig, pending, info, resched_timer);
L
Linus Torvalds 已提交
570 571 572 573
	return sig;
}

/*
574
 * Dequeue a signal and return the element to the caller, which is
L
Linus Torvalds 已提交
575 576 577 578 579 580
 * expected to free it.
 *
 * All callers have to hold the siglock.
 */
int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
{
581
	bool resched_timer = false;
582
	int signr;
583 584 585 586

	/* We only dequeue private signals from ourselves, we don't let
	 * signalfd steal them
	 */
587
	signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer);
588
	if (!signr) {
L
Linus Torvalds 已提交
589
		signr = __dequeue_signal(&tsk->signal->shared_pending,
590
					 mask, info, &resched_timer);
591
#ifdef CONFIG_POSIX_TIMERS
592 593 594 595 596 597
		/*
		 * itimer signal ?
		 *
		 * itimers are process shared and we restart periodic
		 * itimers in the signal delivery path to prevent DoS
		 * attacks in the high resolution timer case. This is
598
		 * compliant with the old way of self-restarting
599 600 601 602 603 604 605 606 607 608
		 * itimers, as the SIGALRM is a legacy signal and only
		 * queued once. Changing the restart behaviour to
		 * restart the timer in the signal dequeue path is
		 * reducing the timer noise on heavy loaded !highres
		 * systems too.
		 */
		if (unlikely(signr == SIGALRM)) {
			struct hrtimer *tmr = &tsk->signal->real_timer;

			if (!hrtimer_is_queued(tmr) &&
T
Thomas Gleixner 已提交
609
			    tsk->signal->it_real_incr != 0) {
610 611 612 613 614
				hrtimer_forward(tmr, tmr->base->get_time(),
						tsk->signal->it_real_incr);
				hrtimer_restart(tmr);
			}
		}
615
#endif
616
	}
617

D
Davide Libenzi 已提交
618
	recalc_sigpending();
619 620 621 622
	if (!signr)
		return 0;

	if (unlikely(sig_kernel_stop(signr))) {
623 624 625 626 627 628 629 630 631 632 633 634
		/*
		 * Set a marker that we have dequeued a stop signal.  Our
		 * caller might release the siglock and then the pending
		 * stop signal it is about to process is no longer in the
		 * pending bitmasks, but must still be cleared by a SIGCONT
		 * (and overruled by a SIGKILL).  So those cases clear this
		 * shared flag after we've set it.  Note that this flag may
		 * remain set after the signal we return is ignored or
		 * handled.  That doesn't matter because its only purpose
		 * is to alert stop-signal processing code when another
		 * processor has come along and cleared the flag.
		 */
635
		current->jobctl |= JOBCTL_STOP_DEQUEUED;
636
	}
637
#ifdef CONFIG_POSIX_TIMERS
638
	if (resched_timer) {
L
Linus Torvalds 已提交
639 640 641 642 643 644 645
		/*
		 * Release the siglock to ensure proper locking order
		 * of timer locks outside of siglocks.  Note, we leave
		 * irqs disabled here, since the posix-timers code is
		 * about to disable them again anyway.
		 */
		spin_unlock(&tsk->sighand->siglock);
646
		posixtimer_rearm(info);
L
Linus Torvalds 已提交
647
		spin_lock(&tsk->sighand->siglock);
648 649 650

		/* Don't expose the si_sys_private value to userspace */
		info->si_sys_private = 0;
L
Linus Torvalds 已提交
651
	}
652
#endif
L
Linus Torvalds 已提交
653 654 655 656 657 658 659 660 661 662 663 664 665 666
	return signr;
}

/*
 * Tell a process that it has a new active signal..
 *
 * NOTE! we rely on the previous spin_lock to
 * lock interrupts for us! We can only be called with
 * "siglock" held, and the local interrupt must
 * have been disabled when that got acquired!
 *
 * No need to set need_resched since signal event passing
 * goes through ->blocked
 */
667
void signal_wake_up_state(struct task_struct *t, unsigned int state)
L
Linus Torvalds 已提交
668 669 670
{
	set_tsk_thread_flag(t, TIF_SIGPENDING);
	/*
671
	 * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
M
Matthew Wilcox 已提交
672
	 * case. We don't check t->state here because there is a race with it
L
Linus Torvalds 已提交
673 674 675 676
	 * executing another processor and just now entering stopped state.
	 * By using wake_up_state, we ensure the process will wake up and
	 * handle its death signal.
	 */
677
	if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
L
Linus Torvalds 已提交
678 679 680
		kick_process(t);
}

681 682 683 684 685 686
/*
 * Remove signals in mask from the pending set and queue.
 * Returns 1 if any signals were found.
 *
 * All callers must be holding the siglock.
 */
687
static int flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
688 689 690 691 692 693 694 695
{
	struct sigqueue *q, *n;
	sigset_t m;

	sigandsets(&m, mask, &s->signal);
	if (sigisemptyset(&m))
		return 0;

696
	sigandnsets(&s->signal, &s->signal, mask);
697 698 699 700 701 702 703 704
	list_for_each_entry_safe(q, n, &s->list, list) {
		if (sigismember(mask, q->info.si_signo)) {
			list_del_init(&q->list);
			__sigqueue_free(q);
		}
	}
	return 1;
}
L
Linus Torvalds 已提交
705

706 707 708 709 710 711 712 713 714 715 716
static inline int is_si_special(const struct siginfo *info)
{
	return info <= SEND_SIG_FORCED;
}

static inline bool si_fromuser(const struct siginfo *info)
{
	return info == SEND_SIG_NOINFO ||
		(!is_si_special(info) && SI_FROMUSER(info));
}

717 718 719
/*
 * called with RCU read lock from check_kill_permission()
 */
720
static bool kill_ok_by_cred(struct task_struct *t)
721 722 723 724
{
	const struct cred *cred = current_cred();
	const struct cred *tcred = __task_cred(t);

725 726 727 728 729
	return uid_eq(cred->euid, tcred->suid) ||
	       uid_eq(cred->euid, tcred->uid) ||
	       uid_eq(cred->uid, tcred->suid) ||
	       uid_eq(cred->uid, tcred->uid) ||
	       ns_capable(tcred->user_ns, CAP_KILL);
730 731
}

L
Linus Torvalds 已提交
732 733
/*
 * Bad permissions for sending the signal
734
 * - the caller must hold the RCU read lock
L
Linus Torvalds 已提交
735 736 737 738
 */
static int check_kill_permission(int sig, struct siginfo *info,
				 struct task_struct *t)
{
739
	struct pid *sid;
740 741
	int error;

742
	if (!valid_signal(sig))
743 744
		return -EINVAL;

745
	if (!si_fromuser(info))
746
		return 0;
A
Amy Griffis 已提交
747

748 749
	error = audit_signal_info(sig, t); /* Let audit system see the signal */
	if (error)
L
Linus Torvalds 已提交
750
		return error;
751

752
	if (!same_thread_group(current, t) &&
753
	    !kill_ok_by_cred(t)) {
754 755 756 757 758 759 760 761 762 763 764 765 766
		switch (sig) {
		case SIGCONT:
			sid = task_session(t);
			/*
			 * We don't return the error if sid == NULL. The
			 * task was unhashed, the caller must notice this.
			 */
			if (!sid || sid == task_session(current))
				break;
		default:
			return -EPERM;
		}
	}
767

768
	return security_task_kill(t, info, sig, NULL);
L
Linus Torvalds 已提交
769 770
}

771 772 773 774 775 776 777 778
/**
 * ptrace_trap_notify - schedule trap to notify ptracer
 * @t: tracee wanting to notify tracer
 *
 * This function schedules sticky ptrace trap which is cleared on the next
 * TRAP_STOP to notify ptracer of an event.  @t must have been seized by
 * ptracer.
 *
T
Tejun Heo 已提交
779 780 781 782 783
 * If @t is running, STOP trap will be taken.  If trapped for STOP and
 * ptracer is listening for events, tracee is woken up so that it can
 * re-trap for the new event.  If trapped otherwise, STOP trap will be
 * eventually taken without returning to userland after the existing traps
 * are finished by PTRACE_CONT.
784 785 786 787 788 789 790 791 792 793
 *
 * CONTEXT:
 * Must be called with @task->sighand->siglock held.
 */
static void ptrace_trap_notify(struct task_struct *t)
{
	WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
	assert_spin_locked(&t->sighand->siglock);

	task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
794
	ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
795 796
}

L
Linus Torvalds 已提交
797
/*
798 799
 * Handle magic process-wide effects of stop/continue signals. Unlike
 * the signal actions, these happen immediately at signal-generation
L
Linus Torvalds 已提交
800 801
 * time regardless of blocking, ignoring, or handling.  This does the
 * actual continuing for SIGCONT, but not the actual stopping for stop
802 803 804 805
 * signals. The process stop is done as a signal action for SIG_DFL.
 *
 * Returns true if the signal should be actually delivered, otherwise
 * it should be dropped.
L
Linus Torvalds 已提交
806
 */
807
static bool prepare_signal(int sig, struct task_struct *p, bool force)
L
Linus Torvalds 已提交
808
{
809
	struct signal_struct *signal = p->signal;
L
Linus Torvalds 已提交
810
	struct task_struct *t;
811
	sigset_t flush;
L
Linus Torvalds 已提交
812

813
	if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
814
		if (!(signal->flags & SIGNAL_GROUP_EXIT))
815
			return sig == SIGKILL;
L
Linus Torvalds 已提交
816
		/*
817
		 * The process is in the middle of dying, nothing to do.
L
Linus Torvalds 已提交
818
		 */
819
	} else if (sig_kernel_stop(sig)) {
L
Linus Torvalds 已提交
820 821 822
		/*
		 * This is a stop signal.  Remove SIGCONT from all queues.
		 */
823
		siginitset(&flush, sigmask(SIGCONT));
824
		flush_sigqueue_mask(&flush, &signal->shared_pending);
825
		for_each_thread(p, t)
826
			flush_sigqueue_mask(&flush, &t->pending);
L
Linus Torvalds 已提交
827
	} else if (sig == SIGCONT) {
828
		unsigned int why;
L
Linus Torvalds 已提交
829
		/*
830
		 * Remove all stop signals from all queues, wake all threads.
L
Linus Torvalds 已提交
831
		 */
832
		siginitset(&flush, SIG_KERNEL_STOP_MASK);
833
		flush_sigqueue_mask(&flush, &signal->shared_pending);
834
		for_each_thread(p, t) {
835
			flush_sigqueue_mask(&flush, &t->pending);
836
			task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
837 838 839 840
			if (likely(!(t->ptrace & PT_SEIZED)))
				wake_up_state(t, __TASK_STOPPED);
			else
				ptrace_trap_notify(t);
841
		}
L
Linus Torvalds 已提交
842

843 844 845 846 847 848 849 850 851
		/*
		 * Notify the parent with CLD_CONTINUED if we were stopped.
		 *
		 * If we were in the middle of a group stop, we pretend it
		 * was already finished, and then continued. Since SIGCHLD
		 * doesn't queue we report only CLD_STOPPED, as if the next
		 * CLD_CONTINUED was dropped.
		 */
		why = 0;
852
		if (signal->flags & SIGNAL_STOP_STOPPED)
853
			why |= SIGNAL_CLD_CONTINUED;
854
		else if (signal->group_stop_count)
855 856 857
			why |= SIGNAL_CLD_STOPPED;

		if (why) {
858
			/*
859
			 * The first thread which returns from do_signal_stop()
860 861 862
			 * will take ->siglock, notice SIGNAL_CLD_MASK, and
			 * notify its parent. See get_signal_to_deliver().
			 */
863
			signal_set_stop_flags(signal, why | SIGNAL_STOP_CONTINUED);
864 865
			signal->group_stop_count = 0;
			signal->group_exit_code = 0;
L
Linus Torvalds 已提交
866 867
		}
	}
868

869
	return !sig_ignored(p, sig, force);
L
Linus Torvalds 已提交
870 871
}

872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
/*
 * Test if P wants to take SIG.  After we've checked all threads with this,
 * it's equivalent to finding no threads not blocking SIG.  Any threads not
 * blocking SIG were ruled out because they are not running and already
 * have pending signals.  Such threads will dequeue from the shared queue
 * as soon as they're available, so putting the signal on the shared queue
 * will be equivalent to sending it to one such thread.
 */
static inline int wants_signal(int sig, struct task_struct *p)
{
	if (sigismember(&p->blocked, sig))
		return 0;
	if (p->flags & PF_EXITING)
		return 0;
	if (sig == SIGKILL)
		return 1;
	if (task_is_stopped_or_traced(p))
		return 0;
	return task_curr(p) || !signal_pending(p);
}

893
static void complete_signal(int sig, struct task_struct *p, int group)
894 895 896 897 898 899 900 901 902 903 904 905
{
	struct signal_struct *signal = p->signal;
	struct task_struct *t;

	/*
	 * Now find a thread we can wake up to take the signal off the queue.
	 *
	 * If the main thread wants the signal, it gets first crack.
	 * Probably the least surprising to the average bear.
	 */
	if (wants_signal(sig, p))
		t = p;
906
	else if (!group || thread_group_empty(p))
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933
		/*
		 * There is just one thread and it does not need to be woken.
		 * It will dequeue unblocked signals before it runs again.
		 */
		return;
	else {
		/*
		 * Otherwise try to find a suitable thread.
		 */
		t = signal->curr_target;
		while (!wants_signal(sig, t)) {
			t = next_thread(t);
			if (t == signal->curr_target)
				/*
				 * No thread needs to be woken.
				 * Any eligible threads will see
				 * the signal in the queue soon.
				 */
				return;
		}
		signal->curr_target = t;
	}

	/*
	 * Found a killable thread.  If the signal will be fatal,
	 * then start taking the whole group down immediately.
	 */
934
	if (sig_fatal(p, sig) &&
935
	    !(signal->flags & SIGNAL_GROUP_EXIT) &&
936
	    !sigismember(&t->real_blocked, sig) &&
937
	    (sig == SIGKILL || !p->ptrace)) {
938 939 940 941 942 943 944 945 946 947 948 949 950 951 952
		/*
		 * This signal will be fatal to the whole group.
		 */
		if (!sig_kernel_coredump(sig)) {
			/*
			 * Start a group exit and wake everybody up.
			 * This way we don't have other threads
			 * running and doing things after a slower
			 * thread has the fatal signal pending.
			 */
			signal->flags = SIGNAL_GROUP_EXIT;
			signal->group_exit_code = sig;
			signal->group_stop_count = 0;
			t = p;
			do {
953
				task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
954 955 956 957 958 959 960 961 962 963 964 965 966 967 968
				sigaddset(&t->pending.signal, SIGKILL);
				signal_wake_up(t, 1);
			} while_each_thread(p, t);
			return;
		}
	}

	/*
	 * The signal is already in the shared-pending queue.
	 * Tell the chosen thread to wake up and dequeue it.
	 */
	signal_wake_up(t, sig == SIGKILL);
	return;
}

969 970 971 972 973
static inline int legacy_queue(struct sigpending *signals, int sig)
{
	return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
}

974 975 976 977 978 979 980 981 982
#ifdef CONFIG_USER_NS
static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
{
	if (current_user_ns() == task_cred_xxx(t, user_ns))
		return;

	if (SI_FROMKERNEL(info))
		return;

983 984 985 986
	rcu_read_lock();
	info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
					make_kuid(current_user_ns(), info->si_uid));
	rcu_read_unlock();
987 988 989 990 991 992 993 994
}
#else
static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
{
	return;
}
#endif

995 996
static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
			int group, int from_ancestor_ns)
L
Linus Torvalds 已提交
997
{
998
	struct sigpending *pending;
999
	struct sigqueue *q;
1000
	int override_rlimit;
1001
	int ret = 0, result;
1002

1003
	assert_spin_locked(&t->sighand->siglock);
1004

1005
	result = TRACE_SIGNAL_IGNORED;
1006 1007
	if (!prepare_signal(sig, t,
			from_ancestor_ns || (info == SEND_SIG_FORCED)))
1008
		goto ret;
1009 1010

	pending = group ? &t->signal->shared_pending : &t->pending;
1011 1012 1013 1014 1015
	/*
	 * Short-circuit ignored signals and support queuing
	 * exactly one non-rt signal, so that we can get more
	 * detailed information about the cause of the signal.
	 */
1016
	result = TRACE_SIGNAL_ALREADY_PENDING;
1017
	if (legacy_queue(pending, sig))
1018 1019 1020
		goto ret;

	result = TRACE_SIGNAL_DELIVERED;
L
Linus Torvalds 已提交
1021 1022 1023 1024
	/*
	 * fast-pathed signals for kernel-internal things like SIGSTOP
	 * or SIGKILL.
	 */
1025
	if (info == SEND_SIG_FORCED)
L
Linus Torvalds 已提交
1026 1027
		goto out_set;

1028 1029 1030 1031 1032 1033 1034 1035 1036
	/*
	 * Real-time signals must be queued if sent by sigqueue, or
	 * some other real-time mechanism.  It is implementation
	 * defined whether kill() does so.  We attempt to do so, on
	 * the principle of least surprise, but since kill is not
	 * allowed to fail with EAGAIN when low on memory we just
	 * make sure at least one signal gets delivered and don't
	 * pass on the info struct.
	 */
1037 1038 1039 1040 1041
	if (sig < SIGRTMIN)
		override_rlimit = (is_si_special(info) || info->si_code >= 0);
	else
		override_rlimit = 0;

1042
	q = __sigqueue_alloc(sig, t, GFP_ATOMIC, override_rlimit);
L
Linus Torvalds 已提交
1043
	if (q) {
1044
		list_add_tail(&q->list, &pending->list);
L
Linus Torvalds 已提交
1045
		switch ((unsigned long) info) {
1046
		case (unsigned long) SEND_SIG_NOINFO:
1047
			clear_siginfo(&q->info);
L
Linus Torvalds 已提交
1048 1049 1050
			q->info.si_signo = sig;
			q->info.si_errno = 0;
			q->info.si_code = SI_USER;
1051
			q->info.si_pid = task_tgid_nr_ns(current,
1052
							task_active_pid_ns(t));
1053
			q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
L
Linus Torvalds 已提交
1054
			break;
1055
		case (unsigned long) SEND_SIG_PRIV:
1056
			clear_siginfo(&q->info);
L
Linus Torvalds 已提交
1057 1058 1059 1060 1061 1062 1063 1064
			q->info.si_signo = sig;
			q->info.si_errno = 0;
			q->info.si_code = SI_KERNEL;
			q->info.si_pid = 0;
			q->info.si_uid = 0;
			break;
		default:
			copy_siginfo(&q->info, info);
1065 1066
			if (from_ancestor_ns)
				q->info.si_pid = 0;
L
Linus Torvalds 已提交
1067 1068
			break;
		}
1069 1070 1071

		userns_fixup_signal_uid(&q->info, t);

1072
	} else if (!is_si_special(info)) {
1073 1074 1075 1076 1077 1078
		if (sig >= SIGRTMIN && info->si_code != SI_USER) {
			/*
			 * Queue overflow, abort.  We may abort if the
			 * signal was rt and sent by user using something
			 * other than kill().
			 */
1079 1080 1081
			result = TRACE_SIGNAL_OVERFLOW_FAIL;
			ret = -EAGAIN;
			goto ret;
1082 1083 1084 1085 1086
		} else {
			/*
			 * This is a silent loss of information.  We still
			 * send the signal, but the *info bits are lost.
			 */
1087
			result = TRACE_SIGNAL_LOSE_INFO;
1088
		}
L
Linus Torvalds 已提交
1089 1090 1091
	}

out_set:
1092
	signalfd_notify(t, sig);
1093
	sigaddset(&pending->signal, sig);
1094
	complete_signal(sig, t, group);
1095 1096 1097
ret:
	trace_signal_generate(sig, info, t, group, result);
	return ret;
L
Linus Torvalds 已提交
1098 1099
}

1100 1101 1102
static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
			int group)
{
1103 1104 1105
	int from_ancestor_ns = 0;

#ifdef CONFIG_PID_NS
1106 1107
	from_ancestor_ns = si_fromuser(info) &&
			   !task_pid_nr_ns(current, task_active_pid_ns(t));
1108 1109 1110
#endif

	return __send_signal(sig, info, t, group, from_ancestor_ns);
1111 1112
}

1113
static void print_fatal_signal(int signr)
I
Ingo Molnar 已提交
1114
{
1115
	struct pt_regs *regs = signal_pt_regs();
1116
	pr_info("potentially unexpected fatal signal %d.\n", signr);
I
Ingo Molnar 已提交
1117

A
Al Viro 已提交
1118
#if defined(__i386__) && !defined(__arch_um__)
1119
	pr_info("code at %08lx: ", regs->ip);
I
Ingo Molnar 已提交
1120 1121 1122 1123 1124
	{
		int i;
		for (i = 0; i < 16; i++) {
			unsigned char insn;

1125 1126
			if (get_user(insn, (unsigned char *)(regs->ip + i)))
				break;
1127
			pr_cont("%02x ", insn);
I
Ingo Molnar 已提交
1128 1129
		}
	}
1130
	pr_cont("\n");
I
Ingo Molnar 已提交
1131
#endif
1132
	preempt_disable();
I
Ingo Molnar 已提交
1133
	show_regs(regs);
1134
	preempt_enable();
I
Ingo Molnar 已提交
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
}

static int __init setup_print_fatal_signals(char *str)
{
	get_option (&str, &print_fatal_signals);

	return 1;
}

__setup("print-fatal-signals=", setup_print_fatal_signals);
L
Linus Torvalds 已提交
1145

1146 1147 1148 1149 1150 1151
int
__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
	return send_signal(sig, info, p, 1);
}

L
Linus Torvalds 已提交
1152 1153 1154
static int
specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
1155
	return send_signal(sig, info, t, 0);
L
Linus Torvalds 已提交
1156 1157
}

1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
			bool group)
{
	unsigned long flags;
	int ret = -ESRCH;

	if (lock_task_sighand(p, &flags)) {
		ret = send_signal(sig, info, p, group);
		unlock_task_sighand(p, &flags);
	}

	return ret;
}

L
Linus Torvalds 已提交
1172 1173 1174
/*
 * Force a signal that the process can't ignore: if necessary
 * we unblock the signal and change any SIG_IGN to SIG_DFL.
1175 1176 1177 1178 1179
 *
 * Note: If we unblock the signal, we always reset it to SIG_DFL,
 * since we do not want to have a signal handler that was blocked
 * be invoked when user space had explicitly blocked it.
 *
1180 1181
 * We don't want to have recursive SIGSEGV's etc, for example,
 * that is why we also clear SIGNAL_UNKILLABLE.
L
Linus Torvalds 已提交
1182 1183 1184 1185 1186
 */
int
force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
	unsigned long int flags;
1187 1188
	int ret, blocked, ignored;
	struct k_sigaction *action;
L
Linus Torvalds 已提交
1189 1190

	spin_lock_irqsave(&t->sighand->siglock, flags);
1191 1192 1193 1194 1195 1196 1197
	action = &t->sighand->action[sig-1];
	ignored = action->sa.sa_handler == SIG_IGN;
	blocked = sigismember(&t->blocked, sig);
	if (blocked || ignored) {
		action->sa.sa_handler = SIG_DFL;
		if (blocked) {
			sigdelset(&t->blocked, sig);
R
Roland McGrath 已提交
1198
			recalc_sigpending_and_wake(t);
1199
		}
L
Linus Torvalds 已提交
1200
	}
1201 1202 1203 1204 1205
	/*
	 * Don't clear SIGNAL_UNKILLABLE for traced tasks, users won't expect
	 * debugging to leave init killable.
	 */
	if (action->sa.sa_handler == SIG_DFL && !t->ptrace)
1206
		t->signal->flags &= ~SIGNAL_UNKILLABLE;
L
Linus Torvalds 已提交
1207 1208 1209 1210 1211 1212 1213 1214 1215
	ret = specific_send_sig_info(sig, info, t);
	spin_unlock_irqrestore(&t->sighand->siglock, flags);

	return ret;
}

/*
 * Nuke all other threads in the group.
 */
1216
int zap_other_threads(struct task_struct *p)
L
Linus Torvalds 已提交
1217
{
1218 1219
	struct task_struct *t = p;
	int count = 0;
L
Linus Torvalds 已提交
1220 1221 1222

	p->signal->group_stop_count = 0;

1223
	while_each_thread(p, t) {
1224
		task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1225 1226 1227
		count++;

		/* Don't bother with already dead threads */
L
Linus Torvalds 已提交
1228 1229 1230 1231 1232
		if (t->exit_state)
			continue;
		sigaddset(&t->pending.signal, SIGKILL);
		signal_wake_up(t, 1);
	}
1233 1234

	return count;
L
Linus Torvalds 已提交
1235 1236
}

1237 1238
struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
					   unsigned long *flags)
1239 1240 1241
{
	struct sighand_struct *sighand;

1242
	rcu_read_lock();
1243 1244
	for (;;) {
		sighand = rcu_dereference(tsk->sighand);
1245
		if (unlikely(sighand == NULL))
1246
			break;
1247

1248 1249
		/*
		 * This sighand can be already freed and even reused, but
1250
		 * we rely on SLAB_TYPESAFE_BY_RCU and sighand_ctor() which
1251 1252 1253 1254 1255 1256 1257 1258
		 * initializes ->siglock: this slab can't go away, it has
		 * the same object type, ->siglock can't be reinitialized.
		 *
		 * We need to ensure that tsk->sighand is still the same
		 * after we take the lock, we can race with de_thread() or
		 * __exit_signal(). In the latter case the next iteration
		 * must see ->sighand == NULL.
		 */
1259 1260
		spin_lock_irqsave(&sighand->siglock, *flags);
		if (likely(sighand == tsk->sighand))
1261
			break;
1262
		spin_unlock_irqrestore(&sighand->siglock, *flags);
1263
	}
1264
	rcu_read_unlock();
1265 1266 1267 1268

	return sighand;
}

1269 1270 1271
/*
 * send signal info to all the members of a group
 */
L
Linus Torvalds 已提交
1272 1273
int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
1274 1275 1276 1277 1278
	int ret;

	rcu_read_lock();
	ret = check_kill_permission(sig, info, p);
	rcu_read_unlock();
1279

1280 1281
	if (!ret && sig)
		ret = do_send_sig_info(sig, info, p, true);
L
Linus Torvalds 已提交
1282 1283 1284 1285 1286

	return ret;
}

/*
1287
 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
L
Linus Torvalds 已提交
1288
 * control characters do (^C, ^Z etc)
1289
 * - the caller must hold at least a readlock on tasklist_lock
L
Linus Torvalds 已提交
1290
 */
1291
int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
L
Linus Torvalds 已提交
1292 1293 1294 1295 1296 1297
{
	struct task_struct *p = NULL;
	int retval, success;

	success = 0;
	retval = -ESRCH;
1298
	do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
L
Linus Torvalds 已提交
1299 1300 1301
		int err = group_send_sig_info(sig, info, p);
		success |= !err;
		retval = err;
1302
	} while_each_pid_task(pgrp, PIDTYPE_PGID, p);
L
Linus Torvalds 已提交
1303 1304 1305
	return success ? 0 : retval;
}

1306
int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
L
Linus Torvalds 已提交
1307
{
1308
	int error = -ESRCH;
L
Linus Torvalds 已提交
1309 1310
	struct task_struct *p;

1311 1312 1313 1314 1315 1316 1317 1318
	for (;;) {
		rcu_read_lock();
		p = pid_task(pid, PIDTYPE_PID);
		if (p)
			error = group_send_sig_info(sig, info, p);
		rcu_read_unlock();
		if (likely(!p || error != -ESRCH))
			return error;
1319

1320 1321 1322 1323 1324 1325
		/*
		 * The task was unhashed in between, try again.  If it
		 * is dead, pid_task() will return NULL, if we race with
		 * de_thread() it will find the new leader.
		 */
	}
L
Linus Torvalds 已提交
1326 1327
}

1328
static int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1329 1330 1331
{
	int error;
	rcu_read_lock();
1332
	error = kill_pid_info(sig, info, find_vpid(pid));
1333 1334 1335 1336
	rcu_read_unlock();
	return error;
}

1337 1338
static inline bool kill_as_cred_perm(const struct cred *cred,
				     struct task_struct *target)
1339 1340
{
	const struct cred *pcred = __task_cred(target);
1341 1342 1343 1344 1345

	return uid_eq(cred->euid, pcred->suid) ||
	       uid_eq(cred->euid, pcred->uid) ||
	       uid_eq(cred->uid, pcred->suid) ||
	       uid_eq(cred->uid, pcred->uid);
1346 1347
}

1348
/* like kill_pid_info(), but doesn't use uid/euid of "current" */
1349
int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid,
1350
			 const struct cred *cred)
1351 1352 1353
{
	int ret = -EINVAL;
	struct task_struct *p;
1354
	unsigned long flags;
1355 1356 1357 1358

	if (!valid_signal(sig))
		return ret;

1359
	rcu_read_lock();
1360
	p = pid_task(pid, PIDTYPE_PID);
1361 1362 1363 1364
	if (!p) {
		ret = -ESRCH;
		goto out_unlock;
	}
1365
	if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
1366 1367 1368
		ret = -EPERM;
		goto out_unlock;
	}
1369
	ret = security_task_kill(p, info, sig, cred);
1370 1371
	if (ret)
		goto out_unlock;
1372 1373 1374 1375 1376 1377 1378

	if (sig) {
		if (lock_task_sighand(p, &flags)) {
			ret = __send_signal(sig, info, p, 1, 0);
			unlock_task_sighand(p, &flags);
		} else
			ret = -ESRCH;
1379 1380
	}
out_unlock:
1381
	rcu_read_unlock();
1382 1383
	return ret;
}
1384
EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
L
Linus Torvalds 已提交
1385 1386 1387 1388 1389 1390 1391 1392

/*
 * kill_something_info() interprets pid in interesting ways just like kill(2).
 *
 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
 * is probably wrong.  Should make it like BSD or SYSV.
 */

1393
static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
L
Linus Torvalds 已提交
1394
{
1395
	int ret;
1396 1397 1398 1399 1400 1401 1402 1403

	if (pid > 0) {
		rcu_read_lock();
		ret = kill_pid_info(sig, info, find_vpid(pid));
		rcu_read_unlock();
		return ret;
	}

1404 1405 1406 1407
	/* -INT_MIN is undefined.  Exclude this case to avoid a UBSAN warning */
	if (pid == INT_MIN)
		return -ESRCH;

1408 1409 1410 1411 1412
	read_lock(&tasklist_lock);
	if (pid != -1) {
		ret = __kill_pgrp_info(sig, info,
				pid ? find_vpid(-pid) : task_pgrp(current));
	} else {
L
Linus Torvalds 已提交
1413 1414 1415 1416
		int retval = 0, count = 0;
		struct task_struct * p;

		for_each_process(p) {
1417 1418
			if (task_pid_vnr(p) > 1 &&
					!same_thread_group(p, current)) {
L
Linus Torvalds 已提交
1419 1420 1421 1422 1423 1424
				int err = group_send_sig_info(sig, info, p);
				++count;
				if (err != -EPERM)
					retval = err;
			}
		}
1425
		ret = count ? retval : -ESRCH;
L
Linus Torvalds 已提交
1426
	}
1427 1428
	read_unlock(&tasklist_lock);

1429
	return ret;
L
Linus Torvalds 已提交
1430 1431 1432 1433 1434 1435
}

/*
 * These are for backward compatibility with the rest of the kernel source.
 */

1436
int send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
L
Linus Torvalds 已提交
1437 1438 1439 1440 1441
{
	/*
	 * Make sure legacy kernel users don't send in bad values
	 * (normal paths check this in check_kill_permission).
	 */
1442
	if (!valid_signal(sig))
L
Linus Torvalds 已提交
1443 1444
		return -EINVAL;

1445
	return do_send_sig_info(sig, info, p, false);
L
Linus Torvalds 已提交
1446 1447
}

1448 1449 1450
#define __si_special(priv) \
	((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)

L
Linus Torvalds 已提交
1451 1452 1453
int
send_sig(int sig, struct task_struct *p, int priv)
{
1454
	return send_sig_info(sig, __si_special(priv), p);
L
Linus Torvalds 已提交
1455 1456
}

1457
void force_sig(int sig, struct task_struct *p)
L
Linus Torvalds 已提交
1458
{
1459
	force_sig_info(sig, SEND_SIG_PRIV, p);
L
Linus Torvalds 已提交
1460 1461 1462 1463 1464 1465 1466 1467
}

/*
 * When things go south during signal handling, we
 * will force a SIGSEGV. And if the signal that caused
 * the problem was already a SIGSEGV, we'll want to
 * make sure we don't even try to deliver the signal..
 */
1468
void force_sigsegv(int sig, struct task_struct *p)
L
Linus Torvalds 已提交
1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
{
	if (sig == SIGSEGV) {
		unsigned long flags;
		spin_lock_irqsave(&p->sighand->siglock, flags);
		p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
		spin_unlock_irqrestore(&p->sighand->siglock, flags);
	}
	force_sig(SIGSEGV, p);
}

1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524
int force_sig_fault(int sig, int code, void __user *addr
	___ARCH_SI_TRAPNO(int trapno)
	___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
	, struct task_struct *t)
{
	struct siginfo info;

	clear_siginfo(&info);
	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code  = code;
	info.si_addr  = addr;
#ifdef __ARCH_SI_TRAPNO
	info.si_trapno = trapno;
#endif
#ifdef __ia64__
	info.si_imm = imm;
	info.si_flags = flags;
	info.si_isr = isr;
#endif
	return force_sig_info(info.si_signo, &info, t);
}

int send_sig_fault(int sig, int code, void __user *addr
	___ARCH_SI_TRAPNO(int trapno)
	___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
	, struct task_struct *t)
{
	struct siginfo info;

	clear_siginfo(&info);
	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code  = code;
	info.si_addr  = addr;
#ifdef __ARCH_SI_TRAPNO
	info.si_trapno = trapno;
#endif
#ifdef __ia64__
	info.si_imm = imm;
	info.si_flags = flags;
	info.si_isr = isr;
#endif
	return send_sig_info(info.si_signo, &info, t);
}

1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581
int force_sig_mceerr(int code, void __user *addr, short lsb, struct task_struct *t)
{
	struct siginfo info;

	WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
	clear_siginfo(&info);
	info.si_signo = SIGBUS;
	info.si_errno = 0;
	info.si_code = code;
	info.si_addr = addr;
	info.si_addr_lsb = lsb;
	return force_sig_info(info.si_signo, &info, t);
}

int send_sig_mceerr(int code, void __user *addr, short lsb, struct task_struct *t)
{
	struct siginfo info;

	WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
	clear_siginfo(&info);
	info.si_signo = SIGBUS;
	info.si_errno = 0;
	info.si_code = code;
	info.si_addr = addr;
	info.si_addr_lsb = lsb;
	return send_sig_info(info.si_signo, &info, t);
}
EXPORT_SYMBOL(send_sig_mceerr);

int force_sig_bnderr(void __user *addr, void __user *lower, void __user *upper)
{
	struct siginfo info;

	clear_siginfo(&info);
	info.si_signo = SIGSEGV;
	info.si_errno = 0;
	info.si_code  = SEGV_BNDERR;
	info.si_addr  = addr;
	info.si_lower = lower;
	info.si_upper = upper;
	return force_sig_info(info.si_signo, &info, current);
}

#ifdef SEGV_PKUERR
int force_sig_pkuerr(void __user *addr, u32 pkey)
{
	struct siginfo info;

	clear_siginfo(&info);
	info.si_signo = SIGSEGV;
	info.si_errno = 0;
	info.si_code  = SEGV_PKUERR;
	info.si_addr  = addr;
	info.si_pkey  = pkey;
	return force_sig_info(info.si_signo, &info, current);
}
#endif
1582

1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597
/* For the crazy architectures that include trap information in
 * the errno field, instead of an actual errno value.
 */
int force_sig_ptrace_errno_trap(int errno, void __user *addr)
{
	struct siginfo info;

	clear_siginfo(&info);
	info.si_signo = SIGTRAP;
	info.si_errno = errno;
	info.si_code  = TRAP_HWBKPT;
	info.si_addr  = addr;
	return force_sig_info(info.si_signo, &info, current);
}

1598 1599
int kill_pgrp(struct pid *pid, int sig, int priv)
{
1600 1601 1602 1603 1604 1605 1606
	int ret;

	read_lock(&tasklist_lock);
	ret = __kill_pgrp_info(sig, __si_special(priv), pid);
	read_unlock(&tasklist_lock);

	return ret;
1607 1608 1609 1610 1611 1612 1613 1614 1615
}
EXPORT_SYMBOL(kill_pgrp);

int kill_pid(struct pid *pid, int sig, int priv)
{
	return kill_pid_info(sig, __si_special(priv), pid);
}
EXPORT_SYMBOL(kill_pid);

L
Linus Torvalds 已提交
1616 1617 1618 1619
/*
 * These functions support sending signals using preallocated sigqueue
 * structures.  This is needed "because realtime applications cannot
 * afford to lose notifications of asynchronous events, like timer
1620
 * expirations or I/O completions".  In the case of POSIX Timers
L
Linus Torvalds 已提交
1621 1622 1623 1624 1625 1626
 * we allocate the sigqueue structure from the timer_create.  If this
 * allocation fails we are able to report the failure to the application
 * with an EAGAIN error.
 */
struct sigqueue *sigqueue_alloc(void)
{
1627
	struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
L
Linus Torvalds 已提交
1628

1629
	if (q)
L
Linus Torvalds 已提交
1630
		q->flags |= SIGQUEUE_PREALLOC;
1631 1632

	return q;
L
Linus Torvalds 已提交
1633 1634 1635 1636 1637
}

void sigqueue_free(struct sigqueue *q)
{
	unsigned long flags;
1638 1639
	spinlock_t *lock = &current->sighand->siglock;

L
Linus Torvalds 已提交
1640 1641
	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
	/*
1642 1643
	 * We must hold ->siglock while testing q->list
	 * to serialize with collect_signal() or with
1644
	 * __exit_signal()->flush_sigqueue().
L
Linus Torvalds 已提交
1645
	 */
1646
	spin_lock_irqsave(lock, flags);
1647 1648 1649 1650 1651
	q->flags &= ~SIGQUEUE_PREALLOC;
	/*
	 * If it is queued it will be freed when dequeued,
	 * like the "regular" sigqueue.
	 */
1652
	if (!list_empty(&q->list))
1653
		q = NULL;
1654 1655
	spin_unlock_irqrestore(lock, flags);

1656 1657
	if (q)
		__sigqueue_free(q);
L
Linus Torvalds 已提交
1658 1659
}

1660
int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1661
{
1662
	int sig = q->info.si_signo;
1663
	struct sigpending *pending;
1664
	unsigned long flags;
1665
	int ret, result;
1666

1667
	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1668 1669 1670 1671 1672

	ret = -1;
	if (!likely(lock_task_sighand(t, &flags)))
		goto ret;

1673
	ret = 1; /* the signal is ignored */
1674
	result = TRACE_SIGNAL_IGNORED;
1675
	if (!prepare_signal(sig, t, false))
1676 1677 1678
		goto out;

	ret = 0;
1679 1680 1681 1682 1683 1684 1685
	if (unlikely(!list_empty(&q->list))) {
		/*
		 * If an SI_TIMER entry is already queue just increment
		 * the overrun count.
		 */
		BUG_ON(q->info.si_code != SI_TIMER);
		q->info.si_overrun++;
1686
		result = TRACE_SIGNAL_ALREADY_PENDING;
1687
		goto out;
1688
	}
1689
	q->info.si_overrun = 0;
1690 1691

	signalfd_notify(t, sig);
1692
	pending = group ? &t->signal->shared_pending : &t->pending;
1693 1694
	list_add_tail(&q->list, &pending->list);
	sigaddset(&pending->signal, sig);
1695
	complete_signal(sig, t, group);
1696
	result = TRACE_SIGNAL_DELIVERED;
1697
out:
1698
	trace_signal_generate(sig, &q->info, t, group, result);
1699 1700 1701
	unlock_task_sighand(t, &flags);
ret:
	return ret;
1702 1703
}

L
Linus Torvalds 已提交
1704 1705 1706
/*
 * Let a parent know about the death of a child.
 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
R
Roland McGrath 已提交
1707
 *
1708 1709
 * Returns true if our parent ignored us and so we've switched to
 * self-reaping.
L
Linus Torvalds 已提交
1710
 */
1711
bool do_notify_parent(struct task_struct *tsk, int sig)
L
Linus Torvalds 已提交
1712 1713 1714 1715
{
	struct siginfo info;
	unsigned long flags;
	struct sighand_struct *psig;
1716
	bool autoreap = false;
1717
	u64 utime, stime;
L
Linus Torvalds 已提交
1718 1719 1720 1721

	BUG_ON(sig == -1);

 	/* do_notify_parent_cldstop should have been called instead.  */
M
Matthew Wilcox 已提交
1722
 	BUG_ON(task_is_stopped_or_traced(tsk));
L
Linus Torvalds 已提交
1723

T
Tejun Heo 已提交
1724
	BUG_ON(!tsk->ptrace &&
L
Linus Torvalds 已提交
1725 1726
	       (tsk->group_leader != tsk || !thread_group_empty(tsk)));

1727 1728 1729 1730 1731 1732 1733 1734 1735
	if (sig != SIGCHLD) {
		/*
		 * This is only possible if parent == real_parent.
		 * Check if it has changed security domain.
		 */
		if (tsk->parent_exec_id != tsk->parent->self_exec_id)
			sig = SIGCHLD;
	}

1736
	clear_siginfo(&info);
L
Linus Torvalds 已提交
1737 1738
	info.si_signo = sig;
	info.si_errno = 0;
1739
	/*
1740 1741
	 * We are under tasklist_lock here so our parent is tied to
	 * us and cannot change.
1742
	 *
1743 1744
	 * task_active_pid_ns will always return the same pid namespace
	 * until a task passes through release_task.
1745 1746 1747 1748 1749 1750
	 *
	 * write_lock() currently calls preempt_disable() which is the
	 * same as rcu_read_lock(), but according to Oleg, this is not
	 * correct to rely on this
	 */
	rcu_read_lock();
1751
	info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1752 1753
	info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
				       task_uid(tsk));
1754 1755
	rcu_read_unlock();

1756 1757 1758
	task_cputime(tsk, &utime, &stime);
	info.si_utime = nsec_to_clock_t(utime + tsk->signal->utime);
	info.si_stime = nsec_to_clock_t(stime + tsk->signal->stime);
L
Linus Torvalds 已提交
1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771

	info.si_status = tsk->exit_code & 0x7f;
	if (tsk->exit_code & 0x80)
		info.si_code = CLD_DUMPED;
	else if (tsk->exit_code & 0x7f)
		info.si_code = CLD_KILLED;
	else {
		info.si_code = CLD_EXITED;
		info.si_status = tsk->exit_code >> 8;
	}

	psig = tsk->parent->sighand;
	spin_lock_irqsave(&psig->siglock, flags);
T
Tejun Heo 已提交
1772
	if (!tsk->ptrace && sig == SIGCHLD &&
L
Linus Torvalds 已提交
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789
	    (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
	     (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
		/*
		 * We are exiting and our parent doesn't care.  POSIX.1
		 * defines special semantics for setting SIGCHLD to SIG_IGN
		 * or setting the SA_NOCLDWAIT flag: we should be reaped
		 * automatically and not left for our parent's wait4 call.
		 * Rather than having the parent do it as a magic kind of
		 * signal handler, we just set this to tell do_exit that we
		 * can be cleaned up without becoming a zombie.  Note that
		 * we still call __wake_up_parent in this case, because a
		 * blocked sys_wait4 might now return -ECHILD.
		 *
		 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
		 * is implementation-defined: we do (if you don't want
		 * it, just use SIG_IGN instead).
		 */
1790
		autoreap = true;
L
Linus Torvalds 已提交
1791
		if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1792
			sig = 0;
L
Linus Torvalds 已提交
1793
	}
1794
	if (valid_signal(sig) && sig)
L
Linus Torvalds 已提交
1795 1796 1797
		__group_send_sig_info(sig, &info, tsk->parent);
	__wake_up_parent(tsk, tsk->parent);
	spin_unlock_irqrestore(&psig->siglock, flags);
R
Roland McGrath 已提交
1798

1799
	return autoreap;
L
Linus Torvalds 已提交
1800 1801
}

1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816
/**
 * do_notify_parent_cldstop - notify parent of stopped/continued state change
 * @tsk: task reporting the state change
 * @for_ptracer: the notification is for ptracer
 * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
 *
 * Notify @tsk's parent that the stopped/continued state has changed.  If
 * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
 * If %true, @tsk reports to @tsk->parent which should be the ptracer.
 *
 * CONTEXT:
 * Must be called with tasklist_lock at least read locked.
 */
static void do_notify_parent_cldstop(struct task_struct *tsk,
				     bool for_ptracer, int why)
L
Linus Torvalds 已提交
1817 1818 1819
{
	struct siginfo info;
	unsigned long flags;
1820
	struct task_struct *parent;
L
Linus Torvalds 已提交
1821
	struct sighand_struct *sighand;
1822
	u64 utime, stime;
L
Linus Torvalds 已提交
1823

1824
	if (for_ptracer) {
1825
		parent = tsk->parent;
1826
	} else {
1827 1828 1829 1830
		tsk = tsk->group_leader;
		parent = tsk->real_parent;
	}

1831
	clear_siginfo(&info);
L
Linus Torvalds 已提交
1832 1833
	info.si_signo = SIGCHLD;
	info.si_errno = 0;
1834
	/*
1835
	 * see comment in do_notify_parent() about the following 4 lines
1836 1837
	 */
	rcu_read_lock();
1838
	info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
1839
	info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
1840 1841
	rcu_read_unlock();

1842 1843 1844
	task_cputime(tsk, &utime, &stime);
	info.si_utime = nsec_to_clock_t(utime);
	info.si_stime = nsec_to_clock_t(stime);
L
Linus Torvalds 已提交
1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872

 	info.si_code = why;
 	switch (why) {
 	case CLD_CONTINUED:
 		info.si_status = SIGCONT;
 		break;
 	case CLD_STOPPED:
 		info.si_status = tsk->signal->group_exit_code & 0x7f;
 		break;
 	case CLD_TRAPPED:
 		info.si_status = tsk->exit_code & 0x7f;
 		break;
 	default:
 		BUG();
 	}

	sighand = parent->sighand;
	spin_lock_irqsave(&sighand->siglock, flags);
	if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
	    !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
		__group_send_sig_info(SIGCHLD, &info, parent);
	/*
	 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
	 */
	__wake_up_parent(tsk, parent);
	spin_unlock_irqrestore(&sighand->siglock, flags);
}

1873
static inline bool may_ptrace_stop(void)
1874
{
T
Tejun Heo 已提交
1875
	if (!likely(current->ptrace))
1876
		return false;
1877 1878 1879 1880 1881 1882
	/*
	 * Are we in the middle of do_coredump?
	 * If so and our tracer is also part of the coredump stopping
	 * is a deadlock situation, and pointless because our tracer
	 * is dead so don't allow us to stop.
	 * If SIGKILL was already sent before the caller unlocked
1883
	 * ->siglock we must see ->core_state != NULL. Otherwise it
1884
	 * is safe to enter schedule().
1885 1886 1887 1888
	 *
	 * This is almost outdated, a task with the pending SIGKILL can't
	 * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported
	 * after SIGKILL was already dequeued.
1889
	 */
1890
	if (unlikely(current->mm->core_state) &&
1891
	    unlikely(current->mm == current->parent->mm))
1892
		return false;
1893

1894
	return true;
1895 1896
}

R
Roland McGrath 已提交
1897
/*
1898
 * Return non-zero if there is a SIGKILL that should be waking us up.
R
Roland McGrath 已提交
1899 1900 1901 1902
 * Called with the siglock held.
 */
static int sigkill_pending(struct task_struct *tsk)
{
1903 1904
	return	sigismember(&tsk->pending.signal, SIGKILL) ||
		sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
R
Roland McGrath 已提交
1905 1906
}

L
Linus Torvalds 已提交
1907 1908 1909 1910 1911 1912 1913 1914
/*
 * This must be called with current->sighand->siglock held.
 *
 * This should be the path for all ptrace stops.
 * We always set current->last_siginfo while stopped here.
 * That makes it a way to test a stopped process for
 * being ptrace-stopped vs being job-control-stopped.
 *
1915 1916
 * If we actually decide not to stop at all because the tracer
 * is gone, we keep current->exit_code unless clear_code.
L
Linus Torvalds 已提交
1917
 */
T
Tejun Heo 已提交
1918
static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
1919 1920
	__releases(&current->sighand->siglock)
	__acquires(&current->sighand->siglock)
L
Linus Torvalds 已提交
1921
{
1922 1923
	bool gstop_done = false;

R
Roland McGrath 已提交
1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938
	if (arch_ptrace_stop_needed(exit_code, info)) {
		/*
		 * The arch code has something special to do before a
		 * ptrace stop.  This is allowed to block, e.g. for faults
		 * on user stack pages.  We can't keep the siglock while
		 * calling arch_ptrace_stop, so we must release it now.
		 * To preserve proper semantics, we must do this before
		 * any signal bookkeeping like checking group_stop_count.
		 * Meanwhile, a SIGKILL could come in before we retake the
		 * siglock.  That must prevent us from sleeping in TASK_TRACED.
		 * So after regaining the lock, we must check for SIGKILL.
		 */
		spin_unlock_irq(&current->sighand->siglock);
		arch_ptrace_stop(exit_code, info);
		spin_lock_irq(&current->sighand->siglock);
1939 1940
		if (sigkill_pending(current))
			return;
R
Roland McGrath 已提交
1941 1942
	}

1943 1944
	set_special_state(TASK_TRACED);

L
Linus Torvalds 已提交
1945
	/*
1946 1947 1948 1949 1950
	 * We're committing to trapping.  TRACED should be visible before
	 * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
	 * Also, transition to TRACED and updates to ->jobctl should be
	 * atomic with respect to siglock and should be done after the arch
	 * hook as siglock is released and regrabbed across it.
1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961
	 *
	 *     TRACER				    TRACEE
	 *
	 *     ptrace_attach()
	 * [L]   wait_on_bit(JOBCTL_TRAPPING)	[S] set_special_state(TRACED)
	 *     do_wait()
	 *       set_current_state()                smp_wmb();
	 *       ptrace_do_wait()
	 *         wait_task_stopped()
	 *           task_stopped_code()
	 * [L]         task_is_traced()		[S] task_clear_jobctl_trapping();
L
Linus Torvalds 已提交
1962
	 */
1963
	smp_wmb();
L
Linus Torvalds 已提交
1964 1965 1966 1967

	current->last_siginfo = info;
	current->exit_code = exit_code;

1968
	/*
1969 1970
	 * If @why is CLD_STOPPED, we're trapping to participate in a group
	 * stop.  Do the bookkeeping.  Note that if SIGCONT was delievered
1971 1972 1973
	 * across siglock relocks since INTERRUPT was scheduled, PENDING
	 * could be clear now.  We act as if SIGCONT is received after
	 * TASK_TRACED is entered - ignore it.
1974
	 */
1975
	if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
1976
		gstop_done = task_participate_group_stop(current);
1977

1978
	/* any trap clears pending STOP trap, STOP trap clears NOTIFY */
1979
	task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
1980 1981
	if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
		task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
1982

1983
	/* entering a trap, clear TRAPPING */
1984
	task_clear_jobctl_trapping(current);
1985

L
Linus Torvalds 已提交
1986 1987
	spin_unlock_irq(&current->sighand->siglock);
	read_lock(&tasklist_lock);
1988
	if (may_ptrace_stop()) {
1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999
		/*
		 * Notify parents of the stop.
		 *
		 * While ptraced, there are two parents - the ptracer and
		 * the real_parent of the group_leader.  The ptracer should
		 * know about every stop while the real parent is only
		 * interested in the completion of group stop.  The states
		 * for the two don't interact with each other.  Notify
		 * separately unless they're gonna be duplicates.
		 */
		do_notify_parent_cldstop(current, true, why);
2000
		if (gstop_done && ptrace_reparented(current))
2001 2002
			do_notify_parent_cldstop(current, false, why);

M
Miklos Szeredi 已提交
2003 2004 2005 2006 2007 2008 2009
		/*
		 * Don't want to allow preemption here, because
		 * sys_ptrace() needs this task to be inactive.
		 *
		 * XXX: implement read_unlock_no_resched().
		 */
		preempt_disable();
L
Linus Torvalds 已提交
2010
		read_unlock(&tasklist_lock);
M
Miklos Szeredi 已提交
2011
		preempt_enable_no_resched();
2012
		freezable_schedule();
L
Linus Torvalds 已提交
2013 2014 2015
	} else {
		/*
		 * By the time we got the lock, our tracer went away.
2016
		 * Don't drop the lock yet, another tracer may come.
2017 2018 2019
		 *
		 * If @gstop_done, the ptracer went away between group stop
		 * completion and here.  During detach, it would have set
2020 2021 2022
		 * JOBCTL_STOP_PENDING on us and we'll re-enter
		 * TASK_STOPPED in do_signal_stop() on return, so notifying
		 * the real parent of the group stop completion is enough.
L
Linus Torvalds 已提交
2023
		 */
2024 2025 2026
		if (gstop_done)
			do_notify_parent_cldstop(current, false, why);

2027
		/* tasklist protects us from ptrace_freeze_traced() */
2028
		__set_current_state(TASK_RUNNING);
2029 2030
		if (clear_code)
			current->exit_code = 0;
2031
		read_unlock(&tasklist_lock);
L
Linus Torvalds 已提交
2032 2033 2034 2035 2036 2037 2038 2039 2040 2041
	}

	/*
	 * We are back.  Now reacquire the siglock before touching
	 * last_siginfo, so that we are sure to have synchronized with
	 * any signal-sending on another CPU that wants to examine it.
	 */
	spin_lock_irq(&current->sighand->siglock);
	current->last_siginfo = NULL;

T
Tejun Heo 已提交
2042 2043 2044
	/* LISTENING can be set only during STOP traps, clear it */
	current->jobctl &= ~JOBCTL_LISTENING;

L
Linus Torvalds 已提交
2045 2046 2047
	/*
	 * Queued signals ignored us while we were stopped for tracing.
	 * So check for any that we should take before resuming user mode.
2048
	 * This sets TIF_SIGPENDING, but never clears it.
L
Linus Torvalds 已提交
2049
	 */
2050
	recalc_sigpending_tsk(current);
L
Linus Torvalds 已提交
2051 2052
}

T
Tejun Heo 已提交
2053
static void ptrace_do_notify(int signr, int exit_code, int why)
L
Linus Torvalds 已提交
2054 2055 2056
{
	siginfo_t info;

2057
	clear_siginfo(&info);
T
Tejun Heo 已提交
2058
	info.si_signo = signr;
L
Linus Torvalds 已提交
2059
	info.si_code = exit_code;
2060
	info.si_pid = task_pid_vnr(current);
2061
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
L
Linus Torvalds 已提交
2062 2063

	/* Let the debugger run.  */
T
Tejun Heo 已提交
2064 2065 2066 2067 2068 2069
	ptrace_stop(exit_code, why, 1, &info);
}

void ptrace_notify(int exit_code)
{
	BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
2070 2071
	if (unlikely(current->task_works))
		task_work_run();
T
Tejun Heo 已提交
2072

L
Linus Torvalds 已提交
2073
	spin_lock_irq(&current->sighand->siglock);
T
Tejun Heo 已提交
2074
	ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
L
Linus Torvalds 已提交
2075 2076 2077
	spin_unlock_irq(&current->sighand->siglock);
}

2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098
/**
 * do_signal_stop - handle group stop for SIGSTOP and other stop signals
 * @signr: signr causing group stop if initiating
 *
 * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
 * and participate in it.  If already set, participate in the existing
 * group stop.  If participated in a group stop (and thus slept), %true is
 * returned with siglock released.
 *
 * If ptraced, this function doesn't handle stop itself.  Instead,
 * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
 * untouched.  The caller must ensure that INTERRUPT trap handling takes
 * places afterwards.
 *
 * CONTEXT:
 * Must be called with @current->sighand->siglock held, which is released
 * on %true return.
 *
 * RETURNS:
 * %false if group stop is already cancelled or ptrace trap is scheduled.
 * %true if participated in group stop.
L
Linus Torvalds 已提交
2099
 */
2100 2101
static bool do_signal_stop(int signr)
	__releases(&current->sighand->siglock)
L
Linus Torvalds 已提交
2102 2103 2104
{
	struct signal_struct *sig = current->signal;

2105
	if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
2106
		unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
2107 2108
		struct task_struct *t;

2109 2110
		/* signr will be recorded in task->jobctl for retries */
		WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
2111

2112
		if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
2113
		    unlikely(signal_group_exit(sig)))
2114
			return false;
L
Linus Torvalds 已提交
2115
		/*
2116 2117 2118 2119 2120 2121 2122
		 * There is no group stop already in progress.  We must
		 * initiate one now.
		 *
		 * While ptraced, a task may be resumed while group stop is
		 * still in effect and then receive a stop signal and
		 * initiate another group stop.  This deviates from the
		 * usual behavior as two consecutive stop signals can't
2123 2124
		 * cause two group stops when !ptraced.  That is why we
		 * also check !task_is_stopped(t) below.
2125 2126 2127 2128 2129 2130 2131 2132
		 *
		 * The condition can be distinguished by testing whether
		 * SIGNAL_STOP_STOPPED is already set.  Don't generate
		 * group_exit_code in such case.
		 *
		 * This is not necessary for SIGNAL_STOP_CONTINUED because
		 * an intervening stop signal is required to cause two
		 * continued events regardless of ptrace.
L
Linus Torvalds 已提交
2133
		 */
2134 2135
		if (!(sig->flags & SIGNAL_STOP_STOPPED))
			sig->group_exit_code = signr;
L
Linus Torvalds 已提交
2136

2137 2138 2139 2140
		sig->group_stop_count = 0;

		if (task_set_jobctl_pending(current, signr | gstop))
			sig->group_stop_count++;
L
Linus Torvalds 已提交
2141

2142 2143
		t = current;
		while_each_thread(current, t) {
L
Linus Torvalds 已提交
2144
			/*
2145 2146 2147
			 * Setting state to TASK_STOPPED for a group
			 * stop is always done with the siglock held,
			 * so this check has no races.
L
Linus Torvalds 已提交
2148
			 */
2149 2150
			if (!task_is_stopped(t) &&
			    task_set_jobctl_pending(t, signr | gstop)) {
2151
				sig->group_stop_count++;
2152 2153 2154 2155
				if (likely(!(t->ptrace & PT_SEIZED)))
					signal_wake_up(t, 0);
				else
					ptrace_trap_notify(t);
2156
			}
2157
		}
L
Linus Torvalds 已提交
2158
	}
2159

T
Tejun Heo 已提交
2160
	if (likely(!current->ptrace)) {
2161
		int notify = 0;
L
Linus Torvalds 已提交
2162

2163 2164 2165 2166 2167 2168 2169 2170
		/*
		 * If there are no other threads in the group, or if there
		 * is a group stop in progress and we are the last to stop,
		 * report to the parent.
		 */
		if (task_participate_group_stop(current))
			notify = CLD_STOPPED;

2171
		set_special_state(TASK_STOPPED);
2172 2173
		spin_unlock_irq(&current->sighand->siglock);

2174 2175 2176 2177 2178 2179 2180 2181 2182
		/*
		 * Notify the parent of the group stop completion.  Because
		 * we're not holding either the siglock or tasklist_lock
		 * here, ptracer may attach inbetween; however, this is for
		 * group stop and should always be delivered to the real
		 * parent of the group leader.  The new ptracer will get
		 * its notification when this task transitions into
		 * TASK_TRACED.
		 */
2183 2184
		if (notify) {
			read_lock(&tasklist_lock);
2185
			do_notify_parent_cldstop(current, false, notify);
2186 2187 2188 2189
			read_unlock(&tasklist_lock);
		}

		/* Now we don't run again until woken by SIGCONT or SIGKILL */
2190
		freezable_schedule();
2191
		return true;
2192
	} else {
2193 2194 2195 2196 2197 2198
		/*
		 * While ptraced, group stop is handled by STOP trap.
		 * Schedule it and let the caller deal with it.
		 */
		task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
		return false;
2199
	}
2200
}
L
Linus Torvalds 已提交
2201

2202 2203 2204
/**
 * do_jobctl_trap - take care of ptrace jobctl traps
 *
T
Tejun Heo 已提交
2205 2206 2207 2208 2209 2210 2211
 * When PT_SEIZED, it's used for both group stop and explicit
 * SEIZE/INTERRUPT traps.  Both generate PTRACE_EVENT_STOP trap with
 * accompanying siginfo.  If stopped, lower eight bits of exit_code contain
 * the stop signal; otherwise, %SIGTRAP.
 *
 * When !PT_SEIZED, it's used only for group stop trap with stop signal
 * number as exit_code and no siginfo.
2212 2213 2214 2215 2216 2217 2218
 *
 * CONTEXT:
 * Must be called with @current->sighand->siglock held, which may be
 * released and re-acquired before returning with intervening sleep.
 */
static void do_jobctl_trap(void)
{
T
Tejun Heo 已提交
2219
	struct signal_struct *signal = current->signal;
2220
	int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2221

T
Tejun Heo 已提交
2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232
	if (current->ptrace & PT_SEIZED) {
		if (!signal->group_stop_count &&
		    !(signal->flags & SIGNAL_STOP_STOPPED))
			signr = SIGTRAP;
		WARN_ON_ONCE(!signr);
		ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
				 CLD_STOPPED);
	} else {
		WARN_ON_ONCE(!signr);
		ptrace_stop(signr, CLD_STOPPED, 0, NULL);
		current->exit_code = 0;
2233
	}
L
Linus Torvalds 已提交
2234 2235
}

2236
static int ptrace_signal(int signr, siginfo_t *info)
R
Roland McGrath 已提交
2237
{
2238 2239 2240 2241 2242 2243 2244 2245 2246 2247
	/*
	 * We do not check sig_kernel_stop(signr) but set this marker
	 * unconditionally because we do not know whether debugger will
	 * change signr. This flag has no meaning unless we are going
	 * to stop after return from ptrace_stop(). In this case it will
	 * be checked in do_signal_stop(), we should only stop if it was
	 * not cleared by SIGCONT while we were sleeping. See also the
	 * comment in dequeue_signal().
	 */
	current->jobctl |= JOBCTL_STOP_DEQUEUED;
T
Tejun Heo 已提交
2248
	ptrace_stop(signr, CLD_TRAPPED, 0, info);
R
Roland McGrath 已提交
2249 2250 2251 2252 2253 2254 2255 2256

	/* We're back.  Did the debugger cancel the sig?  */
	signr = current->exit_code;
	if (signr == 0)
		return signr;

	current->exit_code = 0;

2257 2258 2259 2260 2261 2262
	/*
	 * Update the siginfo structure if the signal has
	 * changed.  If the debugger wanted something
	 * specific in the siginfo structure then it should
	 * have updated *info via PTRACE_SETSIGINFO.
	 */
R
Roland McGrath 已提交
2263
	if (signr != info->si_signo) {
2264
		clear_siginfo(info);
R
Roland McGrath 已提交
2265 2266 2267
		info->si_signo = signr;
		info->si_errno = 0;
		info->si_code = SI_USER;
2268
		rcu_read_lock();
R
Roland McGrath 已提交
2269
		info->si_pid = task_pid_vnr(current->parent);
2270 2271
		info->si_uid = from_kuid_munged(current_user_ns(),
						task_uid(current->parent));
2272
		rcu_read_unlock();
R
Roland McGrath 已提交
2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283
	}

	/* If the (new) signal is now blocked, requeue it.  */
	if (sigismember(&current->blocked, signr)) {
		specific_send_sig_info(signr, info, current);
		signr = 0;
	}

	return signr;
}

2284
int get_signal(struct ksignal *ksig)
L
Linus Torvalds 已提交
2285
{
2286 2287 2288
	struct sighand_struct *sighand = current->sighand;
	struct signal_struct *signal = current->signal;
	int signr;
L
Linus Torvalds 已提交
2289

2290 2291
	if (unlikely(current->task_works))
		task_work_run();
2292

2293 2294 2295
	if (unlikely(uprobe_deny_signal()))
		return 0;

R
Roland McGrath 已提交
2296
	/*
2297 2298 2299
	 * Do this once, we can't return to user-mode if freezing() == T.
	 * do_signal_stop() and ptrace_stop() do freezable_schedule() and
	 * thus do not need another check after return.
R
Roland McGrath 已提交
2300
	 */
2301 2302
	try_to_freeze();

2303
relock:
2304
	spin_lock_irq(&sighand->siglock);
2305 2306 2307 2308 2309
	/*
	 * Every stopped thread goes here after wakeup. Check to see if
	 * we should notify the parent, prepare_signal(SIGCONT) encodes
	 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
	 */
2310
	if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2311 2312 2313 2314 2315 2316 2317
		int why;

		if (signal->flags & SIGNAL_CLD_CONTINUED)
			why = CLD_CONTINUED;
		else
			why = CLD_STOPPED;

2318
		signal->flags &= ~SIGNAL_CLD_MASK;
2319

2320
		spin_unlock_irq(&sighand->siglock);
R
Roland McGrath 已提交
2321

2322 2323 2324 2325 2326 2327 2328 2329
		/*
		 * Notify the parent that we're continuing.  This event is
		 * always per-process and doesn't make whole lot of sense
		 * for ptracers, who shouldn't consume the state via
		 * wait(2) either, but, for backward compatibility, notify
		 * the ptracer of the group leader too unless it's gonna be
		 * a duplicate.
		 */
T
Tejun Heo 已提交
2330
		read_lock(&tasklist_lock);
2331 2332
		do_notify_parent_cldstop(current, false, why);

2333 2334 2335
		if (ptrace_reparented(current->group_leader))
			do_notify_parent_cldstop(current->group_leader,
						true, why);
T
Tejun Heo 已提交
2336
		read_unlock(&tasklist_lock);
2337

2338 2339 2340
		goto relock;
	}

L
Linus Torvalds 已提交
2341 2342
	for (;;) {
		struct k_sigaction *ka;
2343

T
Tejun Heo 已提交
2344 2345
		if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
		    do_signal_stop(0))
2346
			goto relock;
2347

2348 2349 2350 2351 2352
		if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
			do_jobctl_trap();
			spin_unlock_irq(&sighand->siglock);
			goto relock;
		}
L
Linus Torvalds 已提交
2353

2354
		signr = dequeue_signal(current, &current->blocked, &ksig->info);
2355

T
Tejun Heo 已提交
2356 2357
		if (!signr)
			break; /* will return 0 */
2358

2359
		if (unlikely(current->ptrace) && signr != SIGKILL) {
2360
			signr = ptrace_signal(signr, &ksig->info);
T
Tejun Heo 已提交
2361 2362
			if (!signr)
				continue;
L
Linus Torvalds 已提交
2363 2364
		}

T
Tejun Heo 已提交
2365 2366
		ka = &sighand->action[signr-1];

2367
		/* Trace actually delivered signals. */
2368
		trace_signal_deliver(signr, &ksig->info, ka);
2369

L
Linus Torvalds 已提交
2370 2371 2372 2373
		if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
			continue;
		if (ka->sa.sa_handler != SIG_DFL) {
			/* Run the handler.  */
2374
			ksig->ka = *ka;
L
Linus Torvalds 已提交
2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387

			if (ka->sa.sa_flags & SA_ONESHOT)
				ka->sa.sa_handler = SIG_DFL;

			break; /* will return non-zero "signr" value */
		}

		/*
		 * Now we are doing the default action for this signal.
		 */
		if (sig_kernel_ignore(signr)) /* Default is nothing. */
			continue;

2388
		/*
2389
		 * Global init gets no signals it doesn't want.
2390 2391 2392 2393 2394 2395 2396
		 * Container-init gets no signals it doesn't want from same
		 * container.
		 *
		 * Note that if global/container-init sees a sig_kernel_only()
		 * signal here, the signal must have been generated internally
		 * or must have come from an ancestor namespace. In either
		 * case, the signal cannot be dropped.
2397
		 */
2398
		if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2399
				!sig_kernel_only(signr))
L
Linus Torvalds 已提交
2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413
			continue;

		if (sig_kernel_stop(signr)) {
			/*
			 * The default action is to stop all threads in
			 * the thread group.  The job control signals
			 * do nothing in an orphaned pgrp, but SIGSTOP
			 * always works.  Note that siglock needs to be
			 * dropped during the call to is_orphaned_pgrp()
			 * because of lock ordering with tasklist_lock.
			 * This allows an intervening SIGCONT to be posted.
			 * We need to check for that and bail out if necessary.
			 */
			if (signr != SIGSTOP) {
2414
				spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2415 2416 2417

				/* signals can be posted during this window */

2418
				if (is_current_pgrp_orphaned())
L
Linus Torvalds 已提交
2419 2420
					goto relock;

2421
				spin_lock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2422 2423
			}

2424
			if (likely(do_signal_stop(ksig->info.si_signo))) {
L
Linus Torvalds 已提交
2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435
				/* It released the siglock.  */
				goto relock;
			}

			/*
			 * We didn't actually stop, due to a race
			 * with SIGCONT or something like that.
			 */
			continue;
		}

2436
		spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2437 2438 2439 2440 2441

		/*
		 * Anything else is fatal, maybe with a core dump.
		 */
		current->flags |= PF_SIGNALED;
2442

L
Linus Torvalds 已提交
2443
		if (sig_kernel_coredump(signr)) {
2444
			if (print_fatal_signals)
2445
				print_fatal_signal(ksig->info.si_signo);
2446
			proc_coredump_connector(current);
L
Linus Torvalds 已提交
2447 2448 2449 2450 2451 2452 2453 2454
			/*
			 * If it was able to dump core, this kills all
			 * other threads in the group and synchronizes with
			 * their demise.  If we lost the race with another
			 * thread getting here, it set group_exit_code
			 * first and our do_group_exit call below will use
			 * that value and ignore the one we pass it.
			 */
2455
			do_coredump(&ksig->info);
L
Linus Torvalds 已提交
2456 2457 2458 2459 2460
		}

		/*
		 * Death signals, no core dump.
		 */
2461
		do_group_exit(ksig->info.si_signo);
L
Linus Torvalds 已提交
2462 2463
		/* NOTREACHED */
	}
2464
	spin_unlock_irq(&sighand->siglock);
2465 2466 2467

	ksig->sig = signr;
	return ksig->sig > 0;
L
Linus Torvalds 已提交
2468 2469
}

2470
/**
A
Al Viro 已提交
2471
 * signal_delivered - 
R
Richard Weinberger 已提交
2472
 * @ksig:		kernel signal struct
A
Al Viro 已提交
2473
 * @stepping:		nonzero if debugger single-step or block-step in use
2474
 *
2475
 * This function should be called when a signal has successfully been
R
Richard Weinberger 已提交
2476
 * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
A
Al Viro 已提交
2477
 * is always blocked, and the signal itself is blocked unless %SA_NODEFER
R
Richard Weinberger 已提交
2478
 * is set in @ksig->ka.sa.sa_flags.  Tracing is notified.
2479
 */
R
Richard Weinberger 已提交
2480
static void signal_delivered(struct ksignal *ksig, int stepping)
2481 2482 2483
{
	sigset_t blocked;

2484 2485 2486 2487 2488 2489
	/* A signal was successfully delivered, and the
	   saved sigmask was stored on the signal frame,
	   and will be restored by sigreturn.  So we can
	   simply clear the restore sigmask flag.  */
	clear_restore_sigmask();

R
Richard Weinberger 已提交
2490 2491 2492
	sigorsets(&blocked, &current->blocked, &ksig->ka.sa.sa_mask);
	if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
		sigaddset(&blocked, ksig->sig);
2493
	set_current_blocked(&blocked);
2494
	tracehook_signal_handler(stepping);
2495 2496
}

A
Al Viro 已提交
2497 2498 2499 2500 2501
void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
{
	if (failed)
		force_sigsegv(ksig->sig, current);
	else
R
Richard Weinberger 已提交
2502
		signal_delivered(ksig, stepping);
A
Al Viro 已提交
2503 2504
}

2505 2506
/*
 * It could be that complete_signal() picked us to notify about the
2507 2508
 * group-wide signal. Other threads should be notified now to take
 * the shared signals in @which since we will not.
2509
 */
2510
static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2511
{
2512
	sigset_t retarget;
2513 2514
	struct task_struct *t;

2515 2516 2517 2518
	sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
	if (sigisemptyset(&retarget))
		return;

2519 2520
	t = tsk;
	while_each_thread(tsk, t) {
2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533
		if (t->flags & PF_EXITING)
			continue;

		if (!has_pending_signals(&retarget, &t->blocked))
			continue;
		/* Remove the signals this thread can handle. */
		sigandsets(&retarget, &retarget, &t->blocked);

		if (!signal_pending(t))
			signal_wake_up(t, 0);

		if (sigisemptyset(&retarget))
			break;
2534 2535 2536
	}
}

O
Oleg Nesterov 已提交
2537 2538 2539
void exit_signals(struct task_struct *tsk)
{
	int group_stop = 0;
2540
	sigset_t unblocked;
O
Oleg Nesterov 已提交
2541

2542 2543 2544 2545
	/*
	 * @tsk is about to have PF_EXITING set - lock out users which
	 * expect stable threadgroup.
	 */
2546
	cgroup_threadgroup_change_begin(tsk);
2547

2548 2549
	if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
		tsk->flags |= PF_EXITING;
2550
		cgroup_threadgroup_change_end(tsk);
2551
		return;
O
Oleg Nesterov 已提交
2552 2553
	}

2554
	spin_lock_irq(&tsk->sighand->siglock);
O
Oleg Nesterov 已提交
2555 2556 2557 2558 2559
	/*
	 * From now this task is not visible for group-wide signals,
	 * see wants_signal(), do_signal_stop().
	 */
	tsk->flags |= PF_EXITING;
2560

2561
	cgroup_threadgroup_change_end(tsk);
2562

2563 2564 2565
	if (!signal_pending(tsk))
		goto out;

2566 2567 2568
	unblocked = tsk->blocked;
	signotset(&unblocked);
	retarget_shared_pending(tsk, &unblocked);
2569

2570
	if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2571
	    task_participate_group_stop(tsk))
T
Tejun Heo 已提交
2572
		group_stop = CLD_STOPPED;
2573
out:
O
Oleg Nesterov 已提交
2574 2575
	spin_unlock_irq(&tsk->sighand->siglock);

2576 2577 2578 2579
	/*
	 * If group stop has completed, deliver the notification.  This
	 * should always go to the real parent of the group leader.
	 */
2580
	if (unlikely(group_stop)) {
O
Oleg Nesterov 已提交
2581
		read_lock(&tasklist_lock);
2582
		do_notify_parent_cldstop(tsk, false, group_stop);
O
Oleg Nesterov 已提交
2583 2584 2585 2586
		read_unlock(&tasklist_lock);
	}
}

L
Linus Torvalds 已提交
2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598
EXPORT_SYMBOL(recalc_sigpending);
EXPORT_SYMBOL_GPL(dequeue_signal);
EXPORT_SYMBOL(flush_signals);
EXPORT_SYMBOL(force_sig);
EXPORT_SYMBOL(send_sig);
EXPORT_SYMBOL(send_sig_info);
EXPORT_SYMBOL(sigprocmask);

/*
 * System call entry points.
 */

2599 2600 2601
/**
 *  sys_restart_syscall - restart a system call
 */
2602
SYSCALL_DEFINE0(restart_syscall)
L
Linus Torvalds 已提交
2603
{
2604
	struct restart_block *restart = &current->restart_block;
L
Linus Torvalds 已提交
2605 2606 2607 2608 2609 2610 2611 2612
	return restart->fn(restart);
}

long do_no_restart_syscall(struct restart_block *param)
{
	return -EINTR;
}

2613 2614 2615 2616 2617
static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
{
	if (signal_pending(tsk) && !thread_group_empty(tsk)) {
		sigset_t newblocked;
		/* A set of now blocked but previously unblocked signals. */
2618
		sigandnsets(&newblocked, newset, &current->blocked);
2619 2620 2621 2622 2623 2624
		retarget_shared_pending(tsk, &newblocked);
	}
	tsk->blocked = *newset;
	recalc_sigpending();
}

2625 2626 2627 2628 2629 2630
/**
 * set_current_blocked - change current->blocked mask
 * @newset: new mask
 *
 * It is wrong to change ->blocked directly, this helper should be used
 * to ensure the process can't miss a shared signal we are going to block.
L
Linus Torvalds 已提交
2631
 */
2632 2633 2634
void set_current_blocked(sigset_t *newset)
{
	sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2635
	__set_current_blocked(newset);
2636 2637 2638
}

void __set_current_blocked(const sigset_t *newset)
2639 2640 2641
{
	struct task_struct *tsk = current;

2642 2643 2644 2645 2646 2647 2648
	/*
	 * In case the signal mask hasn't changed, there is nothing we need
	 * to do. The current->blocked shouldn't be modified by other task.
	 */
	if (sigequalsets(&tsk->blocked, newset))
		return;

2649
	spin_lock_irq(&tsk->sighand->siglock);
2650
	__set_task_blocked(tsk, newset);
2651 2652
	spin_unlock_irq(&tsk->sighand->siglock);
}
L
Linus Torvalds 已提交
2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663

/*
 * This is also useful for kernel threads that want to temporarily
 * (or permanently) block certain signals.
 *
 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
 * interface happily blocks "unblockable" signals like SIGKILL
 * and friends.
 */
int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
{
2664 2665
	struct task_struct *tsk = current;
	sigset_t newset;
L
Linus Torvalds 已提交
2666

2667
	/* Lockless, only current can change ->blocked, never from irq */
2668
	if (oldset)
2669
		*oldset = tsk->blocked;
2670

L
Linus Torvalds 已提交
2671 2672
	switch (how) {
	case SIG_BLOCK:
2673
		sigorsets(&newset, &tsk->blocked, set);
L
Linus Torvalds 已提交
2674 2675
		break;
	case SIG_UNBLOCK:
2676
		sigandnsets(&newset, &tsk->blocked, set);
L
Linus Torvalds 已提交
2677 2678
		break;
	case SIG_SETMASK:
2679
		newset = *set;
L
Linus Torvalds 已提交
2680 2681
		break;
	default:
2682
		return -EINVAL;
L
Linus Torvalds 已提交
2683
	}
2684

2685
	__set_current_blocked(&newset);
2686
	return 0;
L
Linus Torvalds 已提交
2687 2688
}

2689 2690 2691
/**
 *  sys_rt_sigprocmask - change the list of currently blocked signals
 *  @how: whether to add, remove, or set signals
R
Randy Dunlap 已提交
2692
 *  @nset: stores pending signals
2693 2694 2695
 *  @oset: previous value of signal mask if non-null
 *  @sigsetsize: size of sigset_t type
 */
2696
SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
2697
		sigset_t __user *, oset, size_t, sigsetsize)
L
Linus Torvalds 已提交
2698 2699
{
	sigset_t old_set, new_set;
2700
	int error;
L
Linus Torvalds 已提交
2701 2702 2703

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(sigset_t))
2704
		return -EINVAL;
L
Linus Torvalds 已提交
2705

2706 2707 2708 2709 2710
	old_set = current->blocked;

	if (nset) {
		if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
			return -EFAULT;
L
Linus Torvalds 已提交
2711 2712
		sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));

2713
		error = sigprocmask(how, &new_set, NULL);
L
Linus Torvalds 已提交
2714
		if (error)
2715 2716
			return error;
	}
L
Linus Torvalds 已提交
2717

2718 2719 2720
	if (oset) {
		if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
			return -EFAULT;
L
Linus Torvalds 已提交
2721
	}
2722 2723

	return 0;
L
Linus Torvalds 已提交
2724 2725
}

A
Al Viro 已提交
2726 2727 2728
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
		compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
L
Linus Torvalds 已提交
2729
{
A
Al Viro 已提交
2730 2731 2732 2733 2734 2735 2736 2737 2738
	sigset_t old_set = current->blocked;

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(sigset_t))
		return -EINVAL;

	if (nset) {
		sigset_t new_set;
		int error;
A
Al Viro 已提交
2739
		if (get_compat_sigset(&new_set, nset))
A
Al Viro 已提交
2740 2741 2742 2743 2744 2745 2746
			return -EFAULT;
		sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));

		error = sigprocmask(how, &new_set, NULL);
		if (error)
			return error;
	}
2747
	return oset ? put_compat_sigset(oset, &old_set, sizeof(*oset)) : 0;
A
Al Viro 已提交
2748 2749
}
#endif
L
Linus Torvalds 已提交
2750

2751
static void do_sigpending(sigset_t *set)
L
Linus Torvalds 已提交
2752 2753
{
	spin_lock_irq(&current->sighand->siglock);
A
Al Viro 已提交
2754
	sigorsets(set, &current->pending.signal,
L
Linus Torvalds 已提交
2755 2756 2757 2758
		  &current->signal->shared_pending.signal);
	spin_unlock_irq(&current->sighand->siglock);

	/* Outside the lock because only this thread touches it.  */
A
Al Viro 已提交
2759
	sigandsets(set, &current->blocked, set);
2760
}
L
Linus Torvalds 已提交
2761

2762 2763 2764
/**
 *  sys_rt_sigpending - examine a pending signal that has been raised
 *			while blocked
2765
 *  @uset: stores pending signals
2766 2767
 *  @sigsetsize: size of sigset_t type or larger
 */
A
Al Viro 已提交
2768
SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
L
Linus Torvalds 已提交
2769
{
A
Al Viro 已提交
2770
	sigset_t set;
2771 2772 2773 2774

	if (sigsetsize > sizeof(*uset))
		return -EINVAL;

2775 2776 2777 2778 2779 2780
	do_sigpending(&set);

	if (copy_to_user(uset, &set, sigsetsize))
		return -EFAULT;

	return 0;
A
Al Viro 已提交
2781 2782 2783 2784 2785
}

#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
		compat_size_t, sigsetsize)
L
Linus Torvalds 已提交
2786
{
A
Al Viro 已提交
2787
	sigset_t set;
2788 2789 2790 2791

	if (sigsetsize > sizeof(*uset))
		return -EINVAL;

2792 2793 2794
	do_sigpending(&set);

	return put_compat_sigset(uset, &set, sigsetsize);
L
Linus Torvalds 已提交
2795
}
A
Al Viro 已提交
2796
#endif
L
Linus Torvalds 已提交
2797

2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809
enum siginfo_layout siginfo_layout(int sig, int si_code)
{
	enum siginfo_layout layout = SIL_KILL;
	if ((si_code > SI_USER) && (si_code < SI_KERNEL)) {
		static const struct {
			unsigned char limit, layout;
		} filter[] = {
			[SIGILL]  = { NSIGILL,  SIL_FAULT },
			[SIGFPE]  = { NSIGFPE,  SIL_FAULT },
			[SIGSEGV] = { NSIGSEGV, SIL_FAULT },
			[SIGBUS]  = { NSIGBUS,  SIL_FAULT },
			[SIGTRAP] = { NSIGTRAP, SIL_FAULT },
2810
#if defined(SIGEMT) && defined(NSIGEMT)
2811 2812 2813 2814 2815 2816
			[SIGEMT]  = { NSIGEMT,  SIL_FAULT },
#endif
			[SIGCHLD] = { NSIGCHLD, SIL_CHLD },
			[SIGPOLL] = { NSIGPOLL, SIL_POLL },
			[SIGSYS]  = { NSIGSYS,  SIL_SYS },
		};
2817
		if ((sig < ARRAY_SIZE(filter)) && (si_code <= filter[sig].limit)) {
2818
			layout = filter[sig].layout;
2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829
			/* Handle the exceptions */
			if ((sig == SIGBUS) &&
			    (si_code >= BUS_MCEERR_AR) && (si_code <= BUS_MCEERR_AO))
				layout = SIL_FAULT_MCEERR;
			else if ((sig == SIGSEGV) && (si_code == SEGV_BNDERR))
				layout = SIL_FAULT_BNDERR;
#ifdef SEGV_PKUERR
			else if ((sig == SIGSEGV) && (si_code == SEGV_PKUERR))
				layout = SIL_FAULT_PKUERR;
#endif
		}
2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842
		else if (si_code <= NSIGPOLL)
			layout = SIL_POLL;
	} else {
		if (si_code == SI_TIMER)
			layout = SIL_TIMER;
		else if (si_code == SI_SIGIO)
			layout = SIL_POLL;
		else if (si_code < 0)
			layout = SIL_RT;
	}
	return layout;
}

A
Al Viro 已提交
2843
int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
L
Linus Torvalds 已提交
2844
{
2845
	if (copy_to_user(to, from , sizeof(struct siginfo)))
L
Linus Torvalds 已提交
2846
		return -EFAULT;
2847
	return 0;
L
Linus Torvalds 已提交
2848 2849
}

2850
#ifdef CONFIG_COMPAT
2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885
int copy_siginfo_to_user32(struct compat_siginfo __user *to,
			   const struct siginfo *from)
#if defined(CONFIG_X86_X32_ABI) || defined(CONFIG_IA32_EMULATION)
{
	return __copy_siginfo_to_user32(to, from, in_x32_syscall());
}
int __copy_siginfo_to_user32(struct compat_siginfo __user *to,
			     const struct siginfo *from, bool x32_ABI)
#endif
{
	struct compat_siginfo new;
	memset(&new, 0, sizeof(new));

	new.si_signo = from->si_signo;
	new.si_errno = from->si_errno;
	new.si_code  = from->si_code;
	switch(siginfo_layout(from->si_signo, from->si_code)) {
	case SIL_KILL:
		new.si_pid = from->si_pid;
		new.si_uid = from->si_uid;
		break;
	case SIL_TIMER:
		new.si_tid     = from->si_tid;
		new.si_overrun = from->si_overrun;
		new.si_int     = from->si_int;
		break;
	case SIL_POLL:
		new.si_band = from->si_band;
		new.si_fd   = from->si_fd;
		break;
	case SIL_FAULT:
		new.si_addr = ptr_to_compat(from->si_addr);
#ifdef __ARCH_SI_TRAPNO
		new.si_trapno = from->si_trapno;
#endif
2886 2887 2888 2889 2890
		break;
	case SIL_FAULT_MCEERR:
		new.si_addr = ptr_to_compat(from->si_addr);
#ifdef __ARCH_SI_TRAPNO
		new.si_trapno = from->si_trapno;
2891
#endif
2892 2893 2894 2895 2896 2897
		new.si_addr_lsb = from->si_addr_lsb;
		break;
	case SIL_FAULT_BNDERR:
		new.si_addr = ptr_to_compat(from->si_addr);
#ifdef __ARCH_SI_TRAPNO
		new.si_trapno = from->si_trapno;
2898
#endif
2899 2900 2901 2902 2903 2904 2905
		new.si_lower = ptr_to_compat(from->si_lower);
		new.si_upper = ptr_to_compat(from->si_upper);
		break;
	case SIL_FAULT_PKUERR:
		new.si_addr = ptr_to_compat(from->si_addr);
#ifdef __ARCH_SI_TRAPNO
		new.si_trapno = from->si_trapno;
2906
#endif
2907
		new.si_pkey = from->si_pkey;
2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941
		break;
	case SIL_CHLD:
		new.si_pid    = from->si_pid;
		new.si_uid    = from->si_uid;
		new.si_status = from->si_status;
#ifdef CONFIG_X86_X32_ABI
		if (x32_ABI) {
			new._sifields._sigchld_x32._utime = from->si_utime;
			new._sifields._sigchld_x32._stime = from->si_stime;
		} else
#endif
		{
			new.si_utime = from->si_utime;
			new.si_stime = from->si_stime;
		}
		break;
	case SIL_RT:
		new.si_pid = from->si_pid;
		new.si_uid = from->si_uid;
		new.si_int = from->si_int;
		break;
	case SIL_SYS:
		new.si_call_addr = ptr_to_compat(from->si_call_addr);
		new.si_syscall   = from->si_syscall;
		new.si_arch      = from->si_arch;
		break;
	}

	if (copy_to_user(to, &new, sizeof(struct compat_siginfo)))
		return -EFAULT;

	return 0;
}

2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972
int copy_siginfo_from_user32(struct siginfo *to,
			     const struct compat_siginfo __user *ufrom)
{
	struct compat_siginfo from;

	if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
		return -EFAULT;

	clear_siginfo(to);
	to->si_signo = from.si_signo;
	to->si_errno = from.si_errno;
	to->si_code  = from.si_code;
	switch(siginfo_layout(from.si_signo, from.si_code)) {
	case SIL_KILL:
		to->si_pid = from.si_pid;
		to->si_uid = from.si_uid;
		break;
	case SIL_TIMER:
		to->si_tid     = from.si_tid;
		to->si_overrun = from.si_overrun;
		to->si_int     = from.si_int;
		break;
	case SIL_POLL:
		to->si_band = from.si_band;
		to->si_fd   = from.si_fd;
		break;
	case SIL_FAULT:
		to->si_addr = compat_ptr(from.si_addr);
#ifdef __ARCH_SI_TRAPNO
		to->si_trapno = from.si_trapno;
#endif
2973 2974 2975 2976 2977
		break;
	case SIL_FAULT_MCEERR:
		to->si_addr = compat_ptr(from.si_addr);
#ifdef __ARCH_SI_TRAPNO
		to->si_trapno = from.si_trapno;
2978
#endif
2979 2980 2981 2982 2983 2984
		to->si_addr_lsb = from.si_addr_lsb;
		break;
	case SIL_FAULT_BNDERR:
		to->si_addr = compat_ptr(from.si_addr);
#ifdef __ARCH_SI_TRAPNO
		to->si_trapno = from.si_trapno;
2985
#endif
2986 2987 2988 2989 2990 2991 2992
		to->si_lower = compat_ptr(from.si_lower);
		to->si_upper = compat_ptr(from.si_upper);
		break;
	case SIL_FAULT_PKUERR:
		to->si_addr = compat_ptr(from.si_addr);
#ifdef __ARCH_SI_TRAPNO
		to->si_trapno = from.si_trapno;
2993
#endif
2994
		to->si_pkey = from.si_pkey;
2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025
		break;
	case SIL_CHLD:
		to->si_pid    = from.si_pid;
		to->si_uid    = from.si_uid;
		to->si_status = from.si_status;
#ifdef CONFIG_X86_X32_ABI
		if (in_x32_syscall()) {
			to->si_utime = from._sifields._sigchld_x32._utime;
			to->si_stime = from._sifields._sigchld_x32._stime;
		} else
#endif
		{
			to->si_utime = from.si_utime;
			to->si_stime = from.si_stime;
		}
		break;
	case SIL_RT:
		to->si_pid = from.si_pid;
		to->si_uid = from.si_uid;
		to->si_int = from.si_int;
		break;
	case SIL_SYS:
		to->si_call_addr = compat_ptr(from.si_call_addr);
		to->si_syscall   = from.si_syscall;
		to->si_arch      = from.si_arch;
		break;
	}
	return 0;
}
#endif /* CONFIG_COMPAT */

3026 3027 3028 3029 3030 3031
/**
 *  do_sigtimedwait - wait for queued signals specified in @which
 *  @which: queued signals to wait for
 *  @info: if non-null, the signal's siginfo is returned here
 *  @ts: upper bound on process time suspension
 */
3032
static int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
3033
		    const struct timespec *ts)
3034
{
T
Thomas Gleixner 已提交
3035
	ktime_t *to = NULL, timeout = KTIME_MAX;
3036 3037
	struct task_struct *tsk = current;
	sigset_t mask = *which;
3038
	int sig, ret = 0;
3039 3040 3041 3042

	if (ts) {
		if (!timespec_valid(ts))
			return -EINVAL;
3043 3044
		timeout = timespec_to_ktime(*ts);
		to = &timeout;
3045 3046 3047 3048 3049 3050 3051 3052 3053 3054
	}

	/*
	 * Invert the set of allowed signals to get those we want to block.
	 */
	sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
	signotset(&mask);

	spin_lock_irq(&tsk->sighand->siglock);
	sig = dequeue_signal(tsk, &mask, info);
T
Thomas Gleixner 已提交
3055
	if (!sig && timeout) {
3056 3057 3058
		/*
		 * None ready, temporarily unblock those we're interested
		 * while we are sleeping in so that we'll be awakened when
3059 3060
		 * they arrive. Unblocking is always fine, we can avoid
		 * set_current_blocked().
3061 3062 3063 3064 3065 3066
		 */
		tsk->real_blocked = tsk->blocked;
		sigandsets(&tsk->blocked, &tsk->blocked, &mask);
		recalc_sigpending();
		spin_unlock_irq(&tsk->sighand->siglock);

3067 3068 3069
		__set_current_state(TASK_INTERRUPTIBLE);
		ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns,
							 HRTIMER_MODE_REL);
3070
		spin_lock_irq(&tsk->sighand->siglock);
3071
		__set_task_blocked(tsk, &tsk->real_blocked);
3072
		sigemptyset(&tsk->real_blocked);
3073
		sig = dequeue_signal(tsk, &mask, info);
3074 3075 3076 3077 3078
	}
	spin_unlock_irq(&tsk->sighand->siglock);

	if (sig)
		return sig;
3079
	return ret ? -EINTR : -EAGAIN;
3080 3081
}

3082 3083 3084 3085 3086 3087 3088 3089
/**
 *  sys_rt_sigtimedwait - synchronously wait for queued signals specified
 *			in @uthese
 *  @uthese: queued signals to wait for
 *  @uinfo: if non-null, the signal's siginfo is returned here
 *  @uts: upper bound on process time suspension
 *  @sigsetsize: size of sigset_t type
 */
3090 3091 3092
SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
		siginfo_t __user *, uinfo, const struct timespec __user *, uts,
		size_t, sigsetsize)
L
Linus Torvalds 已提交
3093 3094 3095 3096
{
	sigset_t these;
	struct timespec ts;
	siginfo_t info;
3097
	int ret;
L
Linus Torvalds 已提交
3098 3099 3100 3101 3102 3103 3104

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(sigset_t))
		return -EINVAL;

	if (copy_from_user(&these, uthese, sizeof(these)))
		return -EFAULT;
3105

L
Linus Torvalds 已提交
3106 3107 3108 3109 3110
	if (uts) {
		if (copy_from_user(&ts, uts, sizeof(ts)))
			return -EFAULT;
	}

3111
	ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
L
Linus Torvalds 已提交
3112

3113 3114 3115
	if (ret > 0 && uinfo) {
		if (copy_siginfo_to_user(uinfo, &info))
			ret = -EFAULT;
L
Linus Torvalds 已提交
3116 3117 3118 3119 3120
	}

	return ret;
}

3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait, compat_sigset_t __user *, uthese,
		struct compat_siginfo __user *, uinfo,
		struct compat_timespec __user *, uts, compat_size_t, sigsetsize)
{
	sigset_t s;
	struct timespec t;
	siginfo_t info;
	long ret;

	if (sigsetsize != sizeof(sigset_t))
		return -EINVAL;

A
Al Viro 已提交
3134
	if (get_compat_sigset(&s, uthese))
3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152
		return -EFAULT;

	if (uts) {
		if (compat_get_timespec(&t, uts))
			return -EFAULT;
	}

	ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);

	if (ret > 0 && uinfo) {
		if (copy_siginfo_to_user32(uinfo, &info))
			ret = -EFAULT;
	}

	return ret;
}
#endif

3153 3154 3155 3156 3157
/**
 *  sys_kill - send a signal to a process
 *  @pid: the PID of the process
 *  @sig: signal to be sent
 */
3158
SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
L
Linus Torvalds 已提交
3159 3160 3161
{
	struct siginfo info;

3162
	clear_siginfo(&info);
L
Linus Torvalds 已提交
3163 3164 3165
	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_USER;
3166
	info.si_pid = task_tgid_vnr(current);
3167
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
L
Linus Torvalds 已提交
3168 3169 3170 3171

	return kill_something_info(sig, &info, pid);
}

T
Thomas Gleixner 已提交
3172 3173
static int
do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
L
Linus Torvalds 已提交
3174 3175
{
	struct task_struct *p;
T
Thomas Gleixner 已提交
3176
	int error = -ESRCH;
L
Linus Torvalds 已提交
3177

3178
	rcu_read_lock();
3179
	p = find_task_by_vpid(pid);
3180
	if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
T
Thomas Gleixner 已提交
3181
		error = check_kill_permission(sig, info, p);
L
Linus Torvalds 已提交
3182 3183 3184 3185
		/*
		 * The null signal is a permissions and process existence
		 * probe.  No signal is actually delivered.
		 */
3186 3187 3188 3189 3190 3191 3192 3193 3194
		if (!error && sig) {
			error = do_send_sig_info(sig, info, p, false);
			/*
			 * If lock_task_sighand() failed we pretend the task
			 * dies after receiving the signal. The window is tiny,
			 * and the signal is private anyway.
			 */
			if (unlikely(error == -ESRCH))
				error = 0;
L
Linus Torvalds 已提交
3195 3196
		}
	}
3197
	rcu_read_unlock();
3198

L
Linus Torvalds 已提交
3199 3200 3201
	return error;
}

T
Thomas Gleixner 已提交
3202 3203
static int do_tkill(pid_t tgid, pid_t pid, int sig)
{
3204
	struct siginfo info;
T
Thomas Gleixner 已提交
3205

3206
	clear_siginfo(&info);
T
Thomas Gleixner 已提交
3207 3208 3209 3210
	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_TKILL;
	info.si_pid = task_tgid_vnr(current);
3211
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
T
Thomas Gleixner 已提交
3212 3213 3214 3215

	return do_send_specific(tgid, pid, sig, &info);
}

3216 3217 3218 3219 3220 3221
/**
 *  sys_tgkill - send signal to one specific thread
 *  @tgid: the thread group ID of the thread
 *  @pid: the PID of the thread
 *  @sig: signal to be sent
 *
3222
 *  This syscall also checks the @tgid and returns -ESRCH even if the PID
3223 3224 3225
 *  exists but it's not belonging to the target process anymore. This
 *  method solves the problem of threads exiting and PIDs getting reused.
 */
3226
SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
3227 3228 3229 3230 3231 3232 3233 3234
{
	/* This is only valid for single tasks */
	if (pid <= 0 || tgid <= 0)
		return -EINVAL;

	return do_tkill(tgid, pid, sig);
}

3235 3236 3237 3238 3239
/**
 *  sys_tkill - send signal to one specific task
 *  @pid: the PID of the task
 *  @sig: signal to be sent
 *
L
Linus Torvalds 已提交
3240 3241
 *  Send a signal to only one task, even if it's a CLONE_THREAD task.
 */
3242
SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
L
Linus Torvalds 已提交
3243 3244 3245 3246 3247
{
	/* This is only valid for single tasks */
	if (pid <= 0)
		return -EINVAL;

3248
	return do_tkill(0, pid, sig);
L
Linus Torvalds 已提交
3249 3250
}

A
Al Viro 已提交
3251 3252 3253 3254 3255
static int do_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t *info)
{
	/* Not even root can pretend to send signals from the kernel.
	 * Nor can they impersonate a kill()/tgkill(), which adds source info.
	 */
3256
	if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3257
	    (task_pid_vnr(current) != pid))
A
Al Viro 已提交
3258
		return -EPERM;
3259

A
Al Viro 已提交
3260 3261 3262 3263 3264 3265
	info->si_signo = sig;

	/* POSIX.1b doesn't mention process groups.  */
	return kill_proc_info(sig, info, pid);
}

3266 3267 3268 3269 3270 3271
/**
 *  sys_rt_sigqueueinfo - send signal information to a signal
 *  @pid: the PID of the thread
 *  @sig: signal to be sent
 *  @uinfo: signal info to be sent
 */
3272 3273
SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
		siginfo_t __user *, uinfo)
L
Linus Torvalds 已提交
3274 3275 3276 3277
{
	siginfo_t info;
	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
		return -EFAULT;
A
Al Viro 已提交
3278 3279
	return do_rt_sigqueueinfo(pid, sig, &info);
}
L
Linus Torvalds 已提交
3280

A
Al Viro 已提交
3281 3282 3283 3284 3285 3286
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
			compat_pid_t, pid,
			int, sig,
			struct compat_siginfo __user *, uinfo)
{
3287
	siginfo_t info;
A
Al Viro 已提交
3288 3289 3290 3291
	int ret = copy_siginfo_from_user32(&info, uinfo);
	if (unlikely(ret))
		return ret;
	return do_rt_sigqueueinfo(pid, sig, &info);
L
Linus Torvalds 已提交
3292
}
A
Al Viro 已提交
3293
#endif
L
Linus Torvalds 已提交
3294

3295
static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
3296 3297 3298 3299 3300 3301
{
	/* This is only valid for single tasks */
	if (pid <= 0 || tgid <= 0)
		return -EINVAL;

	/* Not even root can pretend to send signals from the kernel.
3302 3303
	 * Nor can they impersonate a kill()/tgkill(), which adds source info.
	 */
3304 3305
	if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
	    (task_pid_vnr(current) != pid))
3306
		return -EPERM;
3307

3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323
	info->si_signo = sig;

	return do_send_specific(tgid, pid, sig, info);
}

SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
		siginfo_t __user *, uinfo)
{
	siginfo_t info;

	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
		return -EFAULT;

	return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
}

3324 3325 3326 3327 3328 3329 3330
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
			compat_pid_t, tgid,
			compat_pid_t, pid,
			int, sig,
			struct compat_siginfo __user *, uinfo)
{
3331
	siginfo_t info;
3332 3333 3334 3335 3336 3337 3338

	if (copy_siginfo_from_user32(&info, uinfo))
		return -EFAULT;
	return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
}
#endif

3339
/*
3340
 * For kthreads only, must not be used if cloned with CLONE_SIGHAND
3341
 */
3342
void kernel_sigaction(int sig, __sighandler_t action)
3343
{
3344
	spin_lock_irq(&current->sighand->siglock);
3345 3346 3347
	current->sighand->action[sig - 1].sa.sa_handler = action;
	if (action == SIG_IGN) {
		sigset_t mask;
3348

3349 3350
		sigemptyset(&mask);
		sigaddset(&mask, sig);
3351

3352 3353 3354 3355
		flush_sigqueue_mask(&mask, &current->signal->shared_pending);
		flush_sigqueue_mask(&mask, &current->pending);
		recalc_sigpending();
	}
3356 3357
	spin_unlock_irq(&current->sighand->siglock);
}
3358
EXPORT_SYMBOL(kernel_sigaction);
3359

3360 3361 3362 3363 3364
void __weak sigaction_compat_abi(struct k_sigaction *act,
		struct k_sigaction *oact)
{
}

3365
int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
L
Linus Torvalds 已提交
3366
{
3367
	struct task_struct *p = current, *t;
L
Linus Torvalds 已提交
3368
	struct k_sigaction *k;
3369
	sigset_t mask;
L
Linus Torvalds 已提交
3370

3371
	if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
L
Linus Torvalds 已提交
3372 3373
		return -EINVAL;

3374
	k = &p->sighand->action[sig-1];
L
Linus Torvalds 已提交
3375

3376
	spin_lock_irq(&p->sighand->siglock);
L
Linus Torvalds 已提交
3377 3378 3379
	if (oact)
		*oact = *k;

3380 3381
	sigaction_compat_abi(act, oact);

L
Linus Torvalds 已提交
3382
	if (act) {
3383 3384
		sigdelsetmask(&act->sa.sa_mask,
			      sigmask(SIGKILL) | sigmask(SIGSTOP));
3385
		*k = *act;
L
Linus Torvalds 已提交
3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396
		/*
		 * POSIX 3.3.1.3:
		 *  "Setting a signal action to SIG_IGN for a signal that is
		 *   pending shall cause the pending signal to be discarded,
		 *   whether or not it is blocked."
		 *
		 *  "Setting a signal action to SIG_DFL for a signal that is
		 *   pending and whose default action is to ignore the signal
		 *   (for example, SIGCHLD), shall cause the pending signal to
		 *   be discarded, whether or not it is blocked"
		 */
3397
		if (sig_handler_ignored(sig_handler(p, sig), sig)) {
3398 3399
			sigemptyset(&mask);
			sigaddset(&mask, sig);
3400 3401
			flush_sigqueue_mask(&mask, &p->signal->shared_pending);
			for_each_thread(p, t)
3402
				flush_sigqueue_mask(&mask, &t->pending);
L
Linus Torvalds 已提交
3403 3404 3405
		}
	}

3406
	spin_unlock_irq(&p->sighand->siglock);
L
Linus Torvalds 已提交
3407 3408 3409
	return 0;
}

3410
static int
3411
do_sigaltstack (const stack_t *ss, stack_t *oss, unsigned long sp)
L
Linus Torvalds 已提交
3412
{
3413
	struct task_struct *t = current;
L
Linus Torvalds 已提交
3414

3415 3416 3417 3418 3419 3420 3421
	if (oss) {
		memset(oss, 0, sizeof(stack_t));
		oss->ss_sp = (void __user *) t->sas_ss_sp;
		oss->ss_size = t->sas_ss_size;
		oss->ss_flags = sas_ss_flags(sp) |
			(current->sas_ss_flags & SS_FLAG_BITS);
	}
L
Linus Torvalds 已提交
3422

3423 3424 3425 3426
	if (ss) {
		void __user *ss_sp = ss->ss_sp;
		size_t ss_size = ss->ss_size;
		unsigned ss_flags = ss->ss_flags;
3427
		int ss_mode;
L
Linus Torvalds 已提交
3428

3429 3430
		if (unlikely(on_sig_stack(sp)))
			return -EPERM;
L
Linus Torvalds 已提交
3431

3432
		ss_mode = ss_flags & ~SS_FLAG_BITS;
3433 3434 3435
		if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
				ss_mode != 0))
			return -EINVAL;
L
Linus Torvalds 已提交
3436

3437
		if (ss_mode == SS_DISABLE) {
L
Linus Torvalds 已提交
3438 3439 3440
			ss_size = 0;
			ss_sp = NULL;
		} else {
3441 3442
			if (unlikely(ss_size < MINSIGSTKSZ))
				return -ENOMEM;
L
Linus Torvalds 已提交
3443 3444
		}

3445 3446 3447
		t->sas_ss_sp = (unsigned long) ss_sp;
		t->sas_ss_size = ss_size;
		t->sas_ss_flags = ss_flags;
L
Linus Torvalds 已提交
3448
	}
3449
	return 0;
L
Linus Torvalds 已提交
3450
}
3451

3452 3453
SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
{
3454 3455 3456 3457 3458 3459 3460 3461 3462
	stack_t new, old;
	int err;
	if (uss && copy_from_user(&new, uss, sizeof(stack_t)))
		return -EFAULT;
	err = do_sigaltstack(uss ? &new : NULL, uoss ? &old : NULL,
			      current_user_stack_pointer());
	if (!err && uoss && copy_to_user(uoss, &old, sizeof(stack_t)))
		err = -EFAULT;
	return err;
3463
}
L
Linus Torvalds 已提交
3464

A
Al Viro 已提交
3465 3466
int restore_altstack(const stack_t __user *uss)
{
3467 3468 3469 3470
	stack_t new;
	if (copy_from_user(&new, uss, sizeof(stack_t)))
		return -EFAULT;
	(void)do_sigaltstack(&new, NULL, current_user_stack_pointer());
A
Al Viro 已提交
3471
	/* squash all but EFAULT for now */
3472
	return 0;
A
Al Viro 已提交
3473 3474
}

3475 3476 3477
int __save_altstack(stack_t __user *uss, unsigned long sp)
{
	struct task_struct *t = current;
3478 3479
	int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
		__put_user(t->sas_ss_flags, &uss->ss_flags) |
3480
		__put_user(t->sas_ss_size, &uss->ss_size);
3481 3482 3483 3484 3485
	if (err)
		return err;
	if (t->sas_ss_flags & SS_AUTODISARM)
		sas_ss_reset(t);
	return 0;
3486 3487
}

A
Al Viro 已提交
3488
#ifdef CONFIG_COMPAT
3489 3490
static int do_compat_sigaltstack(const compat_stack_t __user *uss_ptr,
				 compat_stack_t __user *uoss_ptr)
A
Al Viro 已提交
3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502
{
	stack_t uss, uoss;
	int ret;

	if (uss_ptr) {
		compat_stack_t uss32;
		if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
			return -EFAULT;
		uss.ss_sp = compat_ptr(uss32.ss_sp);
		uss.ss_flags = uss32.ss_flags;
		uss.ss_size = uss32.ss_size;
	}
3503
	ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss,
A
Al Viro 已提交
3504 3505
			     compat_user_stack_pointer());
	if (ret >= 0 && uoss_ptr)  {
3506 3507 3508 3509 3510 3511
		compat_stack_t old;
		memset(&old, 0, sizeof(old));
		old.ss_sp = ptr_to_compat(uoss.ss_sp);
		old.ss_flags = uoss.ss_flags;
		old.ss_size = uoss.ss_size;
		if (copy_to_user(uoss_ptr, &old, sizeof(compat_stack_t)))
A
Al Viro 已提交
3512 3513 3514 3515 3516
			ret = -EFAULT;
	}
	return ret;
}

3517 3518 3519 3520 3521 3522 3523
COMPAT_SYSCALL_DEFINE2(sigaltstack,
			const compat_stack_t __user *, uss_ptr,
			compat_stack_t __user *, uoss_ptr)
{
	return do_compat_sigaltstack(uss_ptr, uoss_ptr);
}

A
Al Viro 已提交
3524 3525
int compat_restore_altstack(const compat_stack_t __user *uss)
{
3526
	int err = do_compat_sigaltstack(uss, NULL);
A
Al Viro 已提交
3527 3528 3529
	/* squash all but -EFAULT for now */
	return err == -EFAULT ? err : 0;
}
3530 3531 3532

int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
{
3533
	int err;
3534
	struct task_struct *t = current;
3535 3536 3537
	err = __put_user(ptr_to_compat((void __user *)t->sas_ss_sp),
			 &uss->ss_sp) |
		__put_user(t->sas_ss_flags, &uss->ss_flags) |
3538
		__put_user(t->sas_ss_size, &uss->ss_size);
3539 3540 3541 3542 3543
	if (err)
		return err;
	if (t->sas_ss_flags & SS_AUTODISARM)
		sas_ss_reset(t);
	return 0;
3544
}
A
Al Viro 已提交
3545
#endif
L
Linus Torvalds 已提交
3546 3547 3548

#ifdef __ARCH_WANT_SYS_SIGPENDING

3549 3550
/**
 *  sys_sigpending - examine pending signals
3551
 *  @uset: where mask of pending signal is returned
3552
 */
3553
SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, uset)
L
Linus Torvalds 已提交
3554
{
3555 3556 3557 3558 3559
	sigset_t set;

	if (sizeof(old_sigset_t) > sizeof(*uset))
		return -EINVAL;

3560 3561 3562 3563 3564 3565
	do_sigpending(&set);

	if (copy_to_user(uset, &set, sizeof(old_sigset_t)))
		return -EFAULT;

	return 0;
L
Linus Torvalds 已提交
3566 3567
}

A
Al Viro 已提交
3568 3569 3570 3571
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set32)
{
	sigset_t set;
3572 3573 3574 3575

	do_sigpending(&set);

	return put_user(set.sig[0], set32);
A
Al Viro 已提交
3576 3577 3578
}
#endif

L
Linus Torvalds 已提交
3579 3580 3581
#endif

#ifdef __ARCH_WANT_SYS_SIGPROCMASK
3582 3583 3584
/**
 *  sys_sigprocmask - examine and change blocked signals
 *  @how: whether to add, remove, or set signals
3585
 *  @nset: signals to add or remove (if non-null)
3586 3587
 *  @oset: previous value of signal mask if non-null
 *
3588 3589 3590
 * Some platforms have their own version with special arguments;
 * others support only sys_rt_sigprocmask.
 */
L
Linus Torvalds 已提交
3591

3592
SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
3593
		old_sigset_t __user *, oset)
L
Linus Torvalds 已提交
3594 3595
{
	old_sigset_t old_set, new_set;
3596
	sigset_t new_blocked;
L
Linus Torvalds 已提交
3597

3598
	old_set = current->blocked.sig[0];
L
Linus Torvalds 已提交
3599

3600 3601 3602
	if (nset) {
		if (copy_from_user(&new_set, nset, sizeof(*nset)))
			return -EFAULT;
L
Linus Torvalds 已提交
3603

3604
		new_blocked = current->blocked;
L
Linus Torvalds 已提交
3605 3606 3607

		switch (how) {
		case SIG_BLOCK:
3608
			sigaddsetmask(&new_blocked, new_set);
L
Linus Torvalds 已提交
3609 3610
			break;
		case SIG_UNBLOCK:
3611
			sigdelsetmask(&new_blocked, new_set);
L
Linus Torvalds 已提交
3612 3613
			break;
		case SIG_SETMASK:
3614
			new_blocked.sig[0] = new_set;
L
Linus Torvalds 已提交
3615
			break;
3616 3617
		default:
			return -EINVAL;
L
Linus Torvalds 已提交
3618 3619
		}

3620
		set_current_blocked(&new_blocked);
3621 3622 3623
	}

	if (oset) {
L
Linus Torvalds 已提交
3624
		if (copy_to_user(oset, &old_set, sizeof(*oset)))
3625
			return -EFAULT;
L
Linus Torvalds 已提交
3626
	}
3627 3628

	return 0;
L
Linus Torvalds 已提交
3629 3630 3631
}
#endif /* __ARCH_WANT_SYS_SIGPROCMASK */

3632
#ifndef CONFIG_ODD_RT_SIGACTION
3633 3634 3635
/**
 *  sys_rt_sigaction - alter an action taken by a process
 *  @sig: signal to be sent
3636 3637
 *  @act: new sigaction
 *  @oact: used to save the previous sigaction
3638 3639
 *  @sigsetsize: size of sigset_t type
 */
3640 3641 3642 3643
SYSCALL_DEFINE4(rt_sigaction, int, sig,
		const struct sigaction __user *, act,
		struct sigaction __user *, oact,
		size_t, sigsetsize)
L
Linus Torvalds 已提交
3644 3645
{
	struct k_sigaction new_sa, old_sa;
3646
	int ret;
L
Linus Torvalds 已提交
3647 3648 3649

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(sigset_t))
3650
		return -EINVAL;
L
Linus Torvalds 已提交
3651

3652 3653
	if (act && copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
		return -EFAULT;
L
Linus Torvalds 已提交
3654 3655

	ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
3656 3657
	if (ret)
		return ret;
L
Linus Torvalds 已提交
3658

3659 3660 3661 3662
	if (oact && copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
		return -EFAULT;

	return 0;
L
Linus Torvalds 已提交
3663
}
A
Al Viro 已提交
3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig,
		const struct compat_sigaction __user *, act,
		struct compat_sigaction __user *, oact,
		compat_size_t, sigsetsize)
{
	struct k_sigaction new_ka, old_ka;
#ifdef __ARCH_HAS_SA_RESTORER
	compat_uptr_t restorer;
#endif
	int ret;

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(compat_sigset_t))
		return -EINVAL;

	if (act) {
		compat_uptr_t handler;
		ret = get_user(handler, &act->sa_handler);
		new_ka.sa.sa_handler = compat_ptr(handler);
#ifdef __ARCH_HAS_SA_RESTORER
		ret |= get_user(restorer, &act->sa_restorer);
		new_ka.sa.sa_restorer = compat_ptr(restorer);
#endif
A
Al Viro 已提交
3688
		ret |= get_compat_sigset(&new_ka.sa.sa_mask, &act->sa_mask);
3689
		ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
A
Al Viro 已提交
3690 3691 3692 3693 3694 3695 3696 3697
		if (ret)
			return -EFAULT;
	}

	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
	if (!ret && oact) {
		ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), 
			       &oact->sa_handler);
3698 3699
		ret |= put_compat_sigset(&oact->sa_mask, &old_ka.sa.sa_mask,
					 sizeof(oact->sa_mask));
3700
		ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
A
Al Viro 已提交
3701 3702 3703 3704 3705 3706 3707 3708
#ifdef __ARCH_HAS_SA_RESTORER
		ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
				&oact->sa_restorer);
#endif
	}
	return ret;
}
#endif
3709
#endif /* !CONFIG_ODD_RT_SIGACTION */
L
Linus Torvalds 已提交
3710

3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787
#ifdef CONFIG_OLD_SIGACTION
SYSCALL_DEFINE3(sigaction, int, sig,
		const struct old_sigaction __user *, act,
	        struct old_sigaction __user *, oact)
{
	struct k_sigaction new_ka, old_ka;
	int ret;

	if (act) {
		old_sigset_t mask;
		if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
		    __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
		    __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
		    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
		    __get_user(mask, &act->sa_mask))
			return -EFAULT;
#ifdef __ARCH_HAS_KA_RESTORER
		new_ka.ka_restorer = NULL;
#endif
		siginitset(&new_ka.sa.sa_mask, mask);
	}

	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);

	if (!ret && oact) {
		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
		    __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
		    __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
		    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
		    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
			return -EFAULT;
	}

	return ret;
}
#endif
#ifdef CONFIG_COMPAT_OLD_SIGACTION
COMPAT_SYSCALL_DEFINE3(sigaction, int, sig,
		const struct compat_old_sigaction __user *, act,
	        struct compat_old_sigaction __user *, oact)
{
	struct k_sigaction new_ka, old_ka;
	int ret;
	compat_old_sigset_t mask;
	compat_uptr_t handler, restorer;

	if (act) {
		if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
		    __get_user(handler, &act->sa_handler) ||
		    __get_user(restorer, &act->sa_restorer) ||
		    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
		    __get_user(mask, &act->sa_mask))
			return -EFAULT;

#ifdef __ARCH_HAS_KA_RESTORER
		new_ka.ka_restorer = NULL;
#endif
		new_ka.sa.sa_handler = compat_ptr(handler);
		new_ka.sa.sa_restorer = compat_ptr(restorer);
		siginitset(&new_ka.sa.sa_mask, mask);
	}

	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);

	if (!ret && oact) {
		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
		    __put_user(ptr_to_compat(old_ka.sa.sa_handler),
			       &oact->sa_handler) ||
		    __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
			       &oact->sa_restorer) ||
		    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
		    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
			return -EFAULT;
	}
	return ret;
}
#endif
L
Linus Torvalds 已提交
3788

3789
#ifdef CONFIG_SGETMASK_SYSCALL
L
Linus Torvalds 已提交
3790 3791 3792 3793

/*
 * For backwards compatibility.  Functionality superseded by sigprocmask.
 */
3794
SYSCALL_DEFINE0(sgetmask)
L
Linus Torvalds 已提交
3795 3796 3797 3798 3799
{
	/* SMP safe */
	return current->blocked.sig[0];
}

3800
SYSCALL_DEFINE1(ssetmask, int, newmask)
L
Linus Torvalds 已提交
3801
{
3802 3803
	int old = current->blocked.sig[0];
	sigset_t newset;
L
Linus Torvalds 已提交
3804

3805
	siginitset(&newset, newmask);
3806
	set_current_blocked(&newset);
L
Linus Torvalds 已提交
3807 3808 3809

	return old;
}
3810
#endif /* CONFIG_SGETMASK_SYSCALL */
L
Linus Torvalds 已提交
3811 3812 3813 3814 3815

#ifdef __ARCH_WANT_SYS_SIGNAL
/*
 * For backwards compatibility.  Functionality superseded by sigaction.
 */
3816
SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
L
Linus Torvalds 已提交
3817 3818 3819 3820 3821 3822
{
	struct k_sigaction new_sa, old_sa;
	int ret;

	new_sa.sa.sa_handler = handler;
	new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
3823
	sigemptyset(&new_sa.sa.sa_mask);
L
Linus Torvalds 已提交
3824 3825 3826 3827 3828 3829 3830 3831 3832

	ret = do_sigaction(sig, &new_sa, &old_sa);

	return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
}
#endif /* __ARCH_WANT_SYS_SIGNAL */

#ifdef __ARCH_WANT_SYS_PAUSE

3833
SYSCALL_DEFINE0(pause)
L
Linus Torvalds 已提交
3834
{
3835
	while (!signal_pending(current)) {
3836
		__set_current_state(TASK_INTERRUPTIBLE);
3837 3838
		schedule();
	}
L
Linus Torvalds 已提交
3839 3840 3841 3842 3843
	return -ERESTARTNOHAND;
}

#endif

3844
static int sigsuspend(sigset_t *set)
A
Al Viro 已提交
3845 3846 3847 3848
{
	current->saved_sigmask = current->blocked;
	set_current_blocked(set);

3849 3850 3851 3852
	while (!signal_pending(current)) {
		__set_current_state(TASK_INTERRUPTIBLE);
		schedule();
	}
A
Al Viro 已提交
3853 3854 3855 3856
	set_restore_sigmask();
	return -ERESTARTNOHAND;
}

3857 3858 3859 3860 3861 3862
/**
 *  sys_rt_sigsuspend - replace the signal mask for a value with the
 *	@unewset value until a signal is received
 *  @unewset: new signal mask value
 *  @sigsetsize: size of sigset_t type
 */
3863
SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
3864 3865 3866 3867 3868 3869 3870 3871 3872
{
	sigset_t newset;

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(sigset_t))
		return -EINVAL;

	if (copy_from_user(&newset, unewset, sizeof(newset)))
		return -EFAULT;
A
Al Viro 已提交
3873
	return sigsuspend(&newset);
3874
}
A
Al Viro 已提交
3875 3876 3877 3878 3879 3880 3881 3882 3883 3884
 
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
{
	sigset_t newset;

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(sigset_t))
		return -EINVAL;

A
Al Viro 已提交
3885
	if (get_compat_sigset(&newset, unewset))
A
Al Viro 已提交
3886 3887 3888 3889
		return -EFAULT;
	return sigsuspend(&newset);
}
#endif
3890

3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906
#ifdef CONFIG_OLD_SIGSUSPEND
SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
{
	sigset_t blocked;
	siginitset(&blocked, mask);
	return sigsuspend(&blocked);
}
#endif
#ifdef CONFIG_OLD_SIGSUSPEND3
SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask)
{
	sigset_t blocked;
	siginitset(&blocked, mask);
	return sigsuspend(&blocked);
}
#endif
3907

3908
__weak const char *arch_vma_name(struct vm_area_struct *vma)
3909 3910 3911 3912
{
	return NULL;
}

L
Linus Torvalds 已提交
3913 3914
void __init signals_init(void)
{
3915 3916 3917
	/* If this check fails, the __ARCH_SI_PREAMBLE_SIZE value is wrong! */
	BUILD_BUG_ON(__ARCH_SI_PREAMBLE_SIZE
		!= offsetof(struct siginfo, _sifields._pad));
3918
	BUILD_BUG_ON(sizeof(struct siginfo) != SI_MAX_SIZE);
3919

3920
	sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
L
Linus Torvalds 已提交
3921
}
3922 3923 3924 3925

#ifdef CONFIG_KGDB_KDB
#include <linux/kdb.h>
/*
3926
 * kdb_send_sig - Allows kdb to send signals without exposing
3927 3928 3929 3930
 * signal internals.  This function checks if the required locks are
 * available before calling the main signal code, to avoid kdb
 * deadlocks.
 */
3931
void kdb_send_sig(struct task_struct *t, int sig)
3932 3933
{
	static struct task_struct *kdb_prev_t;
3934
	int new_t, ret;
3935 3936 3937 3938 3939 3940 3941 3942 3943
	if (!spin_trylock(&t->sighand->siglock)) {
		kdb_printf("Can't do kill command now.\n"
			   "The sigmask lock is held somewhere else in "
			   "kernel, try again later\n");
		return;
	}
	new_t = kdb_prev_t != t;
	kdb_prev_t = t;
	if (t->state != TASK_RUNNING && new_t) {
3944
		spin_unlock(&t->sighand->siglock);
3945 3946 3947 3948 3949 3950 3951 3952
		kdb_printf("Process is not RUNNING, sending a signal from "
			   "kdb risks deadlock\n"
			   "on the run queue locks. "
			   "The signal has _not_ been sent.\n"
			   "Reissue the kill command if you want to risk "
			   "the deadlock.\n");
		return;
	}
3953 3954 3955
	ret = send_signal(sig, SEND_SIG_PRIV, t, false);
	spin_unlock(&t->sighand->siglock);
	if (ret)
3956 3957 3958 3959 3960 3961
		kdb_printf("Fail to deliver Signal %d to process %d.\n",
			   sig, t->pid);
	else
		kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
}
#endif	/* CONFIG_KGDB_KDB */