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 k_sigaction *ka, 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(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 (ka->sa.sa_flags & SA_RESTORER) 311 restorer = 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)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 k_sigaction *ka, siginfo_t *info, 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(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 put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 368 put_user_ex(sas_ss_flags(regs->sp), 369 &frame->uc.uc_stack.ss_flags); 370 put_user_ex(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 371 372 /* Set up to return from userspace. */ 373 restorer = VDSO32_SYMBOL(current->mm->context.vdso, rt_sigreturn); 374 if (ka->sa.sa_flags & SA_RESTORER) 375 restorer = ka->sa.sa_restorer; 376 put_user_ex(restorer, &frame->pretcode); 377 378 /* 379 * This is movl $__NR_rt_sigreturn, %ax ; int $0x80 380 * 381 * WE DO NOT USE IT ANY MORE! It's only left here for historical 382 * reasons and because gdb uses it as a signature to notice 383 * signal handler stack frames. 384 */ 385 put_user_ex(*((u64 *)&rt_retcode), (u64 *)frame->retcode); 386 } put_user_catch(err); 387 388 err |= copy_siginfo_to_user(&frame->info, info); 389 err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate, 390 regs, set->sig[0]); 391 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 392 393 if (err) 394 return -EFAULT; 395 396 /* Set up registers for signal handler */ 397 regs->sp = (unsigned long)frame; 398 regs->ip = (unsigned long)ka->sa.sa_handler; 399 regs->ax = (unsigned long)sig; 400 regs->dx = (unsigned long)&frame->info; 401 regs->cx = (unsigned long)&frame->uc; 402 403 regs->ds = __USER_DS; 404 regs->es = __USER_DS; 405 regs->ss = __USER_DS; 406 regs->cs = __USER_CS; 407 408 return 0; 409 } 410 #else /* !CONFIG_X86_32 */ 411 static int __setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 412 sigset_t *set, struct pt_regs *regs) 413 { 414 struct rt_sigframe __user *frame; 415 void __user *fp = NULL; 416 int err = 0; 417 struct task_struct *me = current; 418 419 frame = get_sigframe(ka, regs, sizeof(struct rt_sigframe), &fp); 420 421 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 422 return -EFAULT; 423 424 if (ka->sa.sa_flags & SA_SIGINFO) { 425 if (copy_siginfo_to_user(&frame->info, info)) 426 return -EFAULT; 427 } 428 429 put_user_try { 430 /* Create the ucontext. */ 431 if (cpu_has_xsave) 432 put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags); 433 else 434 put_user_ex(0, &frame->uc.uc_flags); 435 put_user_ex(0, &frame->uc.uc_link); 436 put_user_ex(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 437 put_user_ex(sas_ss_flags(regs->sp), 438 &frame->uc.uc_stack.ss_flags); 439 put_user_ex(me->sas_ss_size, &frame->uc.uc_stack.ss_size); 440 441 /* Set up to return from userspace. If provided, use a stub 442 already in userspace. */ 443 /* x86-64 should always use SA_RESTORER. */ 444 if (ka->sa.sa_flags & SA_RESTORER) { 445 put_user_ex(ka->sa.sa_restorer, &frame->pretcode); 446 } else { 447 /* could use a vstub here */ 448 err |= -EFAULT; 449 } 450 } put_user_catch(err); 451 452 err |= setup_sigcontext(&frame->uc.uc_mcontext, fp, regs, set->sig[0]); 453 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 454 455 if (err) 456 return -EFAULT; 457 458 /* Set up registers for signal handler */ 459 regs->di = sig; 460 /* In case the signal handler was declared without prototypes */ 461 regs->ax = 0; 462 463 /* This also works for non SA_SIGINFO handlers because they expect the 464 next argument after the signal number on the stack. */ 465 regs->si = (unsigned long)&frame->info; 466 regs->dx = (unsigned long)&frame->uc; 467 regs->ip = (unsigned long) ka->sa.sa_handler; 468 469 regs->sp = (unsigned long)frame; 470 471 /* Set up the CS register to run signal handlers in 64-bit mode, 472 even if the handler happens to be interrupting 32-bit code. */ 473 regs->cs = __USER_CS; 474 475 return 0; 476 } 477 #endif /* CONFIG_X86_32 */ 478 479 static int x32_setup_rt_frame(int sig, struct k_sigaction *ka, 480 siginfo_t *info, compat_sigset_t *set, 481 struct pt_regs *regs) 482 { 483 #ifdef CONFIG_X86_X32_ABI 484 struct rt_sigframe_x32 __user *frame; 485 void __user *restorer; 486 int err = 0; 487 void __user *fpstate = NULL; 488 489 frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate); 490 491 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 492 return -EFAULT; 493 494 if (ka->sa.sa_flags & SA_SIGINFO) { 495 if (copy_siginfo_to_user32(&frame->info, info)) 496 return -EFAULT; 497 } 498 499 put_user_try { 500 /* Create the ucontext. */ 501 if (cpu_has_xsave) 502 put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags); 503 else 504 put_user_ex(0, &frame->uc.uc_flags); 505 put_user_ex(0, &frame->uc.uc_link); 506 put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 507 put_user_ex(sas_ss_flags(regs->sp), 508 &frame->uc.uc_stack.ss_flags); 509 put_user_ex(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 510 put_user_ex(0, &frame->uc.uc__pad0); 511 512 if (ka->sa.sa_flags & SA_RESTORER) { 513 restorer = ka->sa.sa_restorer; 514 } else { 515 /* could use a vstub here */ 516 restorer = NULL; 517 err |= -EFAULT; 518 } 519 put_user_ex(restorer, &frame->pretcode); 520 } put_user_catch(err); 521 522 err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate, 523 regs, set->sig[0]); 524 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 525 526 if (err) 527 return -EFAULT; 528 529 /* Set up registers for signal handler */ 530 regs->sp = (unsigned long) frame; 531 regs->ip = (unsigned long) ka->sa.sa_handler; 532 533 /* We use the x32 calling convention here... */ 534 regs->di = sig; 535 regs->si = (unsigned long) &frame->info; 536 regs->dx = (unsigned long) &frame->uc; 537 538 loadsegment(ds, __USER_DS); 539 loadsegment(es, __USER_DS); 540 541 regs->cs = __USER_CS; 542 regs->ss = __USER_DS; 543 #endif /* CONFIG_X86_X32_ABI */ 544 545 return 0; 546 } 547 548 #ifdef CONFIG_X86_32 549 /* 550 * Atomically swap in the new signal mask, and wait for a signal. 551 */ 552 asmlinkage int 553 sys_sigsuspend(int history0, int history1, old_sigset_t mask) 554 { 555 sigset_t blocked; 556 siginitset(&blocked, mask); 557 return sigsuspend(&blocked); 558 } 559 560 asmlinkage int 561 sys_sigaction(int sig, const struct old_sigaction __user *act, 562 struct old_sigaction __user *oact) 563 { 564 struct k_sigaction new_ka, old_ka; 565 int ret = 0; 566 567 if (act) { 568 old_sigset_t mask; 569 570 if (!access_ok(VERIFY_READ, act, sizeof(*act))) 571 return -EFAULT; 572 573 get_user_try { 574 get_user_ex(new_ka.sa.sa_handler, &act->sa_handler); 575 get_user_ex(new_ka.sa.sa_flags, &act->sa_flags); 576 get_user_ex(mask, &act->sa_mask); 577 get_user_ex(new_ka.sa.sa_restorer, &act->sa_restorer); 578 } get_user_catch(ret); 579 580 if (ret) 581 return -EFAULT; 582 siginitset(&new_ka.sa.sa_mask, mask); 583 } 584 585 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 586 587 if (!ret && oact) { 588 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact))) 589 return -EFAULT; 590 591 put_user_try { 592 put_user_ex(old_ka.sa.sa_handler, &oact->sa_handler); 593 put_user_ex(old_ka.sa.sa_flags, &oact->sa_flags); 594 put_user_ex(old_ka.sa.sa_mask.sig[0], &oact->sa_mask); 595 put_user_ex(old_ka.sa.sa_restorer, &oact->sa_restorer); 596 } put_user_catch(ret); 597 598 if (ret) 599 return -EFAULT; 600 } 601 602 return ret; 603 } 604 #endif /* CONFIG_X86_32 */ 605 606 long 607 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, 608 struct pt_regs *regs) 609 { 610 return do_sigaltstack(uss, uoss, regs->sp); 611 } 612 613 /* 614 * Do a signal return; undo the signal stack. 615 */ 616 #ifdef CONFIG_X86_32 617 unsigned long sys_sigreturn(struct pt_regs *regs) 618 { 619 struct sigframe __user *frame; 620 unsigned long ax; 621 sigset_t set; 622 623 frame = (struct sigframe __user *)(regs->sp - 8); 624 625 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 626 goto badframe; 627 if (__get_user(set.sig[0], &frame->sc.oldmask) || (_NSIG_WORDS > 1 628 && __copy_from_user(&set.sig[1], &frame->extramask, 629 sizeof(frame->extramask)))) 630 goto badframe; 631 632 set_current_blocked(&set); 633 634 if (restore_sigcontext(regs, &frame->sc, &ax)) 635 goto badframe; 636 return ax; 637 638 badframe: 639 signal_fault(regs, frame, "sigreturn"); 640 641 return 0; 642 } 643 #endif /* CONFIG_X86_32 */ 644 645 long sys_rt_sigreturn(struct pt_regs *regs) 646 { 647 struct rt_sigframe __user *frame; 648 unsigned long ax; 649 sigset_t set; 650 651 frame = (struct rt_sigframe __user *)(regs->sp - sizeof(long)); 652 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 653 goto badframe; 654 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 655 goto badframe; 656 657 set_current_blocked(&set); 658 659 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax)) 660 goto badframe; 661 662 if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->sp) == -EFAULT) 663 goto badframe; 664 665 return ax; 666 667 badframe: 668 signal_fault(regs, frame, "rt_sigreturn"); 669 return 0; 670 } 671 672 /* 673 * OK, we're invoking a handler: 674 */ 675 static int signr_convert(int sig) 676 { 677 #ifdef CONFIG_X86_32 678 struct thread_info *info = current_thread_info(); 679 680 if (info->exec_domain && info->exec_domain->signal_invmap && sig < 32) 681 return info->exec_domain->signal_invmap[sig]; 682 #endif /* CONFIG_X86_32 */ 683 return sig; 684 } 685 686 static int 687 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 688 struct pt_regs *regs) 689 { 690 int usig = signr_convert(sig); 691 sigset_t *set = sigmask_to_save(); 692 compat_sigset_t *cset = (compat_sigset_t *) set; 693 694 /* Set up the stack frame */ 695 if (is_ia32_frame()) { 696 if (ka->sa.sa_flags & SA_SIGINFO) 697 return ia32_setup_rt_frame(usig, ka, info, cset, regs); 698 else 699 return ia32_setup_frame(usig, ka, cset, regs); 700 } else if (is_x32_frame()) { 701 return x32_setup_rt_frame(usig, ka, info, cset, regs); 702 } else { 703 return __setup_rt_frame(sig, ka, info, set, regs); 704 } 705 } 706 707 static void 708 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka, 709 struct pt_regs *regs) 710 { 711 /* Are we from a system call? */ 712 if (syscall_get_nr(current, regs) >= 0) { 713 /* If so, check system call restarting.. */ 714 switch (syscall_get_error(current, regs)) { 715 case -ERESTART_RESTARTBLOCK: 716 case -ERESTARTNOHAND: 717 regs->ax = -EINTR; 718 break; 719 720 case -ERESTARTSYS: 721 if (!(ka->sa.sa_flags & SA_RESTART)) { 722 regs->ax = -EINTR; 723 break; 724 } 725 /* fallthrough */ 726 case -ERESTARTNOINTR: 727 regs->ax = regs->orig_ax; 728 regs->ip -= 2; 729 break; 730 } 731 } 732 733 /* 734 * If TF is set due to a debugger (TIF_FORCED_TF), clear the TF 735 * flag so that register information in the sigcontext is correct. 736 */ 737 if (unlikely(regs->flags & X86_EFLAGS_TF) && 738 likely(test_and_clear_thread_flag(TIF_FORCED_TF))) 739 regs->flags &= ~X86_EFLAGS_TF; 740 741 if (setup_rt_frame(sig, ka, info, regs) < 0) { 742 force_sigsegv(sig, current); 743 return; 744 } 745 746 /* 747 * Clear the direction flag as per the ABI for function entry. 748 */ 749 regs->flags &= ~X86_EFLAGS_DF; 750 751 /* 752 * Clear TF when entering the signal handler, but 753 * notify any tracer that was single-stepping it. 754 * The tracer may want to single-step inside the 755 * handler too. 756 */ 757 regs->flags &= ~X86_EFLAGS_TF; 758 759 signal_delivered(sig, info, ka, regs, 760 test_thread_flag(TIF_SINGLESTEP)); 761 } 762 763 #ifdef CONFIG_X86_32 764 #define NR_restart_syscall __NR_restart_syscall 765 #else /* !CONFIG_X86_32 */ 766 #define NR_restart_syscall \ 767 test_thread_flag(TIF_IA32) ? __NR_ia32_restart_syscall : __NR_restart_syscall 768 #endif /* CONFIG_X86_32 */ 769 770 /* 771 * Note that 'init' is a special process: it doesn't get signals it doesn't 772 * want to handle. Thus you cannot kill init even with a SIGKILL even by 773 * mistake. 774 */ 775 static void do_signal(struct pt_regs *regs) 776 { 777 struct k_sigaction ka; 778 siginfo_t info; 779 int signr; 780 781 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 782 if (signr > 0) { 783 /* Whee! Actually deliver the signal. */ 784 handle_signal(signr, &info, &ka, regs); 785 return; 786 } 787 788 /* Did we come from a system call? */ 789 if (syscall_get_nr(current, regs) >= 0) { 790 /* Restart the system call - no handlers present */ 791 switch (syscall_get_error(current, regs)) { 792 case -ERESTARTNOHAND: 793 case -ERESTARTSYS: 794 case -ERESTARTNOINTR: 795 regs->ax = regs->orig_ax; 796 regs->ip -= 2; 797 break; 798 799 case -ERESTART_RESTARTBLOCK: 800 regs->ax = NR_restart_syscall; 801 regs->ip -= 2; 802 break; 803 } 804 } 805 806 /* 807 * If there's no signal to deliver, we just put the saved sigmask 808 * back. 809 */ 810 restore_saved_sigmask(); 811 } 812 813 /* 814 * notification of userspace execution resumption 815 * - triggered by the TIF_WORK_MASK flags 816 */ 817 void 818 do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags) 819 { 820 user_exit(); 821 822 #ifdef CONFIG_X86_MCE 823 /* notify userspace of pending MCEs */ 824 if (thread_info_flags & _TIF_MCE_NOTIFY) 825 mce_notify_process(); 826 #endif /* CONFIG_X86_64 && CONFIG_X86_MCE */ 827 828 if (thread_info_flags & _TIF_UPROBE) 829 uprobe_notify_resume(regs); 830 831 /* deal with pending signal delivery */ 832 if (thread_info_flags & _TIF_SIGPENDING) 833 do_signal(regs); 834 835 if (thread_info_flags & _TIF_NOTIFY_RESUME) { 836 clear_thread_flag(TIF_NOTIFY_RESUME); 837 tracehook_notify_resume(regs); 838 } 839 if (thread_info_flags & _TIF_USER_RETURN_NOTIFY) 840 fire_user_return_notifiers(); 841 842 user_enter(); 843 } 844 845 void signal_fault(struct pt_regs *regs, void __user *frame, char *where) 846 { 847 struct task_struct *me = current; 848 849 if (show_unhandled_signals && printk_ratelimit()) { 850 printk("%s" 851 "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx", 852 task_pid_nr(current) > 1 ? KERN_INFO : KERN_EMERG, 853 me->comm, me->pid, where, frame, 854 regs->ip, regs->sp, regs->orig_ax); 855 print_vma_addr(" in ", regs->ip); 856 pr_cont("\n"); 857 } 858 859 force_sig(SIGSEGV, me); 860 } 861 862 #ifdef CONFIG_X86_X32_ABI 863 asmlinkage long sys32_x32_rt_sigreturn(struct pt_regs *regs) 864 { 865 struct rt_sigframe_x32 __user *frame; 866 sigset_t set; 867 unsigned long ax; 868 struct pt_regs tregs; 869 870 frame = (struct rt_sigframe_x32 __user *)(regs->sp - 8); 871 872 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 873 goto badframe; 874 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 875 goto badframe; 876 877 set_current_blocked(&set); 878 879 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax)) 880 goto badframe; 881 882 tregs = *regs; 883 if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT) 884 goto badframe; 885 886 return ax; 887 888 badframe: 889 signal_fault(regs, frame, "x32 rt_sigreturn"); 890 return 0; 891 } 892 #endif 893