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