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