signal.c 94.9 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>
34
#include <linux/compat.h>
35 36
#define CREATE_TRACE_POINTS
#include <trace/events/signal.h>
37

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

/*
 * SLAB caches for signal bits.
 */

49
static struct kmem_cache *sigqueue_cachep;
L
Linus Torvalds 已提交
50

51 52
int print_fatal_signals __read_mostly;

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

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

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

69 70 71
	handler = sig_handler(t, sig);

	if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
72
			handler == SIG_DFL && !force)
73 74 75 76 77
		return 1;

	return sig_handler_ignored(handler, sig);
}

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

88
	if (!sig_task_ignored(t, sig, force))
89 90 91 92 93
		return 0;

	/*
	 * Tracers may want to know about even ignored signals.
	 */
94
	return !t->ptrace;
L
Linus Torvalds 已提交
95 96 97 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
}

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

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

void recalc_sigpending(void)
{
157
	if (!recalc_sigpending_tsk(current) && !freezing(current))
158 159
		clear_thread_flag(TIF_SIGPENDING);

L
Linus Torvalds 已提交
160 161 162 163
}

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

164 165
#define SYNCHRONOUS_MASK \
	(sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
166
	 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
167

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

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

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

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

206 207
	case 1:
		/* Nothing to do */
L
Linus Torvalds 已提交
208 209
		break;
	}
210

L
Linus Torvalds 已提交
211 212 213
	return sig;
}

214 215 216 217 218 219 220 221 222 223 224 225 226 227
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);
}

228
/**
229
 * task_set_jobctl_pending - set jobctl pending bits
230
 * @task: target task
231
 * @mask: pending bits to set
232
 *
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
 * Clear @mask from @task->jobctl.  @mask must be subset of
 * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
 * %JOBCTL_TRAPPING.  If stop signo is being set, the existing signo is
 * cleared.  If @task is already being killed or exiting, this function
 * becomes noop.
 *
 * CONTEXT:
 * Must be called with @task->sighand->siglock held.
 *
 * RETURNS:
 * %true if @mask is set, %false if made noop because @task was dying.
 */
bool task_set_jobctl_pending(struct task_struct *task, unsigned int mask)
{
	BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
			JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
	BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));

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

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

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

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

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

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

	task->jobctl &= ~mask;
304 305 306

	if (!(task->jobctl & JOBCTL_PENDING_MASK))
		task_clear_jobctl_trapping(task);
307 308 309 310 311 312
}

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

330
	WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
331

332
	task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
333 334 335 336 337 338 339

	if (!consume)
		return false;

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

340 341 342 343 344
	/*
	 * 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)) {
345 346 347 348 349 350
		sig->flags = SIGNAL_STOP_STOPPED;
		return true;
	}
	return false;
}

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

362
	/*
363 364
	 * Protect access to @t credentials. This can go away when all
	 * callers hold rcu read lock.
365
	 */
366
	rcu_read_lock();
367
	user = get_uid(__task_cred(t)->user);
368
	atomic_inc(&user->sigpending);
369
	rcu_read_unlock();
370

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

L
Linus Torvalds 已提交
379
	if (unlikely(q == NULL)) {
380
		atomic_dec(&user->sigpending);
381
		free_uid(user);
L
Linus Torvalds 已提交
382 383 384
	} else {
		INIT_LIST_HEAD(&q->list);
		q->flags = 0;
385
		q->user = user;
L
Linus Torvalds 已提交
386
	}
387 388

	return q;
L
Linus Torvalds 已提交
389 390
}

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

400
void flush_sigqueue(struct sigpending *queue)
L
Linus Torvalds 已提交
401 402 403 404 405 406 407 408 409 410 411 412 413 414
{
	struct sigqueue *q;

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

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

422
void flush_signals(struct task_struct *t)
L
Linus Torvalds 已提交
423 424 425 426
{
	unsigned long flags;

	spin_lock_irqsave(&t->sighand->siglock, flags);
427
	__flush_signals(t);
L
Linus Torvalds 已提交
428 429 430
	spin_unlock_irqrestore(&t->sighand->siglock, flags);
}

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

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

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

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

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

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

void
unblock_all_signals(void)
{
	unsigned long flags;

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

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

	sigdelset(&list->signal, sig);

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

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

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

594
		collect_signal(sig, pending, info);
L
Linus Torvalds 已提交
595 596 597 598 599 600
	}

	return sig;
}

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

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

D
Davide Libenzi 已提交
642
	recalc_sigpending();
