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>
38 #define ptr_to_u32(x) ((u32)(u64)(x)) /* avoid gcc warning */
42 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
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);
47 int ia32_copy_siginfo_to_user(siginfo_t32 __user *to, siginfo_t *from)
50 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t32)))
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);
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);
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:
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);
79 err |= __put_user(from->si_uid, &to->si_uid);
82 err |= __put_user(from->si_fd, &to->si_fd);
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);
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);
98 int ia32_copy_siginfo_from_user(siginfo_t *to, siginfo_t32 __user *from)
102 if (!access_ok (VERIFY_READ, from, sizeof(siginfo_t32)))
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);
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;
118 sys32_sigsuspend(int history0, int history1, old_sigset_t mask, struct pt_regs regs)
123 spin_lock_irq(¤t->sighand->siglock);
124 saveset = current->blocked;
125 siginitset(¤t->blocked, mask);
127 spin_unlock_irq(¤t->sighand->siglock);
131 current->state = TASK_INTERRUPTIBLE;
133 if (do_signal(®s, &saveset))
139 sys32_sigaltstack(const stack_ia32_t __user *uss_ptr,
140 stack_ia32_t __user *uoss_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))
154 uss.ss_sp = (void *)(u64)ptr;
158 ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs.rsp);
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))
171 * Do a signal return; undo the signal stack.
178 struct sigcontext_ia32 sc;
179 struct _fpstate_ia32 fpstate;
180 unsigned int extramask[_COMPAT_NSIG_WORDS-1];
190 struct siginfo32 info;
191 struct ucontext_ia32 uc;
192 struct _fpstate_ia32 fpstate;
197 ia32_restore_sigcontext(struct pt_regs *regs, struct sigcontext_ia32 __user *sc, unsigned int *peax)
199 unsigned int err = 0;
201 /* Always make any pending restarted system calls return -EINTR */
202 current_thread_info()->restart_block.fn = do_no_restart_syscall;
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);
210 err |= __get_user(reg, &sc->e ##x); \
211 regs->r ## x = reg; \
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)); \
220 if (pre != cur) loadsegment(seg,pre); }
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. */
228 err |= __get_user(gs, &sc->gs);
230 asm("movl %%gs,%0" : "=r" (oldgs));
238 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
239 COPY(dx); COPY(cx); COPY(ip);
240 /* Don't touch extended registers */
242 err |= __get_user(regs->cs, &sc->cs);
244 err |= __get_user(regs->ss, &sc->ss);
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 */
256 struct _fpstate_ia32 __user * buf;
257 err |= __get_user(tmp, &sc->fpstate);
258 buf = compat_ptr(tmp);
260 if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
262 err |= restore_i387_ia32(current, buf, 0);
268 err |= __get_user(tmp, &sc->eax);
277 asmlinkage long sys32_sigreturn(struct pt_regs regs)
279 struct sigframe __user *frame = (struct sigframe __user *)(regs.rsp-8);
283 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
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))))
291 sigdelsetmask(&set, ~_BLOCKABLE);
292 spin_lock_irq(¤t->sighand->siglock);
293 current->blocked = set;
295 spin_unlock_irq(¤t->sighand->siglock);
297 if (ia32_restore_sigcontext(®s, &frame->sc, &eax))
302 signal_fault(®s, frame, "32bit sigreturn");
306 asmlinkage long sys32_rt_sigreturn(struct pt_regs regs)
308 struct rt_sigframe __user *frame = (struct rt_sigframe __user *)(regs.rsp - 4);
312 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
314 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
317 sigdelsetmask(&set, ~_BLOCKABLE);
318 spin_lock_irq(¤t->sighand->siglock);
319 current->blocked = set;
321 spin_unlock_irq(¤t->sighand->siglock);
323 if (ia32_restore_sigcontext(®s, &frame->uc.uc_mcontext, &eax))
326 if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, regs) == -EFAULT)
332 signal_fault(®s,frame,"32bit rt sigreturn");
337 * Set up a signal frame.
341 ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc, struct _fpstate_ia32 __user *fpstate,
342 struct pt_regs *regs, unsigned int mask)
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);
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);
372 tmp = save_i387_ia32(current, fpstate, regs, 0);
376 current->used_math = 0;
378 err |= __put_user((u32)(u64)(tmp ? fpstate : NULL), &sc->fpstate);
381 /* non-iBCS2 extensions.. */
382 err |= __put_user(mask, &sc->oldmask);
383 err |= __put_user(current->thread.cr2, &sc->cr2);
389 * Determine which stack to use..
392 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
396 /* Default to using normal stack */
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;
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;
412 return (void __user *)((rsp - frame_size) & -8UL);
415 void ia32_setup_frame(int sig, struct k_sigaction *ka,
416 compat_sigset_t *set, struct pt_regs * regs)
418 struct sigframe __user *frame;
421 frame = get_sigframe(ka, regs, sizeof(*frame));
423 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
427 struct exec_domain *ed = current_thread_info()->exec_domain;
428 err |= __put_user((ed
431 ? ed->signal_invmap[sig]
438 err |= ia32_setup_sigcontext(&frame->sc, &frame->fpstate, regs, set->sig[0]);
442 if (_COMPAT_NSIG_WORDS > 1) {
443 err |= __copy_to_user(frame->extramask, &set->sig[1],
444 sizeof(frame->extramask));
449 /* Return stub is in 32bit vsyscall page */
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);
456 /* These are actually not used anymore, but left because some
457 gdb versions depend on them as a marker. */
459 /* copy_to_user optimizes that into a single 8 byte store */
460 static const struct {
465 } __attribute__((packed)) code = {
466 0xb858, /* popl %eax ; movl $...,%eax */
468 0x80cd, /* int $0x80 */
471 err |= __copy_to_user(frame->retcode, &code, 8);
476 /* Set up registers for signal handler */
477 regs->rsp = (unsigned long) frame;
478 regs->rip = (unsigned long) ka->sa.sa_handler;
480 asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));
481 asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
483 regs->cs = __USER32_CS;
484 regs->ss = __USER32_DS;
487 regs->eflags &= ~TF_MASK;
490 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
491 current->comm, current->pid, frame, regs->rip, frame->pretcode);
498 ka->sa.sa_handler = SIG_DFL;
499 signal_fault(regs,frame,"32bit signal deliver");
502 void ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
503 compat_sigset_t *set, struct pt_regs * regs)
505 struct rt_sigframe __user *frame;
508 frame = get_sigframe(ka, regs, sizeof(*frame));
510 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
515 struct exec_domain *ed = current_thread_info()->exec_domain;
516 err |= __put_user((ed
519 ? ed->signal_invmap[sig]
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);
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,
538 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
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);
550 /* This is movl $,%eax ; int $0x80 */
551 /* Not actually used anymore, but left because some gdb versions
554 /* __copy_to_user optimizes that into a single 8 byte store */
555 static const struct {
561 } __attribute__((packed)) code = {
563 __NR_ia32_rt_sigreturn,
567 err |= __copy_to_user(frame->retcode, &code, 8);
572 /* Set up registers for signal handler */
573 regs->rsp = (unsigned long) frame;
574 regs->rip = (unsigned long) ka->sa.sa_handler;
576 asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));
577 asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
579 regs->cs = __USER32_CS;
580 regs->ss = __USER32_DS;
583 regs->eflags &= ~TF_MASK;
586 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
587 current->comm, current->pid, frame, regs->rip, frame->pretcode);
594 ka->sa.sa_handler = SIG_DFL;
595 signal_fault(regs, frame, "32bit rt signal setup");