signal.c 101.5 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 69
static int sig_handler_ignored(void __user *handler, int sig)
{
70 71 72 73
	/* Is it explicitly or implicitly ignored? */
	return handler == SIG_IGN ||
		(handler == SIG_DFL && sig_kernel_ignore(sig));
}
L
Linus Torvalds 已提交
74

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

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

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

	return sig_handler_ignored(handler, sig);
}

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

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

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

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

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

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

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

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

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

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

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

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

L
Linus Torvalds 已提交
173 174 175 176
}

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

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

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

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

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

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

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

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

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

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

	if (!print_fatal_signals)
		return;

	if (!__ratelimit(&ratelimit_state))
		return;

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

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

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

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

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

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

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

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

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

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

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

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

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

	if (!consume)
		return false;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	flush_signals(t);
}

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

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

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

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

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

	sigdelset(&list->signal, sig);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

725 726 727 728
	if (uid_eq(cred->euid, tcred->suid) ||
	    uid_eq(cred->euid, tcred->uid)  ||
	    uid_eq(cred->uid,  tcred->suid) ||
	    uid_eq(cred->uid,  tcred->uid))
729 730
		return 1;

731
	if (ns_capable(tcred->user_ns, CAP_KILL))
732 733 734 735 736
		return 1;

	return 0;
}

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

747
	if (!valid_signal(sig))
748 749
		return -EINVAL;

750
	if (!si_fromuser(info))
751
		return 0;
A
Amy Griffis 已提交
752

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

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

773
	return security_task_kill(t, info, sig, NULL);
L
Linus Torvalds 已提交
774 775
}

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

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

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

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

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

874
	return !sig_ignored(p, sig, force);
L
Linus Torvalds 已提交
875 876
}

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

898
static void complete_signal(int sig, struct task_struct *p, int group)
899 900 901 902 903 904 905 906 907 908 909 910
{
	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;
911
	else if (!group || thread_group_empty(p))
912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938
		/*
		 * 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.
	 */
939
	if (sig_fatal(p, sig) &&
940
	    !(signal->flags & SIGNAL_GROUP_EXIT) &&
941
	    !sigismember(&t->real_blocked, sig) &&
942
	    (sig == SIGKILL || !p->ptrace)) {
943 944 945 946 947 948 949 950 951 952 953 954 955 956 957
		/*
		 * 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 {
958
				task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
959 960 961 962 963 964 965 966 967 968 969 970 971 972 973
				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;
}

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

979 980 981 982 983 984 985 986 987
#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;

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

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

1008
	assert_spin_locked(&t->sighand->siglock);
1009

1010
	result = TRACE_SIGNAL_IGNORED;
1011 1012
	if (!prepare_signal(sig, t,
			from_ancestor_ns || (info == SEND_SIG_FORCED)))
1013
		goto ret;
1014 1015

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

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

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

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

		userns_fixup_signal_uid(&q->info, t);

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

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

1105
static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
1106
			enum pid_type type)
1107
{
1108 1109 1110
	int from_ancestor_ns = 0;

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

1115
	return __send_signal(sig, info, t, type != PIDTYPE_PID, from_ancestor_ns);
1116 1117
}

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

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

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

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

1151 1152 1153
int
__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
1154
	return send_signal(sig, info, p, PIDTYPE_TGID);
1155 1156
}

L
Linus Torvalds 已提交
1157 1158 1159
static int
specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
1160
	return send_signal(sig, info, t, PIDTYPE_PID);
L
Linus Torvalds 已提交
1161 1162
}

1163
int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
1164
			enum pid_type type)
1165 1166 1167 1168 1169
{
	unsigned long flags;
	int ret = -ESRCH;

	if (lock_task_sighand(p, &flags)) {
1170
		ret = send_signal(sig, info, p, type);
1171 1172 1173 1174 1175 1176
		unlock_task_sighand(p, &flags);
	}

	return ret;
}

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

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

	return ret;
}

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

	p->signal->group_stop_count = 0;

1228
	while_each_thread(p, t) {
1229
		task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1230 1231 1232
		count++;

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

	return count;
L
Linus Torvalds 已提交
1240 1241
}

1242 1243
struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
					   unsigned long *flags)
1244 1245 1246
{
	struct sighand_struct *sighand;

1247
	rcu_read_lock();
1248 1249
	for (;;) {
		sighand = rcu_dereference(tsk->sighand);
1250
		if (unlikely(sighand == NULL))
1251
			break;
1252

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

	return sighand;
}

1274 1275 1276
/*
 * send signal info to all the members of a group
 */
1277 1278
int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
			enum pid_type type)
L
Linus Torvalds 已提交
1279
{
1280 1281 1282 1283 1284
	int ret;

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

1286
	if (!ret && sig)
1287
		ret = do_send_sig_info(sig, info, p, type);
L
Linus Torvalds 已提交
1288 1289 1290 1291 1292

	return ret;
}

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

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

1312
int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
L
Linus Torvalds 已提交
1313
{
1314
	int error = -ESRCH;
L
Linus Torvalds 已提交
1315 1316
	struct task_struct *p;

1317 1318 1319 1320
	for (;;) {
		rcu_read_lock();
		p = pid_task(pid, PIDTYPE_PID);
		if (p)
1321
			error = group_send_sig_info(sig, info, p, PIDTYPE_TGID);
1322 1323 1324
		rcu_read_unlock();
		if (likely(!p || error != -ESRCH))
			return error;
1325

1326 1327 1328 1329 1330 1331
		/*
		 * 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 已提交
1332 1333
}

1334
static int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1335 1336 1337
{
	int error;
	rcu_read_lock();
1338
	error = kill_pid_info(sig, info, find_vpid(pid));
1339 1340 1341 1342
	rcu_read_unlock();
	return error;
}

1343 1344 1345 1346
static int kill_as_cred_perm(const struct cred *cred,
			     struct task_struct *target)
{
	const struct cred *pcred = __task_cred(target);
1347 1348
	if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) &&
	    !uid_eq(cred->uid,  pcred->suid) && !uid_eq(cred->uid,  pcred->uid))
1349 1350 1351 1352
		return 0;
	return 1;
}

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

	if (!valid_signal(sig))
		return ret;

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

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

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

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

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

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

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

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

1435
	return ret;
L
Linus Torvalds 已提交
1436 1437 1438 1439 1440 1441
}

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

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

1451
	return do_send_sig_info(sig, info, p, PIDTYPE_PID);
L
Linus Torvalds 已提交
1452 1453
}

1454 1455 1456
#define __si_special(priv) \
	((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)

L
Linus Torvalds 已提交
1457 1458 1459
int
send_sig(int sig, struct task_struct *p, int priv)
{
1460
	return send_sig_info(sig, __si_special(priv), p);
L
Linus Torvalds 已提交
1461 1462 1463 1464 1465
}

void
force_sig(int sig, struct task_struct *p)
{
1466
	force_sig_info(sig, SEND_SIG_PRIV, p);
L
Linus Torvalds 已提交
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487
}

/*
 * 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..
 */
int
force_sigsegv(int sig, struct task_struct *p)
{
	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);
	return 0;
}

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 1527 1528 1529 1530 1531 1532 1533
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);
}

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 1584 1585 1586 1587 1588 1589 1590
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
1591

