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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 11 12 #include <linux/sched.h> 13 #include <linux/mm.h> 14 #include <linux/smp.h> 15 #include <linux/kernel.h> 16 #include <linux/errno.h> 17 #include <linux/wait.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 #include <linux/user-return-notifier.h> 24 #include <linux/uprobes.h> 25 #include <linux/context_tracking.h> 26 27 #include <asm/processor.h> 28 #include <asm/ucontext.h> 29 #include <asm/i387.h> 30 #include <asm/fpu-internal.h> 31 #include <asm/vdso.h> 32 #include <asm/mce.h> 33 #include <asm/sighandling.h> 34 35 #ifdef CONFIG_X86_64 36 #include <asm/proto.h> 37 #include <asm/ia32_unistd.h> 38 #include <asm/sys_ia32.h> 39 #endif /* CONFIG_X86_64 */ 40 41 #include <asm/syscall.h> 42 #include <asm/syscalls.h> 43 44 #include <asm/sigframe.h> 45 46 #ifdef CONFIG_X86_32 47 # define FIX_EFLAGS (__FIX_EFLAGS | X86_EFLAGS_RF) 48 #else 49 # define FIX_EFLAGS __FIX_EFLAGS 50 #endif 51 52 #define COPY(x) do { \ 53 get_user_ex(regs->x, &sc->x); \ 54 } while (0) 55 56 #define GET_SEG(seg) ({ \ 57 unsigned short tmp; \ 58 get_user_ex(tmp, &sc->seg); \ 59 tmp; \ 60 }) 61 62 #define COPY_SEG(seg) do { \ 63 regs->seg = GET_SEG(seg); \ 64 } while (0) 65 66 #define COPY_SEG_CPL3(seg) do { \ 67 regs->seg = GET_SEG(seg) | 3; \ 68 } while (0) 69 70 int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, 71 unsigned long *pax) 72 { 73 void __user *buf; 74 unsigned int tmpflags; 75 unsigned int err = 0; 76 77 /* Always make any pending restarted system calls return -EINTR */ 78 current_thread_info()->restart_block.fn = do_no_restart_syscall; 79 80 get_user_try { 81 82 #ifdef CONFIG_X86_32 83 set_user_gs(regs, GET_SEG(gs)); 84 COPY_SEG(fs); 85 COPY_SEG(es); 86 COPY_SEG(ds); 87 #endif /* CONFIG_X86_32 */ 88 89 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx); 90 COPY(dx); COPY(cx); COPY(ip); 91 92 #ifdef CONFIG_X86_64 93 COPY(r8); 94 COPY(r9); 95 COPY(r10); 96 COPY(r11); 97 COPY(r12); 98 COPY(r13); 99 COPY(r14); 100 COPY(r15); 101 #endif /* CONFIG_X86_64 */ 102 103 #ifdef CONFIG_X86_32 104 COPY_SEG_CPL3(cs); 105 COPY_SEG_CPL3(ss); 106 #else /* !CONFIG_X86_32 */ 107 /* Kernel saves and restores only the CS segment register on signals, 108 * which is the bare minimum needed to allow mixed 32/64-bit code. 109 * App's signal handler can save/restore other segments if needed. */ 110 COPY_SEG_CPL3(cs); 111 #endif /* CONFIG_X86_32 */ 112 113 get_user_ex(tmpflags, &sc->flags); 114 regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS); 115 regs->orig_ax = -1; /* disable syscall checks */ 116 117 get_user_ex(buf, &sc->fpstate); 118 119 get_user_ex(*pax, &sc->ax); 120 } get_user_catch(err); 121 122 err |= restore_xstate_sig(buf, config_enabled(CONFIG_X86_32)); 123 124 return err; 125 } 126 127 int setup_sigcontext(struct sigcontext __user *sc, void __user *fpstate, 128 struct pt_regs *regs, unsigned long mask) 129 { 130 int err = 0; 131 132 put_user_try { 133 134 #ifdef CONFIG_X86_32 135 put_user_ex(get_user_gs(regs), (unsigned int __user *)&sc->gs); 136 put_user_ex(regs->fs, (unsigned int __user *)&sc->fs); 137 put_user_ex(regs->es, (unsigned int __user *)&sc->es); 138 put_user_ex(regs->ds, (unsigned int __user *)&sc->ds); 139 #endif /* CONFIG_X86_32 */ 140 141 put_user_ex(regs->di, &sc->di); 142 put_user_ex(regs->si, &sc->si); 143 put_user_ex(regs->bp, &sc->bp); 144 put_user_ex(regs->sp, &sc->sp); 145 put_user_ex(regs->bx, &sc->bx); 146 put_user_ex(regs->dx, &sc->dx); 147 put_user_ex(regs->cx, &sc->cx); 148 put_user_ex(regs->ax, &sc->ax); 149 #ifdef CONFIG_X86_64 150 put_user_ex(regs->r8, &sc->r8); 151 put_user_ex(regs->r9, &sc->r9); 152 put_user_ex(regs->r10, &sc->r10); 153 put_user_ex(regs->r11, &sc->r11); 154 put_user_ex(regs->r12, &sc->r12); 155 put_user_ex(regs->r13, &sc->r13); 156 put_user_ex(regs->r14, &sc->r14); 157 put_user_ex(regs->r15, &sc->r15); 158 #endif /* CONFIG_X86_64 */ 159 160 put_user_ex(current->thread.trap_nr, &sc->trapno); 161 put_user_ex(current->thread.error_code, &sc->err); 162 put_user_ex(regs->ip, &sc->ip); 163 #ifdef CONFIG_X86_32 164 put_user_ex(regs->cs, (unsigned int __user *)&sc->cs); 165 put_user_ex(regs->flags, &sc->flags); 166 put_user_ex(regs->sp, &sc->sp_at_signal); 167 put_user_ex(regs->ss, (unsigned int __user *)&sc->ss); 168 #else /* !CONFIG_X86_32 */ 169 put_user_ex(regs->flags, &sc->flags); 170 put_user_ex(regs->cs, &sc->cs); 171 put_user_ex(0, &sc->gs); 172 put_user_ex(0, &sc->fs); 173 #endif /* CONFIG_X86_32 */ 174 175 put_user_ex(fpstate, &sc->fpstate); 176 177 /* non-iBCS2 extensions.. */ 178 put_user_ex(mask, &sc->oldmask); 179 put_user_ex(current->thread.cr2, &sc->cr2); 180 } put_user_catch(err); 181 182 return err; 183 } 184 185 /* 186 * Set up a signal frame. 187 */ 188 189 /* 190 * Determine which stack to use.. 191 */ 192 static unsigned long align_sigframe(unsigned long sp) 193 { 194 #ifdef CONFIG_X86_32 195 /* 196 * Align the stack pointer according to the i386 ABI, 197 * i.e. so that on function entry ((sp + 4) & 15) == 0. 198 */ 199 sp = ((sp + 4) & -16ul) - 4; 200 #else /* !CONFIG_X86_32 */ 201 sp = round_down(sp, 16) - 8; 202 #endif 203 return sp; 204 } 205 206 static inline void __user * 207 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size, 208 void __user **fpstate) 209 { 210 /* Default to using normal stack */ 211 unsigned long math_size = 0; 212 unsigned long sp = regs->sp; 213 unsigned long buf_fx = 0; 214 int onsigstack = on_sig_stack(sp); 215 216 /* redzone */ 217 if (config_enabled(CONFIG_X86_64)) 218 sp -= 128; 219 220 if (!onsigstack) { 221 /* This is the X/Open sanctioned signal stack switching. */ 222 if (ka->sa.sa_flags & SA_ONSTACK) { 223 if (current->sas_ss_size) 224 sp = current->sas_ss_sp + current->sas_ss_size; 225 } else if (config_enabled(CONFIG_X86_32) && 226 (regs->ss & 0xffff) != __USER_DS && 227 !(ka->sa.sa_flags & SA_RESTORER) && 228 ka->sa.sa_restorer) { 229 /* This is the legacy signal stack switching. */ 230 sp = (unsigned long) ka->sa.sa_restorer; 231 } 232 } 233 234 if (used_math()) { 235 sp = alloc_mathframe(sp, config_enabled(CONFIG_X86_32), 236 &buf_fx, &math_size); 237 *fpstate = (void __user *)sp; 238 } 239 240 sp = align_sigframe(sp - frame_size); 241 242 /* 243 * If we are on the alternate signal stack and would overflow it, don't. 244 * Return an always-bogus address instead so we will die with SIGSEGV. 245 */ 246 if (onsigstack && !likely(on_sig_stack(sp))) 247 return (void __user *)-1L; 248 249 /* save i387 and extended state */ 250 if (used_math() && 251 save_xstate_sig(*fpstate, (void __user *)buf_fx, math_size) < 0) 252 return (void __user *)-1L; 253 254 return (void __user *)sp; 255 } 256 257 #ifdef CONFIG_X86_32 258 static const struct { 259 u16 poplmovl; 260 u32 val; 261 u16 int80; 262 } __attribute__((packed)) retcode = { 263 0xb858, /* popl %eax; movl $..., %eax */ 264 __NR_sigreturn, 265 0x80cd, /* int $0x80 */ 266 }; 267 268 static const struct { 269 u8 movl; 270 u32 val; 271 u16 int80; 272 u8 pad; 273 } __attribute__((packed)) rt_retcode = { 274 0xb8, /* movl $..., %eax */ 275 __NR_rt_sigreturn, 276 0x80cd, /* int $0x80 */ 277 0 278 }; 279 280 static int 281 __setup_frame(int sig, struct ksignal *ksig, sigset_t *set, 282 struct pt_regs *regs) 283 { 284 struct sigframe __user *frame; 285 void __user *restorer; 286 int err = 0; 287 void __user *fpstate = NULL; 288 289 frame = get_sigframe(&ksig->ka, regs, sizeof(*frame), &fpstate); 290 291 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 292 return -EFAULT; 293 294 if (__put_user(sig, &frame->sig)) 295 return -EFAULT; 296 297 if (setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0])) 298 return -EFAULT; 299 300 if (_NSIG_WORDS > 1) { 301 if (__copy_to_user(&frame->extramask, &set->sig[1], 302 sizeof(frame->extramask))) 303 return -EFAULT; 304 } 305 306 if (current->mm->context.vdso) 307 restorer = VDSO32_SYMBOL(current->mm->context.vdso, sigreturn); 308 else 309 restorer = &frame->retcode; 310 if (ksig->ka.sa.sa_flags & SA_RESTORER) 311 restorer = ksig->ka.sa.sa_restorer; 312 313 /* Set up to return from userspace. */ 314 err |= __put_user(restorer, &frame->pretcode); 315 316 /* 317 * This is popl %eax ; movl $__NR_sigreturn, %eax ; int $0x80 318 * 319 * WE DO NOT USE IT ANY MORE! It's only left here for historical 320 * reasons and because gdb uses it as a signature to notice 321 * signal handler stack frames. 322 */ 323 err |= __put_user(*((u64 *)&retcode), (u64 *)frame->retcode); 324 325 if (err) 326 return -EFAULT; 327 328 /* Set up registers for signal handler */ 329 regs->sp = (unsigned long)frame; 330 regs->ip = (unsigned long)ksig->ka.sa.sa_handler; 331 regs->ax = (unsigned long)sig; 332 regs->dx = 0; 333 regs->cx = 0; 334 335 regs->ds = __USER_DS; 336 regs->es = __USER_DS; 337 regs->ss = __USER_DS; 338 regs->cs = __USER_CS; 339 340 return 0; 341 } 342 343 static int __setup_rt_frame(int sig, struct ksignal *ksig, 344 sigset_t *set, struct pt_regs *regs) 345 { 346 struct rt_sigframe __user *frame; 347 void __user *restorer; 348 int err = 0; 349 void __user *fpstate = NULL; 350 351 frame = get_sigframe(&ksig->ka, regs, sizeof(*frame), &fpstate); 352 353 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 354 return -EFAULT; 355 356 put_user_try { 357 put_user_ex(sig, &frame->sig); 358 put_user_ex(&frame->info, &frame->pinfo); 359 put_user_ex(&frame->uc, &frame->puc); 360 361 /* Create the ucontext. */ 362 if (cpu_has_xsave) 363 put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags); 364 else 365 put_user_ex(0, &frame->uc.uc_flags); 366 put_user_ex(0, &frame->uc.uc_link); 367 err |= __save_altstack(&frame->uc.uc_stack, regs->sp); 368 369 /* Set up to return from userspace. */ 370 restorer = VDSO32_SYMBOL(current->mm->context.vdso, rt_sigreturn); 371 if (ksig->ka.sa.sa_flags & SA_RESTORER) 372 restorer = ksig->ka.sa.sa_restorer; 373 put_user_ex(restorer, &frame->pretcode); 374 375 /* 376 * This is movl $__NR_rt_sigreturn, %ax ; int $0x80 377 * 378 * WE DO NOT USE IT ANY MORE! It's only left here for historical 379 * reasons and because gdb uses it as a signature to notice 380 * signal handler stack frames. 381 */ 382 put_user_ex(*((u64 *)&rt_retcode), (u64 *)frame->retcode); 383 } put_user_catch(err); 384 385 err |= copy_siginfo_to_user(&frame->info, &ksig->info); 386 err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate, 387 regs, set->sig[0]); 388 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 389 390 if (err) 391 return -EFAULT; 392 393 /* Set up registers for signal handler */ 394 regs->sp = (unsigned long)frame; 395 regs->ip = (unsigned long)ksig->ka.sa.sa_handler; 396 regs->ax = (unsigned long)sig; 397 regs->dx = (unsigned long)&frame->info; 398 regs->cx = (unsigned long)&frame->uc; 399 400 regs->ds = __USER_DS; 401 regs->es = __USER_DS; 402 regs->ss = __USER_DS; 403 regs->cs = __USER_CS; 404 405 return 0; 406 } 407 #else /* !CONFIG_X86_32 */ 408 static int __setup_rt_frame(int sig, struct ksignal *ksig, 409 sigset_t *set, struct pt_regs *regs) 410 { 411 struct rt_sigframe __user *frame; 412 void __user *fp = NULL; 413 int err = 0; 414 415 frame = get_sigframe(&ksig->ka, regs, sizeof(struct rt_sigframe), &fp); 416 417 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 418 return -EFAULT; 419 420 if (ksig->ka.sa.sa_flags & SA_SIGINFO) { 421 if (copy_siginfo_to_user(&frame->info, &ksig->info)) 422 return -EFAULT; 423 } 424 425 put_user_try { 426 /* Create the ucontext. */ 427 if (cpu_has_xsave) 428 put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags); 429 else 430 put_user_ex(0, &frame->uc.uc_flags); 431 put_user_ex(0, &frame->uc.uc_link); 432 err |= __save_altstack(&frame->uc.uc_stack, regs->sp); 433 434 /* Set up to return from userspace. If provided, use a stub 435 already in userspace. */ 436 /* x86-64 should always use SA_RESTORER. */ 437 if (ksig->ka.sa.sa_flags & SA_RESTORER) { 438 put_user_ex(ksig->ka.sa.sa_restorer, &frame->pretcode); 439 } else { 440 /* could use a vstub here */ 441 err |= -EFAULT; 442 } 443 } put_user_catch(err); 444 445 err |= setup_sigcontext(&frame->uc.uc_mcontext, fp, regs, set->sig[0]); 446 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 447 448 if (err) 449 return -EFAULT; 450 451 /* Set up registers for signal handler */ 452 regs->di = sig; 453 /* In case the signal handler was declared without prototypes */ 454 regs->ax = 0; 455 456 /* This also works for non SA_SIGINFO handlers because they expect the 457 next argument after the signal number on the stack. */ 458 regs->si = (unsigned long)&frame->info; 459 regs->dx = (unsigned long)&frame->uc; 460 regs->ip = (unsigned long) ksig->ka.sa.sa_handler; 461 462 regs->sp = (unsigned long)frame; 463 464 /* Set up the CS register to run signal handlers in 64-bit mode, 465 even if the handler happens to be interrupting 32-bit code. */ 466 regs->cs = __USER_CS; 467 468 return 0; 469 } 470 #endif /* CONFIG_X86_32 */ 471 472 static int x32_setup_rt_frame(struct ksignal *ksig, 473 compat_sigset_t *set, 474 struct pt_regs *regs) 475 { 476 #ifdef CONFIG_X86_X32_ABI 477 struct rt_sigframe_x32 __user *frame; 478 void __user *restorer; 479 int err = 0; 480 void __user *fpstate = NULL; 481 482 frame = get_sigframe(&ksig->ka, regs, sizeof(*frame), &fpstate); 483 484 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 485 return -EFAULT; 486 487 if (ksig->ka.sa.sa_flags & SA_SIGINFO) { 488 if (copy_siginfo_to_user32(&frame->info, &ksig->info)) 489 return -EFAULT; 490 } 491 492 put_user_try { 493 /* Create the ucontext. */ 494 if (cpu_has_xsave) 495 put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags); 496 else 497 put_user_ex(0, &frame->uc.uc_flags); 498 put_user_ex(0, &frame->uc.uc_link); 499 err |= __compat_save_altstack(&frame->uc.uc_stack, regs->sp); 500 put_user_ex(0, &frame->uc.uc__pad0); 501 502 if (ksig->ka.sa.sa_flags & SA_RESTORER) { 503 restorer = ksig->ka.sa.sa_restorer; 504 } else { 505 /* could use a vstub here */ 506 restorer = NULL; 507 err |= -EFAULT; 508 } 509 put_user_ex(restorer, &frame->pretcode); 510 } put_user_catch(err); 511 512 err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate, 513 regs, set->sig[0]); 514 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 515 516 if (err) 517 return -EFAULT; 518 519 /* Set up registers for signal handler */ 520 regs->sp = (unsigned long) frame; 521 regs->ip = (unsigned long) ksig->ka.sa.sa_handler; 522 523 /* We use the x32 calling convention here... */ 524 regs->di = ksig->sig; 525 regs->si = (unsigned long) &frame->info; 526 regs->dx = (unsigned long) &frame->uc; 527 528 loadsegment(ds, __USER_DS); 529 loadsegment(es, __USER_DS); 530 531 regs->cs = __USER_CS; 532 regs->ss = __USER_DS; 533 #endif /* CONFIG_X86_X32_ABI */ 534 535 return 0; 536 } 537 538 /* 539 * Do a signal return; undo the signal stack. 540 */ 541 #ifdef CONFIG_X86_32 542 unsigned long sys_sigreturn(void) 543 { 544 struct pt_regs *regs = current_pt_regs(); 545 struct sigframe __user *frame; 546 unsigned long ax; 547 sigset_t set; 548 549 frame = (struct sigframe __user *)(regs->sp - 8); 550 551 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 552 goto badframe; 553 if (__get_user(set.sig[0], &frame->sc.oldmask) || (_NSIG_WORDS > 1 554 && __copy_from_user(&set.sig[1], &frame->extramask, 555 sizeof(frame->extramask)))) 556 goto badframe; 557 558 set_current_blocked(&set); 559 560 if (restore_sigcontext(regs, &frame->sc, &ax)) 561 goto badframe; 562 return ax; 563 564 badframe: 565 signal_fault(regs, frame, "sigreturn"); 566 567 return 0; 568 } 569 #endif /* CONFIG_X86_32 */ 570 571 long sys_rt_sigreturn(void) 572 { 573 struct pt_regs *regs = current_pt_regs(); 574 struct rt_sigframe __user *frame; 575 unsigned long ax; 576 sigset_t set; 577 578 frame = (struct rt_sigframe __user *)(regs->sp - sizeof(long)); 579 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 580 goto badframe; 581 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 582 goto badframe; 583 584 set_current_blocked(&set); 585 586 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax)) 587 goto badframe; 588 589 if (restore_altstack(&frame->uc.uc_stack)) 590 goto badframe; 591 592 return ax; 593 594 badframe: 595 signal_fault(regs, frame, "rt_sigreturn"); 596 return 0; 597 } 598 599 /* 600 * OK, we're invoking a handler: 601 */ 602 static int signr_convert(int sig) 603 { 604 #ifdef CONFIG_X86_32 605 struct thread_info *info = current_thread_info(); 606 607 if (info->exec_domain && info->exec_domain->signal_invmap && sig < 32) 608 return info->exec_domain->signal_invmap[sig]; 609 #endif /* CONFIG_X86_32 */ 610 return sig; 611 } 612 613 static int 614 setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs) 615 { 616 int usig = signr_convert(ksig->sig); 617 sigset_t *set = sigmask_to_save(); 618 compat_sigset_t *cset = (compat_sigset_t *) set; 619 620 /* Set up the stack frame */ 621 if (is_ia32_frame()) { 622 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 623 return ia32_setup_rt_frame(usig, ksig, cset, regs); 624 else 625 return ia32_setup_frame(usig, ksig, cset, regs); 626 } else if (is_x32_frame()) { 627 return x32_setup_rt_frame(ksig, cset, regs); 628 } else { 629 return __setup_rt_frame(ksig->sig, ksig, set, regs); 630 } 631 } 632 633 static void 634 handle_signal(struct ksignal *ksig, struct pt_regs *regs) 635 { 636 bool failed; 637 /* Are we from a system call? */ 638 if (syscall_get_nr(current, regs) >= 0) { 639 /* If so, check system call restarting.. */ 640 switch (syscall_get_error(current, regs)) { 641 case -ERESTART_RESTARTBLOCK: 642 case -ERESTARTNOHAND: 643 regs->ax = -EINTR; 644 break; 645 646 case -ERESTARTSYS: 647 if (!(ksig->ka.sa.sa_flags & SA_RESTART)) { 648 regs->ax = -EINTR; 649 break; 650 } 651 /* fallthrough */ 652 case -ERESTARTNOINTR: 653 regs->ax = regs->orig_ax; 654 regs->ip -= 2; 655 break; 656 } 657 } 658 659 /* 660 * If TF is set due to a debugger (TIF_FORCED_TF), clear the TF 661 * flag so that register information in the sigcontext is correct. 662 */ 663 if (unlikely(regs->flags & X86_EFLAGS_TF) && 664 likely(test_and_clear_thread_flag(TIF_FORCED_TF))) 665 regs->flags &= ~X86_EFLAGS_TF; 666 667 failed = (setup_rt_frame(ksig, regs) < 0); 668 if (!failed) { 669 /* 670 * Clear the direction flag as per the ABI for function entry. 671 */ 672 regs->flags &= ~X86_EFLAGS_DF; 673 /* 674 * Clear TF when entering the signal handler, but 675 * notify any tracer that was single-stepping it. 676 * The tracer may want to single-step inside the 677 * handler too. 678 */ 679 regs->flags &= ~X86_EFLAGS_TF; 680 } 681 signal_setup_done(failed, ksig, test_thread_flag(TIF_SINGLESTEP)); 682 } 683 684 #ifdef CONFIG_X86_32 685 #define NR_restart_syscall __NR_restart_syscall 686 #else /* !CONFIG_X86_32 */ 687 #define NR_restart_syscall \ 688 test_thread_flag(TIF_IA32) ? __NR_ia32_restart_syscall : __NR_restart_syscall 689 #endif /* CONFIG_X86_32 */ 690 691 /* 692 * Note that 'init' is a special process: it doesn't get signals it doesn't 693 * want to handle. Thus you cannot kill init even with a SIGKILL even by 694 * mistake. 695 */ 696 static void do_signal(struct pt_regs *regs) 697 { 698 struct ksignal ksig; 699 700 if (get_signal(&ksig)) { 701 /* Whee! Actually deliver the signal. */ 702 handle_signal(&ksig, regs); 703 return; 704 } 705 706 /* Did we come from a system call? */ 707 if (syscall_get_nr(current, regs) >= 0) { 708 /* Restart the system call - no handlers present */ 709 switch (syscall_get_error(current, regs)) { 710 case -ERESTARTNOHAND: 711 case -ERESTARTSYS: 712 case -ERESTARTNOINTR: 713 regs->ax = regs->orig_ax; 714 regs->ip -= 2; 715 break; 716 717 case -ERESTART_RESTARTBLOCK: 718 regs->ax = NR_restart_syscall; 719 regs->ip -= 2; 720 break; 721 } 722 } 723 724 /* 725 * If there's no signal to deliver, we just put the saved sigmask 726 * back. 727 */ 728 restore_saved_sigmask(); 729 } 730 731 /* 732 * notification of userspace execution resumption 733 * - triggered by the TIF_WORK_MASK flags 734 */ 735 void 736 do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags) 737 { 738 user_exit(); 739 740 #ifdef CONFIG_X86_MCE 741 /* notify userspace of pending MCEs */ 742 if (thread_info_flags & _TIF_MCE_NOTIFY) 743 mce_notify_process(); 744 #endif /* CONFIG_X86_64 && CONFIG_X86_MCE */ 745 746 if (thread_info_flags & _TIF_UPROBE) 747 uprobe_notify_resume(regs); 748 749 /* deal with pending signal delivery */ 750 if (thread_info_flags & _TIF_SIGPENDING) 751 do_signal(regs); 752 753 if (thread_info_flags & _TIF_NOTIFY_RESUME) { 754 clear_thread_flag(TIF_NOTIFY_RESUME); 755 tracehook_notify_resume(regs); 756 } 757 if (thread_info_flags & _TIF_USER_RETURN_NOTIFY) 758 fire_user_return_notifiers(); 759 760 user_enter(); 761 } 762 763 void signal_fault(struct pt_regs *regs, void __user *frame, char *where) 764 { 765 struct task_struct *me = current; 766 767 if (show_unhandled_signals && printk_ratelimit()) { 768 printk("%s" 769 "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx", 770 task_pid_nr(current) > 1 ? KERN_INFO : KERN_EMERG, 771 me->comm, me->pid, where, frame, 772 regs->ip, regs->sp, regs->orig_ax); 773 print_vma_addr(" in ", regs->ip); 774 pr_cont("\n"); 775 } 776 777 force_sig(SIGSEGV, me); 778 } 779 780 #ifdef CONFIG_X86_X32_ABI 781 asmlinkage long sys32_x32_rt_sigreturn(void) 782 { 783 struct pt_regs *regs = current_pt_regs(); 784 struct rt_sigframe_x32 __user *frame; 785 sigset_t set; 786 unsigned long ax; 787 788 frame = (struct rt_sigframe_x32 __user *)(regs->sp - 8); 789 790 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 791 goto badframe; 792 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 793 goto badframe; 794 795 set_current_blocked(&set); 796 797 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax)) 798 goto badframe; 799 800 if (compat_restore_altstack(&frame->uc.uc_stack)) 801 goto badframe; 802 803 return ax; 804 805 badframe: 806 signal_fault(regs, frame, "x32 rt_sigreturn"); 807 return 0; 808 } 809 #endif 810