signal.c 94.2 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
 * 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.
 */
248
bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
{
	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 long 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
{
	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);
	}
}

/*
417
 * Flush all pending signals for this kthread.
L
Linus Torvalds 已提交
418
 */
419
void flush_signals(struct task_struct *t)
L
Linus Torvalds 已提交
420 421 422 423
{
	unsigned long flags;

	spin_lock_irqsave(&t->sighand->siglock, flags);
424 425 426
	clear_tsk_thread_flag(t, TIF_SIGPENDING);
	flush_sigqueue(&t->pending);
	flush_sigqueue(&t->signal->shared_pending);
L
Linus Torvalds 已提交
427 428 429
	spin_unlock_irqrestore(&t->sighand->siglock, flags);
}

430 431 432 433 434 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
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);
}

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

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

506
static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
L
Linus Torvalds 已提交
507 508 509 510 511 512 513 514 515
{
	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) {
516 517
			if (first)
				goto still_pending;
L
Linus Torvalds 已提交
518 519 520
			first = q;
		}
	}
521 522 523

	sigdelset(&list->signal, sig);

L
Linus Torvalds 已提交
524
	if (first) {
525
still_pending:
L
Linus Torvalds 已提交
526 527 528 529
		list_del_init(&first->list);
		copy_siginfo(info, &first->info);
		__sigqueue_free(first);
	} else {
530 531 532 533
		/*
		 * 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 已提交
534 535 536
		 */
		info->si_signo = sig;
		info->si_errno = 0;
537
		info->si_code = SI_USER;
L
Linus Torvalds 已提交
538 539 540 541 542 543 544 545
		info->si_pid = 0;
		info->si_uid = 0;
	}
}

static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
			siginfo_t *info)
{
546
	int sig = next_signal(pending, mask);
L
Linus Torvalds 已提交
547

548
	if (sig)
549
		collect_signal(sig, pending, info);
L
Linus Torvalds 已提交
550 551 552 553
	return sig;
}

/*
554
 * Dequeue a signal and return the element to the caller, which is
L
Linus Torvalds 已提交
555 556 557 558 559 560
 * expected to free it.
 *
 * All callers have to hold the siglock.
 */
int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
{
561
	int signr;
562 563 564 565

	/* We only dequeue private signals from ourselves, we don't let
	 * signalfd steal them
	 */
D
Davide Libenzi 已提交
566
	signr = __dequeue_signal(&tsk->pending, mask, info);
567
	if (!signr) {
L
Linus Torvalds 已提交
568 569
		signr = __dequeue_signal(&tsk->signal->shared_pending,
					 mask, info);
570 571 572 573 574 575
		/*
		 * 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
576
		 * compliant with the old way of self-restarting
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
		 * 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);
			}
		}
	}
594

D
Davide Libenzi 已提交
595
	recalc_sigpending();
596 597 598 599
	if (!signr)
		return 0;

	if (unlikely(sig_kernel_stop(signr))) {
600 601 602 603 604 605 606 607 608 609 610 611
		/*
		 * 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.
		 */
612
		current->jobctl |= JOBCTL_STOP_DEQUEUED;
613
	}
614
	if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
L
Linus Torvalds 已提交
615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
		/*
		 * 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
 */
639
void signal_wake_up_state(struct task_struct *t, unsigned int state)
L
Linus Torvalds 已提交
640 641 642
{
	set_tsk_thread_flag(t, TIF_SIGPENDING);
	/*
643
	 * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
M
Matthew Wilcox 已提交
644
	 * case. We don't check t->state here because there is a race with it
L
Linus Torvalds 已提交
645 646 647 648
	 * 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.
	 */
649
	if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
L
Linus Torvalds 已提交
650 651 652
		kick_process(t);
}

653 654 655 656 657 658
/*
 * Remove signals in mask from the pending set and queue.
 * Returns 1 if any signals were found.
 *
 * All callers must be holding the siglock.
 */
659
static int flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
660 661 662 663 664 665 666 667
{
	struct sigqueue *q, *n;
	sigset_t m;

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

668
	sigandnsets(&s->signal, &s->signal, mask);
669 670 671 672 673 674 675 676
	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 已提交
677

678 679 680 681 682 683 684 685 686 687 688
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));
}

689 690 691 692 693 694 695 696
/*
 * 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);

697 698 699 700
	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))
701 702
		return 1;

703
	if (ns_capable(tcred->user_ns, CAP_KILL))
704 705 706 707 708
		return 1;

	return 0;
}

L
Linus Torvalds 已提交
709 710
/*
 * Bad permissions for sending the signal
711
 * - the caller must hold the RCU read lock
L
Linus Torvalds 已提交
712 713 714 715
 */
static int check_kill_permission(int sig, struct siginfo *info,
				 struct task_struct *t)
{
716
	struct pid *sid;
717 718
	int error;

719
	if (!valid_signal(sig))
720 721
		return -EINVAL;

722
	if (!si_fromuser(info))
723
		return 0;
A
Amy Griffis 已提交
724

725 726
	error = audit_signal_info(sig, t); /* Let audit system see the signal */
	if (error)
L
Linus Torvalds 已提交
727
		return error;
728

729
	if (!same_thread_group(current, t) &&
730
	    !kill_ok_by_cred(t)) {
731 732 733 734 735 736 737 738 739 740 741 742 743
		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;
		}
	}
744

A
Amy Griffis 已提交
745
	return security_task_kill(t, info, sig, 0);
L
Linus Torvalds 已提交
746 747
}

748 749 750 751 752 753 754 755
/**
 * 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 已提交
756 757 758 759 760
 * 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.
761 762 763 764 765 766 767 768 769 770
 *
 * 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);
771
	ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
772 773
}

L
Linus Torvalds 已提交
774
/*
775 776
 * Handle magic process-wide effects of stop/continue signals. Unlike
 * the signal actions, these happen immediately at signal-generation
L
Linus Torvalds 已提交
777 778
 * time regardless of blocking, ignoring, or handling.  This does the
 * actual continuing for SIGCONT, but not the actual stopping for stop
779 780 781 782
 * 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 已提交
783
 */
784
static bool prepare_signal(int sig, struct task_struct *p, bool force)
L
Linus Torvalds 已提交
785
{
786
	struct signal_struct *signal = p->signal;
L
Linus Torvalds 已提交
787
	struct task_struct *t;
788
	sigset_t flush;
L
Linus Torvalds 已提交
789

790
	if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
791
		if (!(signal->flags & SIGNAL_GROUP_EXIT))
792
			return sig == SIGKILL;
L
Linus Torvalds 已提交
793
		/*
794
		 * The process is in the middle of dying, nothing to do.
L
Linus Torvalds 已提交
795
		 */
796
	} else if (sig_kernel_stop(sig)) {
L
Linus Torvalds 已提交
797 798 799
		/*
		 * This is a stop signal.  Remove SIGCONT from all queues.
		 */
800
		siginitset(&flush, sigmask(SIGCONT));
801
		flush_sigqueue_mask(&flush, &signal->shared_pending);
802
		for_each_thread(p, t)
803
			flush_sigqueue_mask(&flush, &t->pending);
L
Linus Torvalds 已提交
804
	} else if (sig == SIGCONT) {
805
		unsigned int why;
L
Linus Torvalds 已提交
806
		/*
807
		 * Remove all stop signals from all queues, wake all threads.
L
Linus Torvalds 已提交
808
		 */
809
		siginitset(&flush, SIG_KERNEL_STOP_MASK);
810
		flush_sigqueue_mask(&flush, &signal->shared_pending);
811
		for_each_thread(p, t) {
812
			flush_sigqueue_mask(&flush, &t->pending);
813
			task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
814 815 816 817
			if (likely(!(t->ptrace & PT_SEIZED)))
				wake_up_state(t, __TASK_STOPPED);
			else
				ptrace_trap_notify(t);
818
		}
L
Linus Torvalds 已提交
819

820 821 822 823 824 825 826 827 828
		/*
		 * 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;
829
		if (signal->flags & SIGNAL_STOP_STOPPED)
830
			why |= SIGNAL_CLD_CONTINUED;
831
		else if (signal->group_stop_count)
832 833 834
			why |= SIGNAL_CLD_STOPPED;

		if (why) {
835
			/*
836
			 * The first thread which returns from do_signal_stop()
837 838 839
			 * will take ->siglock, notice SIGNAL_CLD_MASK, and
			 * notify its parent. See get_signal_to_deliver().
			 */
840 841 842
			signal->flags = why | SIGNAL_STOP_CONTINUED;
			signal->group_stop_count = 0;
			signal->group_exit_code = 0;
L
Linus Torvalds 已提交
843 844
		}
	}
845

846
	return !sig_ignored(p, sig, force);
L
Linus Torvalds 已提交
847 848
}

849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869
/*
 * 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);
}

870
static void complete_signal(int sig, struct task_struct *p, int group)
871 872 873 874 875 876 877 878 879 880 881 882
{
	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;
883
	else if (!group || thread_group_empty(p))
884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910
		/*
		 * 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.
	 */