1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606
/* 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);
}

1607 1608
int kill_pgrp(struct pid *pid, int sig, int priv)
{
1609 1610 1611 1612 1613 1614 1615
	int ret;

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

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

1638
	if (q)
L
Linus Torvalds 已提交
1639
		q->flags |= SIGQUEUE_PREALLOC;
1640 1641

	return q;
L
Linus Torvalds 已提交
1642 1643 1644 1645 1646
}

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

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

1665 1666
	if (q)
		__sigqueue_free(q);
L
Linus Torvalds 已提交
1667 1668
}

1669
int send_sigqueue(struct sigqueue *q, struct pid *pid, enum pid_type type)
1670
{
1671
	int sig = q->info.si_signo;
1672
	struct sigpending *pending;
1673
	struct task_struct *t;
1674
	unsigned long flags;
1675
	int ret, result;
1676

1677
	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1678 1679

	ret = -1;
1680 1681 1682
	rcu_read_lock();
	t = pid_task(pid, type);
	if (!t || !likely(lock_task_sighand(t, &flags)))
1683 1684
		goto ret;

1685
	ret = 1; /* the signal is ignored */
1686
	result = TRACE_SIGNAL_IGNORED;
1687
	if (!prepare_signal(sig, t, false))
1688 1689 1690
		goto out;

	ret = 0;
1691 1692 1693 1694 1695 1696 1697
	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++;
1698
		result = TRACE_SIGNAL_ALREADY_PENDING;
1699
		goto out;
1700
	}
1701
	q->info.si_overrun = 0;
1702 1703

	signalfd_notify(t, sig);
1704
	pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending;
1705 1706
	list_add_tail(&q->list, &pending->list);
	sigaddset(&pending->signal, sig);
1707
	complete_signal(sig, t, type != PIDTYPE_PID);
1708
	result = TRACE_SIGNAL_DELIVERED;
1709
out:
1710
	trace_signal_generate(sig, &q->info, t, type != PIDTYPE_PID, result);
1711 1712
	unlock_task_sighand(t, &flags);
ret:
1713
	rcu_read_unlock();
1714
	return ret;
1715 1716
}

L
Linus Torvalds 已提交
1717 1718 1719
/*
 * 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 已提交
1720
 *
1721 1722
 * Returns true if our parent ignored us and so we've switched to
 * self-reaping.
L
Linus Torvalds 已提交
1723
 */
1724
bool do_notify_parent(struct task_struct *tsk, int sig)
L
Linus Torvalds 已提交
1725 1726 1727 1728
{
	struct siginfo info;
	unsigned long flags;
	struct sighand_struct *psig;
1729
	bool autoreap = false;
1730
	u64 utime, stime;
L
Linus Torvalds 已提交
1731 1732 1733 1734

	BUG_ON(sig == -1);

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

T
Tejun Heo 已提交
1737
	BUG_ON(!tsk->ptrace &&
L
Linus Torvalds 已提交
1738 1739
	       (tsk->group_leader != tsk || !thread_group_empty(tsk)));

1740 1741 1742 1743 1744 1745 1746 1747 1748
	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;
	}

1749
	clear_siginfo(&info);
L
Linus Torvalds 已提交
1750 1751
	info.si_signo = sig;
	info.si_errno = 0;
1752
	/*
1753 1754
	 * We are under tasklist_lock here so our parent is tied to
	 * us and cannot change.
1755
	 *
1756 1757
	 * task_active_pid_ns will always return the same pid namespace
	 * until a task passes through release_task.
1758 1759 1760 1761 1762 1763
	 *
	 * 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();
1764
	info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1765 1766
	info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
				       task_uid(tsk));
1767 1768
	rcu_read_unlock();

1769 1770 1771
	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 已提交
1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784

	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 已提交
1785
	if (!tsk->ptrace && sig == SIGCHLD &&
L
Linus Torvalds 已提交
1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802
	    (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).
		 */
1803
		autoreap = true;
L
Linus Torvalds 已提交
1804
		if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1805
			sig = 0;
L
Linus Torvalds 已提交
1806
	}
1807
	if (valid_signal(sig) && sig)
L
Linus Torvalds 已提交
1808 1809 1810
		__group_send_sig_info(sig, &info, tsk->parent);
	__wake_up_parent(tsk, tsk->parent);
	spin_unlock_irqrestore(&psig->siglock, flags);
R
Roland McGrath 已提交
1811

1812
	return autoreap;
L
Linus Torvalds 已提交
1813 1814
}

1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
/**
 * 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 已提交
1830 1831 1832
{
	struct siginfo info;
	unsigned long flags;
1833
	struct task_struct *parent;
L
Linus Torvalds 已提交
1834
	struct sighand_struct *sighand;
1835
	u64 utime, stime;
L
Linus Torvalds 已提交
1836

1837
	if (for_ptracer) {
1838
		parent = tsk->parent;
1839
	} else {
1840 1841 1842 1843
		tsk = tsk->group_leader;
		parent = tsk->real_parent;
	}

1844
	clear_siginfo(&info);
L
Linus Torvalds 已提交
1845 1846
	info.si_signo = SIGCHLD;
	info.si_errno = 0;
1847
	/*
1848
	 * see comment in do_notify_parent() about the following 4 lines
1849 1850
	 */
	rcu_read_lock();
1851
	info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
1852
	info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
1853 1854
	rcu_read_unlock();

1855 1856 1857
	task_cputime(tsk, &utime, &stime);
	info.si_utime = nsec_to_clock_t(utime);
	info.si_stime = nsec_to_clock_t(stime);
L
Linus Torvalds 已提交
1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885

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

1886 1887
static inline int may_ptrace_stop(void)
{
T
Tejun Heo 已提交
1888
	if (!likely(current->ptrace))
1889 1890 1891 1892 1893 1894 1895
		return 0;
	/*
	 * 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
1896
	 * ->siglock we must see ->core_state != NULL. Otherwise it
1897
	 * is safe to enter schedule().
1898 1899 1900 1901
	 *
	 * 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.
1902
	 */
1903
	if (unlikely(current->mm->core_state) &&
1904 1905 1906 1907 1908 1909
	    unlikely(current->mm == current->parent->mm))
		return 0;

	return 1;
}

R
Roland McGrath 已提交
1910
/*
1911
 * Return non-zero if there is a SIGKILL that should be waking us up.
R
Roland McGrath 已提交
1912 1913 1914 1915
 * Called with the siglock held.
 */
static int sigkill_pending(struct task_struct *tsk)
{
1916 1917
	return	sigismember(&tsk->pending.signal, SIGKILL) ||
		sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
R
Roland McGrath 已提交
1918 1919
}

L
Linus Torvalds 已提交
1920 1921 1922 1923 1924 1925 1926 1927
/*
 * 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.
 *
1928 1929
 * 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 已提交
1930
 */
T
Tejun Heo 已提交
1931
static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
1932 1933
	__releases(&current->sighand->siglock)
	__acquires(&current->sighand->siglock)
L
Linus Torvalds 已提交
1934
{
1935 1936
	bool gstop_done = false;

R
Roland McGrath 已提交
1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951
	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);
1952 1953
		if (sigkill_pending(current))
			return;
R
Roland McGrath 已提交
1954 1955
	}

1956 1957
	set_special_state(TASK_TRACED);

L
Linus Torvalds 已提交
1958
	/*
1959 1960 1961 1962 1963
	 * 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.
1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974
	 *
	 *     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 已提交
1975
	 */
1976
	smp_wmb();
L
Linus Torvalds 已提交
1977 1978 1979 1980

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

1981
	/*
1982 1983
	 * If @why is CLD_STOPPED, we're trapping to participate in a group
	 * stop.  Do the bookkeeping.  Note that if SIGCONT was delievered
1984 1985 1986
	 * 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.
1987
	 */
1988
	if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
1989
		gstop_done = task_participate_group_stop(current);
1990

1991
	/* any trap clears pending STOP trap, STOP trap clears NOTIFY */
1992
	task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
1993 1994
	if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
		task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
1995

1996
	/* entering a trap, clear TRAPPING */
1997
	task_clear_jobctl_trapping(current);
1998

L
Linus Torvalds 已提交
1999 2000
	spin_unlock_irq(&current->sighand->siglock);
	read_lock(&tasklist_lock);
