signal.c 67.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 *  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>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <linux/tty.h>
#include <linux/binfmts.h>
#include <linux/security.h>
#include <linux/syscalls.h>
#include <linux/ptrace.h>
23
#include <linux/signal.h>
24
#include <linux/signalfd.h>
25
#include <linux/tracehook.h>
26
#include <linux/capability.h>
27
#include <linux/freezer.h>
28 29
#include <linux/pid_namespace.h>
#include <linux/nsproxy.h>
30
#include <trace/events/sched.h>
31

L
Linus Torvalds 已提交
32 33 34 35
#include <asm/param.h>
#include <asm/uaccess.h>
#include <asm/unistd.h>
#include <asm/siginfo.h>
36
#include "audit.h"	/* audit_signal_info() */
L
Linus Torvalds 已提交
37 38 39 40 41

/*
 * SLAB caches for signal bits.
 */

42
static struct kmem_cache *sigqueue_cachep;
L
Linus Torvalds 已提交
43

44
static void __user *sig_handler(struct task_struct *t, int sig)
45
{
46 47
	return t->sighand->action[sig - 1].sa.sa_handler;
}
48

49 50
static int sig_handler_ignored(void __user *handler, int sig)
{
51 52 53 54
	/* Is it explicitly or implicitly ignored? */
	return handler == SIG_IGN ||
		(handler == SIG_DFL && sig_kernel_ignore(sig));
}
L
Linus Torvalds 已提交
55

56 57
static int sig_task_ignored(struct task_struct *t, int sig,
		int from_ancestor_ns)
L
Linus Torvalds 已提交
58
{
59
	void __user *handler;
L
Linus Torvalds 已提交
60

61 62 63
	handler = sig_handler(t, sig);

	if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
64
			handler == SIG_DFL && !from_ancestor_ns)
65 66 67 68 69
		return 1;

	return sig_handler_ignored(handler, sig);
}

70
static int sig_ignored(struct task_struct *t, int sig, int from_ancestor_ns)
71
{
L
Linus Torvalds 已提交
72 73 74 75 76
	/*
	 * Blocked signals are never ignored, since the
	 * signal handler may change by the time it is
	 * unblocked.
	 */
77
	if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
L
Linus Torvalds 已提交
78 79
		return 0;

80
	if (!sig_task_ignored(t, sig, from_ancestor_ns))
81 82 83 84 85
		return 0;

	/*
	 * Tracers may want to know about even ignored signals.
	 */
86
	return !tracehook_consider_ignored_signal(t, sig);
L
Linus Torvalds 已提交
87 88 89 90 91 92 93 94 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
}

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

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

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

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

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

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

R
Roland McGrath 已提交
121
static int recalc_sigpending_tsk(struct task_struct *t)
L
Linus Torvalds 已提交
122 123 124
{
	if (t->signal->group_stop_count > 0 ||
	    PENDING(&t->pending, &t->blocked) ||
R
Roland McGrath 已提交
125
	    PENDING(&t->signal->shared_pending, &t->blocked)) {
L
Linus Torvalds 已提交
126
		set_tsk_thread_flag(t, TIF_SIGPENDING);
R
Roland McGrath 已提交
127 128
		return 1;
	}
129 130 131 132 133
	/*
	 * We must never clear the flag in another thread, or in current
	 * when it's possible the current syscall is returning -ERESTART*.
	 * So we don't clear it here, and only callers who know they should do.
	 */
R
Roland McGrath 已提交
134 135 136 137 138 139 140 141 142 143 144
	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 已提交
145 146 147 148
}

void recalc_sigpending(void)
{
149 150 151
	if (unlikely(tracehook_force_sigpending()))
		set_thread_flag(TIF_SIGPENDING);
	else if (!recalc_sigpending_tsk(current) && !freezing(current))
152 153
		clear_thread_flag(TIF_SIGPENDING);

L
Linus Torvalds 已提交
154 155 156 157
}

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

158
int next_signal(struct sigpending *pending, sigset_t *mask)
L
Linus Torvalds 已提交
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
{
	unsigned long i, *s, *m, x;
	int sig = 0;
	
	s = pending->signal.sig;
	m = mask->sig;
	switch (_NSIG_WORDS) {
	default:
		for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
			if ((x = *s &~ *m) != 0) {
				sig = ffz(~x) + i*_NSIG_BPW + 1;
				break;
			}
		break;

	case 2: if ((x = s[0] &~ m[0]) != 0)
			sig = 1;
		else if ((x = s[1] &~ m[1]) != 0)
			sig = _NSIG_BPW + 1;
		else
			break;
		sig += ffz(~x);
		break;

	case 1: if ((x = *s &~ *m) != 0)
			sig = ffz(~x) + 1;
		break;
	}
	
	return sig;
}

191 192 193
/*
 * allocate a new signal queue record
 * - this may be called without locks if and only if t == current, otherwise an
D
David Howells 已提交
194
 *   appopriate lock must be held to stop the target task from exiting
195
 */
A
Al Viro 已提交
196
static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
L
Linus Torvalds 已提交
197 198 199
					 int override_rlimit)
{
	struct sigqueue *q = NULL;
200
	struct user_struct *user;
L
Linus Torvalds 已提交
201

202
	/*
203 204 205 206
	 * We won't get problems with the target's UID changing under us
	 * because changing it requires RCU be used, and if t != current, the
	 * caller must be holding the RCU readlock (by way of a spinlock) and
	 * we use RCU protection here
207
	 */
D
David Howells 已提交
208
	user = get_uid(__task_cred(t)->user);
209
	atomic_inc(&user->sigpending);
L
Linus Torvalds 已提交
210
	if (override_rlimit ||
211
	    atomic_read(&user->sigpending) <=
L
Linus Torvalds 已提交
212 213 214
			t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
		q = kmem_cache_alloc(sigqueue_cachep, flags);
	if (unlikely(q == NULL)) {
215
		atomic_dec(&user->sigpending);
D
David Howells 已提交
216
		free_uid(user);
L
Linus Torvalds 已提交
217 218 219
	} else {
		INIT_LIST_HEAD(&q->list);
		q->flags = 0;
D
David Howells 已提交
220
		q->user = user;
L
Linus Torvalds 已提交
221
	}
D
David Howells 已提交
222 223

	return q;
L
Linus Torvalds 已提交
224 225
}

226
static void __sigqueue_free(struct sigqueue *q)
L
Linus Torvalds 已提交
227 228 229 230 231 232 233 234
{
	if (q->flags & SIGQUEUE_PREALLOC)
		return;
	atomic_dec(&q->user->sigpending);
	free_uid(q->user);
	kmem_cache_free(sigqueue_cachep, q);
}

235
void flush_sigqueue(struct sigpending *queue)
L
Linus Torvalds 已提交
236 237 238 239 240 241 242 243 244 245 246 247 248 249
{
	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.
 */
250 251 252 253 254 255 256
void __flush_signals(struct task_struct *t)
{
	clear_tsk_thread_flag(t, TIF_SIGPENDING);
	flush_sigqueue(&t->pending);
	flush_sigqueue(&t->signal->shared_pending);
}

257
void flush_signals(struct task_struct *t)
L
Linus Torvalds 已提交
258 259 260 261
{
	unsigned long flags;

	spin_lock_irqsave(&t->sighand->siglock, flags);
262
	__flush_signals(t);
L
Linus Torvalds 已提交
263 264 265
	spin_unlock_irqrestore(&t->sighand->siglock, flags);
}

266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
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);
}

300 301 302 303 304 305 306 307 308 309
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 已提交
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
/*
 * 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;
		sigemptyset(&ka->sa.sa_mask);
		ka++;
	}
}

328 329
int unhandled_signal(struct task_struct *tsk, int sig)
{
330
	void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
331
	if (is_global_init(tsk))
332
		return 1;
333
	if (handler != SIG_IGN && handler != SIG_DFL)
334
		return 0;
335
	return !tracehook_consider_fatal_signal(tsk, sig);
336 337
}

L
Linus Torvalds 已提交
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372

/* Notify the system that a driver wants to block all signals for this
 * 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
 * can use to determine if the signal should be blocked or not.  */

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

