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 bool 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
		return true;
84 85 86 87

	return sig_handler_ignored(handler, sig);
}

88
static bool 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))
96
		return false;
L
Linus Torvalds 已提交
97

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
	if (t->ptrace && sig != SIGKILL)
104
		return false;
105 106

	return sig_task_ignored(t, sig, force);
L
Linus Torvalds 已提交
107 108 109 110 111 112
}

/*
 * Re-calculate pending state from the set of locally pending
 * signals, globally pending signals, and blocked signals.
 */
113
static inline bool has_pending_signals(sigset_t *signal, sigset_t *blocked)
L
Linus Torvalds 已提交
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
{
	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))

141
static bool 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);
147
		return true;
R
Roland McGrath 已提交
148
	}
149

150 151 152 153 154
	/*
	 * 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.
	 */
155
	return false;
R
Roland McGrath 已提交
156 157 158 159 160 161 162 163 164 165
}

/*
 * 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 已提交
166 167 168 169
}

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

L
Linus Torvalds 已提交
174 175 176 177
}

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

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

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

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

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

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

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

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

228 229 230 231 232 233 234 235 236 237
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;

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

242
/**
243
 * task_set_jobctl_pending - set jobctl pending bits
244
 * @task: target task
245
 * @mask: pending bits to set
246
 *
247 248 249 250 251 252 253 254 255 256 257 258
 * 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.
 */
259
bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
{
	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;
}

275
/**
276
 * task_clear_jobctl_trapping - clear jobctl trapping bit
277 278
 * @task: target task
 *
279 280 281 282
 * 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.
283 284 285 286
 *
 * CONTEXT:
 * Must be called with @task->sighand->siglock held.
 */
287
void task_clear_jobctl_trapping(struct task_struct *task)
288
{
289 290
	if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
		task->jobctl &= ~JOBCTL_TRAPPING;
291
		smp_mb();	/* advised by wake_up_bit() */
292
		wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
293 294 295
	}
}

296
/**
297
 * task_clear_jobctl_pending - clear jobctl pending bits
298
 * @task: target task
299
 * @mask: pending bits to clear
300
 *
301 302 303
 * 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.
304
 *
305 306
 * If clearing of @mask leaves no stop or trap pending, this function calls
 * task_clear_jobctl_trapping().
307 308 309 310
 *
 * CONTEXT:
 * Must be called with @task->sighand->siglock held.
 */
311
void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
312
{
313 314 315 316 317 318
	BUG_ON(mask & ~JOBCTL_PENDING_MASK);

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

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

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

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

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

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

	if (!consume)
		return false;

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

355 356 357 358 359
	/*
	 * 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)) {
360
		signal_set_stop_flags(sig, SIGNAL_STOP_STOPPED);
361 362 363 364 365
		return true;
	}
	return false;
}

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

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

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

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

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

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

415
void flush_sigqueue(struct sigpending *queue)
L
Linus Torvalds 已提交
416 417 418 419 420 421 422 423 424 425 426 427
{
	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);
	}
}

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

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

441
#ifdef CONFIG_POSIX_TIMERS
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 474
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);
}
475
#endif
476

477 478 479 480 481 482 483 484 485 486
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 已提交
487 488 489 490 491 492 493 494 495 496 497 498 499
/*
 * 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;
500
#ifdef __ARCH_HAS_SA_RESTORER
501 502
		ka->sa.sa_restorer = NULL;
#endif
L
Linus Torvalds 已提交
503 504 505 506 507
		sigemptyset(&ka->sa.sa_mask);
		ka++;
	}
}

508
bool unhandled_signal(struct task_struct *tsk, int sig)
509
{
510
	void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
511
	if (is_global_init(tsk))
512 513
		return true;

514
	if (handler != SIG_IGN && handler != SIG_DFL)
515 516
		return false;

T
Tejun Heo 已提交
517 518
	/* if ptraced, let the tracer determine */
	return !tsk->ptrace;
519 520
}

521 522
static void collect_signal(int sig, struct sigpending *list, siginfo_t *info,
			   bool *resched_timer)
L
Linus Torvalds 已提交
523 524 525 526 527 528 529 530 531
{
	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) {
532 533
			if (first)
				goto still_pending;
L
Linus Torvalds 已提交
534 535 536
			first = q;
		}
	}
537 538 539

	sigdelset(&list->signal, sig);

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

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

L
Linus Torvalds 已提交
550 551
		__sigqueue_free(first);
	} else {
552 553 554 555
		/*
		 * 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 已提交
556
		 */
557
		clear_siginfo(info);
L
Linus Torvalds 已提交
558 559
		info->si_signo = sig;
		info->si_errno = 0;
560
		info->si_code = SI_USER;
L
Linus Torvalds 已提交
561 562 563 564 565 566
		info->si_pid = 0;
		info->si_uid = 0;
	}
}

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

571
	if (sig)
572
		collect_signal(sig, pending, info, resched_timer);
L
Linus Torvalds 已提交
573 574 575 576
	return sig;
}

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

	/* We only dequeue private signals from ourselves, we don't let
	 * signalfd steal them
	 */
590
	signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer);
