signal_64.c 12.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
/*
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *  Copyright (C) 2000, 2001, 2002 Andi Kleen SuSE Labs
 *
 *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
 *  2000-06-20  Pentium III FXSR, SSE support by Gareth Hughes
 *  2000-2002   x86-64 support by Andi Kleen
 */

#include <linux/sched.h>
#include <linux/mm.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/stddef.h>
#include <linux/personality.h>
#include <linux/compiler.h>
#include <asm/ucontext.h>
#include <asm/uaccess.h>
#include <asm/i387.h>
#include <asm/proto.h>
26
#include <asm/ia32_unistd.h>
27
#include <asm/mce.h>
L
Linus Torvalds 已提交
28 29 30 31 32

/* #define DEBUG_SIG 1 */

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

33
int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
L
Linus Torvalds 已提交
34
               sigset_t *set, struct pt_regs * regs); 
35
int ia32_setup_frame(int sig, struct k_sigaction *ka,
L
Linus Torvalds 已提交
36 37 38 39 40 41
            sigset_t *set, struct pt_regs * regs); 

asmlinkage long
sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
		struct pt_regs *regs)
{
42
	return do_sigaltstack(uss, uoss, regs->sp);
L
Linus Torvalds 已提交
43 44 45 46 47 48 49 50 51
}


/*
 * Do a signal return; undo the signal stack.
 */

struct rt_sigframe
{
52
	char __user *pretcode;
L
Linus Torvalds 已提交
53 54 55 56 57 58 59 60 61 62 63 64
	struct ucontext uc;
	struct siginfo info;
};

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

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

65
#define COPYR(x)	err |= __get_user(regs->x, &sc->r ## x)
L
Linus Torvalds 已提交
66 67
#define COPY(x)		err |= __get_user(regs->x, &sc->x)

68 69
	COPYR(di); COPYR(si); COPYR(bp); COPYR(sp); COPYR(bx);
	COPYR(dx); COPYR(cx); COPYR(ip);
L
Linus Torvalds 已提交
70 71 72 73 74 75 76 77 78
	COPY(r8);
	COPY(r9);
	COPY(r10);
	COPY(r11);
	COPY(r12);
	COPY(r13);
	COPY(r14);
	COPY(r15);

79 80 81 82 83 84 85 86 87
	/* 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. */
	{
		unsigned cs;
		err |= __get_user(cs, &sc->cs);
		regs->cs = cs | 3;	/* Force into user mode */
	}

L
Linus Torvalds 已提交
88 89 90
	{
		unsigned int tmpflags;
		err |= __get_user(tmpflags, &sc->eflags);
91 92
		regs->flags = (regs->flags & ~0x40DD5) | (tmpflags & 0x40DD5);
		regs->orig_ax = -1;		/* disable syscall checks */
L
Linus Torvalds 已提交
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
	}

	{
		struct _fpstate __user * buf;
		err |= __get_user(buf, &sc->fpstate);

		if (buf) {
			if (!access_ok(VERIFY_READ, buf, sizeof(*buf)))
				goto badframe;
			err |= restore_i387(buf);
		} else {
			struct task_struct *me = current;
			if (used_math()) {
				clear_fpu(me);
				clear_used_math();
			}
		}
	}

	err |= __get_user(*prax, &sc->rax);
	return err;

badframe:
	return 1;
}

asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
{
	struct rt_sigframe __user *frame;
	sigset_t set;
123
	unsigned long ax;
L
Linus Torvalds 已提交
124

125
	frame = (struct rt_sigframe __user *)(regs->sp - 8);
L
Linus Torvalds 已提交
126 127 128 129 130 131 132 133 134 135 136 137 138
	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);
	spin_lock_irq(&current->sighand->siglock);
	current->blocked = set;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);
	
139
	if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
L
Linus Torvalds 已提交
140 141 142
		goto badframe;

#ifdef DEBUG_SIG
143
	printk("%d sigreturn ip:%lx sp:%lx frame:%p ax:%lx\n",current->pid,regs->ip,regs->sp,frame,ax);
L
Linus Torvalds 已提交
144 145
#endif

146
	if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->sp) == -EFAULT)
L
Linus Torvalds 已提交
147 148
		goto badframe;

149
	return ax;
L
Linus Torvalds 已提交
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164

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

/*
 * Set up a signal frame.
 */

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

165
	err |= __put_user(regs->cs, &sc->cs);
L
Linus Torvalds 已提交
166 167 168
	err |= __put_user(0, &sc->gs);
	err |= __put_user(0, &sc->fs);

