kernel/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 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 |= restore_xstate_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         unsigned long sp;
 312
 313         /* Default to using normal stack */
 314         sp = regs->sp;
 315
 316         /* This is the X/Open sanctioned signal stack switching.  */
 317         if (ksig->ka.sa.sa_flags & SA_ONSTACK)
 318                 sp = sigsp(sp, ksig);
 319         /* This is the legacy signal stack switching. */
 320         else if ((regs->ss & 0xffff) != __USER32_DS &&
 321                 !(ksig->ka.sa.sa_flags & SA_RESTORER) &&
 322                  ksig->ka.sa.sa_restorer)
 323                 sp = (unsigned long) ksig->ka.sa.sa_restorer;
 324
 325         if (used_math()) {
 326                 unsigned long fx_aligned, math_size;
 327
 328                 sp = alloc_mathframe(sp, 1, &fx_aligned, &math_size);
 329                 *fpstate = (struct _fpstate_ia32 __user *) sp;
 330                 if (save_xstate_sig(*fpstate, (void __user *)fx_aligned,
 331                                     math_size) < 0)
 332                         return (void __user *) -1L;
 333         }
 334
 335         sp -= frame_size;
 336         /* Align the stack pointer according to the i386 ABI,
 337          * i.e. so that on function entry ((sp + 4) & 15) == 0. */
 338         sp = ((sp + 4) & -16ul) - 4;
 339         return (void __user *) sp;
 340 }
 341
 342 int ia32_setup_frame(int sig, struct ksignal *ksig,
 343                      compat_sigset_t *set, struct pt_regs *regs)
 344 {
 345         struct sigframe_ia32 __user *frame;
 346         void __user *restorer;
 347         int err = 0;
 348         void __user *fpstate = NULL;
 349
 350         /* copy_to_user optimizes that into a single 8 byte store */
 351         static const struct {
 352                 u16 poplmovl;
 353                 u32 val;
 354                 u16 int80;
 355         } __attribute__((packed)) code = {
 356                 0xb858,          /* popl %eax ; movl $...,%eax */
 357                 __NR_ia32_sigreturn,
 358                 0x80cd,         /* int $0x80 */
 359         };
 360
 361         frame = get_sigframe(ksig, regs, sizeof(*frame), &fpstate);
 362
 363         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 364                 return -EFAULT;
 365
 366         if (__put_user(sig, &frame->sig))
 367                 return -EFAULT;
 368
 369         if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
 370                 return -EFAULT;
 371
 372         if (_COMPAT_NSIG_WORDS > 1) {
 373                 if (__copy_to_user(frame->extramask, &set->sig[1],
 374                                    sizeof(frame->extramask)))
 375                         return -EFAULT;
 376         }
 377
 378         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 379                 restorer = ksig->ka.sa.sa_restorer;
 380         } else {
 381                 /* Return stub is in 32bit vsyscall page */
 382                 if (current->mm->context.vdso)
 383                         restorer = current->mm->context.vdso +
 384                                 selected_vdso32->sym___kernel_sigreturn;
 385                 else
 386                         restorer = &frame->retcode;
 387         }
 388
 389         put_user_try {
 390                 put_user_ex(ptr_to_compat(restorer), &frame->pretcode);
 391
 392                 /*
 393                  * These are actually not used anymore, but left because some
 394                  * gdb versions depend on them as a marker.
 395                  */
 396                 put_user_ex(*((u64 *)&code), (u64 __user *)frame->retcode);
 397         } put_user_catch(err);
 398
 399         if (err)
 400                 return -EFAULT;
 401
 402         /* Set up registers for signal handler */
 403         regs->sp = (unsigned long) frame;
 404         regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
 405
 406         /* Make -mregparm=3 work */
 407         regs->ax = sig;
 408         regs->dx = 0;
 409         regs->cx = 0;
 410
 411         loadsegment(ds, __USER32_DS);
 412         loadsegment(es, __USER32_DS);
 413
 414         regs->cs = __USER32_CS;
 415         regs->ss = __USER32_DS;
 416
 417         return 0;
 418 }
 419
 420 int ia32_setup_rt_frame(int sig, struct ksignal *ksig,
 421                         compat_sigset_t *set, struct pt_regs *regs)
 422 {
 423         struct rt_sigframe_ia32 __user *frame;
 424         void __user *restorer;
 425         int err = 0;
 426         void __user *fpstate = NULL;
 427
 428         /* __copy_to_user optimizes that into a single 8 byte store */
 429         static const struct {
 430                 u8 movl;
 431                 u32 val;
 432                 u16 int80;
 433                 u8  pad;
 434         } __attribute__((packed)) code = {
 435                 0xb8,
 436                 __NR_ia32_rt_sigreturn,
 437                 0x80cd,
 438                 0,
 439         };
 440
 441         frame = get_sigframe(ksig, regs, sizeof(*frame), &fpstate);
 442
 443         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 444                 return -EFAULT;
 445
 446         put_user_try {
 447                 put_user_ex(sig, &frame->sig);
 448                 put_user_ex(ptr_to_compat(&frame->info), &frame->pinfo);
 449                 put_user_ex(ptr_to_compat(&frame->uc), &frame->puc);
 450
 451                 /* Create the ucontext.  */
 452                 if (cpu_has_xsave)
 453                         put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
 454                 else
 455                         put_user_ex(0, &frame->uc.uc_flags);
 456                 put_user_ex(0, &frame->uc.uc_link);
 457                 compat_save_altstack_ex(&frame->uc.uc_stack, regs->sp);
 458
 459                 if (ksig->ka.sa.sa_flags & SA_RESTORER)
 460                         restorer = ksig->ka.sa.sa_restorer;
 461                 else
 462                         restorer = current->mm->context.vdso +
 463                                 selected_vdso32->sym___kernel_rt_sigreturn;
 464                 put_user_ex(ptr_to_compat(restorer), &frame->pretcode);
 465
 466                 /*
 467                  * Not actually used anymore, but left because some gdb
 468                  * versions need it.
 469                  */
 470                 put_user_ex(*((u64 *)&code), (u64 __user *)frame->retcode);
 471         } put_user_catch(err);
 472
 473         err |= copy_siginfo_to_user32(&frame->info, &ksig->info);
 474         err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
 475                                      regs, set->sig[0]);
 476         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 477
 478         if (err)
 479                 return -EFAULT;
 480
 481         /* Set up registers for signal handler */
 482         regs->sp = (unsigned long) frame;
 483         regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
 484
 485         /* Make -mregparm=3 work */
 486         regs->ax = sig;
 487         regs->dx = (unsigned long) &frame->info;
 488         regs->cx = (unsigned long) &frame->uc;
 489
 490         loadsegment(ds, __USER32_DS);
 491         loadsegment(es, __USER32_DS);
 492
 493         regs->cs = __USER32_CS;
 494         regs->ss = __USER32_DS;
 495
 496         return 0;
 497 }