591
	if (!signr) {
L
Linus Torvalds 已提交
592
		signr = __dequeue_signal(&tsk->signal->shared_pending,
593
					 mask, info, &resched_timer);
594
#ifdef CONFIG_POSIX_TIMERS
595 596 597 598 599 600
		/*
		 * 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
601
		 * compliant with the old way of self-restarting
602 603 604 605 606 607 608 609 610 611
		 * 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 已提交
612
			    tsk->signal->it_real_incr != 0) {
613 614 615 616 617
				hrtimer_forward(tmr, tmr->base->get_time(),
						tsk->signal->it_real_incr);
				hrtimer_restart(tmr);
			}
		}
618
#endif
619
	}
620

D
Davide Libenzi 已提交
621
	recalc_sigpending();
622 623 624 625
	if (!signr)
		return 0;

	if (unlikely(sig_kernel_stop(signr))) {
626 627 628 629 630 631 632 633 634 635 636 637
		/*
		 * 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.
		 */
638
		current->jobctl |= JOBCTL_STOP_DEQUEUED;
639
	}
640
#ifdef CONFIG_POSIX_TIMERS
641
	if (resched_timer) {
L
Linus Torvalds 已提交
642 643 644 645 646 647 648
		/*
		 * 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);
649
		posixtimer_rearm(info);
L
Linus Torvalds 已提交
650
		spin_lock(&tsk->sighand->siglock);
651 652 653

		/* Don't expose the si_sys_private value to userspace */
		info->si_sys_private = 0;
L
Linus Torvalds 已提交
654
	}
655
#endif
L
Linus Torvalds 已提交
656 657 658 659 660 661 662 663 664 665 666 667 668 669
	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
 */
670
void signal_wake_up_state(struct task_struct *t, unsigned int state)
L
Linus Torvalds 已提交
671 672 673
{
	set_tsk_thread_flag(t, TIF_SIGPENDING);
	/*
674
	 * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
M
Matthew Wilcox 已提交
675
	 * case. We don't check t->state here because there is a race with it
L
Linus Torvalds 已提交
676 677 678 679
	 * 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.
	 */
680
	if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
L
Linus Torvalds 已提交
681 682 683
		kick_process(t);
}

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

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

699
	sigandnsets(&s->signal, &s->signal, mask);
700 701 702 703 704 705 706
	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);
		}
	}
}
L
Linus Torvalds 已提交
707

708 709 710 711 712 713 714 715 716 717 718
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));
}

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

727 728 729 730 731
	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);
732 733
}

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

744
	if (!valid_signal(sig))
745 746
		return -EINVAL;

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

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

754
	if (!same_thread_group(current, t) &&
755
	    !kill_ok_by_cred(t)) {
756 757 758 759 760 761 762 763 764 765 766 767 768
		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;
		}
	}
769

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

773 774 775 776 777 778 779 780
/**
 * 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 已提交
781 782 783 784 785
 * 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.
786 787 788 789 790 791 792 793 794 795
 *
 * 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);
796
	ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
797 798
}

L
Linus Torvalds 已提交
799
/*
800 801
 * Handle magic process-wide effects of stop/continue signals. Unlike
 * the signal actions, these happen immediately at signal-generation
L
Linus Torvalds 已提交
802 803
 * time regardless of blocking, ignoring, or handling.  This does the
 * actual continuing for SIGCONT, but not the actual stopping for stop
804 805 806 807
 * 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 已提交
808
 */
809
static bool prepare_signal(int sig, struct task_struct *p, bool force)
L
Linus Torvalds 已提交
810
{
811
	struct signal_struct *signal = p->signal;
L
Linus Torvalds 已提交
812
	struct task_struct *t;
813
	sigset_t flush;
L
Linus Torvalds 已提交
814

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

845 846 847 848 849 850 851 852 853
		/*
		 * 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;
854
		if (signal->flags & SIGNAL_STOP_STOPPED)
855
			why |= SIGNAL_CLD_CONTINUED;
856
		else if (signal->group_stop_count)
857 858 859
			why |= SIGNAL_CLD_STOPPED;

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

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

874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
/*
 * 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);
}

895
static void complete_signal(int sig, struct task_struct *p, int group)
896 897 898 899 900 901 902 903 904 905 906 907
{
	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;
908
	else if (!group || thread_group_empty(p))
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 934 935
		/*
		 * 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.
	 */
936
	if (sig_fatal(p, sig) &&
937
	    !(signal->flags & SIGNAL_GROUP_EXIT) &&
938
	    !sigismember(&t->real_blocked, sig) &&
939
	    (sig == SIGKILL || !p->ptrace)) {
940 941 942 943 944 945 946 947 948 949 950 951 952 953 954
		/*
		 * 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 {
955
				task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
956 957 958 959 960 961 962 963 964 965 966 967 968 969 970
				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;
}

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

976 977 978 979 980 981 982 983 984
#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;

985 986 987 988
	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();
989 990 991 992 993 994 995 996
}
#else
static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
{
	return;
}
#endif

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

1005
	assert_spin_locked(&t->sighand->siglock);
1006

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

	pending = group ? &t->signal->shared_pending : &t->pending;
1013 1014 1015 1016 1017
	/*
	 * 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.
	 */
1018
	result = TRACE_SIGNAL_ALREADY_PENDING;
1019
	if (legacy_queue(pending, sig))
1020 1021 1022
		goto ret;

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

1030 1031 1032 1033 1034 1035 1036 1037 1038
	/*
	 * 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.
	 */
1039 1040 1041 1042 1043
	if (sig < SIGRTMIN)
		override_rlimit = (is_si_special(info) || info->si_code >= 0);
	else
		override_rlimit = 0;

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

		userns_fixup_signal_uid(&q->info, t);

1074
	} else if (!is_si_special(info)) {
1075 1076 1077 1078 1079 1080
		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().
			 */
1081 1082 1083
			result = TRACE_SIGNAL_OVERFLOW_FAIL;
			ret = -EAGAIN;
			goto ret;
1084 1085 1086 1087 1088
		} else {
			/*
			 * This is a silent loss of information.  We still
			 * send the signal, but the *info bits are lost.
			 */
1089
			result = TRACE_SIGNAL_LOSE_INFO;
1090
		}
L
Linus Torvalds 已提交
1091 1092 1093
	}

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

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

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

	return __send_signal(sig, info, t, group, from_ancestor_ns);