643 644 645 646
	if (!signr)
		return 0;

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

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

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

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

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

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

751 752 753 754 755 756 757 758 759 760 761
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));
}

762 763 764 765 766 767 768 769
/*
 * 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);

770 771 772 773
	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))
774 775
		return 1;

776
	if (ns_capable(tcred->user_ns, CAP_KILL))
777 778 779 780 781
		return 1;

	return 0;
}

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

792
	if (!valid_signal(sig))
793 794
		return -EINVAL;

795
	if (!si_fromuser(info))
796
		return 0;
797

798 799
	error = audit_signal_info(sig, t); /* Let audit system see the signal */
	if (error)
L
Linus Torvalds 已提交
800
		return error;
801

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

818
	return security_task_kill(t, info, sig, 0);
L
Linus Torvalds 已提交
819 820
}

821 822 823 824 825 826 827 828
/**
 * 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.
 *
829 830 831 832 833
 * 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.
834 835 836 837 838 839 840 841 842 843
 *
 * 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);
844
	ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
845 846
}

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

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

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

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

919
	return !sig_ignored(p, sig, force);
L
Linus Torvalds 已提交
920 921
}

922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942
/*
 * 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);
}

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

1019 1020 1021 1022 1023
static inline int legacy_queue(struct sigpending *signals, int sig)
{
	return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
}

1024 1025 1026 1027 1028 1029 1030 1031 1032
#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;

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

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

1053
	assert_spin_locked(&t->sighand->siglock);
1054

1055
	result = TRACE_SIGNAL_IGNORED;
1056 1057
	if (!prepare_signal(sig, t,
			from_ancestor_ns || (info == SEND_SIG_FORCED)))
1058
		goto ret;
1059 1060

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

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

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

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

		userns_fixup_signal_uid(&q->info, t);

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

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

1149 1150 1151
static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
			int group)
{
1152 1153 1154
	int from_ancestor_ns = 0;

#ifdef CONFIG_PID_NS
1155 1156
	from_ancestor_ns = si_fromuser(info) &&
			   !task_pid_nr_ns(current, task_active_pid_ns(t));
1157 1158 1159
#endif

	return __send_signal(sig, info, t, group, from_ancestor_ns);
1160 1161
}

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

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

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

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

1195 1196 1197 1198 1199 1200
int
__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
	return send_signal(sig, info, p, 1);
}

L
Linus Torvalds 已提交
1201 1202 1203
static int
specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
1204
	return send_signal(sig, info, t, 0);
L
Linus Torvalds 已提交
1205 1206
}

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

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

	return ret;
}

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

	p->signal->group_stop_count = 0;

1268
	while_each_thread(p, t) {
1269
		task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1270 1271 1272
		count++;

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

	return count;
L
Linus Torvalds 已提交
1280 1281
}

1282 1283
struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
					   unsigned long *flags)
1284 1285 1286 1287
{
	struct sighand_struct *sighand;

	for (;;) {
1288 1289
		local_irq_save(*flags);
		rcu_read_lock();
1290
		sighand = rcu_dereference(tsk->sighand);
1291 1292 1293
		if (unlikely(sighand == NULL)) {
			rcu_read_unlock();
			local_irq_restore(*flags);
1294
			break;
1295
		}
1296

1297 1298 1299
		spin_lock(&sighand->siglock);
		if (likely(sighand == tsk->sighand)) {
			rcu_read_unlock();
1300
			break;
1301 1302 1303 1304
		}
		spin_unlock(&sighand->siglock);
		rcu_read_unlock();
		local_irq_restore(*flags);
1305 1306 1307 1308 1309
	}

	return sighand;
}

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

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

1321 1322
	if (!ret && sig)
		ret = do_send_sig_info(sig, info, p, true);
L
Linus Torvalds 已提交
1323 1324 1325 1326 1327

	return ret;
}

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

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

1347
int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
L
Linus Torvalds 已提交
1348
{
1349
	int error = -ESRCH;
L
Linus Torvalds 已提交
1350 1351
	struct task_struct *p;

I
Ingo Molnar 已提交
1352
	rcu_read_lock();
1353
retry:
1354
	p = pid_task(pid, PIDTYPE_PID);
1355
	if (p) {
L
Linus Torvalds 已提交
1356
		error = group_send_sig_info(sig, info, p);
1357 1358 1359 1360 1361 1362 1363 1364 1365
		if (unlikely(error == -ESRCH))
			/*
			 * The task was unhashed in between, try again.
			 * If it is dead, pid_task() will return NULL,
			 * if we race with de_thread() it will find the
			 * new leader.
			 */
			goto retry;
	}