373
static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
L
Linus Torvalds 已提交
374 375 376 377 378 379 380 381 382
{
	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) {
383 384
			if (first)
				goto still_pending;
L
Linus Torvalds 已提交
385 386 387
			first = q;
		}
	}
388 389 390

	sigdelset(&list->signal, sig);

L
Linus Torvalds 已提交
391
	if (first) {
392
still_pending:
L
Linus Torvalds 已提交
393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
		list_del_init(&first->list);
		copy_siginfo(info, &first->info);
		__sigqueue_free(first);
	} else {
		/* 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.
		 */
		info->si_signo = sig;
		info->si_errno = 0;
		info->si_code = 0;
		info->si_pid = 0;
		info->si_uid = 0;
	}
}

static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
			siginfo_t *info)
{
412
	int sig = next_signal(pending, mask);
L
Linus Torvalds 已提交
413 414 415 416 417 418 419 420 421 422 423

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

424
		collect_signal(sig, pending, info);
L
Linus Torvalds 已提交
425 426 427 428 429 430 431 432 433 434 435 436 437
	}

	return sig;
}

/*
 * Dequeue a signal and return the element to the caller, which is 
 * expected to free it.
 *
 * All callers have to hold the siglock.
 */
int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
{
438
	int signr;
439 440 441 442

	/* We only dequeue private signals from ourselves, we don't let
	 * signalfd steal them
	 */
D
Davide Libenzi 已提交
443
	signr = __dequeue_signal(&tsk->pending, mask, info);
444
	if (!signr) {
L
Linus Torvalds 已提交
445 446
		signr = __dequeue_signal(&tsk->signal->shared_pending,
					 mask, info);
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470
		/*
		 * 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
		 * compliant with the old way of self restarting
		 * 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);
			}
		}
	}
471

D
Davide Libenzi 已提交
472
	recalc_sigpending();
473 474 475 476
	if (!signr)
		return 0;

	if (unlikely(sig_kernel_stop(signr))) {
477 478 479 480 481 482 483 484 485 486 487 488
		/*
		 * 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.
		 */
489
		tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
490
	}
491
	if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
L
Linus Torvalds 已提交
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
		/*
		 * 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
 */
void signal_wake_up(struct task_struct *t, int resume)
{
	unsigned int mask;

	set_tsk_thread_flag(t, TIF_SIGPENDING);

	/*
M
Matthew Wilcox 已提交
523 524
	 * For SIGKILL, we want to wake it up in the stopped/traced/killable
	 * case. We don't check t->state here because there is a race with it
L
Linus Torvalds 已提交
525 526 527 528 529 530
	 * 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.
	 */
	mask = TASK_INTERRUPTIBLE;
	if (resume)
M
Matthew Wilcox 已提交
531
		mask |= TASK_WAKEKILL;
L
Linus Torvalds 已提交
532 533 534 535
	if (!wake_up_state(t, mask))
		kick_process(t);
}

536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
/*
 * 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;

	signandsets(&s->signal, &s->signal, mask);
	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 已提交
563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
/*
 * 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;
}

/*
 * Bad permissions for sending the signal
589
 * - the caller must hold at least the RCU read lock
L
Linus Torvalds 已提交
590 591 592 593
 */
static int check_kill_permission(int sig, struct siginfo *info,
				 struct task_struct *t)
{
594
	const struct cred *cred = current_cred(), *tcred;
595
	struct pid *sid;
596 597
	int error;

598
	if (!valid_signal(sig))
599 600 601 602
		return -EINVAL;

	if (info != SEND_SIG_NOINFO && (is_si_special(info) || SI_FROMKERNEL(info)))
		return 0;
A
Amy Griffis 已提交
603

604 605
	error = audit_signal_info(sig, t); /* Let audit system see the signal */
	if (error)
L
Linus Torvalds 已提交
606
		return error;
607

608 609 610 611 612
	tcred = __task_cred(t);
	if ((cred->euid ^ tcred->suid) &&
	    (cred->euid ^ tcred->uid) &&
	    (cred->uid  ^ tcred->suid) &&
	    (cred->uid  ^ tcred->uid) &&
613 614 615 616 617 618 619 620 621 622 623 624 625 626
	    !capable(CAP_KILL)) {
		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;
		}
	}
627

A
Amy Griffis 已提交
628
	return security_task_kill(t, info, sig, 0);
L
Linus Torvalds 已提交
629 630 631
}

/*
632 633
 * Handle magic process-wide effects of stop/continue signals. Unlike
 * the signal actions, these happen immediately at signal-generation
L
Linus Torvalds 已提交
634 635
 * time regardless of blocking, ignoring, or handling.  This does the
 * actual continuing for SIGCONT, but not the actual stopping for stop
636 637 638 639
 * 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 已提交
640
 */
641
static int prepare_signal(int sig, struct task_struct *p, int from_ancestor_ns)
L
Linus Torvalds 已提交
642
{
643
	struct signal_struct *signal = p->signal;
L
Linus Torvalds 已提交
644 645
	struct task_struct *t;

646
	if (unlikely(signal->flags & SIGNAL_GROUP_EXIT)) {
L
Linus Torvalds 已提交
647
		/*
648
		 * The process is in the middle of dying, nothing to do.
L
Linus Torvalds 已提交
649
		 */
650
	} else if (sig_kernel_stop(sig)) {
L
Linus Torvalds 已提交
651 652 653
		/*
		 * This is a stop signal.  Remove SIGCONT from all queues.
		 */
654
		rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
L
Linus Torvalds 已提交
655 656 657
		t = p;
		do {
			rm_from_queue(sigmask(SIGCONT), &t->pending);
658
		} while_each_thread(p, t);
L
Linus Torvalds 已提交
659
	} else if (sig == SIGCONT) {
660
		unsigned int why;
L
Linus Torvalds 已提交
661 662 663 664
		/*
		 * Remove all stop signals from all queues,
		 * and wake all threads.
		 */
665
		rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
L
Linus Torvalds 已提交
666 667 668 669 670 671 672 673 674 675 676 677 678
		t = p;
		do {
			unsigned int state;
			rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
			/*
			 * If there is a handler for SIGCONT, we must make
			 * sure that no thread returns to user mode before
			 * we post the signal, in case it was the only
			 * thread eligible to run the signal handler--then
			 * it must not do anything between resuming and
			 * running the handler.  With the TIF_SIGPENDING
			 * flag set, the thread will pause and acquire the
			 * siglock that we hold now and until we've queued
679
			 * the pending signal.
L
Linus Torvalds 已提交
680 681 682 683
			 *
			 * Wake up the stopped thread _after_ setting
			 * TIF_SIGPENDING
			 */
M
Matthew Wilcox 已提交
684
			state = __TASK_STOPPED;
L
Linus Torvalds 已提交
685 686 687 688 689
			if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
				set_tsk_thread_flag(t, TIF_SIGPENDING);
				state |= TASK_INTERRUPTIBLE;
			}
			wake_up_state(t, state);
690
		} while_each_thread(p, t);
L
Linus Torvalds 已提交
691

692 693 694 695 696 697 698 699 700
		/*
		 * 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;
701
		if (signal->flags & SIGNAL_STOP_STOPPED)
702
			why |= SIGNAL_CLD_CONTINUED;
703
		else if (signal->group_stop_count)
704 705 706
			why |= SIGNAL_CLD_STOPPED;

		if (why) {
707 708 709 710 711
			/*
			 * The first thread which returns from finish_stop()
			 * will take ->siglock, notice SIGNAL_CLD_MASK, and
			 * notify its parent. See get_signal_to_deliver().
			 */
712 713 714
			signal->flags = why | SIGNAL_STOP_CONTINUED;
			signal->group_stop_count = 0;
			signal->group_exit_code = 0;
L
Linus Torvalds 已提交
715 716 717 718 719 720
		} else {
			/*
			 * We are not stopped, but there could be a stop
			 * signal in the middle of being processed after
			 * being removed from the queue.  Clear that too.
			 */
721
			signal->flags &= ~SIGNAL_STOP_DEQUEUED;
L
Linus Torvalds 已提交
722 723
		}
	}
724

725
	return !sig_ignored(p, sig, from_ancestor_ns);