1113 1114
}

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

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

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

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 已提交
1147

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

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

1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
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 已提交
1174 1175 1176
/*
 * Force a signal that the process can't ignore: if necessary
 * we unblock the signal and change any SIG_IGN to SIG_DFL.
1177 1178 1179 1180 1181
 *
 * 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.
 *
1182 1183
 * We don't want to have recursive SIGSEGV's etc, for example,
 * that is why we also clear SIGNAL_UNKILLABLE.
L
Linus Torvalds 已提交
1184 1185 1186 1187 1188
 */
int
force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
	unsigned long int flags;
1189 1190
	int ret, blocked, ignored;
	struct k_sigaction *action;
L
Linus Torvalds 已提交
1191 1192

	spin_lock_irqsave(&t->sighand->siglock, flags);
1193 1194 1195 1196 1197 1198 1199
	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 已提交
1200
			recalc_sigpending_and_wake(t);
1201
		}
L
Linus Torvalds 已提交
1202
	}
1203 1204 1205 1206 1207
	/*
	 * 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)
1208
		t->signal->flags &= ~SIGNAL_UNKILLABLE;
L
Linus Torvalds 已提交
1209 1210 1211 1212 1213 1214 1215 1216 1217
	ret = specific_send_sig_info(sig, info, t);
	spin_unlock_irqrestore(&t->sighand->siglock, flags);

	return ret;
}

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

	p->signal->group_stop_count = 0;

1225
	while_each_thread(p, t) {
1226
		task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1227 1228 1229
		count++;

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

	return count;
L
Linus Torvalds 已提交
1237 1238
}

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

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

1250 1251
		/*
		 * This sighand can be already freed and even reused, but
1252
		 * we rely on SLAB_TYPESAFE_BY_RCU and sighand_ctor() which
1253 1254 1255 1256 1257 1258 1259 1260
		 * 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.
		 */
1261 1262
		spin_lock_irqsave(&sighand->siglock, *flags);
		if (likely(sighand == tsk->sighand))
1263
			break;
1264
		spin_unlock_irqrestore(&sighand->siglock, *flags);
1265
	}
1266
	rcu_read_unlock();
1267 1268 1269 1270

	return sighand;
}

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

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

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

	return ret;
}

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

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

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

1313 1314 1315 1316 1317 1318 1319 1320
	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;
1321

1322 1323 1324 1325 1326 1327
		/*
		 * 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 已提交
1328 1329
}

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

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

	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);
1348 1349
}

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

	if (!valid_signal(sig))
		return ret;

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

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

/*
 * 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.
 */

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

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

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

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

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

1431
	return ret;
L
Linus Torvalds 已提交
1432 1433 1434 1435 1436 1437
}

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

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

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

1450 1451 1452
#define __si_special(priv) \
	((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)

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

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

/*
 * 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..
 */
1470
void force_sigsegv(int sig, struct task_struct *p)
L
Linus Torvalds 已提交
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
{
	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);
}

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 1525 1526
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);
}

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 1582 1583
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
1584

1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599
/* 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);
}

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

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

	return ret;
1609 1610 1611 1612 1613 1614 1615 1616 1617
}
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 已提交
1618 1619 1620 1621
/*
 * 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
1622
 * expirations or I/O completions".  In the case of POSIX Timers
L
Linus Torvalds 已提交
1623 1624 1625 1626 1627 1628
 * 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)
{
1629
	struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
L
Linus Torvalds 已提交
1630

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

	return q;
L
Linus Torvalds 已提交
1635 1636 1637 1638 1639
}

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

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

1658 1659
	if (q)
		__sigqueue_free(q);
L
Linus Torvalds 已提交
1660 1661
}

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

1669
	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1670 1671 1672 1673 1674

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

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

	ret = 0;
1681 1682 1683 1684 1685 1686 1687
	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++;
1688
		result = TRACE_SIGNAL_ALREADY_PENDING;
1689
		goto out;
1690
	}
1691
	q->info.si_overrun = 0;
1692 1693

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

L
Linus Torvalds 已提交
1706 1707 1708
/*
 * 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 已提交
1709
 *
1710 1711
 * Returns true if our parent ignored us and so we've switched to
 * self-reaping.
L
Linus Torvalds 已提交
1712
 */
