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