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 __user *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 __user *uss_ptr,
 140                   stack_ia32_t __user *uoss_ptr,
 141                   struct pt_regs regs)
 142 {
 143         stack_t uss,uoss;
 144         int ret;
 145         mm_segment_t seg;
 146         if (uss_ptr) {
 147                 u32 ptr;
 148                 memset(&uss,0,sizeof(stack_t));
 149         if (!access_ok(VERIFY_READ,uss_ptr,sizeof(stack_ia32_t)) ||
 150                     __get_user(ptr, &uss_ptr->ss_sp) ||
 151                     __get_user(uss.ss_flags, &uss_ptr->ss_flags) ||
 152                     __get_user(uss.ss_size, &uss_ptr->ss_size))
 153                 return -EFAULT;
 154                 uss.ss_sp = (void *)(u64)ptr;
 155         }
 156         seg = get_fs();
 157         set_fs(KERNEL_DS);
 158         ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs.rsp);
 159         set_fs(seg);
 160         if (ret >= 0 && uoss_ptr)  {
 161                 if (!access_ok(VERIFY_WRITE,uoss_ptr,sizeof(stack_ia32_t)) ||
 162                     __put_user((u32)(u64)uoss.ss_sp, &uoss_ptr->ss_sp) ||
 163                     __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
 164                     __put_user(uoss.ss_size, &uoss_ptr->ss_size))
 165                         ret = -EFAULT;
 166         }
 167         return ret;
 168 }
 169
 170 /*
 171  * Do a signal return; undo the signal stack.
 172  */
 173
 174 struct sigframe
 175 {
 176         u32 pretcode;
 177         int sig;
 178         struct sigcontext_ia32 sc;
 179         struct _fpstate_ia32 fpstate;
 180         unsigned int extramask[_COMPAT_NSIG_WORDS-1];
 181         char retcode[8];
 182 };
 183
 184 struct rt_sigframe
 185 {
 186         u32 pretcode;
 187         int sig;
 188         u32 pinfo;
 189         u32 puc;
 190         struct siginfo32 info;
 191         struct ucontext_ia32 uc;
 192         struct _fpstate_ia32 fpstate;
 193         char retcode[8];
 194 };
 195
 196 static int
 197 ia32_restore_sigcontext(struct pt_regs *regs, struct sigcontext_ia32 __user *sc, unsigned int *peax)
 198 {
 199         unsigned int err = 0;
 200
 201         /* Always make any pending restarted system calls return -EINTR */
 202         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 203
 204 #if DEBUG_SIG
 205         printk("SIG restore_sigcontext: sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
 206                 sc, sc->err, sc->eip, sc->cs, sc->eflags);
 207 #endif
 208 #define COPY(x)         { \
 209         unsigned int reg;       \
 210         err |= __get_user(reg, &sc->e ##x);     \
 211         regs->r ## x = reg;                     \
 212 }
 213
 214 #define RELOAD_SEG(seg,mask)                                            \
 215         { unsigned int cur;                             \
 216           unsigned short pre;                           \
 217           err |= __get_user(pre, &sc->seg);                             \
 218           asm volatile("movl %%" #seg ",%0" : "=r" (cur));              \
 219           pre |= mask;                                                  \
 220           if (pre != cur) loadsegment(seg,pre); }
 221
 222         /* Reload fs and gs if they have changed in the signal handler.
 223            This does not handle long fs/gs base changes in the handler, but
 224            does not clobber them at least in the normal case. */
 225
 226         {
 227                 unsigned gs, oldgs;
 228                 err |= __get_user(gs, &sc->gs);
 229                 gs |= 3;
 230                 asm("movl %%gs,%0" : "=r" (oldgs));
 231                 if (gs != oldgs)
 232                 load_gs_index(gs);
 233         }
 234         RELOAD_SEG(fs,3);
 235         RELOAD_SEG(ds,3);
 236         RELOAD_SEG(es,3);
 237
 238         COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
 239         COPY(dx); COPY(cx); COPY(ip);
 240         /* Don't touch extended registers */
 241
 242         err |= __get_user(regs->cs, &sc->cs);
 243         regs->cs |= 3;
 244         err |= __get_user(regs->ss, &sc->ss);
 245         regs->ss |= 3;
 246
 247         {
 248                 unsigned int tmpflags;
 249                 err |= __get_user(tmpflags, &sc->eflags);
 250                 regs->eflags = (regs->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
 251                 regs->orig_rax = -1;            /* disable syscall checks */
 252         }
 253
 254         {
 255                 u32 tmp;
 256                 struct _fpstate_ia32 __user * buf;
 257                 err |= __get_user(tmp, &sc->fpstate);
 258                 buf = compat_ptr(tmp);
 259                 if (buf) {
 260                         if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
 261                                 goto badframe;
 262                         err |= restore_i387_ia32(current, buf, 0);
 263                 }
 264         }
 265
 266         {
 267                 u32 tmp;
 268                 err |= __get_user(tmp, &sc->eax);
 269                 *peax = tmp;
 270         }
 271         return err;
 272
 273 badframe:
 274         return 1;
 275 }
 276
 277 asmlinkage long sys32_sigreturn(struct pt_regs regs)
 278 {
 279         struct sigframe __user *frame = (struct sigframe __user *)(regs.rsp-8);
 280         sigset_t set;
 281         unsigned int eax;
 282
 283         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 284                 goto badframe;
 285         if (__get_user(set.sig[0], &frame->sc.oldmask)
 286             || (_COMPAT_NSIG_WORDS > 1
 287                 && __copy_from_user((((char *) &set.sig) + 4), &frame->extramask,
 288                                     sizeof(frame->extramask))))
 289                 goto badframe;
 290
 291         sigdelsetmask(&set, ~_BLOCKABLE);
 292         spin_lock_irq(&current->sighand->siglock);
 293         current->blocked = set;
 294         recalc_sigpending();
 295         spin_unlock_irq(&current->sighand->siglock);
 296
 297         if (ia32_restore_sigcontext(&regs, &frame->sc, &eax))
 298                 goto badframe;
 299         return eax;
 300
 301 badframe:
 302         signal_fault(&regs, frame, "32bit sigreturn");
 303         return 0;
 304 }
 305
 306 asmlinkage long sys32_rt_sigreturn(struct pt_regs regs)
 307 {
 308         struct rt_sigframe __user *frame = (struct rt_sigframe __user *)(regs.rsp - 4);
 309         sigset_t set;
 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 __user *sc, struct _fpstate_ia32 __user *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 __user *)&sc->gs);
 349         __asm__("movl %%fs,%0" : "=r"(tmp): "0"(tmp));
 350         err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
 351         __asm__("movl %%ds,%0" : "=r"(tmp): "0"(tmp));
 352         err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
 353         __asm__("movl %%es,%0" : "=r"(tmp): "0"(tmp));
 354         err |= __put_user(tmp, (unsigned int __user *)&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 __user *
 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 __user *)((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 __user *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 __user *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