2001
	if (may_ptrace_stop()) {
2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012
		/*
		 * 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);
2013
		if (gstop_done && ptrace_reparented(current))
2014 2015
			do_notify_parent_cldstop(current, false, why);

M
Miklos Szeredi 已提交
2016 2017 2018 2019 2020 2021 2022
		/*
		 * 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 已提交
2023
		read_unlock(&tasklist_lock);
M
Miklos Szeredi 已提交
2024
		preempt_enable_no_resched();
2025
		freezable_schedule();
L
Linus Torvalds 已提交
2026 2027 2028
	} else {
		/*
		 * By the time we got the lock, our tracer went away.
2029
		 * Don't drop the lock yet, another tracer may come.
2030 2031 2032
		 *
		 * If @gstop_done, the ptracer went away between group stop
		 * completion and here.  During detach, it would have set
2033 2034 2035
		 * 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 已提交
2036
		 */
2037 2038 2039
		if (gstop_done)
			do_notify_parent_cldstop(current, false, why);

2040
		/* tasklist protects us from ptrace_freeze_traced() */
2041
		__set_current_state(TASK_RUNNING);
2042 2043
		if (clear_code)
			current->exit_code = 0;
2044
		read_unlock(&tasklist_lock);
L
Linus Torvalds 已提交
2045 2046 2047 2048 2049 2050 2051 2052 2053 2054
	}

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

L
Linus Torvalds 已提交
2058 2059 2060
	/*
	 * Queued signals ignored us while we were stopped for tracing.
	 * So check for any that we should take before resuming user mode.
2061
	 * This sets TIF_SIGPENDING, but never clears it.
L
Linus Torvalds 已提交
2062
	 */
2063
	recalc_sigpending_tsk(current);
L
Linus Torvalds 已提交
2064 2065
}

T
Tejun Heo 已提交
2066
static void ptrace_do_notify(int signr, int exit_code, int why)
L
Linus Torvalds 已提交
2067 2068 2069
{
	siginfo_t info;

2070
	clear_siginfo(&info);
T
Tejun Heo 已提交
2071
	info.si_signo = signr;
L
Linus Torvalds 已提交
2072
	info.si_code = exit_code;
2073
	info.si_pid = task_pid_vnr(current);
2074
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
L
Linus Torvalds 已提交
2075 2076

	/* Let the debugger run.  */
T
Tejun Heo 已提交
2077 2078 2079 2080 2081 2082
	ptrace_stop(exit_code, why, 1, &info);
}

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

L
Linus Torvalds 已提交
2086
	spin_lock_irq(&current->sighand->siglock);
T
Tejun Heo 已提交
2087
	ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
L
Linus Torvalds 已提交
2088 2089 2090
	spin_unlock_irq(&current->sighand->siglock);
}

2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111
/**
 * 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 已提交
2112
 */
2113 2114
static bool do_signal_stop(int signr)
	__releases(&current->sighand->siglock)
L
Linus Torvalds 已提交
2115 2116 2117
{
	struct signal_struct *sig = current->signal;

2118
	if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
2119
		unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
2120 2121
		struct task_struct *t;

2122 2123
		/* signr will be recorded in task->jobctl for retries */
		WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
2124

2125
		if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
2126
		    unlikely(signal_group_exit(sig)))
2127
			return false;
L
Linus Torvalds 已提交
2128
		/*
2129 2130 2131 2132 2133 2134 2135
		 * 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
2136 2137
		 * cause two group stops when !ptraced.  That is why we
		 * also check !task_is_stopped(t) below.
2138 2139 2140 2141 2142 2143 2144 2145
		 *
		 * 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 已提交
2146
		 */
2147 2148
		if (!(sig->flags & SIGNAL_STOP_STOPPED))
			sig->group_exit_code = signr;
L
Linus Torvalds 已提交
2149

2150 2151 2152 2153
		sig->group_stop_count = 0;

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

2155 2156
		t = current;
		while_each_thread(current, t) {
L
Linus Torvalds 已提交
2157
			/*
2158 2159 2160
			 * 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 已提交
2161
			 */
2162 2163
			if (!task_is_stopped(t) &&
			    task_set_jobctl_pending(t, signr | gstop)) {
2164
				sig->group_stop_count++;
2165 2166 2167 2168
				if (likely(!(t->ptrace & PT_SEIZED)))
					signal_wake_up(t, 0);
				else
					ptrace_trap_notify(t);
2169
			}
2170
		}
L
Linus Torvalds 已提交
2171
	}
2172

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

2176 2177 2178 2179 2180 2181 2182 2183
		/*
		 * 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;

2184
		set_special_state(TASK_STOPPED);
2185 2186
		spin_unlock_irq(&current->sighand->siglock);

2187 2188 2189 2190 2191 2192 2193 2194 2195
		/*
		 * 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.
		 */
2196 2197
		if (notify) {
			read_lock(&tasklist_lock);
2198
			do_notify_parent_cldstop(current, false, notify);
2199 2200 2201 2202
			read_unlock(&tasklist_lock);
		}

		/* Now we don't run again until woken by SIGCONT or SIGKILL */
2203
		freezable_schedule();
2204
		return true;
2205
	} else {
2206 2207 2208 2209 2210 2211
		/*
		 * 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;
2212
	}
2213
}
L
Linus Torvalds 已提交
2214

2215 2216 2217
/**
 * do_jobctl_trap - take care of ptrace jobctl traps
 *
T
Tejun Heo 已提交
2218 2219 2220 2221 2222 2223 2224
 * 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.
2225 2226 2227 2228 2229 2230 2231
 *
 * 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 已提交
2232
	struct signal_struct *signal = current->signal;
2233
	int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2234

T
Tejun Heo 已提交
2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245
	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;
2246
	}
L
Linus Torvalds 已提交
2247 2248
}

2249
static int ptrace_signal(int signr, siginfo_t *info)
R
Roland McGrath 已提交
2250
{
2251 2252 2253 2254 2255 2256 2257 2258 2259 2260
	/*
	 * 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 已提交
2261
	ptrace_stop(signr, CLD_TRAPPED, 0, info);
R
Roland McGrath 已提交
2262 2263 2264 2265 2266 2267 2268 2269

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

	current->exit_code = 0;

2270 2271 2272 2273 2274 2275
	/*
	 * 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 已提交
2276
	if (signr != info->si_signo) {
2277
		clear_siginfo(info);
R
Roland McGrath 已提交
2278 2279 2280
		info->si_signo = signr;
		info->si_errno = 0;
		info->si_code = SI_USER;
2281
		rcu_read_lock();
R
Roland McGrath 已提交
2282
		info->si_pid = task_pid_vnr(current->parent);
2283 2284
		info->si_uid = from_kuid_munged(current_user_ns(),
						task_uid(current->parent));
2285
		rcu_read_unlock();
R
Roland McGrath 已提交
2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296
	}

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

2297
int get_signal(struct ksignal *ksig)
L
Linus Torvalds 已提交
2298
{
2299 2300 2301
	struct sighand_struct *sighand = current->sighand;
	struct signal_struct *signal = current->signal;
	int signr;
L
Linus Torvalds 已提交
2302

2303 2304
	if (unlikely(current->task_works))
		task_work_run();
2305

2306 2307 2308
	if (unlikely(uprobe_deny_signal()))
		return 0;

R
Roland McGrath 已提交
2309
	/*
2310 2311 2312
	 * 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 已提交
2313
	 */
2314 2315
	try_to_freeze();

2316
relock:
2317
	spin_lock_irq(&sighand->siglock);
2318 2319 2320 2321 2322
	/*
	 * 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.
	 */
2323
	if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2324 2325 2326 2327 2328 2329 2330
		int why;

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

2331
		signal->flags &= ~SIGNAL_CLD_MASK;
2332

2333
		spin_unlock_irq(&sighand->siglock);
R
Roland McGrath 已提交
2334

2335 2336 2337 2338 2339 2340 2341 2342
		/*
		 * 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 已提交
2343
		read_lock(&tasklist_lock);
2344 2345
		do_notify_parent_cldstop(current, false, why);

2346 2347 2348
		if (ptrace_reparented(current->group_leader))
			do_notify_parent_cldstop(current->group_leader,
						true, why);
T
Tejun Heo 已提交
2349
		read_unlock(&tasklist_lock);
2350

2351 2352 2353
		goto relock;
	}

L
Linus Torvalds 已提交
2354 2355
	for (;;) {
		struct k_sigaction *ka;
2356

T
Tejun Heo 已提交
2357 2358
		if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
		    do_signal_stop(0))
2359
			goto relock;
2360

2361 2362 2363 2364 2365
		if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
			do_jobctl_trap();
			spin_unlock_irq(&sighand->siglock);
			goto relock;
		}
L
Linus Torvalds 已提交
2366

2367
		signr = dequeue_signal(current, &current->blocked, &ksig->info);
2368

T
Tejun Heo 已提交
2369 2370
		if (!signr)
			break; /* will return 0 */
2371

2372
		if (unlikely(current->ptrace) && signr != SIGKILL) {
2373
			signr = ptrace_signal(signr, &ksig->info);
T
Tejun Heo 已提交
2374 2375
			if (!signr)
				continue;
L
Linus Torvalds 已提交
2376 2377
		}

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

2380
		/* Trace actually delivered signals. */
2381
		trace_signal_deliver(signr, &ksig->info, ka);
2382

L
Linus Torvalds 已提交
2383 2384 2385 2386
		if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
			continue;
		if (ka->sa.sa_handler != SIG_DFL) {
			/* Run the handler.  */
2387
			ksig->ka = *ka;
L
Linus Torvalds 已提交
2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400

			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;

2401
		/*
2402
		 * Global init gets no signals it doesn't want.
2403 2404 2405 2406 2407 2408 2409
		 * 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.
2410
		 */
2411
		if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2412
				!sig_kernel_only(signr))
L
Linus Torvalds 已提交
2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426
			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) {
2427
				spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2428 2429 2430

				/* signals can be posted during this window */

2431
				if (is_current_pgrp_orphaned())
L
Linus Torvalds 已提交
2432 2433
					goto relock;

2434
				spin_lock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2435 2436
			}