L
Linus Torvalds 已提交
726 727
}

728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748
/*
 * 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);
}

749
static void complete_signal(int sig, struct task_struct *p, int group)
750 751 752 753 754 755 756 757 758 759 760 761
{
	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;
762
	else if (!group || thread_group_empty(p))
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789
		/*
		 * 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.
	 */
790 791
	if (sig_fatal(p, sig) &&
	    !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
792
	    !sigismember(&t->real_blocked, sig) &&
793
	    (sig == SIGKILL ||
794
	     !tracehook_consider_fatal_signal(t, sig))) {
795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824
		/*
		 * 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 {
				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;
}

825 826 827 828 829
static inline int legacy_queue(struct sigpending *signals, int sig)
{
	return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
}

830 831
static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
			int group, int from_ancestor_ns)
L
Linus Torvalds 已提交
832
{
833
	struct sigpending *pending;
834
	struct sigqueue *q;
835
	int override_rlimit;
L
Linus Torvalds 已提交
836

837 838
	trace_sched_signal_send(sig, t);

839
	assert_spin_locked(&t->sighand->siglock);
840 841

	if (!prepare_signal(sig, t, from_ancestor_ns))
842
		return 0;
843 844

	pending = group ? &t->signal->shared_pending : &t->pending;
845 846 847 848 849
	/*
	 * 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.
	 */
850
	if (legacy_queue(pending, sig))
851
		return 0;
L
Linus Torvalds 已提交
852 853 854 855
	/*
	 * fast-pathed signals for kernel-internal things like SIGSTOP
	 * or SIGKILL.
	 */
856
	if (info == SEND_SIG_FORCED)
L
Linus Torvalds 已提交
857 858 859 860 861 862 863 864 865 866
		goto out_set;

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

867 868 869 870 871 872 873
	if (sig < SIGRTMIN)
		override_rlimit = (is_si_special(info) || info->si_code >= 0);
	else
		override_rlimit = 0;

	q = __sigqueue_alloc(t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
		override_rlimit);
L
Linus Torvalds 已提交
874
	if (q) {
875
		list_add_tail(&q->list, &pending->list);
L
Linus Torvalds 已提交
876
		switch ((unsigned long) info) {
877
		case (unsigned long) SEND_SIG_NOINFO:
L
Linus Torvalds 已提交
878 879 880
			q->info.si_signo = sig;
			q->info.si_errno = 0;
			q->info.si_code = SI_USER;
881
			q->info.si_pid = task_tgid_nr_ns(current,
882
							task_active_pid_ns(t));
883
			q->info.si_uid = current_uid();
L
Linus Torvalds 已提交
884
			break;
885
		case (unsigned long) SEND_SIG_PRIV:
L
Linus Torvalds 已提交
886 887 888 889 890 891 892 893
			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);
894 895
			if (from_ancestor_ns)
				q->info.si_pid = 0;
L
Linus Torvalds 已提交
896 897
			break;
		}
898 899
	} else if (!is_si_special(info)) {
		if (sig >= SIGRTMIN && info->si_code != SI_USER)
L
Linus Torvalds 已提交
900 901 902 903 904 905 906 907
		/*
		 * Queue overflow, abort.  We may abort if the signal was rt
		 * and sent by user using something other than kill().
		 */
			return -EAGAIN;
	}

out_set:
908
	signalfd_notify(t, sig);
909
	sigaddset(&pending->signal, sig);
910 911
	complete_signal(sig, t, group);
	return 0;
L
Linus Torvalds 已提交
912 913
}

914 915 916
static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
			int group)
{
917 918 919 920 921 922 923 924 925
	int from_ancestor_ns = 0;

#ifdef CONFIG_PID_NS
	if (!is_si_special(info) && SI_FROMUSER(info) &&
			task_pid_nr_ns(current, task_active_pid_ns(t)) <= 0)
		from_ancestor_ns = 1;
#endif

	return __send_signal(sig, info, t, group, from_ancestor_ns);
926 927
}

I
Ingo Molnar 已提交
928 929 930 931 932
int print_fatal_signals;

static void print_fatal_signal(struct pt_regs *regs, int signr)
{
	printk("%s/%d: potentially unexpected fatal signal %d.\n",
933
		current->comm, task_pid_nr(current), signr);
I
Ingo Molnar 已提交
934

A
Al Viro 已提交
935
#if defined(__i386__) && !defined(__arch_um__)
936
	printk("code at %08lx: ", regs->ip);
I
Ingo Molnar 已提交
937 938 939 940 941
	{
		int i;
		for (i = 0; i < 16; i++) {
			unsigned char insn;

942
			__get_user(insn, (unsigned char *)(regs->ip + i));
I
Ingo Molnar 已提交
943 944 945 946 947
			printk("%02x ", insn);
		}
	}
#endif
	printk("\n");
948
	preempt_disable();
I
Ingo Molnar 已提交
949
	show_regs(regs);
950
	preempt_enable();
I
Ingo Molnar 已提交
951 952 953 954 955 956 957 958 959 960
}

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

962 963 964 965 966 967
int
__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
	return send_signal(sig, info, p, 1);
}

L
Linus Torvalds 已提交
968 969 970
static int
specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
971
	return send_signal(sig, info, t, 0);
L
Linus Torvalds 已提交
972 973 974 975 976
}

/*
 * Force a signal that the process can't ignore: if necessary
 * we unblock the signal and change any SIG_IGN to SIG_DFL.
977 978 979 980 981
 *
 * 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.
 *
982 983
 * We don't want to have recursive SIGSEGV's etc, for example,
 * that is why we also clear SIGNAL_UNKILLABLE.
L
Linus Torvalds 已提交
984 985 986 987 988
 */
int
force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
	unsigned long int flags;
989 990
	int ret, blocked, ignored;
	struct k_sigaction *action;
L
Linus Torvalds 已提交
991 992

	spin_lock_irqsave(&t->sighand->siglock, flags);
993 994 995 996 997 998 999
	action = &t->sighand->action[sig-1];
	ignored = action->sa.sa_handler == SIG_IGN;
	blocked = sigismember(&t->blocked, sig);
	if (blocked || ignored) {
		action->sa.sa_handler = SIG_DFL;
		if (blocked) {
			sigdelset(&t->blocked, sig);
R
Roland McGrath 已提交
1000
			recalc_sigpending_and_wake(t);
1001
		}
L
Linus Torvalds 已提交
1002
	}
1003 1004
	if (action->sa.sa_handler == SIG_DFL)
		t->signal->flags &= ~SIGNAL_UNKILLABLE;
L
Linus Torvalds 已提交
1005 1006 1007 1008 1009 1010 1011 1012 1013
	ret = specific_send_sig_info(sig, info, t);
	spin_unlock_irqrestore(&t->sighand->siglock, flags);

	return ret;
}

void
force_sig_specific(int sig, struct task_struct *t)
{
1014
	force_sig_info(sig, SEND_SIG_FORCED, t);
L
Linus Torvalds 已提交
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
}

/*
 * Nuke all other threads in the group.
 */
void zap_other_threads(struct task_struct *p)
{
	struct task_struct *t;

	p->signal->group_stop_count = 0;

	for (t = next_thread(p); t != p; t = next_thread(t)) {
		/*
		 * Don't bother with already dead threads
		 */
		if (t->exit_state)
			continue;

1033
		/* SIGKILL will be handled before any pending SIGSTOP */
L
Linus Torvalds 已提交
1034 1035 1036 1037 1038
		sigaddset(&t->pending.signal, SIGKILL);
		signal_wake_up(t, 1);
	}
}

H
Harvey Harrison 已提交
1039
int __fatal_signal_pending(struct task_struct *tsk)
M
Matthew Wilcox 已提交
1040 1041 1042
{
	return sigismember(&tsk->pending.signal, SIGKILL);
}
1043
EXPORT_SYMBOL(__fatal_signal_pending);
M
Matthew Wilcox 已提交
1044

1045 1046 1047 1048
struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
{
	struct sighand_struct *sighand;

1049
	rcu_read_lock();
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
	for (;;) {
		sighand = rcu_dereference(tsk->sighand);
		if (unlikely(sighand == NULL))
			break;

		spin_lock_irqsave(&sighand->siglock, *flags);
		if (likely(sighand == tsk->sighand))
			break;
		spin_unlock_irqrestore(&sighand->siglock, *flags);
	}
1060
	rcu_read_unlock();
1061 1062 1063 1064

	return sighand;
}

