signal.c 95.0 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 16 17 18 19
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <linux/tty.h>
#include <linux/binfmts.h>
20
#include <linux/coredump.h>
L
Linus Torvalds 已提交
21 22 23
#include <linux/security.h>
#include <linux/syscalls.h>
#include <linux/ptrace.h>
24
#include <linux/signal.h>
25
#include <linux/signalfd.h>
26
#include <linux/ratelimit.h>
27
#include <linux/tracehook.h>
28
#include <linux/capability.h>
29
#include <linux/freezer.h>
30 31
#include <linux/pid_namespace.h>
#include <linux/nsproxy.h>
32
#include <linux/user_namespace.h>
33
#include <linux/uprobes.h>
A
Al Viro 已提交
34
#include <linux/compat.h>
35
#include <linux/cn_proc.h>
36 37
#include <linux/compiler.h>

38 39
#define CREATE_TRACE_POINTS
#include <trace/events/signal.h>
40

L
Linus Torvalds 已提交
41 42 43 44
#include <asm/param.h>
#include <asm/uaccess.h>
#include <asm/unistd.h>
#include <asm/siginfo.h>
45
#include <asm/cacheflush.h>
46
#include "audit.h"	/* audit_signal_info() */
L
Linus Torvalds 已提交
47 48 49 50 51

/*
 * SLAB caches for signal bits.
 */

52
static struct kmem_cache *sigqueue_cachep;
L
Linus Torvalds 已提交
53

54 55
int print_fatal_signals __read_mostly;

56
static void __user *sig_handler(struct task_struct *t, int sig)
57
{
58 59
	return t->sighand->action[sig - 1].sa.sa_handler;
}
60

61 62
static int sig_handler_ignored(void __user *handler, int sig)
{
63 64 65 66
	/* Is it explicitly or implicitly ignored? */
	return handler == SIG_IGN ||
		(handler == SIG_DFL && sig_kernel_ignore(sig));
}
L
Linus Torvalds 已提交
67

68
static int sig_task_ignored(struct task_struct *t, int sig, bool force)
L
Linus Torvalds 已提交
69
{
70
	void __user *handler;
L
Linus Torvalds 已提交
71

72 73 74
	handler = sig_handler(t, sig);

	if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
75
			handler == SIG_DFL && !force)
76 77 78 79 80
		return 1;

	return sig_handler_ignored(handler, sig);
}

81
static int sig_ignored(struct task_struct *t, int sig, bool force)
82
{
L
Linus Torvalds 已提交
83 84 85 86 87
	/*
	 * Blocked signals are never ignored, since the
	 * signal handler may change by the time it is
	 * unblocked.
	 */
88
	if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
L
Linus Torvalds 已提交
89 90
		return 0;

91
	if (!sig_task_ignored(t, sig, force))
92 93 94 95 96
		return 0;

	/*
	 * Tracers may want to know about even ignored signals.
	 */
T
Tejun Heo 已提交
97
	return !t->ptrace;
L
Linus Torvalds 已提交
98 99 100 101 102 103 104 105 106 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
}

/*
 * 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 已提交
132
static int recalc_sigpending_tsk(struct task_struct *t)
L
Linus Torvalds 已提交
133
{
134
	if ((t->jobctl & JOBCTL_PENDING_MASK) ||
L
Linus Torvalds 已提交
135
	    PENDING(&t->pending, &t->blocked) ||
R
Roland McGrath 已提交
136
	    PENDING(&t->signal->shared_pending, &t->blocked)) {
L
Linus Torvalds 已提交
137
		set_tsk_thread_flag(t, TIF_SIGPENDING);
R
Roland McGrath 已提交
138 139
		return 1;
	}
140 141 142 143 144
	/*
	 * 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 已提交
145 146 147 148 149 150 151 152 153 154 155
	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 已提交
156 157 158 159
}

void recalc_sigpending(void)
{
T
Tejun Heo 已提交
160
	if (!recalc_sigpending_tsk(current) && !freezing(current))
161 162
		clear_thread_flag(TIF_SIGPENDING);

L
Linus Torvalds 已提交
163 164 165 166
}

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

167 168
#define SYNCHRONOUS_MASK \
	(sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
169
	 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
170

171
int next_signal(struct sigpending *pending, sigset_t *mask)
L
Linus Torvalds 已提交
172 173 174
{
	unsigned long i, *s, *m, x;
	int sig = 0;
175

L
Linus Torvalds 已提交
176 177
	s = pending->signal.sig;
	m = mask->sig;
178 179 180 181 182 183 184 185 186 187 188 189 190

	/*
	 * 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 已提交
191 192
	switch (_NSIG_WORDS) {
	default:
193 194 195 196 197 198 199
		for (i = 1; i < _NSIG_WORDS; ++i) {
			x = *++s &~ *++m;
			if (!x)
				continue;
			sig = ffz(~x) + i*_NSIG_BPW + 1;
			break;
		}
L
Linus Torvalds 已提交
200 201
		break;

202 203 204
	case 2:
		x = s[1] &~ m[1];
		if (!x)
L
Linus Torvalds 已提交
205
			break;
206
		sig = ffz(~x) + _NSIG_BPW + 1;
L
Linus Torvalds 已提交
207 208
		break;

209 210
	case 1:
		/* Nothing to do */
L
Linus Torvalds 已提交
211 212
		break;
	}
213

L
Linus Torvalds 已提交
214 215 216
	return sig;
}

217 218 219 220 221 222 223 224 225 226 227 228 229 230
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;

	printk(KERN_INFO "%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
				current->comm, current->pid, sig);
}

231
/**
232
 * task_set_jobctl_pending - set jobctl pending bits
233
 * @task: target task
234
 * @mask: pending bits to set
235
 *
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
 * 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.
 */
bool task_set_jobctl_pending(struct task_struct *task, unsigned int mask)
{
	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;
}

264
/**
265
 * task_clear_jobctl_trapping - clear jobctl trapping bit
266 267
 * @task: target task
 *
268 269 270 271
 * 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.
272 273 274 275
 *
 * CONTEXT:
 * Must be called with @task->sighand->siglock held.
 */
276
void task_clear_jobctl_trapping(struct task_struct *task)
277
{
278 279
	if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
		task->jobctl &= ~JOBCTL_TRAPPING;
280
		smp_mb();	/* advised by wake_up_bit() */
281
		wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
282 283 284
	}
}

285
/**
286
 * task_clear_jobctl_pending - clear jobctl pending bits
287
 * @task: target task
288
 * @mask: pending bits to clear
289
 *
290 291 292
 * 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.
293
 *
294 295
 * If clearing of @mask leaves no stop or trap pending, this function calls
 * task_clear_jobctl_trapping().
296 297 298 299
 *
 * CONTEXT:
 * Must be called with @task->sighand->siglock held.
 */
300
void task_clear_jobctl_pending(struct task_struct *task, unsigned int mask)
301
{
302 303 304 305 306 307
	BUG_ON(mask & ~JOBCTL_PENDING_MASK);

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

	task->jobctl &= ~mask;
308 309 310

	if (!(task->jobctl & JOBCTL_PENDING_MASK))
		task_clear_jobctl_trapping(task);
311 312 313 314 315 316
}

/**
 * task_participate_group_stop - participate in a group stop
 * @task: task participating in a group stop
 *
317
 * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
318
 * Group stop states are cleared and the group stop count is consumed if
319
 * %JOBCTL_STOP_CONSUME was set.  If the consumption completes the group
320
 * stop, the appropriate %SIGNAL_* flags are set.
321 322 323
 *
 * CONTEXT:
 * Must be called with @task->sighand->siglock held.
324 325 326 327
 *
 * RETURNS:
 * %true if group stop completion should be notified to the parent, %false
 * otherwise.
328 329 330 331
 */
static bool task_participate_group_stop(struct task_struct *task)
{
	struct signal_struct *sig = task->signal;
332
	bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
333

334
	WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
335

336
	task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
337 338 339 340 341 342 343

	if (!consume)
		return false;

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

344 345 346 347 348
	/*
	 * 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)) {
349 350 351 352 353 354
		sig->flags = SIGNAL_STOP_STOPPED;
		return true;
	}
	return false;
}

355 356 357
/*
 * allocate a new signal queue record
 * - this may be called without locks if and only if t == current, otherwise an
358
 *   appropriate lock must be held to stop the target task from exiting
359
 */
360 361
static struct sigqueue *
__sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
L
Linus Torvalds 已提交
362 363
{
	struct sigqueue *q = NULL;
364
	struct user_struct *user;
L
Linus Torvalds 已提交
365

366
	/*
367 368
	 * Protect access to @t credentials. This can go away when all
	 * callers hold rcu read lock.
369
	 */
370
	rcu_read_lock();
D
David Howells 已提交
371
	user = get_uid(__task_cred(t)->user);
372
	atomic_inc(&user->sigpending);
373
	rcu_read_unlock();
374

L
Linus Torvalds 已提交
375
	if (override_rlimit ||
376
	    atomic_read(&user->sigpending) <=
377
			task_rlimit(t, RLIMIT_SIGPENDING)) {
L
Linus Torvalds 已提交
378
		q = kmem_cache_alloc(sigqueue_cachep, flags);
379 380 381 382
	} else {
		print_dropped_signal(sig);
	}

L
Linus Torvalds 已提交
383
	if (unlikely(q == NULL)) {
384
		atomic_dec(&user->sigpending);
D
David Howells 已提交
385
		free_uid(user);
L
Linus Torvalds 已提交
386 387 388
	} else {
		INIT_LIST_HEAD(&q->list);
		q->flags = 0;
D
David Howells 已提交
389
		q->user = user;
L
Linus Torvalds 已提交
390
	}
D
David Howells 已提交
391 392

	return q;
L
Linus Torvalds 已提交
393 394
}

395
static void __sigqueue_free(struct sigqueue *q)
L
Linus Torvalds 已提交
396 397 398 399 400 401 402 403
{
	if (q->flags & SIGQUEUE_PREALLOC)
		return;
	atomic_dec(&q->user->sigpending);
	free_uid(q->user);
	kmem_cache_free(sigqueue_cachep, q);
}

404
void flush_sigqueue(struct sigpending *queue)
L
Linus Torvalds 已提交
405 406 407 408 409 410 411 412 413 414 415 416 417 418
{
	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);
	}
}

/*
 * Flush all pending signals for a task.
 */
419 420 421 422 423 424 425
void __flush_signals(struct task_struct *t)
{
	clear_tsk_thread_flag(t, TIF_SIGPENDING);
	flush_sigqueue(&t->pending);
	flush_sigqueue(&t->signal->shared_pending);
}

426
void flush_signals(struct task_struct *t)
L
Linus Torvalds 已提交
427 428 429 430
{
	unsigned long flags;

	spin_lock_irqsave(&t->sighand->siglock, flags);
431
	__flush_signals(t);
L
Linus Torvalds 已提交
432 433 434
	spin_unlock_irqrestore(&t->sighand->siglock, flags);
}

435 436 437 438 439 440 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
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);
}

469 470 471 472 473 474 475 476 477 478
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 已提交
479 480 481 482 483 484 485 486 487 488 489 490 491
/*
 * 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;
492
#ifdef __ARCH_HAS_SA_RESTORER
493 494
		ka->sa.sa_restorer = NULL;
#endif
L
Linus Torvalds 已提交
495 496 497 498 499
		sigemptyset(&ka->sa.sa_mask);
		ka++;
	}
}

500 501
int unhandled_signal(struct task_struct *tsk, int sig)
{
502
	void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
503
	if (is_global_init(tsk))
504
		return 1;
505
	if (handler != SIG_IGN && handler != SIG_DFL)
506
		return 0;
T
Tejun Heo 已提交
507 508
	/* if ptraced, let the tracer determine */
	return !tsk->ptrace;
