signal.c 18.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9
/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 1991, 1992  Linus Torvalds
 * Copyright (C) 1994 - 2000  Ralf Baechle
 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
 */
10
#include <linux/cache.h>
11
#include <linux/irqflags.h>
L
Linus Torvalds 已提交
12 13 14 15 16 17 18 19 20 21 22
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/personality.h>
#include <linux/smp.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/wait.h>
#include <linux/ptrace.h>
#include <linux/unistd.h>
#include <linux/compiler.h>
23
#include <linux/syscalls.h>
24
#include <linux/uaccess.h>
25
#include <linux/tracehook.h>
L
Linus Torvalds 已提交
26

27
#include <asm/abi.h>
L
Linus Torvalds 已提交
28 29 30 31 32 33 34
#include <asm/asm.h>
#include <linux/bitops.h>
#include <asm/cacheflush.h>
#include <asm/fpu.h>
#include <asm/sim.h>
#include <asm/ucontext.h>
#include <asm/cpu-features.h>
35
#include <asm/war.h>
36
#include <asm/vdso.h>
37
#include <asm/dsp.h>
L
Linus Torvalds 已提交
38 39 40

#include "signal-common.h"

41 42 43 44 45 46 47 48 49
static int (*save_fp_context)(struct sigcontext __user *sc);
static int (*restore_fp_context)(struct sigcontext __user *sc);

extern asmlinkage int _save_fp_context(struct sigcontext __user *sc);
extern asmlinkage int _restore_fp_context(struct sigcontext __user *sc);

extern asmlinkage int fpu_emulator_save_context(struct sigcontext __user *sc);
extern asmlinkage int fpu_emulator_restore_context(struct sigcontext __user *sc);

50 51
struct sigframe {
	u32 sf_ass[4];		/* argument save space for o32 */
52
	u32 sf_pad[2];		/* Was: signal trampoline */
53 54 55 56
	struct sigcontext sf_sc;
	sigset_t sf_mask;
};

57 58
struct rt_sigframe {
	u32 rs_ass[4];		/* argument save space for o32 */
59
	u32 rs_pad[2];		/* Was: signal trampoline */
60 61 62 63
	struct siginfo rs_info;
	struct ucontext rs_uc;
};

64 65 66
/*
 * Helper routines
 */
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
static int protected_save_fp_context(struct sigcontext __user *sc)
{
	int err;
	while (1) {
		lock_fpu_owner();
		own_fpu_inatomic(1);
		err = save_fp_context(sc); /* this might fail */
		unlock_fpu_owner();
		if (likely(!err))
			break;
		/* touch the sigcontext and try again */
		err = __put_user(0, &sc->sc_fpregs[0]) |
			__put_user(0, &sc->sc_fpregs[31]) |
			__put_user(0, &sc->sc_fpc_csr);
		if (err)
			break;	/* really bad sigcontext */
	}
	return err;
}

static int protected_restore_fp_context(struct sigcontext __user *sc)
{
89
	int err, tmp __maybe_unused;
90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
	while (1) {
		lock_fpu_owner();
		own_fpu_inatomic(0);
		err = restore_fp_context(sc); /* this might fail */
		unlock_fpu_owner();
		if (likely(!err))
			break;
		/* touch the sigcontext and try again */
		err = __get_user(tmp, &sc->sc_fpregs[0]) |
			__get_user(tmp, &sc->sc_fpregs[31]) |
			__get_user(tmp, &sc->sc_fpc_csr);
		if (err)
			break;	/* really bad sigcontext */
	}
	return err;
}

