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