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