911 912
	if (sig_fatal(p, sig) &&
	    !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
913
	    !sigismember(&t->real_blocked, sig) &&
T
Tejun Heo 已提交
914
	    (sig == SIGKILL || !t->ptrace)) {
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
		/*
		 * 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 {
930
				task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
				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;
}

946 947 948 949 950
static inline int legacy_queue(struct sigpending *signals, int sig)
{
	return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
}

951 952 953 954 955 956 957 958 959
#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;

960 961 962 963
	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();
964 965 966 967 968 969 970 971
}
#else
static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
{
	return;
}
#endif

972 973
static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
			int group, int from_ancestor_ns)
L
Linus Torvalds 已提交
974
{
975
	struct sigpending *pending;
976
	struct sigqueue *q;
977
	int override_rlimit;
978
	int ret = 0, result;
979

980
	assert_spin_locked(&t->sighand->siglock);
981

982
	result = TRACE_SIGNAL_IGNORED;
983 984
	if (!prepare_signal(sig, t,
			from_ancestor_ns || (info == SEND_SIG_FORCED)))
985
		goto ret;
986 987

	pending = group ? &t->signal->shared_pending : &t->pending;
988 989 990 991 992
	/*
	 * 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.
	 */
993
	result = TRACE_SIGNAL_ALREADY_PENDING;
994
	if (legacy_queue(pending, sig))
995 996 997
		goto ret;

	result = TRACE_SIGNAL_DELIVERED;
L
Linus Torvalds 已提交
998 999 1000 1001
	/*
	 * fast-pathed signals for kernel-internal things like SIGSTOP
	 * or SIGKILL.
	 */
1002
	if (info == SEND_SIG_FORCED)
L
Linus Torvalds 已提交
1003 1004
		goto out_set;

1005 1006 1007 1008 1009 1010 1011 1012 1013
	/*
	 * 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.
	 */
1014 1015 1016 1017 1018
	if (sig < SIGRTMIN)
		override_rlimit = (is_si_special(info) || info->si_code >= 0);
	else
		override_rlimit = 0;

1019
	q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
1020
		override_rlimit);
L
Linus Torvalds 已提交
1021
	if (q) {
1022
		list_add_tail(&q->list, &pending->list);
L
Linus Torvalds 已提交
1023
		switch ((unsigned long) info) {
1024
		case (unsigned long) SEND_SIG_NOINFO:
L
Linus Torvalds 已提交
1025 1026 1027
			q->info.si_signo = sig;
			q->info.si_errno = 0;
			q->info.si_code = SI_USER;
1028
			q->info.si_pid = task_tgid_nr_ns(current,
1029
							task_active_pid_ns(t));
1030
			q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
L
Linus Torvalds 已提交
1031
			break;
1032
		case (unsigned long) SEND_SIG_PRIV:
L
Linus Torvalds 已提交
1033 1034 1035 1036 1037 1038 1039 1040
			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);
1041 1042
			if (from_ancestor_ns)
				q->info.si_pid = 0;
L
Linus Torvalds 已提交
1043 1044
			break;
		}
1045 1046 1047

		userns_fixup_signal_uid(&q->info, t);

1048
	} else if (!is_si_special(info)) {
1049 1050 1051 1052 1053 1054
		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().
			 */
1055 1056 1057
			result = TRACE_SIGNAL_OVERFLOW_FAIL;
			ret = -EAGAIN;
			goto ret;
1058 1059 1060 1061 1062
		} else {
			/*
			 * This is a silent loss of information.  We still
			 * send the signal, but the *info bits are lost.
			 */
1063
			result = TRACE_SIGNAL_LOSE_INFO;
1064
		}
L
Linus Torvalds 已提交
1065 1066 1067
	}

out_set:
1068
	signalfd_notify(t, sig);
1069
	sigaddset(&pending->signal, sig);
1070
	complete_signal(sig, t, group);
1071 1072 1073
ret:
	trace_signal_generate(sig, info, t, group, result);
	return ret;
L
Linus Torvalds 已提交
1074 1075
}

1076 1077 1078
static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
			int group)
{
1079 1080 1081
	int from_ancestor_ns = 0;

#ifdef CONFIG_PID_NS
1082 1083
	from_ancestor_ns = si_fromuser(info) &&
			   !task_pid_nr_ns(current, task_active_pid_ns(t));
1084 1085 1086
#endif

	return __send_signal(sig, info, t, group, from_ancestor_ns);
1087 1088
}

1089
static void print_fatal_signal(int signr)
I
Ingo Molnar 已提交
1090
{
1091
	struct pt_regs *regs = signal_pt_regs();
1092
	printk(KERN_INFO "potentially unexpected fatal signal %d.\n", signr);
I
Ingo Molnar 已提交
1093

A
Al Viro 已提交
1094
#if defined(__i386__) && !defined(__arch_um__)
1095
	printk(KERN_INFO "code at %08lx: ", regs->ip);
I
Ingo Molnar 已提交
1096 1097 1098 1099 1100
	{
		int i;
		for (i = 0; i < 16; i++) {
			unsigned char insn;

1101 1102
			if (get_user(insn, (unsigned char *)(regs->ip + i)))
				break;
1103
			printk(KERN_CONT "%02x ", insn);
I
Ingo Molnar 已提交
1104 1105
		}
	}
1106
	printk(KERN_CONT "\n");
I
Ingo Molnar 已提交
1107
#endif
1108
	preempt_disable();
I
Ingo Molnar 已提交
1109
	show_regs(regs);
1110
	preempt_enable();
I
Ingo Molnar 已提交
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
}

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

1122 1123 1124 1125 1126 1127
int
__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
	return send_signal(sig, info, p, 1);
}

L
Linus Torvalds 已提交
1128 1129 1130
static int
specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
1131
	return send_signal(sig, info, t, 0);
L
Linus Torvalds 已提交
1132 1133
}

1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
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 已提交
1148 1149 1150
/*
 * Force a signal that the process can't ignore: if necessary
 * we unblock the signal and change any SIG_IGN to SIG_DFL.
1151 1152 1153 1154 1155
 *
 * 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.
 *
1156 1157
 * We don't want to have recursive SIGSEGV's etc, for example,
 * that is why we also clear SIGNAL_UNKILLABLE.
L
Linus Torvalds 已提交
1158 1159 1160 1161 1162
 */
int
force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
	unsigned long int flags;
1163 1164
	int ret, blocked, ignored;
	struct k_sigaction *action;
L
Linus Torvalds 已提交
1165 1166

	spin_lock_irqsave(&t->sighand->siglock, flags);
1167 1168 1169 1170 1171 1172 1173
	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 已提交
1174
			recalc_sigpending_and_wake(t);
1175
		}
L
Linus Torvalds 已提交
1176
	}
1177 1178
	if (action->sa.sa_handler == SIG_DFL)
		t->signal->flags &= ~SIGNAL_UNKILLABLE;
L
Linus Torvalds 已提交
1179 1180 1181 1182 1183 1184 1185 1186 1187
	ret = specific_send_sig_info(sig, info, t);
	spin_unlock_irqrestore(&t->sighand->siglock, flags);

	return ret;
}

/*
 * Nuke all other threads in the group.
 */
1188
int zap_other_threads(struct task_struct *p)
L
Linus Torvalds 已提交
1189
{
1190 1191
	struct task_struct *t = p;
	int count = 0;
L
Linus Torvalds 已提交
1192 1193 1194

	p->signal->group_stop_count = 0;

1195
	while_each_thread(p, t) {
1196
		task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1197 1198 1199
		count++;

		/* Don't bother with already dead threads */
L
Linus Torvalds 已提交
1200 1201 1202 1203 1204
		if (t->exit_state)
			continue;
		sigaddset(&t->pending.signal, SIGKILL);
		signal_wake_up(t, 1);
	}
1205 1206

	return count;
L
Linus Torvalds 已提交
1207 1208
}

1209 1210
struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
					   unsigned long *flags)
1211 1212 1213 1214
{
	struct sighand_struct *sighand;

	for (;;) {
1215 1216 1217 1218
		/*
		 * Disable interrupts early to avoid deadlocks.
		 * See rcu_read_unlock() comment header for details.
		 */
1219 1220
		local_irq_save(*flags);
		rcu_read_lock();
1221
		sighand = rcu_dereference(tsk->sighand);
1222 1223 1224
		if (unlikely(sighand == NULL)) {
			rcu_read_unlock();
			local_irq_restore(*flags);
1225
			break;
1226
		}
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
		/*
		 * This sighand can be already freed and even reused, but
		 * we rely on SLAB_DESTROY_BY_RCU and sighand_ctor() which
		 * initializes ->siglock: this slab can't go away, it has
		 * the same object type, ->siglock can't be reinitialized.
		 *
		 * We need to ensure that tsk->sighand is still the same
		 * after we take the lock, we can race with de_thread() or
		 * __exit_signal(). In the latter case the next iteration
		 * must see ->sighand == NULL.
		 */
1238 1239 1240
		spin_lock(&sighand->siglock);
		if (likely(sighand == tsk->sighand)) {
			rcu_read_unlock();
1241
			break;
1242 1243 1244 1245
		}
		spin_unlock(&sighand->siglock);
		rcu_read_unlock();
		local_irq_restore(*flags);
1246 1247 1248 1249 1250
	}

	return sighand;
}