I
Ingo Molnar 已提交
1366
	rcu_read_unlock();
1367

L
Linus Torvalds 已提交
1368 1369 1370
	return error;
}

1371
int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1372 1373 1374
{
	int error;
	rcu_read_lock();
1375
	error = kill_pid_info(sig, info, find_vpid(pid));
1376 1377 1378 1379
	rcu_read_unlock();
	return error;
}

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

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

	if (!valid_signal(sig))
		return ret;

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

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

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

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

	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 已提交
1451 1452 1453 1454
		int retval = 0, count = 0;
		struct task_struct * p;

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

1467
	return ret;
L
Linus Torvalds 已提交
1468 1469 1470 1471 1472 1473
}

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

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

1483
	return do_send_sig_info(sig, info, p, false);
L
Linus Torvalds 已提交
1484 1485
}

1486 1487 1488
#define __si_special(priv) \
	((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)

L
Linus Torvalds 已提交
1489 1490 1491
int
send_sig(int sig, struct task_struct *p, int priv)
{
1492
	return send_sig_info(sig, __si_special(priv), p);
L
Linus Torvalds 已提交
1493 1494 1495 1496 1497
}

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

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

1520 1521
int kill_pgrp(struct pid *pid, int sig, int priv)
{
1522 1523 1524 1525 1526 1527 1528
	int ret;

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

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

1551
	if (q)
L
Linus Torvalds 已提交
1552
		q->flags |= SIGQUEUE_PREALLOC;
1553 1554

	return q;
L
Linus Torvalds 已提交
1555 1556 1557 1558 1559
}

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

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

1578 1579
	if (q)
		__sigqueue_free(q);
L
Linus Torvalds 已提交
1580 1581
}

1582
int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1583
{
1584
	int sig = q->info.si_signo;
1585
	struct sigpending *pending;
1586
	unsigned long flags;
1587
	int ret, result;
1588

1589
	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1590 1591 1592 1593 1594

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

1595
	ret = 1; /* the signal is ignored */
1596
	result = TRACE_SIGNAL_IGNORED;
1597
	if (!prepare_signal(sig, t, false))
1598 1599 1600
		goto out;

	ret = 0;
1601 1602 1603 1604 1605 1606 1607
	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++;
1608
		result = TRACE_SIGNAL_ALREADY_PENDING;
1609
		goto out;
1610
	}
1611
	q->info.si_overrun = 0;
1612 1613

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

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

	BUG_ON(sig == -1);

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

T
Tejun Heo 已提交
1646
	BUG_ON(!tsk->ptrace &&
L
Linus Torvalds 已提交
1647 1648
	       (tsk->group_leader != tsk || !thread_group_empty(tsk)));

1649 1650 1651 1652 1653 1654 1655 1656 1657
	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 已提交
1658 1659
	info.si_signo = sig;
	info.si_errno = 0;
1660
	/*
1661 1662
	 * We are under tasklist_lock here so our parent is tied to
	 * us and cannot change.
1663
	 *
1664 1665
	 * task_active_pid_ns will always return the same pid namespace
	 * until a task passes through release_task.
1666 1667 1668 1669 1670 1671
	 *
	 * 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();
1672
	info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1673 1674
	info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
				       task_uid(tsk));
1675 1676
	rcu_read_unlock();

1677 1678 1679
	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 已提交
1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692

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

1720
	return autoreap;
L
Linus Torvalds 已提交
1721 1722
}

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

1745
	if (for_ptracer) {
1746
		parent = tsk->parent;
1747
	} else {
1748 1749 1750 1751
		tsk = tsk->group_leader;
		parent = tsk->real_parent;
	}

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

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

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

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

	return 1;
}

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

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

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

L
Linus Torvalds 已提交
1863
	/*
1864 1865 1866 1867 1868
	 * 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 已提交
1869
	 */
1870
	set_current_state(TASK_TRACED);
L
Linus Torvalds 已提交
1871 1872 1873 1874

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

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

1885
	/* any trap clears pending STOP trap, STOP trap clears NOTIFY */
1886
	task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
1887 1888
	if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
		task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
1889

1890
	/* entering a trap, clear TRAPPING */
1891
	task_clear_jobctl_trapping(current);
1892

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

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

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

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

1949 1950 1951
	/* LISTENING can be set only during STOP traps, clear it */
	current->jobctl &= ~JOBCTL_LISTENING;

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

