linux/arch/x86/ia32/ia32_signal.c
<<
>>
Prefs
   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/signal.h>
  16#include <linux/errno.h>
  17#include <linux/wait.h>
  18#include <linux/ptrace.h>
  19#include <linux/unistd.h>
  20#include <linux/stddef.h>
  21#include <linux/personality.h>
  22#include <linux/compat.h>
  23#include <linux/binfmts.h>
  24#include <asm/ucontext.h>
  25#include <asm/uaccess.h>
  26#include <asm/i387.h>
  27#include <asm/ia32.h>
  28#include <asm/ptrace.h>
  29#include <asm/ia32_unistd.h>
  30#include <asm/user32.h>
  31#include <asm/sigcontext32.h>
  32#include <asm/proto.h>
  33#include <asm/vdso.h>
  34
  35#define DEBUG_SIG 0
  36
  37#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  38
  39#define FIX_EFLAGS      (X86_EFLAGS_AC | X86_EFLAGS_OF | \
  40                         X86_EFLAGS_DF | X86_EFLAGS_TF | X86_EFLAGS_SF | \
  41                         X86_EFLAGS_ZF | X86_EFLAGS_AF | X86_EFLAGS_PF | \
  42                         X86_EFLAGS_CF)
  43
  44asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
  45void signal_fault(struct pt_regs *regs, void __user *frame, char *where);
  46
  47int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
  48{
  49        int err;
  50
  51        if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
  52                return -EFAULT;
  53
  54        /* If you change siginfo_t structure, please make sure that
  55           this code is fixed accordingly.
  56           It should never copy any pad contained in the structure
  57           to avoid security leaks, but must copy the generic
  58           3 ints plus the relevant union member.  */
  59        err = __put_user(from->si_signo, &to->si_signo);
  60        err |= __put_user(from->si_errno, &to->si_errno);
  61        err |= __put_user((short)from->si_code, &to->si_code);
  62
  63        if (from->si_code < 0) {
  64                err |= __put_user(from->si_pid, &to->si_pid);
  65                err |= __put_user(from->si_uid, &to->si_uid);
  66                err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);
  67        } else {
  68                /*
  69                 * First 32bits of unions are always present:
  70                 * si_pid === si_band === si_tid === si_addr(LS half)
  71                 */
  72                err |= __put_user(from->_sifields._pad[0],
  73                                  &to->_sifields._pad[0]);
  74                switch (from->si_code >> 16) {
  75                case __SI_FAULT >> 16:
  76                        break;
  77                case __SI_CHLD >> 16:
  78                        err |= __put_user(from->si_utime, &to->si_utime);
  79                        err |= __put_user(from->si_stime, &to->si_stime);
  80                        err |= __put_user(from->si_status, &to->si_status);
  81                        /* FALL THROUGH */
  82                default:
  83                case __SI_KILL >> 16:
  84                        err |= __put_user(from->si_uid, &to->si_uid);
  85                        break;
  86                case __SI_POLL >> 16:
  87                        err |= __put_user(from->si_fd, &to->si_fd);
  88                        break;
  89                case __SI_TIMER >> 16:
  90                        err |= __put_user(from->si_overrun, &to->si_overrun);
  91                        err |= __put_user(ptr_to_compat(from->si_ptr),
  92                                          &to->si_ptr);
  93                        break;
  94                         /* This is not generated by the kernel as of now.  */
  95                case __SI_RT >> 16:
  96                case __SI_MESGQ >> 16:
  97                        err |= __put_user(from->si_uid, &to->si_uid);
  98                        err |= __put_user(from->si_int, &to->si_int);
  99                        break;
 100                }
 101        }
 102        return err;
 103}
 104
 105int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 106{
 107        int err;
 108        u32 ptr32;
 109
 110        if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))
 111                return -EFAULT;
 112
 113        err = __get_user(to->si_signo, &from->si_signo);
 114        err |= __get_user(to->si_errno, &from->si_errno);
 115        err |= __get_user(to->si_code, &from->si_code);
 116
 117        err |= __get_user(to->si_pid, &from->si_pid);
 118        err |= __get_user(to->si_uid, &from->si_uid);
 119        err |= __get_user(ptr32, &from->si_ptr);
 120        to->si_ptr = compat_ptr(ptr32);
 121
 122        return err;
 123}
 124
 125asmlinkage long sys32_sigsuspend(int history0, int history1, old_sigset_t mask)
 126{
 127        mask &= _BLOCKABLE;
 128        spin_lock_irq(&current->sighand->siglock);
 129        current->saved_sigmask = current->blocked;
 130        siginitset(&current->blocked, mask);
 131        recalc_sigpending();
 132        spin_unlock_irq(&current->sighand->siglock);
 133
 134        current->state = TASK_INTERRUPTIBLE;
 135        schedule();
 136        set_restore_sigmask();
 137        return -ERESTARTNOHAND;
 138}
 139
 140asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr,
 141                                  stack_ia32_t __user *uoss_ptr,
 142                                  struct pt_regs *regs)
 143{
 144        stack_t uss, uoss;
 145        int ret;
 146        mm_segment_t seg;
 147
 148        if (uss_ptr) {
 149                u32 ptr;
 150
 151                memset(&uss, 0, sizeof(stack_t));
 152                if (!access_ok(VERIFY_READ, uss_ptr, sizeof(stack_ia32_t)) ||
 153                            __get_user(ptr, &uss_ptr->ss_sp) ||
 154                            __get_user(uss.ss_flags, &uss_ptr->ss_flags) ||
 155                            __get_user(uss.ss_size, &uss_ptr->ss_size))
 156                        return -EFAULT;
 157                uss.ss_sp = compat_ptr(ptr);
 158        }
 159        seg = get_fs();
 160        set_fs(KERNEL_DS);
 161        ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs->sp);
 162        set_fs(seg);
 163        if (ret >= 0 && uoss_ptr)  {
 164                if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(stack_ia32_t)) ||
 165                    __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
 166                    __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
 167                    __put_user(uoss.ss_size, &uoss_ptr->ss_size))
 168                        ret = -EFAULT;
 169        }
 170        return ret;
 171}
 172
 173/*
 174 * Do a signal return; undo the signal stack.
 175 */
 176
 177struct sigframe
 178{
 179        u32 pretcode;
 180        int sig;
 181        struct sigcontext_ia32 sc;
 182        struct _fpstate_ia32 fpstate_unused; /* look at kernel/sigframe.h */
 183        unsigned int extramask[_COMPAT_NSIG_WORDS-1];
 184        char retcode[8];
 185        /* fp state follows here */
 186};
 187
 188struct rt_sigframe
 189{
 190        u32 pretcode;
 191        int sig;
 192        u32 pinfo;
 193        u32 puc;
 194        compat_siginfo_t info;
 195        struct ucontext_ia32 uc;
 196        char retcode[8];
 197        /* fp state follows here */
 198};
 199
 200#define COPY(x)         {               \
 201        unsigned int reg;               \
 202        err |= __get_user(reg, &sc->x); \
 203        regs->x = reg;                  \
 204}
 205
 206#define RELOAD_SEG(seg,mask)                                            \
 207        { unsigned int cur;                                             \
 208          unsigned short pre;                                           \
 209          err |= __get_user(pre, &sc->seg);                             \
 210          savesegment(seg, cur);                                        \
 211          pre |= mask;                                                  \
 212          if (pre != cur) loadsegment(seg, pre); }
 213
 214static int ia32_restore_sigcontext(struct pt_regs *regs,
 215                                   struct sigcontext_ia32 __user *sc,
 216                                   unsigned int *peax)
 217{
 218        unsigned int tmpflags, gs, oldgs, err = 0;
 219        void __user *buf;
 220        u32 tmp;
 221
 222        /* Always make any pending restarted system calls return -EINTR */
 223        current_thread_info()->restart_block.fn = do_no_restart_syscall;
 224
 225#if DEBUG_SIG
 226        printk(KERN_DEBUG "SIG restore_sigcontext: "
 227               "sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
 228               sc, sc->err, sc->ip, sc->cs, sc->flags);
 229#endif
 230
 231        /*
 232         * Reload fs and gs if they have changed in the signal
 233         * handler.  This does not handle long fs/gs base changes in
 234         * the handler, but does not clobber them at least in the
 235         * normal case.
 236         */
 237        err |= __get_user(gs, &sc->gs);
 238        gs |= 3;
 239        savesegment(gs, oldgs);
 240        if (gs != oldgs)
 241                load_gs_index(gs);
 242
 243        RELOAD_SEG(fs, 3);
 244        RELOAD_SEG(ds, 3);
 245        RELOAD_SEG(es, 3);
 246
 247        COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
 248        COPY(dx); COPY(cx); COPY(ip);
 249        /* Don't touch extended registers */
 250
 251        err |= __get_user(regs->cs, &sc->cs);
 252        regs->cs |= 3;
 253        err |= __get_user(regs->ss, &sc->ss);
 254        regs->ss |= 3;
 255
 256        err |= __get_user(tmpflags, &sc->flags);
 257        regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
 258        /* disable syscall checks */
 259        regs->orig_ax = -1;
 260
 261        err |= __get_user(tmp, &sc->fpstate);
 262        buf = compat_ptr(tmp);
 263        err |= restore_i387_xstate_ia32(buf);
 264
 265        err |= __get_user(tmp, &sc->ax);
 266        *peax = tmp;
 267
 268        return err;
 269}
 270
 271asmlinkage long sys32_sigreturn(struct pt_regs *regs)
 272{
 273        struct sigframe __user *frame = (struct sigframe __user *)(regs->sp-8);
 274        sigset_t set;
 275        unsigned int ax;
 276
 277        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 278                goto badframe;
 279        if (__get_user(set.sig[0], &frame->sc.oldmask)
 280            || (_COMPAT_NSIG_WORDS > 1
 281                && __copy_from_user((((char *) &set.sig) + 4),
 282                                    &frame->extramask,
 283                                    sizeof(frame->extramask))))
 284                goto badframe;
 285
 286        sigdelsetmask(&set, ~_BLOCKABLE);
 287        spin_lock_irq(&current->sighand->siglock);
 288        current->blocked = set;
 289        recalc_sigpending();
 290        spin_unlock_irq(&current->sighand->siglock);
 291
 292        if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
 293                goto badframe;
 294        return ax;
 295
 296badframe:
 297        signal_fault(regs, frame, "32bit sigreturn");
 298        return 0;
 299}
 300
 301asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
 302{
 303        struct rt_sigframe __user *frame;
 304        sigset_t set;
 305        unsigned int ax;
 306        struct pt_regs tregs;
 307
 308        frame = (struct rt_sigframe __user *)(regs->sp - 4);
 309
 310        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 311                goto badframe;
 312        if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 313                goto badframe;
 314
 315        sigdelsetmask(&set, ~_BLOCKABLE);
 316        spin_lock_irq(&current->sighand->siglock);
 317        current->blocked = set;
 318        recalc_sigpending();
 319        spin_unlock_irq(&current->sighand->siglock);
 320
 321        if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
 322                goto badframe;
 323
 324        tregs = *regs;
 325        if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
 326                goto badframe;
 327
 328        return ax;
 329
 330badframe:
 331        signal_fault(regs, frame, "32bit rt sigreturn");
 332        return 0;
 333}
 334
 335/*
 336 * Set up a signal frame.
 337 */
 338
 339static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
 340                                 void __user *fpstate,
 341                                 struct pt_regs *regs, unsigned int mask)
 342{
 343        int tmp, err = 0;
 344
 345        savesegment(gs, tmp);
 346        err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
 347        savesegment(fs, tmp);
 348        err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
 349        savesegment(ds, tmp);
 350        err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
 351        savesegment(es, tmp);
 352        err |= __put_user(tmp, (unsigned int __user *)&sc->es);
 353
 354        err |= __put_user(regs->di, &sc->di);
 355        err |= __put_user(regs->si, &sc->si);
 356        err |= __put_user(regs->bp, &sc->bp);
 357        err |= __put_user(regs->sp, &sc->sp);
 358        err |= __put_user(regs->bx, &sc->bx);
 359        err |= __put_user(regs->dx, &sc->dx);
 360        err |= __put_user(regs->cx, &sc->cx);
 361        err |= __put_user(regs->ax, &sc->ax);
 362        err |= __put_user(regs->cs, &sc->cs);
 363        err |= __put_user(regs->ss, &sc->ss);
 364        err |= __put_user(current->thread.trap_no, &sc->trapno);
 365        err |= __put_user(current->thread.error_code, &sc->err);
 366        err |= __put_user(regs->ip, &sc->ip);
 367        err |= __put_user(regs->flags, &sc->flags);
 368        err |= __put_user(regs->sp, &sc->sp_at_signal);
 369
 370        tmp = save_i387_xstate_ia32(fpstate);
 371        if (tmp < 0)
 372                err = -EFAULT;
 373        else
 374                err |= __put_user(ptr_to_compat(tmp ? fpstate : NULL),
 375                                        &sc->fpstate);
 376
 377        /* non-iBCS2 extensions.. */
 378        err |= __put_user(mask, &sc->oldmask);
 379        err |= __put_user(current->thread.cr2, &sc->cr2);
 380
 381        return err;
 382}
 383
 384/*
 385 * Determine which stack to use..
 386 */
 387static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
 388                                 size_t frame_size,
 389                                 void **fpstate)
 390{
 391        unsigned long sp;
 392
 393        /* Default to using normal stack */
 394        sp = regs->sp;
 395
 396        /* This is the X/Open sanctioned signal stack switching.  */
 397        if (ka->sa.sa_flags & SA_ONSTACK) {
 398                if (sas_ss_flags(sp) == 0)
 399                        sp = current->sas_ss_sp + current->sas_ss_size;
 400        }
 401
 402        /* This is the legacy signal stack switching. */
 403        else if ((regs->ss & 0xffff) != __USER_DS &&
 404                !(ka->sa.sa_flags & SA_RESTORER) &&
 405                 ka->sa.sa_restorer)
 406                sp = (unsigned long) ka->sa.sa_restorer;
 407
 408        if (used_math()) {
 409                sp = sp - sig_xstate_ia32_size;
 410                *fpstate = (struct _fpstate_ia32 *) sp;
 411        }
 412
 413        sp -= frame_size;
 414        /* Align the stack pointer according to the i386 ABI,
 415         * i.e. so that on function entry ((sp + 4) & 15) == 0. */
 416        sp = ((sp + 4) & -16ul) - 4;
 417        return (void __user *) sp;
 418}
 419
 420int ia32_setup_frame(int sig, struct k_sigaction *ka,
 421                     compat_sigset_t *set, struct pt_regs *regs)
 422{
 423        struct sigframe __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                u16 poplmovl;
 431                u32 val;
 432                u16 int80;
 433                u16 pad;
 434        } __attribute__((packed)) code = {
 435                0xb858,          /* popl %eax ; movl $...,%eax */
 436                __NR_ia32_sigreturn,
 437                0x80cd,         /* int $0x80 */
 438                0,
 439        };
 440
 441        frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 442
 443        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 444                return -EFAULT;
 445
 446        if (__put_user(sig, &frame->sig))
 447                return -EFAULT;
 448
 449        if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
 450                return -EFAULT;
 451
 452        if (_COMPAT_NSIG_WORDS > 1) {
 453                if (__copy_to_user(frame->extramask, &set->sig[1],
 454                                   sizeof(frame->extramask)))
 455                        return -EFAULT;
 456        }
 457
 458        if (ka->sa.sa_flags & SA_RESTORER) {
 459                restorer = ka->sa.sa_restorer;
 460        } else {
 461                /* Return stub is in 32bit vsyscall page */
 462                if (current->mm->context.vdso)
 463                        restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 464                                                 sigreturn);
 465                else
 466                        restorer = &frame->retcode;
 467        }
 468        err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 469
 470        /*
 471         * These are actually not used anymore, but left because some
 472         * gdb versions depend on them as a marker.
 473         */
 474        err |= __copy_to_user(frame->retcode, &code, 8);
 475        if (err)
 476                return -EFAULT;
 477
 478        /* Set up registers for signal handler */
 479        regs->sp = (unsigned long) frame;
 480        regs->ip = (unsigned long) ka->sa.sa_handler;
 481
 482        /* Make -mregparm=3 work */
 483        regs->ax = sig;
 484        regs->dx = 0;
 485        regs->cx = 0;
 486
 487        loadsegment(ds, __USER32_DS);
 488        loadsegment(es, __USER32_DS);
 489
 490        regs->cs = __USER32_CS;
 491        regs->ss = __USER32_DS;
 492
 493#if DEBUG_SIG
 494        printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
 495               current->comm, current->pid, frame, regs->ip, frame->pretcode);
 496#endif
 497
 498        return 0;
 499}
 500
 501int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 502                        compat_sigset_t *set, struct pt_regs *regs)
 503{
 504        struct rt_sigframe __user *frame;
 505        void __user *restorer;
 506        int err = 0;
 507        void __user *fpstate = NULL;
 508
 509        /* __copy_to_user optimizes that into a single 8 byte store */
 510        static const struct {
 511                u8 movl;
 512                u32 val;
 513                u16 int80;
 514                u16 pad;
 515                u8  pad2;
 516        } __attribute__((packed)) code = {
 517                0xb8,
 518                __NR_ia32_rt_sigreturn,
 519                0x80cd,
 520                0,
 521        };
 522
 523        frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 524
 525        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 526                return -EFAULT;
 527
 528        err |= __put_user(sig, &frame->sig);
 529        err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
 530        err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
 531        err |= copy_siginfo_to_user32(&frame->info, info);
 532        if (err)
 533                return -EFAULT;
 534
 535        /* Create the ucontext.  */
 536        if (cpu_has_xsave)
 537                err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);
 538        else
 539                err |= __put_user(0, &frame->uc.uc_flags);
 540        err |= __put_user(0, &frame->uc.uc_link);
 541        err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 542        err |= __put_user(sas_ss_flags(regs->sp),
 543                          &frame->uc.uc_stack.ss_flags);
 544        err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 545        err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
 546                                     regs, set->sig[0]);
 547        err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 548        if (err)
 549                return -EFAULT;
 550
 551        if (ka->sa.sa_flags & SA_RESTORER)
 552                restorer = ka->sa.sa_restorer;
 553        else
 554                restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 555                                         rt_sigreturn);
 556        err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 557
 558        /*
 559         * Not actually used anymore, but left because some gdb
 560         * versions need it.
 561         */
 562        err |= __copy_to_user(frame->retcode, &code, 8);
 563        if (err)
 564                return -EFAULT;
 565
 566        /* Set up registers for signal handler */
 567        regs->sp = (unsigned long) frame;
 568        regs->ip = (unsigned long) ka->sa.sa_handler;
 569
 570        /* Make -mregparm=3 work */
 571        regs->ax = sig;
 572        regs->dx = (unsigned long) &frame->info;
 573        regs->cx = (unsigned long) &frame->uc;
 574
 575        /* Make -mregparm=3 work */
 576        regs->ax = sig;
 577        regs->dx = (unsigned long) &frame->info;
 578        regs->cx = (unsigned long) &frame->uc;
 579
 580        loadsegment(ds, __USER32_DS);
 581        loadsegment(es, __USER32_DS);
 582
 583        regs->cs = __USER32_CS;
 584        regs->ss = __USER32_DS;
 585
 586#if DEBUG_SIG
 587        printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
 588               current->comm, current->pid, frame, regs->ip, frame->pretcode);
 589#endif
 590
 591        return 0;
 592}
 593