107 108 109 110
int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
{
	int err = 0;
	int i;
111
	unsigned int used_math;
112 113 114 115 116 117 118

	err |= __put_user(regs->cp0_epc, &sc->sc_pc);

	err |= __put_user(0, &sc->sc_regs[0]);
	for (i = 1; i < 32; i++)
		err |= __put_user(regs->regs[i], &sc->sc_regs[i]);

119 120 121
#ifdef CONFIG_CPU_HAS_SMARTMIPS
	err |= __put_user(regs->acx, &sc->sc_acx);
#endif
122 123 124 125 126 127 128 129 130 131 132 133
	err |= __put_user(regs->hi, &sc->sc_mdhi);
	err |= __put_user(regs->lo, &sc->sc_mdlo);
	if (cpu_has_dsp) {
		err |= __put_user(mfhi1(), &sc->sc_hi1);
		err |= __put_user(mflo1(), &sc->sc_lo1);
		err |= __put_user(mfhi2(), &sc->sc_hi2);
		err |= __put_user(mflo2(), &sc->sc_lo2);
		err |= __put_user(mfhi3(), &sc->sc_hi3);
		err |= __put_user(mflo3(), &sc->sc_lo3);
		err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
	}

134 135
	used_math = !!used_math();
	err |= __put_user(used_math, &sc->sc_used_math);
136

137
	if (used_math) {
138 139 140 141
		/*
		 * Save FPU state to signal context. Signal handler
		 * will "inherit" current FPU state.
		 */
142
		err |= protected_save_fp_context(sc);
143 144 145 146
	}
	return err;
}

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
int fpcsr_pending(unsigned int __user *fpcsr)
{
	int err, sig = 0;
	unsigned int csr, enabled;

	err = __get_user(csr, fpcsr);
	enabled = FPU_CSR_UNI_X | ((csr & FPU_CSR_ALL_E) << 5);
	/*
	 * If the signal handler set some FPU exceptions, clear it and
	 * send SIGFPE.
	 */
	if (csr & enabled) {
		csr &= ~enabled;
		err |= __put_user(csr, fpcsr);
		sig = SIGFPE;
	}
	return err ?: sig;
}

static int
check_and_restore_fp_context(struct sigcontext __user *sc)
{
	int err, sig;

	err = sig = fpcsr_pending(&sc->sc_fpc_csr);
	if (err > 0)
		err = 0;
174
	err |= protected_restore_fp_context(sc);
175 176 177
	return err ?: sig;
}

178 179 180 181 182 183 184 185 186 187 188
int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
{
	unsigned int used_math;
	unsigned long treg;
	int err = 0;
	int i;

	/* Always make any pending restarted system calls return -EINTR */
	current_thread_info()->restart_block.fn = do_no_restart_syscall;

	err |= __get_user(regs->cp0_epc, &sc->sc_pc);
189 190 191 192

#ifdef CONFIG_CPU_HAS_SMARTMIPS
	err |= __get_user(regs->acx, &sc->sc_acx);
#endif
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
	err |= __get_user(regs->hi, &sc->sc_mdhi);
	err |= __get_user(regs->lo, &sc->sc_mdlo);
	if (cpu_has_dsp) {
		err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
		err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
		err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
		err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
		err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
		err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
		err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
	}

	for (i = 1; i < 32; i++)
		err |= __get_user(regs->regs[i], &sc->sc_regs[i]);

	err |= __get_user(used_math, &sc->sc_used_math);
	conditional_used_math(used_math);

211
	if (used_math) {
212
		/* restore fpu context if we have used it before */
213 214
		if (!err)
			err = check_and_restore_fp_context(sc);
215 216
	} else {
		/* signal handler may have used FPU.  Give it up. */
217
		lose_fpu(0);
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
	}

	return err;
}

void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
			  size_t frame_size)
{
	unsigned long sp;

	/* Default to using normal stack */
	sp = regs->regs[29];

	/*
	 * FPU emulator may have it's own trampoline active just
	 * above the user stack, 16-bytes before the next lowest
	 * 16 byte boundary.  Try to avoid trashing it.
	 */
	sp -= 32;

	/* This is the X/Open sanctioned signal stack switching.  */
	if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
		sp = current->sas_ss_sp + current->sas_ss_size;

	return (void __user *)((sp - frame_size) & (ICACHE_REFILLS_WORKAROUND_WAR ? ~(cpu_icache_line_size()-1) : ALMASK));
}

L
Linus Torvalds 已提交
245 246 247 248 249
/*
 * Atomically swap in the new signal mask, and wait for a signal.
 */