1960
static void ptrace_do_notify(int signr, int exit_code, int why)
L
Linus Torvalds 已提交
1961 1962 1963 1964
{
	siginfo_t info;

	memset(&info, 0, sizeof info);
1965
	info.si_signo = signr;
L
Linus Torvalds 已提交
1966
	info.si_code = exit_code;
1967
	info.si_pid = task_pid_vnr(current);
1968
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
L
Linus Torvalds 已提交
1969 1970

	/* Let the debugger run.  */
1971 1972 1973 1974 1975 1976
	ptrace_stop(exit_code, why, 1, &info);
}

void ptrace_notify(int exit_code)
{
	BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1977 1978
	if (unlikely(current->task_works))
		task_work_run();
1979

L
Linus Torvalds 已提交
1980
	spin_lock_irq(&current->sighand->siglock);
1981
	ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
L
Linus Torvalds 已提交
1982 1983 1984
	spin_unlock_irq(&current->sighand->siglock);
}

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

2012 2013
	if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
		unsigned int gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
2014 2015
		struct task_struct *t;

2016 2017
		/* signr will be recorded in task->jobctl for retries */
		WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
2018

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

2044 2045 2046 2047
		sig->group_stop_count = 0;

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

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

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

2070 2071 2072 2073 2074 2075 2076 2077
		/*
		 * 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;

2078
		__set_current_state(TASK_STOPPED);
2079 2080
		spin_unlock_irq(&current->sighand->siglock);

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

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

2109 2110 2111
/**
 * do_jobctl_trap - take care of ptrace jobctl traps
 *
2112 2113 2114 2115 2116 2117 2118
 * 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.
2119 2120 2121 2122 2123 2124 2125
 *
 * 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)
{
2126
	struct signal_struct *signal = current->signal;
2127
	int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2128

2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139
	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;
2140
	}
L
Linus Torvalds 已提交
2141 2142
}

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

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

	current->exit_code = 0;

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

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

	return signr;
}

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

2198 2199
	if (unlikely(current->task_works))
		task_work_run();
2200

2201 2202 2203
	if (unlikely(uprobe_deny_signal()))
		return 0;

2204
	/*
2205 2206 2207
	 * 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.
2208
	 */
2209 2210
	try_to_freeze();

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

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

2226
		signal->flags &= ~SIGNAL_CLD_MASK;
2227

2228
		spin_unlock_irq(&sighand->siglock);
R
Roland McGrath 已提交
2229

2230 2231 2232 2233 2234 2235 2236 2237
		/*
		 * 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.
		 */
2238
		read_lock(&tasklist_lock);
2239 2240
		do_notify_parent_cldstop(current, false, why);

2241 2242 2243
		if (ptrace_reparented(current->group_leader))
			do_notify_parent_cldstop(current->group_leader,
						true, why);
2244
		read_unlock(&tasklist_lock);
2245

2246 2247 2248
		goto relock;
	}

L
Linus Torvalds 已提交
2249 2250
	for (;;) {
		struct k_sigaction *ka;
2251

2252 2253
		if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
		    do_signal_stop(0))
2254
			goto relock;
2255

2256 2257 2258 2259 2260
		if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
			do_jobctl_trap();
			spin_unlock_irq(&sighand->siglock);
			goto relock;
		}
L
Linus Torvalds 已提交
2261

2262
		signr = dequeue_signal(current, &current->blocked, info);
2263

2264 2265
		if (!signr)
			break; /* will return 0 */
2266

2267
		if (unlikely(current->ptrace) && signr != SIGKILL) {
2268
			signr = ptrace_signal(signr, info);
2269 2270
			if (!signr)
				continue;
L
Linus Torvalds 已提交
2271 2272
		}

2273 2274
		ka = &sighand->action[signr-1];

2275 2276 2277
		/* Trace actually delivered signals. */
		trace_signal_deliver(signr, info, ka);

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

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

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

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

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

				/* signals can be posted during this window */

2326
				if (is_current_pgrp_orphaned())
L
Linus Torvalds 已提交
2327 2328
					goto relock;

2329
				spin_lock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2330 2331
			}

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

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

2344
		spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2345 2346 2347 2348 2349

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