509 510
}

511 512
/*
 * Notify the system that a driver wants to block all signals for this
L
Linus Torvalds 已提交
513 514 515 516 517
 * process, and wants to be notified if any signals at all were to be
 * sent/acted upon.  If the notifier routine returns non-zero, then the
 * signal will be acted upon after all.  If the notifier routine returns 0,
 * then then signal will be blocked.  Only one block per process is
 * allowed.  priv is a pointer to private data that the notifier routine
518 519
 * can use to determine if the signal should be blocked or not.
 */
L
Linus Torvalds 已提交
520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545
void
block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
{
	unsigned long flags;

	spin_lock_irqsave(&current->sighand->siglock, flags);
	current->notifier_mask = mask;
	current->notifier_data = priv;
	current->notifier = notifier;
	spin_unlock_irqrestore(&current->sighand->siglock, flags);
}

/* Notify the system that blocking has ended. */

void
unblock_all_signals(void)
{
	unsigned long flags;

	spin_lock_irqsave(&current->sighand->siglock, flags);
	current->notifier = NULL;
	current->notifier_data = NULL;
	recalc_sigpending();
	spin_unlock_irqrestore(&current->sighand->siglock, flags);
}

546
static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
L
Linus Torvalds 已提交
547 548 549 550 551 552 553 554 555
{
	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) {
556 557
			if (first)
				goto still_pending;
L
Linus Torvalds 已提交
558 559 560
			first = q;
		}
	}
561 562 563

	sigdelset(&list->signal, sig);

L
Linus Torvalds 已提交
564
	if (first) {
565
still_pending:
L
Linus Torvalds 已提交
566 567 568 569
		list_del_init(&first->list);
		copy_siginfo(info, &first->info);
		__sigqueue_free(first);
	} else {
570 571 572 573
		/*
		 * 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 已提交
574 575 576
		 */
		info->si_signo = sig;
		info->si_errno = 0;
577
		info->si_code = SI_USER;
L
Linus Torvalds 已提交
578 579 580 581 582 583 584 585
		info->si_pid = 0;
		info->si_uid = 0;
	}
}

static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
			siginfo_t *info)
{
586
	int sig = next_signal(pending, mask);
L
Linus Torvalds 已提交
587 588 589 590 591 592 593 594 595 596 597

	if (sig) {
		if (current->notifier) {
			if (sigismember(current->notifier_mask, sig)) {
				if (!(current->notifier)(current->notifier_data)) {
					clear_thread_flag(TIF_SIGPENDING);
					return 0;
				}
			}
		}

598
		collect_signal(sig, pending, info);
L
Linus Torvalds 已提交
599 600 601 602 603 604
	}

	return sig;
}

/*
605
 * Dequeue a signal and return the element to the caller, which is
L
Linus Torvalds 已提交
606 607 608 609 610 611
 * expected to free it.
 *
 * All callers have to hold the siglock.
 */
int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
{
612
	int signr;
613 614 615 616

	/* We only dequeue private signals from ourselves, we don't let
	 * signalfd steal them
	 */
D
Davide Libenzi 已提交
617
	signr = __dequeue_signal(&tsk->pending, mask, info);
618
	if (!signr) {
L
Linus Torvalds 已提交
619 620
		signr = __dequeue_signal(&tsk->signal->shared_pending,
					 mask, info);
621 622 623 624 625 626
		/*
		 * 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
627
		 * compliant with the old way of self-restarting
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
		 * 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) &&
			    tsk->signal->it_real_incr.tv64 != 0) {
				hrtimer_forward(tmr, tmr->base->get_time(),
						tsk->signal->it_real_incr);
				hrtimer_restart(tmr);
			}
		}
	}
645

D
Davide Libenzi 已提交
646
	recalc_sigpending();
647 648 649 650
	if (!signr)
		return 0;

	if (unlikely(sig_kernel_stop(signr))) {
651 652 653 654 655 656 657 658 659 660 661 662
		/*
		 * 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.
		 */
663
		current->jobctl |= JOBCTL_STOP_DEQUEUED;
664
	}
665
	if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
L
Linus Torvalds 已提交
666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
		/*
		 * 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);
		do_schedule_next_timer(info);
		spin_lock(&tsk->sighand->siglock);
	}
	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
 */
690
void signal_wake_up_state(struct task_struct *t, unsigned int state)
L
Linus Torvalds 已提交
691 692 693
{
	set_tsk_thread_flag(t, TIF_SIGPENDING);
	/*
694
	 * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
M
Matthew Wilcox 已提交
695
	 * case. We don't check t->state here because there is a race with it
L
Linus Torvalds 已提交
696 697 698 699
	 * 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.
	 */
700
	if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
L
Linus Torvalds 已提交
701 702 703
		kick_process(t);
}

704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
/*
 * Remove signals in mask from the pending set and queue.
 * Returns 1 if any signals were found.
 *
 * All callers must be holding the siglock.
 *
 * This version takes a sigset mask and looks at all signals,
 * not just those in the first mask word.
 */
static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
{
	struct sigqueue *q, *n;
	sigset_t m;

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

722
	sigandnsets(&s->signal, &s->signal, mask);
723 724 725 726 727 728 729 730
	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 已提交
731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754
/*
 * Remove signals in mask from the pending set and queue.
 * Returns 1 if any signals were found.
 *
 * All callers must be holding the siglock.
 */
static int rm_from_queue(unsigned long mask, struct sigpending *s)
{
	struct sigqueue *q, *n;

	if (!sigtestsetmask(&s->signal, mask))
		return 0;

	sigdelsetmask(&s->signal, mask);
	list_for_each_entry_safe(q, n, &s->list, list) {
		if (q->info.si_signo < SIGRTMIN &&
		    (mask & sigmask(q->info.si_signo))) {
			list_del_init(&q->list);
			__sigqueue_free(q);
		}
	}
	return 1;
}

755 756 757 758 759 760 761 762 763 764 765
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));
}

766 767 768 769 770 771 772 773
/*
 * 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);

774 775 776 777
	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))
778 779
		return 1;

780
	if (ns_capable(tcred->user_ns, CAP_KILL))
781 782 783 784 785
		return 1;

	return 0;
}

L
Linus Torvalds 已提交
786 787
/*
 * Bad permissions for sending the signal
788
 * - the caller must hold the RCU read lock
L
Linus Torvalds 已提交
789 790 791 792
 */
static int check_kill_permission(int sig, struct siginfo *info,
				 struct task_struct *t)
{
793
	struct pid *sid;
794 795
	int error;

796
	if (!valid_signal(sig))
797 798
		return -EINVAL;

799
	if (!si_fromuser(info))
800
		return 0;
A
Amy Griffis 已提交
801

802 803
	error = audit_signal_info(sig, t); /* Let audit system see the signal */
	if (error)
L
Linus Torvalds 已提交
804
		return error;
805

806
	if (!same_thread_group(current, t) &&
807
	    !kill_ok_by_cred(t)) {
808 809 810 811 812 813 814 815 816 817 818 819 820
		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;
		}
	}
821

A
Amy Griffis 已提交
822
	return security_task_kill(t, info, sig, 0);
L
Linus Torvalds 已提交
823 824
}

825 826 827 828 829 830 831 832
/**
 * 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 已提交
833 834 835 836 837
 * 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.
838 839 840 841 842 843 844 845 846 847
 *
 * 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);
848
	ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
849 850
}

L
Linus Torvalds 已提交
851
/*
852 853
 * Handle magic process-wide effects of stop/continue signals. Unlike
 * the signal actions, these happen immediately at signal-generation
L
Linus Torvalds 已提交
854 855
 * time regardless of blocking, ignoring, or handling.  This does the
 * actual continuing for SIGCONT, but not the actual stopping for stop
856 857 858 859
 * 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 已提交
860
 */
861
static bool prepare_signal(int sig, struct task_struct *p, bool force)
L
Linus Torvalds 已提交
862
{
863
	struct signal_struct *signal = p->signal;
L
Linus Torvalds 已提交
864 865
	struct task_struct *t;

866 867 868
	if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
		if (signal->flags & SIGNAL_GROUP_COREDUMP)
			return sig == SIGKILL;
L
Linus Torvalds 已提交
869
		/*
870
		 * The process is in the middle of dying, nothing to do.
L
Linus Torvalds 已提交
871
		 */
872
	} else if (sig_kernel_stop(sig)) {
L
Linus Torvalds 已提交
873 874 875
		/*
		 * This is a stop signal.  Remove SIGCONT from all queues.
		 */
876
		rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
L
Linus Torvalds 已提交
877 878 879
		t = p;
		do {
			rm_from_queue(sigmask(SIGCONT), &t->pending);
880
		} while_each_thread(p, t);
L
Linus Torvalds 已提交
881
	} else if (sig == SIGCONT) {
882
		unsigned int why;
L
Linus Torvalds 已提交
883
		/*
884
		 * Remove all stop signals from all queues, wake all threads.
L
Linus Torvalds 已提交
885
		 */
886
		rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
L
Linus Torvalds 已提交
887 888
		t = p;
		do {
889
			task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
L
Linus Torvalds 已提交
890
			rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
891 892 893 894
			if (likely(!(t->ptrace & PT_SEIZED)))
				wake_up_state(t, __TASK_STOPPED);
			else
				ptrace_trap_notify(t);
895
		} while_each_thread(p, t);
L
Linus Torvalds 已提交
896

897 898 899 900 901 902 903 904 905
		/*
		 * 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;
906
		if (signal->flags & SIGNAL_STOP_STOPPED)
907
			why |= SIGNAL_CLD_CONTINUED;
908
		else if (signal->group_stop_count)
909 910 911
			why |= SIGNAL_CLD_STOPPED;

		if (why) {
912
			/*
913
			 * The first thread which returns from do_signal_stop()
914 915 916
			 * will take ->siglock, notice SIGNAL_CLD_MASK, and
			 * notify its parent. See get_signal_to_deliver().
			 */
917 918 919
			signal->flags = why | SIGNAL_STOP_CONTINUED;
			signal->group_stop_count = 0;
			signal->group_exit_code = 0;
L
Linus Torvalds 已提交
920 921
		}
	}
922

923
	return !sig_ignored(p, sig, force);
L
Linus Torvalds 已提交
924 925
}

926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
/*
 * 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);
}

947
static void complete_signal(int sig, struct task_struct *p, int group)
948 949 950 951 952 953 954 955 956 957 958 959
{
	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;
960
	else if (!group || thread_group_empty(p))
961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987
		/*
		 * 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.
	 */
