signal.c 21.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
 *  Copyright (C) 1991, 1992  Linus Torvalds
3
 *  Copyright (C) 2000, 2001, 2002 Andi Kleen SuSE Labs
L
Linus Torvalds 已提交
4 5 6
 *
 *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
 *  2000-06-20  Pentium III FXSR, SSE support by Gareth Hughes
7
 *  2000-2002   x86-64 support by Andi Kleen
L
Linus Torvalds 已提交
8
 */
9 10 11
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/smp.h>
L
Linus Torvalds 已提交
12 13 14 15
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/wait.h>
16
#include <linux/ptrace.h>
R
Roland McGrath 已提交
17
#include <linux/tracehook.h>
18 19 20 21
#include <linux/unistd.h>
#include <linux/stddef.h>
#include <linux/personality.h>
#include <linux/uaccess.h>
A
Avi Kivity 已提交
22
#include <linux/user-return-notifier.h>
23

L
Linus Torvalds 已提交
24 25 26
#include <asm/processor.h>
#include <asm/ucontext.h>
#include <asm/i387.h>
R
Roland McGrath 已提交
27
#include <asm/vdso.h>
28
#include <asm/mce.h>
29 30 31 32 33 34

#ifdef CONFIG_X86_64
#include <asm/proto.h>
#include <asm/ia32_unistd.h>
#endif /* CONFIG_X86_64 */

35
#include <asm/syscall.h>
36
#include <asm/syscalls.h>
37

38
#include <asm/sigframe.h>
L
Linus Torvalds 已提交
39 40 41

#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))

42 43 44 45 46 47 48 49 50 51 52
#define __FIX_EFLAGS	(X86_EFLAGS_AC | X86_EFLAGS_OF | \
			 X86_EFLAGS_DF | X86_EFLAGS_TF | X86_EFLAGS_SF | \
			 X86_EFLAGS_ZF | X86_EFLAGS_AF | X86_EFLAGS_PF | \
			 X86_EFLAGS_CF)

#ifdef CONFIG_X86_32
# define FIX_EFLAGS	(__FIX_EFLAGS | X86_EFLAGS_RF)
#else
# define FIX_EFLAGS	__FIX_EFLAGS
#endif

T
Tejun Heo 已提交
53 54 55
#define COPY(x)			do {			\
	get_user_ex(regs->x, &sc->x);			\
} while (0)
56

T
Tejun Heo 已提交
57 58 59 60 61
#define GET_SEG(seg)		({			\
	unsigned short tmp;				\
	get_user_ex(tmp, &sc->seg);			\
	tmp;						\
})
62

T
Tejun Heo 已提交
63 64 65
#define COPY_SEG(seg)		do {			\
	regs->seg = GET_SEG(seg);			\
} while (0)
66

T
Tejun Heo 已提交
67 68 69
#define COPY_SEG_CPL3(seg)	do {			\
	regs->seg = GET_SEG(seg) | 3;			\
} while (0)
70 71 72 73 74 75 76 77 78 79 80 81

static int
restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc,
		   unsigned long *pax)
{
	void __user *buf;
	unsigned int tmpflags;
	unsigned int err = 0;

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

82 83
	get_user_try {

84
#ifdef CONFIG_X86_32
T
Tejun Heo 已提交
85
		set_user_gs(regs, GET_SEG(gs));
86 87 88
		COPY_SEG(fs);
		COPY_SEG(es);
		COPY_SEG(ds);
89 90
#endif /* CONFIG_X86_32 */

91 92
		COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
		COPY(dx); COPY(cx); COPY(ip);
93 94

#ifdef CONFIG_X86_64
95 96 97 98 99 100 101 102
		COPY(r8);
		COPY(r9);
		COPY(r10);
		COPY(r11);
		COPY(r12);
		COPY(r13);
		COPY(r14);
		COPY(r15);
103 104 105
#endif /* CONFIG_X86_64 */

#ifdef CONFIG_X86_32
106 107
		COPY_SEG_CPL3(cs);
		COPY_SEG_CPL3(ss);
108
#else /* !CONFIG_X86_32 */
109 110 111 112
		/* Kernel saves and restores only the CS segment register on signals,
		 * which is the bare minimum needed to allow mixed 32/64-bit code.
		 * App's signal handler can save/restore other segments if needed. */
		COPY_SEG_CPL3(cs);
113 114
#endif /* CONFIG_X86_32 */

115 116 117 118 119 120
		get_user_ex(tmpflags, &sc->flags);
		regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
		regs->orig_ax = -1;		/* disable syscall checks */

		get_user_ex(buf, &sc->fpstate);
		err |= restore_i387_xstate(buf);
121

122 123
		get_user_ex(*pax, &sc->ax);
	} get_user_catch(err);
124 125 126 127 128 129 130 131 132 133

	return err;
}

