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