2437
			if (likely(do_signal_stop(ksig->info.si_signo))) {
L
Linus Torvalds 已提交
2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448
				/* It released the siglock.  */
				goto relock;
			}

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

2449
		spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2450 2451 2452 2453 2454

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

L
Linus Torvalds 已提交
2456
		if (sig_kernel_coredump(signr)) {
2457
			if (print_fatal_signals)
2458
				print_fatal_signal(ksig->info.si_signo);
2459
			proc_coredump_connector(current);
L
Linus Torvalds 已提交
2460 2461 2462 2463 2464 2465 2466 2467
			/*
			 * 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.
			 */
2468
			do_coredump(&ksig->info);
L
Linus Torvalds 已提交
2469 2470 2471 2472 2473
		}

		/*
		 * Death signals, no core dump.
		 */
2474
		do_group_exit(ksig->info.si_signo);
L
Linus Torvalds 已提交
2475 2476
		/* NOTREACHED */
	}
2477
	spin_unlock_irq(&sighand->siglock);
2478 2479 2480

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

2483
/**
A
Al Viro 已提交
2484
 * signal_delivered - 
R
Richard Weinberger 已提交
2485
 * @ksig:		kernel signal struct
A
Al Viro 已提交
2486
 * @stepping:		nonzero if debugger single-step or block-step in use
2487
 *
2488
 * This function should be called when a signal has successfully been
R
Richard Weinberger 已提交
2489
 * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
A
Al Viro 已提交
2490
 * is always blocked, and the signal itself is blocked unless %SA_NODEFER
R
Richard Weinberger 已提交
2491
 * is set in @ksig->ka.sa.sa_flags.  Tracing is notified.
2492
 */
R
Richard Weinberger 已提交
2493
static void signal_delivered(struct ksignal *ksig, int stepping)
2494 2495 2496
{
	sigset_t blocked;

2497 2498 2499 2500 2501 2502
	/* 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 已提交
2503 2504 2505
	sigorsets(&blocked, &current->blocked, &ksig->ka.sa.sa_mask);
	if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
		sigaddset(&blocked, ksig->sig);
2506
	set_current_blocked(&blocked);
2507
	tracehook_signal_handler(stepping);
2508 2509
}

A
Al Viro 已提交
2510 2511 2512 2513 2514
void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
{
	if (failed)
		force_sigsegv(ksig->sig, current);
	else
R
Richard Weinberger 已提交
2515
		signal_delivered(ksig, stepping);
A
Al Viro 已提交
2516 2517
}

2518 2519
/*
 * It could be that complete_signal() picked us to notify about the
2520 2521
 * group-wide signal. Other threads should be notified now to take
 * the shared signals in @which since we will not.
2522
 */
2523
static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2524
{
2525
	sigset_t retarget;
2526 2527
	struct task_struct *t;

2528 2529 2530 2531
	sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
	if (sigisemptyset(&retarget))
		return;

2532 2533
	t = tsk;
	while_each_thread(tsk, t) {
2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546
		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;
2547 2548 2549
	}
}

O
Oleg Nesterov 已提交
2550 2551 2552
void exit_signals(struct task_struct *tsk)
{
	int group_stop = 0;
2553
	sigset_t unblocked;
O
Oleg Nesterov 已提交
2554

2555 2556 2557 2558
	/*
	 * @tsk is about to have PF_EXITING set - lock out users which
	 * expect stable threadgroup.
	 */
2559
	cgroup_threadgroup_change_begin(tsk);
2560

2561 2562
	if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
		tsk->flags |= PF_EXITING;
2563
		cgroup_threadgroup_change_end(tsk);
2564
		return;
O
Oleg Nesterov 已提交
2565 2566
	}

2567
	spin_lock_irq(&tsk->sighand->siglock);
O
Oleg Nesterov 已提交
2568 2569 2570 2571 2572
	/*
	 * From now this task is not visible for group-wide signals,
	 * see wants_signal(), do_signal_stop().
	 */
	tsk->flags |= PF_EXITING;
2573

2574
	cgroup_threadgroup_change_end(tsk);
2575

2576 2577 2578
	if (!signal_pending(tsk))
		goto out;

2579 2580 2581
	unblocked = tsk->blocked;
	signotset(&unblocked);
	retarget_shared_pending(tsk, &unblocked);
2582

2583
	if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2584
	    task_participate_group_stop(tsk))
T
Tejun Heo 已提交
2585
		group_stop = CLD_STOPPED;
2586
out:
O
Oleg Nesterov 已提交
2587 2588
	spin_unlock_irq(&tsk->sighand->siglock);

2589 2590 2591 2592
	/*
	 * If group stop has completed, deliver the notification.  This
	 * should always go to the real parent of the group leader.
	 */
2593
	if (unlikely(group_stop)) {
O
Oleg Nesterov 已提交
2594
		read_lock(&tasklist_lock);
2595
		do_notify_parent_cldstop(tsk, false, group_stop);
O
Oleg Nesterov 已提交
2596 2597 2598 2599
		read_unlock(&tasklist_lock);
	}
}

L
Linus Torvalds 已提交
2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611
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.
 */

2612 2613 2614
/**
 *  sys_restart_syscall - restart a system call
 */
2615
SYSCALL_DEFINE0(restart_syscall)
L
Linus Torvalds 已提交
2616
{
2617
	struct restart_block *restart = &current->restart_block;
L
Linus Torvalds 已提交
2618 2619 2620 2621 2622 2623 2624 2625
	return restart->fn(restart);
}

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

