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(regs->di, &sc->di);
 355         err |= __put_user(regs->si, &sc->si);
 356         err |= __put_user(regs->bp, &sc->bp);
 357         err |= __put_user(regs->sp, &sc->sp);
 358         err |= __put_user(regs->bx, &sc->bx);
 359         err |= __put_user(regs->dx, &sc->dx);
 360         err |= __put_user(regs->cx, &sc->cx);
 361         err |= __put_user(regs->ax, &sc->ax);
 362         err |= __put_user(regs->cs, &sc->cs);
 363         err |= __put_user(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(regs->ip, &sc->ip);
 367         err |= __put_user(regs->flags, &sc->flags);
 368         err |= __put_user(regs->sp, &sc->sp_at_signal);
 369
 370         tmp = save_i387_xstate_ia32(fpstate);
 371         if (tmp < 0)
 372                 err = -EFAULT;
 373         else
 374                 err |= __put_user(ptr_to_compat(tmp ? fpstate : NULL),
 375                                         &sc->fpstate);
 376
 377         /* non-iBCS2 extensions.. */
 378         err |= __put_user(mask, &sc->oldmask);
 379         err |= __put_user(current->thread.cr2, &sc->cr2);
 380
 381         return err;
 382 }
 383
 384 /*
 385  * Determine which stack to use..
 386  */
 387 static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
 388                                  size_t frame_size,
 389                                  void **fpstate)
 390 {
 391         unsigned long sp;
 392
 393         /* Default to using normal stack */
 394         sp = regs->sp;
 395
 396         /* This is the X/Open sanctioned signal stack switching.  */
 397         if (ka->sa.sa_flags & SA_ONSTACK) {
 398                 if (sas_ss_flags(sp) == 0)
 399                         sp = current->sas_ss_sp + current->sas_ss_size;
 400         }
 401
 402         /* This is the legacy signal stack switching. */
 403         else if ((regs->ss & 0xffff) != __USER_DS &&
 404                 !(ka->sa.sa_flags & SA_RESTORER) &&
 405                  ka->sa.sa_restorer)
 406                 sp = (unsigned long) ka->sa.sa_restorer;
 407
 408         if (used_math()) {
 409                 sp = sp - sig_xstate_ia32_size;
 410                 *fpstate = (struct _fpstate_ia32 *) sp;
 411         }
 412
 413         sp -= frame_size;
 414         /* Align the stack pointer according to the i386 ABI,
 415          * i.e. so that on function entry ((sp + 4) & 15) == 0. */
 416         sp = ((sp + 4) & -16ul) - 4;
 417         return (void __user *) sp;
 418 }
 419
 420 int ia32_setup_frame(int sig, struct k_sigaction *ka,
 421                      compat_sigset_t *set, struct pt_regs *regs)
 422 {
 423         struct sigframe __user *frame;
 424         void __user *restorer;
 425         int err = 0;
 426         void __user *fpstate = NULL;
 427
 428         /* copy_to_user optimizes that into a single 8 byte store */
 429         static const struct {
 430                 u16 poplmovl;
 431                 u32 val;
 432                 u16 int80;
 433                 u16 pad;
 434         } __attribute__((packed)) code = {
 435                 0xb858,          /* popl %eax ; movl $...,%eax */
 436                 __NR_ia32_sigreturn,
 437                 0x80cd,         /* int $0x80 */
 438                 0,
 439         };
 440
 441         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 442
 443         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 444                 return -EFAULT;
 445
 446         if (__put_user(sig, &frame->sig))
 447                 return -EFAULT;
 448
 449         if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
 450                 return -EFAULT;
 451
 452         if (_COMPAT_NSIG_WORDS > 1) {
 453                 if (__copy_to_user(frame->extramask, &set->sig[1],
 454                                    sizeof(frame->extramask)))
 455                         return -EFAULT;
 456         }
 457
 458         if (ka->sa.sa_flags & SA_RESTORER) {
 459                 restorer = ka->sa.sa_restorer;
 460         } else {
 461                 /* Return stub is in 32bit vsyscall page */
 462                 if (current->mm->context.vdso)
 463                         restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 464                                                  sigreturn);
 465                 else
 466                         restorer = &frame->retcode;
 467         }
 468         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 469
 470         /*
 471          * These are actually not used anymore, but left because some
 472          * gdb versions depend on them as a marker.
 473          */
 474         err |= __copy_to_user(frame->retcode, &code, 8);
 475         if (err)
 476                 return -EFAULT;
 477
 478         /* Set up registers for signal handler */
 479         regs->sp = (unsigned long) frame;
 480         regs->ip = (unsigned long) ka->sa.sa_handler;
 481
 482         /* Make -mregparm=3 work */
 483         regs->ax = sig;
 484         regs->dx = 0;
 485         regs->cx = 0;
 486
 487         loadsegment(ds, __USER32_DS);
 488         loadsegment(es, __USER32_DS);
 489
 490         regs->cs = __USER32_CS;
 491         regs->ss = __USER32_DS;
 492
 493 #if DEBUG_SIG
 494         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
 495                current->comm, current->pid, frame, regs->ip, frame->pretcode);
 496 #endif
 497
 498         return 0;
 499 }
 500
 501 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 502                         compat_sigset_t *set, struct pt_regs *regs)
 503 {
 504         struct rt_sigframe __user *frame;
 505         void __user *restorer;
 506         int err = 0;
 507         void __user *fpstate = NULL;
 508
 509         /* __copy_to_user optimizes that into a single 8 byte store */
 510         static const struct {
 511                 u8 movl;
 512                 u32 val;
 513                 u16 int80;
 514                 u16 pad;
 515                 u8  pad2;
 516         } __attribute__((packed)) code = {
 517                 0xb8,
 518                 __NR_ia32_rt_sigreturn,
 519                 0x80cd,
 520                 0,
 521         };
 522
 523         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 524
 525         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 526                 return -EFAULT;
 527
 528         err |= __put_user(sig, &frame->sig);
 529         err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
 530         err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
 531         err |= copy_siginfo_to_user32(&frame->info, info);
 532         if (err)
 533                 return -EFAULT;
 534
 535         /* Create the ucontext.  */
 536         if (cpu_has_xsave)
 537                 err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);
 538         else
 539                 err |= __put_user(0, &frame->uc.uc_flags);
 540         err |= __put_user(0, &frame->uc.uc_link);
 541         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 542         err |= __put_user(sas_ss_flags(regs->sp),
 543                           &frame->uc.uc_stack.ss_flags);
 544         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 545         err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
 546                                      regs, set->sig[0]);
 547         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 548         if (err)
 549                 return -EFAULT;
 550
 551         if (ka->sa.sa_flags & SA_RESTORER)
 552                 restorer = ka->sa.sa_restorer;
 553         else
 554                 restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 555                                          rt_sigreturn);
 556         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 557
 558         /*
 559          * Not actually used anymore, but left because some gdb
 560          * versions need it.
 561          */
 562         err |= __copy_to_user(frame->retcode, &code, 8);
 563         if (err)
 564                 return -EFAULT;
 565
 566         /* Set up registers for signal handler */
 567         regs->sp = (unsigned long) frame;
 568         regs->ip = (unsigned long) ka->sa.sa_handler;
 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         /* Make -mregparm=3 work */
 576         regs->ax = sig;
 577         regs->dx = (unsigned long) &frame->info;
 578         regs->cx = (unsigned long) &frame->uc;
 579
 580         loadsegment(ds, __USER32_DS);
 581         loadsegment(es, __USER32_DS);
 582
 583         regs->cs = __USER32_CS;
 584         regs->ss = __USER32_DS;
 585
 586 #if DEBUG_SIG
 587         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
 588                current->comm, current->pid, frame, regs->ip, frame->pretcode);
 589 #endif
 590
 591         return 0;
 592 }