static int
setup_sigcontext(struct sigcontext __user *sc, void __user *fpstate,
		 struct pt_regs *regs, unsigned long mask)
{
	int err = 0;

134
	put_user_try {
135

136
#ifdef CONFIG_X86_32
T
Tejun Heo 已提交
137
		put_user_ex(get_user_gs(regs), (unsigned int __user *)&sc->gs);
138 139 140
		put_user_ex(regs->fs, (unsigned int __user *)&sc->fs);
		put_user_ex(regs->es, (unsigned int __user *)&sc->es);
		put_user_ex(regs->ds, (unsigned int __user *)&sc->ds);
141 142
#endif /* CONFIG_X86_32 */

143 144 145 146 147 148 149 150
		put_user_ex(regs->di, &sc->di);
		put_user_ex(regs->si, &sc->si);
		put_user_ex(regs->bp, &sc->bp);
		put_user_ex(regs->sp, &sc->sp);
		put_user_ex(regs->bx, &sc->bx);
		put_user_ex(regs->dx, &sc->dx);
		put_user_ex(regs->cx, &sc->cx);
		put_user_ex(regs->ax, &sc->ax);
151
#ifdef CONFIG_X86_64
152 153 154 155 156 157 158 159
		put_user_ex(regs->r8, &sc->r8);
		put_user_ex(regs->r9, &sc->r9);
		put_user_ex(regs->r10, &sc->r10);
		put_user_ex(regs->r11, &sc->r11);
		put_user_ex(regs->r12, &sc->r12);
		put_user_ex(regs->r13, &sc->r13);
		put_user_ex(regs->r14, &sc->r14);
		put_user_ex(regs->r15, &sc->r15);
160 161
#endif /* CONFIG_X86_64 */

162 163 164
		put_user_ex(current->thread.trap_no, &sc->trapno);
		put_user_ex(current->thread.error_code, &sc->err);
		put_user_ex(regs->ip, &sc->ip);
165
#ifdef CONFIG_X86_32
166 167 168 169
		put_user_ex(regs->cs, (unsigned int __user *)&sc->cs);
		put_user_ex(regs->flags, &sc->flags);
		put_user_ex(regs->sp, &sc->sp_at_signal);
		put_user_ex(regs->ss, (unsigned int __user *)&sc->ss);
170
#else /* !CONFIG_X86_32 */
171 172 173 174
		put_user_ex(regs->flags, &sc->flags);
		put_user_ex(regs->cs, &sc->cs);
		put_user_ex(0, &sc->gs);
		put_user_ex(0, &sc->fs);
175 176
#endif /* CONFIG_X86_32 */

177
		put_user_ex(fpstate, &sc->fpstate);
178

179 180 181 182
		/* non-iBCS2 extensions.. */
		put_user_ex(mask, &sc->oldmask);
		put_user_ex(current->thread.cr2, &sc->cr2);
	} put_user_catch(err);
183 184 185 186

	return err;
}

L
Linus Torvalds 已提交
187
/*
188
 * Set up a signal frame.
L
Linus Torvalds 已提交
189 190 191 192 193
 */

/*
 * Determine which stack to use..
 */
194 195 196 197 198 199 200 201 202 203 204 205 206 207
static unsigned long align_sigframe(unsigned long sp)
{
#ifdef CONFIG_X86_32
	/*
	 * Align the stack pointer according to the i386 ABI,
	 * i.e. so that on function entry ((sp + 4) & 15) == 0.
	 */
	sp = ((sp + 4) & -16ul) - 4;
#else /* !CONFIG_X86_32 */
	sp = round_down(sp, 16) - 8;
#endif
	return sp;
}