L
Linus Torvalds 已提交
2351
		if (sig_kernel_coredump(signr)) {
2352
			if (print_fatal_signals)
2353
				print_fatal_signal(info->si_signo);
L
Linus Torvalds 已提交
2354 2355 2356 2357 2358 2359 2360 2361
			/*
			 * 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.
			 */
2362
			do_coredump(info);
L
Linus Torvalds 已提交
2363 2364 2365 2366 2367
		}

		/*
		 * Death signals, no core dump.
		 */
2368
		do_group_exit(info->si_signo);
L
Linus Torvalds 已提交
2369 2370
		/* NOTREACHED */
	}
2371
	spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
2372 2373 2374
	return signr;
}

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

2393 2394 2395 2396 2397 2398
	/* 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();

2399 2400
	sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask);
	if (!(ka->sa.sa_flags & SA_NODEFER))
A
Al Viro 已提交
2401
		sigaddset(&blocked, sig);
2402
	set_current_blocked(&blocked);
A
Al Viro 已提交
2403
	tracehook_signal_handler(sig, info, ka, regs, stepping);
2404 2405
}

A
Al Viro 已提交
2406 2407 2408 2409 2410 2411 2412 2413 2414
void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
{
	if (failed)
		force_sigsegv(ksig->sig, current);
	else
		signal_delivered(ksig->sig, &ksig->info, &ksig->ka,
			signal_pt_regs(), stepping);
}

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

2425 2426 2427 2428
	sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
	if (sigisemptyset(&retarget))
		return;

2429 2430
	t = tsk;
	while_each_thread(tsk, t) {
2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443
		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;
2444 2445 2446
	}
}

2447 2448 2449
void exit_signals(struct task_struct *tsk)
{
	int group_stop = 0;
2450
	sigset_t unblocked;
2451

2452 2453 2454 2455 2456 2457
	/*
	 * @tsk is about to have PF_EXITING set - lock out users which
	 * expect stable threadgroup.
	 */
	threadgroup_change_begin(tsk);

2458 2459
	if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
		tsk->flags |= PF_EXITING;
2460
		threadgroup_change_end(tsk);
2461
		return;
2462 2463
	}

2464
	spin_lock_irq(&tsk->sighand->siglock);
2465 2466 2467 2468 2469
	/*
	 * From now this task is not visible for group-wide signals,
	 * see wants_signal(), do_signal_stop().
	 */
	tsk->flags |= PF_EXITING;
2470 2471 2472

	threadgroup_change_end(tsk);

2473 2474 2475
	if (!signal_pending(tsk))
		goto out;

2476 2477 2478
	unblocked = tsk->blocked;
	signotset(&unblocked);
	retarget_shared_pending(tsk, &unblocked);
2479

2480
	if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2481
	    task_participate_group_stop(tsk))
2482
		group_stop = CLD_STOPPED;
2483
out:
2484 2485
	spin_unlock_irq(&tsk->sighand->siglock);

2486 2487 2488 2489
	/*
	 * If group stop has completed, deliver the notification.  This
	 * should always go to the real parent of the group leader.
	 */
2490
	if (unlikely(group_stop)) {
2491
		read_lock(&tasklist_lock);
2492
		do_notify_parent_cldstop(tsk, false, group_stop);
2493 2494 2495 2496
		read_unlock(&tasklist_lock);
	}
}

L
Linus Torvalds 已提交
2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511
EXPORT_SYMBOL(recalc_sigpending);
EXPORT_SYMBOL_GPL(dequeue_signal);
EXPORT_SYMBOL(flush_signals);
EXPORT_SYMBOL(force_sig);
EXPORT_SYMBOL(send_sig);
EXPORT_SYMBOL(send_sig_info);
EXPORT_SYMBOL(sigprocmask);
EXPORT_SYMBOL(block_all_signals);
EXPORT_SYMBOL(unblock_all_signals);


/*
 * System call entry points.
 */

2512 2513 2514
/**
 *  sys_restart_syscall - restart a system call
 */
2515
SYSCALL_DEFINE0(restart_syscall)
L
Linus Torvalds 已提交
2516 2517 2518 2519 2520 2521 2522 2523 2524 2525
{
	struct restart_block *restart = &current_thread_info()->restart_block;
	return restart->fn(restart);
}

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

2526 2527 2528 2529 2530
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. */
2531
		sigandnsets(&newblocked, newset, &current->blocked);
2532 2533 2534 2535 2536 2537
		retarget_shared_pending(tsk, &newblocked);
	}
	tsk->blocked = *newset;
	recalc_sigpending();
}

2538 2539 2540 2541 2542 2543
/**
 * 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 已提交
2544
 */
