1 /* 2 * linux/arch/x86_64/kernel/signal.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * Copyright (C) 2000, 2001, 2002 Andi Kleen SuSE Labs 6 * 7 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson 8 * 2000-06-20 Pentium III FXSR, SSE support by Gareth Hughes 9 * 2000-2002 x86-64 support by Andi Kleen 10 */ 11 12 #include <linux/sched.h> 13 #include <linux/mm.h> 14 #include <linux/smp.h> 15 #include <linux/kernel.h> 16 #include <linux/signal.h> 17 #include <linux/errno.h> 18 #include <linux/wait.h> 19 #include <linux/ptrace.h> 20 #include <linux/unistd.h> 21 #include <linux/stddef.h> 22 #include <linux/personality.h> 23 #include <linux/compiler.h> 24 #include <asm/ucontext.h> 25 #include <asm/uaccess.h> 26 #include <asm/i387.h> 27 #include <asm/proto.h> 28 #include <asm/ia32_unistd.h> 29 #include <asm/mce.h> 30 31 /* #define DEBUG_SIG 1 */ 32 33 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 34 35 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 36 sigset_t *set, struct pt_regs * regs); 37 int ia32_setup_frame(int sig, struct k_sigaction *ka, 38 sigset_t *set, struct pt_regs * regs); 39 40 asmlinkage long 41 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, 42 struct pt_regs *regs) 43 { 44 return do_sigaltstack(uss, uoss, regs->rsp); 45 } 46 47 48 /* 49 * Do a signal return; undo the signal stack. 50 */ 51 52 struct rt_sigframe 53 { 54 char __user *pretcode; 55 struct ucontext uc; 56 struct siginfo info; 57 }; 58 59 static int 60 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, unsigned long *prax) 61 { 62 unsigned int err = 0; 63 64 /* Always make any pending restarted system calls return -EINTR */ 65 current_thread_info()->restart_block.fn = do_no_restart_syscall; 66 67 #define COPY(x) err |= __get_user(regs->x, &sc->x) 68 69 COPY(rdi); COPY(rsi); COPY(rbp); COPY(rsp); COPY(rbx); 70 COPY(rdx); COPY(rcx); COPY(rip); 71 COPY(r8); 72 COPY(r9); 73 COPY(r10); 74 COPY(r11); 75 COPY(r12); 76 COPY(r13); 77 COPY(r14); 78 COPY(r15); 79 80 /* Kernel saves and restores only the CS segment register on signals, 81 * which is the bare minimum needed to allow mixed 32/64-bit code. 82 * App's signal handler can save/restore other segments if needed. */ 83 { 84 unsigned cs; 85 err |= __get_user(cs, &sc->cs); 86 regs->cs = cs | 3; /* Force into user mode */ 87 } 88 89 { 90 unsigned int tmpflags; 91 err |= __get_user(tmpflags, &sc->eflags); 92 regs->eflags = (regs->eflags & ~0x40DD5) | (tmpflags & 0x40DD5); 93 regs->orig_rax = -1; /* disable syscall checks */ 94 } 95 96 { 97 struct _fpstate __user * buf; 98 err |= __get_user(buf, &sc->fpstate); 99 100 if (buf) { 101 if (!access_ok(VERIFY_READ, buf, sizeof(*buf))) 102 goto badframe; 103 err |= restore_i387(buf); 104 } else { 105 struct task_struct *me = current; 106 if (used_math()) { 107 clear_fpu(me); 108 clear_used_math(); 109 } 110 } 111 } 112 113 err |= __get_user(*prax, &sc->rax); 114 return err; 115 116 badframe: 117 return 1; 118 } 119 120 asmlinkage long sys_rt_sigreturn(struct pt_regs *regs) 121 { 122 struct rt_sigframe __user *frame; 123 sigset_t set; 124 unsigned long eax; 125 126 frame = (struct rt_sigframe __user *)(regs->rsp - 8); 127 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) { 128 goto badframe; 129 } 130 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) { 131 goto badframe; 132 } 133 134 sigdelsetmask(&set, ~_BLOCKABLE); 135 spin_lock_irq(¤t->sighand->siglock); 136 current->blocked = set; 137 recalc_sigpending(); 138 spin_unlock_irq(¤t->sighand->siglock); 139 140 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &eax)) 141 goto badframe; 142 143 #ifdef DEBUG_SIG 144 printk("%d sigreturn rip:%lx rsp:%lx frame:%p rax:%lx\n",current->pid,regs->rip,regs->rsp,frame,eax); 145 #endif 146 147 if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->rsp) == -EFAULT) 148 goto badframe; 149 150 return eax; 151 152 badframe: 153 signal_fault(regs,frame,"sigreturn"); 154 return 0; 155 } 156 157 /* 158 * Set up a signal frame. 159 */ 160 161 static inline int 162 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, unsigned long mask, struct task_struct *me) 163 { 164 int err = 0; 165 166 err |= __put_user(regs->cs, &sc->cs); 167 err |= __put_user(0, &sc->gs); 168 err |= __put_user(0, &sc->fs); 169 170 err |= __put_user(regs->rdi, &sc->rdi); 171 err |= __put_user(regs->rsi, &sc->rsi); 172 err |= __put_user(regs->rbp, &sc->rbp); 173 err |= __put_user(regs->rsp, &sc->rsp); 174 err |= __put_user(regs->rbx, &sc->rbx); 175 err |= __put_user(regs->rdx, &sc->rdx); 176 err |= __put_user(regs->rcx, &sc->rcx); 177 err |= __put_user(regs->rax, &sc->rax); 178 err |= __put_user(regs->r8, &sc->r8); 179 err |= __put_user(regs->r9, &sc->r9); 180 err |= __put_user(regs->r10, &sc->r10); 181 err |= __put_user(regs->r11, &sc->r11); 182 err |= __put_user(regs->r12, &sc->r12); 183 err |= __put_user(regs->r13, &sc->r13); 184 err |= __put_user(regs->r14, &sc->r14); 185 err |= __put_user(regs->r15, &sc->r15); 186 err |= __put_user(me->thread.trap_no, &sc->trapno); 187 err |= __put_user(me->thread.error_code, &sc->err); 188 err |= __put_user(regs->rip, &sc->rip); 189 err |= __put_user(regs->eflags, &sc->eflags); 190 err |= __put_user(mask, &sc->oldmask); 191 err |= __put_user(me->thread.cr2, &sc->cr2); 192 193 return err; 194 } 195 196 /* 197 * Determine which stack to use.. 198 */ 199 200 static void __user * 201 get_stack(struct k_sigaction *ka, struct pt_regs *regs, unsigned long size) 202 { 203 unsigned long rsp; 204 205 /* Default to using normal stack - redzone*/ 206 rsp = regs->rsp - 128; 207 208 /* This is the X/Open sanctioned signal stack switching. */ 209 if (ka->sa.sa_flags & SA_ONSTACK) { 210 if (sas_ss_flags(rsp) == 0) 211 rsp = current->sas_ss_sp + current->sas_ss_size; 212 } 213 214 return (void __user *)round_down(rsp - size, 16); 215 } 216 217 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 218 sigset_t *set, struct pt_regs * regs) 219 { 220 struct rt_sigframe __user *frame; 221 struct _fpstate __user *fp = NULL; 222 int err = 0; 223 struct task_struct *me = current; 224 225 if (used_math()) { 226 fp = get_stack(ka, regs, sizeof(struct _fpstate)); 227 frame = (void __user *)round_down( 228 (unsigned long)fp - sizeof(struct rt_sigframe), 16) - 8; 229 230 if (!access_ok(VERIFY_WRITE, fp, sizeof(struct _fpstate))) 231 goto give_sigsegv; 232 233 if (save_i387(fp) < 0) 234 err |= -1; 235 } else 236 frame = get_stack(ka, regs, sizeof(struct rt_sigframe)) - 8; 237 238 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 239 goto give_sigsegv; 240 241 if (ka->sa.sa_flags & SA_SIGINFO) { 242 err |= copy_siginfo_to_user(&frame->info, info); 243 if (err) 244 goto give_sigsegv; 245 } 246 247 /* Create the ucontext. */ 248 err |= __put_user(0, &frame->uc.uc_flags); 249 err |= __put_user(0, &frame->uc.uc_link); 250 err |= __put_user(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 251 err |= __put_user(sas_ss_flags(regs->rsp), 252 &frame->uc.uc_stack.ss_flags); 253 err |= __put_user(me->sas_ss_size, &frame->uc.uc_stack.ss_size); 254 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0], me); 255 err |= __put_user(fp, &frame->uc.uc_mcontext.fpstate); 256 if (sizeof(*set) == 16) { 257 __put_user(set->sig[0], &frame->uc.uc_sigmask.sig[0]); 258 __put_user(set->sig[1], &frame->uc.uc_sigmask.sig[1]); 259 } else 260 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 261 262 /* Set up to return from userspace. If provided, use a stub 263 already in userspace. */ 264 /* x86-64 should always use SA_RESTORER. */ 265 if (ka->sa.sa_flags & SA_RESTORER) { 266 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode); 267 } else { 268 /* could use a vstub here */ 269 goto give_sigsegv; 270 } 271 272 if (err) 273 goto give_sigsegv; 274 275 #ifdef DEBUG_SIG 276 printk("%d old rip %lx old rsp %lx old rax %lx\n", current->pid,regs->rip,regs->rsp,regs->rax); 277 #endif 278 279 /* Set up registers for signal handler */ 280 regs->rdi = sig; 281 /* In case the signal handler was declared without prototypes */ 282 regs->rax = 0; 283 284 /* This also works for non SA_SIGINFO handlers because they expect the 285 next argument after the signal number on the stack. */ 286 regs->rsi = (unsigned long)&frame->info; 287 regs->rdx = (unsigned long)&frame->uc; 288 regs->rip = (unsigned long) ka->sa.sa_handler; 289 290 regs->rsp = (unsigned long)frame; 291 292 /* Set up the CS register to run signal handlers in 64-bit mode, 293 even if the handler happens to be interrupting 32-bit code. */ 294 regs->cs = __USER_CS; 295 296 /* This, by contrast, has nothing to do with segment registers - 297 see include/asm-x86_64/uaccess.h for details. */ 298 set_fs(USER_DS); 299 300 regs->eflags &= ~TF_MASK; 301 if (test_thread_flag(TIF_SINGLESTEP)) 302 ptrace_notify(SIGTRAP); 303 #ifdef DEBUG_SIG 304 printk("SIG deliver (%s:%d): sp=%p pc=%lx ra=%p\n", 305 current->comm, current->pid, frame, regs->rip, frame->pretcode); 306 #endif 307 308 return 0; 309 310 give_sigsegv: 311 force_sigsegv(sig, current); 312 return -EFAULT; 313 } 314 315 /* 316 * OK, we're invoking a handler 317 */ 318 319 static int 320 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka, 321 sigset_t *oldset, struct pt_regs *regs) 322 { 323 int ret; 324 325 #ifdef DEBUG_SIG 326 printk("handle_signal pid:%d sig:%lu rip:%lx rsp:%lx regs=%p\n", 327 current->pid, sig, 328 regs->rip, regs->rsp, regs); 329 #endif 330 331 /* Are we from a system call? */ 332 if ((long)regs->orig_rax >= 0) { 333 /* If so, check system call restarting.. */ 334 switch (regs->rax) { 335 case -ERESTART_RESTARTBLOCK: 336 case -ERESTARTNOHAND: 337 regs->rax = -EINTR; 338 break; 339 340 case -ERESTARTSYS: 341 if (!(ka->sa.sa_flags & SA_RESTART)) { 342 regs->rax = -EINTR; 343 break; 344 } 345 /* fallthrough */ 346 case -ERESTARTNOINTR: 347 regs->rax = regs->orig_rax; 348 regs->rip -= 2; 349 break; 350 } 351 } 352 353 /* 354 * If TF is set due to a debugger (PT_DTRACE), clear the TF 355 * flag so that register information in the sigcontext is 356 * correct. 357 */ 358 if (unlikely(regs->eflags & TF_MASK)) { 359 if (likely(current->ptrace & PT_DTRACE)) { 360 current->ptrace &= ~PT_DTRACE; 361 regs->eflags &= ~TF_MASK; 362 } 363 } 364 365 #ifdef CONFIG_IA32_EMULATION 366 if (test_thread_flag(TIF_IA32)) { 367 if (ka->sa.sa_flags & SA_SIGINFO) 368 ret = ia32_setup_rt_frame(sig, ka, info, oldset, regs); 369 else 370 ret = ia32_setup_frame(sig, ka, oldset, regs); 371 } else 372 #endif 373 ret = setup_rt_frame(sig, ka, info, oldset, regs); 374 375 if (ret == 0) { 376 spin_lock_irq(¤t->sighand->siglock); 377 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 378 if (!(ka->sa.sa_flags & SA_NODEFER)) 379 sigaddset(¤t->blocked,sig); 380 recalc_sigpending(); 381 spin_unlock_irq(¤t->sighand->siglock); 382 } 383 384 return ret; 385 } 386 387 /* 388 * Note that 'init' is a special process: it doesn't get signals it doesn't 389 * want to handle. Thus you cannot kill init even with a SIGKILL even by 390 * mistake. 391 */ 392 static void do_signal(struct pt_regs *regs) 393 { 394 struct k_sigaction ka; 395 siginfo_t info; 396 int signr; 397 sigset_t *oldset; 398 399 /* 400 * We want the common case to go fast, which 401 * is why we may in certain cases get here from 402 * kernel mode. Just return without doing anything 403 * if so. 404 */ 405 if (!user_mode(regs)) 406 return; 407 408 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 409 oldset = ¤t->saved_sigmask; 410 else 411 oldset = ¤t->blocked; 412 413 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 414 if (signr > 0) { 415 /* Reenable any watchpoints before delivering the 416 * signal to user space. The processor register will 417 * have been cleared if the watchpoint triggered 418 * inside the kernel. 419 */ 420 if (current->thread.debugreg7) 421 set_debugreg(current->thread.debugreg7, 7); 422 423 /* Whee! Actually deliver the signal. */ 424 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) { 425 /* a signal was successfully delivered; the saved 426 * sigmask will have been stored in the signal frame, 427 * and will be restored by sigreturn, so we can simply 428 * clear the TIF_RESTORE_SIGMASK flag */ 429 clear_thread_flag(TIF_RESTORE_SIGMASK); 430 } 431 return; 432 } 433 434 /* Did we come from a system call? */ 435 if ((long)regs->orig_rax >= 0) { 436 /* Restart the system call - no handlers present */ 437 long res = regs->rax; 438 switch (res) { 439 case -ERESTARTNOHAND: 440 case -ERESTARTSYS: 441 case -ERESTARTNOINTR: 442 regs->rax = regs->orig_rax; 443 regs->rip -= 2; 444 break; 445 case -ERESTART_RESTARTBLOCK: 446 regs->rax = test_thread_flag(TIF_IA32) ? 447 __NR_ia32_restart_syscall : 448 __NR_restart_syscall; 449 regs->rip -= 2; 450 break; 451 } 452 } 453 454 /* if there's no signal to deliver, we just put the saved sigmask 455 back. */ 456 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 457 clear_thread_flag(TIF_RESTORE_SIGMASK); 458 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 459 } 460 } 461 462 void 463 do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags) 464 { 465 #ifdef DEBUG_SIG 466 printk("do_notify_resume flags:%x rip:%lx rsp:%lx caller:%p pending:%x\n", 467 thread_info_flags, regs->rip, regs->rsp, __builtin_return_address(0),signal_pending(current)); 468 #endif 469 470 /* Pending single-step? */ 471 if (thread_info_flags & _TIF_SINGLESTEP) { 472 regs->eflags |= TF_MASK; 473 clear_thread_flag(TIF_SINGLESTEP); 474 } 475 476 #ifdef CONFIG_X86_MCE 477 /* notify userspace of pending MCEs */ 478 if (thread_info_flags & _TIF_MCE_NOTIFY) 479 mce_notify_user(); 480 #endif /* CONFIG_X86_MCE */ 481 482 /* deal with pending signal delivery */ 483 if (thread_info_flags & (_TIF_SIGPENDING|_TIF_RESTORE_SIGMASK)) 484 do_signal(regs); 485 } 486 487 void signal_fault(struct pt_regs *regs, void __user *frame, char *where) 488 { 489 struct task_struct *me = current; 490 if (show_unhandled_signals && printk_ratelimit()) 491 printk("%s[%d] bad frame in %s frame:%p rip:%lx rsp:%lx orax:%lx\n", 492 me->comm,me->pid,where,frame,regs->rip,regs->rsp,regs->orig_rax); 493 494 force_sig(SIGSEGV, me); 495 } 496