L
Linus Torvalds 已提交
208
static inline void __user *
209
get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size,
210
	     void __user **fpstate)
L
Linus Torvalds 已提交
211 212
{
	/* Default to using normal stack */
213
	unsigned long sp = regs->sp;
214
	int onsigstack = on_sig_stack(sp);
215 216 217 218 219

#ifdef CONFIG_X86_64
	/* redzone */
	sp -= 128;
#endif /* CONFIG_X86_64 */
L
Linus Torvalds 已提交
220

221 222 223
	if (!onsigstack) {
		/* This is the X/Open sanctioned signal stack switching.  */
		if (ka->sa.sa_flags & SA_ONSTACK) {
224
			if (current->sas_ss_size)
225 226
				sp = current->sas_ss_sp + current->sas_ss_size;
		} else {
227
#ifdef CONFIG_X86_32
228 229 230 231 232
			/* This is the legacy signal stack switching. */
			if ((regs->ss & 0xffff) != __USER_DS &&
				!(ka->sa.sa_flags & SA_RESTORER) &&
					ka->sa.sa_restorer)
				sp = (unsigned long) ka->sa.sa_restorer;
233
#endif /* CONFIG_X86_32 */
234
		}
L
Linus Torvalds 已提交
235 236
	}

237
	if (used_math()) {
238
		sp -= sig_xstate_size;
239 240 241 242
#ifdef CONFIG_X86_64
		sp = round_down(sp, 64);
#endif /* CONFIG_X86_64 */
		*fpstate = (void __user *)sp;
243 244
	}

245 246 247 248 249 250 251 252 253 254 255 256 257 258
	sp = align_sigframe(sp - frame_size);

	/*
	 * If we are on the alternate signal stack and would overflow it, don't.
	 * Return an always-bogus address instead so we will die with SIGSEGV.
	 */
	if (onsigstack && !likely(on_sig_stack(sp)))
		return (void __user *)-1L;

	/* save i387 state */
	if (used_math() && save_i387_xstate(*fpstate) < 0)
		return (void __user *)-1L;

	return (void __user *)sp;
L
Linus Torvalds 已提交
259 260
}

261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
#ifdef CONFIG_X86_32
static const struct {
	u16 poplmovl;
	u32 val;
	u16 int80;
} __attribute__((packed)) retcode = {
	0xb858,		/* popl %eax; movl $..., %eax */
	__NR_sigreturn,
	0x80cd,		/* int $0x80 */
};

static const struct {
	u8  movl;
	u32 val;
	u16 int80;
	u8  pad;
} __attribute__((packed)) rt_retcode = {
	0xb8,		/* movl $..., %eax */
	__NR_rt_sigreturn,
	0x80cd,		/* int $0x80 */
	0
};

284
static int
285 286
__setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
	      struct pt_regs *regs)