169 170 171 172 173 174 175 176
	err |= __put_user(regs->di, &sc->rdi);
	err |= __put_user(regs->si, &sc->rsi);
	err |= __put_user(regs->bp, &sc->rbp);
	err |= __put_user(regs->sp, &sc->rsp);
	err |= __put_user(regs->bx, &sc->rbx);
	err |= __put_user(regs->dx, &sc->rdx);
	err |= __put_user(regs->cx, &sc->rcx);
	err |= __put_user(regs->ax, &sc->rax);
L
Linus Torvalds 已提交
177 178 179 180 181 182 183 184 185 186
	err |= __put_user(regs->r8, &sc->r8);
	err |= __put_user(regs->r9, &sc->r9);
	err |= __put_user(regs->r10, &sc->r10);
	err |= __put_user(regs->r11, &sc->r11);
	err |= __put_user(regs->r12, &sc->r12);
	err |= __put_user(regs->r13, &sc->r13);
	err |= __put_user(regs->r14, &sc->r14);
	err |= __put_user(regs->r15, &sc->r15);
	err |= __put_user(me->thread.trap_no, &sc->trapno);
	err |= __put_user(me->thread.error_code, &sc->err);
187 188
	err |= __put_user(regs->ip, &sc->rip);
	err |= __put_user(regs->flags, &sc->eflags);
L
Linus Torvalds 已提交
189 190 191 192 193 194 195 196 197 198 199 200 201
	err |= __put_user(mask, &sc->oldmask);
	err |= __put_user(me->thread.cr2, &sc->cr2);

	return err;
}

/*
 * Determine which stack to use..
 */

static void __user *
get_stack(struct k_sigaction *ka, struct pt_regs *regs, unsigned long size)
{
202
	unsigned long sp;
L
Linus Torvalds 已提交
203 204

	/* Default to using normal stack - redzone*/
205
	sp = regs->sp - 128;
L
Linus Torvalds 已提交
206 207 208

	/* This is the X/Open sanctioned signal stack switching.  */
	if (ka->sa.sa_flags & SA_ONSTACK) {
209 210
		if (sas_ss_flags(sp) == 0)
			sp = current->sas_ss_sp + current->sas_ss_size;
L
Linus Torvalds 已提交
211 212
	}

213
	return (void __user *)round_down(sp - size, 16);
L
Linus Torvalds 已提交
214 215
}

216
static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
L
Linus Torvalds 已提交
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 243 244 245 246 247 248 249
			   sigset_t *set, struct pt_regs * regs)
{
	struct rt_sigframe __user *frame;
	struct _fpstate __user *fp = NULL; 
	int err = 0;
	struct task_struct *me = current;

	if (used_math()) {
		fp = get_stack(ka, regs, sizeof(struct _fpstate)); 
		frame = (void __user *)round_down(
			(unsigned long)fp - sizeof(struct rt_sigframe), 16) - 8;

		if (!access_ok(VERIFY_WRITE, fp, sizeof(struct _fpstate)))
			goto give_sigsegv;

		if (save_i387(fp) < 0) 
			err |= -1; 
	} else
		frame = get_stack(ka, regs, sizeof(struct rt_sigframe)) - 8;

	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
		goto give_sigsegv;

	if (ka->sa.sa_flags & SA_SIGINFO) { 
		err |= copy_siginfo_to_user(&frame->info, info);
		if (err)
			goto give_sigsegv;
	}
		
	/* Create the ucontext.  */
	err |= __put_user(0, &frame->uc.uc_flags);
	err |= __put_user(0, &frame->uc.uc_link);
	err |= __put_user(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
250
	err |= __put_user(sas_ss_flags(regs->sp),
L
Linus Torvalds 已提交
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
			  &frame->uc.uc_stack.ss_flags);
	err |= __put_user(me->sas_ss_size, &frame->uc.uc_stack.ss_size);
	err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0], me);
	err |= __put_user(fp, &frame->uc.uc_mcontext.fpstate);
	if (sizeof(*set) == 16) { 
		__put_user(set->sig[0], &frame->uc.uc_sigmask.sig[0]);
		__put_user(set->sig[1], &frame->uc.uc_sigmask.sig[1]); 
	} else
		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) {
		err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
	} else {
		/* could use a vstub here */
		goto give_sigsegv; 
	}

	if (err)
		goto give_sigsegv;

#ifdef DEBUG_SIG
275
	printk("%d old ip %lx old sp %lx old ax %lx\n", current->pid,regs->ip,regs->sp,regs->ax);