1251 1252 1253
/*
 * send signal info to all the members of a group
 */
L
Linus Torvalds 已提交
1254 1255
int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
1256 1257 1258 1259 1260
	int ret;

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

1262 1263
	if (!ret && sig)
		ret = do_send_sig_info(sig, info, p, true);
L
Linus Torvalds 已提交
1264 1265 1266 1267 1268

	return ret;
}

/*
1269
 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
L
Linus Torvalds 已提交
1270
 * control characters do (^C, ^Z etc)
1271
 * - the caller must hold at least a readlock on tasklist_lock
L
Linus Torvalds 已提交
1272
 */
1273
int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
L
Linus Torvalds 已提交
1274 1275 1276 1277 1278 1279
{
	struct task_struct *p = NULL;
	int retval, success;

	success = 0;
	retval = -ESRCH;
1280
	do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
L
Linus Torvalds 已提交
1281 1282 1283
		int err = group_send_sig_info(sig, info, p);
		success |= !err;
		retval = err;
1284
	} while_each_pid_task(pgrp, PIDTYPE_PGID, p);
L
Linus Torvalds 已提交
1285 1286 1287
	return success ? 0 : retval;
}

1288
int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
L
Linus Torvalds 已提交
1289
{
1290
	int error = -ESRCH;
L
Linus Torvalds 已提交
1291 1292
	struct task_struct *p;

1293 1294 1295 1296 1297 1298 1299 1300
	for (;;) {
		rcu_read_lock();
		p = pid_task(pid, PIDTYPE_PID);
		if (p)
			error = group_send_sig_info(sig, info, p);
		rcu_read_unlock();
		if (likely(!p || error != -ESRCH))
			return error;
1301

1302 1303 1304 1305 1306 1307
		/*
		 * The task was unhashed in between, try again.  If it
		 * is dead, pid_task() will return NULL, if we race with
		 * de_thread() it will find the new leader.
		 */
	}
L
Linus Torvalds 已提交
1308 1309
}

1310
int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1311 1312 1313
{
	int error;
	rcu_read_lock();
1314
	error = kill_pid_info(sig, info, find_vpid(pid));
1315 1316 1317 1318
	rcu_read_unlock();
	return error;
}

1319 1320 1321 1322
static int kill_as_cred_perm(const struct cred *cred,
			     struct task_struct *target)
{
	const struct cred *pcred = __task_cred(target);
1323 1324
	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))
1325 1326 1327 1328
		return 0;
	return 1;
}

1329
/* like kill_pid_info(), but doesn't use uid/euid of "current" */
1330 1331
int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid,
			 const struct cred *cred, u32 secid)
1332 1333 1334
{
	int ret = -EINVAL;
	struct task_struct *p;
1335
	unsigned long flags;
1336 1337 1338 1339

	if (!valid_signal(sig))
		return ret;

1340
	rcu_read_lock();
1341
	p = pid_task(pid, PIDTYPE_PID);
1342 1343 1344 1345
	if (!p) {
		ret = -ESRCH;
		goto out_unlock;
	}
1346
	if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
1347 1348 1349
		ret = -EPERM;
		goto out_unlock;
	}
1350 1351 1352
	ret = security_task_kill(p, info, sig, secid);
	if (ret)
		goto out_unlock;
1353 1354 1355 1356 1357 1358 1359

	if (sig) {
		if (lock_task_sighand(p, &flags)) {
			ret = __send_signal(sig, info, p, 1, 0);
			unlock_task_sighand(p, &flags);
		} else
			ret = -ESRCH;
1360 1361
	}
out_unlock:
1362
	rcu_read_unlock();
1363 1364
	return ret;
}
1365
EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
L
Linus Torvalds 已提交
1366 1367 1368 1369 1370 1371 1372 1373

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

1374
static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
L
Linus Torvalds 已提交
1375
{
1376
	int ret;
1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389

	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 已提交
1390 1391 1392 1393
		int retval = 0, count = 0;
		struct task_struct * p;

		for_each_process(p) {
1394 1395
			if (task_pid_vnr(p) > 1 &&
					!same_thread_group(p, current)) {
L
Linus Torvalds 已提交
1396 1397 1398 1399 1400 1401
				int err = group_send_sig_info(sig, info, p);
				++count;
				if (err != -EPERM)
					retval = err;
			}
		}
1402
		ret = count ? retval : -ESRCH;
L
Linus Torvalds 已提交
1403
	}
1404 1405
	read_unlock(&tasklist_lock);

1406
	return ret;
L
Linus Torvalds 已提交
1407 1408 1409 1410 1411 1412
}

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

1413
int send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
L
Linus Torvalds 已提交
1414 1415 1416 1417 1418
{
	/*
	 * Make sure legacy kernel users don't send in bad values
	 * (normal paths check this in check_kill_permission).
	 */
1419
	if (!valid_signal(sig))
L
Linus Torvalds 已提交
1420 1421
		return -EINVAL;

1422
	return do_send_sig_info(sig, info, p, false);
L
Linus Torvalds 已提交
1423 1424
}

1425 1426 1427
#define __si_special(priv) \
	((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)

L
Linus Torvalds 已提交
1428 1429 1430
int
send_sig(int sig, struct task_struct *p, int priv)
{
1431
	return send_sig_info(sig, __si_special(priv), p);
L
Linus Torvalds 已提交
1432 1433 1434 1435 1436
}

void
force_sig(int sig, struct task_struct *p)
{
1437
	force_sig_info(sig, SEND_SIG_PRIV, p);
L
Linus Torvalds 已提交
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458
}

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

1459 1460
int kill_pgrp(struct pid *pid, int sig, int priv)
{
1461 1462 1463 1464 1465 1466 1467
	int ret;

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

	return ret;
1468 1469 1470 1471 1472 1473 1474 1475 1476
}
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 已提交
1477 1478 1479 1480
/*
 * 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
1481
 * expirations or I/O completions".  In the case of POSIX Timers
L
Linus Torvalds 已提交
1482 1483 1484 1485 1486 1487
 * 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)
{
1488
	struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
L
Linus Torvalds 已提交
1489

1490
	if (q)
L
Linus Torvalds 已提交
1491
		q->flags |= SIGQUEUE_PREALLOC;
1492 1493

	return q;
L
Linus Torvalds 已提交
1494 1495 1496 1497 1498
}

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

L
Linus Torvalds 已提交
1501 1502
	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
	/*
1503 1504
	 * We must hold ->siglock while testing q->list
	 * to serialize with collect_signal() or with
1505
	 * __exit_signal()->flush_sigqueue().
L
Linus Torvalds 已提交
1506
	 */
1507
	spin_lock_irqsave(lock, flags);
1508 1509 1510 1511 1512
	q->flags &= ~SIGQUEUE_PREALLOC;
	/*
	 * If it is queued it will be freed when dequeued,
	 * like the "regular" sigqueue.
	 */
1513
	if (!list_empty(&q->list))
1514
		q = NULL;
1515 1516
	spin_unlock_irqrestore(lock, flags);

1517 1518
	if (q)
		__sigqueue_free(q);
L
Linus Torvalds 已提交
1519 1520
}

1521
int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1522
{
1523
	int sig = q->info.si_signo;
1524
	struct sigpending *pending;
1525
	unsigned long flags;
1526
	int ret, result;
1527

1528
	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1529 1530 1531 1532 1533

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

1534
	ret = 1; /* the signal is ignored */
1535
	result = TRACE_SIGNAL_IGNORED;
1536
	if (!prepare_signal(sig, t, false))
1537 1538 1539
		goto out;

	ret = 0;
1540 1541 1542 1543 1544 1545 1546
	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++;
1547
		result = TRACE_SIGNAL_ALREADY_PENDING;
1548
		goto out;
1549
	}
1550
	q->info.si_overrun = 0;
1551 1552

	signalfd_notify(t, sig);
1553
	pending = group ? &t->signal->shared_pending : &t->pending;
1554 1555
	list_add_tail(&q->list, &pending->list);
	sigaddset(&pending->signal, sig);
1556
	complete_signal(sig, t, group);
1557
	result = TRACE_SIGNAL_DELIVERED;
1558
out:
1559
	trace_signal_generate(sig, &q->info, t, group, result);
1560 1561 1562
	unlock_task_sighand(t, &flags);
ret:
	return ret;
1563 1564
}

L
Linus Torvalds 已提交
1565 1566 1567
/*
 * 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 已提交
1568
 *
1569 1570
 * Returns true if our parent ignored us and so we've switched to
 * self-reaping.
L
Linus Torvalds 已提交
1571
 */
