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