L
Linus Torvalds 已提交
276 277 278
#endif

	/* Set up registers for signal handler */
279
	regs->di = sig;
L
Linus Torvalds 已提交
280
	/* In case the signal handler was declared without prototypes */ 
281
	regs->ax = 0;
L
Linus Torvalds 已提交
282 283 284

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

289
	regs->sp = (unsigned long)frame;
L
Linus Torvalds 已提交
290

291 292 293 294 295 296
	/* 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;

	/* This, by contrast, has nothing to do with segment registers -
	   see include/asm-x86_64/uaccess.h for details. */
L
Linus Torvalds 已提交
297
	set_fs(USER_DS);
298

299
	regs->flags &= ~TF_MASK;
300 301
	if (test_thread_flag(TIF_SINGLESTEP))
		ptrace_notify(SIGTRAP);
L
Linus Torvalds 已提交
302
#ifdef DEBUG_SIG
303
	printk("SIG deliver (%s:%d): sp=%p pc=%lx ra=%p\n",
304
		current->comm, current->pid, frame, regs->ip, frame->pretcode);
L
Linus Torvalds 已提交
305 306
#endif

A
Andi Kleen 已提交
307
	return 0;
L
Linus Torvalds 已提交
308 309 310

give_sigsegv:
	force_sigsegv(sig, current);
A
Andi Kleen 已提交
311
	return -EFAULT;
L
Linus Torvalds 已提交
312 313 314 315 316 317
}

/*
 * OK, we're invoking a handler
 */	

318
static int
L
Linus Torvalds 已提交
319 320 321
handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
		sigset_t *oldset, struct pt_regs *regs)
{
322 323
	int ret;

L
Linus Torvalds 已提交
324
#ifdef DEBUG_SIG
325
	printk("handle_signal pid:%d sig:%lu ip:%lx sp:%lx regs=%p\n",
L
Linus Torvalds 已提交
326
		current->pid, sig,
327
		regs->ip, regs->sp, regs);
L
Linus Torvalds 已提交
328 329 330
#endif

	/* Are we from a system call? */
331
	if ((long)regs->orig_ax >= 0) {
L
Linus Torvalds 已提交
332
		/* If so, check system call restarting.. */
333
		switch (regs->ax) {
L
Linus Torvalds 已提交
334 335
		        case -ERESTART_RESTARTBLOCK:
			case -ERESTARTNOHAND:
336
				regs->ax = -EINTR;
L
Linus Torvalds 已提交
337 338 339 340
				break;

			case -ERESTARTSYS:
				if (!(ka->sa.sa_flags & SA_RESTART)) {
341
					regs->ax = -EINTR;
L
Linus Torvalds 已提交
342 343 344 345
					break;
				}
				/* fallthrough */
			case -ERESTARTNOINTR:
346 347
				regs->ax = regs->orig_ax;
				regs->ip -= 2;
L
Linus Torvalds 已提交
348 349 350 351
				break;
		}
	}

352
	/*
R
Roland McGrath 已提交
353 354
	 * If TF is set due to a debugger (TIF_FORCED_TF), clear the TF
	 * flag so that register information in the sigcontext is correct.
355
	 */
356
	if (unlikely(regs->flags & X86_EFLAGS_TF) &&
R
Roland McGrath 已提交
357
	    likely(test_and_clear_thread_flag(TIF_FORCED_TF)))
358
		regs->flags &= ~X86_EFLAGS_TF;
359

L
Linus Torvalds 已提交
360 361 362
#ifdef CONFIG_IA32_EMULATION
	if (test_thread_flag(TIF_IA32)) {
		if (ka->sa.sa_flags & SA_SIGINFO)
363
			ret = ia32_setup_rt_frame(sig, ka, info, oldset, regs);
L
Linus Torvalds 已提交
364
		else
365
			ret = ia32_setup_frame(sig, ka, oldset, regs);
L
Linus Torvalds 已提交
366 367
	} else 
#endif
368
	ret = setup_rt_frame(sig, ka, info, oldset, regs);
L
Linus Torvalds 已提交
369

A
Andi Kleen 已提交
370
	if (ret == 0) {
L
Linus Torvalds 已提交
371 372
		spin_lock_irq(&current->sighand->siglock);
		sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
373 374
		if (!(ka->sa.sa_flags & SA_NODEFER))
			sigaddset(&current->blocked,sig);
L
Linus Torvalds 已提交
375 376 377
		recalc_sigpending();
		spin_unlock_irq(&current->sighand->siglock);
	}
378 379

	return ret;
L
Linus Torvalds 已提交
380 381 382 383 384 385 386
}