1713
bool do_notify_parent(struct task_struct *tsk, int sig)
L
Linus Torvalds 已提交
1714 1715 1716 1717
{
	struct siginfo info;
	unsigned long flags;
	struct sighand_struct *psig;
1718
	bool autoreap = false;
1719
	u64 utime, stime;
L
Linus Torvalds 已提交
1720 1721 1722 1723

	BUG_ON(sig == -1);

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

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

1729 1730 1731 1732 1733 1734 1735 1736 1737
	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;
	}

1738
	clear_siginfo(&info);
L
Linus Torvalds 已提交
1739 1740
	info.si_signo = sig;
	info.si_errno = 0;
1741
	/*
1742 1743
	 * We are under tasklist_lock here so our parent is tied to
	 * us and cannot change.
1744
	 *
1745 1746
	 * task_active_pid_ns will always return the same pid namespace
	 * until a task passes through release_task.
1747 1748 1749 1750 1751 1752
	 *
	 * 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();
1753
	info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1754 1755
	info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
				       task_uid(tsk));
1756 1757
	rcu_read_unlock();

1758 1759 1760
	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 已提交
1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773

	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 已提交
1774
	if (!tsk->ptrace && sig == SIGCHLD &&
L
Linus Torvalds 已提交
1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791
	    (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).
		 */
1792
		autoreap = true;
L
Linus Torvalds 已提交
1793
		if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1794
			sig = 0;
L
Linus Torvalds 已提交
1795
	}
1796
	if (valid_signal(sig) && sig)
L
Linus Torvalds 已提交
1797 1798 1799
		__group_send_sig_info(sig, &info, tsk->parent);
	__wake_up_parent(tsk, tsk->parent);
	spin_unlock_irqrestore(&psig->siglock, flags);
R
Roland McGrath 已提交
1800

1801
	return autoreap;
L
Linus Torvalds 已提交
1802 1803
}

1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818
/**
 * 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 已提交
1819 1820 1821
{
	struct siginfo info;
	unsigned long flags;
1822
	struct task_struct *parent;
L
Linus Torvalds 已提交
1823
	struct sighand_struct *sighand;
1824
	u64 utime, stime;
L
Linus Torvalds 已提交
1825

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

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

1844 1845 1846
	task_cputime(tsk, &utime, &stime);
	info.si_utime = nsec_to_clock_t(utime);
	info.si_stime = nsec_to_clock_t(stime);
L
Linus Torvalds 已提交
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 1873 1874

 	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);
}

1875
static inline bool may_ptrace_stop(void)
1876
{
T
Tejun Heo 已提交
1877
	if (!likely(current->ptrace))
1878
		return false;
1879 1880 1881 1882 1883 1884
	/*
	 * 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
1885
	 * ->siglock we must see ->core_state != NULL. Otherwise it
1886
	 * is safe to enter schedule().
1887 1888 1889 1890
	 *
	 * 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.
1891
	 */
1892
	if (unlikely(current->mm->core_state) &&
1893
	    unlikely(current->mm == current->parent->mm))
1894
		return false;
1895

1896
	return true;
1897 1898
}

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

L
Linus Torvalds 已提交
1909 1910 1911 1912 1913 1914 1915 1916
/*
 * 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.
 *
1917 1918
 * 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 已提交
1919
 */
T
Tejun Heo 已提交
1920
static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
1921 1922
	__releases(&current->sighand->siglock)
	__acquires(&current->sighand->siglock)
L
Linus Torvalds 已提交
1923
{
1924 1925
	bool gstop_done = false;

R
Roland McGrath 已提交
1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940
	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);
1941 1942
		if (sigkill_pending(current))
			return;
R
Roland McGrath 已提交
1943 1944
	}

1945 1946
	set_special_state(TASK_TRACED);

L
Linus Torvalds 已提交
1947
	/*
1948 1949 1950 1951 1952
	 * 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.
1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963
	 *
	 *     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 已提交
1964
	 */
1965
	smp_wmb();
L
Linus Torvalds 已提交
1966 1967 1968 1969

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

1970
	/*
1971 1972
	 * If @why is CLD_STOPPED, we're trapping to participate in a group
	 * stop.  Do the bookkeeping.  Note that if SIGCONT was delievered
1973 1974 1975
	 * 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.
1976
	 */
1977
	if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
1978
		gstop_done = task_participate_group_stop(current);
1979

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

1985
	/* entering a trap, clear TRAPPING */
1986
	task_clear_jobctl_trapping(current);
1987

L
Linus Torvalds 已提交
1988 1989
	spin_unlock_irq(&current->sighand->siglock);
	read_lock(&tasklist_lock);
