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>
L
Linus Torvalds 已提交
11 12 13 14 15 16 17 18 19 20 21
#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>
22
#include <linux/syscalls.h>
23
#include <linux/uaccess.h>
24
#include <linux/tracehook.h>
L
Linus Torvalds 已提交
25

26
#include <asm/abi.h>
L
Linus Torvalds 已提交
27 28 29 30 31 32 33
#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>
34
#include <asm/war.h>
35
#include <asm/vdso.h>
L
Linus Torvalds 已提交
36 37 38

#include "signal-common.h"

39 40 41 42 43 44 45 46 47
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);

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

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

62 63 64
/*
 * Helper routines
 */
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
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)
{
	int err, tmp;
	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;
}

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

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

117 118 119
#ifdef CONFIG_CPU_HAS_SMARTMIPS
	err |= __put_user(regs->acx, &sc->sc_acx);
#endif
120 121 122 123 124 125 126 127 128 129 130 131
	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);
	}

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

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

145 146 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
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;
172
	err |= protected_restore_fp_context(sc);
173 174 175
	return err ?: sig;
}

176 177 178 179 180 181 182 183 184 185 186
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);
187 188 189 190

#ifdef CONFIG_CPU_HAS_SMARTMIPS
	err |= __get_user(regs->acx, &sc->sc_acx);
#endif
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
	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);

209
	if (used_math) {
210
		/* restore fpu context if we have used it before */
211 212
		if (!err)
			err = check_and_restore_fp_context(sc);
213 214
	} else {
		/* signal handler may have used FPU.  Give it up. */
215
		lose_fpu(0);
216 217 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
	}

	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 已提交
243 244 245 246 247
/*
 * Atomically swap in the new signal mask, and wait for a signal.
 */

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

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

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

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

271
asmlinkage int sys_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
L
Linus Torvalds 已提交
272
{
273
	sigset_t newset;
R
Ralf Baechle 已提交
274
	sigset_t __user *unewset;
L
Linus Torvalds 已提交
275 276 277 278 279 280 281
	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 已提交
282
	unewset = (sigset_t __user *) regs.regs[4];
L
Linus Torvalds 已提交
283 284 285 286 287
	if (copy_from_user(&newset, unewset, sizeof(newset)))
		return -EFAULT;
	sigdelsetmask(&newset, ~_BLOCKABLE);

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

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

#ifdef CONFIG_TRAD_SIGNALS
300 301
SYSCALL_DEFINE3(sigaction, int, sig, const struct sigaction __user *, act,
	struct sigaction __user *, oact)
L
Linus Torvalds 已提交
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
{
	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 已提交
325
			return -EFAULT;
L
Linus Torvalds 已提交
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
		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 已提交
342 343
	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 已提交
344 345 346 347 348 349
	unsigned long usp = regs.regs[29];

	return do_sigaltstack(uss, uoss, usp);
}

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

356
	frame = (struct sigframe __user *) regs.regs[29];
L
Linus Torvalds 已提交
357 358 359 360 361 362 363 364 365 366 367
	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);

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

	/*
	 * 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);
}
387
#endif /* CONFIG_TRAD_SIGNALS */
L
Linus Torvalds 已提交
388

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

396
	frame = (struct rt_sigframe __user *) regs.regs[29];
L
Linus Torvalds 已提交
397 398 399 400 401 402 403 404 405 406 407
	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);

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

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

	/*
	 * 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
435 436
static int setup_frame(void *sig_return, struct k_sigaction *ka,
		       struct pt_regs *regs, int signr, sigset_t *set)
L
Linus Torvalds 已提交
437
{
438
	struct sigframe __user *frame;
L
Linus Torvalds 已提交
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
	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;
464
	regs->regs[31] = (unsigned long) sig_return;
L
Linus Torvalds 已提交
465 466
	regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;

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

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

478 479 480
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 已提交
481
{
482
	struct rt_sigframe __user *frame;
L
Linus Torvalds 已提交
483 484 485 486 487 488 489 490 491 492 493
	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);
494
	err |= __put_user(NULL, &frame->rs_uc.uc_link);
A
Atsushi Nemoto 已提交
495
	err |= __put_user((void __user *)current->sas_ss_sp,
L
Linus Torvalds 已提交
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
	                  &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;
521
	regs->regs[31] = (unsigned long) sig_return;
L
Linus Torvalds 已提交
522 523
	regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;

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

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

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

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

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

A
Al Viro 已提交
553 554 555 556
	if (regs->regs[0]) {
		switch(regs->regs[2]) {
		case ERESTART_RESTARTBLOCK:
		case ERESTARTNOHAND:
L
Linus Torvalds 已提交
557 558
			regs->regs[2] = EINTR;
			break;
A
Al Viro 已提交
559 560 561 562 563 564 565 566 567 568
		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 已提交
569 570
		}

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

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

581 582 583
	if (ret)
		return ret;

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

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

594
static void do_signal(struct pt_regs *regs)
L
Linus Torvalds 已提交
595 596
{
	struct k_sigaction ka;
597
	sigset_t *oldset;
L
Linus Torvalds 已提交
598 599 600 601 602 603 604 605 606
	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))
607
		return;
L
Linus Torvalds 已提交
608

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

	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
615 616 617 618 619 620 621 622 623 624 625 626
	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);
		}
627 628

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

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

	/*
	 * 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 已提交
655 656 657 658
}

/*
 * notification of userspace execution resumption
659
 * - triggered by the TIF_WORK_MASK flags
L
Linus Torvalds 已提交
660
 */
661
asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
L
Linus Torvalds 已提交
662 663 664
	__u32 thread_info_flags)
{
	/* deal with pending signal delivery */
665
	if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
666
		do_signal(regs);
667 668 669 670

	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
		clear_thread_flag(TIF_NOTIFY_RESUME);
		tracehook_notify_resume(regs);
671 672
		if (current->replacement_session_keyring)
			key_replace_session_keyring();
673
	}
L
Linus Torvalds 已提交
674
}
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

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