L
Linus Torvalds 已提交
287 288
{
	struct sigframe __user *frame;
289
	void __user *restorer;
L
Linus Torvalds 已提交
290
	int err = 0;
291
	void __user *fpstate = NULL;
L
Linus Torvalds 已提交
292

293
	frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
L
Linus Torvalds 已提交
294 295

	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
296
		return -EFAULT;
L
Linus Torvalds 已提交
297

298
	if (__put_user(sig, &frame->sig))
299
		return -EFAULT;
L
Linus Torvalds 已提交
300

301
	if (setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
302
		return -EFAULT;
L
Linus Torvalds 已提交
303 304

	if (_NSIG_WORDS > 1) {
305 306
		if (__copy_to_user(&frame->extramask, &set->sig[1],
				   sizeof(frame->extramask)))
307
			return -EFAULT;
L
Linus Torvalds 已提交
308 309
	}

310
	if (current->mm->context.vdso)
R
Roland McGrath 已提交
311
		restorer = VDSO32_SYMBOL(current->mm->context.vdso, sigreturn);
312
	else
J
Jan Engelhardt 已提交
313
		restorer = &frame->retcode;
L
Linus Torvalds 已提交
314 315 316 317 318
	if (ka->sa.sa_flags & SA_RESTORER)
		restorer = ka->sa.sa_restorer;

	/* Set up to return from userspace.  */
	err |= __put_user(restorer, &frame->pretcode);
319

L
Linus Torvalds 已提交
320
	/*
321
	 * This is popl %eax ; movl $__NR_sigreturn, %eax ; int $0x80
L
Linus Torvalds 已提交
322 323 324 325 326
	 *
	 * WE DO NOT USE IT ANY MORE! It's only left here for historical
	 * reasons and because gdb uses it as a signature to notice
	 * signal handler stack frames.
	 */
327
	err |= __put_user(*((u64 *)&retcode), (u64 *)frame->retcode);
L
Linus Torvalds 已提交
328 329

	if (err)
330
		return -EFAULT;
L
Linus Torvalds 已提交
331 332

	/* Set up registers for signal handler */
333 334 335
	regs->sp = (unsigned long)frame;
	regs->ip = (unsigned long)ka->sa.sa_handler;
	regs->ax = (unsigned long)sig;
336 337
	regs->dx = 0;
	regs->cx = 0;
L
Linus Torvalds 已提交
338

339 340 341 342
	regs->ds = __USER_DS;
	regs->es = __USER_DS;
	regs->ss = __USER_DS;
	regs->cs = __USER_CS;
L
Linus Torvalds 已提交
343

344
	return 0;
L
Linus Torvalds 已提交
345 346
}

347 348
static int __setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
			    sigset_t *set, struct pt_regs *regs)
L
Linus Torvalds 已提交
349 350
{
	struct rt_sigframe __user *frame;
351
	void __user *restorer;
L
Linus Torvalds 已提交
352
	int err = 0;
353
	void __user *fpstate = NULL;
L
Linus Torvalds 已提交
354

355
	frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
L
Linus Torvalds 已提交
356 357

	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
358
		return -EFAULT;
L
Linus Torvalds 已提交
359

360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
	put_user_try {
		put_user_ex(sig, &frame->sig);
		put_user_ex(&frame->info, &frame->pinfo);
		put_user_ex(&frame->uc, &frame->puc);
		err |= copy_siginfo_to_user(&frame->info, info);

		/* Create the ucontext.  */
		if (cpu_has_xsave)
			put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
		else
			put_user_ex(0, &frame->uc.uc_flags);
		put_user_ex(0, &frame->uc.uc_link);
		put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
		put_user_ex(sas_ss_flags(regs->sp),
			    &frame->uc.uc_stack.ss_flags);
		put_user_ex(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
		err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
					regs, set->sig[0]);
		err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));

		/* Set up to return from userspace.  */
		restorer = VDSO32_SYMBOL(current->mm->context.vdso, rt_sigreturn);
		if (ka->sa.sa_flags & SA_RESTORER)
			restorer = ka->sa.sa_restorer;
		put_user_ex(restorer, &frame->pretcode);

		/*
		 * This is movl $__NR_rt_sigreturn, %ax ; int $0x80
		 *
		 * WE DO NOT USE IT ANY MORE! It's only left here for historical
		 * reasons and because gdb uses it as a signature to notice
		 * signal handler stack frames.
		 */
		put_user_ex(*((u64 *)&rt_retcode), (u64 *)frame->retcode);
	} put_user_catch(err);
L
Linus Torvalds 已提交
395 396

	if (err)
397
		return -EFAULT;
L
Linus Torvalds 已提交
398 399

	/* Set up registers for signal handler */
400 401
	regs->sp = (unsigned long)frame;
	regs->ip = (unsigned long)ka->sa.sa_handler;
402
	regs->ax = (unsigned long)sig;
403 404
	regs->dx = (unsigned long)&frame->info;
	regs->cx = (unsigned long)&frame->uc;
L
Linus Torvalds 已提交
405

406 407 408 409
	regs->ds = __USER_DS;
	regs->es = __USER_DS;
	regs->ss = __USER_DS;
	regs->cs = __USER_CS;
L
Linus Torvalds 已提交
410

411
	return 0;