#ifdef CONFIG_TRAD_SIGNALS
250
asmlinkage int sys_sigsuspend(nabi_no_regargs struct pt_regs regs)
L
Linus Torvalds 已提交
251
{
252
	sigset_t newset;
R
Ralf Baechle 已提交
253
	sigset_t __user *uset;
L
Linus Torvalds 已提交
254

R
Ralf Baechle 已提交
255
	uset = (sigset_t __user *) regs.regs[4];
L
Linus Torvalds 已提交
256 257 258 259 260
	if (copy_from_user(&newset, uset, sizeof(sigset_t)))
		return -EFAULT;
	sigdelsetmask(&newset, ~_BLOCKABLE);

	spin_lock_irq(&current->sighand->siglock);
261
	current->saved_sigmask = current->blocked;
L
Linus Torvalds 已提交
262 263 264 265
	current->blocked = newset;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

266 267 268 269
	current->state = TASK_INTERRUPTIBLE;
	schedule();
	set_thread_flag(TIF_RESTORE_SIGMASK);
	return -ERESTARTNOHAND;
L
Linus Torvalds 已提交
270 271 272
}
#endif

273
asmlinkage int sys_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
L
Linus Torvalds 已提交
274
{
275
	sigset_t newset;
R
Ralf Baechle 已提交
276
	sigset_t __user *unewset;
L
Linus Torvalds 已提交
277 278 279 280 281 282 283
	size_t sigsetsize;

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

R
Ralf Baechle 已提交
284
	unewset = (sigset_t __user *) regs.regs[4];
L
Linus Torvalds 已提交
285 286 287 288 289
	if (copy_from_user(&newset, unewset, sizeof(newset)))
		return -EFAULT;
	sigdelsetmask(&newset, ~_BLOCKABLE);

	spin_lock_irq(&current->sighand->siglock);
290
	current->saved_sigmask = current->blocked;
L
Linus Torvalds 已提交
291
	current->blocked = newset;
R
Ralf Baechle 已提交
292
	recalc_sigpending();
L
Linus Torvalds 已提交
293 294
	spin_unlock_irq(&current->sighand->siglock);

295 296 297 298
	current->state = TASK_INTERRUPTIBLE;
	schedule();
	set_thread_flag(TIF_RESTORE_SIGMASK);
	return -ERESTARTNOHAND;
L
Linus Torvalds 已提交
299 300 301
}

#ifdef CONFIG_TRAD_SIGNALS
302 303
SYSCALL_DEFINE3(sigaction, int, sig, const struct sigaction __user *, act,
	struct sigaction __user *, oact)
L
Linus Torvalds 已提交
304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
{
	struct k_sigaction new_ka, old_ka;
	int ret;
	int err = 0;

	if (act) {
		old_sigset_t mask;

		if (!access_ok(VERIFY_READ, act, sizeof(*act)))
			return -EFAULT;
		err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
		err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
		err |= __get_user(mask, &act->sa_mask.sig[0]);
		if (err)
			return -EFAULT;

		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)))
R
Ralf Baechle 已提交
327
			return -EFAULT;
L
Linus Torvalds 已提交
328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
		err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
		err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
		err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
		err |= __put_user(0, &oact->sa_mask.sig[1]);
		err |= __put_user(0, &oact->sa_mask.sig[2]);
		err |= __put_user(0, &oact->sa_mask.sig[3]);
		if (err)
			return -EFAULT;
	}

	return ret;
}
#endif

asmlinkage int sys_sigaltstack(nabi_no_regargs struct pt_regs regs)
{
R
Ralf Baechle 已提交
344 345
	const stack_t __user *uss = (const stack_t __user *) regs.regs[4];
	stack_t __user *uoss = (stack_t __user *) regs.regs[5];
L
Linus Torvalds 已提交
346 347 348 349 350 351
	unsigned long usp = regs.regs[29];

	return do_sigaltstack(uss, uoss, usp);
}

#ifdef CONFIG_TRAD_SIGNALS
352
asmlinkage void sys_sigreturn(nabi_no_regargs struct pt_regs regs)
L
Linus Torvalds 已提交
353
{
354
	struct sigframe __user *frame;
L
Linus Torvalds 已提交
355
	sigset_t blocked;
356
	int sig;
L
Linus Torvalds 已提交
357

358
	frame = (struct sigframe __user *) regs.regs[29];
L
Linus Torvalds 已提交
359 360 361 362 363 364 365 366 367 368 369
	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
		goto badframe;

	sigdelsetmask(&blocked, ~_BLOCKABLE);
	spin_lock_irq(&current->sighand->siglock);
	current->blocked = blocked;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

370 371
	sig = restore_sigcontext(&regs, &frame->sf_sc);
	if (sig < 0)
L
Linus Torvalds 已提交
372
		goto badframe;
373 374
	else if (sig)
		force_sig(sig, current);
L
Linus Torvalds 已提交
375 376 377 378 379 380 381 382 383 384 385 386 387 388

	/*
	 * Don't let your children do this ...
	 */
	__asm__ __volatile__(
		"move\t$29, %0\n\t"
		"j\tsyscall_exit"
		:/* no outputs */
		:"r" (&regs));
	/* Unreached */

badframe:
	force_sig(SIGSEGV, current);
}
389
#endif /* CONFIG_TRAD_SIGNALS */
L
Linus Torvalds 已提交
390