2626 2627 2628 2629 2630
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. */
2631
		sigandnsets(&newblocked, newset, &current->blocked);
2632 2633 2634 2635 2636 2637
		retarget_shared_pending(tsk, &newblocked);
	}
	tsk->blocked = *newset;
	recalc_sigpending();
}

2638 2639 2640 2641 2642 2643
/**
 * 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 已提交
2644
 */
2645 2646 2647
void set_current_blocked(sigset_t *newset)
{
	sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2648
	__set_current_blocked(newset);
2649 2650 2651
}

void __set_current_blocked(const sigset_t *newset)
2652 2653 2654
{
	struct task_struct *tsk = current;

2655 2656 2657 2658 2659 2660 2661
	/*
	 * 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;

2662
	spin_lock_irq(&tsk->sighand->siglock);
2663
	__set_task_blocked(tsk, newset);
2664 2665
	spin_unlock_irq(&tsk->sighand->siglock);
}
L
Linus Torvalds 已提交
2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676

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

2680
	/* Lockless, only current can change ->blocked, never from irq */
2681
	if (oldset)
2682
		*oldset = tsk->blocked;
2683

L
Linus Torvalds 已提交
2684 2685
	switch (how) {
	case SIG_BLOCK:
2686
		sigorsets(&newset, &tsk->blocked, set);
L
Linus Torvalds 已提交
2687 2688
		break;
	case SIG_UNBLOCK:
2689
		sigandnsets(&newset, &tsk->blocked, set);
L
Linus Torvalds 已提交
2690 2691
		break;
	case SIG_SETMASK:
2692
		newset = *set;
L
Linus Torvalds 已提交
2693 2694
		break;
	default:
2695
		return -EINVAL;
L
Linus Torvalds 已提交
2696
	}
2697

2698
	__set_current_blocked(&newset);
2699
	return 0;
L
Linus Torvalds 已提交
2700 2701
}

2702 2703 2704
/**
 *  sys_rt_sigprocmask - change the list of currently blocked signals
 *  @how: whether to add, remove, or set signals
R
Randy Dunlap 已提交
2705
 *  @nset: stores pending signals
2706 2707 2708
 *  @oset: previous value of signal mask if non-null
 *  @sigsetsize: size of sigset_t type
 */
2709
SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
2710
		sigset_t __user *, oset, size_t, sigsetsize)
L
Linus Torvalds 已提交
2711 2712
{
	sigset_t old_set, new_set;
2713
	int error;
L
Linus Torvalds 已提交
2714 2715 2716

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

2719 2720 2721 2722 2723
	old_set = current->blocked;

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

2726
		error = sigprocmask(how, &new_set, NULL);
L
Linus Torvalds 已提交
2727
		if (error)
2728 2729
			return error;
	}
L
Linus Torvalds 已提交
2730

2731 2732 2733
	if (oset) {
		if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
			return -EFAULT;
L
Linus Torvalds 已提交
2734
	}
2735 2736

	return 0;
L
Linus Torvalds 已提交
2737 2738
}

A
Al Viro 已提交
2739 2740 2741
#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 已提交
2742
{
A
Al Viro 已提交
2743 2744 2745 2746 2747 2748 2749 2750 2751
	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 已提交
2752
		if (get_compat_sigset(&new_set, nset))
A
Al Viro 已提交
2753 2754 2755 2756 2757 2758 2759
			return -EFAULT;
		sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));

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

2764
static int do_sigpending(sigset_t *set)
L
Linus Torvalds 已提交
2765 2766
{
	spin_lock_irq(&current->sighand->siglock);
A
Al Viro 已提交
2767
	sigorsets(set, &current->pending.signal,
L
Linus Torvalds 已提交
2768 2769 2770 2771
		  &current->signal->shared_pending.signal);
	spin_unlock_irq(&current->sighand->siglock);

	/* Outside the lock because only this thread touches it.  */
A
Al Viro 已提交
2772 2773
	sigandsets(set, &current->blocked, set);
	return 0;
2774
}
L
Linus Torvalds 已提交
2775

2776 2777 2778
/**
 *  sys_rt_sigpending - examine a pending signal that has been raised
 *			while blocked
2779
 *  @uset: stores pending signals
2780 2781
 *  @sigsetsize: size of sigset_t type or larger
 */
A
Al Viro 已提交
2782
SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
L
Linus Torvalds 已提交
2783
{
A
Al Viro 已提交
2784
	sigset_t set;
2785 2786 2787 2788 2789 2790
	int err;

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

	err = do_sigpending(&set);
A
Al Viro 已提交
2791 2792 2793 2794 2795 2796 2797 2798
	if (!err && copy_to_user(uset, &set, sigsetsize))
		err = -EFAULT;
	return err;
}

#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
		compat_size_t, sigsetsize)
L
Linus Torvalds 已提交
2799
{
A
Al Viro 已提交
2800
	sigset_t set;
2801 2802 2803 2804 2805 2806
	int err;

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

	err = do_sigpending(&set);
2807 2808
	if (!err)
		err = put_compat_sigset(uset, &set, sigsetsize);
A
Al Viro 已提交
2809
	return err;
L
Linus Torvalds 已提交
2810
}
A
Al Viro 已提交
2811
#endif
L
Linus Torvalds 已提交
2812

2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824
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 },
2825
#if defined(SIGEMT) && defined(NSIGEMT)
2826 2827 2828 2829 2830 2831
			[SIGEMT]  = { NSIGEMT,  SIL_FAULT },
#endif
			[SIGCHLD] = { NSIGCHLD, SIL_CHLD },
			[SIGPOLL] = { NSIGPOLL, SIL_POLL },
			[SIGSYS]  = { NSIGSYS,  SIL_SYS },
		};
2832
		if ((sig < ARRAY_SIZE(filter)) && (si_code <= filter[sig].limit)) {
2833
			layout = filter[sig].layout;
2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844
			/* 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
		}
2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857
		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 已提交
2858
int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
L
Linus Torvalds 已提交
2859
{
2860
	if (copy_to_user(to, from , sizeof(struct siginfo)))
L
Linus Torvalds 已提交
2861
		return -EFAULT;
2862
	return 0;
L
Linus Torvalds 已提交
2863 2864
}

2865
#ifdef CONFIG_COMPAT
2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900
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
2901 2902 2903 2904 2905
		break;
	case SIL_FAULT_MCEERR:
		new.si_addr = ptr_to_compat(from->si_addr);
#ifdef __ARCH_SI_TRAPNO
		new.si_trapno = from->si_trapno;
2906
#endif
2907 2908 2909 2910 2911 2912
		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;
2913
#endif
2914 2915 2916 2917 2918 2919 2920
		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;
2921
#endif
2922
		new.si_pkey = from->si_pkey;
2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956
		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;
}

2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987
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
2988 2989 2990 2991 2992
		break;
	case SIL_FAULT_MCEERR:
		to->si_addr = compat_ptr(from.si_addr);
#ifdef __ARCH_SI_TRAPNO
		to->si_trapno = from.si_trapno;
2993
#endif
2994 2995 2996 2997 2998 2999
		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;
3000
#endif
3001 3002 3003 3004 3005 3006 3007
		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;
3008
#endif
3009
		to->si_pkey = from.si_pkey;
3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040
		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 */

3041 3042 3043 3044 3045 3046
/**
 *  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
 */
3047
static int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
3048
		    const struct timespec *ts)
