1 /* 2 * Copyright (C) 1991, 1992 Linus Torvalds 3 * Copyright (C) 2000, 2001, 2002 Andi Kleen SuSE Labs 4 * 5 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson 6 * 2000-06-20 Pentium III FXSR, SSE support by Gareth Hughes 7 * 2000-2002 x86-64 support by Andi Kleen 8 */ 9 10 #include <linux/sched.h> 11 #include <linux/mm.h> 12 #include <linux/smp.h> 13 #include <linux/kernel.h> 14 #include <linux/signal.h> 15 #include <linux/errno.h> 16 #include <linux/wait.h> 17 #include <linux/ptrace.h> 18 #include <linux/tracehook.h> 19 #include <linux/unistd.h> 20 #include <linux/stddef.h> 21 #include <linux/personality.h> 22 #include <linux/uaccess.h> 23 24 #include <asm/processor.h> 25 #include <asm/ucontext.h> 26 #include <asm/i387.h> 27 #include <asm/vdso.h> 28 29 #ifdef CONFIG_X86_64 30 #include <asm/proto.h> 31 #include <asm/ia32_unistd.h> 32 #include <asm/mce.h> 33 #endif /* CONFIG_X86_64 */ 34 35 #include <asm/syscall.h> 36 #include <asm/syscalls.h> 37 38 #include <asm/sigframe.h> 39 40 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 41 42 #define __FIX_EFLAGS (X86_EFLAGS_AC | X86_EFLAGS_OF | \ 43 X86_EFLAGS_DF | X86_EFLAGS_TF | X86_EFLAGS_SF | \ 44 X86_EFLAGS_ZF | X86_EFLAGS_AF | X86_EFLAGS_PF | \ 45 X86_EFLAGS_CF) 46 47 #ifdef CONFIG_X86_32 48 # define FIX_EFLAGS (__FIX_EFLAGS | X86_EFLAGS_RF) 49 #else 50 # define FIX_EFLAGS __FIX_EFLAGS 51 #endif 52 53 #define COPY(x) { \ 54 err |= __get_user(regs->x, &sc->x); \ 55 } 56 57 #define COPY_SEG(seg) { \ 58 unsigned short tmp; \ 59 err |= __get_user(tmp, &sc->seg); \ 60 regs->seg = tmp; \ 61 } 62 63 #define COPY_SEG_CPL3(seg) { \ 64 unsigned short tmp; \ 65 err |= __get_user(tmp, &sc->seg); \ 66 regs->seg = tmp | 3; \ 67 } 68 69 #define GET_SEG(seg) { \ 70 unsigned short tmp; \ 71 err |= __get_user(tmp, &sc->seg); \ 72 loadsegment(seg, tmp); \ 73 } 74 75 static int 76 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, 77 unsigned long *pax) 78 { 79 void __user *buf; 80 unsigned int tmpflags; 81 unsigned int err = 0; 82 83 /* Always make any pending restarted system calls return -EINTR */ 84 current_thread_info()->restart_block.fn = do_no_restart_syscall; 85 86 #ifdef CONFIG_X86_32 87 GET_SEG(gs); 88 COPY_SEG(fs); 89 COPY_SEG(es); 90 COPY_SEG(ds); 91 #endif /* CONFIG_X86_32 */ 92 93 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx); 94 COPY(dx); COPY(cx); COPY(ip); 95 96 #ifdef CONFIG_X86_64 97 COPY(r8); 98 COPY(r9); 99 COPY(r10); 100 COPY(r11); 101 COPY(r12); 102 COPY(r13); 103 COPY(r14); 104 COPY(r15); 105 #endif /* CONFIG_X86_64 */ 106 107 #ifdef CONFIG_X86_32 108 COPY_SEG_CPL3(cs); 109 COPY_SEG_CPL3(ss); 110 #else /* !CONFIG_X86_32 */ 111 /* Kernel saves and restores only the CS segment register on signals, 112 * which is the bare minimum needed to allow mixed 32/64-bit code. 113 * App's signal handler can save/restore other segments if needed. */ 114 COPY_SEG_CPL3(cs); 115 #endif /* CONFIG_X86_32 */ 116 117 err |= __get_user(tmpflags, &sc->flags); 118 regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS); 119 regs->orig_ax = -1; /* disable syscall checks */ 120 121 err |= __get_user(buf, &sc->fpstate); 122 err |= restore_i387_xstate(buf); 123 124 err |= __get_user(*pax, &sc->ax); 125 return err; 126 } 127 128 static int 129 setup_sigcontext(struct sigcontext __user *sc, void __user *fpstate, 130 struct pt_regs *regs, unsigned long mask) 131 { 132 int err = 0; 133 134 #ifdef CONFIG_X86_32 135 { 136 unsigned int tmp; 137 138 savesegment(gs, tmp); 139 err |= __put_user(tmp, (unsigned int __user *)&sc->gs); 140 } 141 err |= __put_user(regs->fs, (unsigned int __user *)&sc->fs); 142 err |= __put_user(regs->es, (unsigned int __user *)&sc->es); 143 err |= __put_user(regs->ds, (unsigned int __user *)&sc->ds); 144 #endif /* CONFIG_X86_32 */ 145 146 err |= __put_user(regs->di, &sc->di); 147 err |= __put_user(regs->si, &sc->si); 148 err |= __put_user(regs->bp, &sc->bp); 149 err |= __put_user(regs->sp, &sc->sp); 150 err |= __put_user(regs->bx, &sc->bx); 151 err |= __put_user(regs->dx, &sc->dx); 152 err |= __put_user(regs->cx, &sc->cx); 153 err |= __put_user(regs->ax, &sc->ax); 154 #ifdef CONFIG_X86_64 155 err |= __put_user(regs->r8, &sc->r8); 156 err |= __put_user(regs->r9, &sc->r9); 157 err |= __put_user(regs->r10, &sc->r10); 158 err |= __put_user(regs->r11, &sc->r11); 159 err |= __put_user(regs->r12, &sc->r12); 160 err |= __put_user(regs->r13, &sc->r13); 161 err |= __put_user(regs->r14, &sc->r14); 162 err |= __put_user(regs->r15, &sc->r15); 163 #endif /* CONFIG_X86_64 */ 164 165 err |= __put_user(current->thread.trap_no, &sc->trapno); 166 err |= __put_user(current->thread.error_code, &sc->err); 167 err |= __put_user(regs->ip, &sc->ip); 168 #ifdef CONFIG_X86_32 169 err |= __put_user(regs->cs, (unsigned int __user *)&sc->cs); 170 err |= __put_user(regs->flags, &sc->flags); 171 err |= __put_user(regs->sp, &sc->sp_at_signal); 172 err |= __put_user(regs->ss, (unsigned int __user *)&sc->ss); 173 #else /* !CONFIG_X86_32 */ 174 err |= __put_user(regs->flags, &sc->flags); 175 err |= __put_user(regs->cs, &sc->cs); 176 err |= __put_user(0, &sc->gs); 177 err |= __put_user(0, &sc->fs); 178 #endif /* CONFIG_X86_32 */ 179 180 err |= __put_user(fpstate, &sc->fpstate); 181 182 /* non-iBCS2 extensions.. */ 183 err |= __put_user(mask, &sc->oldmask); 184 err |= __put_user(current->thread.cr2, &sc->cr2); 185 186 return err; 187 } 188 189 /* 190 * Set up a signal frame. 191 */ 192 #ifdef CONFIG_X86_32 193 static const struct { 194 u16 poplmovl; 195 u32 val; 196 u16 int80; 197 } __attribute__((packed)) retcode = { 198 0xb858, /* popl %eax; movl $..., %eax */ 199 __NR_sigreturn, 200 0x80cd, /* int $0x80 */ 201 }; 202 203 static const struct { 204 u8 movl; 205 u32 val; 206 u16 int80; 207 u8 pad; 208 } __attribute__((packed)) rt_retcode = { 209 0xb8, /* movl $..., %eax */ 210 __NR_rt_sigreturn, 211 0x80cd, /* int $0x80 */ 212 0 213 }; 214 215 /* 216 * Determine which stack to use.. 217 */ 218 static inline void __user * 219 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size, 220 void **fpstate) 221 { 222 unsigned long sp; 223 224 /* Default to using normal stack */ 225 sp = regs->sp; 226 227 /* 228 * If we are on the alternate signal stack and would overflow it, don't. 229 * Return an always-bogus address instead so we will die with SIGSEGV. 230 */ 231 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size))) 232 return (void __user *) -1L; 233 234 /* This is the X/Open sanctioned signal stack switching. */ 235 if (ka->sa.sa_flags & SA_ONSTACK) { 236 if (sas_ss_flags(sp) == 0) 237 sp = current->sas_ss_sp + current->sas_ss_size; 238 } else { 239 /* This is the legacy signal stack switching. */ 240 if ((regs->ss & 0xffff) != __USER_DS && 241 !(ka->sa.sa_flags & SA_RESTORER) && 242 ka->sa.sa_restorer) 243 sp = (unsigned long) ka->sa.sa_restorer; 244 } 245 246 if (used_math()) { 247 sp = sp - sig_xstate_size; 248 *fpstate = (struct _fpstate *) sp; 249 if (save_i387_xstate(*fpstate) < 0) 250 return (void __user *)-1L; 251 } 252 253 sp -= frame_size; 254 /* 255 * Align the stack pointer according to the i386 ABI, 256 * i.e. so that on function entry ((sp + 4) & 15) == 0. 257 */ 258 sp = ((sp + 4) & -16ul) - 4; 259 260 return (void __user *) sp; 261 } 262 263 static int 264 __setup_frame(int sig, struct k_sigaction *ka, sigset_t *set, 265 struct pt_regs *regs) 266 { 267 struct sigframe __user *frame; 268 void __user *restorer; 269 int err = 0; 270 void __user *fpstate = NULL; 271 272 frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate); 273 274 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 275 return -EFAULT; 276 277 if (__put_user(sig, &frame->sig)) 278 return -EFAULT; 279 280 if (setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0])) 281 return -EFAULT; 282 283 if (_NSIG_WORDS > 1) { 284 if (__copy_to_user(&frame->extramask, &set->sig[1], 285 sizeof(frame->extramask))) 286 return -EFAULT; 287 } 288 289 if (current->mm->context.vdso) 290 restorer = VDSO32_SYMBOL(current->mm->context.vdso, sigreturn); 291 else 292 restorer = &frame->retcode; 293 if (ka->sa.sa_flags & SA_RESTORER) 294 restorer = ka->sa.sa_restorer; 295 296 /* Set up to return from userspace. */ 297 err |= __put_user(restorer, &frame->pretcode); 298 299 /* 300 * This is popl %eax ; movl $__NR_sigreturn, %eax ; int $0x80 301 * 302 * WE DO NOT USE IT ANY MORE! It's only left here for historical 303 * reasons and because gdb uses it as a signature to notice 304 * signal handler stack frames. 305 */ 306 err |= __put_user(*((u64 *)&retcode), (u64 *)frame->retcode); 307 308 if (err) 309 return -EFAULT; 310 311 /* Set up registers for signal handler */ 312 regs->sp = (unsigned long)frame; 313 regs->ip = (unsigned long)ka->sa.sa_handler; 314 regs->ax = (unsigned long)sig; 315 regs->dx = 0; 316 regs->cx = 0; 317 318 regs->ds = __USER_DS; 319 regs->es = __USER_DS; 320 regs->ss = __USER_DS; 321 regs->cs = __USER_CS; 322 323 return 0; 324 } 325 326 static int __setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 327 sigset_t *set, struct pt_regs *regs) 328 { 329 struct rt_sigframe __user *frame; 330 void __user *restorer; 331 int err = 0; 332 void __user *fpstate = NULL; 333 334 frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate); 335 336 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 337 return -EFAULT; 338 339 err |= __put_user(sig, &frame->sig); 340 err |= __put_user(&frame->info, &frame->pinfo); 341 err |= __put_user(&frame->uc, &frame->puc); 342 err |= copy_siginfo_to_user(&frame->info, info); 343 if (err) 344 return -EFAULT; 345 346 /* Create the ucontext. */ 347 if (cpu_has_xsave) 348 err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags); 349 else 350 err |= __put_user(0, &frame->uc.uc_flags); 351 err |= __put_user(0, &frame->uc.uc_link); 352 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 353 err |= __put_user(sas_ss_flags(regs->sp), 354 &frame->uc.uc_stack.ss_flags); 355 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 356 err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate, 357 regs, set->sig[0]); 358 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 359 if (err) 360 return -EFAULT; 361 362 /* Set up to return from userspace. */ 363 restorer = VDSO32_SYMBOL(current->mm->context.vdso, rt_sigreturn); 364 if (ka->sa.sa_flags & SA_RESTORER) 365 restorer = ka->sa.sa_restorer; 366 err |= __put_user(restorer, &frame->pretcode); 367 368 /* 369 * This is movl $__NR_rt_sigreturn, %ax ; int $0x80 370 * 371 * WE DO NOT USE IT ANY MORE! It's only left here for historical 372 * reasons and because gdb uses it as a signature to notice 373 * signal handler stack frames. 374 */ 375 err |= __put_user(*((u64 *)&rt_retcode), (u64 *)frame->retcode); 376 377 if (err) 378 return -EFAULT; 379 380 /* Set up registers for signal handler */ 381 regs->sp = (unsigned long)frame; 382 regs->ip = (unsigned long)ka->sa.sa_handler; 383 regs->ax = (unsigned long)sig; 384 regs->dx = (unsigned long)&frame->info; 385 regs->cx = (unsigned long)&frame->uc; 386 387 regs->ds = __USER_DS; 388 regs->es = __USER_DS; 389 regs->ss = __USER_DS; 390 regs->cs = __USER_CS; 391 392 return 0; 393 } 394 #else /* !CONFIG_X86_32 */ 395 /* 396 * Determine which stack to use.. 397 */ 398 static void __user * 399 get_stack(struct k_sigaction *ka, unsigned long sp, unsigned long size) 400 { 401 /* Default to using normal stack - redzone*/ 402 sp -= 128; 403 404 /* This is the X/Open sanctioned signal stack switching. */ 405 if (ka->sa.sa_flags & SA_ONSTACK) { 406 if (sas_ss_flags(sp) == 0) 407 sp = current->sas_ss_sp + current->sas_ss_size; 408 } 409 410 return (void __user *)round_down(sp - size, 64); 411 } 412 413 static int __setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 414 sigset_t *set, struct pt_regs *regs) 415 { 416 struct rt_sigframe __user *frame; 417 void __user *fp = NULL; 418 int err = 0; 419 struct task_struct *me = current; 420 421 if (used_math()) { 422 fp = get_stack(ka, regs->sp, sig_xstate_size); 423 frame = (void __user *)round_down( 424 (unsigned long)fp - sizeof(struct rt_sigframe), 16) - 8; 425 426 if (save_i387_xstate(fp) < 0) 427 return -EFAULT; 428 } else 429 frame = get_stack(ka, regs->sp, sizeof(struct rt_sigframe)) - 8; 430 431 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 432 return -EFAULT; 433 434 if (ka->sa.sa_flags & SA_SIGINFO) { 435 if (copy_siginfo_to_user(&frame->info, info)) 436 return -EFAULT; 437 } 438 439 /* Create the ucontext. */ 440 if (cpu_has_xsave) 441 err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags); 442 else 443 err |= __put_user(0, &frame->uc.uc_flags); 444 err |= __put_user(0, &frame->uc.uc_link); 445 err |= __put_user(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 446 err |= __put_user(sas_ss_flags(regs->sp), 447 &frame->uc.uc_stack.ss_flags); 448 err |= __put_user(me->sas_ss_size, &frame->uc.uc_stack.ss_size); 449 err |= setup_sigcontext(&frame->uc.uc_mcontext, fp, regs, set->sig[0]); 450 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 451 452 /* Set up to return from userspace. If provided, use a stub 453 already in userspace. */ 454 /* x86-64 should always use SA_RESTORER. */ 455 if (ka->sa.sa_flags & SA_RESTORER) { 456 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode); 457 } else { 458 /* could use a vstub here */ 459 return -EFAULT; 460 } 461 462 if (err) 463 return -EFAULT; 464 465 /* Set up registers for signal handler */ 466 regs->di = sig; 467 /* In case the signal handler was declared without prototypes */ 468 regs->ax = 0; 469 470 /* This also works for non SA_SIGINFO handlers because they expect the 471 next argument after the signal number on the stack. */ 472 regs->si = (unsigned long)&frame->info; 473 regs->dx = (unsigned long)&frame->uc; 474 regs->ip = (unsigned long) ka->sa.sa_handler; 475 476 regs->sp = (unsigned long)frame; 477 478 /* Set up the CS register to run signal handlers in 64-bit mode, 479 even if the handler happens to be interrupting 32-bit code. */ 480 regs->cs = __USER_CS; 481 482 return 0; 483 } 484 #endif /* CONFIG_X86_32 */ 485 486 #ifdef CONFIG_X86_32 487 /* 488 * Atomically swap in the new signal mask, and wait for a signal. 489 */ 490 asmlinkage int 491 sys_sigsuspend(int history0, int history1, old_sigset_t mask) 492 { 493 mask &= _BLOCKABLE; 494 spin_lock_irq(¤t->sighand->siglock); 495 current->saved_sigmask = current->blocked; 496 siginitset(¤t->blocked, mask); 497 recalc_sigpending(); 498 spin_unlock_irq(¤t->sighand->siglock); 499 500 current->state = TASK_INTERRUPTIBLE; 501 schedule(); 502 set_restore_sigmask(); 503 504 return -ERESTARTNOHAND; 505 } 506 507 asmlinkage int 508 sys_sigaction(int sig, const struct old_sigaction __user *act, 509 struct old_sigaction __user *oact) 510 { 511 struct k_sigaction new_ka, old_ka; 512 int ret; 513 514 if (act) { 515 old_sigset_t mask; 516 517 if (!access_ok(VERIFY_READ, act, sizeof(*act)) || 518 __get_user(new_ka.sa.sa_handler, &act->sa_handler) || 519 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer)) 520 return -EFAULT; 521 522 __get_user(new_ka.sa.sa_flags, &act->sa_flags); 523 __get_user(mask, &act->sa_mask); 524 siginitset(&new_ka.sa.sa_mask, mask); 525 } 526 527 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 528 529 if (!ret && oact) { 530 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || 531 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) || 532 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer)) 533 return -EFAULT; 534 535 __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 536 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask); 537 } 538 539 return ret; 540 } 541 #endif /* CONFIG_X86_32 */ 542 543 #ifdef CONFIG_X86_32 544 asmlinkage int sys_sigaltstack(unsigned long bx) 545 { 546 /* 547 * This is needed to make gcc realize it doesn't own the 548 * "struct pt_regs" 549 */ 550 struct pt_regs *regs = (struct pt_regs *)&bx; 551 const stack_t __user *uss = (const stack_t __user *)bx; 552 stack_t __user *uoss = (stack_t __user *)regs->cx; 553 554 return do_sigaltstack(uss, uoss, regs->sp); 555 } 556 #else /* !CONFIG_X86_32 */ 557 asmlinkage long 558 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, 559 struct pt_regs *regs) 560 { 561 return do_sigaltstack(uss, uoss, regs->sp); 562 } 563 #endif /* CONFIG_X86_32 */ 564 565 /* 566 * Do a signal return; undo the signal stack. 567 */ 568 #ifdef CONFIG_X86_32 569 asmlinkage unsigned long sys_sigreturn(unsigned long __unused) 570 { 571 struct sigframe __user *frame; 572 struct pt_regs *regs; 573 unsigned long ax; 574 sigset_t set; 575 576 regs = (struct pt_regs *) &__unused; 577 frame = (struct sigframe __user *)(regs->sp - 8); 578 579 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 580 goto badframe; 581 if (__get_user(set.sig[0], &frame->sc.oldmask) || (_NSIG_WORDS > 1 582 && __copy_from_user(&set.sig[1], &frame->extramask, 583 sizeof(frame->extramask)))) 584 goto badframe; 585 586 sigdelsetmask(&set, ~_BLOCKABLE); 587 spin_lock_irq(¤t->sighand->siglock); 588 current->blocked = set; 589 recalc_sigpending(); 590 spin_unlock_irq(¤t->sighand->siglock); 591 592 if (restore_sigcontext(regs, &frame->sc, &ax)) 593 goto badframe; 594 return ax; 595 596 badframe: 597 signal_fault(regs, frame, "sigreturn"); 598 599 return 0; 600 } 601 #endif /* CONFIG_X86_32 */ 602 603 static long do_rt_sigreturn(struct pt_regs *regs) 604 { 605 struct rt_sigframe __user *frame; 606 unsigned long ax; 607 sigset_t set; 608 609 frame = (struct rt_sigframe __user *)(regs->sp - sizeof(long)); 610 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 611 goto badframe; 612 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 613 goto badframe; 614 615 sigdelsetmask(&set, ~_BLOCKABLE); 616 spin_lock_irq(¤t->sighand->siglock); 617 current->blocked = set; 618 recalc_sigpending(); 619 spin_unlock_irq(¤t->sighand->siglock); 620 621 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax)) 622 goto badframe; 623 624 if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->sp) == -EFAULT) 625 goto badframe; 626 627 return ax; 628 629 badframe: 630 signal_fault(regs, frame, "rt_sigreturn"); 631 return 0; 632 } 633 634 #ifdef CONFIG_X86_32 635 /* 636 * Note: do not pass in pt_regs directly as with tail-call optimization 637 * GCC will incorrectly stomp on the caller's frame and corrupt user-space 638 * register state: 639 */ 640 asmlinkage int sys_rt_sigreturn(unsigned long __unused) 641 { 642 struct pt_regs *regs = (struct pt_regs *)&__unused; 643 644 return do_rt_sigreturn(regs); 645 } 646 #else /* !CONFIG_X86_32 */ 647 asmlinkage long sys_rt_sigreturn(struct pt_regs *regs) 648 { 649 return do_rt_sigreturn(regs); 650 } 651 #endif /* CONFIG_X86_32 */ 652 653 /* 654 * OK, we're invoking a handler: 655 */ 656 static int signr_convert(int sig) 657 { 658 #ifdef CONFIG_X86_32 659 struct thread_info *info = current_thread_info(); 660 661 if (info->exec_domain && info->exec_domain->signal_invmap && sig < 32) 662 return info->exec_domain->signal_invmap[sig]; 663 #endif /* CONFIG_X86_32 */ 664 return sig; 665 } 666 667 #ifdef CONFIG_X86_32 668 669 #define is_ia32 1 670 #define ia32_setup_frame __setup_frame 671 #define ia32_setup_rt_frame __setup_rt_frame 672 673 #else /* !CONFIG_X86_32 */ 674 675 #ifdef CONFIG_IA32_EMULATION 676 #define is_ia32 test_thread_flag(TIF_IA32) 677 #else /* !CONFIG_IA32_EMULATION */ 678 #define is_ia32 0 679 #endif /* CONFIG_IA32_EMULATION */ 680 681 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 682 sigset_t *set, struct pt_regs *regs); 683 int ia32_setup_frame(int sig, struct k_sigaction *ka, 684 sigset_t *set, struct pt_regs *regs); 685 686 #endif /* CONFIG_X86_32 */ 687 688 static int 689 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 690 sigset_t *set, struct pt_regs *regs) 691 { 692 int usig = signr_convert(sig); 693 int ret; 694 695 /* Set up the stack frame */ 696 if (is_ia32) { 697 if (ka->sa.sa_flags & SA_SIGINFO) 698 ret = ia32_setup_rt_frame(usig, ka, info, set, regs); 699 else 700 ret = ia32_setup_frame(usig, ka, set, regs); 701 } else 702 ret = __setup_rt_frame(sig, ka, info, set, regs); 703 704 if (ret) { 705 force_sigsegv(sig, current); 706 return -EFAULT; 707 } 708 709 return ret; 710 } 711 712 static int 713 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka, 714 sigset_t *oldset, struct pt_regs *regs) 715 { 716 int ret; 717 718 /* Are we from a system call? */ 719 if (syscall_get_nr(current, regs) >= 0) { 720 /* If so, check system call restarting.. */ 721 switch (syscall_get_error(current, regs)) { 722 case -ERESTART_RESTARTBLOCK: 723 case -ERESTARTNOHAND: 724 regs->ax = -EINTR; 725 break; 726 727 case -ERESTARTSYS: 728 if (!(ka->sa.sa_flags & SA_RESTART)) { 729 regs->ax = -EINTR; 730 break; 731 } 732 /* fallthrough */ 733 case -ERESTARTNOINTR: 734 regs->ax = regs->orig_ax; 735 regs->ip -= 2; 736 break; 737 } 738 } 739 740 /* 741 * If TF is set due to a debugger (TIF_FORCED_TF), clear the TF 742 * flag so that register information in the sigcontext is correct. 743 */ 744 if (unlikely(regs->flags & X86_EFLAGS_TF) && 745 likely(test_and_clear_thread_flag(TIF_FORCED_TF))) 746 regs->flags &= ~X86_EFLAGS_TF; 747 748 ret = setup_rt_frame(sig, ka, info, oldset, regs); 749 750 if (ret) 751 return ret; 752 753 #ifdef CONFIG_X86_64 754 /* 755 * This has nothing to do with segment registers, 756 * despite the name. This magic affects uaccess.h 757 * macros' behavior. Reset it to the normal setting. 758 */ 759 set_fs(USER_DS); 760 #endif 761 762 /* 763 * Clear the direction flag as per the ABI for function entry. 764 */ 765 regs->flags &= ~X86_EFLAGS_DF; 766 767 /* 768 * Clear TF when entering the signal handler, but 769 * notify any tracer that was single-stepping it. 770 * The tracer may want to single-step inside the 771 * handler too. 772 */ 773 regs->flags &= ~X86_EFLAGS_TF; 774 775 spin_lock_irq(¤t->sighand->siglock); 776 sigorsets(¤t->blocked, ¤t->blocked, &ka->sa.sa_mask); 777 if (!(ka->sa.sa_flags & SA_NODEFER)) 778 sigaddset(¤t->blocked, sig); 779 recalc_sigpending(); 780 spin_unlock_irq(¤t->sighand->siglock); 781 782 tracehook_signal_handler(sig, info, ka, regs, 783 test_thread_flag(TIF_SINGLESTEP)); 784 785 return 0; 786 } 787 788 #ifdef CONFIG_X86_32 789 #define NR_restart_syscall __NR_restart_syscall 790 #else /* !CONFIG_X86_32 */ 791 #define NR_restart_syscall \ 792 test_thread_flag(TIF_IA32) ? __NR_ia32_restart_syscall : __NR_restart_syscall 793 #endif /* CONFIG_X86_32 */ 794 795 /* 796 * Note that 'init' is a special process: it doesn't get signals it doesn't 797 * want to handle. Thus you cannot kill init even with a SIGKILL even by 798 * mistake. 799 */ 800 static void do_signal(struct pt_regs *regs) 801 { 802 struct k_sigaction ka; 803 siginfo_t info; 804 int signr; 805 sigset_t *oldset; 806 807 /* 808 * We want the common case to go fast, which is why we may in certain 809 * cases get here from kernel mode. Just return without doing anything 810 * if so. 811 * X86_32: vm86 regs switched out by assembly code before reaching 812 * here, so testing against kernel CS suffices. 813 */ 814 if (!user_mode(regs)) 815 return; 816 817 if (current_thread_info()->status & TS_RESTORE_SIGMASK) 818 oldset = ¤t->saved_sigmask; 819 else 820 oldset = ¤t->blocked; 821 822 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 823 if (signr > 0) { 824 /* 825 * Re-enable any watchpoints before delivering the 826 * signal to user space. The processor register will 827 * have been cleared if the watchpoint triggered 828 * inside the kernel. 829 */ 830 if (current->thread.debugreg7) 831 set_debugreg(current->thread.debugreg7, 7); 832 833 /* Whee! Actually deliver the signal. */ 834 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) { 835 /* 836 * A signal was successfully delivered; the saved 837 * sigmask will have been stored in the signal frame, 838 * and will be restored by sigreturn, so we can simply 839 * clear the TS_RESTORE_SIGMASK flag. 840 */ 841 current_thread_info()->status &= ~TS_RESTORE_SIGMASK; 842 } 843 return; 844 } 845 846 /* Did we come from a system call? */ 847 if (syscall_get_nr(current, regs) >= 0) { 848 /* Restart the system call - no handlers present */ 849 switch (syscall_get_error(current, regs)) { 850 case -ERESTARTNOHAND: 851 case -ERESTARTSYS: 852 case -ERESTARTNOINTR: 853 regs->ax = regs->orig_ax; 854 regs->ip -= 2; 855 break; 856 857 case -ERESTART_RESTARTBLOCK: 858 regs->ax = NR_restart_syscall; 859 regs->ip -= 2; 860 break; 861 } 862 } 863 864 /* 865 * If there's no signal to deliver, we just put the saved sigmask 866 * back. 867 */ 868 if (current_thread_info()->status & TS_RESTORE_SIGMASK) { 869 current_thread_info()->status &= ~TS_RESTORE_SIGMASK; 870 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 871 } 872 } 873 874 /* 875 * notification of userspace execution resumption 876 * - triggered by the TIF_WORK_MASK flags 877 */ 878 void 879 do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags) 880 { 881 #if defined(CONFIG_X86_64) && defined(CONFIG_X86_MCE) 882 /* notify userspace of pending MCEs */ 883 if (thread_info_flags & _TIF_MCE_NOTIFY) 884 mce_notify_user(); 885 #endif /* CONFIG_X86_64 && CONFIG_X86_MCE */ 886 887 /* deal with pending signal delivery */ 888 if (thread_info_flags & _TIF_SIGPENDING) 889 do_signal(regs); 890 891 if (thread_info_flags & _TIF_NOTIFY_RESUME) { 892 clear_thread_flag(TIF_NOTIFY_RESUME); 893 tracehook_notify_resume(regs); 894 } 895 896 #ifdef CONFIG_X86_32 897 clear_thread_flag(TIF_IRET); 898 #endif /* CONFIG_X86_32 */ 899 } 900 901 void signal_fault(struct pt_regs *regs, void __user *frame, char *where) 902 { 903 struct task_struct *me = current; 904 905 if (show_unhandled_signals && printk_ratelimit()) { 906 printk("%s" 907 "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx", 908 task_pid_nr(current) > 1 ? KERN_INFO : KERN_EMERG, 909 me->comm, me->pid, where, frame, 910 regs->ip, regs->sp, regs->orig_ax); 911 print_vma_addr(" in ", regs->ip); 912 printk(KERN_CONT "\n"); 913 } 914 915 force_sig(SIGSEGV, me); 916 } 917