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