988 989
	if (sig_fatal(p, sig) &&
	    !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
990
	    !sigismember(&t->real_blocked, sig) &&
T
Tejun Heo 已提交
991
	    (sig == SIGKILL || !t->ptrace)) {
992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006
		/*
		 * 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 {
1007
				task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
				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;
}

1023 1024 1025 1026 1027
static inline int legacy_queue(struct sigpending *signals, int sig)
{
	return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
}

1028 1029 1030 1031 1032 1033 1034 1035 1036
#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;

1037 1038 1039 1040
	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();
1041 1042 1043 1044 1045 1046 1047 1048
}
#else
static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
{
	return;
}
#endif

1049 1050
static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
			int group, int from_ancestor_ns)
L
Linus Torvalds 已提交
1051
{
1052
	struct sigpending *pending;
1053
	struct sigqueue *q;
1054
	int override_rlimit;
1055
	int ret = 0, result;
1056

1057
	assert_spin_locked(&t->sighand->siglock);
1058

1059
	result = TRACE_SIGNAL_IGNORED;
1060 1061
	if (!prepare_signal(sig, t,
			from_ancestor_ns || (info == SEND_SIG_FORCED)))
1062
		goto ret;
1063 1064

	pending = group ? &t->signal->shared_pending : &t->pending;
1065 1066 1067 1068 1069
	/*
	 * 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.
	 */
1070
	result = TRACE_SIGNAL_ALREADY_PENDING;
1071
	if (legacy_queue(pending, sig))
1072 1073 1074
		goto ret;

	result = TRACE_SIGNAL_DELIVERED;
L
Linus Torvalds 已提交
1075 1076 1077 1078
	/*
	 * fast-pathed signals for kernel-internal things like SIGSTOP
	 * or SIGKILL.
	 */
1079
	if (info == SEND_SIG_FORCED)
L
Linus Torvalds 已提交
1080 1081
		goto out_set;

1082 1083 1084 1085 1086 1087 1088 1089 1090
	/*
	 * 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.
	 */
1091 1092 1093 1094 1095
	if (sig < SIGRTMIN)
		override_rlimit = (is_si_special(info) || info->si_code >= 0);
	else
		override_rlimit = 0;

1096
	q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
1097
		override_rlimit);
L
Linus Torvalds 已提交
1098
	if (q) {
1099
		list_add_tail(&q->list, &pending->list);
L
Linus Torvalds 已提交
1100
		switch ((unsigned long) info) {
1101
		case (unsigned long) SEND_SIG_NOINFO:
L
Linus Torvalds 已提交
1102 1103 1104
			q->info.si_signo = sig;
			q->info.si_errno = 0;
			q->info.si_code = SI_USER;
1105
			q->info.si_pid = task_tgid_nr_ns(current,
1106
							task_active_pid_ns(t));
1107
			q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
L
Linus Torvalds 已提交
1108
			break;
1109
		case (unsigned long) SEND_SIG_PRIV:
L
Linus Torvalds 已提交
1110 1111 1112 1113 1114 1115 1116 1117
			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);
1118 1119
			if (from_ancestor_ns)
				q->info.si_pid = 0;
L
Linus Torvalds 已提交
1120 1121
			break;
		}
1122 1123 1124

		userns_fixup_signal_uid(&q->info, t);

1125
	} else if (!is_si_special(info)) {
1126 1127 1128 1129 1130 1131
		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().
			 */
1132 1133 1134
			result = TRACE_SIGNAL_OVERFLOW_FAIL;
			ret = -EAGAIN;
			goto ret;
1135 1136 1137 1138 1139
		} else {
			/*
			 * This is a silent loss of information.  We still
			 * send the signal, but the *info bits are lost.
			 */
1140
			result = TRACE_SIGNAL_LOSE_INFO;
1141
		}
L
Linus Torvalds 已提交
1142 1143 1144
	}

out_set:
1145
	signalfd_notify(t, sig);
1146
	sigaddset(&pending->signal, sig);
1147
	complete_signal(sig, t, group);
1148 1149 1150
ret:
	trace_signal_generate(sig, info, t, group, result);
	return ret;
L
Linus Torvalds 已提交
1151 1152
}

1153 1154 1155
static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
			int group)
{
1156 1157 1158
	int from_ancestor_ns = 0;

#ifdef CONFIG_PID_NS
1159 1160
	from_ancestor_ns = si_fromuser(info) &&
			   !task_pid_nr_ns(current, task_active_pid_ns(t));
1161 1162 1163
#endif

	return __send_signal(sig, info, t, group, from_ancestor_ns);
1164 1165
}

1166
static void print_fatal_signal(int signr)
I
Ingo Molnar 已提交
1167
{
1168
	struct pt_regs *regs = signal_pt_regs();
1169
	printk(KERN_INFO "potentially unexpected fatal signal %d.\n", signr);
I
Ingo Molnar 已提交
1170

A
Al Viro 已提交
1171
#if defined(__i386__) && !defined(__arch_um__)
1172
	printk(KERN_INFO "code at %08lx: ", regs->ip);
I
Ingo Molnar 已提交
1173 1174 1175 1176 1177
	{
		int i;
		for (i = 0; i < 16; i++) {
			unsigned char insn;

1178 1179
			if (get_user(insn, (unsigned char *)(regs->ip + i)))
				break;
1180
			printk(KERN_CONT "%02x ", insn);
I
Ingo Molnar 已提交
1181 1182
		}
	}
1183
	printk(KERN_CONT "\n");
I
Ingo Molnar 已提交
1184
#endif
1185
	preempt_disable();
I
Ingo Molnar 已提交
1186
	show_regs(regs);
1187
	preempt_enable();
I
Ingo Molnar 已提交
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
}

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

1199 1200 1201 1202 1203 1204
int
__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
	return send_signal(sig, info, p, 1);
}

L
Linus Torvalds 已提交
1205 1206 1207
static int
specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
1208
	return send_signal(sig, info, t, 0);
L
Linus Torvalds 已提交
1209 1210
}

1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
			bool group)
{
	unsigned long flags;
	int ret = -ESRCH;

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

	return ret;
}

L
Linus Torvalds 已提交
1225 1226 1227
/*
 * Force a signal that the process can't ignore: if necessary
 * we unblock the signal and change any SIG_IGN to SIG_DFL.
1228 1229 1230 1231 1232
 *
 * 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.
 *
1233 1234
 * We don't want to have recursive SIGSEGV's etc, for example,
 * that is why we also clear SIGNAL_UNKILLABLE.
L
Linus Torvalds 已提交
1235 1236 1237 1238 1239
 */
int
force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
	unsigned long int flags;
1240 1241
	int ret, blocked, ignored;
	struct k_sigaction *action;
L
Linus Torvalds 已提交
1242 1243

	spin_lock_irqsave(&t->sighand->siglock, flags);
1244 1245 1246 1247 1248 1249 1250
	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 已提交
1251
			recalc_sigpending_and_wake(t);
1252
		}
L
Linus Torvalds 已提交
1253
	}
1254 1255
	if (action->sa.sa_handler == SIG_DFL)
		t->signal->flags &= ~SIGNAL_UNKILLABLE;
L
Linus Torvalds 已提交
1256 1257 1258 1259 1260 1261 1262 1263 1264
	ret = specific_send_sig_info(sig, info, t);
	spin_unlock_irqrestore(&t->sighand->siglock, flags);

	return ret;
}

/*
 * Nuke all other threads in the group.
 */
1265
int zap_other_threads(struct task_struct *p)
L
Linus Torvalds 已提交
1266
{
1267 1268
	struct task_struct *t = p;
	int count = 0;
L
Linus Torvalds 已提交
1269 1270 1271

	p->signal->group_stop_count = 0;

1272
	while_each_thread(p, t) {
1273
		task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1274 1275 1276
		count++;

		/* Don't bother with already dead threads */
L
Linus Torvalds 已提交
1277 1278 1279 1280 1281
		if (t->exit_state)
			continue;
		sigaddset(&t->pending.signal, SIGKILL);
		signal_wake_up(t, 1);
	}
1282 1283

	return count;
L
Linus Torvalds 已提交
1284 1285
}

1286 1287
struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
					   unsigned long *flags)
1288 1289 1290 1291
{
	struct sighand_struct *sighand;

	for (;;) {
1292 1293
		local_irq_save(*flags);
		rcu_read_lock();
1294
		sighand = rcu_dereference(tsk->sighand);
1295 1296 1297
		if (unlikely(sighand == NULL)) {
			rcu_read_unlock();
			local_irq_restore(*flags);
1298
			break;
1299
		}
1300

1301 1302 1303
		spin_lock(&sighand->siglock);
		if (likely(sighand == tsk->sighand)) {
			rcu_read_unlock();
1304
			break;
1305 1306 1307 1308
		}
		spin_unlock(&sighand->siglock);
		rcu_read_unlock();
		local_irq_restore(*flags);
1309 1310 1311 1312 1313
	}

	return sighand;
}

1314 1315 1316
/*
 * send signal info to all the members of a group
 */
L
Linus Torvalds 已提交
1317 1318
int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
1319 1320 1321 1322 1323
	int ret;

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

1325 1326
	if (!ret && sig)
		ret = do_send_sig_info(sig, info, p, true);
L
Linus Torvalds 已提交
1327 1328 1329 1330 1331

	return ret;
}

/*
1332
 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
L
Linus Torvalds 已提交
1333
 * control characters do (^C, ^Z etc)
1334
 * - the caller must hold at least a readlock on tasklist_lock
L
Linus Torvalds 已提交
1335
 */
1336
int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
L
Linus Torvalds 已提交
1337 1338 1339 1340 1341 1342
{
	struct task_struct *p = NULL;
	int retval, success;

	success = 0;
	retval = -ESRCH;
1343
	do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
L
Linus Torvalds 已提交
1344 1345 1346
		int err = group_send_sig_info(sig, info, p);
		success |= !err;
		retval = err;
1347
	} while_each_pid_task(pgrp, PIDTYPE_PGID, p);
L
Linus Torvalds 已提交
1348 1349 1350
	return success ? 0 : retval;
}

1351
int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
L
Linus Torvalds 已提交
1352
{
1353
	int error = -ESRCH;
L
Linus Torvalds 已提交
1354 1355
	struct task_struct *p;

I
Ingo Molnar 已提交
1356
	rcu_read_lock();
1357
retry:
1358
	p = pid_task(pid, PIDTYPE_PID);
1359
	if (p) {
L
Linus Torvalds 已提交
1360
		error = group_send_sig_info(sig, info, p);
1361 1362 1363 1364 1365 1366 1367 1368 1369
		if (unlikely(error == -ESRCH))
			/*
			 * 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.
			 */
			goto retry;
	}
I
Ingo Molnar 已提交
1370
	rcu_read_unlock();
1371

L
Linus Torvalds 已提交
1372 1373 1374
	return error;
}

1375
int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1376 1377 1378
{
	int error;
	rcu_read_lock();
1379
	error = kill_pid_info(sig, info, find_vpid(pid));
1380 1381 1382 1383
	rcu_read_unlock();
	return error;
}

1384 1385 1386 1387
static int kill_as_cred_perm(const struct cred *cred,
			     struct task_struct *target)
{
	const struct cred *pcred = __task_cred(target);
1388 1389
	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))
1390 1391 1392 1393
		return 0;
	return 1;
}

1394
/* like kill_pid_info(), but doesn't use uid/euid of "current" */
1395 1396
int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid,
			 const struct cred *cred, u32 secid)
1397 1398 1399
{
	int ret = -EINVAL;
	struct task_struct *p;
1400
	unsigned long flags;
1401 1402 1403 1404

	if (!valid_signal(sig))
		return ret;

1405
	rcu_read_lock();
1406
	p = pid_task(pid, PIDTYPE_PID);
1407 1408 1409 1410
	if (!p) {
		ret = -ESRCH;
		goto out_unlock;
	}
1411
	if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
1412 1413 1414
		ret = -EPERM;
		goto out_unlock;
	}
1415 1416 1417
	ret = security_task_kill(p, info, sig, secid);
	if (ret)
		goto out_unlock;
1418 1419 1420 1421 1422 1423 1424

	if (sig) {
		if (lock_task_sighand(p, &flags)) {
			ret = __send_signal(sig, info, p, 1, 0);
			unlock_task_sighand(p, &flags);
		} else
			ret = -ESRCH;
1425 1426
	}
out_unlock:
1427
	rcu_read_unlock();
1428 1429
	return ret;
}
1430
EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
L
Linus Torvalds 已提交
1431 1432 1433 1434 1435 1436 1437 1438

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

