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         if (!access_ok (VERIFY_READ, from, sizeof(siginfo_t32)))
 102                 return -EFAULT;
 103
 104         err = __get_user(to->si_signo, &from->si_signo);
 105         err |= __get_user(to->si_errno, &from->si_errno);
 106         err |= __get_user(to->si_code, &from->si_code);
 107
 108         err |= __get_user(to->si_pid, &from->si_pid);
 109         err |= __get_user(to->si_uid, &from->si_uid);
 110         err |= __get_user((u32)(u64)to->si_ptr, &from->si_ptr);
 111
 112         return err;
 113 }
 114
 115 asmlinkage long
 116 sys32_sigsuspend(int history0, int history1, old_sigset_t mask, struct pt_regs regs)
 117 {
 118         sigset_t saveset;
 119
 120         mask &= _BLOCKABLE;
 121         spin_lock_irq(&current->sighand->siglock);
 122         saveset = current->blocked;
 123         siginitset(&current->blocked, mask);
 124         recalc_sigpending();
 125         spin_unlock_irq(&current->sighand->siglock);
 126
 127         regs.rax = -EINTR;
 128         while (1) {
 129                 current->state = TASK_INTERRUPTIBLE;
 130                 schedule();
 131                 if (do_signal(&regs, &saveset))
 132                         return -EINTR;
 133         }
 134 }
 135
 136 asmlinkage long
 137 sys32_sigaltstack(const stack_ia32_t *uss_ptr, stack_ia32_t *uoss_ptr,
 138                                   struct pt_regs regs)
 139 {
 140         stack_t uss,uoss;
 141         int ret;
 142         mm_segment_t seg;
 143         if (uss_ptr) {
 144                 u32 ptr;
 145                 memset(&uss,0,sizeof(stack_t));
 146         if (!access_ok(VERIFY_READ,uss_ptr,sizeof(stack_ia32_t)) ||
 147                     __get_user(ptr, &uss_ptr->ss_sp) ||
 148                     __get_user(uss.ss_flags, &uss_ptr->ss_flags) ||
 149                     __get_user(uss.ss_size, &uss_ptr->ss_size))
 150                 return -EFAULT;
 151                 uss.ss_sp = (void *)(u64)ptr;
 152         }
 153         seg = get_fs();
 154         set_fs(KERNEL_DS);
 155         ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs.rsp);
 156         set_fs(seg);
 157         if (ret >= 0 && uoss_ptr)  {
 158                 if (!access_ok(VERIFY_WRITE,uoss_ptr,sizeof(stack_ia32_t)) ||
 159                     __put_user((u32)(u64)uoss.ss_sp, &uoss_ptr->ss_sp) ||
 160                     __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
 161                     __put_user(uoss.ss_size, &uoss_ptr->ss_size))
 162                         ret = -EFAULT;
 163         }
 164         return ret;
 165 }
 166
 167 /*
 168  * Do a signal return; undo the signal stack.
 169  */
 170
 171 struct sigframe
 172 {
 173         u32 pretcode;
 174         int sig;
 175         struct sigcontext_ia32 sc;
 176         struct _fpstate_ia32 fpstate;
 177         unsigned int extramask[_COMPAT_NSIG_WORDS-1];
 178         char retcode[8];
 179 };
 180
 181 struct rt_sigframe
 182 {
 183         u32 pretcode;
 184         int sig;
 185         u32 pinfo;
 186         u32 puc;
 187         struct siginfo32 info;
 188         struct ucontext_ia32 uc;
 189         struct _fpstate_ia32 fpstate;
 190         char retcode[8];
 191 };
 192
 193 static int
 194 ia32_restore_sigcontext(struct pt_regs *regs, struct sigcontext_ia32 *sc, unsigned int *peax)
 195 {
 196         unsigned int err = 0;
 197
 198         /* Always make any pending restarted system calls return -EINTR */
 199         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 200
 201 #if DEBUG_SIG
 202         printk("SIG restore_sigcontext: sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
 203                 sc, sc->err, sc->eip, sc->cs, sc->eflags);
 204 #endif
 205 #define COPY(x)         { \
 206         unsigned int reg;       \
 207         err |= __get_user(reg, &sc->e ##x);     \
 208         regs->r ## x = reg;                     \
 209 }
 210
 211 #define RELOAD_SEG(seg,mask)                                            \
 212         { unsigned int cur;                             \
 213           unsigned short pre;                           \
 214           err |= __get_user(pre, &sc->seg);                             \
 215           asm volatile("movl %%" #seg ",%0" : "=r" (cur));              \
 216           pre |= mask;                                                  \
 217           if (pre != cur) loadsegment(seg,pre); }
 218
 219         /* Reload fs and gs if they have changed in the signal handler.
 220            This does not handle long fs/gs base changes in the handler, but
 221            does not clobber them at least in the normal case. */
 222
 223         {
 224                 unsigned gs, oldgs;
 225                 err |= __get_user(gs, &sc->gs);
 226                 gs |= 3;
 227                 asm("movl %%gs,%0" : "=r" (oldgs));
 228                 if (gs != oldgs)
 229                 load_gs_index(gs);
 230         }
 231         RELOAD_SEG(fs,3);
 232         RELOAD_SEG(ds,3);
 233         RELOAD_SEG(es,3);
 234
 235         COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
 236         COPY(dx); COPY(cx); COPY(ip);
 237         /* Don't touch extended registers */
 238
 239         err |= __get_user(regs->cs, &sc->cs);
 240         regs->cs |= 3;
 241         err |= __get_user(regs->ss, &sc->ss);
 242         regs->ss |= 3;
 243
 244         {
 245                 unsigned int tmpflags;
 246                 err |= __get_user(tmpflags, &sc->eflags);
 247                 regs->eflags = (regs->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
 248                 regs->orig_rax = -1;            /* disable syscall checks */
 249         }
 250
 251         {
 252                 u32 tmp;
 253                 struct _fpstate_ia32 * buf;
 254                 err |= __get_user(tmp, &sc->fpstate);
 255                 buf = (struct _fpstate_ia32 *) (u64)tmp;
 256                 if (buf) {
 257                         if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
 258                                 goto badframe;
 259                         err |= restore_i387_ia32(current, buf, 0);
 260                 }
 261         }
 262
 263         {
 264                 u32 tmp;
 265                 err |= __get_user(tmp, &sc->eax);
 266                 *peax = tmp;
 267         }
 268         return err;
 269
 270 badframe:
 271         return 1;
 272 }
 273
 274 asmlinkage long sys32_sigreturn(struct pt_regs regs)
 275 {
 276         struct sigframe *frame = (struct sigframe *)(regs.rsp - 8);
 277         sigset_t set;
 278         unsigned int eax;
 279
 280         if (verify_area(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), &frame->extramask,
 285                                     sizeof(frame->extramask))))
 286                 goto badframe;
 287
 288         sigdelsetmask(&set, ~_BLOCKABLE);
 289         spin_lock_irq(&current->sighand->siglock);
 290         current->blocked = set;
 291         recalc_sigpending();
 292         spin_unlock_irq(&current->sighand->siglock);
 293
 294         if (ia32_restore_sigcontext(&regs, &frame->sc, &eax))
 295                 goto badframe;
 296         return eax;
 297
 298 badframe:
 299         signal_fault(&regs, frame, "32bit sigreturn");
 300         return 0;
 301 }
 302
 303 asmlinkage long sys32_rt_sigreturn(struct pt_regs regs)
 304 {
 305         struct rt_sigframe *frame = (struct rt_sigframe *)(regs.rsp - 4);
 306         sigset_t set;
 307         stack_t st;
 308         unsigned int eax;
 309
 310         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 311                 goto badframe;
 312         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 313                 goto badframe;
 314
 315         sigdelsetmask(&set, ~_BLOCKABLE);
 316         spin_lock_irq(&current->sighand->siglock);
 317         current->blocked = set;
 318         recalc_sigpending();
 319         spin_unlock_irq(&current->sighand->siglock);
 320
 321         if (ia32_restore_sigcontext(&regs, &frame->uc.uc_mcontext, &eax))
 322                 goto badframe;
 323
 324         if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
 325                 goto badframe;
 326         /* It is more difficult to avoid calling this function than to
 327            call it and ignore errors.  */
 328         {
 329                 mm_segment_t oldds = get_fs();
 330                 set_fs(KERNEL_DS);
 331                 do_sigaltstack(&st, NULL, regs.rsp);
 332                 set_fs(oldds);
 333         }
 334
 335         return eax;
 336
 337 badframe:
 338         signal_fault(&regs,frame,"32bit rt sigreturn");
 339         return 0;
 340 }
 341
 342 /*
 343  * Set up a signal frame.
 344  */
 345
 346 static int
 347 ia32_setup_sigcontext(struct sigcontext_ia32 *sc, struct _fpstate_ia32 *fpstate,
 348                  struct pt_regs *regs, unsigned int mask)
 349 {
 350         int tmp, err = 0;
 351
 352         tmp = 0;
 353         __asm__("movl %%gs,%0" : "=r"(tmp): "0"(tmp));
 354         err |= __put_user(tmp, (unsigned int *)&sc->gs);
 355         __asm__("movl %%fs,%0" : "=r"(tmp): "0"(tmp));
 356         err |= __put_user(tmp, (unsigned int *)&sc->fs);
 357         __asm__("movl %%ds,%0" : "=r"(tmp): "0"(tmp));
 358         err |= __put_user(tmp, (unsigned int *)&sc->ds);
 359         __asm__("movl %%es,%0" : "=r"(tmp): "0"(tmp));
 360         err |= __put_user(tmp, (unsigned int *)&sc->es);
 361
 362         err |= __put_user((u32)regs->rdi, &sc->edi);
 363         err |= __put_user((u32)regs->rsi, &sc->esi);
 364         err |= __put_user((u32)regs->rbp, &sc->ebp);
 365         err |= __put_user((u32)regs->rsp, &sc->esp);
 366         err |= __put_user((u32)regs->rbx, &sc->ebx);
 367         err |= __put_user((u32)regs->rdx, &sc->edx);
 368         err |= __put_user((u32)regs->rcx, &sc->ecx);
 369         err |= __put_user((u32)regs->rax, &sc->eax);
 370         err |= __put_user((u32)regs->cs, &sc->cs);
 371         err |= __put_user((u32)regs->ss, &sc->ss);
 372         err |= __put_user(current->thread.trap_no, &sc->trapno);
 373         err |= __put_user(current->thread.error_code, &sc->err);
 374         err |= __put_user((u32)regs->rip, &sc->eip);
 375         err |= __put_user((u32)regs->eflags, &sc->eflags);
 376         err |= __put_user((u32)regs->rsp, &sc->esp_at_signal);
 377
 378         tmp = save_i387_ia32(current, fpstate, regs, 0);
 379         if (tmp < 0)
 380           err = -EFAULT;
 381         else {
 382                 current->used_math = 0;
 383                 stts();
 384           err |= __put_user((u32)(u64)(tmp ? fpstate : NULL), &sc->fpstate);
 385         }
 386
 387         /* non-iBCS2 extensions.. */
 388         err |= __put_user(mask, &sc->oldmask);
 389         err |= __put_user(current->thread.cr2, &sc->cr2);
 390
 391         return err;
 392 }
 393
 394 /*
 395  * Determine which stack to use..
 396  */
 397 static void *
 398 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
 399 {
 400         unsigned long rsp;
 401
 402         /* Default to using normal stack */
 403         rsp = regs->rsp;
 404
 405         /* This is the X/Open sanctioned signal stack switching.  */
 406         if (ka->sa.sa_flags & SA_ONSTACK) {
 407                 if (sas_ss_flags(rsp) == 0)
 408                         rsp = current->sas_ss_sp + current->sas_ss_size;
 409         }
 410
 411         /* This is the legacy signal stack switching. */
 412         else if ((regs->ss & 0xffff) != __USER_DS &&
 413                 !(ka->sa.sa_flags & SA_RESTORER) &&
 414                  ka->sa.sa_restorer) {
 415                 rsp = (unsigned long) ka->sa.sa_restorer;
 416         }
 417
 418         return (void *)((rsp - frame_size) & -8UL);
 419 }
 420
 421 void ia32_setup_frame(int sig, struct k_sigaction *ka,
 422                         compat_sigset_t *set, struct pt_regs * regs)
 423 {
 424         struct sigframe *frame;
 425         int err = 0;
 426
 427         frame = get_sigframe(ka, regs, sizeof(*frame));
 428
 429         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 430                 goto give_sigsegv;
 431
 432         {
 433                 struct exec_domain *ed = current_thread_info()->exec_domain;
 434         err |= __put_user((ed
 435                            && ed->signal_invmap
 436                            && sig < 32
 437                            ? ed->signal_invmap[sig]
 438                            : sig),
 439                           &frame->sig);
 440         }
 441         if (err)
 442                 goto give_sigsegv;
 443
 444         err |= ia32_setup_sigcontext(&frame->sc, &frame->fpstate, regs, set->sig[0]);
 445         if (err)
 446                 goto give_sigsegv;
 447
 448         if (_COMPAT_NSIG_WORDS > 1) {
 449                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 450                                       sizeof(frame->extramask));
 451         }
 452         if (err)
 453                 goto give_sigsegv;
 454
 455         /* Return stub is in 32bit vsyscall page */
 456         {
 457                 void *restorer = VSYSCALL32_SIGRETURN;
 458                 if (ka->sa.sa_flags & SA_RESTORER)
 459                         restorer = ka->sa.sa_restorer;
 460                 err |= __put_user(ptr_to_u32(restorer), &frame->pretcode);
 461         }
 462         /* These are actually not used anymore, but left because some
 463            gdb versions depend on them as a marker. */
 464         {
 465                 /* copy_to_user optimizes that into a single 8 byte store */
 466                 static const struct {
 467                         u16 poplmovl;
 468                         u32 val;
 469                         u16 int80;
 470                         u16 pad;
 471                 } __attribute__((packed)) code = {
 472                         0xb858,          /* popl %eax ; movl $...,%eax */
 473                         __NR_ia32_sigreturn,
 474                         0x80cd,         /* int $0x80 */
 475                         0,
 476                 };
 477                 err |= __copy_to_user(frame->retcode, &code, 8);
 478         }
 479         if (err)
 480                 goto give_sigsegv;
 481
 482         /* Set up registers for signal handler */
 483         regs->rsp = (unsigned long) frame;
 484         regs->rip = (unsigned long) ka->sa.sa_handler;
 485
 486         asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));
 487         asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
 488
 489         regs->cs = __USER32_CS;
 490         regs->ss = __USER32_DS;
 491
 492         set_fs(USER_DS);
 493         regs->eflags &= ~TF_MASK;
 494
 495 #if DEBUG_SIG
 496         printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
 497                 current->comm, current->pid, frame, regs->rip, frame->pretcode);
 498 #endif
 499
 500         return;
 501
 502 give_sigsegv:
 503         if (sig == SIGSEGV)
 504                 ka->sa.sa_handler = SIG_DFL;
 505         signal_fault(regs,frame,"32bit signal deliver");
 506 }
 507
 508 void ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 509                            compat_sigset_t *set, struct pt_regs * regs)
 510 {
 511         struct rt_sigframe *frame;
 512         int err = 0;
 513
 514         frame = get_sigframe(ka, regs, sizeof(*frame));
 515
 516         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 517                 goto give_sigsegv;
 518
 519
 520         {
 521                 struct exec_domain *ed = current_thread_info()->exec_domain;
 522         err |= __put_user((ed
 523                            && ed->signal_invmap
 524                            && sig < 32
 525                            ? ed->signal_invmap[sig]
 526                            : sig),
 527                           &frame->sig);
 528         }
 529         err |= __put_user((u32)(u64)&frame->info, &frame->pinfo);
 530         err |= __put_user((u32)(u64)&frame->uc, &frame->puc);
 531         err |= ia32_copy_siginfo_to_user(&frame->info, info);
 532         if (err)
 533                 goto give_sigsegv;
 534
 535         /* Create the ucontext.  */
 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->rsp),
 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, &frame->fpstate,
 543                                 regs, set->sig[0]);
 544         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 545         if (err)
 546                 goto give_sigsegv;
 547
 548
 549         {
 550                 void *restorer = VSYSCALL32_RTSIGRETURN;
 551                 if (ka->sa.sa_flags & SA_RESTORER)
 552                         restorer = ka->sa.sa_restorer;
 553                 err |= __put_user(ptr_to_u32(restorer), &frame->pretcode);
 554         }
 555
 556         /* This is movl $,%eax ; int $0x80 */
 557         /* Not actually used anymore, but left because some gdb versions
 558            need it. */
 559         {
 560                 /* __copy_to_user optimizes that into a single 8 byte store */
 561                 static const struct {
 562                         u8 movl;
 563                         u32 val;
 564                         u16 int80;
 565                         u16 pad;
 566                         u8  pad2;
 567                 } __attribute__((packed)) code = {
 568                         0xb8,
 569                         __NR_ia32_rt_sigreturn,
 570                         0x80cd,
 571                         0,
 572                 };
 573                 err |= __copy_to_user(frame->retcode, &code, 8);
 574         }
 575         if (err)
 576                 goto give_sigsegv;
 577
 578         /* Set up registers for signal handler */
 579         regs->rsp = (unsigned long) frame;
 580         regs->rip = (unsigned long) ka->sa.sa_handler;
 581
 582         asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));
 583         asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
 584
 585         regs->cs = __USER32_CS;
 586         regs->ss = __USER32_DS;
 587
 588         set_fs(USER_DS);
 589         regs->eflags &= ~TF_MASK;
 590
 591 #if DEBUG_SIG
 592         printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
 593                 current->comm, current->pid, frame, regs->rip, frame->pretcode);
 594 #endif
 595
 596         return;
 597
 598 give_sigsegv:
 599         if (sig == SIGSEGV)
 600                 ka->sa.sa_handler = SIG_DFL;
 601         signal_fault(regs, frame, "32bit rt signal setup");
 602 }
 603