1572
bool do_notify_parent(struct task_struct *tsk, int sig)
L
Linus Torvalds 已提交
1573 1574 1575 1576
{
	struct siginfo info;
	unsigned long flags;
	struct sighand_struct *psig;
1577
	bool autoreap = false;
1578
	cputime_t utime, stime;
L
Linus Torvalds 已提交
1579 1580 1581 1582

	BUG_ON(sig == -1);

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

T
Tejun Heo 已提交
1585
	BUG_ON(!tsk->ptrace &&
L
Linus Torvalds 已提交
1586 1587
	       (tsk->group_leader != tsk || !thread_group_empty(tsk)));

1588 1589 1590 1591 1592 1593 1594 1595 1596
	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 已提交
1597 1598
	info.si_signo = sig;
	info.si_errno = 0;
1599
	/*
1600 1601
	 * We are under tasklist_lock here so our parent is tied to
	 * us and cannot change.
1602
	 *
1603 1604
	 * task_active_pid_ns will always return the same pid namespace
	 * until a task passes through release_task.
1605 1606 1607 1608 1609 1610
	 *
	 * 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();
1611
	info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1612 1613
	info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
				       task_uid(tsk));
1614 1615
	rcu_read_unlock();

1616 1617 1618
	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 已提交
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631

	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 已提交
1632
	if (!tsk->ptrace && sig == SIGCHLD &&
L
Linus Torvalds 已提交
1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649
	    (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).
		 */
1650
		autoreap = true;
L
Linus Torvalds 已提交
1651
		if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1652
			sig = 0;
L
Linus Torvalds 已提交
1653
	}
1654
	if (valid_signal(sig) && sig)
L
Linus Torvalds 已提交
1655 1656 1657
		__group_send_sig_info(sig, &info, tsk->parent);
	__wake_up_parent(tsk, tsk->parent);
	spin_unlock_irqrestore(&psig->siglock, flags);
R
Roland McGrath 已提交
1658

1659
	return autoreap;
L
Linus Torvalds 已提交
1660 1661
}

1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676
/**
 * 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 已提交
1677 1678 1679
{
	struct siginfo info;
	unsigned long flags;
1680
	struct task_struct *parent;
L
Linus Torvalds 已提交
1681
	struct sighand_struct *sighand;
1682
	cputime_t utime, stime;
L
Linus Torvalds 已提交
1683

1684
	if (for_ptracer) {
1685
		parent = tsk->parent;
1686
	} else {
1687 1688 1689 1690
		tsk = tsk->group_leader;
		parent = tsk->real_parent;
	}

L
Linus Torvalds 已提交
1691 1692
	info.si_signo = SIGCHLD;
	info.si_errno = 0;
1693
	/*
1694
	 * see comment in do_notify_parent() about the following 4 lines
1695 1696
	 */
	rcu_read_lock();
1697
	info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
1698
	info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
1699 1700
	rcu_read_unlock();

1701 1702 1703
	task_cputime(tsk, &utime, &stime);
	info.si_utime = cputime_to_clock_t(utime);
	info.si_stime = cputime_to_clock_t(stime);
L
Linus Torvalds 已提交
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731

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

1732 1733
static inline int may_ptrace_stop(void)
{
T
Tejun Heo 已提交
1734
	if (!likely(current->ptrace))
1735 1736 1737 1738 1739 1740 1741
		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
1742
	 * ->siglock we must see ->core_state != NULL. Otherwise it
1743
	 * is safe to enter schedule().
1744 1745 1746 1747
	 *
	 * 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.
1748
	 */
1749
	if (unlikely(current->mm->core_state) &&
1750 1751 1752 1753 1754 1755
	    unlikely(current->mm == current->parent->mm))
		return 0;

	return 1;
}

R
Roland McGrath 已提交
1756
/*
1757
 * Return non-zero if there is a SIGKILL that should be waking us up.
R
Roland McGrath 已提交
1758 1759 1760 1761
 * Called with the siglock held.
 */
static int sigkill_pending(struct task_struct *tsk)
{
1762 1763
	return	sigismember(&tsk->pending.signal, SIGKILL) ||
		sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
R
Roland McGrath 已提交
1764 1765
}

L
Linus Torvalds 已提交
1766 1767 1768 1769 1770 1771 1772 1773
/*
 * 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.
 *
1774 1775
 * 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 已提交
1776
 */
T
Tejun Heo 已提交
1777
static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
1778 1779
	__releases(&current->sighand->siglock)
	__acquires(&current->sighand->siglock)
L
Linus Torvalds 已提交
1780
{
1781 1782
	bool gstop_done = false;

R
Roland McGrath 已提交
1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797
	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);
1798 1799
		if (sigkill_pending(current))
			return;
R
Roland McGrath 已提交
1800 1801
	}

L
Linus Torvalds 已提交
1802
	/*
1803 1804 1805 1806 1807
	 * 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 已提交
1808
	 */
1809
	set_current_state(TASK_TRACED);
L
Linus Torvalds 已提交
1810 1811 1812 1813

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

1814
	/*
1815 1816
	 * If @why is CLD_STOPPED, we're trapping to participate in a group
	 * stop.  Do the bookkeeping.  Note that if SIGCONT was delievered
1817 1818 1819
	 * 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.
1820
	 */
1821
	if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
1822
		gstop_done = task_participate_group_stop(current);
1823

1824
	/* any trap clears pending STOP trap, STOP trap clears NOTIFY */
1825
	task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
1826 1827
	if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
		task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
1828

1829
	/* entering a trap, clear TRAPPING */
1830
	task_clear_jobctl_trapping(current);
1831

L
Linus Torvalds 已提交
1832 1833
	spin_unlock_irq(&current->sighand->siglock);
	read_lock(&tasklist_lock);
1834
	if (may_ptrace_stop()) {
1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845
		/*
		 * 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);
1846
		if (gstop_done && ptrace_reparented(current))
1847 1848
			do_notify_parent_cldstop(current, false, why);

M
Miklos Szeredi 已提交
1849 1850 1851 1852 1853 1854 1855
		/*
		 * 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 已提交
1856
		read_unlock(&tasklist_lock);
M
Miklos Szeredi 已提交
1857
		preempt_enable_no_resched();
1858
		freezable_schedule();
L
Linus Torvalds 已提交
1859 1860 1861
	} else {
		/*
		 * By the time we got the lock, our tracer went away.
1862
		 * Don't drop the lock yet, another tracer may come.
1863 1864 1865
		 *
		 * If @gstop_done, the ptracer went away between group stop
		 * completion and here.  During detach, it would have set
1866 1867 1868
		 * 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 已提交
1869
		 */
1870 1871 1872
		if (gstop_done)
			do_notify_parent_cldstop(current, false, why);

1873
		/* tasklist protects us from ptrace_freeze_traced() */
1874
		__set_current_state(TASK_RUNNING);
1875 1876
		if (clear_code)
			current->exit_code = 0;
1877
		read_unlock(&tasklist_lock);
L
Linus Torvalds 已提交
1878 1879 1880 1881 1882 1883 1884 1885 1886 1887
	}

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

L
Linus Torvalds 已提交
1891 1892 1893
	/*
	 * Queued signals ignored us while we were stopped for tracing.
	 * So check for any that we should take before resuming user mode.
1894
	 * This sets TIF_SIGPENDING, but never clears it.
L
Linus Torvalds 已提交
1895
	 */
1896
	recalc_sigpending_tsk(current);
L
Linus Torvalds 已提交
1897 1898
}

T
Tejun Heo 已提交
1899
static void ptrace_do_notify(int signr, int exit_code, int why)
L
Linus Torvalds 已提交
1900 1901 1902 1903
{
	siginfo_t info;

	memset(&info, 0, sizeof info);
T
Tejun Heo 已提交
1904
	info.si_signo = signr;
L
Linus Torvalds 已提交
1905
	info.si_code = exit_code;
1906
	info.si_pid = task_pid_vnr(current);
1907
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
L
Linus Torvalds 已提交
1908 1909

	/* Let the debugger run.  */
T
Tejun Heo 已提交
1910 1911 1912 1913 1914 1915
	ptrace_stop(exit_code, why, 1, &info);
}

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

L
Linus Torvalds 已提交
1919
	spin_lock_irq(&current->sighand->siglock);
T
Tejun Heo 已提交
1920
	ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
L
Linus Torvalds 已提交
1921 1922 1923
	spin_unlock_irq(&current->sighand->siglock);
}

1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
/**
 * 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 已提交
1945
 */
1946 1947
static bool do_signal_stop(int signr)
	__releases(&current->sighand->siglock)
L
Linus Torvalds 已提交
1948 1949 1950
{
	struct signal_struct *sig = current->signal;

1951
	if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
1952
		unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
1953 1954
		struct task_struct *t;

1955 1956
		/* signr will be recorded in task->jobctl for retries */
		WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
1957

1958
		if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
1959
		    unlikely(signal_group_exit(sig)))
1960
			return false;
L
Linus Torvalds 已提交
1961
		/*
1962 1963 1964 1965 1966 1967 1968
		 * 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
1969 1970
		 * cause two group stops when !ptraced.  That is why we
		 * also check !task_is_stopped(t) below.
1971 1972 1973 1974 1975 1976 1977 1978
		 *
		 * 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 已提交
1979
		 */
1980 1981
		if (!(sig->flags & SIGNAL_STOP_STOPPED))
			sig->group_exit_code = signr;
L
Linus Torvalds 已提交
1982

1983 1984 1985 1986
		sig->group_stop_count = 0;

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

1988 1989
		t = current;
		while_each_thread(current, t) {
L
Linus Torvalds 已提交
1990
			/*
1991 1992 1993
			 * 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 已提交
1994
			 */
1995 1996
			if (!task_is_stopped(t) &&
			    task_set_jobctl_pending(t, signr | gstop)) {
1997
				sig->group_stop_count++;
1998 1999 2000 2001
				if (likely(!(t->ptrace & PT_SEIZED)))
					signal_wake_up(t, 0);
				else
					ptrace_trap_notify(t);
2002
			}
2003
		}