1439
static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
L
Linus Torvalds 已提交
1440
{
1441
	int ret;
1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454

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

	read_lock(&tasklist_lock);
	if (pid != -1) {
		ret = __kill_pgrp_info(sig, info,
				pid ? find_vpid(-pid) : task_pgrp(current));
	} else {
L
Linus Torvalds 已提交
1455 1456 1457 1458
		int retval = 0, count = 0;
		struct task_struct * p;

		for_each_process(p) {
1459 1460
			if (task_pid_vnr(p) > 1 &&
					!same_thread_group(p, current)) {
L
Linus Torvalds 已提交
1461 1462 1463 1464 1465 1466
				int err = group_send_sig_info(sig, info, p);
				++count;
				if (err != -EPERM)
					retval = err;
			}
		}
1467
		ret = count ? retval : -ESRCH;
L
Linus Torvalds 已提交
1468
	}
1469 1470
	read_unlock(&tasklist_lock);

1471
	return ret;
L
Linus Torvalds 已提交
1472 1473 1474 1475 1476 1477
}

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

1478
int send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
L
Linus Torvalds 已提交
1479 1480 1481 1482 1483
{
	/*
	 * Make sure legacy kernel users don't send in bad values
	 * (normal paths check this in check_kill_permission).
	 */
1484
	if (!valid_signal(sig))
L
Linus Torvalds 已提交
1485 1486
		return -EINVAL;

1487
	return do_send_sig_info(sig, info, p, false);
L
Linus Torvalds 已提交
1488 1489
}

1490 1491 1492
#define __si_special(priv) \
	((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)

L
Linus Torvalds 已提交
1493 1494 1495
int
send_sig(int sig, struct task_struct *p, int priv)
{
1496
	return send_sig_info(sig, __si_special(priv), p);
L
Linus Torvalds 已提交
1497 1498 1499 1500 1501
}

void
force_sig(int sig, struct task_struct *p)
{
1502
	force_sig_info(sig, SEND_SIG_PRIV, p);
L
Linus Torvalds 已提交
1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523
}

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

1524 1525
int kill_pgrp(struct pid *pid, int sig, int priv)
{
1526 1527 1528 1529 1530 1531 1532
	int ret;

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

	return ret;
1533 1534 1535 1536 1537 1538 1539 1540 1541
}
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 已提交
1542 1543 1544 1545
/*
 * 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
1546
 * expirations or I/O completions".  In the case of POSIX Timers
L
Linus Torvalds 已提交
1547 1548 1549 1550 1551 1552
 * 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)
{
1553
	struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
L
Linus Torvalds 已提交
1554

1555
	if (q)
L
Linus Torvalds 已提交
1556
		q->flags |= SIGQUEUE_PREALLOC;
1557 1558

	return q;
L
Linus Torvalds 已提交
1559 1560 1561 1562 1563
}

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

L
Linus Torvalds 已提交
1566 1567
	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
	/*
1568 1569
	 * We must hold ->siglock while testing q->list
	 * to serialize with collect_signal() or with
1570
	 * __exit_signal()->flush_sigqueue().
L
Linus Torvalds 已提交
1571
	 */
1572
	spin_lock_irqsave(lock, flags);
1573 1574 1575 1576 1577
	q->flags &= ~SIGQUEUE_PREALLOC;
	/*
	 * If it is queued it will be freed when dequeued,
	 * like the "regular" sigqueue.
	 */
1578
	if (!list_empty(&q->list))
1579
		q = NULL;
1580 1581
	spin_unlock_irqrestore(lock, flags);

1582 1583
	if (q)
		__sigqueue_free(q);
L
Linus Torvalds 已提交
1584 1585
}

1586
int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1587
{
1588
	int sig = q->info.si_signo;
1589
	struct sigpending *pending;
1590
	unsigned long flags;
1591
	int ret, result;
1592

1593
	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1594 1595 1596 1597 1598

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

1599
	ret = 1; /* the signal is ignored */
1600
	result = TRACE_SIGNAL_IGNORED;
1601
	if (!prepare_signal(sig, t, false))
1602 1603 1604
		goto out;

	ret = 0;
1605 1606 1607 1608 1609 1610 1611
	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++;
1612
		result = TRACE_SIGNAL_ALREADY_PENDING;
1613
		goto out;
1614
	}
1615
	q->info.si_overrun = 0;
1616 1617

	signalfd_notify(t, sig);
1618
	pending = group ? &t->signal->shared_pending : &t->pending;
1619 1620
	list_add_tail(&q->list, &pending->list);
	sigaddset(&pending->signal, sig);
1621
	complete_signal(sig, t, group);
1622
	result = TRACE_SIGNAL_DELIVERED;
1623
out:
1624
	trace_signal_generate(sig, &q->info, t, group, result);
1625 1626 1627
	unlock_task_sighand(t, &flags);
ret:
	return ret;
1628 1629
}

L
Linus Torvalds 已提交
1630 1631 1632
/*
 * 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 已提交
1633
 *
1634 1635
 * Returns true if our parent ignored us and so we've switched to
 * self-reaping.
L
Linus Torvalds 已提交
1636
 */
1637
bool do_notify_parent(struct task_struct *tsk, int sig)
L
Linus Torvalds 已提交
1638 1639 1640 1641
{
	struct siginfo info;
	unsigned long flags;
	struct sighand_struct *psig;
1642
	bool autoreap = false;
1643
	cputime_t utime, stime;
L
Linus Torvalds 已提交
1644 1645 1646 1647

	BUG_ON(sig == -1);

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

T
Tejun Heo 已提交
1650
	BUG_ON(!tsk->ptrace &&
L
Linus Torvalds 已提交
1651 1652
	       (tsk->group_leader != tsk || !thread_group_empty(tsk)));

1653 1654 1655 1656 1657 1658 1659 1660 1661
	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;
	}

L
Linus Torvalds 已提交
1662 1663
	info.si_signo = sig;
	info.si_errno = 0;
1664
	/*
1665 1666
	 * We are under tasklist_lock here so our parent is tied to
	 * us and cannot change.
1667
	 *
1668 1669
	 * task_active_pid_ns will always return the same pid namespace
	 * until a task passes through release_task.
1670 1671 1672 1673 1674 1675
	 *
	 * 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();
1676
	info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1677 1678
	info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
				       task_uid(tsk));
1679 1680
	rcu_read_unlock();

1681 1682 1683
	task_cputime(tsk, &utime, &stime);
	info.si_utime = cputime_to_clock_t(utime + tsk->signal->utime);
	info.si_stime = cputime_to_clock_t(stime + tsk->signal->stime);
L
Linus Torvalds 已提交
1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696

	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 已提交
1697
	if (!tsk->ptrace && sig == SIGCHLD &&
L
Linus Torvalds 已提交
1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714
	    (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).
		 */
1715
		autoreap = true;
L
Linus Torvalds 已提交
1716
		if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1717
			sig = 0;
L
Linus Torvalds 已提交
1718
	}
1719
	if (valid_signal(sig) && sig)
L
Linus Torvalds 已提交
1720 1721 1722
		__group_send_sig_info(sig, &info, tsk->parent);
	__wake_up_parent(tsk, tsk->parent);
	spin_unlock_irqrestore(&psig->siglock, flags);
R
Roland McGrath 已提交
1723

1724
	return autoreap;
L
Linus Torvalds 已提交
1725 1726
}

1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741
/**
 * 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 已提交
1742 1743 1744
{
	struct siginfo info;
	unsigned long flags;
1745
	struct task_struct *parent;
L
Linus Torvalds 已提交
1746
	struct sighand_struct *sighand;
1747
	cputime_t utime, stime;
L
Linus Torvalds 已提交
1748

1749
	if (for_ptracer) {
1750
		parent = tsk->parent;
1751
	} else {
1752 1753 1754 1755
		tsk = tsk->group_leader;
		parent = tsk->real_parent;
	}

L
Linus Torvalds 已提交
1756 1757
	info.si_signo = SIGCHLD;
	info.si_errno = 0;
1758
	/*
1759
	 * see comment in do_notify_parent() about the following 4 lines
1760 1761
	 */
	rcu_read_lock();
1762
	info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
1763
	info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
1764 1765
	rcu_read_unlock();

1766 1767 1768
	task_cputime(tsk, &utime, &stime);
	info.si_utime = cputime_to_clock_t(utime);
	info.si_stime = cputime_to_clock_t(stime);
L
Linus Torvalds 已提交
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796

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

1797 1798
static inline int may_ptrace_stop(void)
{
T
Tejun Heo 已提交
1799
	if (!likely(current->ptrace))
1800 1801 1802 1803 1804 1805 1806
		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
1807
	 * ->siglock we must see ->core_state != NULL. Otherwise it
1808
	 * is safe to enter schedule().
1809 1810 1811 1812
	 *
	 * 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.
1813
	 */
1814
	if (unlikely(current->mm->core_state) &&
1815 1816 1817 1818 1819 1820
	    unlikely(current->mm == current->parent->mm))
		return 0;

	return 1;
}

R
Roland McGrath 已提交
1821
/*
1822
 * Return non-zero if there is a SIGKILL that should be waking us up.
R
Roland McGrath 已提交
1823 1824 1825 1826
 * Called with the siglock held.
 */
static int sigkill_pending(struct task_struct *tsk)
{
1827 1828
	return	sigismember(&tsk->pending.signal, SIGKILL) ||
		sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
R
Roland McGrath 已提交
1829 1830
}

L
Linus Torvalds 已提交
1831 1832 1833 1834 1835 1836 1837 1838
/*
 * 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.
 *
1839 1840
 * 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 已提交
1841
 */
T
Tejun Heo 已提交
1842
static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
1843 1844
	__releases(&current->sighand->siglock)
	__acquires(&current->sighand->siglock)
L
Linus Torvalds 已提交
1845
{
1846 1847
	bool gstop_done = false;

R
Roland McGrath 已提交
1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862
	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);
1863 1864
		if (sigkill_pending(current))
			return;
R
Roland McGrath 已提交
1865 1866
	}

L
Linus Torvalds 已提交
1867
	/*
1868 1869 1870 1871 1872
	 * 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.
L
Linus Torvalds 已提交
1873
	 */
1874
	set_current_state(TASK_TRACED);
L
Linus Torvalds 已提交
1875 1876 1877 1878

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

1879
	/*
1880 1881
	 * If @why is CLD_STOPPED, we're trapping to participate in a group
	 * stop.  Do the bookkeeping.  Note that if SIGCONT was delievered
1882 1883 1884
	 * 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.
1885
	 */
1886
	if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
1887
		gstop_done = task_participate_group_stop(current);
1888

1889
	/* any trap clears pending STOP trap, STOP trap clears NOTIFY */
1890
	task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
1891 1892
	if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
		task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
1893

1894
	/* entering a trap, clear TRAPPING */
1895
	task_clear_jobctl_trapping(current);
1896

L
Linus Torvalds 已提交
1897 1898
	spin_unlock_irq(&current->sighand->siglock);
	read_lock(&tasklist_lock);