1065 1066 1067 1068
/*
 * send signal info to all the members of a group
 * - the caller must hold the RCU read lock at least
 */
L
Linus Torvalds 已提交
1069 1070 1071 1072 1073 1074
int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
	unsigned long flags;
	int ret;

	ret = check_kill_permission(sig, info, p);
1075 1076 1077 1078 1079 1080

	if (!ret && sig) {
		ret = -ESRCH;
		if (lock_task_sighand(p, &flags)) {
			ret = __group_send_sig_info(sig, info, p);
			unlock_task_sighand(p, &flags);
1081
		}
L
Linus Torvalds 已提交
1082 1083 1084 1085 1086 1087
	}

	return ret;
}

/*
1088
 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
L
Linus Torvalds 已提交
1089
 * control characters do (^C, ^Z etc)
1090
 * - the caller must hold at least a readlock on tasklist_lock
L
Linus Torvalds 已提交
1091
 */
1092
int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
L
Linus Torvalds 已提交
1093 1094 1095 1096 1097 1098
{
	struct task_struct *p = NULL;
	int retval, success;

	success = 0;
	retval = -ESRCH;
1099
	do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
L
Linus Torvalds 已提交
1100 1101 1102
		int err = group_send_sig_info(sig, info, p);
		success |= !err;
		retval = err;
1103
	} while_each_pid_task(pgrp, PIDTYPE_PGID, p);
L
Linus Torvalds 已提交
1104 1105 1106
	return success ? 0 : retval;
}

1107
int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
L
Linus Torvalds 已提交
1108
{
1109
	int error = -ESRCH;
L
Linus Torvalds 已提交
1110 1111
	struct task_struct *p;

I
Ingo Molnar 已提交
1112
	rcu_read_lock();
1113
retry:
1114
	p = pid_task(pid, PIDTYPE_PID);
1115
	if (p) {
L
Linus Torvalds 已提交
1116
		error = group_send_sig_info(sig, info, p);
1117 1118 1119 1120 1121 1122 1123 1124 1125
		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 已提交
1126
	rcu_read_unlock();
1127

L
Linus Torvalds 已提交
1128 1129 1130
	return error;
}

1131 1132
int
kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1133 1134 1135
{
	int error;
	rcu_read_lock();
1136
	error = kill_pid_info(sig, info, find_vpid(pid));
1137 1138 1139 1140
	rcu_read_unlock();
	return error;
}

1141 1142
/* like kill_pid_info(), but doesn't use uid/euid of "current" */
int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
1143
		      uid_t uid, uid_t euid, u32 secid)
1144 1145 1146
{
	int ret = -EINVAL;
	struct task_struct *p;
1147
	const struct cred *pcred;
1148 1149 1150 1151 1152

	if (!valid_signal(sig))
		return ret;

	read_lock(&tasklist_lock);
1153
	p = pid_task(pid, PIDTYPE_PID);
1154 1155 1156 1157
	if (!p) {
		ret = -ESRCH;
		goto out_unlock;
	}
1158 1159 1160 1161 1162
	pcred = __task_cred(p);
	if ((info == SEND_SIG_NOINFO ||
	     (!is_si_special(info) && SI_FROMUSER(info))) &&
	    euid != pcred->suid && euid != pcred->uid &&
	    uid  != pcred->suid && uid  != pcred->uid) {
1163 1164 1165
		ret = -EPERM;
		goto out_unlock;
	}
1166 1167 1168
	ret = security_task_kill(p, info, sig, secid);
	if (ret)
		goto out_unlock;
1169 1170 1171
	if (sig && p->sighand) {
		unsigned long flags;
		spin_lock_irqsave(&p->sighand->siglock, flags);
1172
		ret = __send_signal(sig, info, p, 1, 0);
1173 1174 1175 1176 1177 1178
		spin_unlock_irqrestore(&p->sighand->siglock, flags);
	}
out_unlock:
	read_unlock(&tasklist_lock);
	return ret;
}
1179
EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
L
Linus Torvalds 已提交
1180 1181 1182 1183 1184 1185 1186 1187

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

1188
static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
L
Linus Torvalds 已提交
1189
{
1190
	int ret;
1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203

	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 已提交
1204 1205 1206 1207
		int retval = 0, count = 0;
		struct task_struct * p;

		for_each_process(p) {
1208 1209
			if (task_pid_vnr(p) > 1 &&
					!same_thread_group(p, current)) {
L
Linus Torvalds 已提交
1210 1211 1212 1213 1214 1215
				int err = group_send_sig_info(sig, info, p);
				++count;
				if (err != -EPERM)
					retval = err;
			}
		}
1216
		ret = count ? retval : -ESRCH;
L
Linus Torvalds 已提交
1217
	}
1218 1219
	read_unlock(&tasklist_lock);

1220
	return ret;
L
Linus Torvalds 已提交
1221 1222 1223 1224 1225 1226 1227
}

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

/*
1228
 * The caller must ensure the task can't exit.
L
Linus Torvalds 已提交
1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
 */
int
send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
	int ret;
	unsigned long flags;

	/*
	 * Make sure legacy kernel users don't send in bad values
	 * (normal paths check this in check_kill_permission).
	 */
1240
	if (!valid_signal(sig))
L
Linus Torvalds 已提交
1241 1242 1243 1244 1245 1246 1247 1248
		return -EINVAL;

	spin_lock_irqsave(&p->sighand->siglock, flags);
	ret = specific_send_sig_info(sig, info, p);
	spin_unlock_irqrestore(&p->sighand->siglock, flags);
	return ret;
}

1249 1250 1251
#define __si_special(priv) \
	((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)

L
Linus Torvalds 已提交
1252 1253 1254
int
send_sig(int sig, struct task_struct *p, int priv)
{
1255
	return send_sig_info(sig, __si_special(priv), p);
L
Linus Torvalds 已提交
1256 1257 1258 1259 1260
}

void
force_sig(int sig, struct task_struct *p)
{
1261
	force_sig_info(sig, SEND_SIG_PRIV, p);
L
Linus Torvalds 已提交
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
}

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

1283 1284
int kill_pgrp(struct pid *pid, int sig, int priv)
{
1285 1286 1287 1288 1289 1290 1291
	int ret;

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

	return ret;
1292 1293 1294 1295 1296 1297 1298 1299 1300
}
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 已提交
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
/*
 * 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
 * expirations or I/O completions".  In the case of Posix Timers 
 * 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)
{
	struct sigqueue *q;

	if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
		q->flags |= SIGQUEUE_PREALLOC;
	return(q);
}

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

L
Linus Torvalds 已提交
1325 1326
	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
	/*
1327 1328
	 * We must hold ->siglock while testing q->list
	 * to serialize with collect_signal() or with
1329
	 * __exit_signal()->flush_sigqueue().
L
Linus Torvalds 已提交
1330
	 */
1331
	spin_lock_irqsave(lock, flags);
1332 1333 1334 1335 1336
	q->flags &= ~SIGQUEUE_PREALLOC;
	/*
	 * If it is queued it will be freed when dequeued,
	 * like the "regular" sigqueue.
	 */
1337
	if (!list_empty(&q->list))
1338
		q = NULL;
1339 1340
	spin_unlock_irqrestore(lock, flags);

1341 1342
	if (q)
		__sigqueue_free(q);
L
Linus Torvalds 已提交
1343 1344
}

1345
int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1346
{
1347
	int sig = q->info.si_signo;
1348
	struct sigpending *pending;
1349 1350
	unsigned long flags;
	int ret;
1351

1352
	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1353 1354 1355 1356 1357

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

1358
	ret = 1; /* the signal is ignored */
1359
	if (!prepare_signal(sig, t, 0))
1360 1361 1362
		goto out;

	ret = 0;
1363 1364 1365 1366 1367 1368 1369
	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++;
1370
		goto out;
1371
	}
1372
	q->info.si_overrun = 0;
1373 1374

	signalfd_notify(t, sig);