L
Linus Torvalds 已提交
2004
	}
2005

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

2009 2010 2011 2012 2013 2014 2015 2016
		/*
		 * 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;

2017
		__set_current_state(TASK_STOPPED);
2018 2019
		spin_unlock_irq(&current->sighand->siglock);

2020 2021 2022 2023 2024 2025 2026 2027 2028
		/*
		 * 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.
		 */
2029 2030
		if (notify) {
			read_lock(&tasklist_lock);
2031
			do_notify_parent_cldstop(current, false, notify);
2032 2033 2034 2035
			read_unlock(&tasklist_lock);
		}

		/* Now we don't run again until woken by SIGCONT or SIGKILL */
2036
		freezable_schedule();
2037
		return true;
2038
	} else {
2039 2040 2041 2042 2043 2044
		/*
		 * 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;
2045
	}
2046
}
L
Linus Torvalds 已提交
2047

2048 2049 2050
/**
 * do_jobctl_trap - take care of ptrace jobctl traps
 *
T
Tejun Heo 已提交
2051 2052 2053 2054 2055 2056 2057
 * 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.
2058 2059 2060 2061 2062 2063 2064
 *
 * 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 已提交
2065
	struct signal_struct *signal = current->signal;
2066
	int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2067

T
Tejun Heo 已提交
2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078
	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;
2079
	}
L
Linus Torvalds 已提交
2080 2081
}

2082
static int ptrace_signal(int signr, siginfo_t *info)
R
Roland McGrath 已提交
2083
{
2084
	ptrace_signal_deliver();
2085 2086 2087 2088 2089 2090 2091 2092 2093 2094
	/*
	 * 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 已提交
2095
	ptrace_stop(signr, CLD_TRAPPED, 0, info);
R
Roland McGrath 已提交
2096 2097 2098 2099 2100 2101 2102 2103

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

	current->exit_code = 0;

2104 2105 2106 2107 2108 2109
	/*
	 * 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 已提交
2110 2111 2112 2113
	if (signr != info->si_signo) {
		info->si_signo = signr;
		info->si_errno = 0;
		info->si_code = SI_USER;
2114
		rcu_read_lock();
R
Roland McGrath 已提交
2115
		info->si_pid = task_pid_vnr(current->parent);
2116 2117
		info->si_uid = from_kuid_munged(current_user_ns(),
						task_uid(current->parent));
2118
		rcu_read_unlock();
R
Roland McGrath 已提交
2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
	}

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

2130
int get_signal(struct ksignal *ksig)
L
Linus Torvalds 已提交
2131
{
2132 2133 2134
	struct sighand_struct *sighand = current->sighand;
	struct signal_struct *signal = current->signal;
	int signr;
L
Linus Torvalds 已提交
2135

2136 2137
	if (unlikely(current->task_works))
		task_work_run();
2138

2139 2140 2141
	if (unlikely(uprobe_deny_signal()))
		return 0;

R
Roland McGrath 已提交
2142
	/*
2143 2144 2145
	 * 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 已提交
2146
	 */
2147 2148
	try_to_freeze();

2149
relock:
2150
	spin_lock_irq(&sighand->siglock);
2151 2152 2153 2154 2155
	/*
	 * 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.
	 */
2156
	if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2157 2158 2159 2160 2161 2162 2163
		int why;

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

2164
		signal->flags &= ~SIGNAL_CLD_MASK;
2165

2166
		spin_unlock_irq(&sighand->siglock);
R
Roland McGrath 已提交
2167

2168 2169 2170 2171 2172 2173 2174 2175
		/*
		 * 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 已提交
2176
		read_lock(&tasklist_lock);
2177 2178
		do_notify_parent_cldstop(current, false, why);

2179 2180 2181
		if (ptrace_reparented(current->group_leader))
			do_notify_parent_cldstop(current->group_leader,
						true, why);
T
Tejun Heo 已提交
2182
		read_unlock(&tasklist_lock);
2183

2184 2185 2186
		goto relock;
	}

L
Linus Torvalds 已提交
2187 2188
	for (;;) {
		struct k_sigaction *ka;
2189

T
Tejun Heo 已提交
2190 2191
		if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
		    do_signal_stop(0))
2192
			goto relock;
2193

2194 2195 2196 2197 2198
		if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
			do_jobctl_trap();
			spin_unlock_irq(&sighand->siglock);
			goto relock;
		}
L
Linus Torvalds 已提交
2199

2200
		signr = dequeue_signal(current, &current->blocked, &ksig->info);
2201

T
Tejun Heo 已提交
2202 2203
		if (!signr)
			break; /* will return 0 */
2204

2205
		if (unlikely(current->ptrace) && signr != SIGKILL) {
2206
			signr = ptrace_signal(signr, &ksig->info);
T
Tejun Heo 已提交
2207 2208
			if (!signr)
				continue;
L
Linus Torvalds 已提交
2209 2210
		}

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

2213
		/* Trace actually delivered signals. */
2214
		trace_signal_deliver(signr, &ksig->info, ka);
2215

L
Linus Torvalds 已提交
2216 2217 2218 2219
		if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
			continue;
		if (ka->sa.sa_handler != SIG_DFL) {
			/* Run the handler.  */
2220
			ksig->ka = *ka;
L
Linus Torvalds 已提交
2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233

			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;

2234
		/*
2235
		 * Global init gets no signals it doesn't want.
2236 2237 2238 2239 2240 2241 2242
		 * 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.
2243
		 */
2244
		if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2245
				!sig_kernel_only(signr))
L
Linus Torvalds 已提交
2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259
			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) {
2260
				spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2261 2262 2263

				/* signals can be posted during this window */

2264
				if (is_current_pgrp_orphaned())
L
Linus Torvalds 已提交
2265 2266
					goto relock;

2267
				spin_lock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2268 2269
			}

2270
			if (likely(do_signal_stop(ksig->info.si_signo))) {
L
Linus Torvalds 已提交
2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281
				/* It released the siglock.  */
				goto relock;
			}

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

2282
		spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2283 2284 2285 2286 2287

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

L
Linus Torvalds 已提交
2289
		if (sig_kernel_coredump(signr)) {
2290
			if (print_fatal_signals)
2291
				print_fatal_signal(ksig->info.si_signo);
2292
			proc_coredump_connector(current);
L
Linus Torvalds 已提交
2293 2294 2295 2296 2297 2298 2299 2300
			/*
			 * 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.
			 */
2301
			do_coredump(&ksig->info);
L
Linus Torvalds 已提交
2302 2303 2304 2305 2306
		}

		/*
		 * Death signals, no core dump.
		 */
2307
		do_group_exit(ksig->info.si_signo);
L
Linus Torvalds 已提交
2308 2309
		/* NOTREACHED */
	}
2310
	spin_unlock_irq(&sighand->siglock);
2311 2312 2313

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

2316
/**
A
Al Viro 已提交
2317
 * signal_delivered - 
R
Richard Weinberger 已提交
2318
 * @ksig:		kernel signal struct
A
Al Viro 已提交
2319
 * @stepping:		nonzero if debugger single-step or block-step in use
2320
 *
2321
 * This function should be called when a signal has successfully been
R
Richard Weinberger 已提交
2322
 * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
A
Al Viro 已提交
2323
 * is always blocked, and the signal itself is blocked unless %SA_NODEFER
R
Richard Weinberger 已提交
2324
 * is set in @ksig->ka.sa.sa_flags.  Tracing is notified.
2325
 */
R
Richard Weinberger 已提交
2326
static void signal_delivered(struct ksignal *ksig, int stepping)
2327 2328 2329
{
	sigset_t blocked;

2330 2331 2332 2333 2334 2335
	/* A signal was successfully delivered, and the
	   saved sigmask was stored on the signal frame,
	   and will be restored by sigreturn.  So we can
	   simply clear the restore sigmask flag.  */
	clear_restore_sigmask();

R
Richard Weinberger 已提交
2336 2337 2338
	sigorsets(&blocked, &current->blocked, &ksig->ka.sa.sa_mask);
	if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
		sigaddset(&blocked, ksig->sig);
2339
	set_current_blocked(&blocked);
2340
	tracehook_signal_handler(stepping);
2341 2342
}

A
Al Viro 已提交
2343 2344 2345 2346 2347
void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
{
	if (failed)
		force_sigsegv(ksig->sig, current);
	else
R
Richard Weinberger 已提交
2348
		signal_delivered(ksig, stepping);
A
Al Viro 已提交
2349 2350
}

2351 2352
/*
 * It could be that complete_signal() picked us to notify about the
2353 2354
 * group-wide signal. Other threads should be notified now to take
 * the shared signals in @which since we will not.
2355
 */
2356
static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2357
{
2358
	sigset_t retarget;
2359 2360
	struct task_struct *t;

2361 2362 2363 2364
	sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
	if (sigisemptyset(&retarget))
		return;

2365 2366
	t = tsk;
	while_each_thread(tsk, t) {
2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379
		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;
2380 2381 2382
	}
}