1899
	if (may_ptrace_stop()) {
1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910
		/*
		 * 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);
1911
		if (gstop_done && ptrace_reparented(current))
1912 1913
			do_notify_parent_cldstop(current, false, why);

M
Miklos Szeredi 已提交
1914 1915 1916 1917 1918 1919 1920
		/*
		 * 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 已提交
1921
		read_unlock(&tasklist_lock);
M
Miklos Szeredi 已提交
1922
		preempt_enable_no_resched();
1923
		freezable_schedule();
L
Linus Torvalds 已提交
1924 1925 1926
	} else {
		/*
		 * By the time we got the lock, our tracer went away.
1927
		 * Don't drop the lock yet, another tracer may come.
1928 1929 1930
		 *
		 * If @gstop_done, the ptracer went away between group stop
		 * completion and here.  During detach, it would have set
1931 1932 1933
		 * 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 已提交
1934
		 */
1935 1936 1937
		if (gstop_done)
			do_notify_parent_cldstop(current, false, why);

1938
		/* tasklist protects us from ptrace_freeze_traced() */
1939
		__set_current_state(TASK_RUNNING);
1940 1941
		if (clear_code)
			current->exit_code = 0;
1942
		read_unlock(&tasklist_lock);
L
Linus Torvalds 已提交
1943 1944 1945 1946 1947 1948 1949 1950 1951 1952
	}

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

L
Linus Torvalds 已提交
1956 1957 1958
	/*
	 * Queued signals ignored us while we were stopped for tracing.
	 * So check for any that we should take before resuming user mode.
1959
	 * This sets TIF_SIGPENDING, but never clears it.
L
Linus Torvalds 已提交
1960
	 */
1961
	recalc_sigpending_tsk(current);
L
Linus Torvalds 已提交
1962 1963
}

T
Tejun Heo 已提交
1964
static void ptrace_do_notify(int signr, int exit_code, int why)
L
Linus Torvalds 已提交
1965 1966 1967 1968
{
	siginfo_t info;

	memset(&info, 0, sizeof info);
T
Tejun Heo 已提交
1969
	info.si_signo = signr;
L
Linus Torvalds 已提交
1970
	info.si_code = exit_code;
1971
	info.si_pid = task_pid_vnr(current);
1972
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
L
Linus Torvalds 已提交
1973 1974

	/* Let the debugger run.  */
T
Tejun Heo 已提交
1975 1976 1977 1978 1979 1980
	ptrace_stop(exit_code, why, 1, &info);
}

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

L
Linus Torvalds 已提交
1984
	spin_lock_irq(&current->sighand->siglock);
T
Tejun Heo 已提交
1985
	ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
L
Linus Torvalds 已提交
1986 1987 1988
	spin_unlock_irq(&current->sighand->siglock);
}

1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009
/**
 * 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 已提交
2010
 */
2011 2012
static bool do_signal_stop(int signr)
	__releases(&current->sighand->siglock)
L
Linus Torvalds 已提交
2013 2014 2015
{
	struct signal_struct *sig = current->signal;

2016 2017
	if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
		unsigned int gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
2018 2019
		struct task_struct *t;

2020 2021
		/* signr will be recorded in task->jobctl for retries */
		WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
2022

2023
		if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
2024
		    unlikely(signal_group_exit(sig)))
2025
			return false;
L
Linus Torvalds 已提交
2026
		/*
2027 2028 2029 2030 2031 2032 2033
		 * 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
2034 2035
		 * cause two group stops when !ptraced.  That is why we
		 * also check !task_is_stopped(t) below.
2036 2037 2038 2039 2040 2041 2042 2043
		 *
		 * 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 已提交
2044
		 */
2045 2046
		if (!(sig->flags & SIGNAL_STOP_STOPPED))
			sig->group_exit_code = signr;
L
Linus Torvalds 已提交
2047

2048 2049 2050 2051
		sig->group_stop_count = 0;

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

2053 2054
		t = current;
		while_each_thread(current, t) {
L
Linus Torvalds 已提交
2055
			/*
2056 2057 2058
			 * 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 已提交
2059
			 */
2060 2061
			if (!task_is_stopped(t) &&
			    task_set_jobctl_pending(t, signr | gstop)) {
2062
				sig->group_stop_count++;
2063 2064 2065 2066
				if (likely(!(t->ptrace & PT_SEIZED)))
					signal_wake_up(t, 0);
				else
					ptrace_trap_notify(t);
2067
			}
2068
		}
L
Linus Torvalds 已提交
2069
	}
2070

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

2074 2075 2076 2077 2078 2079 2080 2081
		/*
		 * 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;

2082
		__set_current_state(TASK_STOPPED);
2083 2084
		spin_unlock_irq(&current->sighand->siglock);

2085 2086 2087 2088 2089 2090 2091 2092 2093
		/*
		 * 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.
		 */
2094 2095
		if (notify) {
			read_lock(&tasklist_lock);
2096
			do_notify_parent_cldstop(current, false, notify);
2097 2098 2099 2100
			read_unlock(&tasklist_lock);
		}

		/* Now we don't run again until woken by SIGCONT or SIGKILL */
2101
		freezable_schedule();
2102
		return true;
2103
	} else {
2104 2105 2106 2107 2108 2109
		/*
		 * 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;
2110
	}
2111
}
L
Linus Torvalds 已提交
2112

2113 2114 2115
/**
 * do_jobctl_trap - take care of ptrace jobctl traps
 *
T
Tejun Heo 已提交
2116 2117 2118 2119 2120 2121 2122
 * 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.
2123 2124 2125 2126 2127 2128 2129
 *
 * 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 已提交
2130
	struct signal_struct *signal = current->signal;
2131
	int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2132

T
Tejun Heo 已提交
2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143
	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;
2144
	}
L
Linus Torvalds 已提交
2145 2146
}

2147
static int ptrace_signal(int signr, siginfo_t *info)
R
Roland McGrath 已提交
2148
{
2149
	ptrace_signal_deliver();
2150 2151 2152 2153 2154 2155 2156 2157 2158 2159
	/*
	 * 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 已提交
2160
	ptrace_stop(signr, CLD_TRAPPED, 0, info);
R
Roland McGrath 已提交
2161 2162 2163 2164 2165 2166 2167 2168

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

	current->exit_code = 0;

2169 2170 2171 2172 2173 2174
	/*
	 * 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 已提交
2175 2176 2177 2178
	if (signr != info->si_signo) {
		info->si_signo = signr;
		info->si_errno = 0;
		info->si_code = SI_USER;
2179
		rcu_read_lock();
R
Roland McGrath 已提交
2180
		info->si_pid = task_pid_vnr(current->parent);
2181 2182
		info->si_uid = from_kuid_munged(current_user_ns(),
						task_uid(current->parent));
2183
		rcu_read_unlock();
R
Roland McGrath 已提交
2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194
	}

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

L
Linus Torvalds 已提交
2195 2196 2197
int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
			  struct pt_regs *regs, void *cookie)
{
2198 2199 2200
	struct sighand_struct *sighand = current->sighand;
	struct signal_struct *signal = current->signal;
	int signr;
L
Linus Torvalds 已提交
2201

2202 2203
	if (unlikely(current->task_works))
		task_work_run();
2204

2205 2206 2207
	if (unlikely(uprobe_deny_signal()))
		return 0;

R
Roland McGrath 已提交
2208
	/*
2209 2210 2211
	 * 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 已提交
2212
	 */
2213 2214
	try_to_freeze();

2215
relock:
2216
	spin_lock_irq(&sighand->siglock);
2217 2218 2219 2220 2221
	/*
	 * 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.
	 */
2222
	if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2223 2224 2225 2226 2227 2228 2229
		int why;

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

2230
		signal->flags &= ~SIGNAL_CLD_MASK;
2231

2232
		spin_unlock_irq(&sighand->siglock);
R
Roland McGrath 已提交
2233

2234 2235 2236 2237 2238 2239 2240 2241
		/*
		 * 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 已提交
2242
		read_lock(&tasklist_lock);
2243 2244
		do_notify_parent_cldstop(current, false, why);

2245 2246 2247
		if (ptrace_reparented(current->group_leader))
			do_notify_parent_cldstop(current->group_leader,
						true, why);
T
Tejun Heo 已提交
2248
		read_unlock(&tasklist_lock);
2249

2250 2251 2252
		goto relock;
	}

L
Linus Torvalds 已提交
2253 2254
	for (;;) {
		struct k_sigaction *ka;
2255

T
Tejun Heo 已提交
2256 2257
		if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
		    do_signal_stop(0))
2258
			goto relock;
2259

2260 2261 2262 2263 2264
		if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
			do_jobctl_trap();
			spin_unlock_irq(&sighand->siglock);
			goto relock;
		}
L
Linus Torvalds 已提交
2265

T
Tejun Heo 已提交
2266
		signr = dequeue_signal(current, &current->blocked, info);
2267

T
Tejun Heo 已提交
2268 2269
		if (!signr)
			break; /* will return 0 */
2270

2271
		if (unlikely(current->ptrace) && signr != SIGKILL) {
2272
			signr = ptrace_signal(signr, info);
T
Tejun Heo 已提交
2273 2274
			if (!signr)
				continue;
L
Linus Torvalds 已提交
2275 2276
		}

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

2279 2280 2281
		/* Trace actually delivered signals. */
		trace_signal_deliver(signr, info, ka);

L
Linus Torvalds 已提交
2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299
		if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
			continue;
		if (ka->sa.sa_handler != SIG_DFL) {
			/* Run the handler.  */
			*return_ka = *ka;

			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;

2300
		/*
2301
		 * Global init gets no signals it doesn't want.
2302 2303 2304 2305 2306 2307 2308
		 * 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.
2309
		 */
2310
		if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2311
				!sig_kernel_only(signr))
L
Linus Torvalds 已提交
2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325
			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) {
2326
				spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2327 2328 2329

				/* signals can be posted during this window */

2330
				if (is_current_pgrp_orphaned())
L
Linus Torvalds 已提交
2331 2332
					goto relock;

2333
				spin_lock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2334 2335
			}

2336
			if (likely(do_signal_stop(info->si_signo))) {
L
Linus Torvalds 已提交
2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347
				/* It released the siglock.  */
				goto relock;
			}

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

2348
		spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2349 2350 2351 2352 2353

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

L
Linus Torvalds 已提交
2355
		if (sig_kernel_coredump(signr)) {
2356
			if (print_fatal_signals)
2357
				print_fatal_signal(info->si_signo);
2358
			proc_coredump_connector(current);
L
Linus Torvalds 已提交
2359 2360 2361 2362 2363 2364 2365 2366
			/*
			 * 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.
			 */
2367
			do_coredump(info);
L
Linus Torvalds 已提交
2368 2369 2370 2371 2372
		}

		/*
		 * Death signals, no core dump.
		 */
2373
		do_group_exit(info->si_signo);
L
Linus Torvalds 已提交
2374 2375
		/* NOTREACHED */
	}
2376
	spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2377 2378 2379
	return signr;
}

2380
/**
A
Al Viro 已提交
2381 2382 2383 2384 2385 2386
 * signal_delivered - 
 * @sig:		number of signal being delivered
 * @info:		siginfo_t of signal being delivered
 * @ka:			sigaction setting that chose the handler
 * @regs:		user register state
 * @stepping:		nonzero if debugger single-step or block-step in use
2387
 *
2388
 * This function should be called when a signal has successfully been
A
Al Viro 已提交
2389 2390 2391
 * delivered. It updates the blocked signals accordingly (@ka->sa.sa_mask
 * is always blocked, and the signal itself is blocked unless %SA_NODEFER
 * is set in @ka->sa.sa_flags.  Tracing is notified.
2392
 */
A
Al Viro 已提交
2393 2394
void signal_delivered(int sig, siginfo_t *info, struct k_sigaction *ka,
			struct pt_regs *regs, int stepping)
