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 /*
 133  * Do a signal return; undo the signal stack.
 134  */
 135 #define loadsegment_gs(v)       load_gs_index(v)
 136 #define loadsegment_fs(v)       loadsegment(fs, v)
 137 #define loadsegment_ds(v)       loadsegment(ds, v)
 138 #define loadsegment_es(v)       loadsegment(es, v)
 139
 140 #define get_user_seg(seg)       ({ unsigned int v; savesegment(seg, v); v; })
 141 #define set_user_seg(seg, v)    loadsegment_##seg(v)
 142
 143 #define COPY(x)                 {               \
 144         get_user_ex(regs->x, &sc->x);           \
 145 }
 146
 147 #define GET_SEG(seg)            ({                      \
 148         unsigned short tmp;                             \
 149         get_user_ex(tmp, &sc->seg);                     \
 150         tmp;                                            \
 151 })
 152
 153 #define COPY_SEG_CPL3(seg)      do {                    \
 154         regs->seg = GET_SEG(seg) | 3;                   \
 155 } while (0)
 156
 157 #define RELOAD_SEG(seg)         {               \
 158         unsigned int pre = GET_SEG(seg);        \
 159         unsigned int cur = get_user_seg(seg);   \
 160         pre |= 3;                               \
 161         if (pre != cur)                         \
 162                 set_user_seg(seg, pre);         \
 163 }
 164
 165 static int ia32_restore_sigcontext(struct pt_regs *regs,
 166                                    struct sigcontext_ia32 __user *sc,
 167                                    unsigned int *pax)
 168 {
 169         unsigned int tmpflags, err = 0;
 170         void __user *buf;
 171         u32 tmp;
 172
 173         /* Always make any pending restarted system calls return -EINTR */
 174         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 175
 176         get_user_try {
 177                 /*
 178                  * Reload fs and gs if they have changed in the signal
 179                  * handler.  This does not handle long fs/gs base changes in
 180                  * the handler, but does not clobber them at least in the
 181                  * normal case.
 182                  */
 183                 RELOAD_SEG(gs);
 184                 RELOAD_SEG(fs);
 185                 RELOAD_SEG(ds);
 186                 RELOAD_SEG(es);
 187
 188                 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
 189                 COPY(dx); COPY(cx); COPY(ip);
 190                 /* Don't touch extended registers */
 191
 192                 COPY_SEG_CPL3(cs);
 193                 COPY_SEG_CPL3(ss);
 194
 195                 get_user_ex(tmpflags, &sc->flags);
 196                 regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
 197                 /* disable syscall checks */
 198                 regs->orig_ax = -1;
 199
 200                 get_user_ex(tmp, &sc->fpstate);
 201                 buf = compat_ptr(tmp);
 202
 203                 get_user_ex(*pax, &sc->ax);
 204         } get_user_catch(err);
 205
 206         err |= restore_xstate_sig(buf, 1);
 207
 208         return err;
 209 }
 210
 211 asmlinkage long sys32_sigreturn(void)
 212 {
 213         struct pt_regs *regs = current_pt_regs();
 214         struct sigframe_ia32 __user *frame = (struct sigframe_ia32 __user *)(regs->sp-8);
 215         sigset_t set;
 216         unsigned int ax;
 217
 218         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 219                 goto badframe;
 220         if (__get_user(set.sig[0], &frame->sc.oldmask)
 221             || (_COMPAT_NSIG_WORDS > 1
 222                 && __copy_from_user((((char *) &set.sig) + 4),
 223                                     &frame->extramask,
 224                                     sizeof(frame->extramask))))
 225                 goto badframe;
 226
 227         set_current_blocked(&set);
 228
 229         if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
 230                 goto badframe;
 231         return ax;
 232
 233 badframe:
 234         signal_fault(regs, frame, "32bit sigreturn");
 235         return 0;
 236 }
 237
 238 asmlinkage long sys32_rt_sigreturn(void)
 239 {
 240         struct pt_regs *regs = current_pt_regs();
 241         struct rt_sigframe_ia32 __user *frame;
 242         sigset_t set;
 243         unsigned int ax;
 244
 245         frame = (struct rt_sigframe_ia32 __user *)(regs->sp - 4);
 246
 247         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 248                 goto badframe;
 249         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 250                 goto badframe;
 251
 252         set_current_blocked(&set);
 253
 254         if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
 255                 goto badframe;
 256
 257         if (compat_restore_altstack(&frame->uc.uc_stack))
 258                 goto badframe;
 259
 260         return ax;
 261
 262 badframe:
 263         signal_fault(regs, frame, "32bit rt sigreturn");
 264         return 0;
 265 }
 266
 267 /*
 268  * Set up a signal frame.
 269  */
 270
 271 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
 272                                  void __user *fpstate,
 273                                  struct pt_regs *regs, unsigned int mask)
 274 {
 275         int err = 0;
 276
 277         put_user_try {
 278                 put_user_ex(get_user_seg(gs), (unsigned int __user *)&sc->gs);
 279                 put_user_ex(get_user_seg(fs), (unsigned int __user *)&sc->fs);
 280                 put_user_ex(get_user_seg(ds), (unsigned int __user *)&sc->ds);
 281                 put_user_ex(get_user_seg(es), (unsigned int __user *)&sc->es);
 282
 283                 put_user_ex(regs->di, &sc->di);
 284                 put_user_ex(regs->si, &sc->si);
 285                 put_user_ex(regs->bp, &sc->bp);
 286                 put_user_ex(regs->sp, &sc->sp);
 287                 put_user_ex(regs->bx, &sc->bx);
 288                 put_user_ex(regs->dx, &sc->dx);
 289                 put_user_ex(regs->cx, &sc->cx);
 290                 put_user_ex(regs->ax, &sc->ax);
 291                 put_user_ex(current->thread.trap_nr, &sc->trapno);
 292                 put_user_ex(current->thread.error_code, &sc->err);
 293                 put_user_ex(regs->ip, &sc->ip);
 294                 put_user_ex(regs->cs, (unsigned int __user *)&sc->cs);
 295                 put_user_ex(regs->flags, &sc->flags);
 296                 put_user_ex(regs->sp, &sc->sp_at_signal);
 297                 put_user_ex(regs->ss, (unsigned int __user *)&sc->ss);
 298
 299                 put_user_ex(ptr_to_compat(fpstate), &sc->fpstate);
 300
 301                 /* non-iBCS2 extensions.. */
 302                 put_user_ex(mask, &sc->oldmask);
 303                 put_user_ex(current->thread.cr2, &sc->cr2);
 304         } put_user_catch(err);
 305
 306         return err;
 307 }
 308
 309 /*
 310  * Determine which stack to use..
 311  */
 312 static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs,
 313                                  size_t frame_size,
 314                                  void __user **fpstate)
 315 {
 316         unsigned long sp;
 317
 318         /* Default to using normal stack */
 319         sp = regs->sp;
 320
 321         /* This is the X/Open sanctioned signal stack switching.  */
 322         if (ksig->ka.sa.sa_flags & SA_ONSTACK)
 323                 sp = sigsp(sp, ksig);
 324         /* This is the legacy signal stack switching. */
 325         else if ((regs->ss & 0xffff) != __USER32_DS &&
 326                 !(ksig->ka.sa.sa_flags & SA_RESTORER) &&
 327                  ksig->ka.sa.sa_restorer)
 328                 sp = (unsigned long) ksig->ka.sa.sa_restorer;
 329
 330         if (used_math()) {
 331                 unsigned long fx_aligned, math_size;
 332
 333                 sp = alloc_mathframe(sp, 1, &fx_aligned, &math_size);
 334                 *fpstate = (struct _fpstate_ia32 __user *) sp;
 335                 if (save_xstate_sig(*fpstate, (void __user *)fx_aligned,
 336                                     math_size) < 0)
 337                         return (void __user *) -1L;
 338         }
 339
 340         sp -= frame_size;
 341         /* Align the stack pointer according to the i386 ABI,
 342          * i.e. so that on function entry ((sp + 4) & 15) == 0. */
 343         sp = ((sp + 4) & -16ul) - 4;
 344         return (void __user *) sp;
 345 }
 346
 347 int ia32_setup_frame(int sig, struct ksignal *ksig,
 348                      compat_sigset_t *set, struct pt_regs *regs)
 349 {
 350         struct sigframe_ia32 __user *frame;
 351         void __user *restorer;
 352         int err = 0;
 353         void __user *fpstate = NULL;
 354
 355         /* copy_to_user optimizes that into a single 8 byte store */
 356         static const struct {
 357                 u16 poplmovl;
 358                 u32 val;
 359                 u16 int80;
 360         } __attribute__((packed)) code = {
 361                 0xb858,          /* popl %eax ; movl $...,%eax */
 362                 __NR_ia32_sigreturn,
 363                 0x80cd,         /* int $0x80 */
 364         };
 365
 366         frame = get_sigframe(ksig, regs, sizeof(*frame), &fpstate);
 367
 368         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 369                 return -EFAULT;
 370
 371         if (__put_user(sig, &frame->sig))
 372                 return -EFAULT;
 373
 374         if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
 375                 return -EFAULT;
 376
 377         if (_COMPAT_NSIG_WORDS > 1) {
 378                 if (__copy_to_user(frame->extramask, &set->sig[1],
 379                                    sizeof(frame->extramask)))
 380                         return -EFAULT;
 381         }
 382
 383         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 384                 restorer = ksig->ka.sa.sa_restorer;
 385         } else {
 386                 /* Return stub is in 32bit vsyscall page */
 387                 if (current->mm->context.vdso)
 388                         restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 389                                                  sigreturn);
 390                 else
 391                         restorer = &frame->retcode;
 392         }
 393
 394         put_user_try {
 395                 put_user_ex(ptr_to_compat(restorer), &frame->pretcode);
 396
 397                 /*
 398                  * These are actually not used anymore, but left because some
 399                  * gdb versions depend on them as a marker.
 400                  */
 401                 put_user_ex(*((u64 *)&code), (u64 __user *)frame->retcode);
 402         } put_user_catch(err);
 403
 404         if (err)
 405                 return -EFAULT;
 406
 407         /* Set up registers for signal handler */
 408         regs->sp = (unsigned long) frame;
 409         regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
 410
 411         /* Make -mregparm=3 work */
 412         regs->ax = sig;
 413         regs->dx = 0;
 414         regs->cx = 0;
 415
 416         loadsegment(ds, __USER32_DS);
 417         loadsegment(es, __USER32_DS);
 418
 419         regs->cs = __USER32_CS;
 420         regs->ss = __USER32_DS;
 421
 422         return 0;
 423 }
 424
 425 int ia32_setup_rt_frame(int sig, struct ksignal *ksig,
 426                         compat_sigset_t *set, struct pt_regs *regs)
 427 {
 428         struct rt_sigframe_ia32 __user *frame;
 429         void __user *restorer;
 430         int err = 0;
 431         void __user *fpstate = NULL;
 432
 433         /* __copy_to_user optimizes that into a single 8 byte store */
 434         static const struct {
 435                 u8 movl;
 436                 u32 val;
 437                 u16 int80;
 438                 u8  pad;
 439         } __attribute__((packed)) code = {
 440                 0xb8,
 441                 __NR_ia32_rt_sigreturn,
 442                 0x80cd,
 443                 0,
 444         };
 445
 446         frame = get_sigframe(ksig, regs, sizeof(*frame), &fpstate);
 447
 448         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 449                 return -EFAULT;
 450
 451         put_user_try {
 452                 put_user_ex(sig, &frame->sig);
 453                 put_user_ex(ptr_to_compat(&frame->info), &frame->pinfo);
 454                 put_user_ex(ptr_to_compat(&frame->uc), &frame->puc);
 455
 456                 /* Create the ucontext.  */
 457                 if (cpu_has_xsave)
 458                         put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
 459                 else
 460                         put_user_ex(0, &frame->uc.uc_flags);
 461                 put_user_ex(0, &frame->uc.uc_link);
 462                 compat_save_altstack_ex(&frame->uc.uc_stack, regs->sp);
 463
 464                 if (ksig->ka.sa.sa_flags & SA_RESTORER)
 465                         restorer = ksig->ka.sa.sa_restorer;
 466                 else
 467                         restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 468                                                  rt_sigreturn);
 469                 put_user_ex(ptr_to_compat(restorer), &frame->pretcode);
 470
 471                 /*
 472                  * Not actually used anymore, but left because some gdb
 473                  * versions need it.
 474                  */
 475                 put_user_ex(*((u64 *)&code), (u64 __user *)frame->retcode);
 476         } put_user_catch(err);
 477
 478         err |= copy_siginfo_to_user32(&frame->info, &ksig->info);
 479         err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
 480                                      regs, set->sig[0]);
 481         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 482
 483         if (err)
 484                 return -EFAULT;
 485
 486         /* Set up registers for signal handler */
 487         regs->sp = (unsigned long) frame;
 488         regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
 489
 490         /* Make -mregparm=3 work */
 491         regs->ax = sig;
 492         regs->dx = (unsigned long) &frame->info;
 493         regs->cx = (unsigned long) &frame->uc;
 494
 495         loadsegment(ds, __USER32_DS);
 496         loadsegment(es, __USER32_DS);
 497
 498         regs->cs = __USER32_CS;
 499         regs->ss = __USER32_DS;
 500
 501         return 0;
 502 }