LXR linux/arch/x86/ia32/ia32

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