391
asmlinkage void sys_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
L
Linus Torvalds 已提交
392
{
393
	struct rt_sigframe __user *frame;
L
Linus Torvalds 已提交
394
	sigset_t set;
395
	int sig;
L
Linus Torvalds 已提交
396

397
	frame = (struct rt_sigframe __user *) regs.regs[29];
L
Linus Torvalds 已提交
398 399 400 401 402 403 404 405 406 407 408
	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
		goto badframe;

	sigdelsetmask(&set, ~_BLOCKABLE);
	spin_lock_irq(&current->sighand->siglock);
	current->blocked = set;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

409 410
	sig = restore_sigcontext(&regs, &frame->rs_uc.uc_mcontext);
	if (sig < 0)
L
Linus Torvalds 已提交
411
		goto badframe;
412 413
	else if (sig)
		force_sig(sig, current);
L
Linus Torvalds 已提交
414 415 416

	/* It is more difficult to avoid calling this function than to
	   call it and ignore errors.  */
417
	do_sigaltstack(&frame->rs_uc.uc_stack, NULL, regs.regs[29]);
L
Linus Torvalds 已提交
418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433

	/*
	 * Don't let your children do this ...
	 */
	__asm__ __volatile__(
		"move\t$29, %0\n\t"
		"j\tsyscall_exit"
		:/* no outputs */
		:"r" (&regs));
	/* Unreached */

badframe:
	force_sig(SIGSEGV, current);
}

#ifdef CONFIG_TRAD_SIGNALS
434 435
static int setup_frame(void *sig_return, struct k_sigaction *ka,
		       struct pt_regs *regs, int signr, sigset_t *set)
L
Linus Torvalds 已提交
436
{
437
	struct sigframe __user *frame;
L
Linus Torvalds 已提交
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
	int err = 0;

	frame = get_sigframe(ka, regs, sizeof(*frame));
	if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
		goto give_sigsegv;

	err |= setup_sigcontext(regs, &frame->sf_sc);
	err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
	if (err)
		goto give_sigsegv;

	/*
	 * Arguments to signal handler:
	 *
	 *   a0 = signal number
	 *   a1 = 0 (should be cause)
	 *   a2 = pointer to struct sigcontext
	 *
	 * $25 and c0_epc point to the signal handler, $29 points to the
	 * struct sigframe.
	 */
	regs->regs[ 4] = signr;
	regs->regs[ 5] = 0;
	regs->regs[ 6] = (unsigned long) &frame->sf_sc;
	regs->regs[29] = (unsigned long) frame;
463
	regs->regs[31] = (unsigned long) sig_return;
L
Linus Torvalds 已提交
464 465
	regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;

466
	DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
L
Linus Torvalds 已提交
467
	       current->comm, current->pid,
468
	       frame, regs->cp0_epc, regs->regs[31]);
R
Ralf Baechle 已提交
469
	return 0;
L
Linus Torvalds 已提交
470 471 472

give_sigsegv:
	force_sigsegv(signr, current);
473
	return -EFAULT;
L
Linus Torvalds 已提交
474 475 476
}
#endif

477 478 479
static int setup_rt_frame(void *sig_return, struct k_sigaction *ka,
			  struct pt_regs *regs,	int signr, sigset_t *set,
			  siginfo_t *info)