1375
	pending = group ? &t->signal->shared_pending : &t->pending;
1376 1377
	list_add_tail(&q->list, &pending->list);
	sigaddset(&pending->signal, sig);
1378
	complete_signal(sig, t, group);
1379 1380 1381 1382
out:
	unlock_task_sighand(t, &flags);
ret:
	return ret;
1383 1384
}

L
Linus Torvalds 已提交
1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396
/*
 * Wake up any threads in the parent blocked in wait* syscalls.
 */
static inline void __wake_up_parent(struct task_struct *p,
				    struct task_struct *parent)
{
	wake_up_interruptible_sync(&parent->signal->wait_chldexit);
}

/*
 * 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 已提交
1397 1398 1399
 *
 * Returns -1 if our parent ignored us and so we've switched to
 * self-reaping, or else @sig.
L
Linus Torvalds 已提交
1400
 */
R
Roland McGrath 已提交
1401
int do_notify_parent(struct task_struct *tsk, int sig)
L
Linus Torvalds 已提交
1402 1403 1404 1405
{
	struct siginfo info;
	unsigned long flags;
	struct sighand_struct *psig;
R
Roland McGrath 已提交
1406
	int ret = sig;
L
Linus Torvalds 已提交
1407 1408 1409 1410

	BUG_ON(sig == -1);

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

1413
	BUG_ON(!task_ptrace(tsk) &&
L
Linus Torvalds 已提交
1414 1415 1416 1417
	       (tsk->group_leader != tsk || !thread_group_empty(tsk)));

	info.si_signo = sig;
	info.si_errno = 0;
1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
	/*
	 * we are under tasklist_lock here so our parent is tied to
	 * us and cannot exit and release its namespace.
	 *
	 * the only it can is to switch its nsproxy with sys_unshare,
	 * bu uncharing pid namespaces is not allowed, so we'll always
	 * see relevant namespace
	 *
	 * 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();
	info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1432
	info.si_uid = __task_cred(tsk)->uid;
1433 1434
	rcu_read_unlock();

1435 1436 1437 1438
	info.si_utime = cputime_to_clock_t(cputime_add(tsk->utime,
				tsk->signal->utime));
	info.si_stime = cputime_to_clock_t(cputime_add(tsk->stime,
				tsk->signal->stime));
L
Linus Torvalds 已提交
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451

	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);
1452
	if (!task_ptrace(tsk) && sig == SIGCHLD &&
L
Linus Torvalds 已提交
1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469
	    (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).
		 */
R
Roland McGrath 已提交
1470
		ret = tsk->exit_signal = -1;
L
Linus Torvalds 已提交
1471
		if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
R
Roland McGrath 已提交
1472
			sig = -1;
L
Linus Torvalds 已提交
1473
	}
1474
	if (valid_signal(sig) && sig > 0)
L
Linus Torvalds 已提交
1475 1476 1477
		__group_send_sig_info(sig, &info, tsk->parent);
	__wake_up_parent(tsk, tsk->parent);
	spin_unlock_irqrestore(&psig->siglock, flags);
R
Roland McGrath 已提交
1478

R
Roland McGrath 已提交
1479
	return ret;
L
Linus Torvalds 已提交
1480 1481
}

1482
static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
L
Linus Torvalds 已提交
1483 1484 1485
{
	struct siginfo info;
	unsigned long flags;
1486
	struct task_struct *parent;
L
Linus Torvalds 已提交
1487 1488
	struct sighand_struct *sighand;

1489
	if (task_ptrace(tsk))
1490 1491 1492 1493 1494 1495
		parent = tsk->parent;
	else {
		tsk = tsk->group_leader;
		parent = tsk->real_parent;
	}

L
Linus Torvalds 已提交
1496 1497
	info.si_signo = SIGCHLD;
	info.si_errno = 0;
1498 1499 1500 1501 1502
	/*
	 * see comment in do_notify_parent() abot the following 3 lines
	 */
	rcu_read_lock();
	info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1503
	info.si_uid = __task_cred(tsk)->uid;
1504 1505
	rcu_read_unlock();

1506 1507
	info.si_utime = cputime_to_clock_t(tsk->utime);
	info.si_stime = cputime_to_clock_t(tsk->stime);
L
Linus Torvalds 已提交
1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535

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

1536 1537
static inline int may_ptrace_stop(void)
{
1538
	if (!likely(task_ptrace(current)))
1539 1540 1541 1542 1543 1544 1545
		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
1546
	 * ->siglock we must see ->core_state != NULL. Otherwise it
1547 1548
	 * is safe to enter schedule().
	 */
1549
	if (unlikely(current->mm->core_state) &&
1550 1551 1552 1553 1554 1555
	    unlikely(current->mm == current->parent->mm))
		return 0;

	return 1;
}

R
Roland McGrath 已提交
1556 1557 1558 1559 1560 1561
/*
 * Return nonzero if there is a SIGKILL that should be waking us up.
 * Called with the siglock held.
 */
static int sigkill_pending(struct task_struct *tsk)
{
1562 1563
	return	sigismember(&tsk->pending.signal, SIGKILL) ||
		sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
R
Roland McGrath 已提交
1564 1565
}

L
Linus Torvalds 已提交
1566 1567 1568 1569 1570 1571 1572 1573
/*
 * 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.
 *
1574 1575
 * 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 已提交
1576
 */
1577
static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
L
Linus Torvalds 已提交
1578
{
R
Roland McGrath 已提交
1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
	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);
1594 1595
		if (sigkill_pending(current))
			return;
R
Roland McGrath 已提交
1596 1597
	}

L
Linus Torvalds 已提交
1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608
	/*
	 * If there is a group stop in progress,
	 * we must participate in the bookkeeping.
	 */
	if (current->signal->group_stop_count > 0)
		--current->signal->group_stop_count;

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

	/* Let the debugger run.  */
1609
	__set_current_state(TASK_TRACED);
L
Linus Torvalds 已提交
1610 1611
	spin_unlock_irq(&current->sighand->siglock);
	read_lock(&tasklist_lock);
1612
	if (may_ptrace_stop()) {
1613
		do_notify_parent_cldstop(current, CLD_TRAPPED);
M
Miklos Szeredi 已提交
1614 1615 1616 1617 1618 1619 1620
		/*
		 * 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 已提交
1621
		read_unlock(&tasklist_lock);
M
Miklos Szeredi 已提交
1622
		preempt_enable_no_resched();
L
Linus Torvalds 已提交
1623 1624 1625 1626
		schedule();
	} else {
		/*
		 * By the time we got the lock, our tracer went away.
1627
		 * Don't drop the lock yet, another tracer may come.
L
Linus Torvalds 已提交
1628
		 */
1629
		__set_current_state(TASK_RUNNING);
1630 1631
		if (clear_code)
			current->exit_code = 0;
1632
		read_unlock(&tasklist_lock);
L
Linus Torvalds 已提交
1633 1634
	}

R
Roland McGrath 已提交
1635 1636 1637 1638 1639 1640 1641
	/*
	 * While in TASK_TRACED, we were considered "frozen enough".
	 * Now that we woke up, it's crucial if we're supposed to be
	 * frozen that we freeze now before running anything substantial.
	 */
	try_to_freeze();

L
Linus Torvalds 已提交
1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652
	/*
	 * 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;

	/*
	 * Queued signals ignored us while we were stopped for tracing.
	 * So check for any that we should take before resuming user mode.
1653
	 * This sets TIF_SIGPENDING, but never clears it.
L
Linus Torvalds 已提交
1654
	 */
1655
	recalc_sigpending_tsk(current);
L
Linus Torvalds 已提交
1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
}

void ptrace_notify(int exit_code)
{
	siginfo_t info;

	BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);

	memset(&info, 0, sizeof info);
	info.si_signo = SIGTRAP;
	info.si_code = exit_code;
1667
	info.si_pid = task_pid_vnr(current);
1668
	info.si_uid = current_uid();
L
Linus Torvalds 已提交
1669 1670 1671

	/* Let the debugger run.  */
	spin_lock_irq(&current->sighand->siglock);
1672
	ptrace_stop(exit_code, 1, &info);
