git.oblomov.eu Git - linux-2.6/blob - arch/x86/ia32/ia32_signal.c

   1 /*
   2  *  linux/arch/x86_64/ia32/ia32_signal.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *
   6  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
   7  *  2000-06-20  Pentium III FXSR, SSE support by Gareth Hughes
   8  *  2000-12-*   x86-64 compatibility mode signal handling by Andi Kleen
   9  */
  10
  11 #include <linux/sched.h>
  12 #include <linux/mm.h>
  13 #include <linux/smp.h>
  14 #include <linux/kernel.h>
  15 #include <linux/signal.h>
  16 #include <linux/errno.h>
  17 #include <linux/wait.h>
  18 #include <linux/ptrace.h>
  19 #include <linux/unistd.h>
  20 #include <linux/stddef.h>
  21 #include <linux/personality.h>
  22 #include <linux/compat.h>
  23 #include <linux/binfmts.h>
  24 #include <asm/ucontext.h>
  25 #include <asm/uaccess.h>
  26 #include <asm/i387.h>
  27 #include <asm/ia32.h>
  28 #include <asm/ptrace.h>
  29 #include <asm/ia32_unistd.h>
  30 #include <asm/user32.h>
  31 #include <asm/sigcontext32.h>
  32 #include <asm/proto.h>
  33 #include <asm/vdso.h>
  34
  35 #include <asm/sigframe.h>
  36
  37 #define DEBUG_SIG 0
  38
  39 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  40
  41 #define FIX_EFLAGS      (X86_EFLAGS_AC | X86_EFLAGS_OF | \
  42                          X86_EFLAGS_DF | X86_EFLAGS_TF | X86_EFLAGS_SF | \
  43                          X86_EFLAGS_ZF | X86_EFLAGS_AF | X86_EFLAGS_PF | \
  44                          X86_EFLAGS_CF)
  45
  46 void signal_fault(struct pt_regs *regs, void __user *frame, char *where);
  47
  48 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
  49 {
  50         int err;
  51
  52         if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
  53                 return -EFAULT;
  54
  55         /* If you change siginfo_t structure, please make sure that
  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
  64         if (from->si_code < 0) {
  65                 err |= __put_user(from->si_pid, &to->si_pid);
  66                 err |= __put_user(from->si_uid, &to->si_uid);
  67                 err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);
  68         } else {
  69                 /*
  70                  * First 32bits of unions are always present:
  71                  * si_pid === si_band === si_tid === si_addr(LS half)
  72                  */
  73                 err |= __put_user(from->_sifields._pad[0],
  74                                   &to->_sifields._pad[0]);
  75                 switch (from->si_code >> 16) {
  76                 case __SI_FAULT >> 16:
  77                         break;
  78                 case __SI_CHLD >> 16:
  79                         err |= __put_user(from->si_utime, &to->si_utime);
  80                         err |= __put_user(from->si_stime, &to->si_stime);
  81                         err |= __put_user(from->si_status, &to->si_status);
  82                         /* FALL THROUGH */
  83                 default:
  84                 case __SI_KILL >> 16:
  85                         err |= __put_user(from->si_uid, &to->si_uid);
  86                         break;
  87                 case __SI_POLL >> 16:
  88                         err |= __put_user(from->si_fd, &to->si_fd);
  89                         break;
  90                 case __SI_TIMER >> 16:
  91                         err |= __put_user(from->si_overrun, &to->si_overrun);
  92                         err |= __put_user(ptr_to_compat(from->si_ptr),
  93                                           &to->si_ptr);
  94                         break;
  95                          /* This is not generated by the kernel as of now.  */
  96                 case __SI_RT >> 16:
  97                 case __SI_MESGQ >> 16:
  98                         err |= __put_user(from->si_uid, &to->si_uid);
  99                         err |= __put_user(from->si_int, &to->si_int);
 100                         break;
 101                 }
 102         }
 103         return err;
 104 }
 105
 106 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 107 {
 108         int err;
 109         u32 ptr32;
 110
 111         if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))
 112                 return -EFAULT;
 113
 114         err = __get_user(to->si_signo, &from->si_signo);
 115         err |= __get_user(to->si_errno, &from->si_errno);
 116         err |= __get_user(to->si_code, &from->si_code);
 117
 118         err |= __get_user(to->si_pid, &from->si_pid);
 119         err |= __get_user(to->si_uid, &from->si_uid);
 120         err |= __get_user(ptr32, &from->si_ptr);
 121         to->si_ptr = compat_ptr(ptr32);
 122
 123         return err;
 124 }
 125
 126 asmlinkage long sys32_sigsuspend(int history0, int history1, old_sigset_t mask)
 127 {
 128         mask &= _BLOCKABLE;
 129         spin_lock_irq(&current->sighand->siglock);
 130         current->saved_sigmask = current->blocked;
 131         siginitset(&current->blocked, mask);
 132         recalc_sigpending();
 133         spin_unlock_irq(&current->sighand->siglock);
 134
 135         current->state = TASK_INTERRUPTIBLE;
 136         schedule();
 137         set_restore_sigmask();
 138         return -ERESTARTNOHAND;
 139 }
 140
 141 asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr,
 142                                   stack_ia32_t __user *uoss_ptr,
 143                                   struct pt_regs *regs)
 144 {
 145         stack_t uss, uoss;
 146         int ret;
 147         mm_segment_t seg;
 148
 149         if (uss_ptr) {
 150                 u32 ptr;
 151
 152                 memset(&uss, 0, sizeof(stack_t));
 153                 if (!access_ok(VERIFY_READ, uss_ptr, sizeof(stack_ia32_t)) ||
 154                             __get_user(ptr, &uss_ptr->ss_sp) ||
 155                             __get_user(uss.ss_flags, &uss_ptr->ss_flags) ||
 156                             __get_user(uss.ss_size, &uss_ptr->ss_size))
 157                         return -EFAULT;
 158                 uss.ss_sp = compat_ptr(ptr);
 159         }
 160         seg = get_fs();
 161         set_fs(KERNEL_DS);
 162         ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs->sp);
 163         set_fs(seg);
 164         if (ret >= 0 && uoss_ptr)  {
 165                 if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(stack_ia32_t)) ||
 166                     __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
 167                     __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
 168                     __put_user(uoss.ss_size, &uoss_ptr->ss_size))
 169                         ret = -EFAULT;
 170         }
 171         return ret;
 172 }
 173
 174 /*
 175  * Do a signal return; undo the signal stack.
 176  */
 177 #define COPY(x)                 {               \
 178         err |= __get_user(regs->x, &sc->x);     \
 179 }
 180
 181 #define COPY_SEG_CPL3(seg)      {                       \
 182                 unsigned short tmp;                     \
 183                 err |= __get_user(tmp, &sc->seg);       \
 184                 regs->seg = tmp | 3;                    \
 185 }
 186
 187 #define RELOAD_SEG(seg)         {               \
 188         unsigned int cur, pre;                  \
 189         err |= __get_user(pre, &sc->seg);       \
 190         savesegment(seg, cur);                  \
 191         pre |= 3;                               \
 192         if (pre != cur)                         \
 193                 loadsegment(seg, pre);          \
 194 }
 195
 196 static int ia32_restore_sigcontext(struct pt_regs *regs,
 197                                    struct sigcontext_ia32 __user *sc,
 198                                    unsigned int *pax)
 199 {
 200         unsigned int tmpflags, gs, oldgs, err = 0;
 201         void __user *buf;
 202         u32 tmp;
 203
 204         /* Always make any pending restarted system calls return -EINTR */
 205         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 206
 207 #if DEBUG_SIG
 208         printk(KERN_DEBUG "SIG restore_sigcontext: "
 209                "sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
 210                sc, sc->err, sc->ip, sc->cs, sc->flags);
 211 #endif
 212
 213         /*
 214          * Reload fs and gs if they have changed in the signal
 215          * handler.  This does not handle long fs/gs base changes in
 216          * the handler, but does not clobber them at least in the
 217          * normal case.
 218          */
 219         err |= __get_user(gs, &sc->gs);
 220         gs |= 3;
 221         savesegment(gs, oldgs);
 222         if (gs != oldgs)
 223                 load_gs_index(gs);
 224
 225         RELOAD_SEG(fs);
 226         RELOAD_SEG(ds);
 227         RELOAD_SEG(es);
 228
 229         COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
 230         COPY(dx); COPY(cx); COPY(ip);
 231         /* Don't touch extended registers */
 232
 233         COPY_SEG_CPL3(cs);
 234         COPY_SEG_CPL3(ss);
 235
 236         err |= __get_user(tmpflags, &sc->flags);
 237         regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
 238         /* disable syscall checks */
 239         regs->orig_ax = -1;
 240
 241         err |= __get_user(tmp, &sc->fpstate);
 242         buf = compat_ptr(tmp);
 243         err |= restore_i387_xstate_ia32(buf);
 244
 245         err |= __get_user(*pax, &sc->ax);
 246         return err;
 247 }
 248
 249 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
 250 {
 251         struct sigframe_ia32 __user *frame = (struct sigframe_ia32 __user *)(regs->sp-8);
 252         sigset_t set;
 253         unsigned int ax;
 254
 255         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 256                 goto badframe;
 257         if (__get_user(set.sig[0], &frame->sc.oldmask)
 258             || (_COMPAT_NSIG_WORDS > 1
 259                 && __copy_from_user((((char *) &set.sig) + 4),
 260                                     &frame->extramask,
 261                                     sizeof(frame->extramask))))
 262                 goto badframe;
 263
 264         sigdelsetmask(&set, ~_BLOCKABLE);
 265         spin_lock_irq(&current->sighand->siglock);
 266         current->blocked = set;
 267         recalc_sigpending();
 268         spin_unlock_irq(&current->sighand->siglock);
 269
 270         if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
 271                 goto badframe;
 272         return ax;
 273
 274 badframe:
 275         signal_fault(regs, frame, "32bit sigreturn");
 276         return 0;
 277 }
 278
 279 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
 280 {
 281         struct rt_sigframe_ia32 __user *frame;
 282         sigset_t set;
 283         unsigned int ax;
 284         struct pt_regs tregs;
 285
 286         frame = (struct rt_sigframe_ia32 __user *)(regs->sp - 4);
 287
 288         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 289                 goto badframe;
 290         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 291                 goto badframe;
 292
 293         sigdelsetmask(&set, ~_BLOCKABLE);
 294         spin_lock_irq(&current->sighand->siglock);
 295         current->blocked = set;
 296         recalc_sigpending();
 297         spin_unlock_irq(&current->sighand->siglock);
 298
 299         if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
 300                 goto badframe;
 301
 302         tregs = *regs;
 303         if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
 304                 goto badframe;
 305
 306         return ax;
 307
 308 badframe:
 309         signal_fault(regs, frame, "32bit rt sigreturn");
 310         return 0;
 311 }
 312
 313 /*
 314  * Set up a signal frame.
 315  */
 316
 317 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
 318                                  void __user *fpstate,
 319                                  struct pt_regs *regs, unsigned int mask)
 320 {
 321         int tmp, err = 0;
 322
 323         savesegment(gs, tmp);
 324         err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
 325         savesegment(fs, tmp);
 326         err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
 327         savesegment(ds, tmp);
 328         err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
 329         savesegment(es, tmp);
 330         err |= __put_user(tmp, (unsigned int __user *)&sc->es);
 331
 332         err |= __put_user(regs->di, &sc->di);
 333         err |= __put_user(regs->si, &sc->si);
 334         err |= __put_user(regs->bp, &sc->bp);
 335         err |= __put_user(regs->sp, &sc->sp);
 336         err |= __put_user(regs->bx, &sc->bx);
 337         err |= __put_user(regs->dx, &sc->dx);
 338         err |= __put_user(regs->cx, &sc->cx);
 339         err |= __put_user(regs->ax, &sc->ax);
 340         err |= __put_user(current->thread.trap_no, &sc->trapno);
 341         err |= __put_user(current->thread.error_code, &sc->err);
 342         err |= __put_user(regs->ip, &sc->ip);
 343         err |= __put_user(regs->cs, (unsigned int __user *)&sc->cs);
 344         err |= __put_user(regs->flags, &sc->flags);
 345         err |= __put_user(regs->sp, &sc->sp_at_signal);
 346         err |= __put_user(regs->ss, (unsigned int __user *)&sc->ss);
 347
 348         err |= __put_user(ptr_to_compat(fpstate), &sc->fpstate);
 349
 350         /* non-iBCS2 extensions.. */
 351         err |= __put_user(mask, &sc->oldmask);
 352         err |= __put_user(current->thread.cr2, &sc->cr2);
 353
 354         return err;
 355 }
 356
 357 /*
 358  * Determine which stack to use..
 359  */
 360 static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
 361                                  size_t frame_size,
 362                                  void **fpstate)
 363 {
 364         unsigned long sp;
 365
 366         /* Default to using normal stack */
 367         sp = regs->sp;
 368
 369         /* This is the X/Open sanctioned signal stack switching.  */
 370         if (ka->sa.sa_flags & SA_ONSTACK) {
 371                 if (sas_ss_flags(sp) == 0)
 372                         sp = current->sas_ss_sp + current->sas_ss_size;
 373         }
 374
 375         /* This is the legacy signal stack switching. */
 376         else if ((regs->ss & 0xffff) != __USER32_DS &&
 377                 !(ka->sa.sa_flags & SA_RESTORER) &&
 378                  ka->sa.sa_restorer)
 379                 sp = (unsigned long) ka->sa.sa_restorer;
 380
 381         if (used_math()) {
 382                 sp = sp - sig_xstate_ia32_size;
 383                 *fpstate = (struct _fpstate_ia32 *) sp;
 384                 if (save_i387_xstate_ia32(*fpstate) < 0)
 385                         return (void __user *) -1L;
 386         }
 387
 388         sp -= frame_size;
 389         /* Align the stack pointer according to the i386 ABI,
 390          * i.e. so that on function entry ((sp + 4) & 15) == 0. */
 391         sp = ((sp + 4) & -16ul) - 4;
 392         return (void __user *) sp;
 393 }
 394
 395 int ia32_setup_frame(int sig, struct k_sigaction *ka,
 396                      compat_sigset_t *set, struct pt_regs *regs)
 397 {
 398         struct sigframe_ia32 __user *frame;
 399         void __user *restorer;
 400         int err = 0;
 401         void __user *fpstate = NULL;
 402
 403         /* copy_to_user optimizes that into a single 8 byte store */
 404         static const struct {
 405                 u16 poplmovl;
 406                 u32 val;
 407                 u16 int80;
 408         } __attribute__((packed)) code = {
 409                 0xb858,          /* popl %eax ; movl $...,%eax */
 410                 __NR_ia32_sigreturn,
 411                 0x80cd,         /* int $0x80 */
 412         };
 413
 414         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 415
 416         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 417                 return -EFAULT;
 418
 419         if (__put_user(sig, &frame->sig))
 420                 return -EFAULT;
 421
 422         if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
 423                 return -EFAULT;
 424
 425         if (_COMPAT_NSIG_WORDS > 1) {
 426                 if (__copy_to_user(frame->extramask, &set->sig[1],
 427                                    sizeof(frame->extramask)))
 428                         return -EFAULT;
 429         }
 430
 431         if (ka->sa.sa_flags & SA_RESTORER) {
 432                 restorer = ka->sa.sa_restorer;
 433         } else {
 434                 /* Return stub is in 32bit vsyscall page */
 435                 if (current->mm->context.vdso)
 436                         restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 437                                                  sigreturn);
 438                 else
 439                         restorer = &frame->retcode;
 440         }
 441         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 442
 443         /*
 444          * These are actually not used anymore, but left because some
 445          * gdb versions depend on them as a marker.
 446          */
 447         err |= __put_user(*((u64 *)&code), (u64 *)frame->retcode);
 448         if (err)
 449                 return -EFAULT;
 450
 451         /* Set up registers for signal handler */
 452         regs->sp = (unsigned long) frame;
 453         regs->ip = (unsigned long) ka->sa.sa_handler;
 454
 455         /* Make -mregparm=3 work */
 456         regs->ax = sig;
 457         regs->dx = 0;
 458         regs->cx = 0;
 459
 460         loadsegment(ds, __USER32_DS);
 461         loadsegment(es, __USER32_DS);
 462
 463         regs->cs = __USER32_CS;
 464         regs->ss = __USER32_DS;
 465
 466 #if DEBUG_SIG
 467         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
 468                current->comm, current->pid, frame, regs->ip, frame->pretcode);
 469 #endif
 470
 471         return 0;
 472 }
 473
 474 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 475                         compat_sigset_t *set, struct pt_regs *regs)
 476 {
 477         struct rt_sigframe_ia32 __user *frame;
 478         void __user *restorer;
 479         int err = 0;
 480         void __user *fpstate = NULL;
 481
 482         /* __copy_to_user optimizes that into a single 8 byte store */
 483         static const struct {
 484                 u8 movl;
 485                 u32 val;
 486                 u16 int80;
 487                 u8  pad;
 488         } __attribute__((packed)) code = {
 489                 0xb8,
 490                 __NR_ia32_rt_sigreturn,
 491                 0x80cd,
 492                 0,
 493         };
 494
 495         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 496
 497         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 498                 return -EFAULT;
 499
 500         err |= __put_user(sig, &frame->sig);
 501         err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
 502         err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
 503         err |= copy_siginfo_to_user32(&frame->info, info);
 504         if (err)
 505                 return -EFAULT;
 506
 507         /* Create the ucontext.  */
 508         if (cpu_has_xsave)
 509                 err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);
 510         else
 511                 err |= __put_user(0, &frame->uc.uc_flags);
 512         err |= __put_user(0, &frame->uc.uc_link);
 513         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 514         err |= __put_user(sas_ss_flags(regs->sp),
 515                           &frame->uc.uc_stack.ss_flags);
 516         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 517         err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
 518                                      regs, set->sig[0]);
 519         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 520         if (err)
 521                 return -EFAULT;
 522
 523         if (ka->sa.sa_flags & SA_RESTORER)
 524                 restorer = ka->sa.sa_restorer;
 525         else
 526                 restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 527                                          rt_sigreturn);
 528         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 529
 530         /*
 531          * Not actually used anymore, but left because some gdb
 532          * versions need it.
 533          */
 534         err |= __put_user(*((u64 *)&code), (u64 *)frame->retcode);
 535         if (err)
 536                 return -EFAULT;
 537
 538         /* Set up registers for signal handler */
 539         regs->sp = (unsigned long) frame;
 540         regs->ip = (unsigned long) ka->sa.sa_handler;
 541
 542         /* Make -mregparm=3 work */
 543         regs->ax = sig;
 544         regs->dx = (unsigned long) &frame->info;
 545         regs->cx = (unsigned long) &frame->uc;
 546
 547         loadsegment(ds, __USER32_DS);
 548         loadsegment(es, __USER32_DS);
 549
 550         regs->cs = __USER32_CS;
 551         regs->ss = __USER32_DS;
 552
 553 #if DEBUG_SIG
 554         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
 555                current->comm, current->pid, frame, regs->ip, frame->pretcode);
 556 #endif
 557
 558         return 0;
 559 }