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