L
Linus Torvalds 已提交
412
}
413 414 415 416 417 418 419 420 421
#else /* !CONFIG_X86_32 */
static int __setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
			    sigset_t *set, struct pt_regs *regs)
{
	struct rt_sigframe __user *frame;
	void __user *fp = NULL;
	int err = 0;
	struct task_struct *me = current;

422
	frame = get_sigframe(ka, regs, sizeof(struct rt_sigframe), &fp);
423 424 425 426 427 428 429 430 431

	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
		return -EFAULT;

	if (ka->sa.sa_flags & SA_SIGINFO) {
		if (copy_siginfo_to_user(&frame->info, info))
			return -EFAULT;
	}

432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455
	put_user_try {
		/* Create the ucontext.  */
		if (cpu_has_xsave)
			put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
		else
			put_user_ex(0, &frame->uc.uc_flags);
		put_user_ex(0, &frame->uc.uc_link);
		put_user_ex(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
		put_user_ex(sas_ss_flags(regs->sp),
			    &frame->uc.uc_stack.ss_flags);
		put_user_ex(me->sas_ss_size, &frame->uc.uc_stack.ss_size);
		err |= setup_sigcontext(&frame->uc.uc_mcontext, fp, regs, set->sig[0]);
		err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));

		/* Set up to return from userspace.  If provided, use a stub
		   already in userspace.  */
		/* x86-64 should always use SA_RESTORER. */
		if (ka->sa.sa_flags & SA_RESTORER) {
			put_user_ex(ka->sa.sa_restorer, &frame->pretcode);
		} else {
			/* could use a vstub here */
			err |= -EFAULT;
		}
	} put_user_catch(err);
456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480

	if (err)
		return -EFAULT;

	/* Set up registers for signal handler */
	regs->di = sig;
	/* In case the signal handler was declared without prototypes */
	regs->ax = 0;

	/* This also works for non SA_SIGINFO handlers because they expect the
	   next argument after the signal number on the stack. */
	regs->si = (unsigned long)&frame->info;
	regs->dx = (unsigned long)&frame->uc;
	regs->ip = (unsigned long) ka->sa.sa_handler;

	regs->sp = (unsigned long)frame;

	/* Set up the CS register to run signal handlers in 64-bit mode,
	   even if the handler happens to be interrupting 32-bit code. */
	regs->cs = __USER_CS;

	return 0;
}
#endif /* CONFIG_X86_32 */

481
#ifdef CONFIG_X86_32
482 483 484 485 486 487
/*
 * Atomically swap in the new signal mask, and wait for a signal.
 */
asmlinkage int
sys_sigsuspend(int history0, int history1, old_sigset_t mask)
{
488 489
	sigset_t blocked;

490
	current->saved_sigmask = current->blocked;
491 492 493 494

	mask &= _BLOCKABLE;
	siginitset(&blocked, mask);
	set_current_blocked(&blocked);
495 496 497 498

	current->state = TASK_INTERRUPTIBLE;
	schedule();

499
	set_restore_sigmask();
500 501 502 503 504 505 506 507
	return -ERESTARTNOHAND;
}

asmlinkage int
sys_sigaction(int sig, const struct old_sigaction __user *act,
	      struct old_sigaction __user *oact)
{
	struct k_sigaction new_ka, old_ka;
508
	int ret = 0;
509 510 511 512

	if (act) {
		old_sigset_t mask;

513
		if (!access_ok(VERIFY_READ, act, sizeof(*act)))
514 515
			return -EFAULT;

516 517 518 519 520 521 522 523 524
		get_user_try {
			get_user_ex(new_ka.sa.sa_handler, &act->sa_handler);
			get_user_ex(new_ka.sa.sa_flags, &act->sa_flags);
			get_user_ex(mask, &act->sa_mask);
			get_user_ex(new_ka.sa.sa_restorer, &act->sa_restorer);
		} get_user_catch(ret);

		if (ret)
			return -EFAULT;
525 526 527 528 529 530
		siginitset(&new_ka.sa.sa_mask, mask);
	}

	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);

	if (!ret && oact) {
531
		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
532 533
			return -EFAULT;

534 535 536 537 538 539 540 541 542
		put_user_try {
			put_user_ex(old_ka.sa.sa_handler, &oact->sa_handler);
			put_user_ex(old_ka.sa.sa_flags, &oact->sa_flags);
			put_user_ex(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
			put_user_ex(old_ka.sa.sa_restorer, &oact->sa_restorer);
		} put_user_catch(ret);

		if (ret)
			return -EFAULT;
543 544 545 546
	}

	return ret;
}
547
#endif /* CONFIG_X86_32 */
548