3049
{
T
Thomas Gleixner 已提交
3050
	ktime_t *to = NULL, timeout = KTIME_MAX;
3051 3052
	struct task_struct *tsk = current;
	sigset_t mask = *which;
3053
	int sig, ret = 0;
3054 3055 3056 3057

	if (ts) {
		if (!timespec_valid(ts))
			return -EINVAL;
3058 3059
		timeout = timespec_to_ktime(*ts);
		to = &timeout;
3060 3061 3062 3063 3064 3065 3066 3067 3068 3069
	}

	/*
	 * 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 已提交
3070
	if (!sig && timeout) {
3071 3072 3073
		/*
		 * None ready, temporarily unblock those we're interested
		 * while we are sleeping in so that we'll be awakened when
3074 3075
		 * they arrive. Unblocking is always fine, we can avoid
		 * set_current_blocked().
3076 3077 3078 3079 3080 3081
		 */
		tsk->real_blocked = tsk->blocked;
		sigandsets(&tsk->blocked, &tsk->blocked, &mask);
		recalc_sigpending();
		spin_unlock_irq(&tsk->sighand->siglock);

3082 3083 3084
		__set_current_state(TASK_INTERRUPTIBLE);
		ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns,
							 HRTIMER_MODE_REL);
3085
		spin_lock_irq(&tsk->sighand->siglock);
3086
		__set_task_blocked(tsk, &tsk->real_blocked);
3087
		sigemptyset(&tsk->real_blocked);
3088
		sig = dequeue_signal(tsk, &mask, info);
3089 3090 3091 3092 3093
	}
	spin_unlock_irq(&tsk->sighand->siglock);

	if (sig)
		return sig;
3094
	return ret ? -EINTR : -EAGAIN;
3095 3096
}

3097 3098 3099 3100 3101 3102 3103 3104
/**
 *  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
 */
3105 3106 3107
SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
		siginfo_t __user *, uinfo, const struct timespec __user *, uts,
		size_t, sigsetsize)
L
Linus Torvalds 已提交
3108 3109 3110 3111
{
	sigset_t these;
	struct timespec ts;
	siginfo_t info;
3112
	int ret;
L
Linus Torvalds 已提交
3113 3114 3115 3116 3117 3118 3119

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

L
Linus Torvalds 已提交
3121 3122 3123 3124 3125
	if (uts) {
		if (copy_from_user(&ts, uts, sizeof(ts)))
			return -EFAULT;
	}

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

3128 3129 3130
	if (ret > 0 && uinfo) {
		if (copy_siginfo_to_user(uinfo, &info))
			ret = -EFAULT;
L
Linus Torvalds 已提交
3131 3132 3133 3134 3135
	}

	return ret;
}

3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148
#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 已提交
3149
	if (get_compat_sigset(&s, uthese))
3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167
		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

3168 3169 3170 3171 3172
/**
 *  sys_kill - send a signal to a process
 *  @pid: the PID of the process
 *  @sig: signal to be sent
 */
3173
SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
L
Linus Torvalds 已提交
3174 3175 3176
{
	struct siginfo info;

3177
	clear_siginfo(&info);
L
Linus Torvalds 已提交
3178 3179 3180
	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_USER;
3181
	info.si_pid = task_tgid_vnr(current);
3182
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
L
Linus Torvalds 已提交
3183 3184 3185 3186

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

T
Thomas Gleixner 已提交
3187 3188
static int
do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
L
Linus Torvalds 已提交
3189 3190
{
	struct task_struct *p;
T
Thomas Gleixner 已提交
3191
	int error = -ESRCH;
L
Linus Torvalds 已提交
3192

3193
	rcu_read_lock();
3194
	p = find_task_by_vpid(pid);
3195
	if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
T
Thomas Gleixner 已提交
3196
		error = check_kill_permission(sig, info, p);
L
Linus Torvalds 已提交
3197 3198 3199 3200
		/*
		 * The null signal is a permissions and process existence
		 * probe.  No signal is actually delivered.
		 */
3201
		if (!error && sig) {
3202
			error = do_send_sig_info(sig, info, p, PIDTYPE_PID);
3203 3204 3205 3206 3207 3208 3209
			/*
			 * 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 已提交
3210 3211
		}
	}
3212
	rcu_read_unlock();
3213

L
Linus Torvalds 已提交
3214 3215 3216
	return error;
}

T
Thomas Gleixner 已提交
3217 3218
static int do_tkill(pid_t tgid, pid_t pid, int sig)
{
3219
	struct siginfo info;
T
Thomas Gleixner 已提交
3220

3221
	clear_siginfo(&info);
T
Thomas Gleixner 已提交
3222 3223 3224 3225
	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_TKILL;
	info.si_pid = task_tgid_vnr(current);
3226
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
T
Thomas Gleixner 已提交
3227 3228 3229 3230

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

3231 3232 3233 3234 3235 3236
/**
 *  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
 *
3237
 *  This syscall also checks the @tgid and returns -ESRCH even if the PID
3238 3239 3240
 *  exists but it's not belonging to the target process anymore. This
 *  method solves the problem of threads exiting and PIDs getting reused.
 */
3241
SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
3242 3243 3244 3245 3246 3247 3248 3249
{
	/* This is only valid for single tasks */
	if (pid <= 0 || tgid <= 0)
		return -EINVAL;

	return do_tkill(tgid, pid, sig);
}

3250 3251 3252 3253 3254
/**
 *  sys_tkill - send signal to one specific task
 *  @pid: the PID of the task
 *  @sig: signal to be sent
 *
L
Linus Torvalds 已提交
3255 3256
 *  Send a signal to only one task, even if it's a CLONE_THREAD task.
 */
3257
SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
L
Linus Torvalds 已提交
3258 3259 3260 3261 3262
{
	/* This is only valid for single tasks */
	if (pid <= 0)
		return -EINVAL;

3263
	return do_tkill(0, pid, sig);
L
Linus Torvalds 已提交
3264 3265
}

A
Al Viro 已提交
3266 3267 3268 3269 3270
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.
	 */
3271
	if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3272
	    (task_pid_vnr(current) != pid))
A
Al Viro 已提交
3273
		return -EPERM;
3274

A
Al Viro 已提交
3275 3276 3277 3278 3279 3280
	info->si_signo = sig;

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

3281 3282 3283 3284 3285 3286
/**
 *  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
 */
3287 3288
SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
		siginfo_t __user *, uinfo)
L
Linus Torvalds 已提交
3289 3290 3291 3292
{
	siginfo_t info;
	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
		return -EFAULT;
A
Al Viro 已提交
3293 3294
	return do_rt_sigqueueinfo(pid, sig, &info);
}
L
Linus Torvalds 已提交
3295

A
Al Viro 已提交
3296 3297 3298 3299 3300 3301
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
			compat_pid_t, pid,
			int, sig,
			struct compat_siginfo __user *, uinfo)
{
3302
	siginfo_t info;
A
Al Viro 已提交
3303 3304 3305 3306
	int ret = copy_siginfo_from_user32(&info, uinfo);
	if (unlikely(ret))
		return ret;
	return do_rt_sigqueueinfo(pid, sig, &info);
L
Linus Torvalds 已提交
3307
}
A
Al Viro 已提交
3308
#endif
L
Linus Torvalds 已提交
3309

3310
static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
3311 3312 3313 3314 3315 3316
{
	/* 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.
3317 3318
	 * Nor can they impersonate a kill()/tgkill(), which adds source info.
	 */
3319 3320
	if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
	    (task_pid_vnr(current) != pid))
3321
		return -EPERM;
3322

3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338
	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);
}