L
Linus Torvalds 已提交
480
{
481
	struct rt_sigframe __user *frame;
L
Linus Torvalds 已提交
482 483 484 485 486 487 488 489 490 491 492
	int err = 0;

	frame = get_sigframe(ka, regs, sizeof(*frame));
	if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
		goto give_sigsegv;

	/* Create siginfo.  */
	err |= copy_siginfo_to_user(&frame->rs_info, info);

	/* Create the ucontext.  */
	err |= __put_user(0, &frame->rs_uc.uc_flags);
493
	err |= __put_user(NULL, &frame->rs_uc.uc_link);
A
Atsushi Nemoto 已提交
494
	err |= __put_user((void __user *)current->sas_ss_sp,
L
Linus Torvalds 已提交
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
	                  &frame->rs_uc.uc_stack.ss_sp);
	err |= __put_user(sas_ss_flags(regs->regs[29]),
	                  &frame->rs_uc.uc_stack.ss_flags);
	err |= __put_user(current->sas_ss_size,
	                  &frame->rs_uc.uc_stack.ss_size);
	err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
	err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));

	if (err)
		goto give_sigsegv;

	/*
	 * Arguments to signal handler:
	 *
	 *   a0 = signal number
	 *   a1 = 0 (should be cause)
	 *   a2 = pointer to ucontext
	 *
	 * $25 and c0_epc point to the signal handler, $29 points to
	 * the struct rt_sigframe.
	 */
	regs->regs[ 4] = signr;
	regs->regs[ 5] = (unsigned long) &frame->rs_info;
	regs->regs[ 6] = (unsigned long) &frame->rs_uc;
	regs->regs[29] = (unsigned long) frame;
520
	regs->regs[31] = (unsigned long) sig_return;
L
Linus Torvalds 已提交
521 522
	regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;

523
	DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
L
Linus Torvalds 已提交
524 525
	       current->comm, current->pid,
	       frame, regs->cp0_epc, regs->regs[31]);
526

527
	return 0;
L
Linus Torvalds 已提交
528 529 530

give_sigsegv:
	force_sigsegv(signr, current);
531
	return -EFAULT;
L
Linus Torvalds 已提交
532 533
}

534 535 536
struct mips_abi mips_abi = {
#ifdef CONFIG_TRAD_SIGNALS
	.setup_frame	= setup_frame,
537
	.signal_return_offset = offsetof(struct mips_vdso, signal_trampoline),
538 539
#endif
	.setup_rt_frame	= setup_rt_frame,
540 541
	.rt_signal_return_offset =
		offsetof(struct mips_vdso, rt_signal_trampoline),
542 543 544
	.restart	= __NR_restart_syscall
};

545
static int handle_signal(unsigned long sig, siginfo_t *info,
L
Linus Torvalds 已提交
546 547
	struct k_sigaction *ka, sigset_t *oldset, struct pt_regs *regs)
{
548
	int ret;
549 550
	struct mips_abi *abi = current->thread.abi;
	void *vdso = current->mm->context.vdso;
551

A
Al Viro 已提交
552 553 554 555
	if (regs->regs[0]) {
		switch(regs->regs[2]) {
		case ERESTART_RESTARTBLOCK:
		case ERESTARTNOHAND:
L
Linus Torvalds 已提交
556 557
			regs->regs[2] = EINTR;
			break;
A
Al Viro 已提交
558 559 560 561 562 563 564 565 566 567
		case ERESTARTSYS:
			if (!(ka->sa.sa_flags & SA_RESTART)) {
				regs->regs[2] = EINTR;
				break;
			}
		/* fallthrough */
		case ERESTARTNOINTR:
			regs->regs[7] = regs->regs[26];
			regs->regs[2] = regs->regs[0];
			regs->cp0_epc -= 4;
L
Linus Torvalds 已提交
568 569
		}

A
Al Viro 已提交
570 571
		regs->regs[0] = 0;		/* Don't deal with this again.  */
	}
L
Linus Torvalds 已提交
572

573
	if (sig_uses_siginfo(ka))
574 575
		ret = abi->setup_rt_frame(vdso + abi->rt_signal_return_offset,
					  ka, regs, sig, oldset, info);
L
Linus Torvalds 已提交
576
	else
577 578
		ret = abi->setup_frame(vdso + abi->signal_return_offset,
				       ka, regs, sig, oldset);
L
Linus Torvalds 已提交
579

580 581 582
	if (ret)
		return ret;

583
	spin_lock_irq(&current->sighand->siglock);
584
	sigorsets(&current->blocked, &current->blocked, &ka->sa.sa_mask);
585
	if (!(ka->sa.sa_flags & SA_NODEFER))
586
		sigaddset(&current->blocked, sig);
587 588
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);
589 590

	return ret;
L
Linus Torvalds 已提交
591 592
}