1990
	if (may_ptrace_stop()) {
1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001
		/*
		 * 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);
2002
		if (gstop_done && ptrace_reparented(current))
2003 2004
			do_notify_parent_cldstop(current, false, why);

M
Miklos Szeredi 已提交
2005 2006 2007 2008 2009 2010 2011
		/*
		 * 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 已提交
2012
		read_unlock(&tasklist_lock);
M
Miklos Szeredi 已提交
2013
		preempt_enable_no_resched();
2014
		freezable_schedule();
L
Linus Torvalds 已提交
2015 2016 2017
	} else {
		/*
		 * By the time we got the lock, our tracer went away.
2018
		 * Don't drop the lock yet, another tracer may come.
2019 2020 2021
		 *
		 * If @gstop_done, the ptracer went away between group stop
		 * completion and here.  During detach, it would have set
2022 2023 2024
		 * 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 已提交
2025
		 */
2026 2027 2028
		if (gstop_done)
			do_notify_parent_cldstop(current, false, why);

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

	/*
	 * 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 已提交
2044 2045 2046
	/* LISTENING can be set only during STOP traps, clear it */
	current->jobctl &= ~JOBCTL_LISTENING;

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

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

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

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

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

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

2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100
/**
 * 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 已提交
2101
 */
2102 2103
static bool do_signal_stop(int signr)
	__releases(&current->sighand->siglock)
L
Linus Torvalds 已提交
2104 2105 2106
{
	struct signal_struct *sig = current->signal;

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

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

2114
		if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
2115
		    unlikely(signal_group_exit(sig)))
2116
			return false;
L
Linus Torvalds 已提交
2117
		/*
2118 2119 2120 2121 2122 2123 2124
		 * 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
2125 2126
		 * cause two group stops when !ptraced.  That is why we
		 * also check !task_is_stopped(t) below.
2127 2128 2129 2130 2131 2132 2133 2134
		 *
		 * 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 已提交
2135
		 */
2136 2137
		if (!(sig->flags & SIGNAL_STOP_STOPPED))
			sig->group_exit_code = signr;
L
Linus Torvalds 已提交
2138

2139 2140 2141 2142
		sig->group_stop_count = 0;

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

2144 2145
		t = current;
		while_each_thread(current, t) {
L
Linus Torvalds 已提交
2146
			/*
2147 2148 2149
			 * 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 已提交
2150
			 */
2151 2152
			if (!task_is_stopped(t) &&
			    task_set_jobctl_pending(t, signr | gstop)) {
2153
				sig->group_stop_count++;
2154 2155 2156 2157
				if (likely(!(t->ptrace & PT_SEIZED)))
					signal_wake_up(t, 0);
				else
					ptrace_trap_notify(t);
2158
			}
2159
		}
L
Linus Torvalds 已提交
2160
	}
2161

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

2165 2166 2167 2168 2169 2170 2171 2172
		/*
		 * 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;

2173
		set_special_state(TASK_STOPPED);
2174 2175
		spin_unlock_irq(&current->sighand->siglock);

2176 2177 2178 2179 2180 2181 2182 2183 2184
		/*
		 * 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.
		 */
2185 2186
		if (notify) {
			read_lock(&tasklist_lock);
2187
			do_notify_parent_cldstop(current, false, notify);
2188 2189 2190 2191
			read_unlock(&tasklist_lock);
		}

		/* Now we don't run again until woken by SIGCONT or SIGKILL */
2192
		freezable_schedule();
2193
		return true;
2194
	} else {
2195 2196 2197 2198 2199 2200
		/*
		 * 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;
2201
	}
2202
}
L
Linus Torvalds 已提交
2203

2204 2205 2206
/**
 * do_jobctl_trap - take care of ptrace jobctl traps
 *
T
Tejun Heo 已提交
2207 2208 2209 2210 2211 2212 2213
 * 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.
2214 2215 2216 2217 2218 2219 2220
 *
 * 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 已提交
2221
	struct signal_struct *signal = current->signal;
2222
	int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2223

T
Tejun Heo 已提交
2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234
	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;
2235
	}
L
Linus Torvalds 已提交
2236 2237
}

2238
static int ptrace_signal(int signr, siginfo_t *info)
R
Roland McGrath 已提交
2239
{
2240 2241 2242 2243 2244 2245 2246 2247 2248 2249
	/*
	 * 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 已提交
2250
	ptrace_stop(signr, CLD_TRAPPED, 0, info);
R
Roland McGrath 已提交
2251 2252 2253 2254 2255 2256 2257 2258

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

	current->exit_code = 0;

2259 2260 2261 2262 2263 2264
	/*
	 * 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 已提交
2265
	if (signr != info->si_signo) {
2266
		clear_siginfo(info);
R
Roland McGrath 已提交
2267 2268 2269
		info->si_signo = signr;
		info->si_errno = 0;
		info->si_code = SI_USER;
2270
		rcu_read_lock();
R
Roland McGrath 已提交
2271
		info->si_pid = task_pid_vnr(current->parent);
2272 2273
		info->si_uid = from_kuid_munged(current_user_ns(),
						task_uid(current->parent));
2274
		rcu_read_unlock();
R
Roland McGrath 已提交
2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285
	}

	/* 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;
}

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

2292 2293
	if (unlikely(current->task_works))
		task_work_run();
2294

2295 2296 2297
	if (unlikely(uprobe_deny_signal()))
		return 0;

R
Roland McGrath 已提交
2298
	/*
2299 2300 2301
	 * 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 已提交
2302
	 */
2303 2304
	try_to_freeze();

2305
relock:
2306
	spin_lock_irq(&sighand->siglock);
2307 2308 2309 2310 2311
	/*
	 * 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.
	 */
2312
	if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2313 2314 2315 2316 2317 2318 2319
		int why;

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

2320
		signal->flags &= ~SIGNAL_CLD_MASK;
2321

2322
		spin_unlock_irq(&sighand->siglock);
R
Roland McGrath 已提交
2323

2324 2325 2326 2327 2328 2329 2330 2331
		/*
		 * 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 已提交
2332
		read_lock(&tasklist_lock);
2333 2334
		do_notify_parent_cldstop(current, false, why);

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

2340 2341 2342
		goto relock;
	}

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

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

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

2356
		signr = dequeue_signal(current, &current->blocked, &ksig->info);
2357

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

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

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

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

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

			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;

2390
		/*
2391
		 * Global init gets no signals it doesn't want.
2392 2393 2394 2395 2396 2397 2398
		 * 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.
2399
		 */
2400
		if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2401
				!sig_kernel_only(signr))
