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