2 * linux/arch/x86_64/ia32/ia32_signal.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
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
11 #include <linux/sched.h>
13 #include <linux/smp.h>
14 #include <linux/smp_lock.h>
15 #include <linux/kernel.h>
16 #include <linux/signal.h>
17 #include <linux/errno.h>
18 #include <linux/wait.h>
19 #include <linux/ptrace.h>
20 #include <linux/unistd.h>
21 #include <linux/stddef.h>
22 #include <linux/personality.h>
23 #include <linux/compat.h>
24 #include <asm/ucontext.h>
25 #include <asm/uaccess.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/fpu32.h>
33 #include <asm/proto.h>
34 #include <asm/vsyscall32.h>
38 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
40 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
41 void signal_fault(struct pt_regs *regs, void __user *frame, char *where);
43 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
46 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
49 /* If you change siginfo_t structure, please make sure that
50 this code is fixed accordingly.
51 It should never copy any pad contained in the structure
52 to avoid security leaks, but must copy the generic
53 3 ints plus the relevant union member. */
54 err = __put_user(from->si_signo, &to->si_signo);
55 err |= __put_user(from->si_errno, &to->si_errno);
56 err |= __put_user((short)from->si_code, &to->si_code);
58 if (from->si_code < 0) {
59 err |= __put_user(from->si_pid, &to->si_pid);
60 err |= __put_user(from->si_uid, &to->si_uid);
61 err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);
63 /* First 32bits of unions are always present:
64 * si_pid === si_band === si_tid === si_addr(LS half) */
65 err |= __put_user(from->_sifields._pad[0], &to->_sifields._pad[0]);
66 switch (from->si_code >> 16) {
67 case __SI_FAULT >> 16:
70 err |= __put_user(from->si_utime, &to->si_utime);
71 err |= __put_user(from->si_stime, &to->si_stime);
72 err |= __put_user(from->si_status, &to->si_status);
76 err |= __put_user(from->si_uid, &to->si_uid);
79 err |= __put_user(from->si_fd, &to->si_fd);
81 case __SI_TIMER >> 16:
82 err |= __put_user(from->si_overrun, &to->si_overrun);
83 err |= __put_user(ptr_to_compat(from->si_ptr),
86 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
87 case __SI_MESGQ >> 16:
88 err |= __put_user(from->si_uid, &to->si_uid);
89 err |= __put_user(from->si_int, &to->si_int);
96 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
100 if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
103 err = __get_user(to->si_signo, &from->si_signo);
104 err |= __get_user(to->si_errno, &from->si_errno);
105 err |= __get_user(to->si_code, &from->si_code);
107 err |= __get_user(to->si_pid, &from->si_pid);
108 err |= __get_user(to->si_uid, &from->si_uid);
109 err |= __get_user(ptr32, &from->si_ptr);
110 to->si_ptr = compat_ptr(ptr32);
116 sys32_sigsuspend(int history0, int history1, old_sigset_t mask,
117 struct pt_regs *regs)
122 spin_lock_irq(¤t->sighand->siglock);
123 saveset = current->blocked;
124 siginitset(¤t->blocked, mask);
126 spin_unlock_irq(¤t->sighand->siglock);
130 current->state = TASK_INTERRUPTIBLE;
132 if (do_signal(regs, &saveset))
138 sys32_sigaltstack(const stack_ia32_t __user *uss_ptr,
139 stack_ia32_t __user *uoss_ptr,
140 struct pt_regs *regs)
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))
153 uss.ss_sp = compat_ptr(ptr);
157 ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs->rsp);
159 if (ret >= 0 && uoss_ptr) {
160 if (!access_ok(VERIFY_WRITE,uoss_ptr,sizeof(stack_ia32_t)) ||
161 __put_user(ptr_to_compat(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))
170 * Do a signal return; undo the signal stack.
177 struct sigcontext_ia32 sc;
178 struct _fpstate_ia32 fpstate;
179 unsigned int extramask[_COMPAT_NSIG_WORDS-1];
189 compat_siginfo_t info;
190 struct ucontext_ia32 uc;
191 struct _fpstate_ia32 fpstate;
196 ia32_restore_sigcontext(struct pt_regs *regs, struct sigcontext_ia32 __user *sc, unsigned int *peax)
198 unsigned int err = 0;
200 /* Always make any pending restarted system calls return -EINTR */
201 current_thread_info()->restart_block.fn = do_no_restart_syscall;
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);
209 err |= __get_user(reg, &sc->e ##x); \
210 regs->r ## x = reg; \
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)); \
219 if (pre != cur) loadsegment(seg,pre); }
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. */
227 err |= __get_user(gs, &sc->gs);
229 asm("movl %%gs,%0" : "=r" (oldgs));
237 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
238 COPY(dx); COPY(cx); COPY(ip);
239 /* Don't touch extended registers */
241 err |= __get_user(regs->cs, &sc->cs);
243 err |= __get_user(regs->ss, &sc->ss);
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 */
255 struct _fpstate_ia32 __user * buf;
256 err |= __get_user(tmp, &sc->fpstate);
257 buf = compat_ptr(tmp);
259 if (!access_ok(VERIFY_READ, buf, sizeof(*buf)))
261 err |= restore_i387_ia32(current, buf, 0);
263 struct task_struct *me = current;
273 err |= __get_user(tmp, &sc->eax);
282 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
284 struct sigframe __user *frame = (struct sigframe __user *)(regs->rsp-8);
288 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
290 if (__get_user(set.sig[0], &frame->sc.oldmask)
291 || (_COMPAT_NSIG_WORDS > 1
292 && __copy_from_user((((char *) &set.sig) + 4), &frame->extramask,
293 sizeof(frame->extramask))))
296 sigdelsetmask(&set, ~_BLOCKABLE);
297 spin_lock_irq(¤t->sighand->siglock);
298 current->blocked = set;
300 spin_unlock_irq(¤t->sighand->siglock);
302 if (ia32_restore_sigcontext(regs, &frame->sc, &eax))
307 signal_fault(regs, frame, "32bit sigreturn");
311 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
313 struct rt_sigframe __user *frame;
316 struct pt_regs tregs;
318 frame = (struct rt_sigframe __user *)(regs->rsp - 4);
320 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
322 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
325 sigdelsetmask(&set, ~_BLOCKABLE);
326 spin_lock_irq(¤t->sighand->siglock);
327 current->blocked = set;
329 spin_unlock_irq(¤t->sighand->siglock);
331 if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &eax))
335 if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
341 signal_fault(regs,frame,"32bit rt sigreturn");
346 * Set up a signal frame.
350 ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc, struct _fpstate_ia32 __user *fpstate,
351 struct pt_regs *regs, unsigned int mask)
356 __asm__("movl %%gs,%0" : "=r"(tmp): "0"(tmp));
357 err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
358 __asm__("movl %%fs,%0" : "=r"(tmp): "0"(tmp));
359 err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
360 __asm__("movl %%ds,%0" : "=r"(tmp): "0"(tmp));
361 err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
362 __asm__("movl %%es,%0" : "=r"(tmp): "0"(tmp));
363 err |= __put_user(tmp, (unsigned int __user *)&sc->es);
365 err |= __put_user((u32)regs->rdi, &sc->edi);
366 err |= __put_user((u32)regs->rsi, &sc->esi);
367 err |= __put_user((u32)regs->rbp, &sc->ebp);
368 err |= __put_user((u32)regs->rsp, &sc->esp);
369 err |= __put_user((u32)regs->rbx, &sc->ebx);
370 err |= __put_user((u32)regs->rdx, &sc->edx);
371 err |= __put_user((u32)regs->rcx, &sc->ecx);
372 err |= __put_user((u32)regs->rax, &sc->eax);
373 err |= __put_user((u32)regs->cs, &sc->cs);
374 err |= __put_user((u32)regs->ss, &sc->ss);
375 err |= __put_user(current->thread.trap_no, &sc->trapno);
376 err |= __put_user(current->thread.error_code, &sc->err);
377 err |= __put_user((u32)regs->rip, &sc->eip);
378 err |= __put_user((u32)regs->eflags, &sc->eflags);
379 err |= __put_user((u32)regs->rsp, &sc->esp_at_signal);
381 tmp = save_i387_ia32(current, fpstate, regs, 0);
387 err |= __put_user(ptr_to_compat(tmp ? fpstate : NULL),
391 /* non-iBCS2 extensions.. */
392 err |= __put_user(mask, &sc->oldmask);
393 err |= __put_user(current->thread.cr2, &sc->cr2);
399 * Determine which stack to use..
402 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
406 /* Default to using normal stack */
409 /* This is the X/Open sanctioned signal stack switching. */
410 if (ka->sa.sa_flags & SA_ONSTACK) {
411 if (sas_ss_flags(rsp) == 0)
412 rsp = current->sas_ss_sp + current->sas_ss_size;
415 /* This is the legacy signal stack switching. */
416 else if ((regs->ss & 0xffff) != __USER_DS &&
417 !(ka->sa.sa_flags & SA_RESTORER) &&
418 ka->sa.sa_restorer) {
419 rsp = (unsigned long) ka->sa.sa_restorer;
423 /* Align the stack pointer according to the i386 ABI,
424 * i.e. so that on function entry ((sp + 4) & 15) == 0. */
425 rsp = ((rsp + 4) & -16ul) - 4;
426 return (void __user *) rsp;
429 int ia32_setup_frame(int sig, struct k_sigaction *ka,
430 compat_sigset_t *set, struct pt_regs * regs)
432 struct sigframe __user *frame;
435 frame = get_sigframe(ka, regs, sizeof(*frame));
437 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
441 struct exec_domain *ed = current_thread_info()->exec_domain;
442 err |= __put_user((ed
445 ? ed->signal_invmap[sig]
452 err |= ia32_setup_sigcontext(&frame->sc, &frame->fpstate, regs,
457 if (_COMPAT_NSIG_WORDS > 1) {
458 err |= __copy_to_user(frame->extramask, &set->sig[1],
459 sizeof(frame->extramask));
464 /* Return stub is in 32bit vsyscall page */
466 void __user *restorer = VSYSCALL32_SIGRETURN;
467 if (ka->sa.sa_flags & SA_RESTORER)
468 restorer = ka->sa.sa_restorer;
469 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
471 /* These are actually not used anymore, but left because some
472 gdb versions depend on them as a marker. */
474 /* copy_to_user optimizes that into a single 8 byte store */
475 static const struct {
480 } __attribute__((packed)) code = {
481 0xb858, /* popl %eax ; movl $...,%eax */
483 0x80cd, /* int $0x80 */
486 err |= __copy_to_user(frame->retcode, &code, 8);
491 /* Set up registers for signal handler */
492 regs->rsp = (unsigned long) frame;
493 regs->rip = (unsigned long) ka->sa.sa_handler;
495 asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));
496 asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
498 regs->cs = __USER32_CS;
499 regs->ss = __USER32_DS;
502 regs->eflags &= ~TF_MASK;
503 if (test_thread_flag(TIF_SINGLESTEP))
504 ptrace_notify(SIGTRAP);
507 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
508 current->comm, current->pid, frame, regs->rip, frame->pretcode);
514 force_sigsegv(sig, current);
518 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
519 compat_sigset_t *set, struct pt_regs * regs)
521 struct rt_sigframe __user *frame;
524 frame = get_sigframe(ka, regs, sizeof(*frame));
526 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
530 struct exec_domain *ed = current_thread_info()->exec_domain;
531 err |= __put_user((ed
534 ? ed->signal_invmap[sig]
538 err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
539 err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
540 err |= copy_siginfo_to_user32(&frame->info, info);
544 /* Create the ucontext. */
545 err |= __put_user(0, &frame->uc.uc_flags);
546 err |= __put_user(0, &frame->uc.uc_link);
547 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
548 err |= __put_user(sas_ss_flags(regs->rsp),
549 &frame->uc.uc_stack.ss_flags);
550 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
551 err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, &frame->fpstate,
553 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
559 void __user *restorer = VSYSCALL32_RTSIGRETURN;
560 if (ka->sa.sa_flags & SA_RESTORER)
561 restorer = ka->sa.sa_restorer;
562 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
565 /* This is movl $,%eax ; int $0x80 */
566 /* Not actually used anymore, but left because some gdb versions
569 /* __copy_to_user optimizes that into a single 8 byte store */
570 static const struct {
576 } __attribute__((packed)) code = {
578 __NR_ia32_rt_sigreturn,
582 err |= __copy_to_user(frame->retcode, &code, 8);
587 /* Set up registers for signal handler */
588 regs->rsp = (unsigned long) frame;
589 regs->rip = (unsigned long) ka->sa.sa_handler;
591 asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));
592 asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
594 regs->cs = __USER32_CS;
595 regs->ss = __USER32_DS;
598 regs->eflags &= ~TF_MASK;
599 if (test_thread_flag(TIF_SINGLESTEP))
600 ptrace_notify(SIGTRAP);
603 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
604 current->comm, current->pid, frame, regs->rip, frame->pretcode);
610 force_sigsegv(sig, current);