O
Oleg Nesterov 已提交
2383 2384 2385
void exit_signals(struct task_struct *tsk)
{
	int group_stop = 0;
2386
	sigset_t unblocked;
O
Oleg Nesterov 已提交
2387

2388 2389 2390 2391 2392 2393
	/*
	 * @tsk is about to have PF_EXITING set - lock out users which
	 * expect stable threadgroup.
	 */
	threadgroup_change_begin(tsk);

2394 2395
	if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
		tsk->flags |= PF_EXITING;
2396
		threadgroup_change_end(tsk);
2397
		return;
O
Oleg Nesterov 已提交
2398 2399
	}

2400
	spin_lock_irq(&tsk->sighand->siglock);
O
Oleg Nesterov 已提交
2401 2402 2403 2404 2405
	/*
	 * From now this task is not visible for group-wide signals,
	 * see wants_signal(), do_signal_stop().
	 */
	tsk->flags |= PF_EXITING;
2406 2407 2408

	threadgroup_change_end(tsk);

2409 2410 2411
	if (!signal_pending(tsk))
		goto out;

2412 2413 2414
	unblocked = tsk->blocked;
	signotset(&unblocked);
	retarget_shared_pending(tsk, &unblocked);
2415

2416
	if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2417
	    task_participate_group_stop(tsk))
T
Tejun Heo 已提交
2418
		group_stop = CLD_STOPPED;
2419
out:
O
Oleg Nesterov 已提交
2420 2421
	spin_unlock_irq(&tsk->sighand->siglock);

2422 2423 2424 2425
	/*
	 * If group stop has completed, deliver the notification.  This
	 * should always go to the real parent of the group leader.
	 */
2426
	if (unlikely(group_stop)) {
O
Oleg Nesterov 已提交
2427
		read_lock(&tasklist_lock);
2428
		do_notify_parent_cldstop(tsk, false, group_stop);
O
Oleg Nesterov 已提交
2429 2430 2431 2432
		read_unlock(&tasklist_lock);
	}
}

L
Linus Torvalds 已提交
2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444
EXPORT_SYMBOL(recalc_sigpending);
EXPORT_SYMBOL_GPL(dequeue_signal);
EXPORT_SYMBOL(flush_signals);
EXPORT_SYMBOL(force_sig);
EXPORT_SYMBOL(send_sig);
EXPORT_SYMBOL(send_sig_info);
EXPORT_SYMBOL(sigprocmask);

/*
 * System call entry points.
 */

2445 2446 2447
/**
 *  sys_restart_syscall - restart a system call
 */
2448
SYSCALL_DEFINE0(restart_syscall)
L
Linus Torvalds 已提交
2449
{
2450
	struct restart_block *restart = &current->restart_block;
L
Linus Torvalds 已提交
2451 2452 2453 2454 2455 2456 2457 2458
	return restart->fn(restart);
}

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

2459 2460 2461 2462 2463
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. */
2464
		sigandnsets(&newblocked, newset, &current->blocked);
2465 2466 2467 2468 2469 2470
		retarget_shared_pending(tsk, &newblocked);
	}
	tsk->blocked = *newset;
	recalc_sigpending();
}

2471 2472 2473 2474 2475 2476
/**
 * 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 已提交
2477
 */
2478 2479 2480
void set_current_blocked(sigset_t *newset)
{
	sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2481
	__set_current_blocked(newset);
2482 2483 2484
}

void __set_current_blocked(const sigset_t *newset)
2485 2486 2487 2488
{
	struct task_struct *tsk = current;

	spin_lock_irq(&tsk->sighand->siglock);
2489
	__set_task_blocked(tsk, newset);
2490 2491
	spin_unlock_irq(&tsk->sighand->siglock);
}
L
Linus Torvalds 已提交
2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502

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

2506
	/* Lockless, only current can change ->blocked, never from irq */
2507
	if (oldset)
2508
		*oldset = tsk->blocked;
2509

L
Linus Torvalds 已提交
2510 2511
	switch (how) {
	case SIG_BLOCK:
2512
		sigorsets(&newset, &tsk->blocked, set);
L
Linus Torvalds 已提交
2513 2514
		break;
	case SIG_UNBLOCK:
2515
		sigandnsets(&newset, &tsk->blocked, set);
L
Linus Torvalds 已提交
2516 2517
		break;
	case SIG_SETMASK:
2518
		newset = *set;
L
Linus Torvalds 已提交
2519 2520
		break;
	default:
2521
		return -EINVAL;
L
Linus Torvalds 已提交
2522
	}
2523

2524
	__set_current_blocked(&newset);
2525
	return 0;
L
Linus Torvalds 已提交
2526 2527
}

2528 2529 2530
/**
 *  sys_rt_sigprocmask - change the list of currently blocked signals
 *  @how: whether to add, remove, or set signals
R
Randy Dunlap 已提交
2531
 *  @nset: stores pending signals
2532 2533 2534
 *  @oset: previous value of signal mask if non-null
 *  @sigsetsize: size of sigset_t type
 */
2535
SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
2536
		sigset_t __user *, oset, size_t, sigsetsize)
L
Linus Torvalds 已提交
2537 2538
{
	sigset_t old_set, new_set;
2539
	int error;
L
Linus Torvalds 已提交
2540 2541 2542

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

2545 2546 2547 2548 2549
	old_set = current->blocked;

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

2552
		error = sigprocmask(how, &new_set, NULL);
L
Linus Torvalds 已提交
2553
		if (error)
2554 2555
			return error;
	}
L
Linus Torvalds 已提交
2556

2557 2558 2559
	if (oset) {
		if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
			return -EFAULT;
L
Linus Torvalds 已提交
2560
	}
2561 2562

	return 0;
L
Linus Torvalds 已提交
2563 2564
}

A
Al Viro 已提交
2565 2566 2567
#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 已提交
2568
{
A
Al Viro 已提交
2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592
#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 已提交
2593
		if (copy_to_user(oset, &old32, sizeof(compat_sigset_t)))
A
Al Viro 已提交
2594 2595 2596 2597 2598 2599 2600 2601 2602
			return -EFAULT;
	}
	return 0;
#else
	return sys_rt_sigprocmask(how, (sigset_t __user *)nset,
				  (sigset_t __user *)oset, sigsetsize);
#endif
}
#endif
L
Linus Torvalds 已提交
2603