L
Linus Torvalds 已提交
2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415
			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) {
2416
				spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2417 2418 2419

				/* signals can be posted during this window */

2420
				if (is_current_pgrp_orphaned())
L
Linus Torvalds 已提交
2421 2422
					goto relock;

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

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

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

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

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

L
Linus Torvalds 已提交
2445
		if (sig_kernel_coredump(signr)) {
2446
			if (print_fatal_signals)
2447
				print_fatal_signal(ksig->info.si_signo);
2448
			proc_coredump_connector(current);
L
Linus Torvalds 已提交
2449 2450 2451 2452 2453 2454 2455 2456
			/*
			 * 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.
			 */
2457
			do_coredump(&ksig->info);
L
Linus Torvalds 已提交
2458 2459 2460 2461 2462
		}

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

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

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

2486 2487 2488 2489 2490 2491
	/* 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 已提交
2492 2493 2494
	sigorsets(&blocked, &current->blocked, &ksig->ka.sa.sa_mask);
	if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
		sigaddset(&blocked, ksig->sig);
2495
	set_current_blocked(&blocked);
2496
	tracehook_signal_handler(stepping);
2497 2498
}

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

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

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

2521 2522
	t = tsk;
	while_each_thread(tsk, t) {
2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535
		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;
2536 2537 2538
	}
}

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

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

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

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

2563
	cgroup_threadgroup_change_end(tsk);
2564

2565 2566 2567
	if (!signal_pending(tsk))
		goto out;

2568 2569 2570
	unblocked = tsk->blocked;
	signotset(&unblocked);
	retarget_shared_pending(tsk, &unblocked);
2571

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

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

L
Linus Torvalds 已提交
2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600
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.
 */

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

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

2615 2616 2617 2618 2619
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. */
2620
		sigandnsets(&newblocked, newset, &current->blocked);
2621 2622 2623 2624 2625 2626
		retarget_shared_pending(tsk, &newblocked);
	}
	tsk->blocked = *newset;
	recalc_sigpending();
}

2627 2628 2629 2630 2631 2632
/**
 * 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 已提交
2633
 */
2634 2635 2636
void set_current_blocked(sigset_t *newset)
{
	sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2637
	__set_current_blocked(newset);
2638 2639 2640
}

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

2644 2645 2646 2647 2648 2649 2650
	/*
	 * 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;

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

/*
 * 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)
{
2666 2667
	struct task_struct *tsk = current;
	sigset_t newset;
L
Linus Torvalds 已提交
2668

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

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

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

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

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

2708 2709 2710 2711 2712
	old_set = current->blocked;

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

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

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

	return 0;
L
Linus Torvalds 已提交
2726 2727
}

A
Al Viro 已提交
2728 2729 2730
#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 已提交
2731
{
A
Al Viro 已提交
2732 2733 2734 2735 2736 2737 2738 2739 2740
	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 已提交
2741
		if (get_compat_sigset(&new_set, nset))
A
Al Viro 已提交
2742 2743 2744 2745 2746 2747 2748
			return -EFAULT;
		sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));

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

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

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

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

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

2777 2778 2779 2780 2781 2782
	do_sigpending(&set);

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

	return 0;
A
Al Viro 已提交
2783 2784 2785 2786 2787
}

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

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

2794 2795 2796
	do_sigpending(&set);

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

2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811
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 },
2812
#if defined(SIGEMT) && defined(NSIGEMT)
2813 2814 2815 2816 2817 2818
			[SIGEMT]  = { NSIGEMT,  SIL_FAULT },
#endif
			[SIGCHLD] = { NSIGCHLD, SIL_CHLD },
			[SIGPOLL] = { NSIGPOLL, SIL_POLL },
			[SIGSYS]  = { NSIGSYS,  SIL_SYS },
		};
2819
		if ((sig < ARRAY_SIZE(filter)) && (si_code <= filter[sig].limit)) {
2820
			layout = filter[sig].layout;
2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831
			/* 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
		}
2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844
		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 已提交
2845
int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
L
Linus Torvalds 已提交
2846
{
2847
	if (copy_to_user(to, from , sizeof(struct siginfo)))
L
Linus Torvalds 已提交
2848
		return -EFAULT;
2849
	return 0;
L
Linus Torvalds 已提交
2850 2851
}

2852
#ifdef CONFIG_COMPAT
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 2886 2887
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
2888 2889 2890 2891 2892
		break;
	case SIL_FAULT_MCEERR:
		new.si_addr = ptr_to_compat(from->si_addr);
#ifdef __ARCH_SI_TRAPNO
		new.si_trapno = from->si_trapno;
2893
#endif
2894 2895 2896 2897 2898 2899
		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;
2900
#endif
2901 2902 2903 2904 2905 2906 2907
		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;
2908
#endif
2909
		new.si_pkey = from->si_pkey;
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 2942 2943
		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;
}

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 2973 2974
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
2975 2976 2977 2978 2979
		break;
	case SIL_FAULT_MCEERR:
		to->si_addr = compat_ptr(from.si_addr);
#ifdef __ARCH_SI_TRAPNO
		to->si_trapno = from.si_trapno;
2980
#endif
2981 2982 2983 2984 2985 2986
		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;
2987
#endif
2988 2989 2990 2991 2992 2993 2994
		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;
2995
#endif
2996
		to->si_pkey = from.si_pkey;
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 3026 3027
		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 */