2395 2396 2397
{
	sigset_t blocked;

2398 2399 2400 2401 2402 2403
	/* 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();

2404 2405
	sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask);
	if (!(ka->sa.sa_flags & SA_NODEFER))
A
Al Viro 已提交
2406
		sigaddset(&blocked, sig);
2407
	set_current_blocked(&blocked);
A
Al Viro 已提交
2408
	tracehook_signal_handler(sig, info, ka, regs, stepping);
2409 2410
}

A
Al Viro 已提交
2411 2412 2413 2414 2415 2416 2417 2418 2419
void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
{
	if (failed)
		force_sigsegv(ksig->sig, current);
	else
		signal_delivered(ksig->sig, &ksig->info, &ksig->ka,
			signal_pt_regs(), stepping);
}

2420 2421
/*
 * It could be that complete_signal() picked us to notify about the
2422 2423
 * group-wide signal. Other threads should be notified now to take
 * the shared signals in @which since we will not.
2424
 */
2425
static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2426
{
2427
	sigset_t retarget;
2428 2429
	struct task_struct *t;

2430 2431 2432 2433
	sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
	if (sigisemptyset(&retarget))
		return;

2434 2435
	t = tsk;
	while_each_thread(tsk, t) {
2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448
		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;
2449 2450 2451
	}
}

O
Oleg Nesterov 已提交
2452 2453 2454
void exit_signals(struct task_struct *tsk)
{
	int group_stop = 0;
2455
	sigset_t unblocked;
O
Oleg Nesterov 已提交
2456

2457 2458 2459 2460 2461 2462
	/*
	 * @tsk is about to have PF_EXITING set - lock out users which
	 * expect stable threadgroup.
	 */
	threadgroup_change_begin(tsk);

2463 2464
	if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
		tsk->flags |= PF_EXITING;
2465
		threadgroup_change_end(tsk);
2466
		return;
O
Oleg Nesterov 已提交
2467 2468
	}

2469
	spin_lock_irq(&tsk->sighand->siglock);
O
Oleg Nesterov 已提交
2470 2471 2472 2473 2474
	/*
	 * From now this task is not visible for group-wide signals,
	 * see wants_signal(), do_signal_stop().
	 */
	tsk->flags |= PF_EXITING;
2475 2476 2477

	threadgroup_change_end(tsk);

2478 2479 2480
	if (!signal_pending(tsk))
		goto out;

2481 2482 2483
	unblocked = tsk->blocked;
	signotset(&unblocked);
	retarget_shared_pending(tsk, &unblocked);
2484

2485
	if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2486
	    task_participate_group_stop(tsk))
T
Tejun Heo 已提交
2487
		group_stop = CLD_STOPPED;
2488
out:
O
Oleg Nesterov 已提交
2489 2490
	spin_unlock_irq(&tsk->sighand->siglock);

2491 2492 2493 2494
	/*
	 * If group stop has completed, deliver the notification.  This
	 * should always go to the real parent of the group leader.
	 */
2495
	if (unlikely(group_stop)) {
O
Oleg Nesterov 已提交
2496
		read_lock(&tasklist_lock);
2497
		do_notify_parent_cldstop(tsk, false, group_stop);
O
Oleg Nesterov 已提交
2498 2499 2500 2501
		read_unlock(&tasklist_lock);
	}
}

L
Linus Torvalds 已提交
2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516
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);
EXPORT_SYMBOL(block_all_signals);
EXPORT_SYMBOL(unblock_all_signals);


/*
 * System call entry points.
 */

2517 2518 2519
/**
 *  sys_restart_syscall - restart a system call
 */
2520
SYSCALL_DEFINE0(restart_syscall)
L
Linus Torvalds 已提交
2521 2522 2523 2524 2525 2526 2527 2528 2529 2530
{
	struct restart_block *restart = &current_thread_info()->restart_block;
	return restart->fn(restart);
}

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

2531 2532 2533 2534 2535
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. */
2536
		sigandnsets(&newblocked, newset, &current->blocked);
2537 2538 2539 2540 2541 2542
		retarget_shared_pending(tsk, &newblocked);
	}
	tsk->blocked = *newset;
	recalc_sigpending();
}

2543 2544 2545 2546 2547 2548
/**
 * 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 已提交
2549
 */
2550 2551 2552
void set_current_blocked(sigset_t *newset)
{
	sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2553
	__set_current_blocked(newset);
2554 2555 2556
}

void __set_current_blocked(const sigset_t *newset)
2557 2558 2559 2560
{
	struct task_struct *tsk = current;

	spin_lock_irq(&tsk->sighand->siglock);
2561
	__set_task_blocked(tsk, newset);
2562 2563
	spin_unlock_irq(&tsk->sighand->siglock);
}
L
Linus Torvalds 已提交
2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574

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

2578
	/* Lockless, only current can change ->blocked, never from irq */
2579
	if (oldset)
2580
		*oldset = tsk->blocked;
2581

L
Linus Torvalds 已提交
2582 2583
	switch (how) {
	case SIG_BLOCK:
2584
		sigorsets(&newset, &tsk->blocked, set);
L
Linus Torvalds 已提交
2585 2586
		break;
	case SIG_UNBLOCK:
2587
		sigandnsets(&newset, &tsk->blocked, set);
L
Linus Torvalds 已提交
2588 2589
		break;
	case SIG_SETMASK:
2590
		newset = *set;
L
Linus Torvalds 已提交
2591 2592
		break;
	default:
2593
		return -EINVAL;
L
Linus Torvalds 已提交
2594
	}
2595

2596
	__set_current_blocked(&newset);
2597
	return 0;
L
Linus Torvalds 已提交
2598 2599
}

2600 2601 2602
/**
 *  sys_rt_sigprocmask - change the list of currently blocked signals
 *  @how: whether to add, remove, or set signals
R
Randy Dunlap 已提交
2603
 *  @nset: stores pending signals
2604 2605 2606
 *  @oset: previous value of signal mask if non-null
 *  @sigsetsize: size of sigset_t type
 */
2607
SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
2608
		sigset_t __user *, oset, size_t, sigsetsize)
L
Linus Torvalds 已提交
2609 2610
{
	sigset_t old_set, new_set;
2611
	int error;
L
Linus Torvalds 已提交
2612 2613 2614

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

2617 2618 2619 2620 2621
	old_set = current->blocked;

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

2624
		error = sigprocmask(how, &new_set, NULL);
L
Linus Torvalds 已提交
2625
		if (error)
2626 2627
			return error;
	}
L
Linus Torvalds 已提交
2628

2629 2630 2631
	if (oset) {
		if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
			return -EFAULT;
L
Linus Torvalds 已提交
2632
	}
2633 2634

	return 0;
L
Linus Torvalds 已提交
2635 2636
}

A
Al Viro 已提交
2637 2638 2639
#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 已提交
2640
{
A
Al Viro 已提交
2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664
#ifdef __BIG_ENDIAN
	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) {
		compat_sigset_t new32;
		sigset_t new_set;
		int error;
		if (copy_from_user(&new32, nset, sizeof(compat_sigset_t)))
			return -EFAULT;

		sigset_from_compat(&new_set, &new32);
		sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));

		error = sigprocmask(how, &new_set, NULL);
		if (error)
			return error;
	}
	if (oset) {
		compat_sigset_t old32;
		sigset_to_compat(&old32, &old_set);
A
Al Viro 已提交
2665
		if (copy_to_user(oset, &old32, sizeof(compat_sigset_t)))
A
Al Viro 已提交
2666 2667 2668 2669 2670 2671 2672 2673 2674
			return -EFAULT;
	}
	return 0;
#else
	return sys_rt_sigprocmask(how, (sigset_t __user *)nset,
				  (sigset_t __user *)oset, sigsetsize);
#endif
}
#endif
L
Linus Torvalds 已提交
2675

A
Al Viro 已提交
2676
static int do_sigpending(void *set, unsigned long sigsetsize)
L
Linus Torvalds 已提交
2677 2678
{
	if (sigsetsize > sizeof(sigset_t))
A
Al Viro 已提交
2679
		return -EINVAL;
L
Linus Torvalds 已提交
2680 2681

	spin_lock_irq(&current->sighand->siglock);
A
Al Viro 已提交
2682
	sigorsets(set, &current->pending.signal,
L
Linus Torvalds 已提交
2683 2684 2685 2686
		  &current->signal->shared_pending.signal);
	spin_unlock_irq(&current->sighand->siglock);

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

2691 2692 2693
/**
 *  sys_rt_sigpending - examine a pending signal that has been raised
 *			while blocked
2694
 *  @uset: stores pending signals
2695 2696
 *  @sigsetsize: size of sigset_t type or larger
 */
A
Al Viro 已提交
2697
SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
L
Linus Torvalds 已提交
2698
{
A
Al Viro 已提交
2699 2700 2701 2702 2703 2704 2705 2706 2707 2708
	sigset_t set;
	int err = do_sigpending(&set, sigsetsize);
	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 已提交
2709
{
A
Al Viro 已提交
2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723
#ifdef __BIG_ENDIAN
	sigset_t set;
	int err = do_sigpending(&set, sigsetsize);
	if (!err) {
		compat_sigset_t set32;
		sigset_to_compat(&set32, &set);
		/* we can get here only if sigsetsize <= sizeof(set) */
		if (copy_to_user(uset, &set32, sigsetsize))
			err = -EFAULT;
	}
	return err;
#else
	return sys_rt_sigpending((sigset_t __user *)uset, sigsetsize);
#endif
L
Linus Torvalds 已提交
2724
}
A
Al Viro 已提交
2725
#endif
L
Linus Torvalds 已提交
2726 2727 2728

#ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER

A
Al Viro 已提交
2729
int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
L
Linus Torvalds 已提交
2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740
{
	int err;

	if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
		return -EFAULT;
	if (from->si_code < 0)
		return __copy_to_user(to, from, sizeof(siginfo_t))
			? -EFAULT : 0;
	/*
	 * If you change siginfo_t structure, please be sure
	 * this code is fixed accordingly.
2741 2742
	 * Please remember to update the signalfd_copyinfo() function
	 * inside fs/signalfd.c too, in case siginfo_t changes.
L
Linus Torvalds 已提交
2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767
	 * It should never copy any pad contained in the structure
	 * to avoid security leaks, but must copy the generic
	 * 3 ints plus the relevant union member.
	 */
	err = __put_user(from->si_signo, &to->si_signo);
	err |= __put_user(from->si_errno, &to->si_errno);
	err |= __put_user((short)from->si_code, &to->si_code);
	switch (from->si_code & __SI_MASK) {
	case __SI_KILL:
		err |= __put_user(from->si_pid, &to->si_pid);
		err |= __put_user(from->si_uid, &to->si_uid);
		break;
	case __SI_TIMER:
		 err |= __put_user(from->si_tid, &to->si_tid);
		 err |= __put_user(from->si_overrun, &to->si_overrun);
		 err |= __put_user(from->si_ptr, &to->si_ptr);
		break;
	case __SI_POLL:
		err |= __put_user(from->si_band, &to->si_band);
		err |= __put_user(from->si_fd, &to->si_fd);
		break;
	case __SI_FAULT:
		err |= __put_user(from->si_addr, &to->si_addr);
#ifdef __ARCH_SI_TRAPNO
		err |= __put_user(from->si_trapno, &to->si_trapno);
A
Andi Kleen 已提交
2768 2769
#endif
#ifdef BUS_MCEERR_AO
2770
		/*
A
Andi Kleen 已提交
2771
		 * Other callers might not initialize the si_lsb field,
2772
		 * so check explicitly for the right codes here.
A
Andi Kleen 已提交
2773 2774 2775
		 */
		if (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO)
			err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
L
Linus Torvalds 已提交
2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790
#endif
		break;
	case __SI_CHLD:
		err |= __put_user(from->si_pid, &to->si_pid);
		err |= __put_user(from->si_uid, &to->si_uid);
		err |= __put_user(from->si_status, &to->si_status);
		err |= __put_user(from->si_utime, &to->si_utime);
		err |= __put_user(from->si_stime, &to->si_stime);
		break;
	case __SI_RT: /* This is not generated by the kernel as of now. */
	case __SI_MESGQ: /* But this is */
		err |= __put_user(from->si_pid, &to->si_pid);
		err |= __put_user(from->si_uid, &to->si_uid);
		err |= __put_user(from->si_ptr, &to->si_ptr);
		break;
2791 2792 2793 2794 2795 2796 2797
#ifdef __ARCH_SIGSYS
	case __SI_SYS:
		err |= __put_user(from->si_call_addr, &to->si_call_addr);
		err |= __put_user(from->si_syscall, &to->si_syscall);
		err |= __put_user(from->si_arch, &to->si_arch);
		break;
#endif
L
Linus Torvalds 已提交
2798 2799 2800 2801 2802 2803 2804 2805 2806 2807
	default: /* this is just in case for now ... */
		err |= __put_user(from->si_pid, &to->si_pid);
		err |= __put_user(from->si_uid, &to->si_uid);
		break;
	}
	return err;
}

#endif

2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845
/**
 *  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
 */
int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
			const struct timespec *ts)
{
	struct task_struct *tsk = current;
	long timeout = MAX_SCHEDULE_TIMEOUT;
	sigset_t mask = *which;
	int sig;

	if (ts) {
		if (!timespec_valid(ts))
			return -EINVAL;
		timeout = timespec_to_jiffies(ts);
		/*
		 * We can be close to the next tick, add another one
		 * to ensure we will wait at least the time asked for.
		 */
		if (ts->tv_sec || ts->tv_nsec)
			timeout++;
	}

	/*
	 * 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);
	if (!sig && timeout) {
		/*
		 * None ready, temporarily unblock those we're interested
		 * while we are sleeping in so that we'll be awakened when
2846 2847
		 * they arrive. Unblocking is always fine, we can avoid
		 * set_current_blocked().
2848 2849 2850 2851 2852 2853
		 */
		tsk->real_blocked = tsk->blocked;
		sigandsets(&tsk->blocked, &tsk->blocked, &mask);
		recalc_sigpending();
		spin_unlock_irq(&tsk->sighand->siglock);

2854
		timeout = freezable_schedule_timeout_interruptible(timeout);
2855 2856

		spin_lock_irq(&tsk->sighand->siglock);
2857
		__set_task_blocked(tsk, &tsk->real_blocked);
2858
		sigemptyset(&tsk->real_blocked);
2859
		sig = dequeue_signal(tsk, &mask, info);
2860 2861 2862 2863 2864 2865 2866 2867
	}
	spin_unlock_irq(&tsk->sighand->siglock);

	if (sig)
		return sig;
	return timeout ? -EINTR : -EAGAIN;
}