A
Al Viro 已提交
2604
static int do_sigpending(void *set, unsigned long sigsetsize)
L
Linus Torvalds 已提交
2605 2606
{
	if (sigsetsize > sizeof(sigset_t))
A
Al Viro 已提交
2607
		return -EINVAL;
L
Linus Torvalds 已提交
2608 2609

	spin_lock_irq(&current->sighand->siglock);
A
Al Viro 已提交
2610
	sigorsets(set, &current->pending.signal,
L
Linus Torvalds 已提交
2611 2612 2613 2614
		  &current->signal->shared_pending.signal);
	spin_unlock_irq(&current->sighand->siglock);

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

2619 2620 2621
/**
 *  sys_rt_sigpending - examine a pending signal that has been raised
 *			while blocked
2622
 *  @uset: stores pending signals
2623 2624
 *  @sigsetsize: size of sigset_t type or larger
 */
A
Al Viro 已提交
2625
SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
L
Linus Torvalds 已提交
2626
{
A
Al Viro 已提交
2627 2628 2629 2630 2631 2632 2633 2634 2635 2636
	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 已提交
2637
{
A
Al Viro 已提交
2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651
#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 已提交
2652
}
A
Al Viro 已提交
2653
#endif
L
Linus Torvalds 已提交
2654 2655 2656

#ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER

A
Al Viro 已提交
2657
int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
L
Linus Torvalds 已提交
2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668
{
	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.
2669 2670
	 * Please remember to update the signalfd_copyinfo() function
	 * inside fs/signalfd.c too, in case siginfo_t changes.
L
Linus Torvalds 已提交
2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695
	 * 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 已提交
2696 2697
#endif
#ifdef BUS_MCEERR_AO
2698
		/*
A
Andi Kleen 已提交
2699
		 * Other callers might not initialize the si_lsb field,
2700
		 * so check explicitly for the right codes here.
A
Andi Kleen 已提交
2701
		 */
2702 2703
		if (from->si_signo == SIGBUS &&
		    (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO))
A
Andi Kleen 已提交
2704
			err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
2705 2706
#endif
#ifdef SEGV_BNDERR
2707 2708 2709 2710
		if (from->si_signo == SIGSEGV && from->si_code == SEGV_BNDERR) {
			err |= __put_user(from->si_lower, &to->si_lower);
			err |= __put_user(from->si_upper, &to->si_upper);
		}
2711 2712 2713 2714
#endif
#ifdef SEGV_PKUERR
		if (from->si_signo == SIGSEGV && from->si_code == SEGV_PKUERR)
			err |= __put_user(from->si_pkey, &to->si_pkey);
L
Linus Torvalds 已提交
2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729
#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;
2730 2731 2732 2733 2734 2735 2736
#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 已提交
2737 2738 2739 2740 2741 2742 2743 2744 2745 2746
	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

2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784
/**
 *  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
2785 2786
		 * they arrive. Unblocking is always fine, we can avoid
		 * set_current_blocked().
2787 2788 2789 2790 2791 2792
		 */
		tsk->real_blocked = tsk->blocked;
		sigandsets(&tsk->blocked, &tsk->blocked, &mask);
		recalc_sigpending();
		spin_unlock_irq(&tsk->sighand->siglock);

2793
		timeout = freezable_schedule_timeout_interruptible(timeout);
2794 2795

		spin_lock_irq(&tsk->sighand->siglock);
2796
		__set_task_blocked(tsk, &tsk->real_blocked);
2797
		sigemptyset(&tsk->real_blocked);
2798
		sig = dequeue_signal(tsk, &mask, info);
2799 2800 2801 2802 2803 2804 2805 2806
	}
	spin_unlock_irq(&tsk->sighand->siglock);

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

2807 2808 2809 2810 2811 2812 2813 2814
/**
 *  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
 */
2815 2816 2817
SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
		siginfo_t __user *, uinfo, const struct timespec __user *, uts,
		size_t, sigsetsize)
L
Linus Torvalds 已提交
2818 2819 2820 2821
{
	sigset_t these;
	struct timespec ts;
	siginfo_t info;
2822
	int ret;
L
Linus Torvalds 已提交
2823 2824 2825 2826 2827 2828 2829

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

L
Linus Torvalds 已提交
2831 2832 2833 2834 2835
	if (uts) {
		if (copy_from_user(&ts, uts, sizeof(ts)))
			return -EFAULT;
	}

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

2838 2839 2840
	if (ret > 0 && uinfo) {
		if (copy_siginfo_to_user(uinfo, &info))
			ret = -EFAULT;
L
Linus Torvalds 已提交
2841 2842 2843 2844 2845
	}

	return ret;
}

2846 2847 2848 2849 2850
/**
 *  sys_kill - send a signal to a process
 *  @pid: the PID of the process
 *  @sig: signal to be sent
 */
2851
SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
L
Linus Torvalds 已提交
2852 2853 2854 2855 2856 2857
{
	struct siginfo info;

	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_USER;
2858
	info.si_pid = task_tgid_vnr(current);
2859
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
L
Linus Torvalds 已提交
2860 2861 2862 2863

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

T
Thomas Gleixner 已提交
2864 2865
static int
do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
L
Linus Torvalds 已提交
2866 2867
{
	struct task_struct *p;
T
Thomas Gleixner 已提交
2868
	int error = -ESRCH;
L
Linus Torvalds 已提交
2869

2870
	rcu_read_lock();
2871
	p = find_task_by_vpid(pid);
2872
	if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
T
Thomas Gleixner 已提交
2873
		error = check_kill_permission(sig, info, p);
L
Linus Torvalds 已提交
2874 2875 2876 2877
		/*
		 * The null signal is a permissions and process existence
		 * probe.  No signal is actually delivered.
		 */
2878 2879 2880 2881 2882 2883 2884 2885 2886
		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 已提交
2887 2888
		}
	}
2889
	rcu_read_unlock();
2890

L
Linus Torvalds 已提交
2891 2892 2893
	return error;
}

T
Thomas Gleixner 已提交
2894 2895
static int do_tkill(pid_t tgid, pid_t pid, int sig)
{
2896
	struct siginfo info = {};
T
Thomas Gleixner 已提交
2897 2898 2899 2900 2901

	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_TKILL;
	info.si_pid = task_tgid_vnr(current);
2902
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
T
Thomas Gleixner 已提交
2903 2904 2905 2906

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

2907 2908 2909 2910 2911 2912
/**
 *  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
 *
2913
 *  This syscall also checks the @tgid and returns -ESRCH even if the PID
2914 2915 2916
 *  exists but it's not belonging to the target process anymore. This
 *  method solves the problem of threads exiting and PIDs getting reused.
 */
2917
SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
2918 2919 2920 2921 2922 2923 2924 2925
{
	/* This is only valid for single tasks */
	if (pid <= 0 || tgid <= 0)
		return -EINVAL;

	return do_tkill(tgid, pid, sig);
}

2926 2927 2928 2929 2930
/**
 *  sys_tkill - send signal to one specific task
 *  @pid: the PID of the task
 *  @sig: signal to be sent
 *
L
Linus Torvalds 已提交
2931 2932
 *  Send a signal to only one task, even if it's a CLONE_THREAD task.
 */
2933
SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
L
Linus Torvalds 已提交
2934 2935 2936 2937 2938
{
	/* This is only valid for single tasks */
	if (pid <= 0)
		return -EINVAL;

2939
	return do_tkill(0, pid, sig);
L
Linus Torvalds 已提交
2940 2941
}

A
Al Viro 已提交
2942 2943 2944 2945 2946
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.
	 */
2947
	if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
2948
	    (task_pid_vnr(current) != pid))
A
Al Viro 已提交
2949
		return -EPERM;
2950

A
Al Viro 已提交
2951 2952 2953 2954 2955 2956
	info->si_signo = sig;

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

2957 2958 2959 2960 2961 2962
/**
 *  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
 */
2963 2964
SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
		siginfo_t __user *, uinfo)
L
Linus Torvalds 已提交
2965 2966 2967 2968
{
	siginfo_t info;
	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
		return -EFAULT;
A
Al Viro 已提交
2969 2970
	return do_rt_sigqueueinfo(pid, sig, &info);
}
L
Linus Torvalds 已提交
2971

A
Al Viro 已提交
2972 2973 2974 2975 2976 2977
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
			compat_pid_t, pid,
			int, sig,
			struct compat_siginfo __user *, uinfo)
{
2978
	siginfo_t info = {};
A
Al Viro 已提交
2979 2980 2981 2982
	int ret = copy_siginfo_from_user32(&info, uinfo);
	if (unlikely(ret))
		return ret;
	return do_rt_sigqueueinfo(pid, sig, &info);
L
Linus Torvalds 已提交
2983
}
A
Al Viro 已提交
2984
#endif
L
Linus Torvalds 已提交
2985

2986
static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
2987 2988 2989 2990 2991 2992
{
	/* 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.
2993 2994
	 * Nor can they impersonate a kill()/tgkill(), which adds source info.
	 */
2995 2996
	if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
	    (task_pid_vnr(current) != pid))
2997
		return -EPERM;
2998

2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014
	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);
}