3339 3340 3341 3342 3343 3344 3345
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
			compat_pid_t, tgid,
			compat_pid_t, pid,
			int, sig,
			struct compat_siginfo __user *, uinfo)
{
3346
	siginfo_t info;
3347 3348 3349 3350 3351 3352 3353

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

3354
/*
3355
 * For kthreads only, must not be used if cloned with CLONE_SIGHAND
3356
 */
3357
void kernel_sigaction(int sig, __sighandler_t action)
3358
{
3359
	spin_lock_irq(&current->sighand->siglock);
3360 3361 3362
	current->sighand->action[sig - 1].sa.sa_handler = action;
	if (action == SIG_IGN) {
		sigset_t mask;
3363

3364 3365
		sigemptyset(&mask);
		sigaddset(&mask, sig);
3366

3367 3368 3369 3370
		flush_sigqueue_mask(&mask, &current->signal->shared_pending);
		flush_sigqueue_mask(&mask, &current->pending);
		recalc_sigpending();
	}
3371 3372
	spin_unlock_irq(&current->sighand->siglock);
}
3373
EXPORT_SYMBOL(kernel_sigaction);
3374

3375 3376 3377 3378 3379
void __weak sigaction_compat_abi(struct k_sigaction *act,
		struct k_sigaction *oact)
{
}

3380
int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
L
Linus Torvalds 已提交
3381
{
3382
	struct task_struct *p = current, *t;
L
Linus Torvalds 已提交
3383
	struct k_sigaction *k;
3384
	sigset_t mask;
L
Linus Torvalds 已提交
3385

3386
	if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
L
Linus Torvalds 已提交
3387 3388
		return -EINVAL;

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

3391
	spin_lock_irq(&p->sighand->siglock);
L
Linus Torvalds 已提交
3392 3393 3394
	if (oact)
		*oact = *k;

3395 3396
	sigaction_compat_abi(act, oact);

L
Linus Torvalds 已提交
3397
	if (act) {
3398 3399
		sigdelsetmask(&act->sa.sa_mask,
			      sigmask(SIGKILL) | sigmask(SIGSTOP));
3400
		*k = *act;
L
Linus Torvalds 已提交
3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411
		/*
		 * 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"
		 */
3412
		if (sig_handler_ignored(sig_handler(p, sig), sig)) {
3413 3414
			sigemptyset(&mask);
			sigaddset(&mask, sig);
3415 3416
			flush_sigqueue_mask(&mask, &p->signal->shared_pending);
			for_each_thread(p, t)
3417
				flush_sigqueue_mask(&mask, &t->pending);
L
Linus Torvalds 已提交
3418 3419 3420
		}
	}

3421
	spin_unlock_irq(&p->sighand->siglock);
L
Linus Torvalds 已提交
3422 3423 3424
	return 0;
}

3425
static int
3426
do_sigaltstack (const stack_t *ss, stack_t *oss, unsigned long sp)
L
Linus Torvalds 已提交
3427
{
3428
	struct task_struct *t = current;
L
Linus Torvalds 已提交
3429

3430 3431 3432 3433 3434 3435 3436
	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 已提交
3437

3438 3439 3440 3441
	if (ss) {
		void __user *ss_sp = ss->ss_sp;
		size_t ss_size = ss->ss_size;
		unsigned ss_flags = ss->ss_flags;
3442
		int ss_mode;
L
Linus Torvalds 已提交
3443

3444 3445
		if (unlikely(on_sig_stack(sp)))
			return -EPERM;
L
Linus Torvalds 已提交
3446

3447
		ss_mode = ss_flags & ~SS_FLAG_BITS;
3448 3449 3450
		if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
				ss_mode != 0))
			return -EINVAL;
L
Linus Torvalds 已提交
3451

3452
		if (ss_mode == SS_DISABLE) {
L
Linus Torvalds 已提交
3453 3454 3455
			ss_size = 0;
			ss_sp = NULL;
		} else {
3456 3457
			if (unlikely(ss_size < MINSIGSTKSZ))
				return -ENOMEM;
L
Linus Torvalds 已提交
3458 3459
		}

3460 3461 3462
		t->sas_ss_sp = (unsigned long) ss_sp;
		t->sas_ss_size = ss_size;
		t->sas_ss_flags = ss_flags;
L
Linus Torvalds 已提交
3463
	}
3464
	return 0;
L
Linus Torvalds 已提交
3465
}
3466

3467 3468
SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
{
3469 3470 3471 3472 3473 3474 3475 3476 3477
	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;
3478
}
L
Linus Torvalds 已提交
3479

A
Al Viro 已提交
3480 3481
int restore_altstack(const stack_t __user *uss)
{
3482 3483 3484 3485
	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 已提交
3486
	/* squash all but EFAULT for now */
3487
	return 0;
A
Al Viro 已提交
3488 3489
}

3490 3491 3492
int __save_altstack(stack_t __user *uss, unsigned long sp)
{
	struct task_struct *t = current;
3493 3494
	int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
		__put_user(t->sas_ss_flags, &uss->ss_flags) |
3495
		__put_user(t->sas_ss_size, &uss->ss_size);
3496 3497 3498 3499 3500
	if (err)
		return err;
	if (t->sas_ss_flags & SS_AUTODISARM)
		sas_ss_reset(t);
	return 0;
3501 3502
}

A
Al Viro 已提交
3503
#ifdef CONFIG_COMPAT
3504 3505
static int do_compat_sigaltstack(const compat_stack_t __user *uss_ptr,
				 compat_stack_t __user *uoss_ptr)
A
Al Viro 已提交
3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517
{
	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;
	}
3518
	ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss,
A
Al Viro 已提交
3519 3520
			     compat_user_stack_pointer());
	if (ret >= 0 && uoss_ptr)  {
3521 3522 3523 3524 3525 3526
		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 已提交
3527 3528 3529 3530 3531
			ret = -EFAULT;
	}
	return ret;
}

3532 3533 3534 3535 3536 3537 3538
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 已提交
3539 3540
int compat_restore_altstack(const compat_stack_t __user *uss)
{
3541
	int err = do_compat_sigaltstack(uss, NULL);
A
Al Viro 已提交
3542 3543 3544
	/* squash all but -EFAULT for now */
	return err == -EFAULT ? err : 0;
}
3545 3546 3547

int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
{
3548
	int err;
3549
	struct task_struct *t = current;
3550 3551 3552
	err = __put_user(ptr_to_compat((void __user *)t->sas_ss_sp),
			 &uss->ss_sp) |
		__put_user(t->sas_ss_flags, &uss->ss_flags) |
3553
		__put_user(t->sas_ss_size, &uss->ss_size);
3554 3555 3556 3557 3558
	if (err)
		return err;
	if (t->sas_ss_flags & SS_AUTODISARM)
		sas_ss_reset(t);
	return 0;
3559
}
A
Al Viro 已提交
3560
#endif
L
Linus Torvalds 已提交
3561 3562 3563

#ifdef __ARCH_WANT_SYS_SIGPENDING

3564 3565
/**
 *  sys_sigpending - examine pending signals
3566
 *  @uset: where mask of pending signal is returned
3567
 */
3568
SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, uset)
L
Linus Torvalds 已提交
3569
{
3570 3571 3572 3573 3574 3575 3576 3577 3578 3579
	sigset_t set;
	int err;

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

	err = do_sigpending(&set);
	if (!err && copy_to_user(uset, &set, sizeof(old_sigset_t)))
		err = -EFAULT;
	return err;
L
Linus Torvalds 已提交
3580 3581
}

A
Al Viro 已提交
3582 3583 3584 3585
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set32)
{
	sigset_t set;
3586
	int err = do_sigpending(&set);
3587 3588
	if (!err)
		err = put_user(set.sig[0], set32);
A
Al Viro 已提交
3589 3590 3591 3592
	return err;
}
#endif

L
Linus Torvalds 已提交
3593 3594 3595
#endif

#ifdef __ARCH_WANT_SYS_SIGPROCMASK
3596 3597 3598
/**
 *  sys_sigprocmask - examine and change blocked signals
 *  @how: whether to add, remove, or set signals
3599
 *  @nset: signals to add or remove (if non-null)
3600 3601
 *  @oset: previous value of signal mask if non-null
 *
3602 3603 3604
 * Some platforms have their own version with special arguments;
 * others support only sys_rt_sigprocmask.
 */
L
Linus Torvalds 已提交
3605

3606
SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
3607
		old_sigset_t __user *, oset)