L
Linus Torvalds 已提交
1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683
	spin_unlock_irq(&current->sighand->siglock);
}

static void
finish_stop(int stop_count)
{
	/*
	 * 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.  When ptraced, every thread reports itself.
	 */
R
Roland McGrath 已提交
1684
	if (tracehook_notify_jctl(stop_count == 0, CLD_STOPPED)) {
1685 1686 1687 1688
		read_lock(&tasklist_lock);
		do_notify_parent_cldstop(current, CLD_STOPPED);
		read_unlock(&tasklist_lock);
	}
1689

1690 1691 1692
	do {
		schedule();
	} while (try_to_freeze());
L
Linus Torvalds 已提交
1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
	/*
	 * Now we don't run again until continued.
	 */
	current->exit_code = 0;
}

/*
 * This performs the stopping for SIGSTOP and other stop signals.
 * We have to stop all threads in the thread group.
 * Returns nonzero if we've actually stopped and released the siglock.
 * Returns zero if we didn't stop and still hold the siglock.
 */
1705
static int do_signal_stop(int signr)
L
Linus Torvalds 已提交
1706 1707
{
	struct signal_struct *sig = current->signal;
1708
	int stop_count;
L
Linus Torvalds 已提交
1709 1710 1711 1712 1713 1714 1715

	if (sig->group_stop_count > 0) {
		/*
		 * There is a group stop in progress.  We don't need to
		 * start another one.
		 */
		stop_count = --sig->group_stop_count;
1716
	} else {
1717 1718
		struct task_struct *t;

1719
		if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED) ||
1720
		    unlikely(signal_group_exit(sig)))
1721
			return 0;
L
Linus Torvalds 已提交
1722 1723
		/*
		 * There is no group stop already in progress.
1724
		 * We must initiate one now.
L
Linus Torvalds 已提交
1725
		 */
1726
		sig->group_exit_code = signr;
L
Linus Torvalds 已提交
1727

1728 1729
		stop_count = 0;
		for (t = next_thread(current); t != current; t = next_thread(t))
L
Linus Torvalds 已提交
1730
			/*
1731 1732 1733
			 * 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 已提交
1734
			 */
O
Oleg Nesterov 已提交
1735
			if (!(t->flags & PF_EXITING) &&
M
Matthew Wilcox 已提交
1736
			    !task_is_stopped_or_traced(t)) {
1737 1738 1739 1740
				stop_count++;
				signal_wake_up(t, 0);
			}
		sig->group_stop_count = stop_count;
L
Linus Torvalds 已提交
1741 1742
	}

1743 1744 1745 1746 1747 1748
	if (stop_count == 0)
		sig->flags = SIGNAL_STOP_STOPPED;
	current->exit_code = sig->group_exit_code;
	__set_current_state(TASK_STOPPED);

	spin_unlock_irq(&current->sighand->siglock);
L
Linus Torvalds 已提交
1749 1750 1751 1752
	finish_stop(stop_count);
	return 1;
}

R
Roland McGrath 已提交
1753 1754 1755
static int ptrace_signal(int signr, siginfo_t *info,
			 struct pt_regs *regs, void *cookie)
{
1756
	if (!task_ptrace(current))
R
Roland McGrath 已提交
1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
		return signr;

	ptrace_signal_deliver(regs, cookie);

	/* Let the debugger run.  */
	ptrace_stop(signr, 0, info);

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

	current->exit_code = 0;

	/* 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.  */
	if (signr != info->si_signo) {
		info->si_signo = signr;
		info->si_errno = 0;
		info->si_code = SI_USER;
		info->si_pid = task_pid_vnr(current->parent);
1780
		info->si_uid = task_uid(current->parent);
R
Roland McGrath 已提交
1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791
	}

	/* 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 已提交
1792 1793 1794
int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
			  struct pt_regs *regs, void *cookie)
{
1795 1796 1797
	struct sighand_struct *sighand = current->sighand;
	struct signal_struct *signal = current->signal;
	int signr;
L
Linus Torvalds 已提交
1798

R
Roland McGrath 已提交
1799 1800 1801 1802 1803 1804 1805
relock:
	/*
	 * We'll jump back here after any time we were stopped in TASK_STOPPED.
	 * While in TASK_STOPPED, we were considered "frozen enough".
	 * Now that we woke up, it's crucial if we're supposed to be
	 * frozen that we freeze now before running anything substantial.
	 */
1806 1807
	try_to_freeze();

1808
	spin_lock_irq(&sighand->siglock);
1809 1810 1811 1812 1813
	/*
	 * 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.
	 */
1814 1815
	if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
		int why = (signal->flags & SIGNAL_STOP_CONTINUED)
1816
				? CLD_CONTINUED : CLD_STOPPED;
1817 1818
		signal->flags &= ~SIGNAL_CLD_MASK;
		spin_unlock_irq(&sighand->siglock);
1819

R
Roland McGrath 已提交
1820 1821 1822
		if (unlikely(!tracehook_notify_jctl(1, why)))
			goto relock;

1823 1824 1825 1826 1827 1828
		read_lock(&tasklist_lock);
		do_notify_parent_cldstop(current->group_leader, why);
		read_unlock(&tasklist_lock);
		goto relock;
	}

L
Linus Torvalds 已提交
1829 1830 1831
	for (;;) {
		struct k_sigaction *ka;

1832
		if (unlikely(signal->group_stop_count > 0) &&
1833
		    do_signal_stop(0))
L
Linus Torvalds 已提交
1834 1835
			goto relock;

1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848
		/*
		 * Tracing can induce an artifical signal and choose sigaction.
		 * The return value in @signr determines the default action,
		 * but @info->si_signo is the signal number we will report.
		 */
		signr = tracehook_get_signal(current, regs, info, return_ka);
		if (unlikely(signr < 0))
			goto relock;
		if (unlikely(signr != 0))
			ka = return_ka;
		else {
			signr = dequeue_signal(current, &current->blocked,
					       info);
L
Linus Torvalds 已提交
1849

R
Roland McGrath 已提交
1850
			if (!signr)
1851 1852 1853 1854 1855 1856 1857 1858 1859 1860
				break; /* will return 0 */

			if (signr != SIGKILL) {
				signr = ptrace_signal(signr, info,
						      regs, cookie);
				if (!signr)
					continue;
			}

			ka = &sighand->action[signr-1];
L
Linus Torvalds 已提交
1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880
		}

		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;

1881
		/*
1882
		 * Global init gets no signals it doesn't want.
1883 1884 1885 1886 1887 1888 1889
		 * 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.
1890
		 */
1891
		if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
1892
				!sig_kernel_only(signr))
L
Linus Torvalds 已提交
1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906
			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) {
1907
				spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
1908 1909 1910

				/* signals can be posted during this window */

1911
				if (is_current_pgrp_orphaned())
L
Linus Torvalds 已提交
1912 1913
					goto relock;

1914
				spin_lock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
1915 1916
			}

1917
			if (likely(do_signal_stop(info->si_signo))) {
L
Linus Torvalds 已提交
1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928
				/* It released the siglock.  */
				goto relock;
			}

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

1929
		spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
1930 1931 1932 1933 1934

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

L
Linus Torvalds 已提交
1936
		if (sig_kernel_coredump(signr)) {
1937
			if (print_fatal_signals)
1938
				print_fatal_signal(regs, info->si_signo);
L
Linus Torvalds 已提交
1939 1940 1941 1942 1943 1944 1945 1946
			/*
			 * 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.
			 */
1947
			do_coredump(info->si_signo, info->si_signo, regs);
L
Linus Torvalds 已提交
1948 1949 1950 1951 1952
		}

		/*
		 * Death signals, no core dump.
		 */
1953
		do_group_exit(info->si_signo);
L
Linus Torvalds 已提交
1954 1955
		/* NOTREACHED */
	}
1956
	spin_unlock_irq(&sighand->siglock);
L
Linus Torvalds 已提交
1957 1958 1959
	return signr;
}

O
Oleg Nesterov 已提交
1960 1961 1962
void exit_signals(struct task_struct *tsk)
{
	int group_stop = 0;
1963
	struct task_struct *t;
O
Oleg Nesterov 已提交
1964

1965 1966 1967
	if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
		tsk->flags |= PF_EXITING;
		return;
O
Oleg Nesterov 已提交
1968 1969
	}

