signal.c 21.3 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
static int
setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
654
		struct pt_regs *regs)
655
{
656
	int usig = signr_convert(sig);
657
	sigset_t *set = &current->blocked;
658 659
	int ret;

660 661 662
	if (current_thread_info()->status & TS_RESTORE_SIGMASK)
		set = &current->saved_sigmask;

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

672 673 674 675 676
	if (ret) {
		force_sigsegv(sig, current);
		return -EFAULT;
	}

677
	current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
678 679 680
	return ret;
}

681
static int
L
Linus Torvalds 已提交
682
handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
683
		struct pt_regs *regs)
L
Linus Torvalds 已提交
684
{
685
	sigset_t blocked;
686 687
	int ret;

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

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

	/*
R
Roland McGrath 已提交
711 712
	 * 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 已提交
713
	 */
714
	if (unlikely(regs->flags & X86_EFLAGS_TF) &&
R
Roland McGrath 已提交
715
	    likely(test_and_clear_thread_flag(TIF_FORCED_TF)))
716
		regs->flags &= ~X86_EFLAGS_TF;
L
Linus Torvalds 已提交
717

718
	ret = setup_rt_frame(sig, ka, info, regs);
L
Linus Torvalds 已提交
719

720 721
	if (ret)
		return ret;
722

723 724 725 726 727 728 729 730 731
#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

732 733 734 735 736 737 738 739 740 741 742 743 744
	/*
	 * 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;

745
	sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask);
746
	if (!(ka->sa.sa_flags & SA_NODEFER))
747 748
		sigaddset(&blocked, sig);
	set_current_blocked(&blocked);
749

R
Roland McGrath 已提交
750 751 752
	tracehook_signal_handler(sig, info, ka, regs,
				 test_thread_flag(TIF_SINGLESTEP));

753
	return 0;
L
Linus Torvalds 已提交
754 755
}

756
#ifdef CONFIG_X86_32
757
#define NR_restart_syscall	__NR_restart_syscall
758 759 760 761 762
#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 已提交
763 764 765 766 767
/*
 * 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.
 */
768
static void do_signal(struct pt_regs *regs)
L
Linus Torvalds 已提交
769
{
770
	struct k_sigaction ka;
L
Linus Torvalds 已提交
771 772 773 774
	siginfo_t info;
	int signr;

	/*
775 776 777 778 779
	 * 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 已提交
780
	 */
781
	if (!user_mode(regs))
782
		return;
L
Linus Torvalds 已提交
783 784 785

	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
	if (signr > 0) {
786
		/* Whee! Actually deliver the signal.  */
787
		handle_signal(signr, &info, &ka, regs);
788
		return;
L
Linus Torvalds 已提交
789 790 791
	}

	/* Did we come from a system call? */
792
	if (syscall_get_nr(current, regs) >= 0) {
L
Linus Torvalds 已提交
793
		/* Restart the system call - no handlers present */
794
		switch (syscall_get_error(current, regs)) {
795 796 797
		case -ERESTARTNOHAND:
		case -ERESTARTSYS:
		case -ERESTARTNOINTR:
798 799
			regs->ax = regs->orig_ax;
			regs->ip -= 2;
800 801 802
			break;

		case -ERESTART_RESTARTBLOCK:
803
			regs->ax = NR_restart_syscall;
804
			regs->ip -= 2;
805
			break;
L
Linus Torvalds 已提交
806 807
		}
	}
808

809 810 811 812
	/*
	 * If there's no signal to deliver, we just put the saved sigmask
	 * back.
	 */
R
Roland McGrath 已提交
813 814
	if (current_thread_info()->status & TS_RESTORE_SIGMASK) {
		current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
815
		set_current_blocked(&current->saved_sigmask);
816
	}
L
Linus Torvalds 已提交
817 818 819 820
}

/*
 * notification of userspace execution resumption
821
 * - triggered by the TIF_WORK_MASK flags
L
Linus Torvalds 已提交
822
 */
823 824
void
do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags)
L
Linus Torvalds 已提交
825
{
826
#ifdef CONFIG_X86_MCE
827 828
	/* notify userspace of pending MCEs */
	if (thread_info_flags & _TIF_MCE_NOTIFY)
829
		mce_notify_process();
830 831
#endif /* CONFIG_X86_64 && CONFIG_X86_MCE */

L
Linus Torvalds 已提交
832
	/* deal with pending signal delivery */
R
Roland McGrath 已提交
833
	if (thread_info_flags & _TIF_SIGPENDING)
834
		do_signal(regs);
P
Peter Zijlstra 已提交
835

836 837 838
	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
		clear_thread_flag(TIF_NOTIFY_RESUME);
		tracehook_notify_resume(regs);
839 840
		if (current->replacement_session_keyring)
			key_replace_session_keyring();
841
	}
A
Avi Kivity 已提交
842 843
	if (thread_info_flags & _TIF_USER_RETURN_NOTIFY)
		fire_user_return_notifiers();
844

845
#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
846
	clear_thread_flag(TIF_IRET);
847
#endif /* CONFIG_X86_32 */
L
Linus Torvalds 已提交
848
}
849 850 851 852 853 854

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

	if (show_unhandled_signals && printk_ratelimit()) {
855
		printk("%s"
856
		       "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx",
857
		       task_pid_nr(current) > 1 ? KERN_INFO : KERN_EMERG,
858 859 860 861 862 863 864 865
		       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);
}