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
10 * $Id: ia32_signal.c,v 1.22 2002/07/29 10:34:03 ak Exp $
13 #include <linux/sched.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>
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>
40 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
42 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
43 void signal_fault(struct pt_regs *regs, void __user *frame, char *where);
45 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
48 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
51 /* If you change siginfo_t structure, please make sure that
52 this code is fixed accordingly.
53 It should never copy any pad contained in the structure
54 to avoid security leaks, but must copy the generic
55 3 ints plus the relevant union member. */
56 err = __put_user(from->si_signo, &to->si_signo);
57 err |= __put_user(from->si_errno, &to->si_errno);
58 err |= __put_user((short)from->si_code, &to->si_code);
60 if (from->si_code < 0) {
61 err |= __put_user(from->si_pid, &to->si_pid);
62 err |= __put_user(from->si_uid, &to->si_uid);
63 err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);
65 /* First 32bits of unions are always present:
66 * si_pid === si_band === si_tid === si_addr(LS half) */
67 err |= __put_user(from->_sifields._pad[0], &to->_sifields._pad[0]);
68 switch (from->si_code >> 16) {
69 case __SI_FAULT >> 16:
72 err |= __put_user(from->si_utime, &to->si_utime);
73 err |= __put_user(from->si_stime, &to->si_stime);
74 err |= __put_user(from->si_status, &to->si_status);
77 err |= __put_user(from->si_uid, &to->si_uid);
80 err |= __put_user(from->si_fd, &to->si_fd);
82 case __SI_TIMER >> 16:
83 err |= __put_user(from->si_overrun, &to->si_overrun);
84 err |= __put_user(ptr_to_compat(from->si_ptr), &to->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 (verify_area(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 (verify_area(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 (verify_area(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)
357 __asm__("movl %%gs,%0" : "=r"(tmp): "0"(tmp));
358 err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
359 __asm__("movl %%fs,%0" : "=r"(tmp): "0"(tmp));
360 err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
361 __asm__("movl %%ds,%0" : "=r"(tmp): "0"(tmp));
362 err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
363 __asm__("movl %%es,%0" : "=r"(tmp): "0"(tmp));
364 err |= __put_user(tmp, (unsigned int __user *)&sc->es);
366 err |= __put_user((u32)regs->rdi, &sc->edi);
367 err |= __put_user((u32)regs->rsi, &sc->esi);
368 err |= __put_user((u32)regs->rbp, &sc->ebp);
369 err |= __put_user((u32)regs->rsp, &sc->esp);
370 err |= __put_user((u32)regs->rbx, &sc->ebx);
371 err |= __put_user((u32)regs->rdx, &sc->edx);
372 err |= __put_user((u32)regs->rcx, &sc->ecx);
373 err |= __put_user((u32)regs->rax, &sc->eax);
374 err |= __put_user((u32)regs->cs, &sc->cs);
375 err |= __put_user((u32)regs->ss, &sc->ss);
376 err |= __put_user(current->thread.trap_no, &sc->trapno);
377 err |= __put_user(current->thread.error_code, &sc->err);
378 err |= __put_user((u32)regs->rip, &sc->eip);
379 eflags = regs->eflags;
380 if (current->ptrace & PT_PTRACED) {
383 err |= __put_user((u32)eflags, &sc->eflags);
384 err |= __put_user((u32)regs->rsp, &sc->esp_at_signal);
386 tmp = save_i387_ia32(current, fpstate, regs, 0);
392 err |= __put_user(ptr_to_compat(tmp ? fpstate : NULL), &sc->fpstate);
395 /* non-iBCS2 extensions.. */
396 err |= __put_user(mask, &sc->oldmask);
397 err |= __put_user(current->thread.cr2, &sc->cr2);
403 * Determine which stack to use..
406 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
410 /* Default to using normal stack */
413 /* This is the X/Open sanctioned signal stack switching. */
414 if (ka->sa.sa_flags & SA_ONSTACK) {
415 if (sas_ss_flags(rsp) == 0)
416 rsp = current->sas_ss_sp + current->sas_ss_size;
419 /* This is the legacy signal stack switching. */
420 else if ((regs->ss & 0xffff) != __USER_DS &&
421 !(ka->sa.sa_flags & SA_RESTORER) &&
422 ka->sa.sa_restorer) {
423 rsp = (unsigned long) ka->sa.sa_restorer;
426 return (void __user *)((rsp - frame_size) & -8UL);
429 void 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, set->sig[0]);
456 if (_COMPAT_NSIG_WORDS > 1) {
457 err |= __copy_to_user(frame->extramask, &set->sig[1],
458 sizeof(frame->extramask));
463 /* Return stub is in 32bit vsyscall page */
465 void __user *restorer = VSYSCALL32_SIGRETURN;
466 if (ka->sa.sa_flags & SA_RESTORER)
467 restorer = ka->sa.sa_restorer;
468 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
470 /* These are actually not used anymore, but left because some
471 gdb versions depend on them as a marker. */
473 /* copy_to_user optimizes that into a single 8 byte store */
474 static const struct {
479 } __attribute__((packed)) code = {
480 0xb858, /* popl %eax ; movl $...,%eax */
482 0x80cd, /* int $0x80 */
485 err |= __copy_to_user(frame->retcode, &code, 8);
490 /* Set up registers for signal handler */
491 regs->rsp = (unsigned long) frame;
492 regs->rip = (unsigned long) ka->sa.sa_handler;
494 asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));
495 asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
497 regs->cs = __USER32_CS;
498 regs->ss = __USER32_DS;
501 if (regs->eflags & TF_MASK) {
502 if (current->ptrace & PT_PTRACED) {
503 ptrace_notify(SIGTRAP);
505 regs->eflags &= ~TF_MASK;
510 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
511 current->comm, current->pid, frame, regs->rip, frame->pretcode);
517 force_sigsegv(sig, current);
520 void ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
521 compat_sigset_t *set, struct pt_regs * regs)
523 struct rt_sigframe __user *frame;
526 frame = get_sigframe(ka, regs, sizeof(*frame));
528 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
533 struct exec_domain *ed = current_thread_info()->exec_domain;
534 err |= __put_user((ed
537 ? ed->signal_invmap[sig]
541 err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
542 err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
543 err |= copy_siginfo_to_user32(&frame->info, info);
547 /* Create the ucontext. */
548 err |= __put_user(0, &frame->uc.uc_flags);
549 err |= __put_user(0, &frame->uc.uc_link);
550 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
551 err |= __put_user(sas_ss_flags(regs->rsp),
552 &frame->uc.uc_stack.ss_flags);
553 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
554 err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, &frame->fpstate,
556 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
562 void __user *restorer = VSYSCALL32_RTSIGRETURN;
563 if (ka->sa.sa_flags & SA_RESTORER)
564 restorer = ka->sa.sa_restorer;
565 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
568 /* This is movl $,%eax ; int $0x80 */
569 /* Not actually used anymore, but left because some gdb versions
572 /* __copy_to_user optimizes that into a single 8 byte store */
573 static const struct {
579 } __attribute__((packed)) code = {
581 __NR_ia32_rt_sigreturn,
585 err |= __copy_to_user(frame->retcode, &code, 8);
590 /* Set up registers for signal handler */
591 regs->rsp = (unsigned long) frame;
592 regs->rip = (unsigned long) ka->sa.sa_handler;
594 asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));
595 asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
597 regs->cs = __USER32_CS;
598 regs->ss = __USER32_DS;
601 if (regs->eflags & TF_MASK) {
602 if (current->ptrace & PT_PTRACED) {
603 ptrace_notify(SIGTRAP);
605 regs->eflags &= ~TF_MASK;
610 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
611 current->comm, current->pid, frame, regs->rip, frame->pretcode);
617 force_sigsegv(sig, current);