3015 3016 3017 3018 3019 3020 3021
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
			compat_pid_t, tgid,
			compat_pid_t, pid,
			int, sig,
			struct compat_siginfo __user *, uinfo)
{
3022
	siginfo_t info = {};
3023 3024 3025 3026 3027 3028 3029

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

3030
/*
3031
 * For kthreads only, must not be used if cloned with CLONE_SIGHAND
3032
 */
3033
void kernel_sigaction(int sig, __sighandler_t action)
3034
{
3035
	spin_lock_irq(&current->sighand->siglock);
3036 3037 3038
	current->sighand->action[sig - 1].sa.sa_handler = action;
	if (action == SIG_IGN) {
		sigset_t mask;
3039

3040 3041
		sigemptyset(&mask);
		sigaddset(&mask, sig);
3042

3043 3044 3045 3046
		flush_sigqueue_mask(&mask, &current->signal->shared_pending);
		flush_sigqueue_mask(&mask, &current->pending);
		recalc_sigpending();
	}
3047 3048
	spin_unlock_irq(&current->sighand->siglock);
}
3049
EXPORT_SYMBOL(kernel_sigaction);
3050

3051
int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
L
Linus Torvalds 已提交
3052
{
3053
	struct task_struct *p = current, *t;
L
Linus Torvalds 已提交
3054
	struct k_sigaction *k;
3055
	sigset_t mask;
L
Linus Torvalds 已提交
3056

3057
	if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
L
Linus Torvalds 已提交
3058 3059
		return -EINVAL;

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

3062
	spin_lock_irq(&p->sighand->siglock);
L
Linus Torvalds 已提交
3063 3064 3065 3066
	if (oact)
		*oact = *k;

	if (act) {
3067 3068
		sigdelsetmask(&act->sa.sa_mask,
			      sigmask(SIGKILL) | sigmask(SIGSTOP));
3069
		*k = *act;
L
Linus Torvalds 已提交
3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080
		/*
		 * 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"
		 */
3081
		if (sig_handler_ignored(sig_handler(p, sig), sig)) {
3082 3083
			sigemptyset(&mask);
			sigaddset(&mask, sig);
3084 3085
			flush_sigqueue_mask(&mask, &p->signal->shared_pending);
			for_each_thread(p, t)
3086
				flush_sigqueue_mask(&mask, &t->pending);
L
Linus Torvalds 已提交
3087 3088 3089
		}
	}

3090
	spin_unlock_irq(&p->sighand->siglock);
L
Linus Torvalds 已提交
3091 3092 3093
	return 0;
}

3094
static int
L
Linus Torvalds 已提交
3095 3096 3097 3098 3099
do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
{
	stack_t oss;
	int error;

3100 3101 3102
	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 已提交
3103 3104 3105 3106

	if (uss) {
		void __user *ss_sp;
		size_t ss_size;
3107 3108
		unsigned ss_flags;
		int ss_mode;
L
Linus Torvalds 已提交
3109 3110

		error = -EFAULT;
L
Linus Torvalds 已提交
3111 3112 3113 3114 3115 3116
		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 已提交
3117 3118 3119 3120 3121 3122
			goto out;

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

3123
		ss_mode = ss_flags & ~SS_FLAG_BITS;
L
Linus Torvalds 已提交
3124
		error = -EINVAL;
3125 3126
		if (ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
				ss_mode != 0)
L
Linus Torvalds 已提交
3127 3128
			goto out;

3129
		if (ss_mode == SS_DISABLE) {
L
Linus Torvalds 已提交
3130 3131 3132 3133 3134 3135 3136 3137 3138 3139
			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;
3140
		current->sas_ss_flags = ss_flags;
L
Linus Torvalds 已提交
3141 3142
	}

3143
	error = 0;
L
Linus Torvalds 已提交
3144 3145
	if (uoss) {
		error = -EFAULT;
3146
		if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
L
Linus Torvalds 已提交
3147
			goto out;
3148 3149 3150
		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 已提交
3151 3152 3153 3154 3155
	}

out:
	return error;
}
3156 3157 3158 3159
SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
{
	return do_sigaltstack(uss, uoss, current_user_stack_pointer());
}
L
Linus Torvalds 已提交
3160

A
Al Viro 已提交
3161 3162 3163 3164 3165 3166 3167
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;
}

3168 3169 3170
int __save_altstack(stack_t __user *uss, unsigned long sp)
{
	struct task_struct *t = current;
3171 3172
	int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
		__put_user(t->sas_ss_flags, &uss->ss_flags) |
3173
		__put_user(t->sas_ss_size, &uss->ss_size);
3174 3175 3176 3177 3178
	if (err)
		return err;
	if (t->sas_ss_flags & SS_AUTODISARM)
		sas_ss_reset(t);
	return 0;
3179 3180
}

A
Al Viro 已提交
3181
#ifdef CONFIG_COMPAT
3182 3183 3184
COMPAT_SYSCALL_DEFINE2(sigaltstack,
			const compat_stack_t __user *, uss_ptr,
			compat_stack_t __user *, uoss_ptr)
A
Al Viro 已提交
3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221
{
	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;
}
3222 3223 3224 3225 3226 3227 3228 3229

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 已提交
3230
#endif
L
Linus Torvalds 已提交
3231 3232 3233

#ifdef __ARCH_WANT_SYS_SIGPENDING

3234 3235 3236 3237
/**
 *  sys_sigpending - examine pending signals
 *  @set: where mask of pending signal is returned
 */
3238
SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
L
Linus Torvalds 已提交
3239
{
A
Al Viro 已提交
3240
	return sys_rt_sigpending((sigset_t __user *)set, sizeof(old_sigset_t)); 
L
Linus Torvalds 已提交
3241 3242 3243 3244 3245
}

#endif

#ifdef __ARCH_WANT_SYS_SIGPROCMASK
3246 3247 3248
/**
 *  sys_sigprocmask - examine and change blocked signals
 *  @how: whether to add, remove, or set signals
3249
 *  @nset: signals to add or remove (if non-null)
3250 3251
 *  @oset: previous value of signal mask if non-null
 *
3252 3253 3254
 * Some platforms have their own version with special arguments;
 * others support only sys_rt_sigprocmask.
 */
L
Linus Torvalds 已提交
3255

3256
SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
3257
		old_sigset_t __user *, oset)
L
Linus Torvalds 已提交
3258 3259
{
	old_sigset_t old_set, new_set;
3260
	sigset_t new_blocked;
L
Linus Torvalds 已提交
3261

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

3264 3265 3266
	if (nset) {
		if (copy_from_user(&new_set, nset, sizeof(*nset)))
			return -EFAULT;
L
Linus Torvalds 已提交
3267

3268
		new_blocked = current->blocked;
L
Linus Torvalds 已提交
3269 3270 3271

		switch (how) {
		case SIG_BLOCK:
3272
			sigaddsetmask(&new_blocked, new_set);
L
Linus Torvalds 已提交
3273 3274
			break;
		case SIG_UNBLOCK:
3275
			sigdelsetmask(&new_blocked, new_set);
L
Linus Torvalds 已提交
3276 3277
			break;
		case SIG_SETMASK:
3278
			new_blocked.sig[0] = new_set;
L
Linus Torvalds 已提交
3279
			break;
3280 3281
		default:
			return -EINVAL;
L
Linus Torvalds 已提交
3282 3283
		}

3284
		set_current_blocked(&new_blocked);
3285 3286 3287
	}

	if (oset) {
L
Linus Torvalds 已提交
3288
		if (copy_to_user(oset, &old_set, sizeof(*oset)))
3289
			return -EFAULT;
L
Linus Torvalds 已提交
3290
	}
3291 3292

	return 0;
L
Linus Torvalds 已提交
3293 3294 3295
}
#endif /* __ARCH_WANT_SYS_SIGPROCMASK */

3296
#ifndef CONFIG_ODD_RT_SIGACTION
3297 3298 3299
/**
 *  sys_rt_sigaction - alter an action taken by a process
 *  @sig: signal to be sent
3300 3301
 *  @act: new sigaction
 *  @oact: used to save the previous sigaction
3302 3303
 *  @sigsetsize: size of sigset_t type
 */
3304 3305 3306 3307
SYSCALL_DEFINE4(rt_sigaction, int, sig,
		const struct sigaction __user *, act,
		struct sigaction __user *, oact,
		size_t, sigsetsize)
L
Linus Torvalds 已提交
3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329
{
	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 已提交
3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355
#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));
3356
		ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
A
Al Viro 已提交
3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367
		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));
3368
		ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
A
Al Viro 已提交
3369 3370 3371 3372 3373 3374 3375 3376
#ifdef __ARCH_HAS_SA_RESTORER
		ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
				&oact->sa_restorer);
#endif
	}
	return ret;
}
#endif
3377
#endif /* !CONFIG_ODD_RT_SIGACTION */
L
Linus Torvalds 已提交
3378

3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 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
#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 已提交
3456

3457
#ifdef CONFIG_SGETMASK_SYSCALL
L
Linus Torvalds 已提交
3458 3459 3460 3461

/*
 * For backwards compatibility.  Functionality superseded by sigprocmask.
 */
3462
SYSCALL_DEFINE0(sgetmask)
L
Linus Torvalds 已提交
3463 3464 3465 3466 3467
{
	/* SMP safe */
	return current->blocked.sig[0];
}

3468
SYSCALL_DEFINE1(ssetmask, int, newmask)
L
Linus Torvalds 已提交
3469
{
3470 3471
	int old = current->blocked.sig[0];
	sigset_t newset;
L
Linus Torvalds 已提交
3472

3473
	siginitset(&newset, newmask);
3474
	set_current_blocked(&newset);
L
Linus Torvalds 已提交
3475 3476 3477

	return old;
}
3478
#endif /* CONFIG_SGETMASK_SYSCALL */
L
Linus Torvalds 已提交
3479 3480 3481 3482 3483

#ifdef __ARCH_WANT_SYS_SIGNAL
/*
 * For backwards compatibility.  Functionality superseded by sigaction.
 */
3484
SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
L
Linus Torvalds 已提交
3485 3486 3487 3488 3489 3490
{
	struct k_sigaction new_sa, old_sa;
	int ret;

	new_sa.sa.sa_handler = handler;
	new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
3491
	sigemptyset(&new_sa.sa.sa_mask);
L
Linus Torvalds 已提交
3492 3493 3494 3495 3496 3497 3498 3499 3500

	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

3501
SYSCALL_DEFINE0(pause)
L
Linus Torvalds 已提交
3502
{
3503
	while (!signal_pending(current)) {
3504
		__set_current_state(TASK_INTERRUPTIBLE);
3505 3506
		schedule();
	}
L
Linus Torvalds 已提交
3507 3508 3509 3510 3511
	return -ERESTARTNOHAND;
}

#endif

3512
static int sigsuspend(sigset_t *set)
A
Al Viro 已提交
3513 3514 3515 3516
{
	current->saved_sigmask = current->blocked;
	set_current_blocked(set);

3517 3518 3519 3520
	while (!signal_pending(current)) {
		__set_current_state(TASK_INTERRUPTIBLE);
		schedule();
	}
A
Al Viro 已提交
3521 3522 3523 3524
	set_restore_sigmask();
	return -ERESTARTNOHAND;
}

3525 3526 3527 3528 3529 3530
/**
 *  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
 */
3531
SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
3532 3533 3534 3535 3536 3537 3538 3539 3540
{
	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 已提交
3541
	return sigsuspend(&newset);
3542
}
A
Al Viro 已提交
3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564
 
#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
3565

3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581
#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
3582

3583
__weak const char *arch_vma_name(struct vm_area_struct *vma)
3584 3585 3586 3587
{
	return NULL;
}

L
Linus Torvalds 已提交
3588 3589
void __init signals_init(void)
{
3590 3591 3592 3593
	/* If this check fails, the __ARCH_SI_PREAMBLE_SIZE value is wrong! */
	BUILD_BUG_ON(__ARCH_SI_PREAMBLE_SIZE
		!= offsetof(struct siginfo, _sifields._pad));

3594
	sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
L
Linus Torvalds 已提交
3595
}
3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635

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