B
Brian Gerst 已提交
549
long
550 551 552 553 554 555 556 557 558
sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
		struct pt_regs *regs)
{
	return do_sigaltstack(uss, uoss, regs->sp);
}

/*
 * Do a signal return; undo the signal stack.
 */
559
#ifdef CONFIG_X86_32
560
unsigned long sys_sigreturn(struct pt_regs *regs)
561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
{
	struct sigframe __user *frame;
	unsigned long ax;
	sigset_t set;

	frame = (struct sigframe __user *)(regs->sp - 8);

	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__get_user(set.sig[0], &frame->sc.oldmask) || (_NSIG_WORDS > 1
		&& __copy_from_user(&set.sig[1], &frame->extramask,
				    sizeof(frame->extramask))))
		goto badframe;

	sigdelsetmask(&set, ~_BLOCKABLE);
576
	set_current_blocked(&set);
577 578 579 580 581 582

	if (restore_sigcontext(regs, &frame->sc, &ax))
		goto badframe;
	return ax;

badframe:
583
	signal_fault(regs, frame, "sigreturn");
584 585 586

	return 0;
}
587
#endif /* CONFIG_X86_32 */
588

589
long sys_rt_sigreturn(struct pt_regs *regs)
590 591 592 593 594 595 596 597 598 599 600 601
{
	struct rt_sigframe __user *frame;
	unsigned long ax;
	sigset_t set;

	frame = (struct rt_sigframe __user *)(regs->sp - sizeof(long));
	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
		goto badframe;

	sigdelsetmask(&set, ~_BLOCKABLE);
602
	set_current_blocked(&set);
603 604 605 606 607 608 609 610 611 612 613 614 615 616

	if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
		goto badframe;

	if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->sp) == -EFAULT)
		goto badframe;

	return ax;

badframe:
	signal_fault(regs, frame, "rt_sigreturn");
	return 0;
}

L
Linus Torvalds 已提交
617
/*
618 619
 * OK, we're invoking a handler:
 */
620 621
static int signr_convert(int sig)
{
622
#ifdef CONFIG_X86_32
623 624 625 626
	struct thread_info *info = current_thread_info();

	if (info->exec_domain && info->exec_domain->signal_invmap && sig < 32)
		return info->exec_domain->signal_invmap[sig];
627
#endif /* CONFIG_X86_32 */
628 629 630
	return sig;
}

631 632
#ifdef CONFIG_X86_32

633
#define is_ia32	1
634 635
#define ia32_setup_frame	__setup_frame
#define ia32_setup_rt_frame	__setup_rt_frame
636

637 638 639 640 641 642 643 644
#else /* !CONFIG_X86_32 */

#ifdef CONFIG_IA32_EMULATION
#define is_ia32	test_thread_flag(TIF_IA32)
#else /* !CONFIG_IA32_EMULATION */
#define is_ia32	0
#endif /* CONFIG_IA32_EMULATION */

645 646 647 648 649
int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
		sigset_t *set, struct pt_regs *regs);
int ia32_setup_frame(int sig, struct k_sigaction *ka,
		sigset_t *set, struct pt_regs *regs);

650 651
#endif /* CONFIG_X86_32 */

652 653 654 655
static int
setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
	       sigset_t *set, struct pt_regs *regs)
{
656
	int usig = signr_convert(sig);
657 658 659
	int ret;

	/* Set up the stack frame */
660 661
	if (is_ia32) {
		if (ka->sa.sa_flags & SA_SIGINFO)
662
			ret = ia32_setup_rt_frame(usig, ka, info, set, regs);
663
		else
664
			ret = ia32_setup_frame(usig, ka, set, regs);
665 666
	} else
		ret = __setup_rt_frame(sig, ka, info, set, regs);
667

668 669 670 671 672
	if (ret) {
		force_sigsegv(sig, current);
		return -EFAULT;
	}

673 674 675
	return ret;
}

