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 = is_ia32_task();
  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                 err |= restore_i387_xstate_ia32(buf);
 254
 255                 get_user_ex(*pax, &sc->ax);
 256         } get_user_catch(err);
 257
 258         return err;
 259 }
 260
 261 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
 262 {
 263         struct sigframe_ia32 __user *frame = (struct sigframe_ia32 __user *)(regs->sp-8);
 264         sigset_t set;
 265         unsigned int ax;
 266
 267         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 268                 goto badframe;
 269         if (__get_user(set.sig[0], &frame->sc.oldmask)
 270             || (_COMPAT_NSIG_WORDS > 1
 271                 && __copy_from_user((((char *) &set.sig) + 4),
 272                                     &frame->extramask,
 273                                     sizeof(frame->extramask))))
 274                 goto badframe;
 275
 276         sigdelsetmask(&set, ~_BLOCKABLE);
 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         sigdelsetmask(&set, ~_BLOCKABLE);
 303         set_current_blocked(&set);
 304
 305         if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
 306                 goto badframe;
 307
 308         tregs = *regs;
 309         if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
 310                 goto badframe;
 311
 312         return ax;
 313
 314 badframe:
 315         signal_fault(regs, frame, "32bit rt sigreturn");
 316         return 0;
 317 }
 318
 319 /*
 320  * Set up a signal frame.
 321  */
 322
 323 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
 324                                  void __user *fpstate,
 325                                  struct pt_regs *regs, unsigned int mask)
 326 {
 327         int err = 0;
 328
 329         put_user_try {
 330                 put_user_ex(get_user_seg(gs), (unsigned int __user *)&sc->gs);
 331                 put_user_ex(get_user_seg(fs), (unsigned int __user *)&sc->fs);
 332                 put_user_ex(get_user_seg(ds), (unsigned int __user *)&sc->ds);
 333                 put_user_ex(get_user_seg(es), (unsigned int __user *)&sc->es);
 334
 335                 put_user_ex(regs->di, &sc->di);
 336                 put_user_ex(regs->si, &sc->si);
 337                 put_user_ex(regs->bp, &sc->bp);
 338                 put_user_ex(regs->sp, &sc->sp);
 339                 put_user_ex(regs->bx, &sc->bx);
 340                 put_user_ex(regs->dx, &sc->dx);
 341                 put_user_ex(regs->cx, &sc->cx);
 342                 put_user_ex(regs->ax, &sc->ax);
 343                 put_user_ex(current->thread.trap_nr, &sc->trapno);
 344                 put_user_ex(current->thread.error_code, &sc->err);
 345                 put_user_ex(regs->ip, &sc->ip);
 346                 put_user_ex(regs->cs, (unsigned int __user *)&sc->cs);
 347                 put_user_ex(regs->flags, &sc->flags);
 348                 put_user_ex(regs->sp, &sc->sp_at_signal);
 349                 put_user_ex(regs->ss, (unsigned int __user *)&sc->ss);
 350
 351                 put_user_ex(ptr_to_compat(fpstate), &sc->fpstate);
 352
 353                 /* non-iBCS2 extensions.. */
 354                 put_user_ex(mask, &sc->oldmask);
 355                 put_user_ex(current->thread.cr2, &sc->cr2);
 356         } put_user_catch(err);
 357
 358         return err;
 359 }
 360
 361 /*
 362  * Determine which stack to use..
 363  */
 364 static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
 365                                  size_t frame_size,
 366                                  void **fpstate)
 367 {
 368         unsigned long sp;
 369
 370         /* Default to using normal stack */
 371         sp = regs->sp;
 372
 373         /* This is the X/Open sanctioned signal stack switching.  */
 374         if (ka->sa.sa_flags & SA_ONSTACK) {
 375                 if (sas_ss_flags(sp) == 0)
 376                         sp = current->sas_ss_sp + current->sas_ss_size;
 377         }
 378
 379         /* This is the legacy signal stack switching. */
 380         else if ((regs->ss & 0xffff) != __USER32_DS &&
 381                 !(ka->sa.sa_flags & SA_RESTORER) &&
 382                  ka->sa.sa_restorer)
 383                 sp = (unsigned long) ka->sa.sa_restorer;
 384
 385         if (used_math()) {
 386                 sp = sp - sig_xstate_ia32_size;
 387                 *fpstate = (struct _fpstate_ia32 *) sp;
 388                 if (save_i387_xstate_ia32(*fpstate) < 0)
 389                         return (void __user *) -1L;
 390         }
 391
 392         sp -= frame_size;
 393         /* Align the stack pointer according to the i386 ABI,
 394          * i.e. so that on function entry ((sp + 4) & 15) == 0. */
 395         sp = ((sp + 4) & -16ul) - 4;
 396         return (void __user *) sp;
 397 }
 398
 399 int ia32_setup_frame(int sig, struct k_sigaction *ka,
 400                      compat_sigset_t *set, struct pt_regs *regs)
 401 {
 402         struct sigframe_ia32 __user *frame;
 403         void __user *restorer;
 404         int err = 0;
 405         void __user *fpstate = NULL;
 406
 407         /* copy_to_user optimizes that into a single 8 byte store */
 408         static const struct {
 409                 u16 poplmovl;
 410                 u32 val;
 411                 u16 int80;
 412         } __attribute__((packed)) code = {
 413                 0xb858,          /* popl %eax ; movl $...,%eax */
 414                 __NR_ia32_sigreturn,
 415                 0x80cd,         /* int $0x80 */
 416         };
 417
 418         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 419
 420         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 421                 return -EFAULT;
 422
 423         if (__put_user(sig, &frame->sig))
 424                 return -EFAULT;
 425
 426         if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
 427                 return -EFAULT;
 428
 429         if (_COMPAT_NSIG_WORDS > 1) {
 430                 if (__copy_to_user(frame->extramask, &set->sig[1],
 431                                    sizeof(frame->extramask)))
 432                         return -EFAULT;
 433         }
 434
 435         if (ka->sa.sa_flags & SA_RESTORER) {
 436                 restorer = ka->sa.sa_restorer;
 437         } else {
 438                 /* Return stub is in 32bit vsyscall page */
 439                 if (current->mm->context.vdso)
 440                         restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 441                                                  sigreturn);
 442                 else
 443                         restorer = &frame->retcode;
 444         }
 445
 446         put_user_try {
 447                 put_user_ex(ptr_to_compat(restorer), &frame->pretcode);
 448
 449                 /*
 450                  * These are actually not used anymore, but left because some
 451                  * gdb versions depend on them as a marker.
 452                  */
 453                 put_user_ex(*((u64 *)&code), (u64 *)frame->retcode);
 454         } put_user_catch(err);
 455
 456         if (err)
 457                 return -EFAULT;
 458
 459         /* Set up registers for signal handler */
 460         regs->sp = (unsigned long) frame;
 461         regs->ip = (unsigned long) ka->sa.sa_handler;
 462
 463         /* Make -mregparm=3 work */
 464         regs->ax = sig;
 465         regs->dx = 0;
 466         regs->cx = 0;
 467
 468         loadsegment(ds, __USER32_DS);
 469         loadsegment(es, __USER32_DS);
 470
 471         regs->cs = __USER32_CS;
 472         regs->ss = __USER32_DS;
 473
 474         return 0;
 475 }
 476
 477 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 478                         compat_sigset_t *set, struct pt_regs *regs)
 479 {
 480         struct rt_sigframe_ia32 __user *frame;
 481         void __user *restorer;
 482         int err = 0;
 483         void __user *fpstate = NULL;
 484
 485         /* __copy_to_user optimizes that into a single 8 byte store */
 486         static const struct {
 487                 u8 movl;
 488                 u32 val;
 489                 u16 int80;
 490                 u8  pad;
 491         } __attribute__((packed)) code = {
 492                 0xb8,
 493                 __NR_ia32_rt_sigreturn,
 494                 0x80cd,
 495                 0,
 496         };
 497
 498         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 499
 500         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 501                 return -EFAULT;
 502
 503         put_user_try {
 504                 put_user_ex(sig, &frame->sig);
 505                 put_user_ex(ptr_to_compat(&frame->info), &frame->pinfo);
 506                 put_user_ex(ptr_to_compat(&frame->uc), &frame->puc);
 507                 err |= copy_siginfo_to_user32(&frame->info, info);
 508
 509                 /* Create the ucontext.  */
 510                 if (cpu_has_xsave)
 511                         put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
 512                 else
 513                         put_user_ex(0, &frame->uc.uc_flags);
 514                 put_user_ex(0, &frame->uc.uc_link);
 515                 put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 516                 put_user_ex(sas_ss_flags(regs->sp),
 517                             &frame->uc.uc_stack.ss_flags);
 518                 put_user_ex(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 519                 err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
 520                                              regs, set->sig[0]);
 521                 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 522
 523                 if (ka->sa.sa_flags & SA_RESTORER)
 524                         restorer = ka->sa.sa_restorer;
 525                 else
 526                         restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 527                                                  rt_sigreturn);
 528                 put_user_ex(ptr_to_compat(restorer), &frame->pretcode);
 529
 530                 /*
 531                  * Not actually used anymore, but left because some gdb
 532                  * versions need it.
 533                  */
 534                 put_user_ex(*((u64 *)&code), (u64 *)frame->retcode);
 535         } put_user_catch(err);
 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 }