1/* 2 * linux/arch/x86_64/kernel/signal.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * Copyright (C) 2000, 2001 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-2001 x86-64 support by Andi Kleen 10 * 11 * $Id: signal.c,v 1.1.1.1 2008/10/15 03:26:21 james26_jang Exp $ 12 */ 13 14#include <linux/sched.h> 15#include <linux/mm.h> 16#include <linux/smp.h> 17#include <linux/smp_lock.h> 18#include <linux/kernel.h> 19#include <linux/signal.h> 20#include <linux/errno.h> 21#include <linux/wait.h> 22#include <linux/ptrace.h> 23#include <linux/unistd.h> 24#include <linux/stddef.h> 25#include <linux/tty.h> 26#include <linux/personality.h> 27#include <linux/compiler.h> 28#include <linux/binfmts.h> 29#include <asm/ucontext.h> 30#include <asm/uaccess.h> 31#include <asm/i387.h> 32 33#define DEBUG_SIG 0 34 35#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 36 37asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset); 38 39void ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 40 sigset_t *set, struct pt_regs * regs); 41void ia32_setup_frame(int sig, struct k_sigaction *ka, 42 sigset_t *set, struct pt_regs * regs); 43void signal_fault(struct pt_regs *regs, void *frame, char *where); 44extern int exception_trace; 45 46int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from) 47{ 48 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t))) 49 return -EFAULT; 50 if (from->si_code < 0) 51 return __copy_to_user(to, from, sizeof(siginfo_t)); 52 else { 53 int err; 54 55 /* If you change siginfo_t structure, please be sure 56 this code is fixed accordingly. 57 It should never copy any pad contained in the structure 58 to avoid security leaks, but must copy the generic 59 3 ints plus the relevant union member. */ 60 err = __put_user(from->si_signo, &to->si_signo); 61 err |= __put_user(from->si_errno, &to->si_errno); 62 err |= __put_user((short)from->si_code, &to->si_code); 63 /* First 32bits of unions are always present. */ 64 err |= __put_user(from->si_pid, &to->si_pid); 65 switch (from->si_code >> 16) { 66 case __SI_FAULT >> 16: 67 break; 68 case __SI_CHLD >> 16: 69 err |= __put_user(from->si_utime, &to->si_utime); 70 err |= __put_user(from->si_stime, &to->si_stime); 71 err |= __put_user(from->si_status, &to->si_status); 72 default: 73 err |= __put_user(from->si_uid, &to->si_uid); 74 break; 75 /* case __SI_RT: This is not generated by the kernel as of now. */ 76 } 77 return err; 78 } 79} 80 81asmlinkage long 82sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, struct pt_regs regs) 83{ 84 sigset_t saveset, newset; 85 86 if (sigsetsize != sizeof(sigset_t)) 87 return -EINVAL; 88 89 if (copy_from_user(&newset, unewset, sizeof(newset))) 90 return -EFAULT; 91 sigdelsetmask(&newset, ~_BLOCKABLE); 92 93 spin_lock_irq(¤t->sigmask_lock); 94 saveset = current->blocked; 95 current->blocked = newset; 96 recalc_sigpending(current); 97 spin_unlock_irq(¤t->sigmask_lock); 98#if DEBUG_SIG 99 printk("rt_sigsuspend savset(%lx) newset(%lx) regs(%p) rip(%lx)\n", 100 saveset, newset, ®s, regs.rip); 101#endif 102 regs.rax = -EINTR; 103 while (1) { 104 current->state = TASK_INTERRUPTIBLE; 105 schedule(); 106 if (do_signal(®s, &saveset)) 107 return -EINTR; 108 } 109} 110 111asmlinkage long 112sys_sigaltstack(const stack_t *uss, stack_t *uoss, struct pt_regs regs) 113{ 114 return do_sigaltstack(uss, uoss, regs.rsp); 115} 116 117 118/* 119 * Do a signal return; undo the signal stack. 120 */ 121 122struct rt_sigframe 123{ 124 char *pretcode; 125 struct ucontext uc; 126 struct siginfo info; 127}; 128 129static int 130restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc, unsigned long *prax) 131{ 132 unsigned int err = 0; 133 134 135#define COPY(x) err |= __get_user(regs->x, &sc->x) 136#define COPY_CANON(x) \ 137 COPY(x); \ 138 if ((regs->x >> 48) != 0 && (regs->x >> 48) != 0xffff) \ 139 regs->x = 0; 140 141 { 142 unsigned int seg; 143 err |= __get_user(seg, &sc->gs); 144 load_gs_index(seg); 145 err |= __get_user(seg, &sc->fs); 146 loadsegment(fs,seg); 147 } 148 149 COPY(rdi); COPY(rsi); COPY(rbp); COPY_CANON(rsp); COPY(rbx); 150 COPY(rdx); COPY(rcx); COPY_CANON(rip); 151 COPY(r8); 152 COPY(r9); 153 COPY(r10); 154 COPY(r11); 155 COPY(r12); 156 COPY(r13); 157 COPY(r14); 158 COPY(r15); 159 160 /* do not copy CS/SS because 64bit should not need it. 161 also need IRET exception handling anyways. */ 162 163 { 164 unsigned int tmpflags; 165 err |= __get_user(tmpflags, &sc->eflags); 166 regs->eflags = (regs->eflags & ~0x40DD5) | (tmpflags & 0x40DD5); 167 regs->orig_rax = -1; /* disable syscall checks */ 168 } 169 170 { 171 struct _fpstate * buf; 172 err |= __get_user(buf, &sc->fpstate); 173 if (buf) { 174 if (unlikely(verify_area(VERIFY_READ, buf, sizeof(*buf)))) 175 return 1; 176 err |= restore_i387(buf); 177 } 178 } 179 180 err |= __get_user(*prax, &sc->rax); 181 return err; 182} 183#undef COPY 184 185asmlinkage long sys_rt_sigreturn(struct pt_regs regs) 186{ 187 struct rt_sigframe *frame = (struct rt_sigframe *)(regs.rsp - 8); 188 sigset_t set; 189 stack_t st; 190 long eax; 191 192 if (verify_area(VERIFY_READ, frame, sizeof(*frame))) 193 goto badframe; 194 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 195 goto badframe; 196 197 sigdelsetmask(&set, ~_BLOCKABLE); 198 spin_lock_irq(¤t->sigmask_lock); 199 current->blocked = set; 200 recalc_sigpending(current); 201 spin_unlock_irq(¤t->sigmask_lock); 202 203 if (restore_sigcontext(®s, &frame->uc.uc_mcontext, &eax)) 204 goto badframe; 205 206#if DEBUG_SIG 207 printk("%d sigreturn rip:%lx rsp:%lx frame:%p rax:%lx\n",current->pid,regs.rip,regs.rsp,frame,eax); 208#endif 209 210 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st))) 211 goto badframe; 212 /* It is more difficult to avoid calling this function than to 213 call it and ignore errors. */ 214 do_sigaltstack(&st, NULL, regs.rsp); 215 216 return eax; 217 218badframe: 219 signal_fault(®s, frame, "rt_sigreturn"); 220 return 0; 221} 222 223/* 224 * Set up a signal frame. 225 */ 226 227static int 228setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs, unsigned long mask) 229{ 230 int tmp, err = 0; 231 struct task_struct *me = current; 232 233 tmp = 0; 234 __asm__("movl %%gs,%0" : "=r"(tmp): "0"(tmp)); 235 err |= __put_user(tmp, (unsigned int *)&sc->gs); 236 __asm__("movl %%fs,%0" : "=r"(tmp): "0"(tmp)); 237 err |= __put_user(tmp, (unsigned int *)&sc->fs); 238 239 err |= __put_user(regs->rdi, &sc->rdi); 240 err |= __put_user(regs->rsi, &sc->rsi); 241 err |= __put_user(regs->rbp, &sc->rbp); 242 err |= __put_user(regs->rsp, &sc->rsp); 243 err |= __put_user(regs->rbx, &sc->rbx); 244 err |= __put_user(regs->rdx, &sc->rdx); 245 err |= __put_user(regs->rcx, &sc->rcx); 246 err |= __put_user(regs->rax, &sc->rax); 247 err |= __put_user(regs->r8, &sc->r8); 248 err |= __put_user(regs->r9, &sc->r9); 249 err |= __put_user(regs->r10, &sc->r10); 250 err |= __put_user(regs->r11, &sc->r11); 251 err |= __put_user(regs->r12, &sc->r12); 252 err |= __put_user(regs->r13, &sc->r13); 253 err |= __put_user(regs->r14, &sc->r14); 254 err |= __put_user(regs->r15, &sc->r15); 255 err |= __put_user(me->thread.trap_no, &sc->trapno); 256 err |= __put_user(me->thread.error_code, &sc->err); 257 err |= __put_user(regs->rip, &sc->rip); 258 err |= __put_user(regs->cs, &sc->cs); 259 err |= __put_user(regs->eflags, &sc->eflags); 260 err |= __put_user(mask, &sc->oldmask); 261 err |= __put_user(me->thread.cr2, &sc->cr2); 262 263 return err; 264} 265 266/* 267 * Determine which stack to use.. 268 */ 269#define round_down(p, r) ((void *) ((unsigned long)((p) - (r) + 1) & ~((r)-1))) 270 271 272static void * 273get_stack(struct k_sigaction *ka, struct pt_regs *regs, unsigned long size) 274{ 275 unsigned long rsp; 276 277 /* Default to using normal stack - redzone*/ 278 rsp = regs->rsp - 128; 279 280 /* This is the X/Open sanctioned signal stack switching. */ 281 if (ka->sa.sa_flags & SA_ONSTACK) { 282 if (! sas_ss_flags(rsp) == 0) 283 rsp = current->sas_ss_sp + current->sas_ss_size; 284 } 285 286 return round_down(rsp - size, 16); 287} 288 289static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 290 sigset_t *set, struct pt_regs * regs) 291{ 292 struct rt_sigframe *frame = NULL; 293 struct _fpstate *fp = NULL; 294 int err = 0; 295 296 if (current->used_math) { 297 fp = get_stack(ka, regs, sizeof(struct _fpstate)); 298 frame = round_down((char *)fp - sizeof(struct rt_sigframe), 16) - 8; 299 300 if (!access_ok(VERIFY_WRITE, fp, sizeof(struct _fpstate))) { 301 goto give_sigsegv; 302 } 303 if (save_i387(fp) < 0) 304 err |= -1; 305 } 306 307 if (!frame) 308 frame = get_stack(ka, regs, sizeof(struct rt_sigframe)) - 8; 309 310 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) { 311 goto give_sigsegv; 312 } 313 314 315 if (ka->sa.sa_flags & SA_SIGINFO) { 316 err |= copy_siginfo_to_user(&frame->info, info); 317 if (err) 318 goto give_sigsegv; 319 } 320 321 /* Create the ucontext. */ 322 err |= __put_user(0, &frame->uc.uc_flags); 323 err |= __put_user(0, &frame->uc.uc_link); 324 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 325 err |= __put_user(sas_ss_flags(regs->rsp), 326 &frame->uc.uc_stack.ss_flags); 327 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 328 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]); 329 err |= __put_user(fp, &frame->uc.uc_mcontext.fpstate); 330 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 331 332 /* Set up to return from userspace. If provided, use a stub 333 already in userspace. */ 334 /* x86-64 should always use SA_RESTORER. */ 335 if (ka->sa.sa_flags & SA_RESTORER) { 336 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode); 337 } else { 338 printk("%s forgot to set SA_RESTORER for signal %d.\n", current->comm, sig); 339 goto give_sigsegv; 340 } 341 342 if (err) 343 goto give_sigsegv; 344 345#if DEBUG_SIG 346 printk("%d old rip %lx old rsp %lx old rax %lx\n", current->pid,regs->rip,regs->rsp,regs->rax); 347#endif 348 349 /* Set up registers for signal handler */ 350 { 351 struct exec_domain *ed = current->exec_domain; 352 if (unlikely(ed && ed->signal_invmap && sig < 32)) 353 sig = ed->signal_invmap[sig]; 354 } 355 regs->rdi = sig; 356 357 /* could reload DS/ES to __USER_DS here, but assume for now 358 that 64bit does not care */ 359 360 /* In case the signal handler was declared without prototypes */ 361 regs->rax = 0; 362 363 /* This also works for non SA_SIGINFO handlers because they expect the 364 next argument after the signal number on the stack. */ 365 regs->rsi = (unsigned long)&frame->info; 366 regs->rdx = (unsigned long)&frame->uc; 367 regs->rsp = (unsigned long) frame; 368 regs->rip = (unsigned long) ka->sa.sa_handler; 369 regs->cs = __USER_CS; 370 regs->ss = __USER_DS; 371 372 set_fs(USER_DS); 373 regs->eflags &= ~TF_MASK; 374 375#if DEBUG_SIG 376 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n", 377 current->comm, current->pid, frame, regs->rip, frame->pretcode); 378#endif 379 380 return; 381 382give_sigsegv: 383 if (sig == SIGSEGV) 384 ka->sa.sa_handler = SIG_DFL; 385 signal_fault(regs, frame, "signal deliver"); 386} 387 388/* 389 * OK, we're invoking a handler 390 */ 391 392static void 393handle_signal(unsigned long sig, struct k_sigaction *ka, 394 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs) 395{ 396#if DEBUG_SIG 397 printk("handle_signal pid:%d sig:%lu rip:%lx rsp:%lx regs=%p\n", current->pid, sig, 398 regs->rip, regs->rsp, regs); 399#endif 400 401 /* Are we from a system call? */ 402 if (regs->orig_rax >= 0) { 403 /* If so, check system call restarting.. */ 404 switch (regs->rax) { 405 case -ERESTARTNOHAND: 406 regs->rax = -EINTR; 407 break; 408 409 case -ERESTARTSYS: 410 if (!(ka->sa.sa_flags & SA_RESTART)) { 411 regs->rax = -EINTR; 412 break; 413 } 414 /* fallthrough */ 415 case -ERESTARTNOINTR: 416 regs->rax = regs->orig_rax; 417 regs->rip -= 2; 418 break; 419 } 420 } 421 422#ifdef CONFIG_IA32_EMULATION 423 if (current->thread.flags & THREAD_IA32) { 424 if (ka->sa.sa_flags & SA_SIGINFO) 425 ia32_setup_rt_frame(sig, ka, info, oldset, regs); 426 else 427 ia32_setup_frame(sig, ka, oldset, regs); 428 } else 429#endif 430 setup_rt_frame(sig, ka, info, oldset, regs); 431 432 if (ka->sa.sa_flags & SA_ONESHOT) 433 ka->sa.sa_handler = SIG_DFL; 434 435 if (!(ka->sa.sa_flags & SA_NODEFER)) { 436 spin_lock_irq(¤t->sigmask_lock); 437 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 438 sigaddset(¤t->blocked,sig); 439 recalc_sigpending(current); 440 spin_unlock_irq(¤t->sigmask_lock); 441 } 442} 443 444/* 445 * Note that 'init' is a special process: it doesn't get signals it doesn't 446 * want to handle. Thus you cannot kill init even with a SIGKILL even by 447 * mistake. 448 */ 449int do_signal(struct pt_regs *regs, sigset_t *oldset) 450{ 451 siginfo_t info; 452 struct k_sigaction *ka; 453 454 /* 455 * We want the common case to go fast, which 456 * is why we may in certain cases get here from 457 * kernel mode. Just return without doing anything 458 * if so. 459 */ 460 if ((regs->cs & 3) != 3) { 461 return 1; 462 } 463 464 if (!oldset) 465 oldset = ¤t->blocked; 466 467 for (;;) { 468 unsigned long signr; 469 470 spin_lock_irq(¤t->sigmask_lock); 471 signr = dequeue_signal(¤t->blocked, &info); 472 spin_unlock_irq(¤t->sigmask_lock); 473 474 if (!signr) { 475 break; 476 } 477 478 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) { 479 /* Let the debugger run. */ 480 current->exit_code = signr; 481 current->state = TASK_STOPPED; 482 notify_parent(current, SIGCHLD); 483 schedule(); 484 485 /* We're back. Did the debugger cancel the sig? */ 486 if (!(signr = current->exit_code)) 487 continue; 488 current->exit_code = 0; 489 490 /* The debugger continued. Ignore SIGSTOP. */ 491 if (signr == SIGSTOP) 492 continue; 493 494 /* Update the siginfo structure. Is this good? */ 495 if (signr != info.si_signo) { 496 info.si_signo = signr; 497 info.si_errno = 0; 498 info.si_code = SI_USER; 499 info.si_pid = current->p_pptr->pid; 500 info.si_uid = current->p_pptr->uid; 501 } 502 503 /* If the (new) signal is now blocked, requeue it. */ 504 if (sigismember(¤t->blocked, signr)) { 505 send_sig_info(signr, &info, current); 506 continue; 507 } 508 } 509 510 ka = ¤t->sig->action[signr-1]; 511 if (ka->sa.sa_handler == SIG_IGN) { 512 if (signr != SIGCHLD) 513 continue; 514 /* Check for SIGCHLD: it's special. */ 515 while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0) 516 /* nothing */; 517 continue; 518 } 519 520 if (ka->sa.sa_handler == SIG_DFL) { 521 int exit_code = signr; 522 523 /* Init gets no signals it doesn't want. */ 524 if (current->pid == 1) 525 continue; 526 527 switch (signr) { 528 case SIGCONT: case SIGCHLD: case SIGWINCH: case SIGURG: 529 continue; 530 531 case SIGTSTP: case SIGTTIN: case SIGTTOU: 532 if (is_orphaned_pgrp(current->pgrp)) 533 continue; 534 /* FALLTHRU */ 535 536 case SIGSTOP: { 537 struct signal_struct *sig; 538 current->state = TASK_STOPPED; 539 current->exit_code = signr; 540 sig = current->p_pptr->sig; 541 if (sig && !(sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP)) 542 notify_parent(current, SIGCHLD); 543 schedule(); 544 continue; 545 } 546 547 case SIGQUIT: case SIGILL: case SIGTRAP: 548 case SIGABRT: case SIGFPE: case SIGSEGV: 549 case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ: 550 if (do_coredump(signr, regs)) 551 exit_code |= 0x80; 552 /* FALLTHRU */ 553 554 default: 555 sig_exit(signr, exit_code, &info); 556 /* NOTREACHED */ 557 } 558 } 559 560 /* Reenable any watchpoints before delivering the 561 * signal to user space. The processor register will 562 * have been cleared if the watchpoint triggered 563 * inside the kernel. 564 */ 565 __asm__("movq %0,%%db7" : : "r" (current->thread.debugreg[7])); 566 567 /* Whee! Actually deliver the signal. */ 568 handle_signal(signr, ka, &info, oldset, regs); 569 return 1; 570 } 571 572 /* Did we come from a system call? */ 573 if (regs->orig_rax >= 0) { 574 /* Restart the system call - no handlers present */ 575 if (regs->rax == -ERESTARTNOHAND || 576 regs->rax == -ERESTARTSYS || 577 regs->rax == -ERESTARTNOINTR) { 578 regs->rax = regs->orig_rax; 579 regs->rip -= 2; 580 } 581 } 582 return 0; 583} 584 585 586void signal_fault(struct pt_regs *regs, void *frame, char *where) 587{ 588 struct task_struct *me = current; 589 if (exception_trace) 590 printk("%s[%d] bad frame in %s frame:%p rip:%lx rsp:%lx orax:%lx\n", 591 me->comm,me->pid,where,frame,regs->rip,regs->rsp,regs->orig_rax); 592 593 force_sig(SIGSEGV, me); 594} 595