676
static int
L
Linus Torvalds 已提交
677
handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
678
	      sigset_t *oldset, struct pt_regs *regs)
L
Linus Torvalds 已提交
679
{
680
	sigset_t blocked;
681 682
	int ret;

L
Linus Torvalds 已提交
683
	/* Are we from a system call? */
684
	if (syscall_get_nr(current, regs) >= 0) {
L
Linus Torvalds 已提交
685
		/* If so, check system call restarting.. */
686
		switch (syscall_get_error(current, regs)) {
687 688 689 690 691 692 693
		case -ERESTART_RESTARTBLOCK:
		case -ERESTARTNOHAND:
			regs->ax = -EINTR;
			break;

		case -ERESTARTSYS:
			if (!(ka->sa.sa_flags & SA_RESTART)) {
694
				regs->ax = -EINTR;
L
Linus Torvalds 已提交
695
				break;
696 697 698 699 700 701
			}
		/* fallthrough */
		case -ERESTARTNOINTR:
			regs->ax = regs->orig_ax;
			regs->ip -= 2;
			break;
L
Linus Torvalds 已提交
702 703 704 705
		}
	}

	/*
R
Roland McGrath 已提交
706 707
	 * If TF is set due to a debugger (TIF_FORCED_TF), clear the TF
	 * flag so that register information in the sigcontext is correct.
L
Linus Torvalds 已提交
708
	 */
709
	if (unlikely(regs->flags & X86_EFLAGS_TF) &&
R
Roland McGrath 已提交
710
	    likely(test_and_clear_thread_flag(TIF_FORCED_TF)))
711
		regs->flags &= ~X86_EFLAGS_TF;
L
Linus Torvalds 已提交
712

713
	ret = setup_rt_frame(sig, ka, info, oldset, regs);
L
Linus Torvalds 已提交
714

715 716
	if (ret)
		return ret;
717

718 719 720 721 722 723 724 725 726
#ifdef CONFIG_X86_64
	/*
	 * This has nothing to do with segment registers,
	 * despite the name.  This magic affects uaccess.h
	 * macros' behavior.  Reset it to the normal setting.
	 */
	set_fs(USER_DS);
#endif

727 728 729 730 731 732 733 734 735 736 737 738 739
	/*
	 * Clear the direction flag as per the ABI for function entry.
	 */
	regs->flags &= ~X86_EFLAGS_DF;

	/*
	 * Clear TF when entering the signal handler, but
	 * notify any tracer that was single-stepping it.
	 * The tracer may want to single-step inside the
	 * handler too.
	 */
	regs->flags &= ~X86_EFLAGS_TF;

740
	sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask);
741
	if (!(ka->sa.sa_flags & SA_NODEFER))
742 743
		sigaddset(&blocked, sig);
	set_current_blocked(&blocked);
744

R
Roland McGrath 已提交
745 746 747
	tracehook_signal_handler(sig, info, ka, regs,
				 test_thread_flag(TIF_SINGLESTEP));

748
	return 0;
L
Linus Torvalds 已提交
749 750
}

751
#ifdef CONFIG_X86_32
752
#define NR_restart_syscall	__NR_restart_syscall
753 754 755 756 757
#else /* !CONFIG_X86_32 */
#define NR_restart_syscall	\
	test_thread_flag(TIF_IA32) ? __NR_ia32_restart_syscall : __NR_restart_syscall
#endif /* CONFIG_X86_32 */

L
Linus Torvalds 已提交
758 759 760 761 762
/*
 * Note that 'init' is a special process: it doesn't get signals it doesn't
 * want to handle. Thus you cannot kill init even with a SIGKILL even by
 * mistake.
 */
