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/ptrace.h>
  26 #include <asm/ia32_unistd.h>
  27 #include <asm/user32.h>
  28 #include <asm/sigcontext32.h>
  29 #include <asm/proto.h>
  30 #include <asm/vdso.h>
  31 #include <asm/sigframe.h>
  32 #include <asm/sighandling.h>
  33 #include <asm/sys_ia32.h>
  34
  35 #define FIX_EFLAGS      __FIX_EFLAGS
  36
  37 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
  38 {
  39         int err = 0;
  40
  41         if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
  42                 return -EFAULT;
  43
  44         put_user_try {
  45                 /* If you change siginfo_t structure, please make sure that
  46                    this code is fixed accordingly.
  47                    It should never copy any pad contained in the structure
  48                    to avoid security leaks, but must copy the generic
  49                    3 ints plus the relevant union member.  */
  50                 put_user_ex(from->si_signo, &to->si_signo);
  51                 put_user_ex(from->si_errno, &to->si_errno);
  52                 put_user_ex((short)from->si_code, &to->si_code);
  53
  54                 if (from->si_code < 0) {
  55                         put_user_ex(from->si_pid, &to->si_pid);
  56                         put_user_ex(from->si_uid, &to->si_uid);
  57                         put_user_ex(ptr_to_compat(from->si_ptr), &to->si_ptr);
  58                 } else {
  59                         /*
  60                          * First 32bits of unions are always present:
  61                          * si_pid === si_band === si_tid === si_addr(LS half)
  62                          */
  63                         put_user_ex(from->_sifields._pad[0],
  64                                           &to->_sifields._pad[0]);
  65                         switch (from->si_code >> 16) {
  66                         case __SI_FAULT >> 16:
  67                                 break;
  68                         case __SI_CHLD >> 16:
  69                                 put_user_ex(from->si_utime, &to->si_utime);
  70                                 put_user_ex(from->si_stime, &to->si_stime);
  71                                 put_user_ex(from->si_status, &to->si_status);
  72                                 /* FALL THROUGH */
  73                         default:
  74                         case __SI_KILL >> 16:
  75                                 put_user_ex(from->si_uid, &to->si_uid);
  76                                 break;
  77                         case __SI_POLL >> 16:
  78                                 put_user_ex(from->si_fd, &to->si_fd);
  79                                 break;
  80                         case __SI_TIMER >> 16:
  81                                 put_user_ex(from->si_overrun, &to->si_overrun);
  82                                 put_user_ex(ptr_to_compat(from->si_ptr),
  83                                             &to->si_ptr);
  84                                 break;
  85                                  /* This is not generated by the kernel as of now.  */
  86                         case __SI_RT >> 16:
  87                         case __SI_MESGQ >> 16:
  88                                 put_user_ex(from->si_uid, &to->si_uid);
  89                                 put_user_ex(from->si_int, &to->si_int);
  90                                 break;
  91                         }
  92                 }
  93         } put_user_catch(err);
  94
  95         return err;
  96 }
  97
  98 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
  99 {
 100         int err = 0;
 101         u32 ptr32;
 102
 103         if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))
 104                 return -EFAULT;
 105
 106         get_user_try {
 107                 get_user_ex(to->si_signo, &from->si_signo);
 108                 get_user_ex(to->si_errno, &from->si_errno);
 109                 get_user_ex(to->si_code, &from->si_code);
 110
 111                 get_user_ex(to->si_pid, &from->si_pid);
 112                 get_user_ex(to->si_uid, &from->si_uid);
 113                 get_user_ex(ptr32, &from->si_ptr);
 114                 to->si_ptr = compat_ptr(ptr32);
 115         } get_user_catch(err);
 116
 117         return err;
 118 }
 119
 120 asmlinkage long sys32_sigsuspend(int history0, int history1, old_sigset_t mask)
 121 {
 122         sigset_t blocked;
 123
 124         current->saved_sigmask = current->blocked;
 125
 126         mask &= _BLOCKABLE;
 127         siginitset(&blocked, mask);
 128         set_current_blocked(&blocked);
 129
 130         current->state = TASK_INTERRUPTIBLE;
 131         schedule();
 132
 133         set_restore_sigmask();
 134         return -ERESTARTNOHAND;
 135 }
 136
 137 asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr,
 138                                   stack_ia32_t __user *uoss_ptr,
 139                                   struct pt_regs *regs)
 140 {
 141         stack_t uss, uoss;
 142         int ret, err = 0;
 143         mm_segment_t seg;
 144
 145         if (uss_ptr) {
 146                 u32 ptr;
 147
 148                 memset(&uss, 0, sizeof(stack_t));
 149                 if (!access_ok(VERIFY_READ, uss_ptr, sizeof(stack_ia32_t)))
 150                         return -EFAULT;
 151
 152                 get_user_try {
 153                         get_user_ex(ptr, &uss_ptr->ss_sp);
 154                         get_user_ex(uss.ss_flags, &uss_ptr->ss_flags);
 155                         get_user_ex(uss.ss_size, &uss_ptr->ss_size);
 156                 } get_user_catch(err);
 157
 158                 if (err)
 159                         return -EFAULT;
 160                 uss.ss_sp = compat_ptr(ptr);
 161         }
 162         seg = get_fs();
 163         set_fs(KERNEL_DS);
 164         ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs->sp);
 165         set_fs(seg);
 166         if (ret >= 0 && uoss_ptr)  {
 167                 if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(stack_ia32_t)))
 168                         return -EFAULT;
 169
 170                 put_user_try {
 171                         put_user_ex(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp);
 172                         put_user_ex(uoss.ss_flags, &uoss_ptr->ss_flags);
 173                         put_user_ex(uoss.ss_size, &uoss_ptr->ss_size);
 174                 } put_user_catch(err);
 175
 176                 if (err)
 177                         ret = -EFAULT;
 178         }
 179         return ret;
 180 }
 181
 182 /*
 183  * Do a signal return; undo the signal stack.
 184  */
 185 #define loadsegment_gs(v)       load_gs_index(v)
 186 #define loadsegment_fs(v)       loadsegment(fs, v)
 187 #define loadsegment_ds(v)       loadsegment(ds, v)
 188 #define loadsegment_es(v)       loadsegment(es, v)
 189
 190 #define get_user_seg(seg)       ({ unsigned int v; savesegment(seg, v); v; })
 191 #define set_user_seg(seg, v)    loadsegment_##seg(v)
 192
 193 #define COPY(x)                 {               \
 194         get_user_ex(regs->x, &sc->x);           \
 195 }
 196
 197 #define GET_SEG(seg)            ({                      \
 198         unsigned short tmp;                             \
 199         get_user_ex(tmp, &sc->seg);                     \
 200         tmp;                                            \
 201 })
 202
 203 #define COPY_SEG_CPL3(seg)      do {                    \
 204         regs->seg = GET_SEG(seg) | 3;                   \
 205 } while (0)
 206
 207 #define RELOAD_SEG(seg)         {               \
 208         unsigned int pre = GET_SEG(seg);        \
 209         unsigned int cur = get_user_seg(seg);   \
 210         pre |= 3;                               \
 211         if (pre != cur)                         \
 212                 set_user_seg(seg, pre);         \
 213 }
 214
 215 static int ia32_restore_sigcontext(struct pt_regs *regs,
 216                                    struct sigcontext_ia32 __user *sc,
 217                                    unsigned int *pax)
 218 {
 219         unsigned int tmpflags, err = 0;
 220         void __user *buf;
 221         u32 tmp;
 222
 223         /* Always make any pending restarted system calls return -EINTR */
 224         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 225
 226         get_user_try {
 227                 /*
 228                  * Reload fs and gs if they have changed in the signal
 229                  * handler.  This does not handle long fs/gs base changes in
 230                  * the handler, but does not clobber them at least in the
 231                  * normal case.
 232                  */
 233                 RELOAD_SEG(gs);
 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         set_current_blocked(&set);
 277
 278         if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
 279                 goto badframe;
 280         return ax;
 281
 282 badframe:
 283         signal_fault(regs, frame, "32bit sigreturn");
 284         return 0;
 285 }
 286
 287 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
 288 {
 289         struct rt_sigframe_ia32 __user *frame;
 290         sigset_t set;
 291         unsigned int ax;
 292         struct pt_regs tregs;
 293
 294         frame = (struct rt_sigframe_ia32 __user *)(regs->sp - 4);
 295
 296         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 297                 goto badframe;
 298         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 299                 goto badframe;
 300
 301         sigdelsetmask(&set, ~_BLOCKABLE);
 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_no, &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                 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 *)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 }