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)         {               \
 211         unsigned int cur, pre;                  \
 212         err |= __get_user(pre, &sc->seg);       \
 213         savesegment(seg, cur);                  \
 214         pre |= 3;                               \
 215         if (pre != cur)                         \
 216                 loadsegment(seg, pre);          \
 217 }
 218
 219 static int ia32_restore_sigcontext(struct pt_regs *regs,
 220                                    struct sigcontext_ia32 __user *sc,
 221                                    unsigned int *pax)
 222 {
 223         unsigned int tmpflags, gs, oldgs, err = 0;
 224         void __user *buf;
 225         u32 tmp;
 226
 227         /* Always make any pending restarted system calls return -EINTR */
 228         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 229
 230 #if DEBUG_SIG
 231         printk(KERN_DEBUG "SIG restore_sigcontext: "
 232                "sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
 233                sc, sc->err, sc->ip, sc->cs, sc->flags);
 234 #endif
 235
 236         /*
 237          * Reload fs and gs if they have changed in the signal
 238          * handler.  This does not handle long fs/gs base changes in
 239          * the handler, but does not clobber them at least in the
 240          * normal case.
 241          */
 242         err |= __get_user(gs, &sc->gs);
 243         gs |= 3;
 244         savesegment(gs, oldgs);
 245         if (gs != oldgs)
 246                 load_gs_index(gs);
 247
 248         RELOAD_SEG(fs);
 249         RELOAD_SEG(ds);
 250         RELOAD_SEG(es);
 251
 252         COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
 253         COPY(dx); COPY(cx); COPY(ip);
 254         /* Don't touch extended registers */
 255
 256         COPY_SEG_CPL3(cs);
 257         COPY_SEG_CPL3(ss);
 258
 259         err |= __get_user(tmpflags, &sc->flags);
 260         regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
 261         /* disable syscall checks */
 262         regs->orig_ax = -1;
 263
 264         err |= __get_user(tmp, &sc->fpstate);
 265         buf = compat_ptr(tmp);
 266         err |= restore_i387_xstate_ia32(buf);
 267
 268         err |= __get_user(*pax, &sc->ax);
 269         return err;
 270 }
 271
 272 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
 273 {
 274         struct sigframe __user *frame = (struct sigframe __user *)(regs->sp-8);
 275         sigset_t set;
 276         unsigned int ax;
 277
 278         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 279                 goto badframe;
 280         if (__get_user(set.sig[0], &frame->sc.oldmask)
 281             || (_COMPAT_NSIG_WORDS > 1
 282                 && __copy_from_user((((char *) &set.sig) + 4),
 283                                     &frame->extramask,
 284                                     sizeof(frame->extramask))))
 285                 goto badframe;
 286
 287         sigdelsetmask(&set, ~_BLOCKABLE);
 288         spin_lock_irq(&current->sighand->siglock);
 289         current->blocked = set;
 290         recalc_sigpending();
 291         spin_unlock_irq(&current->sighand->siglock);
 292
 293         if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
 294                 goto badframe;
 295         return ax;
 296
 297 badframe:
 298         signal_fault(regs, frame, "32bit sigreturn");
 299         return 0;
 300 }
 301
 302 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
 303 {
 304         struct rt_sigframe __user *frame;
 305         sigset_t set;
 306         unsigned int ax;
 307         struct pt_regs tregs;
 308
 309         frame = (struct rt_sigframe __user *)(regs->sp - 4);
 310
 311         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 312                 goto badframe;
 313         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 314                 goto badframe;
 315
 316         sigdelsetmask(&set, ~_BLOCKABLE);
 317         spin_lock_irq(&current->sighand->siglock);
 318         current->blocked = set;
 319         recalc_sigpending();
 320         spin_unlock_irq(&current->sighand->siglock);
 321
 322         if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
 323                 goto badframe;
 324
 325         tregs = *regs;
 326         if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
 327                 goto badframe;
 328
 329         return ax;
 330
 331 badframe:
 332         signal_fault(regs, frame, "32bit rt sigreturn");
 333         return 0;
 334 }
 335
 336 /*
 337  * Set up a signal frame.
 338  */
 339
 340 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
 341                                  void __user *fpstate,
 342                                  struct pt_regs *regs, unsigned int mask)
 343 {
 344         int tmp, err = 0;
 345
 346         savesegment(gs, tmp);
 347         err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
 348         savesegment(fs, tmp);
 349         err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
 350         savesegment(ds, tmp);
 351         err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
 352         savesegment(es, tmp);
 353         err |= __put_user(tmp, (unsigned int __user *)&sc->es);
 354
 355         err |= __put_user(regs->di, &sc->di);
 356         err |= __put_user(regs->si, &sc->si);
 357         err |= __put_user(regs->bp, &sc->bp);
 358         err |= __put_user(regs->sp, &sc->sp);
 359         err |= __put_user(regs->bx, &sc->bx);
 360         err |= __put_user(regs->dx, &sc->dx);
 361         err |= __put_user(regs->cx, &sc->cx);
 362         err |= __put_user(regs->ax, &sc->ax);
 363         err |= __put_user(current->thread.trap_no, &sc->trapno);
 364         err |= __put_user(current->thread.error_code, &sc->err);
 365         err |= __put_user(regs->ip, &sc->ip);
 366         err |= __put_user(regs->cs, (unsigned int __user *)&sc->cs);
 367         err |= __put_user(regs->flags, &sc->flags);
 368         err |= __put_user(regs->sp, &sc->sp_at_signal);
 369         err |= __put_user(regs->ss, (unsigned int __user *)&sc->ss);
 370
 371         err |= __put_user(ptr_to_compat(fpstate), &sc->fpstate);
 372
 373         /* non-iBCS2 extensions.. */
 374         err |= __put_user(mask, &sc->oldmask);
 375         err |= __put_user(current->thread.cr2, &sc->cr2);
 376
 377         return err;
 378 }
 379
 380 /*
 381  * Determine which stack to use..
 382  */
 383 static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
 384                                  size_t frame_size,
 385                                  void **fpstate)
 386 {
 387         unsigned long sp;
 388
 389         /* Default to using normal stack */
 390         sp = regs->sp;
 391
 392         /* This is the X/Open sanctioned signal stack switching.  */
 393         if (ka->sa.sa_flags & SA_ONSTACK) {
 394                 if (sas_ss_flags(sp) == 0)
 395                         sp = current->sas_ss_sp + current->sas_ss_size;
 396         }
 397
 398         /* This is the legacy signal stack switching. */
 399         else if ((regs->ss & 0xffff) != __USER_DS &&
 400                 !(ka->sa.sa_flags & SA_RESTORER) &&
 401                  ka->sa.sa_restorer)
 402                 sp = (unsigned long) ka->sa.sa_restorer;
 403
 404         if (used_math()) {
 405                 sp = sp - sig_xstate_ia32_size;
 406                 *fpstate = (struct _fpstate_ia32 *) sp;
 407                 if (save_i387_xstate_ia32(*fpstate) < 0)
 408                         return (void __user *) -1L;
 409         }
 410
 411         sp -= frame_size;
 412         /* Align the stack pointer according to the i386 ABI,
 413          * i.e. so that on function entry ((sp + 4) & 15) == 0. */
 414         sp = ((sp + 4) & -16ul) - 4;
 415         return (void __user *) sp;
 416 }
 417
 418 int ia32_setup_frame(int sig, struct k_sigaction *ka,
 419                      compat_sigset_t *set, struct pt_regs *regs)
 420 {
 421         struct sigframe __user *frame;
 422         void __user *restorer;
 423         int err = 0;
 424         void __user *fpstate = NULL;
 425
 426         /* copy_to_user optimizes that into a single 8 byte store */
 427         static const struct {
 428                 u16 poplmovl;
 429                 u32 val;
 430                 u16 int80;
 431         } __attribute__((packed)) code = {
 432                 0xb858,          /* popl %eax ; movl $...,%eax */
 433                 __NR_ia32_sigreturn,
 434                 0x80cd,         /* int $0x80 */
 435         };
 436
 437         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 438
 439         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 440                 return -EFAULT;
 441
 442         if (__put_user(sig, &frame->sig))
 443                 return -EFAULT;
 444
 445         if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
 446                 return -EFAULT;
 447
 448         if (_COMPAT_NSIG_WORDS > 1) {
 449                 if (__copy_to_user(frame->extramask, &set->sig[1],
 450                                    sizeof(frame->extramask)))
 451                         return -EFAULT;
 452         }
 453
 454         if (ka->sa.sa_flags & SA_RESTORER) {
 455                 restorer = ka->sa.sa_restorer;
 456         } else {
 457                 /* Return stub is in 32bit vsyscall page */
 458                 if (current->mm->context.vdso)
 459                         restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 460                                                  sigreturn);
 461                 else
 462                         restorer = &frame->retcode;
 463         }
 464         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 465
 466         /*
 467          * These are actually not used anymore, but left because some
 468          * gdb versions depend on them as a marker.
 469          */
 470         err |= __copy_to_user(frame->retcode, &code, 8);
 471         if (err)
 472                 return -EFAULT;
 473
 474         /* Set up registers for signal handler */
 475         regs->sp = (unsigned long) frame;
 476         regs->ip = (unsigned long) ka->sa.sa_handler;
 477
 478         /* Make -mregparm=3 work */
 479         regs->ax = sig;
 480         regs->dx = 0;
 481         regs->cx = 0;
 482
 483         loadsegment(ds, __USER32_DS);
 484         loadsegment(es, __USER32_DS);
 485
 486         regs->cs = __USER32_CS;
 487         regs->ss = __USER32_DS;
 488
 489 #if DEBUG_SIG
 490         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
 491                current->comm, current->pid, frame, regs->ip, frame->pretcode);
 492 #endif
 493
 494         return 0;
 495 }
 496
 497 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 498                         compat_sigset_t *set, struct pt_regs *regs)
 499 {
 500         struct rt_sigframe __user *frame;
 501         void __user *restorer;
 502         int err = 0;
 503         void __user *fpstate = NULL;
 504
 505         /* __copy_to_user optimizes that into a single 8 byte store */
 506         static const struct {
 507                 u8 movl;
 508                 u32 val;
 509                 u16 int80;
 510                 u8  pad;
 511         } __attribute__((packed)) code = {
 512                 0xb8,
 513                 __NR_ia32_rt_sigreturn,
 514                 0x80cd,
 515                 0,
 516         };
 517
 518         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 519
 520         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 521                 return -EFAULT;
 522
 523         err |= __put_user(sig, &frame->sig);
 524         err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
 525         err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
 526         err |= copy_siginfo_to_user32(&frame->info, info);
 527         if (err)
 528                 return -EFAULT;
 529
 530         /* Create the ucontext.  */
 531         if (cpu_has_xsave)
 532                 err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);
 533         else
 534                 err |= __put_user(0, &frame->uc.uc_flags);
 535         err |= __put_user(0, &frame->uc.uc_link);
 536         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 537         err |= __put_user(sas_ss_flags(regs->sp),
 538                           &frame->uc.uc_stack.ss_flags);
 539         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 540         err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
 541                                      regs, set->sig[0]);
 542         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 543         if (err)
 544                 return -EFAULT;
 545
 546         if (ka->sa.sa_flags & SA_RESTORER)
 547                 restorer = ka->sa.sa_restorer;
 548         else
 549                 restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 550                                          rt_sigreturn);
 551         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 552
 553         /*
 554          * Not actually used anymore, but left because some gdb
 555          * versions need it.
 556          */
 557         err |= __copy_to_user(frame->retcode, &code, 8);
 558         if (err)
 559                 return -EFAULT;
 560
 561         /* Set up registers for signal handler */
 562         regs->sp = (unsigned long) frame;
 563         regs->ip = (unsigned long) ka->sa.sa_handler;
 564
 565         /* Make -mregparm=3 work */
 566         regs->ax = sig;
 567         regs->dx = (unsigned long) &frame->info;
 568         regs->cx = (unsigned long) &frame->uc;
 569
 570         /* Make -mregparm=3 work */
 571         regs->ax = sig;
 572         regs->dx = (unsigned long) &frame->info;
 573         regs->cx = (unsigned long) &frame->uc;
 574
 575         loadsegment(ds, __USER32_DS);
 576         loadsegment(es, __USER32_DS);
 577
 578         regs->cs = __USER32_CS;
 579         regs->ss = __USER32_DS;
 580
 581 #if DEBUG_SIG
 582         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
 583                current->comm, current->pid, frame, regs->ip, frame->pretcode);
 584 #endif
 585
 586         return 0;
 587 }