763
static void do_signal(struct pt_regs *regs)
L
Linus Torvalds 已提交
764
{
765
	struct k_sigaction ka;
L
Linus Torvalds 已提交
766 767
	siginfo_t info;
	int signr;
768
	sigset_t *oldset;
L
Linus Torvalds 已提交
769 770

	/*
771 772 773 774 775
	 * 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.
	 * X86_32: vm86 regs switched out by assembly code before reaching
	 * here, so testing against kernel CS suffices.
L
Linus Torvalds 已提交
776
	 */
777
	if (!user_mode(regs))
778
		return;
L
Linus Torvalds 已提交
779

R
Roland McGrath 已提交
780
	if (current_thread_info()->status & TS_RESTORE_SIGMASK)
781 782
		oldset = &current->saved_sigmask;
	else
L
Linus Torvalds 已提交
783 784 785 786
		oldset = &current->blocked;

	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
	if (signr > 0) {
787
		/* Whee! Actually deliver the signal.  */
788
		if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
789
			/*
R
Roland McGrath 已提交
790
			 * A signal was successfully delivered; the saved
791 792
			 * sigmask will have been stored in the signal frame,
			 * and will be restored by sigreturn, so we can simply
R
Roland McGrath 已提交
793
			 * clear the TS_RESTORE_SIGMASK flag.
794
			 */
R
Roland McGrath 已提交
795
			current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
796 797
		}
		return;
L
Linus Torvalds 已提交
798 799 800
	}

	/* Did we come from a system call? */
801
	if (syscall_get_nr(current, regs) >= 0) {
L
Linus Torvalds 已提交
802
		/* Restart the system call - no handlers present */
803
		switch (syscall_get_error(current, regs)) {
804 805 806
		case -ERESTARTNOHAND:
		case -ERESTARTSYS:
		case -ERESTARTNOINTR:
807 808
			regs->ax = regs->orig_ax;
			regs->ip -= 2;
809 810 811
			break;

		case -ERESTART_RESTARTBLOCK:
812
			regs->ax = NR_restart_syscall;
813
			regs->ip -= 2;
814
			break;
L
Linus Torvalds 已提交
815 816
		}
	}
817

818 819 820 821
	/*
	 * If there's no signal to deliver, we just put the saved sigmask
	 * back.
	 */
R
Roland McGrath 已提交
822 823
	if (current_thread_info()->status & TS_RESTORE_SIGMASK) {
		current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
824 825
		sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
	}
L
Linus Torvalds 已提交
826 827 828 829
}

/*
 * notification of userspace execution resumption
830
 * - triggered by the TIF_WORK_MASK flags
L
Linus Torvalds 已提交
831
 */
832 833
void
do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags)
L
Linus Torvalds 已提交
834
{
835
#ifdef CONFIG_X86_MCE
836 837
	/* notify userspace of pending MCEs */
	if (thread_info_flags & _TIF_MCE_NOTIFY)
838
		mce_notify_process();
839 840
#endif /* CONFIG_X86_64 && CONFIG_X86_MCE */

L
Linus Torvalds 已提交
841
	/* deal with pending signal delivery */
R
Roland McGrath 已提交
842
	if (thread_info_flags & _TIF_SIGPENDING)
843
		do_signal(regs);
P
Peter Zijlstra 已提交
844

845 846 847
	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
		clear_thread_flag(TIF_NOTIFY_RESUME);
		tracehook_notify_resume(regs);
848 849
		if (current->replacement_session_keyring)
			key_replace_session_keyring();
850
	}
A
Avi Kivity 已提交
851 852
	if (thread_info_flags & _TIF_USER_RETURN_NOTIFY)
		fire_user_return_notifiers();
853

854
#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
855
	clear_thread_flag(TIF_IRET);
856
#endif /* CONFIG_X86_32 */
L
Linus Torvalds 已提交
857
}
858 859 860 861 862 863

void signal_fault(struct pt_regs *regs, void __user *frame, char *where)
{
	struct task_struct *me = current;

	if (show_unhandled_signals && printk_ratelimit()) {
864
		printk("%s"
865
		       "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx",
866
		       task_pid_nr(current) > 1 ? KERN_INFO : KERN_EMERG,
867 868 869 870 871 872 873 874
		       me->comm, me->pid, where, frame,
		       regs->ip, regs->sp, regs->orig_ax);
		print_vma_addr(" in ", regs->ip);
		printk(KERN_CONT "\n");
	}

	force_sig(SIGSEGV, me);
}