2868 2869 2870 2871 2872 2873 2874 2875
/**
 *  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
 */
2876 2877 2878
SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
		siginfo_t __user *, uinfo, const struct timespec __user *, uts,
		size_t, sigsetsize)
L
Linus Torvalds 已提交
2879 2880 2881 2882
{
	sigset_t these;
	struct timespec ts;
	siginfo_t info;
2883
	int ret;
L
Linus Torvalds 已提交
2884 2885 2886 2887 2888 2889 2890

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

L
Linus Torvalds 已提交
2892 2893 2894 2895 2896
	if (uts) {
		if (copy_from_user(&ts, uts, sizeof(ts)))
			return -EFAULT;
	}

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

2899 2900 2901
	if (ret > 0 && uinfo) {
		if (copy_siginfo_to_user(uinfo, &info))
			ret = -EFAULT;
L
Linus Torvalds 已提交
2902 2903 2904 2905 2906
	}

	return ret;
}

2907 2908 2909 2910 2911
/**
 *  sys_kill - send a signal to a process
 *  @pid: the PID of the process
 *  @sig: signal to be sent
 */
2912
SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
L
Linus Torvalds 已提交
2913 2914 2915 2916 2917 2918
{
	struct siginfo info;

	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_USER;
2919
	info.si_pid = task_tgid_vnr(current);
2920
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
L
Linus Torvalds 已提交
2921 2922 2923 2924

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

T
Thomas Gleixner 已提交
2925 2926
static int
do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
L
Linus Torvalds 已提交
2927 2928
{
	struct task_struct *p;
T
Thomas Gleixner 已提交
2929
	int error = -ESRCH;
L
Linus Torvalds 已提交
2930

2931
	rcu_read_lock();
2932
	p = find_task_by_vpid(pid);
2933
	if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
T
Thomas Gleixner 已提交
2934
		error = check_kill_permission(sig, info, p);
L
Linus Torvalds 已提交
2935 2936 2937 2938
		/*
		 * The null signal is a permissions and process existence
		 * probe.  No signal is actually delivered.
		 */
2939 2940 2941 2942 2943 2944 2945 2946 2947
		if (!error && sig) {
			error = do_send_sig_info(sig, info, p, false);
			/*
			 * If lock_task_sighand() failed we pretend the task
			 * dies after receiving the signal. The window is tiny,
			 * and the signal is private anyway.
			 */
			if (unlikely(error == -ESRCH))
				error = 0;
L
Linus Torvalds 已提交
2948 2949
		}
	}
2950
	rcu_read_unlock();
2951

L
Linus Torvalds 已提交
2952 2953 2954
	return error;
}

T
Thomas Gleixner 已提交
2955 2956
static int do_tkill(pid_t tgid, pid_t pid, int sig)
{
2957
	struct siginfo info = {};
T
Thomas Gleixner 已提交
2958 2959 2960 2961 2962

	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_TKILL;
	info.si_pid = task_tgid_vnr(current);
2963
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
T
Thomas Gleixner 已提交
2964 2965 2966 2967

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

2968 2969 2970 2971 2972 2973
/**
 *  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
 *
2974
 *  This syscall also checks the @tgid and returns -ESRCH even if the PID
2975 2976 2977
 *  exists but it's not belonging to the target process anymore. This
 *  method solves the problem of threads exiting and PIDs getting reused.
 */
2978
SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
2979 2980 2981 2982 2983 2984 2985 2986
{
	/* This is only valid for single tasks */
	if (pid <= 0 || tgid <= 0)
		return -EINVAL;

	return do_tkill(tgid, pid, sig);
}

2987 2988 2989 2990 2991
/**
 *  sys_tkill - send signal to one specific task
 *  @pid: the PID of the task
 *  @sig: signal to be sent
 *
L
Linus Torvalds 已提交
2992 2993
 *  Send a signal to only one task, even if it's a CLONE_THREAD task.
 */
2994
SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
L
Linus Torvalds 已提交
2995 2996 2997 2998 2999
{
	/* This is only valid for single tasks */
	if (pid <= 0)
		return -EINVAL;

3000
	return do_tkill(0, pid, sig);
L
Linus Torvalds 已提交
3001 3002
}

A
Al Viro 已提交
3003 3004 3005 3006 3007
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.
	 */
3008 3009
	if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
	    (task_pid_vnr(current) != pid)) {
A
Al Viro 已提交
3010 3011 3012 3013 3014 3015 3016 3017 3018 3019
		/* We used to allow any < 0 si_code */
		WARN_ON_ONCE(info->si_code < 0);
		return -EPERM;
	}
	info->si_signo = sig;

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

3020 3021 3022 3023 3024 3025
/**
 *  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
 */
3026 3027
SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
		siginfo_t __user *, uinfo)
L
Linus Torvalds 已提交
3028 3029 3030 3031
{
	siginfo_t info;
	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
		return -EFAULT;
A
Al Viro 已提交
3032 3033
	return do_rt_sigqueueinfo(pid, sig, &info);
}
L
Linus Torvalds 已提交
3034

A
Al Viro 已提交
3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
			compat_pid_t, pid,
			int, sig,
			struct compat_siginfo __user *, uinfo)
{
	siginfo_t info;
	int ret = copy_siginfo_from_user32(&info, uinfo);
	if (unlikely(ret))
		return ret;
	return do_rt_sigqueueinfo(pid, sig, &info);
L
Linus Torvalds 已提交
3046
}
A
Al Viro 已提交
3047
#endif
L
Linus Torvalds 已提交
3048

3049
static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
3050 3051 3052 3053 3054 3055
{
	/* 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.
3056 3057
	 * Nor can they impersonate a kill()/tgkill(), which adds source info.
	 */
3058 3059
	if (((info->si_code >= 0 || info->si_code == SI_TKILL)) &&
	    (task_pid_vnr(current) != pid)) {
3060 3061
		/* We used to allow any < 0 si_code */
		WARN_ON_ONCE(info->si_code < 0);
3062
		return -EPERM;
3063
	}
3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079
	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);
}

3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
			compat_pid_t, tgid,
			compat_pid_t, pid,
			int, sig,
			struct compat_siginfo __user *, uinfo)
{
	siginfo_t info;

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

3095
int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
L
Linus Torvalds 已提交
3096
{
3097
	struct task_struct *t = current;
L
Linus Torvalds 已提交
3098
	struct k_sigaction *k;
3099
	sigset_t mask;
L
Linus Torvalds 已提交
3100

3101
	if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
L
Linus Torvalds 已提交
3102 3103
		return -EINVAL;

3104
	k = &t->sighand->action[sig-1];
L
Linus Torvalds 已提交
3105 3106 3107 3108 3109 3110

	spin_lock_irq(&current->sighand->siglock);
	if (oact)
		*oact = *k;

	if (act) {
3111 3112
		sigdelsetmask(&act->sa.sa_mask,
			      sigmask(SIGKILL) | sigmask(SIGSTOP));
3113
		*k = *act;
L
Linus Torvalds 已提交
3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124
		/*
		 * 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"
		 */
3125
		if (sig_handler_ignored(sig_handler(t, sig), sig)) {
3126 3127 3128
			sigemptyset(&mask);
			sigaddset(&mask, sig);
			rm_from_queue_full(&mask, &t->signal->shared_pending);
L
Linus Torvalds 已提交
3129
			do {
3130
				rm_from_queue_full(&mask, &t->pending);
3131
			} while_each_thread(current, t);
L
Linus Torvalds 已提交
3132 3133 3134 3135 3136 3137 3138
		}
	}

	spin_unlock_irq(&current->sighand->siglock);
	return 0;
}

A
Al Viro 已提交
3139
static int 
L
Linus Torvalds 已提交
3140 3141 3142 3143 3144
do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
{
	stack_t oss;
	int error;

3145 3146 3147
	oss.ss_sp = (void __user *) current->sas_ss_sp;
	oss.ss_size = current->sas_ss_size;
	oss.ss_flags = sas_ss_flags(sp);
L
Linus Torvalds 已提交
3148 3149 3150 3151 3152 3153 3154

	if (uss) {
		void __user *ss_sp;
		size_t ss_size;
		int ss_flags;

		error = -EFAULT;
L
Linus Torvalds 已提交
3155 3156 3157 3158 3159 3160
		if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
			goto out;
		error = __get_user(ss_sp, &uss->ss_sp) |
			__get_user(ss_flags, &uss->ss_flags) |
			__get_user(ss_size, &uss->ss_size);
		if (error)
L
Linus Torvalds 已提交
3161 3162 3163 3164 3165 3166 3167 3168
			goto out;

		error = -EPERM;
		if (on_sig_stack(sp))
			goto out;

		error = -EINVAL;
		/*
3169
		 * Note - this code used to test ss_flags incorrectly:
L
Linus Torvalds 已提交
3170 3171 3172
		 *  	  old code may have been written using ss_flags==0
		 *	  to mean ss_flags==SS_ONSTACK (as this was the only
		 *	  way that worked) - this fix preserves that older
3173
		 *	  mechanism.
L
Linus Torvalds 已提交
3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190
		 */
		if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
			goto out;

		if (ss_flags == SS_DISABLE) {
			ss_size = 0;
			ss_sp = NULL;
		} else {
			error = -ENOMEM;
			if (ss_size < MINSIGSTKSZ)
				goto out;
		}

		current->sas_ss_sp = (unsigned long) ss_sp;
		current->sas_ss_size = ss_size;
	}

3191
	error = 0;
L
Linus Torvalds 已提交
3192 3193
	if (uoss) {
		error = -EFAULT;
3194
		if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
L
Linus Torvalds 已提交
3195
			goto out;
3196 3197 3198
		error = __put_user(oss.ss_sp, &uoss->ss_sp) |
			__put_user(oss.ss_size, &uoss->ss_size) |
			__put_user(oss.ss_flags, &uoss->ss_flags);
L
Linus Torvalds 已提交
3199 3200 3201 3202 3203
	}

out:
	return error;
}
3204 3205 3206 3207
SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
{
	return do_sigaltstack(uss, uoss, current_user_stack_pointer());
}
L
Linus Torvalds 已提交
3208

A
Al Viro 已提交
3209 3210 3211 3212 3213 3214 3215
int restore_altstack(const stack_t __user *uss)
{
	int err = do_sigaltstack(uss, NULL, current_user_stack_pointer());
	/* squash all but EFAULT for now */
	return err == -EFAULT ? err : 0;
}

3216 3217 3218 3219 3220 3221 3222 3223
int __save_altstack(stack_t __user *uss, unsigned long sp)
{
	struct task_struct *t = current;
	return  __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
		__put_user(sas_ss_flags(sp), &uss->ss_flags) |
		__put_user(t->sas_ss_size, &uss->ss_size);
}

A
Al Viro 已提交
3224
#ifdef CONFIG_COMPAT
3225 3226 3227
COMPAT_SYSCALL_DEFINE2(sigaltstack,
			const compat_stack_t __user *, uss_ptr,
			compat_stack_t __user *, uoss_ptr)
A
Al Viro 已提交
3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264
{
	stack_t uss, uoss;
	int ret;
	mm_segment_t seg;

	if (uss_ptr) {
		compat_stack_t uss32;

		memset(&uss, 0, sizeof(stack_t));
		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;
	}
	seg = get_fs();
	set_fs(KERNEL_DS);
	ret = do_sigaltstack((stack_t __force __user *) (uss_ptr ? &uss : NULL),
			     (stack_t __force __user *) &uoss,
			     compat_user_stack_pointer());
	set_fs(seg);
	if (ret >= 0 && uoss_ptr)  {
		if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(compat_stack_t)) ||
		    __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
		    __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
		    __put_user(uoss.ss_size, &uoss_ptr->ss_size))
			ret = -EFAULT;
	}
	return ret;
}

