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