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