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((stack_t __force __user *) (uss_ptr ? &uss : NULL),
 166                              (stack_t __force __user *) &uoss, regs->sp);
 167         set_fs(seg);
 168         if (ret >= 0 && uoss_ptr)  {
 169                 if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(stack_ia32_t)))
 170                         return -EFAULT;
 171
 172                 put_user_try {
 173                         put_user_ex(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp);
 174                         put_user_ex(uoss.ss_flags, &uoss_ptr->ss_flags);
 175                         put_user_ex(uoss.ss_size, &uoss_ptr->ss_size);
 176                 } put_user_catch(err);
 177
 178                 if (err)
 179                         ret = -EFAULT;
 180         }
 181         return ret;
 182 }
 183
 184 /*
 185  * Do a signal return; undo the signal stack.
 186  */
 187 #define loadsegment_gs(v)       load_gs_index(v)
 188 #define loadsegment_fs(v)       loadsegment(fs, v)
 189 #define loadsegment_ds(v)       loadsegment(ds, v)
 190 #define loadsegment_es(v)       loadsegment(es, v)
 191
 192 #define get_user_seg(seg)       ({ unsigned int v; savesegment(seg, v); v; })
 193 #define set_user_seg(seg, v)    loadsegment_##seg(v)
 194
 195 #define COPY(x)                 {               \
 196         get_user_ex(regs->x, &sc->x);           \
 197 }
 198
 199 #define GET_SEG(seg)            ({                      \
 200         unsigned short tmp;                             \
 201         get_user_ex(tmp, &sc->seg);                     \
 202         tmp;                                            \
 203 })
 204
 205 #define COPY_SEG_CPL3(seg)      do {                    \
 206         regs->seg = GET_SEG(seg) | 3;                   \
 207 } while (0)
 208
 209 #define RELOAD_SEG(seg)         {               \
 210         unsigned int pre = GET_SEG(seg);        \
 211         unsigned int cur = get_user_seg(seg);   \
 212         pre |= 3;                               \
 213         if (pre != cur)                         \
 214                 set_user_seg(seg, pre);         \
 215 }
 216
 217 static int ia32_restore_sigcontext(struct pt_regs *regs,
 218                                    struct sigcontext_ia32 __user *sc,
 219                                    unsigned int *pax)
 220 {
 221         unsigned int tmpflags, err = 0;
 222         void __user *buf;
 223         u32 tmp;
 224
 225         /* Always make any pending restarted system calls return -EINTR */
 226         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 227
 228         get_user_try {
 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                 RELOAD_SEG(gs);
 236                 RELOAD_SEG(fs);
 237                 RELOAD_SEG(ds);
 238                 RELOAD_SEG(es);
 239
 240                 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
 241                 COPY(dx); COPY(cx); COPY(ip);
 242                 /* Don't touch extended registers */
 243
 244                 COPY_SEG_CPL3(cs);
 245                 COPY_SEG_CPL3(ss);
 246
 247                 get_user_ex(tmpflags, &sc->flags);
 248                 regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
 249                 /* disable syscall checks */
 250                 regs->orig_ax = -1;
 251
 252                 get_user_ex(tmp, &sc->fpstate);
 253                 buf = compat_ptr(tmp);
 254                 err |= restore_i387_xstate_ia32(buf);
 255
 256                 get_user_ex(*pax, &sc->ax);
 257         } get_user_catch(err);
 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 __user **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 __user *) 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 __user *)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                 err |= copy_siginfo_to_user32(&frame->info, info);
 507
 508                 /* Create the ucontext.  */
 509                 if (cpu_has_xsave)
 510                         put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
 511                 else
 512                         put_user_ex(0, &frame->uc.uc_flags);
 513                 put_user_ex(0, &frame->uc.uc_link);
 514                 put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 515                 put_user_ex(sas_ss_flags(regs->sp),
 516                             &frame->uc.uc_stack.ss_flags);
 517                 put_user_ex(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 518                 err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
 519                                              regs, set->sig[0]);
 520                 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 521
 522                 if (ka->sa.sa_flags & SA_RESTORER)
 523                         restorer = ka->sa.sa_restorer;
 524                 else
 525                         restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 526                                                  rt_sigreturn);
 527                 put_user_ex(ptr_to_compat(restorer), &frame->pretcode);
 528
 529                 /*
 530                  * Not actually used anymore, but left because some gdb
 531                  * versions need it.
 532                  */
 533                 put_user_ex(*((u64 *)&code), (u64 __user *)frame->retcode);
 534         } put_user_catch(err);
 535
 536         if (err)
 537                 return -EFAULT;
 538
 539         /* Set up registers for signal handler */
 540         regs->sp = (unsigned long) frame;
 541         regs->ip = (unsigned long) ka->sa.sa_handler;
 542
 543         /* Make -mregparm=3 work */
 544         regs->ax = sig;
 545         regs->dx = (unsigned long) &frame->info;
 546         regs->cx = (unsigned long) &frame->uc;
 547
 548         loadsegment(ds, __USER32_DS);
 549         loadsegment(es, __USER32_DS);
 550
 551         regs->cs = __USER32_CS;
 552         regs->ss = __USER32_DS;
 553
 554         return 0;
 555 }