593
static void do_signal(struct pt_regs *regs)
L
Linus Torvalds 已提交
594 595
{
	struct k_sigaction ka;
596
	sigset_t *oldset;
L
Linus Torvalds 已提交
597 598 599 600 601 602 603 604 605
	siginfo_t info;
	int signr;

	/*
	 * We want the common case to go fast, which is why we may in certain
	 * cases get here from kernel mode. Just return without doing anything
	 * if so.
	 */
	if (!user_mode(regs))
606
		return;
L
Linus Torvalds 已提交
607

608 609 610
	if (test_thread_flag(TIF_RESTORE_SIGMASK))
		oldset = &current->saved_sigmask;
	else
L
Linus Torvalds 已提交
611 612 613
		oldset = &current->blocked;

	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
614 615 616 617 618 619 620 621 622 623 624 625
	if (signr > 0) {
		/* Whee!  Actually deliver the signal.  */
		if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
			/*
			 * A signal was successfully delivered; the saved
			 * sigmask will have been stored in the signal frame,
			 * and will be restored by sigreturn, so we can simply
			 * clear the TIF_RESTORE_SIGMASK flag.
			 */
			if (test_thread_flag(TIF_RESTORE_SIGMASK))
				clear_thread_flag(TIF_RESTORE_SIGMASK);
		}
626 627

		return;
628
	}
L
Linus Torvalds 已提交
629 630 631 632 633

	if (regs->regs[0]) {
		if (regs->regs[2] == ERESTARTNOHAND ||
		    regs->regs[2] == ERESTARTSYS ||
		    regs->regs[2] == ERESTARTNOINTR) {
A
Al Viro 已提交
634
			regs->regs[2] = regs->regs[0];
L
Linus Torvalds 已提交
635
			regs->regs[7] = regs->regs[26];
A
Al Viro 已提交
636
			regs->cp0_epc -= 4;
L
Linus Torvalds 已提交
637 638
		}
		if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
639
			regs->regs[2] = current->thread.abi->restart;
L
Linus Torvalds 已提交
640 641 642
			regs->regs[7] = regs->regs[26];
			regs->cp0_epc -= 4;
		}
643
		regs->regs[0] = 0;	/* Don't deal with this again.  */
L
Linus Torvalds 已提交
644
	}
645 646 647 648 649 650 651 652 653

	/*
	 * If there's no signal to deliver, we just put the saved sigmask
	 * back
	 */
	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
		clear_thread_flag(TIF_RESTORE_SIGMASK);
		sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
	}
L
Linus Torvalds 已提交
654 655 656 657
}

/*
 * notification of userspace execution resumption
658
 * - triggered by the TIF_WORK_MASK flags
L
Linus Torvalds 已提交
659
 */
660
asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
L
Linus Torvalds 已提交
661 662
	__u32 thread_info_flags)
{
663 664
	local_irq_enable();

L
Linus Torvalds 已提交
665
	/* deal with pending signal delivery */
666
	if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
667
		do_signal(regs);
668 669 670 671

	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
		clear_thread_flag(TIF_NOTIFY_RESUME);
		tracehook_notify_resume(regs);
672 673
		if (current->replacement_session_keyring)
			key_replace_session_keyring();
674
	}
L
Linus Torvalds 已提交
675
}
676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712

#ifdef CONFIG_SMP
static int smp_save_fp_context(struct sigcontext __user *sc)
{
	return raw_cpu_has_fpu
	       ? _save_fp_context(sc)
	       : fpu_emulator_save_context(sc);
}

static int smp_restore_fp_context(struct sigcontext __user *sc)
{
	return raw_cpu_has_fpu
	       ? _restore_fp_context(sc)
	       : fpu_emulator_restore_context(sc);
}
#endif

static int signal_setup(void)
{
#ifdef CONFIG_SMP
	/* For now just do the cpu_has_fpu check when the functions are invoked */
	save_fp_context = smp_save_fp_context;
	restore_fp_context = smp_restore_fp_context;
#else
	if (cpu_has_fpu) {
		save_fp_context = _save_fp_context;
		restore_fp_context = _restore_fp_context;
	} else {
		save_fp_context = fpu_emulator_save_context;
		restore_fp_context = fpu_emulator_restore_context;
	}
#endif

	return 0;
}

arch_initcall(signal_setup);