2545 2546 2547
void set_current_blocked(sigset_t *newset)
{
	sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2548
	__set_current_blocked(newset);
2549 2550 2551
}

void __set_current_blocked(const sigset_t *newset)
2552 2553 2554 2555
{
	struct task_struct *tsk = current;

	spin_lock_irq(&tsk->sighand->siglock);
2556
	__set_task_blocked(tsk, newset);
2557 2558
	spin_unlock_irq(&tsk->sighand->siglock);
}
L
Linus Torvalds 已提交
2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569

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

2573
	/* Lockless, only current can change ->blocked, never from irq */
2574
	if (oldset)
2575
		*oldset = tsk->blocked;
2576

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

2591
	__set_current_blocked(&newset);
2592
	return 0;
L
Linus Torvalds 已提交
2593 2594
}

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

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

2612 2613 2614 2615 2616
	old_set = current->blocked;

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

2619
		error = sigprocmask(how, &new_set, NULL);
L
Linus Torvalds 已提交
2620
		if (error)
2621 2622
			return error;
	}
L
Linus Torvalds 已提交
2623

2624 2625 2626
	if (oset) {
		if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
			return -EFAULT;
L
Linus Torvalds 已提交
2627
	}
2628 2629

	return 0;
L
Linus Torvalds 已提交
2630 2631
}

2632 2633 2634
#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 已提交
2635
{
2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659
#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 已提交
2660
		if (copy_to_user(oset, &old32, sizeof(compat_sigset_t)))
2661 2662 2663 2664 2665 2666 2667 2668 2669
			return -EFAULT;
	}
	return 0;
#else
	return sys_rt_sigprocmask(how, (sigset_t __user *)nset,
				  (sigset_t __user *)oset, sigsetsize);
#endif
}
#endif
L
Linus Torvalds 已提交
2670

2671
static int do_sigpending(void *set, unsigned long sigsetsize)
L
Linus Torvalds 已提交
2672 2673
{
	if (sigsetsize > sizeof(sigset_t))
2674
		return -EINVAL;
L
Linus Torvalds 已提交
2675 2676

	spin_lock_irq(&current->sighand->siglock);
2677
	sigorsets(set, &current->pending.signal,
L
Linus Torvalds 已提交
2678 2679 2680 2681
		  &current->signal->shared_pending.signal);
	spin_unlock_irq(&current->sighand->siglock);

	/* Outside the lock because only this thread touches it.  */
2682 2683
	sigandsets(set, &current->blocked, set);
	return 0;
2684
}
L
Linus Torvalds 已提交
2685

2686 2687 2688
/**
 *  sys_rt_sigpending - examine a pending signal that has been raised
 *			while blocked
2689
 *  @uset: stores pending signals
2690 2691
 *  @sigsetsize: size of sigset_t type or larger
 */
2692
SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
L
Linus Torvalds 已提交
2693
{
2694 2695 2696 2697 2698 2699 2700 2701 2702 2703
	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 已提交
2704
{
2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718
#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 已提交
2719
}
2720
#endif
L
Linus Torvalds 已提交
2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735

#ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER

int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
{
	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.
2736 2737
	 * Please remember to update the signalfd_copyinfo() function
	 * inside fs/signalfd.c too, in case siginfo_t changes.
L
Linus Torvalds 已提交
2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762
	 * 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);
2763 2764
#endif
#ifdef BUS_MCEERR_AO
2765
		/*
2766
		 * Other callers might not initialize the si_lsb field,
2767
		 * so check explicitly for the right codes here.
2768 2769 2770
		 */
		if (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO)
			err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
L
Linus Torvalds 已提交
2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785
#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;
2786 2787 2788 2789 2790 2791 2792
#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 已提交
2793 2794 2795 2796 2797 2798 2799 2800 2801 2802
	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

2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840
/**
 *  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
2841 2842
		 * they arrive. Unblocking is always fine, we can avoid
		 * set_current_blocked().
2843 2844 2845 2846 2847 2848 2849 2850 2851
		 */
		tsk->real_blocked = tsk->blocked;
		sigandsets(&tsk->blocked, &tsk->blocked, &mask);
		recalc_sigpending();
		spin_unlock_irq(&tsk->sighand->siglock);

		timeout = schedule_timeout_interruptible(timeout);

		spin_lock_irq(&tsk->sighand->siglock);
2852
		__set_task_blocked(tsk, &tsk->real_blocked);
2853
		siginitset(&tsk->real_blocked, 0);
2854
		sig = dequeue_signal(tsk, &mask, info);
2855 2856 2857 2858 2859 2860 2861 2862
	}
	spin_unlock_irq(&tsk->sighand->siglock);

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

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

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