3028 3029 3030 3031 3032 3033
/**
 *  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
 */
3034
static int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
3035
		    const struct timespec *ts)
3036
{
T
Thomas Gleixner 已提交
3037
	ktime_t *to = NULL, timeout = KTIME_MAX;
3038 3039
	struct task_struct *tsk = current;
	sigset_t mask = *which;
3040
	int sig, ret = 0;
3041 3042 3043 3044

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

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

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

	if (sig)
		return sig;
3081
	return ret ? -EINTR : -EAGAIN;
3082 3083
}

3084 3085 3086 3087 3088 3089 3090 3091
/**
 *  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
 */
3092 3093 3094
SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
		siginfo_t __user *, uinfo, const struct timespec __user *, uts,
		size_t, sigsetsize)
L
Linus Torvalds 已提交
3095 3096 3097 3098
{
	sigset_t these;
	struct timespec ts;
	siginfo_t info;
3099
	int ret;
L
Linus Torvalds 已提交
3100 3101 3102 3103 3104 3105 3106

	/* 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;
3107

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

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

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

	return ret;
}

3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135
#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 已提交
3136
	if (get_compat_sigset(&s, uthese))
3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154
		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

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

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

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

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

3180
	rcu_read_lock();
3181
	p = find_task_by_vpid(pid);
3182
	if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
T
Thomas Gleixner 已提交
3183
		error = check_kill_permission(sig, info, p);
L
Linus Torvalds 已提交
3184 3185 3186 3187
		/*
		 * The null signal is a permissions and process existence
		 * probe.  No signal is actually delivered.
		 */
3188 3189 3190 3191 3192 3193 3194 3195 3196
		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 已提交
3197 3198
		}
	}
3199
	rcu_read_unlock();
3200

L
Linus Torvalds 已提交
3201 3202 3203
	return error;
}

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

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

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

3218 3219 3220 3221 3222 3223
/**
 *  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
 *
3224
 *  This syscall also checks the @tgid and returns -ESRCH even if the PID
3225 3226 3227
 *  exists but it's not belonging to the target process anymore. This
 *  method solves the problem of threads exiting and PIDs getting reused.
 */
3228
SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
3229 3230 3231 3232 3233 3234 3235 3236
{
	/* This is only valid for single tasks */
	if (pid <= 0 || tgid <= 0)
		return -EINVAL;

	return do_tkill(tgid, pid, sig);
}

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

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

A
Al Viro 已提交
3253 3254 3255 3256 3257
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.
	 */
3258
	if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3259
	    (task_pid_vnr(current) != pid))
A
Al Viro 已提交
3260
		return -EPERM;
3261

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

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

3268 3269 3270 3271 3272 3273
/**
 *  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
 */
3274 3275
SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
		siginfo_t __user *, uinfo)
L
Linus Torvalds 已提交
3276 3277 3278 3279
{
	siginfo_t info;
	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
		return -EFAULT;
A
Al Viro 已提交
3280 3281
	return do_rt_sigqueueinfo(pid, sig, &info);
}
L
Linus Torvalds 已提交
3282

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

3297
static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
3298 3299 3300 3301 3302 3303
{
	/* 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.
3304 3305
	 * Nor can they impersonate a kill()/tgkill(), which adds source info.
	 */
3306 3307
	if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
	    (task_pid_vnr(current) != pid))
3308
		return -EPERM;
3309

3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325
	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);
}

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

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

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

3351 3352
		sigemptyset(&mask);
		sigaddset(&mask, sig);
3353

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

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

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

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

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

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

3382 3383
	sigaction_compat_abi(act, oact);

