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