int compat_restore_altstack(const compat_stack_t __user *uss)
{
	int err = compat_sys_sigaltstack(uss, NULL);
	/* squash all but -EFAULT for now */
	return err == -EFAULT ? err : 0;
}
3265 3266 3267 3268 3269 3270 3271 3272

int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
{
	struct task_struct *t = current;
	return  __put_user(ptr_to_compat((void __user *)t->sas_ss_sp), &uss->ss_sp) |
		__put_user(sas_ss_flags(sp), &uss->ss_flags) |
		__put_user(t->sas_ss_size, &uss->ss_size);
}
A
Al Viro 已提交
3273
#endif
L
Linus Torvalds 已提交
3274 3275 3276

#ifdef __ARCH_WANT_SYS_SIGPENDING

3277 3278 3279 3280
/**
 *  sys_sigpending - examine pending signals
 *  @set: where mask of pending signal is returned
 */
3281
SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
L
Linus Torvalds 已提交
3282
{
A
Al Viro 已提交
3283
	return sys_rt_sigpending((sigset_t __user *)set, sizeof(old_sigset_t)); 
L
Linus Torvalds 已提交
3284 3285 3286 3287 3288
}

#endif

#ifdef __ARCH_WANT_SYS_SIGPROCMASK
3289 3290 3291
/**
 *  sys_sigprocmask - examine and change blocked signals
 *  @how: whether to add, remove, or set signals
3292
 *  @nset: signals to add or remove (if non-null)
3293 3294
 *  @oset: previous value of signal mask if non-null
 *
3295 3296 3297
 * Some platforms have their own version with special arguments;
 * others support only sys_rt_sigprocmask.
 */
L
Linus Torvalds 已提交
3298

3299
SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
3300
		old_sigset_t __user *, oset)
L
Linus Torvalds 已提交
3301 3302
{
	old_sigset_t old_set, new_set;
3303
	sigset_t new_blocked;
L
Linus Torvalds 已提交
3304

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

3307 3308 3309
	if (nset) {
		if (copy_from_user(&new_set, nset, sizeof(*nset)))
			return -EFAULT;
L
Linus Torvalds 已提交
3310

3311
		new_blocked = current->blocked;
L
Linus Torvalds 已提交
3312 3313 3314

		switch (how) {
		case SIG_BLOCK:
3315
			sigaddsetmask(&new_blocked, new_set);
L
Linus Torvalds 已提交
3316 3317
			break;
		case SIG_UNBLOCK:
3318
			sigdelsetmask(&new_blocked, new_set);
L
Linus Torvalds 已提交
3319 3320
			break;
		case SIG_SETMASK:
3321
			new_blocked.sig[0] = new_set;
L
Linus Torvalds 已提交
3322
			break;
3323 3324
		default:
			return -EINVAL;
L
Linus Torvalds 已提交
3325 3326
		}

3327
		set_current_blocked(&new_blocked);
3328 3329 3330
	}

	if (oset) {
L
Linus Torvalds 已提交
3331
		if (copy_to_user(oset, &old_set, sizeof(*oset)))
3332
			return -EFAULT;
L
Linus Torvalds 已提交
3333
	}
3334 3335

	return 0;
L
Linus Torvalds 已提交
3336 3337 3338
}
#endif /* __ARCH_WANT_SYS_SIGPROCMASK */

3339
#ifndef CONFIG_ODD_RT_SIGACTION
3340 3341 3342
/**
 *  sys_rt_sigaction - alter an action taken by a process
 *  @sig: signal to be sent
3343 3344
 *  @act: new sigaction
 *  @oact: used to save the previous sigaction
3345 3346
 *  @sigsetsize: size of sigset_t type
 */
3347 3348 3349 3350
SYSCALL_DEFINE4(rt_sigaction, int, sig,
		const struct sigaction __user *, act,
		struct sigaction __user *, oact,
		size_t, sigsetsize)
L
Linus Torvalds 已提交
3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372
{
	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 已提交
3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398
#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;
	compat_sigset_t mask;
#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
		ret |= copy_from_user(&mask, &act->sa_mask, sizeof(mask));
3399
		ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
A
Al Viro 已提交
3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410
		if (ret)
			return -EFAULT;
		sigset_from_compat(&new_ka.sa.sa_mask, &mask);
	}

	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
	if (!ret && oact) {
		sigset_to_compat(&mask, &old_ka.sa.sa_mask);
		ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), 
			       &oact->sa_handler);
		ret |= copy_to_user(&oact->sa_mask, &mask, sizeof(mask));
3411
		ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
A
Al Viro 已提交
3412 3413 3414 3415 3416 3417 3418 3419
#ifdef __ARCH_HAS_SA_RESTORER
		ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
				&oact->sa_restorer);
#endif
	}
	return ret;
}
#endif
3420
#endif /* !CONFIG_ODD_RT_SIGACTION */
L
Linus Torvalds 已提交
3421

3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498
#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 已提交
3499

3500
#ifdef CONFIG_SGETMASK_SYSCALL
L
Linus Torvalds 已提交
3501 3502 3503 3504

/*
 * For backwards compatibility.  Functionality superseded by sigprocmask.
 */
3505
SYSCALL_DEFINE0(sgetmask)
L
Linus Torvalds 已提交
3506 3507 3508 3509 3510
{
	/* SMP safe */
	return current->blocked.sig[0];
}

3511
SYSCALL_DEFINE1(ssetmask, int, newmask)
L
Linus Torvalds 已提交
3512
{
3513 3514
	int old = current->blocked.sig[0];
	sigset_t newset;
L
Linus Torvalds 已提交
3515

3516
	siginitset(&newset, newmask);
3517
	set_current_blocked(&newset);
L
Linus Torvalds 已提交
3518 3519 3520

	return old;
}
3521
#endif /* CONFIG_SGETMASK_SYSCALL */
L
Linus Torvalds 已提交
3522 3523 3524 3525 3526

#ifdef __ARCH_WANT_SYS_SIGNAL
/*
 * For backwards compatibility.  Functionality superseded by sigaction.
 */
3527
SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
L
Linus Torvalds 已提交
3528 3529 3530 3531 3532 3533
{
	struct k_sigaction new_sa, old_sa;
	int ret;

	new_sa.sa.sa_handler = handler;
	new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
3534
	sigemptyset(&new_sa.sa.sa_mask);
L
Linus Torvalds 已提交
3535 3536 3537 3538 3539 3540 3541 3542 3543

	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

3544
SYSCALL_DEFINE0(pause)
L
Linus Torvalds 已提交
3545
{
3546 3547 3548 3549
	while (!signal_pending(current)) {
		current->state = TASK_INTERRUPTIBLE;
		schedule();
	}
L
Linus Torvalds 已提交
3550 3551 3552 3553 3554
	return -ERESTARTNOHAND;
}

#endif

A
Al Viro 已提交
3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565
int sigsuspend(sigset_t *set)
{
	current->saved_sigmask = current->blocked;
	set_current_blocked(set);

	current->state = TASK_INTERRUPTIBLE;
	schedule();
	set_restore_sigmask();
	return -ERESTARTNOHAND;
}

3566 3567 3568 3569 3570 3571
/**
 *  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
 */
3572
SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
3573 3574 3575 3576 3577 3578 3579 3580 3581
{
	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 已提交
3582
	return sigsuspend(&newset);
3583
}
A
Al Viro 已提交
3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605
 
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
{
#ifdef __BIG_ENDIAN
	sigset_t newset;
	compat_sigset_t newset32;

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

	if (copy_from_user(&newset32, unewset, sizeof(compat_sigset_t)))
		return -EFAULT;
	sigset_from_compat(&newset, &newset32);
	return sigsuspend(&newset);
#else
	/* on little-endian bitmaps don't care about granularity */
	return sys_rt_sigsuspend((sigset_t __user *)unewset, sigsetsize);
#endif
}
#endif
3606

3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622
#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
3623

3624
__weak const char *arch_vma_name(struct vm_area_struct *vma)
3625 3626 3627 3628
{
	return NULL;
}

L
Linus Torvalds 已提交
3629 3630
void __init signals_init(void)
{
3631
	sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
L
Linus Torvalds 已提交
3632
}
3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672

#ifdef CONFIG_KGDB_KDB
#include <linux/kdb.h>
/*
 * kdb_send_sig_info - Allows kdb to send signals without exposing
 * signal internals.  This function checks if the required locks are
 * available before calling the main signal code, to avoid kdb
 * deadlocks.
 */
void
kdb_send_sig_info(struct task_struct *t, struct siginfo *info)
{
	static struct task_struct *kdb_prev_t;
	int sig, new_t;
	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;
	}
	spin_unlock(&t->sighand->siglock);
	new_t = kdb_prev_t != t;
	kdb_prev_t = t;
	if (t->state != TASK_RUNNING && new_t) {
		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;
	}
	sig = info->si_signo;
	if (send_sig_info(sig, info, t))
		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 */