L
Linus Torvalds 已提交
3384
	if (act) {
3385 3386
		sigdelsetmask(&act->sa.sa_mask,
			      sigmask(SIGKILL) | sigmask(SIGSTOP));
3387
		*k = *act;
L
Linus Torvalds 已提交
3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398
		/*
		 * 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"
		 */
3399
		if (sig_handler_ignored(sig_handler(p, sig), sig)) {
3400 3401
			sigemptyset(&mask);
			sigaddset(&mask, sig);
3402 3403
			flush_sigqueue_mask(&mask, &p->signal->shared_pending);
			for_each_thread(p, t)
3404
				flush_sigqueue_mask(&mask, &t->pending);
L
Linus Torvalds 已提交
3405 3406 3407
		}
	}

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

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

3417 3418 3419 3420 3421 3422 3423
	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 已提交
3424

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

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

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

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

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

3454 3455
SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
{
3456 3457 3458 3459 3460 3461 3462 3463 3464
	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;
3465
}
L
Linus Torvalds 已提交
3466

A
Al Viro 已提交
3467 3468
int restore_altstack(const stack_t __user *uss)
{
3469 3470 3471 3472
	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 已提交
3473
	/* squash all but EFAULT for now */
3474
	return 0;
A
Al Viro 已提交
3475 3476
}

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

A
Al Viro 已提交
3490
#ifdef CONFIG_COMPAT
3491 3492
static int do_compat_sigaltstack(const compat_stack_t __user *uss_ptr,
				 compat_stack_t __user *uoss_ptr)
A
Al Viro 已提交
3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504
{
	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;
	}
3505
	ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss,
A
Al Viro 已提交
3506 3507
			     compat_user_stack_pointer());
	if (ret >= 0 && uoss_ptr)  {
3508 3509 3510 3511 3512 3513
		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 已提交
3514 3515 3516 3517 3518
			ret = -EFAULT;
	}
	return ret;
}

3519 3520 3521 3522 3523 3524 3525
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 已提交
3526 3527
int compat_restore_altstack(const compat_stack_t __user *uss)
{
3528
	int err = do_compat_sigaltstack(uss, NULL);
A
Al Viro 已提交
3529 3530 3531
	/* squash all but -EFAULT for now */
	return err == -EFAULT ? err : 0;
}
3532 3533 3534

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

#ifdef __ARCH_WANT_SYS_SIGPENDING

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

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

3562 3563 3564 3565 3566 3567
	do_sigpending(&set);

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

	return 0;
L
Linus Torvalds 已提交
3568 3569
}

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

	do_sigpending(&set);

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

L
Linus Torvalds 已提交
3581 3582 3583
#endif

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

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

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

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

3606
		new_blocked = current->blocked;
L
Linus Torvalds 已提交
3607 3608 3609

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

3622
		set_current_blocked(&new_blocked);
3623 3624 3625
	}

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

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

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

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

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

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

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

	return 0;
L
Linus Torvalds 已提交
3665
}
A
Al Viro 已提交
3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689
#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 已提交
3690
		ret |= get_compat_sigset(&new_ka.sa.sa_mask, &act->sa_mask);
3691
		ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
A
Al Viro 已提交
3692 3693 3694 3695 3696 3697 3698 3699
		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);
3700 3701
		ret |= put_compat_sigset(&oact->sa_mask, &old_ka.sa.sa_mask,
					 sizeof(oact->sa_mask));
3702
		ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
A
Al Viro 已提交
3703 3704 3705 3706 3707 3708 3709 3710
#ifdef __ARCH_HAS_SA_RESTORER
		ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
				&oact->sa_restorer);
#endif
	}
	return ret;
}
#endif
3711
#endif /* !CONFIG_ODD_RT_SIGACTION */
L
Linus Torvalds 已提交
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 3788 3789
#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 已提交
3790

3791
#ifdef CONFIG_SGETMASK_SYSCALL
L
Linus Torvalds 已提交
3792 3793 3794 3795

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

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

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

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

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

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

	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

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

#endif

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

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

3859 3860 3861 3862 3863 3864
/**
 *  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
 */
3865
SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
3866 3867 3868 3869 3870 3871 3872 3873 3874
{
	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 已提交
3875
	return sigsuspend(&newset);
3876
}
A
Al Viro 已提交
3877 3878 3879 3880 3881 3882 3883 3884 3885 3886
 
#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 已提交
3887
	if (get_compat_sigset(&newset, unewset))
A
Al Viro 已提交
3888 3889 3890 3891
		return -EFAULT;
	return sigsuspend(&newset);
}
#endif
3892

3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908
#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
3909

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

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

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

#ifdef CONFIG_KGDB_KDB
#include <linux/kdb.h>
/*
3928
 * kdb_send_sig - Allows kdb to send signals without exposing
3929 3930 3931 3932
 * signal internals.  This function checks if the required locks are
 * available before calling the main signal code, to avoid kdb
 * deadlocks.
 */
3933
void kdb_send_sig(struct task_struct *t, int sig)
3934 3935
{
	static struct task_struct *kdb_prev_t;
3936
	int new_t, ret;
3937 3938 3939 3940 3941 3942 3943 3944 3945
	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) {
3946
		spin_unlock(&t->sighand->siglock);
3947 3948 3949 3950 3951 3952 3953 3954
		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;
	}
3955 3956 3957
	ret = send_signal(sig, SEND_SIG_PRIV, t, false);
	spin_unlock(&t->sighand->siglock);
	if (ret)
3958 3959 3960 3961 3962 3963
		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 */