L
Linus Torvalds 已提交
3608 3609
{
	old_sigset_t old_set, new_set;
3610
	sigset_t new_blocked;
L
Linus Torvalds 已提交
3611

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

3614 3615 3616
	if (nset) {
		if (copy_from_user(&new_set, nset, sizeof(*nset)))
			return -EFAULT;
L
Linus Torvalds 已提交
3617

3618
		new_blocked = current->blocked;
L
Linus Torvalds 已提交
3619 3620 3621

		switch (how) {
		case SIG_BLOCK:
3622
			sigaddsetmask(&new_blocked, new_set);
L
Linus Torvalds 已提交
3623 3624
			break;
		case SIG_UNBLOCK:
3625
			sigdelsetmask(&new_blocked, new_set);
L
Linus Torvalds 已提交
3626 3627
			break;
		case SIG_SETMASK:
3628
			new_blocked.sig[0] = new_set;
L
Linus Torvalds 已提交
3629
			break;
3630 3631
		default:
			return -EINVAL;
L
Linus Torvalds 已提交
3632 3633
		}

3634
		set_current_blocked(&new_blocked);
3635 3636 3637
	}

	if (oset) {
L
Linus Torvalds 已提交
3638
		if (copy_to_user(oset, &old_set, sizeof(*oset)))
3639
			return -EFAULT;
L
Linus Torvalds 已提交
3640
	}
3641 3642

	return 0;
L
Linus Torvalds 已提交
3643 3644 3645
}
#endif /* __ARCH_WANT_SYS_SIGPROCMASK */

3646
#ifndef CONFIG_ODD_RT_SIGACTION
3647 3648 3649
/**
 *  sys_rt_sigaction - alter an action taken by a process
 *  @sig: signal to be sent
3650 3651
 *  @act: new sigaction
 *  @oact: used to save the previous sigaction
3652 3653
 *  @sigsetsize: size of sigset_t type
 */
3654 3655 3656 3657
SYSCALL_DEFINE4(rt_sigaction, int, sig,
		const struct sigaction __user *, act,
		struct sigaction __user *, oact,
		size_t, sigsetsize)
L
Linus Torvalds 已提交
3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679
{
	struct k_sigaction new_sa, old_sa;
	int ret = -EINVAL;

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

	if (act) {
		if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
			return -EFAULT;
	}

	ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);

	if (!ret && oact) {
		if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
			return -EFAULT;
	}
out:
	return ret;
}
A
Al Viro 已提交
3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703
#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 已提交
3704
		ret |= get_compat_sigset(&new_ka.sa.sa_mask, &act->sa_mask);
3705
		ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
A
Al Viro 已提交
3706 3707 3708 3709 3710 3711 3712 3713
		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);
3714 3715
		ret |= put_compat_sigset(&oact->sa_mask, &old_ka.sa.sa_mask,
					 sizeof(oact->sa_mask));
3716
		ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
A
Al Viro 已提交
3717 3718 3719 3720 3721 3722 3723 3724
#ifdef __ARCH_HAS_SA_RESTORER
		ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
				&oact->sa_restorer);
#endif
	}
	return ret;
}
#endif
3725
#endif /* !CONFIG_ODD_RT_SIGACTION */
L
Linus Torvalds 已提交
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 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803
#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 已提交
3804

3805
#ifdef CONFIG_SGETMASK_SYSCALL
L
Linus Torvalds 已提交
3806 3807 3808 3809

/*
 * For backwards compatibility.  Functionality superseded by sigprocmask.
 */
3810
SYSCALL_DEFINE0(sgetmask)
L
Linus Torvalds 已提交
3811 3812 3813 3814 3815
{
	/* SMP safe */
	return current->blocked.sig[0];
}

3816
SYSCALL_DEFINE1(ssetmask, int, newmask)
L
Linus Torvalds 已提交
3817
{
3818 3819
	int old = current->blocked.sig[0];
	sigset_t newset;
L
Linus Torvalds 已提交
3820

3821
	siginitset(&newset, newmask);
3822
	set_current_blocked(&newset);
L
Linus Torvalds 已提交
3823 3824 3825

	return old;
}
3826
#endif /* CONFIG_SGETMASK_SYSCALL */
L
Linus Torvalds 已提交
3827 3828 3829 3830 3831

#ifdef __ARCH_WANT_SYS_SIGNAL
/*
 * For backwards compatibility.  Functionality superseded by sigaction.
 */
3832
SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
L
Linus Torvalds 已提交
3833 3834 3835 3836 3837 3838
{
	struct k_sigaction new_sa, old_sa;
	int ret;

	new_sa.sa.sa_handler = handler;
	new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
3839
	sigemptyset(&new_sa.sa.sa_mask);
L
Linus Torvalds 已提交
3840 3841 3842 3843 3844 3845 3846 3847 3848

	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

3849
SYSCALL_DEFINE0(pause)
L
Linus Torvalds 已提交
3850
{
3851
	while (!signal_pending(current)) {
3852
		__set_current_state(TASK_INTERRUPTIBLE);
3853 3854
		schedule();
	}
L
Linus Torvalds 已提交
3855 3856 3857 3858 3859
	return -ERESTARTNOHAND;
}

#endif

3860
static int sigsuspend(sigset_t *set)
A
Al Viro 已提交
3861 3862 3863 3864
{
	current->saved_sigmask = current->blocked;
	set_current_blocked(set);

3865 3866 3867 3868
	while (!signal_pending(current)) {
		__set_current_state(TASK_INTERRUPTIBLE);
		schedule();
	}
A
Al Viro 已提交
3869 3870 3871 3872
	set_restore_sigmask();
	return -ERESTARTNOHAND;
}

3873 3874 3875 3876 3877 3878
/**
 *  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
 */
3879
SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
3880 3881 3882 3883 3884 3885 3886 3887 3888
{
	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 已提交
3889
	return sigsuspend(&newset);
3890
}
A
Al Viro 已提交
3891 3892 3893 3894 3895 3896 3897 3898 3899 3900
 
#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 已提交
3901
	if (get_compat_sigset(&newset, unewset))
A
Al Viro 已提交
3902 3903 3904 3905
		return -EFAULT;
	return sigsuspend(&newset);
}
#endif
3906

3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922
#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
3923

3924
__weak const char *arch_vma_name(struct vm_area_struct *vma)
3925 3926 3927 3928
{
	return NULL;
}

L
Linus Torvalds 已提交
3929 3930
void __init signals_init(void)
{
3931 3932 3933
	/* If this check fails, the __ARCH_SI_PREAMBLE_SIZE value is wrong! */
	BUILD_BUG_ON(__ARCH_SI_PREAMBLE_SIZE
		!= offsetof(struct siginfo, _sifields._pad));
3934
	BUILD_BUG_ON(sizeof(struct siginfo) != SI_MAX_SIZE);
3935

3936
	sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
L
Linus Torvalds 已提交
3937
}
3938 3939 3940 3941

#ifdef CONFIG_KGDB_KDB
#include <linux/kdb.h>
/*
3942
 * kdb_send_sig - Allows kdb to send signals without exposing
3943 3944 3945 3946
 * signal internals.  This function checks if the required locks are
 * available before calling the main signal code, to avoid kdb
 * deadlocks.
 */
3947
void kdb_send_sig(struct task_struct *t, int sig)
3948 3949
{
	static struct task_struct *kdb_prev_t;
3950
	int new_t, ret;
3951 3952 3953 3954 3955 3956 3957 3958 3959
	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) {
3960
		spin_unlock(&t->sighand->siglock);
3961 3962 3963 3964 3965 3966 3967 3968
		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;
	}
3969
	ret = send_signal(sig, SEND_SIG_PRIV, t, PIDTYPE_PID);
3970 3971
	spin_unlock(&t->sighand->siglock);
	if (ret)
3972 3973 3974 3975 3976 3977
		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 */