/*
 * 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.
 */
A
Andi Kleen 已提交
387
static void do_signal(struct pt_regs *regs)
L
Linus Torvalds 已提交
388 389 390 391
{
	struct k_sigaction ka;
	siginfo_t info;
	int signr;
A
Andi Kleen 已提交
392
	sigset_t *oldset;
L
Linus Torvalds 已提交
393 394 395 396 397 398 399

	/*
	 * 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.
	 */
400
	if (!user_mode(regs))
A
Andi Kleen 已提交
401
		return;
L
Linus Torvalds 已提交
402

A
Andi Kleen 已提交
403 404 405
	if (test_thread_flag(TIF_RESTORE_SIGMASK))
		oldset = &current->saved_sigmask;
	else
L
Linus Torvalds 已提交
406 407 408 409
		oldset = &current->blocked;

	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
	if (signr > 0) {
S
Simon Arlott 已提交
410
		/* Re-enable any watchpoints before delivering the
L
Linus Torvalds 已提交
411 412 413 414 415
		 * signal to user space. The processor register will
		 * have been cleared if the watchpoint triggered
		 * inside the kernel.
		 */
		if (current->thread.debugreg7)
416
			set_debugreg(current->thread.debugreg7, 7);
L
Linus Torvalds 已提交
417 418

		/* Whee!  Actually deliver the signal.  */
A
Andi Kleen 已提交
419 420 421 422 423 424 425 426
		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 */
			clear_thread_flag(TIF_RESTORE_SIGMASK);
		}
		return;
L
Linus Torvalds 已提交
427 428 429
	}

	/* Did we come from a system call? */
430
	if ((long)regs->orig_ax >= 0) {
L
Linus Torvalds 已提交
431
		/* Restart the system call - no handlers present */
432
		long res = regs->ax;
A
Andi Kleen 已提交
433 434 435 436
		switch (res) {
		case -ERESTARTNOHAND:
		case -ERESTARTSYS:
		case -ERESTARTNOINTR:
437 438
			regs->ax = regs->orig_ax;
			regs->ip -= 2;
A
Andi Kleen 已提交
439 440
			break;
		case -ERESTART_RESTARTBLOCK:
441
			regs->ax = test_thread_flag(TIF_IA32) ?
442 443
					__NR_ia32_restart_syscall :
					__NR_restart_syscall;
444
			regs->ip -= 2;
A
Andi Kleen 已提交
445
			break;
L
Linus Torvalds 已提交
446 447
		}
	}
A
Andi Kleen 已提交
448 449 450 451 452 453 454

	/* 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 已提交
455 456
}

A
Andi Kleen 已提交
457 458
void
do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags)
L
Linus Torvalds 已提交
459 460
{
#ifdef DEBUG_SIG
461 462
	printk("do_notify_resume flags:%x ip:%lx sp:%lx caller:%p pending:%x\n",
	       thread_info_flags, regs->ip, regs->sp, __builtin_return_address(0),signal_pending(current));
L
Linus Torvalds 已提交
463 464 465 466
#endif
	       
	/* Pending single-step? */
	if (thread_info_flags & _TIF_SINGLESTEP) {
467
		regs->flags |= TF_MASK;
L
Linus Torvalds 已提交
468 469 470
		clear_thread_flag(TIF_SINGLESTEP);
	}

471 472 473 474 475 476
#ifdef CONFIG_X86_MCE
	/* notify userspace of pending MCEs */
	if (thread_info_flags & _TIF_MCE_NOTIFY)
		mce_notify_user();
#endif /* CONFIG_X86_MCE */

L
Linus Torvalds 已提交
477
	/* deal with pending signal delivery */
A
Andi Kleen 已提交
478 479
	if (thread_info_flags & (_TIF_SIGPENDING|_TIF_RESTORE_SIGMASK))
		do_signal(regs);
P
Peter Zijlstra 已提交
480 481 482

	if (thread_info_flags & _TIF_HRTICK_RESCHED)
		hrtick_resched();
L
Linus Torvalds 已提交
483 484 485 486 487
}

void signal_fault(struct pt_regs *regs, void __user *frame, char *where)
{ 
	struct task_struct *me = current; 
488
	if (show_unhandled_signals && printk_ratelimit())
489 490
		printk("%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx\n",
	       me->comm,me->pid,where,frame,regs->ip,regs->sp,regs->orig_ax);
L
Linus Torvalds 已提交
491 492 493

	force_sig(SIGSEGV, me); 
}