L
Linus Torvalds 已提交
2887 2888 2889 2890 2891
	if (uts) {
		if (copy_from_user(&ts, uts, sizeof(ts)))
			return -EFAULT;
	}

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

2894 2895 2896
	if (ret > 0 && uinfo) {
		if (copy_siginfo_to_user(uinfo, &info))
			ret = -EFAULT;
L
Linus Torvalds 已提交
2897 2898 2899 2900 2901
	}

	return ret;
}

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

	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_USER;
2914
	info.si_pid = task_tgid_vnr(current);
2915
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
L
Linus Torvalds 已提交
2916 2917 2918 2919

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

T
Thomas Gleixner 已提交
2920 2921
static int
do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
L
Linus Torvalds 已提交
2922 2923
{
	struct task_struct *p;
T
Thomas Gleixner 已提交
2924
	int error = -ESRCH;
L
Linus Torvalds 已提交
2925

2926
	rcu_read_lock();
2927
	p = find_task_by_vpid(pid);
2928
	if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
T
Thomas Gleixner 已提交
2929
		error = check_kill_permission(sig, info, p);
L
Linus Torvalds 已提交
2930 2931 2932 2933
		/*
		 * The null signal is a permissions and process existence
		 * probe.  No signal is actually delivered.
		 */
2934 2935 2936 2937 2938 2939 2940 2941 2942
		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 已提交
2943 2944
		}
	}
2945
	rcu_read_unlock();
2946

L
Linus Torvalds 已提交
2947 2948 2949
	return error;
}

T
Thomas Gleixner 已提交
2950 2951
static int do_tkill(pid_t tgid, pid_t pid, int sig)
{
2952
	struct siginfo info = {};
T
Thomas Gleixner 已提交
2953 2954 2955 2956 2957

	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_TKILL;
	info.si_pid = task_tgid_vnr(current);
2958
	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
T
Thomas Gleixner 已提交
2959 2960 2961 2962

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

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

	return do_tkill(tgid, pid, sig);
}

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

2995
	return do_tkill(0, pid, sig);
L
Linus Torvalds 已提交
2996 2997
}

2998 2999 3000 3001 3002
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.
	 */
3003 3004
	if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
	    (task_pid_vnr(current) != pid)) {
3005 3006 3007 3008 3009 3010 3011 3012 3013 3014
		/* We used to allow any < 0 si_code */
		WARN_ON_ONCE(info->si_code < 0);
		return -EPERM;
	}
	info->si_signo = sig;

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

3015 3016 3017 3018 3019 3020
/**
 *  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
 */
3021 3022
SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
		siginfo_t __user *, uinfo)
L
Linus Torvalds 已提交
3023 3024 3025 3026
{
	siginfo_t info;
	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
		return -EFAULT;
3027 3028
	return do_rt_sigqueueinfo(pid, sig, &info);
}
L
Linus Torvalds 已提交
3029

3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
			compat_pid_t, pid,
			int, sig,
			struct compat_siginfo __user *, uinfo)
{
	siginfo_t info;
	int ret = copy_siginfo_from_user32(&info, uinfo);
	if (unlikely(ret))
		return ret;
	return do_rt_sigqueueinfo(pid, sig, &info);
L
Linus Torvalds 已提交
3041
}
3042
#endif
L
Linus Torvalds 已提交
3043

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

