2 * linux/arch/i386/kernel/signal.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
6 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
9 #include <linux/config.h>
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 <asm/ucontext.h>
23 #include <asm/uaccess.h>
27 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
29 asmlinkage
int sys_wait4(pid_t pid
, unsigned long *stat_addr
,
30 int options
, unsigned long *ru
);
31 asmlinkage
int FASTCALL(do_signal(struct pt_regs
*regs
, sigset_t
*oldset
));
34 * Atomically swap in the new signal mask, and wait for a signal.
37 sys_sigsuspend(int history0
, int history1
, old_sigset_t mask
)
39 struct pt_regs
* regs
= (struct pt_regs
*) &history0
;
43 spin_lock_irq(¤t
->sigmask_lock
);
44 saveset
= current
->blocked
;
45 siginitset(¤t
->blocked
, mask
);
46 recalc_sigpending(current
);
47 spin_unlock_irq(¤t
->sigmask_lock
);
51 current
->state
= TASK_INTERRUPTIBLE
;
53 if (do_signal(regs
, &saveset
))
59 sys_rt_sigsuspend(sigset_t
*unewset
, size_t sigsetsize
)
61 struct pt_regs
* regs
= (struct pt_regs
*) &unewset
;
62 sigset_t saveset
, newset
;
64 /* XXX: Don't preclude handling different sized sigset_t's. */
65 if (sigsetsize
!= sizeof(sigset_t
))
68 if (copy_from_user(&newset
, unewset
, sizeof(newset
)))
70 sigdelsetmask(&newset
, ~_BLOCKABLE
);
72 spin_lock_irq(¤t
->sigmask_lock
);
73 saveset
= current
->blocked
;
74 current
->blocked
= newset
;
75 recalc_sigpending(current
);
76 spin_unlock_irq(¤t
->sigmask_lock
);
80 current
->state
= TASK_INTERRUPTIBLE
;
82 if (do_signal(regs
, &saveset
))
88 sys_sigaction(int sig
, const struct old_sigaction
*act
,
89 struct old_sigaction
*oact
)
91 struct k_sigaction new_ka
, old_ka
;
96 if (verify_area(VERIFY_READ
, act
, sizeof(*act
)) ||
97 __get_user(new_ka
.sa
.sa_handler
, &act
->sa_handler
) ||
98 __get_user(new_ka
.sa
.sa_restorer
, &act
->sa_restorer
))
100 __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
);
101 __get_user(mask
, &act
->sa_mask
);
102 siginitset(&new_ka
.sa
.sa_mask
, mask
);
105 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
108 if (verify_area(VERIFY_WRITE
, oact
, sizeof(*oact
)) ||
109 __put_user(old_ka
.sa
.sa_handler
, &oact
->sa_handler
) ||
110 __put_user(old_ka
.sa
.sa_restorer
, &oact
->sa_restorer
))
112 __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
);
113 __put_user(old_ka
.sa
.sa_mask
.sig
[0], &oact
->sa_mask
);
120 sys_sigaltstack(const stack_t
*uss
, stack_t
*uoss
)
122 struct pt_regs
*regs
= (struct pt_regs
*) &uss
;
123 return do_sigaltstack(uss
, uoss
, regs
->esp
);
128 * Do a signal return; undo the signal stack.
135 struct sigcontext sc
;
136 struct _fpstate fpstate
;
137 unsigned long extramask
[_NSIG_WORDS
-1];
145 struct siginfo
*pinfo
;
149 struct _fpstate fpstate
;
154 static inline int restore_i387_hard(struct _fpstate
*buf
)
156 struct task_struct
*tsk
= current
;
158 return __copy_from_user(&tsk
->thread
.i387
.hard
, buf
, sizeof(*buf
));
161 static inline int restore_i387(struct _fpstate
*buf
)
164 #ifndef CONFIG_MATH_EMULATION
165 err
= restore_i387_hard(buf
);
167 if (boot_cpu_data
.hard_math
)
168 err
= restore_i387_hard(buf
);
170 err
= restore_i387_soft(¤t
->thread
.i387
.soft
, buf
);
172 current
->used_math
= 1;
177 restore_sigcontext(struct pt_regs
*regs
, struct sigcontext
*sc
, int *peax
)
179 unsigned int err
= 0;
181 #define COPY(x) err |= __get_user(regs->x, &sc->x)
183 #define COPY_SEG(seg) \
184 { unsigned short tmp; \
185 err |= __get_user(tmp, &sc->seg); \
186 regs->x##seg = tmp; }
188 #define COPY_SEG_STRICT(seg) \
189 { unsigned short tmp; \
190 err |= __get_user(tmp, &sc->seg); \
191 regs->x##seg = tmp|3; }
193 #define GET_SEG(seg) \
194 { unsigned short tmp; \
195 err |= __get_user(tmp, &sc->seg); \
196 loadsegment(seg,tmp); }
214 unsigned int tmpflags
;
215 err
|= __get_user(tmpflags
, &sc
->eflags
);
216 regs
->eflags
= (regs
->eflags
& ~0x40DD5) | (tmpflags
& 0x40DD5);
217 regs
->orig_eax
= -1; /* disable syscall checks */
221 struct _fpstate
* buf
;
222 err
|= __get_user(buf
, &sc
->fpstate
);
224 if (verify_area(VERIFY_READ
, buf
, sizeof(*buf
)))
226 err
|= restore_i387(buf
);
230 err
|= __get_user(*peax
, &sc
->eax
);
237 asmlinkage
int sys_sigreturn(unsigned long __unused
)
239 struct pt_regs
*regs
= (struct pt_regs
*) &__unused
;
240 struct sigframe
*frame
= (struct sigframe
*)(regs
->esp
- 8);
244 if (verify_area(VERIFY_READ
, frame
, sizeof(*frame
)))
246 if (__get_user(set
.sig
[0], &frame
->sc
.oldmask
)
248 && __copy_from_user(&set
.sig
[1], &frame
->extramask
,
249 sizeof(frame
->extramask
))))
252 sigdelsetmask(&set
, ~_BLOCKABLE
);
253 spin_lock_irq(¤t
->sigmask_lock
);
254 current
->blocked
= set
;
255 recalc_sigpending(current
);
256 spin_unlock_irq(¤t
->sigmask_lock
);
258 if (restore_sigcontext(regs
, &frame
->sc
, &eax
))
263 force_sig(SIGSEGV
, current
);
267 asmlinkage
int sys_rt_sigreturn(unsigned long __unused
)
269 struct pt_regs
*regs
= (struct pt_regs
*) &__unused
;
270 struct rt_sigframe
*frame
= (struct rt_sigframe
*)(regs
->esp
- 4);
275 if (verify_area(VERIFY_READ
, frame
, sizeof(*frame
)))
277 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
280 sigdelsetmask(&set
, ~_BLOCKABLE
);
281 spin_lock_irq(¤t
->sigmask_lock
);
282 current
->blocked
= set
;
283 recalc_sigpending(current
);
284 spin_unlock_irq(¤t
->sigmask_lock
);
286 if (restore_sigcontext(regs
, &frame
->uc
.uc_mcontext
, &eax
))
289 if (__copy_from_user(&st
, &frame
->uc
.uc_stack
, sizeof(st
)))
291 /* It is more difficult to avoid calling this function than to
292 call it and ignore errors. */
293 do_sigaltstack(&st
, NULL
, regs
->esp
);
298 force_sig(SIGSEGV
, current
);
303 * Set up a signal frame.
306 static inline int save_i387_hard(struct _fpstate
* buf
)
308 struct task_struct
*tsk
= current
;
311 tsk
->thread
.i387
.hard
.status
= tsk
->thread
.i387
.hard
.swd
;
312 if (__copy_to_user(buf
, &tsk
->thread
.i387
.hard
, sizeof(*buf
)))
317 static int save_i387(struct _fpstate
*buf
)
319 if (!current
->used_math
)
322 /* This will cause a "finit" to be triggered by the next
323 attempted FPU operation by the 'current' process.
325 current
->used_math
= 0;
327 #ifndef CONFIG_MATH_EMULATION
328 return save_i387_hard(buf
);
330 return boot_cpu_data
.hard_math
? save_i387_hard(buf
)
331 : save_i387_soft(¤t
->thread
.i387
.soft
, buf
);
336 setup_sigcontext(struct sigcontext
*sc
, struct _fpstate
*fpstate
,
337 struct pt_regs
*regs
, unsigned long mask
)
342 __asm__("movl %%gs,%w0" : "=r"(tmp
): "0"(tmp
));
343 err
|= __put_user(tmp
, (unsigned int *)&sc
->gs
);
344 __asm__("movl %%fs,%w0" : "=r"(tmp
): "0"(tmp
));
345 err
|= __put_user(tmp
, (unsigned int *)&sc
->fs
);
347 err
|= __put_user(regs
->xes
, (unsigned int *)&sc
->es
);
348 err
|= __put_user(regs
->xds
, (unsigned int *)&sc
->ds
);
349 err
|= __put_user(regs
->edi
, &sc
->edi
);
350 err
|= __put_user(regs
->esi
, &sc
->esi
);
351 err
|= __put_user(regs
->ebp
, &sc
->ebp
);
352 err
|= __put_user(regs
->esp
, &sc
->esp
);
353 err
|= __put_user(regs
->ebx
, &sc
->ebx
);
354 err
|= __put_user(regs
->edx
, &sc
->edx
);
355 err
|= __put_user(regs
->ecx
, &sc
->ecx
);
356 err
|= __put_user(regs
->eax
, &sc
->eax
);
357 err
|= __put_user(current
->thread
.trap_no
, &sc
->trapno
);
358 err
|= __put_user(current
->thread
.error_code
, &sc
->err
);
359 err
|= __put_user(regs
->eip
, &sc
->eip
);
360 err
|= __put_user(regs
->xcs
, (unsigned int *)&sc
->cs
);
361 err
|= __put_user(regs
->eflags
, &sc
->eflags
);
362 err
|= __put_user(regs
->esp
, &sc
->esp_at_signal
);
363 err
|= __put_user(regs
->xss
, (unsigned int *)&sc
->ss
);
365 tmp
= save_i387(fpstate
);
369 err
|= __put_user(tmp
? fpstate
: NULL
, &sc
->fpstate
);
371 /* non-iBCS2 extensions.. */
372 err
|= __put_user(mask
, &sc
->oldmask
);
373 err
|= __put_user(current
->thread
.cr2
, &sc
->cr2
);
379 * Determine which stack to use..
382 get_sigframe(struct k_sigaction
*ka
, struct pt_regs
* regs
, size_t frame_size
)
386 /* Default to using normal stack */
389 /* This is the X/Open sanctioned signal stack switching. */
390 if (ka
->sa
.sa_flags
& SA_ONSTACK
) {
391 if (! on_sig_stack(esp
))
392 esp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
395 /* This is the legacy signal stack switching. */
396 else if ((regs
->xss
& 0xffff) != __USER_DS
&&
397 !(ka
->sa
.sa_flags
& SA_RESTORER
) &&
398 ka
->sa
.sa_restorer
) {
399 esp
= (unsigned long) ka
->sa
.sa_restorer
;
402 return (void *)((esp
- frame_size
) & -8ul);
405 static void setup_frame(int sig
, struct k_sigaction
*ka
,
406 sigset_t
*set
, struct pt_regs
* regs
)
408 struct sigframe
*frame
;
411 frame
= get_sigframe(ka
, regs
, sizeof(*frame
));
413 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
416 err
|= __put_user((current
->exec_domain
417 && current
->exec_domain
->signal_invmap
419 ? current
->exec_domain
->signal_invmap
[sig
]
423 err
|= setup_sigcontext(&frame
->sc
, &frame
->fpstate
, regs
, set
->sig
[0]);
425 if (_NSIG_WORDS
> 1) {
426 err
|= __copy_to_user(frame
->extramask
, &set
->sig
[1],
427 sizeof(frame
->extramask
));
430 /* Set up to return from userspace. If provided, use a stub
431 already in userspace. */
432 if (ka
->sa
.sa_flags
& SA_RESTORER
) {
433 err
|= __put_user(ka
->sa
.sa_restorer
, &frame
->pretcode
);
435 err
|= __put_user(frame
->retcode
, &frame
->pretcode
);
436 /* This is popl %eax ; movl $,%eax ; int $0x80 */
437 err
|= __put_user(0xb858, (short *)(frame
->retcode
+0));
438 err
|= __put_user(__NR_sigreturn
, (int *)(frame
->retcode
+2));
439 err
|= __put_user(0x80cd, (short *)(frame
->retcode
+6));
445 /* Set up registers for signal handler */
446 regs
->esp
= (unsigned long) frame
;
447 regs
->eip
= (unsigned long) ka
->sa
.sa_handler
;
450 regs
->xds
= __USER_DS
;
451 regs
->xes
= __USER_DS
;
452 regs
->xss
= __USER_DS
;
453 regs
->xcs
= __USER_CS
;
454 regs
->eflags
&= ~TF_MASK
;
457 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
458 current
->comm
, current
->pid
, frame
, regs
->eip
, frame
->pretcode
);
465 ka
->sa
.sa_handler
= SIG_DFL
;
466 force_sig(SIGSEGV
, current
);
469 static void setup_rt_frame(int sig
, struct k_sigaction
*ka
, siginfo_t
*info
,
470 sigset_t
*set
, struct pt_regs
* regs
)
472 struct rt_sigframe
*frame
;
475 frame
= get_sigframe(ka
, regs
, sizeof(*frame
));
477 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
480 err
|= __put_user((current
->exec_domain
481 && current
->exec_domain
->signal_invmap
483 ? current
->exec_domain
->signal_invmap
[sig
]
486 err
|= __put_user(&frame
->info
, &frame
->pinfo
);
487 err
|= __put_user(&frame
->uc
, &frame
->puc
);
488 err
|= __copy_to_user(&frame
->info
, info
, sizeof(*info
));
490 /* Create the ucontext. */
491 err
|= __put_user(0, &frame
->uc
.uc_flags
);
492 err
|= __put_user(0, &frame
->uc
.uc_link
);
493 err
|= __put_user(current
->sas_ss_sp
, &frame
->uc
.uc_stack
.ss_sp
);
494 err
|= __put_user(sas_ss_flags(regs
->esp
),
495 &frame
->uc
.uc_stack
.ss_flags
);
496 err
|= __put_user(current
->sas_ss_size
, &frame
->uc
.uc_stack
.ss_size
);
497 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, &frame
->fpstate
,
499 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
501 /* Set up to return from userspace. If provided, use a stub
502 already in userspace. */
503 if (ka
->sa
.sa_flags
& SA_RESTORER
) {
504 err
|= __put_user(ka
->sa
.sa_restorer
, &frame
->pretcode
);
506 err
|= __put_user(frame
->retcode
, &frame
->pretcode
);
507 /* This is movl $,%eax ; int $0x80 */
508 err
|= __put_user(0xb8, (char *)(frame
->retcode
+0));
509 err
|= __put_user(__NR_rt_sigreturn
, (int *)(frame
->retcode
+1));
510 err
|= __put_user(0x80cd, (short *)(frame
->retcode
+5));
516 /* Set up registers for signal handler */
517 regs
->esp
= (unsigned long) frame
;
518 regs
->eip
= (unsigned long) ka
->sa
.sa_handler
;
521 regs
->xds
= __USER_DS
;
522 regs
->xes
= __USER_DS
;
523 regs
->xss
= __USER_DS
;
524 regs
->xcs
= __USER_CS
;
525 regs
->eflags
&= ~TF_MASK
;
528 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
529 current
->comm
, current
->pid
, frame
, regs
->eip
, frame
->pretcode
);
536 ka
->sa
.sa_handler
= SIG_DFL
;
537 force_sig(SIGSEGV
, current
);
541 * OK, we're invoking a handler
545 handle_signal(unsigned long sig
, struct k_sigaction
*ka
,
546 siginfo_t
*info
, sigset_t
*oldset
, struct pt_regs
* regs
)
548 /* Are we from a system call? */
549 if (regs
->orig_eax
>= 0) {
550 /* If so, check system call restarting.. */
552 case -ERESTARTNOHAND
:
557 if (!(ka
->sa
.sa_flags
& SA_RESTART
)) {
562 case -ERESTARTNOINTR
:
563 regs
->eax
= regs
->orig_eax
;
568 /* Set up the stack frame */
569 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
570 setup_rt_frame(sig
, ka
, info
, oldset
, regs
);
572 setup_frame(sig
, ka
, oldset
, regs
);
574 if (ka
->sa
.sa_flags
& SA_ONESHOT
)
575 ka
->sa
.sa_handler
= SIG_DFL
;
577 if (!(ka
->sa
.sa_flags
& SA_NODEFER
)) {
578 spin_lock_irq(¤t
->sigmask_lock
);
579 sigorsets(¤t
->blocked
,¤t
->blocked
,&ka
->sa
.sa_mask
);
580 sigaddset(¤t
->blocked
,sig
);
581 recalc_sigpending(current
);
582 spin_unlock_irq(¤t
->sigmask_lock
);
587 * Note that 'init' is a special process: it doesn't get signals it doesn't
588 * want to handle. Thus you cannot kill init even with a SIGKILL even by
591 * Note that we go through the signals twice: once to check the signals that
592 * the kernel can handle, and then we build all the user-level signal handling
593 * stack-frames in one go after that.
595 int do_signal(struct pt_regs
*regs
, sigset_t
*oldset
)
598 struct k_sigaction
*ka
;
601 * We want the common case to go fast, which
602 * is why we may in certain cases get here from
603 * kernel mode. Just return without doing anything
606 if ((regs
->xcs
& 3) != 3)
610 oldset
= ¤t
->blocked
;
615 spin_lock_irq(¤t
->sigmask_lock
);
616 signr
= dequeue_signal(¤t
->blocked
, &info
);
617 spin_unlock_irq(¤t
->sigmask_lock
);
622 if ((current
->flags
& PF_PTRACED
) && signr
!= SIGKILL
) {
623 /* Let the debugger run. */
624 current
->exit_code
= signr
;
625 current
->state
= TASK_STOPPED
;
626 notify_parent(current
, SIGCHLD
);
629 /* We're back. Did the debugger cancel the sig? */
630 if (!(signr
= current
->exit_code
))
632 current
->exit_code
= 0;
634 /* The debugger continued. Ignore SIGSTOP. */
635 if (signr
== SIGSTOP
)
638 /* Update the siginfo structure. Is this good? */
639 if (signr
!= info
.si_signo
) {
640 info
.si_signo
= signr
;
642 info
.si_code
= SI_USER
;
643 info
.si_pid
= current
->p_pptr
->pid
;
644 info
.si_uid
= current
->p_pptr
->uid
;
647 /* If the (new) signal is now blocked, requeue it. */
648 if (sigismember(¤t
->blocked
, signr
)) {
649 send_sig_info(signr
, &info
, current
);
654 ka
= ¤t
->sig
->action
[signr
-1];
655 if (ka
->sa
.sa_handler
== SIG_IGN
) {
656 if (signr
!= SIGCHLD
)
658 /* Check for SIGCHLD: it's special. */
659 while (sys_wait4(-1, NULL
, WNOHANG
, NULL
) > 0)
664 if (ka
->sa
.sa_handler
== SIG_DFL
) {
665 int exit_code
= signr
;
667 /* Init gets no signals it doesn't want. */
668 if (current
->pid
== 1)
672 case SIGCONT
: case SIGCHLD
: case SIGWINCH
:
675 case SIGTSTP
: case SIGTTIN
: case SIGTTOU
:
676 if (is_orphaned_pgrp(current
->pgrp
))
681 current
->state
= TASK_STOPPED
;
682 current
->exit_code
= signr
;
683 if (!(current
->p_pptr
->sig
->action
[SIGCHLD
-1].sa
.sa_flags
& SA_NOCLDSTOP
))
684 notify_parent(current
, SIGCHLD
);
688 case SIGQUIT
: case SIGILL
: case SIGTRAP
:
689 case SIGABRT
: case SIGFPE
: case SIGSEGV
:
690 if (do_coredump(signr
, regs
))
696 sigaddset(¤t
->signal
, signr
);
697 recalc_sigpending(current
);
698 current
->flags
|= PF_SIGNALED
;
704 /* Whee! Actually deliver the signal. */
705 handle_signal(signr
, ka
, &info
, oldset
, regs
);
709 /* Did we come from a system call? */
710 if (regs
->orig_eax
>= 0) {
711 /* Restart the system call - no handlers present */
712 if (regs
->eax
== -ERESTARTNOHAND
||
713 regs
->eax
== -ERESTARTSYS
||
714 regs
->eax
== -ERESTARTNOINTR
) {
715 regs
->eax
= regs
->orig_eax
;