1970
	spin_lock_irq(&tsk->sighand->siglock);
O
Oleg Nesterov 已提交
1971 1972 1973 1974 1975
	/*
	 * From now this task is not visible for group-wide signals,
	 * see wants_signal(), do_signal_stop().
	 */
	tsk->flags |= PF_EXITING;
1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992
	if (!signal_pending(tsk))
		goto out;

	/* It could be that __group_complete_signal() choose us to
	 * notify about group-wide signal. Another thread should be
	 * woken now to take the signal since we will not.
	 */
	for (t = tsk; (t = next_thread(t)) != tsk; )
		if (!signal_pending(t) && !(t->flags & PF_EXITING))
			recalc_sigpending_and_wake(t);

	if (unlikely(tsk->signal->group_stop_count) &&
			!--tsk->signal->group_stop_count) {
		tsk->signal->flags = SIGNAL_STOP_STOPPED;
		group_stop = 1;
	}
out:
O
Oleg Nesterov 已提交
1993 1994
	spin_unlock_irq(&tsk->sighand->siglock);

R
Roland McGrath 已提交
1995
	if (unlikely(group_stop) && tracehook_notify_jctl(1, CLD_STOPPED)) {
O
Oleg Nesterov 已提交
1996 1997 1998 1999 2000 2001
		read_lock(&tasklist_lock);
		do_notify_parent_cldstop(tsk, CLD_STOPPED);
		read_unlock(&tasklist_lock);
	}
}

L
Linus Torvalds 已提交
2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
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.
 */

2017
SYSCALL_DEFINE0(restart_syscall)
L
Linus Torvalds 已提交
2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046
{
	struct restart_block *restart = &current_thread_info()->restart_block;
	return restart->fn(restart);
}

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

/*
 * We don't need to get the kernel lock - this is all local to this
 * particular thread.. (and that's good, because this is _heavily_
 * used by various programs)
 */

/*
 * 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)
{
	int error;

	spin_lock_irq(&current->sighand->siglock);
2047 2048 2049
	if (oldset)
		*oldset = current->blocked;

L
Linus Torvalds 已提交
2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065
	error = 0;
	switch (how) {
	case SIG_BLOCK:
		sigorsets(&current->blocked, &current->blocked, set);
		break;
	case SIG_UNBLOCK:
		signandsets(&current->blocked, &current->blocked, set);
		break;
	case SIG_SETMASK:
		current->blocked = *set;
		break;
	default:
		error = -EINVAL;
	}
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);
2066

L
Linus Torvalds 已提交
2067 2068 2069
	return error;
}

2070 2071
SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, set,
		sigset_t __user *, oset, size_t, sigsetsize)
L
Linus Torvalds 已提交
2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
{
	int error = -EINVAL;
	sigset_t old_set, new_set;

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

	if (set) {
		error = -EFAULT;
		if (copy_from_user(&new_set, set, sizeof(*set)))
			goto out;
		sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));

		error = sigprocmask(how, &new_set, &old_set);
		if (error)
			goto out;
		if (oset)
			goto set_old;
	} else if (oset) {
		spin_lock_irq(&current->sighand->siglock);
		old_set = current->blocked;
		spin_unlock_irq(&current->sighand->siglock);

	set_old:
		error = -EFAULT;
		if (copy_to_user(oset, &old_set, sizeof(*oset)))
			goto out;
	}
	error = 0;
out:
	return error;
}

long do_sigpending(void __user *set, unsigned long sigsetsize)
{
	long error = -EINVAL;
	sigset_t pending;

	if (sigsetsize > sizeof(sigset_t))
		goto out;

	spin_lock_irq(&current->sighand->siglock);
	sigorsets(&pending, &current->pending.signal,
		  &current->signal->shared_pending.signal);
	spin_unlock_irq(&current->sighand->siglock);

	/* Outside the lock because only this thread touches it.  */
	sigandsets(&pending, &current->blocked, &pending);

	error = -EFAULT;
	if (!copy_to_user(set, &pending, sigsetsize))
		error = 0;

out:
	return error;
}	

2130
SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, set, size_t, sigsetsize)
L
Linus Torvalds 已提交
2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148
{
	return do_sigpending(set, sigsetsize);
}

#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.
2149 2150
	 * Please remember to update the signalfd_copyinfo() function
	 * inside fs/signalfd.c too, in case siginfo_t changes.
L
Linus Torvalds 已提交
2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200
	 * 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);
#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;
	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

2201 2202 2203
SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
		siginfo_t __user *, uinfo, const struct timespec __user *, uts,
		size_t, sigsetsize)
L
Linus Torvalds 已提交
2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249
{
	int ret, sig;
	sigset_t these;
	struct timespec ts;
	siginfo_t info;
	long timeout = 0;

	/* 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;
		
	/*
	 * Invert the set of allowed signals to get those we
	 * want to block.
	 */
	sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
	signotset(&these);

	if (uts) {
		if (copy_from_user(&ts, uts, sizeof(ts)))
			return -EFAULT;
		if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
		    || ts.tv_sec < 0)
			return -EINVAL;
	}

	spin_lock_irq(&current->sighand->siglock);
	sig = dequeue_signal(current, &these, &info);
	if (!sig) {
		timeout = MAX_SCHEDULE_TIMEOUT;
		if (uts)
			timeout = (timespec_to_jiffies(&ts)
				   + (ts.tv_sec || ts.tv_nsec));

		if (timeout) {
			/* None ready -- temporarily unblock those we're
			 * interested while we are sleeping in so that we'll
			 * be awakened when they arrive.  */
			current->real_blocked = current->blocked;
			sigandsets(&current->blocked, &current->blocked, &these);
			recalc_sigpending();
			spin_unlock_irq(&current->sighand->siglock);

2250
			timeout = schedule_timeout_interruptible(timeout);
L
Linus Torvalds 已提交
2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275

			spin_lock_irq(&current->sighand->siglock);
			sig = dequeue_signal(current, &these, &info);
			current->blocked = current->real_blocked;
			siginitset(&current->real_blocked, 0);
			recalc_sigpending();
		}
	}
	spin_unlock_irq(&current->sighand->siglock);

	if (sig) {
		ret = sig;
		if (uinfo) {
			if (copy_siginfo_to_user(uinfo, &info))
				ret = -EFAULT;
		}
	} else {
		ret = -EAGAIN;
		if (timeout)
			ret = -EINTR;
	}

	return ret;
}

2276
SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
L
Linus Torvalds 已提交
2277 2278 2279 2280 2281 2282
{
	struct siginfo info;

	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_USER;
2283
	info.si_pid = task_tgid_vnr(current);
2284
	info.si_uid = current_uid();
L
Linus Torvalds 已提交
2285 2286 2287 2288

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

T
Thomas Gleixner 已提交
2289 2290
static int
do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
L
Linus Torvalds 已提交
2291 2292
{
	struct task_struct *p;
2293
	unsigned long flags;
T
Thomas Gleixner 已提交
2294
	int error = -ESRCH;
L
Linus Torvalds 已提交
2295

2296
	rcu_read_lock();
2297
	p = find_task_by_vpid(pid);
2298
	if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
T
Thomas Gleixner 已提交
2299
		error = check_kill_permission(sig, info, p);
L
Linus Torvalds 已提交
2300 2301 2302
		/*
		 * The null signal is a permissions and process existence
		 * probe.  No signal is actually delivered.
2303 2304 2305 2306
		 *
		 * If lock_task_sighand() fails we pretend the task dies
		 * after receiving the signal. The window is tiny, and the
		 * signal is private anyway.
L
Linus Torvalds 已提交
2307
		 */
2308
		if (!error && sig && lock_task_sighand(p, &flags)) {
T
Thomas Gleixner 已提交
2309
			error = specific_send_sig_info(sig, info, p);
2310
			unlock_task_sighand(p, &flags);
L
Linus Torvalds 已提交
2311 2312
		}
	}
2313
	rcu_read_unlock();
2314

L
Linus Torvalds 已提交
2315 2316 2317
	return error;
}

