SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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/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
  44 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
  45 void signal_fault(struct pt_regs *regs, void __user *frame, char *where);
  46
  47 int 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
 105 int 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
 125 asmlinkage 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
 140 asmlinkage 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
 177 struct 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
 188 struct 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         err |= __get_user(regs->x, &sc->x);     \
 202 }
 203
 204 #define COPY_SEG_CPL3(seg)      {                       \
 205                 unsigned short tmp;                     \
 206                 err |= __get_user(tmp, &sc->seg);       \
 207                 regs->seg = tmp | 3;                    \
 208 }
 209
 210 #define RELOAD_SEG(seg)         {               \
 211         unsigned int cur, pre;                  \
 212         err |= __get_user(pre, &sc->seg);       \
 213         savesegment(seg, cur);                  \
 214         pre |= 3;                               \
 215         if (pre != cur)                         \
 216                 loadsegment(seg, pre);          \
 217 }
 218
 219 static int ia32_restore_sigcontext(struct pt_regs *regs,
 220                                    struct sigcontext_ia32 __user *sc,
 221                                    unsigned int *peax)
 222 {
 223         unsigned int tmpflags, gs, oldgs, err = 0;
 224         void __user *buf;
 225         u32 tmp;
 226
 227         /* Always make any pending restarted system calls return -EINTR */
 228         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 229
 230 #if DEBUG_SIG
 231         printk(KERN_DEBUG "SIG restore_sigcontext: "
 232                "sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
 233                sc, sc->err, sc->ip, sc->cs, sc->flags);
 234 #endif
 235
 236         /*
 237          * Reload fs and gs if they have changed in the signal
 238          * handler.  This does not handle long fs/gs base changes in
 239          * the handler, but does not clobber them at least in the
 240          * normal case.
 241          */
 242         err |= __get_user(gs, &sc->gs);
 243         gs |= 3;
 244         savesegment(gs, oldgs);
 245         if (gs != oldgs)
 246                 load_gs_index(gs);
 247
 248         RELOAD_SEG(fs);
 249         RELOAD_SEG(ds);
 250         RELOAD_SEG(es);
 251
 252         COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
 253         COPY(dx); COPY(cx); COPY(ip);
 254         /* Don't touch extended registers */
 255
 256         COPY_SEG_CPL3(cs);
 257         COPY_SEG_CPL3(ss);
 258
 259         err |= __get_user(tmpflags, &sc->flags);
 260         regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
 261         /* disable syscall checks */
 262         regs->orig_ax = -1;
 263
 264         err |= __get_user(tmp, &sc->fpstate);
 265         buf = compat_ptr(tmp);
 266         err |= restore_i387_xstate_ia32(buf);
 267
 268         err |= __get_user(tmp, &sc->ax);
 269         *peax = tmp;
 270
 271         return err;
 272 }
 273
 274 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
 275 {
 276         struct sigframe __user *frame = (struct sigframe __user *)(regs->sp-8);
 277         sigset_t set;
 278         unsigned int ax;
 279
 280         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 281                 goto badframe;
 282         if (__get_user(set.sig[0], &frame->sc.oldmask)
 283             || (_COMPAT_NSIG_WORDS > 1
 284                 && __copy_from_user((((char *) &set.sig) + 4),
 285                                     &frame->extramask,
 286                                     sizeof(frame->extramask))))
 287                 goto badframe;
 288
 289         sigdelsetmask(&set, ~_BLOCKABLE);
 290         spin_lock_irq(&current->sighand->siglock);
 291         current->blocked = set;
 292         recalc_sigpending();
 293         spin_unlock_irq(&current->sighand->siglock);
 294
 295         if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
 296                 goto badframe;
 297         return ax;
 298
 299 badframe:
 300         signal_fault(regs, frame, "32bit sigreturn");
 301         return 0;
 302 }
 303
 304 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
 305 {
 306         struct rt_sigframe __user *frame;
 307         sigset_t set;
 308         unsigned int ax;
 309         struct pt_regs tregs;
 310
 311         frame = (struct rt_sigframe __user *)(regs->sp - 4);
 312
 313         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 314                 goto badframe;
 315         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 316                 goto badframe;
 317
 318         sigdelsetmask(&set, ~_BLOCKABLE);
 319         spin_lock_irq(&current->sighand->siglock);
 320         current->blocked = set;
 321         recalc_sigpending();
 322         spin_unlock_irq(&current->sighand->siglock);
 323
 324         if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
 325                 goto badframe;
 326
 327         tregs = *regs;
 328         if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
 329                 goto badframe;
 330
 331         return ax;
 332
 333 badframe:
 334         signal_fault(regs, frame, "32bit rt sigreturn");
 335         return 0;
 336 }
 337
 338 /*
 339  * Set up a signal frame.
 340  */
 341
 342 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
 343                                  void __user *fpstate,
 344                                  struct pt_regs *regs, unsigned int mask)
 345 {
 346         int tmp, err = 0;
 347
 348         savesegment(gs, tmp);
 349         err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
 350         savesegment(fs, tmp);
 351         err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
 352         savesegment(ds, tmp);
 353         err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
 354         savesegment(es, tmp);
 355         err |= __put_user(tmp, (unsigned int __user *)&sc->es);
 356
 357         err |= __put_user(regs->di, &sc->di);
 358         err |= __put_user(regs->si, &sc->si);
 359         err |= __put_user(regs->bp, &sc->bp);
 360         err |= __put_user(regs->sp, &sc->sp);
 361         err |= __put_user(regs->bx, &sc->bx);
 362         err |= __put_user(regs->dx, &sc->dx);
 363         err |= __put_user(regs->cx, &sc->cx);
 364         err |= __put_user(regs->ax, &sc->ax);
 365         err |= __put_user(regs->cs, &sc->cs);
 366         err |= __put_user(regs->ss, &sc->ss);
 367         err |= __put_user(current->thread.trap_no, &sc->trapno);
 368         err |= __put_user(current->thread.error_code, &sc->err);
 369         err |= __put_user(regs->ip, &sc->ip);
 370         err |= __put_user(regs->flags, &sc->flags);
 371         err |= __put_user(regs->sp, &sc->sp_at_signal);
 372
 373         err |= __put_user(ptr_to_compat(fpstate), &sc->fpstate);
 374
 375         /* non-iBCS2 extensions.. */
 376         err |= __put_user(mask, &sc->oldmask);
 377         err |= __put_user(current->thread.cr2, &sc->cr2);
 378
 379         return err;
 380 }
 381
 382 /*
 383  * Determine which stack to use..
 384  */
 385 static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
 386                                  size_t frame_size,
 387                                  void **fpstate)
 388 {
 389         unsigned long sp;
 390
 391         /* Default to using normal stack */
 392         sp = regs->sp;
 393
 394         /* This is the X/Open sanctioned signal stack switching.  */
 395         if (ka->sa.sa_flags & SA_ONSTACK) {
 396                 if (sas_ss_flags(sp) == 0)
 397                         sp = current->sas_ss_sp + current->sas_ss_size;
 398         }
 399
 400         /* This is the legacy signal stack switching. */
 401         else if ((regs->ss & 0xffff) != __USER_DS &&
 402                 !(ka->sa.sa_flags & SA_RESTORER) &&
 403                  ka->sa.sa_restorer)
 404                 sp = (unsigned long) ka->sa.sa_restorer;
 405
 406         if (used_math()) {
 407                 sp = sp - sig_xstate_ia32_size;
 408                 *fpstate = (struct _fpstate_ia32 *) sp;
 409                 if (save_i387_xstate_ia32(*fpstate) < 0)
 410                         return (void __user *) -1L;
 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
 420 int 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         } __attribute__((packed)) code = {
 434                 0xb858,          /* popl %eax ; movl $...,%eax */
 435                 __NR_ia32_sigreturn,
 436                 0x80cd,         /* int $0x80 */
 437         };
 438
 439         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 440
 441         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 442                 return -EFAULT;
 443
 444         if (__put_user(sig, &frame->sig))
 445                 return -EFAULT;
 446
 447         if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
 448                 return -EFAULT;
 449
 450         if (_COMPAT_NSIG_WORDS > 1) {
 451                 if (__copy_to_user(frame->extramask, &set->sig[1],
 452                                    sizeof(frame->extramask)))
 453                         return -EFAULT;
 454         }
 455
 456         if (ka->sa.sa_flags & SA_RESTORER) {
 457                 restorer = ka->sa.sa_restorer;
 458         } else {
 459                 /* Return stub is in 32bit vsyscall page */
 460                 if (current->mm->context.vdso)
 461                         restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 462                                                  sigreturn);
 463                 else
 464                         restorer = &frame->retcode;
 465         }
 466         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 467
 468         /*
 469          * These are actually not used anymore, but left because some
 470          * gdb versions depend on them as a marker.
 471          */
 472         err |= __copy_to_user(frame->retcode, &code, 8);
 473         if (err)
 474                 return -EFAULT;
 475
 476         /* Set up registers for signal handler */
 477         regs->sp = (unsigned long) frame;
 478         regs->ip = (unsigned long) ka->sa.sa_handler;
 479
 480         /* Make -mregparm=3 work */
 481         regs->ax = sig;
 482         regs->dx = 0;
 483         regs->cx = 0;
 484
 485         loadsegment(ds, __USER32_DS);
 486         loadsegment(es, __USER32_DS);
 487
 488         regs->cs = __USER32_CS;
 489         regs->ss = __USER32_DS;
 490
 491 #if DEBUG_SIG
 492         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
 493                current->comm, current->pid, frame, regs->ip, frame->pretcode);
 494 #endif
 495
 496         return 0;
 497 }
 498
 499 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 500                         compat_sigset_t *set, struct pt_regs *regs)
 501 {
 502         struct rt_sigframe __user *frame;
 503         void __user *restorer;
 504         int err = 0;
 505         void __user *fpstate = NULL;
 506
 507         /* __copy_to_user optimizes that into a single 8 byte store */
 508         static const struct {
 509                 u8 movl;
 510                 u32 val;
 511                 u16 int80;
 512                 u8  pad;
 513         } __attribute__((packed)) code = {
 514                 0xb8,
 515                 __NR_ia32_rt_sigreturn,
 516                 0x80cd,
 517                 0,
 518         };
 519
 520         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 521
 522         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 523                 return -EFAULT;
 524
 525         err |= __put_user(sig, &frame->sig);
 526         err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
 527         err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
 528         err |= copy_siginfo_to_user32(&frame->info, info);
 529         if (err)
 530                 return -EFAULT;
 531
 532         /* Create the ucontext.  */
 533         if (cpu_has_xsave)
 534                 err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);
 535         else
 536                 err |= __put_user(0, &frame->uc.uc_flags);
 537         err |= __put_user(0, &frame->uc.uc_link);
 538         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 539         err |= __put_user(sas_ss_flags(regs->sp),
 540                           &frame->uc.uc_stack.ss_flags);
 541         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 542         err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
 543                                      regs, set->sig[0]);
 544         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 545         if (err)
 546                 return -EFAULT;
 547
 548         if (ka->sa.sa_flags & SA_RESTORER)
 549                 restorer = ka->sa.sa_restorer;
 550         else
 551                 restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 552                                          rt_sigreturn);
 553         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 554
 555         /*
 556          * Not actually used anymore, but left because some gdb
 557          * versions need it.
 558          */
 559         err |= __copy_to_user(frame->retcode, &code, 8);
 560         if (err)
 561                 return -EFAULT;
 562
 563         /* Set up registers for signal handler */
 564         regs->sp = (unsigned long) frame;
 565         regs->ip = (unsigned long) ka->sa.sa_handler;
 566
 567         /* Make -mregparm=3 work */
 568         regs->ax = sig;
 569         regs->dx = (unsigned long) &frame->info;
 570         regs->cx = (unsigned long) &frame->uc;
 571
 572         /* Make -mregparm=3 work */
 573         regs->ax = sig;
 574         regs->dx = (unsigned long) &frame->info;
 575         regs->cx = (unsigned long) &frame->uc;
 576
 577         loadsegment(ds, __USER32_DS);
 578         loadsegment(es, __USER32_DS);
 579
 580         regs->cs = __USER32_CS;
 581         regs->ss = __USER32_DS;
 582
 583 #if DEBUG_SIG
 584         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
 585                current->comm, current->pid, frame, regs->ip, frame->pretcode);
 586 #endif
 587
 588         return 0;
 589 }