3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
			compat_pid_t, tgid,
			compat_pid_t, pid,
			int, sig,
			struct compat_siginfo __user *, uinfo)
{
	siginfo_t info;

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

3090
int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
L
Linus Torvalds 已提交
3091
{
3092
	struct task_struct *t = current;
L
Linus Torvalds 已提交
3093
	struct k_sigaction *k;
3094
	sigset_t mask;
L
Linus Torvalds 已提交
3095

3096
	if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
L
Linus Torvalds 已提交
3097 3098
		return -EINVAL;

3099
	k = &t->sighand->action[sig-1];
L
Linus Torvalds 已提交
3100 3101 3102 3103 3104 3105

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

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

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

A
Al Viro 已提交
3135
static int 
L
Linus Torvalds 已提交
3136 3137 3138 3139 3140
do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
{
	stack_t oss;
	int error;

3141 3142 3143
	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 已提交
3144 3145 3146 3147 3148 3149 3150

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

		error = -EFAULT;
3151 3152 3153 3154 3155 3156
		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 已提交
3157 3158 3159 3160 3161 3162 3163 3164
			goto out;

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

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

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

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

3187
	error = 0;
L
Linus Torvalds 已提交
3188 3189
	if (uoss) {
		error = -EFAULT;
3190
		if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
L
Linus Torvalds 已提交
3191
			goto out;
3192 3193 3194
		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 已提交
3195 3196 3197 3198 3199
	}

out:
	return error;
}
3200 3201 3202 3203
SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
{
	return do_sigaltstack(uss, uoss, current_user_stack_pointer());
}
L
Linus Torvalds 已提交
3204

A
Al Viro 已提交
3205 3206 3207 3208 3209 3210 3211
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;
}

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

3220
#ifdef CONFIG_COMPAT
3221 3222 3223
COMPAT_SYSCALL_DEFINE2(sigaltstack,
			const compat_stack_t __user *, uss_ptr,
			compat_stack_t __user *, uoss_ptr)
3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260
{
	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;
}
3261 3262 3263 3264 3265 3266 3267 3268

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);
}
3269
#endif
L
Linus Torvalds 已提交
3270 3271 3272

#ifdef __ARCH_WANT_SYS_SIGPENDING

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

#endif

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

3295
SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
3296
		old_sigset_t __user *, oset)
L
Linus Torvalds 已提交
3297 3298
{
	old_sigset_t old_set, new_set;
3299
	sigset_t new_blocked;
L
Linus Torvalds 已提交
3300

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

3303 3304 3305
	if (nset) {
		if (copy_from_user(&new_set, nset, sizeof(*nset)))
			return -EFAULT;
L
Linus Torvalds 已提交
3306

3307
		new_blocked = current->blocked;
L
Linus Torvalds 已提交
3308 3309 3310

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

3323
		set_current_blocked(&new_blocked);
3324 3325 3326
	}

	if (oset) {
L
Linus Torvalds 已提交
3327
		if (copy_to_user(oset, &old_set, sizeof(*oset)))
3328
			return -EFAULT;
L
Linus Torvalds 已提交
3329
	}
3330 3331

	return 0;
L
Linus Torvalds 已提交
3332 3333 3334
}
#endif /* __ARCH_WANT_SYS_SIGPROCMASK */

3335
#ifndef CONFIG_ODD_RT_SIGACTION
3336 3337 3338
/**
 *  sys_rt_sigaction - alter an action taken by a process
 *  @sig: signal to be sent
3339 3340
 *  @act: new sigaction
 *  @oact: used to save the previous sigaction
3341 3342
 *  @sigsetsize: size of sigset_t type
 */
3343 3344 3345 3346
SYSCALL_DEFINE4(rt_sigaction, int, sig,
		const struct sigaction __user *, act,
		struct sigaction __user *, oact,
		size_t, sigsetsize)
L
Linus Torvalds 已提交
3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368
{
	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;
}
3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415
#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));
		ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
		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));
		ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
#ifdef __ARCH_HAS_SA_RESTORER
		ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
				&oact->sa_restorer);
#endif
	}
	return ret;
}
#endif
3416
#endif /* !CONFIG_ODD_RT_SIGACTION */
L
Linus Torvalds 已提交
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 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494
#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 已提交
3495 3496 3497 3498 3499 3500

#ifdef __ARCH_WANT_SYS_SGETMASK

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

3507
SYSCALL_DEFINE1(ssetmask, int, newmask)
L
Linus Torvalds 已提交
3508
{
3509 3510
	int old = current->blocked.sig[0];
	sigset_t newset;
L
Linus Torvalds 已提交
3511

3512
	siginitset(&newset, newmask);
3513
	set_current_blocked(&newset);
L
Linus Torvalds 已提交
3514 3515 3516 3517 3518 3519 3520 3521 3522

	return old;
}
#endif /* __ARCH_WANT_SGETMASK */

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

	new_sa.sa.sa_handler = handler;
	new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
3530
	sigemptyset(&new_sa.sa.sa_mask);
L
Linus Torvalds 已提交
3531 3532 3533 3534 3535 3536 3537 3538 3539

	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

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

#endif

A
Al Viro 已提交
3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561
int sigsuspend(sigset_t *set)
{
	current->saved_sigmask = current->blocked;
	set_current_blocked(set);

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

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

3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618
#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
3619

3620 3621 3622 3623 3624
__attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
{
	return NULL;
}

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

#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 */
反馈
建议
客服 返回
顶部