T
Thomas Gleixner 已提交
2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330
static int do_tkill(pid_t tgid, pid_t pid, int sig)
{
	struct siginfo info;

	info.si_signo = sig;
	info.si_errno = 0;
	info.si_code = SI_TKILL;
	info.si_pid = task_tgid_vnr(current);
	info.si_uid = current_uid();

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

2331 2332 2333 2334 2335 2336
/**
 *  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
 *
2337
 *  This syscall also checks the @tgid and returns -ESRCH even if the PID
2338 2339 2340
 *  exists but it's not belonging to the target process anymore. This
 *  method solves the problem of threads exiting and PIDs getting reused.
 */
2341
SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
2342 2343 2344 2345 2346 2347 2348 2349
{
	/* This is only valid for single tasks */
	if (pid <= 0 || tgid <= 0)
		return -EINVAL;

	return do_tkill(tgid, pid, sig);
}

L
Linus Torvalds 已提交
2350 2351 2352
/*
 *  Send a signal to only one task, even if it's a CLONE_THREAD task.
 */
2353
SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
L
Linus Torvalds 已提交
2354 2355 2356 2357 2358
{
	/* This is only valid for single tasks */
	if (pid <= 0)
		return -EINVAL;

2359
	return do_tkill(0, pid, sig);
L
Linus Torvalds 已提交
2360 2361
}

2362 2363
SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
		siginfo_t __user *, uinfo)
L
Linus Torvalds 已提交
2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379
{
	siginfo_t info;

	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
		return -EFAULT;

	/* Not even root can pretend to send signals from the kernel.
	   Nor can they impersonate a kill(), which adds source info.  */
	if (info.si_code >= 0)
		return -EPERM;
	info.si_signo = sig;

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

2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405
long do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
{
	/* 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.
	   Nor can they impersonate a kill(), which adds source info.  */
	if (info->si_code >= 0)
		return -EPERM;
	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);
}

2406
int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
L
Linus Torvalds 已提交
2407
{
2408
	struct task_struct *t = current;
L
Linus Torvalds 已提交
2409
	struct k_sigaction *k;
2410
	sigset_t mask;
L
Linus Torvalds 已提交
2411

2412
	if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
L
Linus Torvalds 已提交
2413 2414
		return -EINVAL;

2415
	k = &t->sighand->action[sig-1];
L
Linus Torvalds 已提交
2416 2417 2418 2419 2420 2421

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

	if (act) {
2422 2423
		sigdelsetmask(&act->sa.sa_mask,
			      sigmask(SIGKILL) | sigmask(SIGSTOP));
2424
		*k = *act;
L
Linus Torvalds 已提交
2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435
		/*
		 * 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"
		 */
2436
		if (sig_handler_ignored(sig_handler(t, sig), sig)) {
2437 2438 2439
			sigemptyset(&mask);
			sigaddset(&mask, sig);
			rm_from_queue_full(&mask, &t->signal->shared_pending);
L
Linus Torvalds 已提交
2440
			do {
2441
				rm_from_queue_full(&mask, &t->pending);
L
Linus Torvalds 已提交
2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516
				t = next_thread(t);
			} while (t != current);
		}
	}

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

int 
do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
{
	stack_t oss;
	int error;

	if (uoss) {
		oss.ss_sp = (void __user *) current->sas_ss_sp;
		oss.ss_size = current->sas_ss_size;
		oss.ss_flags = sas_ss_flags(sp);
	}

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

		error = -EFAULT;
		if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
		    || __get_user(ss_sp, &uss->ss_sp)
		    || __get_user(ss_flags, &uss->ss_flags)
		    || __get_user(ss_size, &uss->ss_size))
			goto out;

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

		error = -EINVAL;
		/*
		 *
		 * Note - this code used to test ss_flags incorrectly
		 *  	  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
		 *	  mechanism
		 */
		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;
	}

	if (uoss) {
		error = -EFAULT;
		if (copy_to_user(uoss, &oss, sizeof(oss)))
			goto out;
	}

	error = 0;
out:
	return error;
}

#ifdef __ARCH_WANT_SYS_SIGPENDING

2517
SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
L
Linus Torvalds 已提交
2518 2519 2520 2521 2522 2523 2524 2525 2526 2527
{
	return do_sigpending(set, sizeof(*set));
}

#endif

#ifdef __ARCH_WANT_SYS_SIGPROCMASK
/* Some platforms have their own version with special arguments others
   support only sys_rt_sigprocmask.  */

2528 2529
SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, set,
		old_sigset_t __user *, oset)
L
Linus Torvalds 已提交
2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578
{
	int error;
	old_sigset_t old_set, new_set;

	if (set) {
		error = -EFAULT;
		if (copy_from_user(&new_set, set, sizeof(*set)))
			goto out;
		new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));

		spin_lock_irq(&current->sighand->siglock);
		old_set = current->blocked.sig[0];

		error = 0;
		switch (how) {
		default:
			error = -EINVAL;
			break;
		case SIG_BLOCK:
			sigaddsetmask(&current->blocked, new_set);
			break;
		case SIG_UNBLOCK:
			sigdelsetmask(&current->blocked, new_set);
			break;
		case SIG_SETMASK:
			current->blocked.sig[0] = new_set;
			break;
		}

		recalc_sigpending();
		spin_unlock_irq(&current->sighand->siglock);
		if (error)
			goto out;
		if (oset)
			goto set_old;
	} else if (oset) {
		old_set = current->blocked.sig[0];
	set_old:
		error = -EFAULT;
		if (copy_to_user(oset, &old_set, sizeof(*oset)))
			goto out;
	}
	error = 0;
out:
	return error;
}
#endif /* __ARCH_WANT_SYS_SIGPROCMASK */

#ifdef __ARCH_WANT_SYS_RT_SIGACTION
2579 2580 2581 2582
SYSCALL_DEFINE4(rt_sigaction, int, sig,
		const struct sigaction __user *, act,
		struct sigaction __user *, oact,
		size_t, sigsetsize)
L
Linus Torvalds 已提交
2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611
{
	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;
}
#endif /* __ARCH_WANT_SYS_RT_SIGACTION */

#ifdef __ARCH_WANT_SYS_SGETMASK

/*
 * For backwards compatibility.  Functionality superseded by sigprocmask.
 */
2612
SYSCALL_DEFINE0(sgetmask)
L
Linus Torvalds 已提交
2613 2614 2615 2616 2617
{
	/* SMP safe */
	return current->blocked.sig[0];
}

2618
SYSCALL_DEFINE1(ssetmask, int, newmask)
L
Linus Torvalds 已提交
2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637
{
	int old;

	spin_lock_irq(&current->sighand->siglock);
	old = current->blocked.sig[0];

	siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
						  sigmask(SIGSTOP)));
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

	return old;
}
#endif /* __ARCH_WANT_SGETMASK */

#ifdef __ARCH_WANT_SYS_SIGNAL
/*
 * For backwards compatibility.  Functionality superseded by sigaction.
 */
2638
SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
L
Linus Torvalds 已提交
2639 2640 2641 2642 2643 2644
{
	struct k_sigaction new_sa, old_sa;
	int ret;

	new_sa.sa.sa_handler = handler;
	new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2645
	sigemptyset(&new_sa.sa.sa_mask);
L
Linus Torvalds 已提交
2646 2647 2648 2649 2650 2651 2652 2653 2654

	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

2655
SYSCALL_DEFINE0(pause)
L
Linus Torvalds 已提交
2656 2657 2658 2659 2660 2661 2662 2663
{
	current->state = TASK_INTERRUPTIBLE;
	schedule();
	return -ERESTARTNOHAND;
}

#endif

2664
#ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2665
SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684
{
	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;
	sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));

	spin_lock_irq(&current->sighand->siglock);
	current->saved_sigmask = current->blocked;
	current->blocked = newset;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

	current->state = TASK_INTERRUPTIBLE;
	schedule();
2685
	set_restore_sigmask();
2686 2687 2688 2689
	return -ERESTARTNOHAND;
}
#endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */

2690 2691 2692 2693 2694
__attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
{
	return NULL;
}

L
Linus Torvalds 已提交
2695 2696
void __init signals_init(void)
{
2697
	sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
L
Linus Torvalds 已提交
2698
}