arch/x86_64/kernel/signal.c

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