]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - arch/um/kernel/signal.c
2 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
3 * Licensed under the GPL
6 #include <linux/module.h>
7 #include <linux/ptrace.h>
8 #include <linux/sched.h>
9 #include <asm/siginfo.h>
10 #include <asm/signal.h>
11 #include <asm/unistd.h>
12 #include "frame_kern.h"
13 #include "kern_util.h"
15 EXPORT_SYMBOL(block_signals
);
16 EXPORT_SYMBOL(unblock_signals
);
18 #define _S(nr) (1<<((nr)-1))
20 #define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))
23 * OK, we're invoking a handler
25 static int handle_signal(struct pt_regs
*regs
, unsigned long signr
,
26 struct k_sigaction
*ka
, siginfo_t
*info
,
32 /* Always make any pending restarted system calls return -EINTR */
33 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
35 /* Did we come from a system call? */
36 if (PT_REGS_SYSCALL_NR(regs
) >= 0) {
37 /* If so, check system call restarting.. */
38 switch (PT_REGS_SYSCALL_RET(regs
)) {
39 case -ERESTART_RESTARTBLOCK
:
41 PT_REGS_SYSCALL_RET(regs
) = -EINTR
;
45 if (!(ka
->sa
.sa_flags
& SA_RESTART
)) {
46 PT_REGS_SYSCALL_RET(regs
) = -EINTR
;
51 PT_REGS_RESTART_SYSCALL(regs
);
52 PT_REGS_ORIG_SYSCALL(regs
) = PT_REGS_SYSCALL_NR(regs
);
57 sp
= PT_REGS_SP(regs
);
58 if ((ka
->sa
.sa_flags
& SA_ONSTACK
) && (sas_ss_flags(sp
) == 0))
59 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
61 #ifdef CONFIG_ARCH_HAS_SC_SIGNALS
62 if (!(ka
->sa
.sa_flags
& SA_SIGINFO
))
63 err
= setup_signal_stack_sc(sp
, signr
, ka
, regs
, oldset
);
66 err
= setup_signal_stack_si(sp
, signr
, ka
, regs
, info
, oldset
);
69 force_sigsegv(signr
, current
);
71 spin_lock_irq(¤t
->sighand
->siglock
);
72 sigorsets(¤t
->blocked
, ¤t
->blocked
,
74 if (!(ka
->sa
.sa_flags
& SA_NODEFER
))
75 sigaddset(¤t
->blocked
, signr
);
77 spin_unlock_irq(¤t
->sighand
->siglock
);
83 static int kern_do_signal(struct pt_regs
*regs
)
85 struct k_sigaction ka_copy
;
88 int sig
, handled_sig
= 0;
90 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
91 oldset
= ¤t
->saved_sigmask
;
93 oldset
= ¤t
->blocked
;
95 while ((sig
= get_signal_to_deliver(&info
, &ka_copy
, regs
, NULL
)) > 0) {
97 /* Whee! Actually deliver the signal. */
98 if (!handle_signal(regs
, sig
, &ka_copy
, &info
, oldset
)) {
100 * a signal was successfully delivered; the saved
101 * sigmask will have been stored in the signal frame,
102 * and will be restored by sigreturn, so we can simply
103 * clear the TIF_RESTORE_SIGMASK flag
105 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
106 clear_thread_flag(TIF_RESTORE_SIGMASK
);
111 /* Did we come from a system call? */
112 if (!handled_sig
&& (PT_REGS_SYSCALL_NR(regs
) >= 0)) {
113 /* Restart the system call - no handlers present */
114 switch (PT_REGS_SYSCALL_RET(regs
)) {
115 case -ERESTARTNOHAND
:
117 case -ERESTARTNOINTR
:
118 PT_REGS_ORIG_SYSCALL(regs
) = PT_REGS_SYSCALL_NR(regs
);
119 PT_REGS_RESTART_SYSCALL(regs
);
121 case -ERESTART_RESTARTBLOCK
:
122 PT_REGS_ORIG_SYSCALL(regs
) = __NR_restart_syscall
;
123 PT_REGS_RESTART_SYSCALL(regs
);
129 * This closes a way to execute a system call on the host. If
130 * you set a breakpoint on a system call instruction and singlestep
131 * from it, the tracing thread used to PTRACE_SINGLESTEP the process
132 * rather than PTRACE_SYSCALL it, allowing the system call to execute
133 * on the host. The tracing thread will check this flag and
134 * PTRACE_SYSCALL if necessary.
136 if (current
->ptrace
& PT_DTRACE
)
137 current
->thread
.singlestep_syscall
=
138 is_syscall(PT_REGS_IP(¤t
->thread
.regs
));
141 * if there's no signal to deliver, we just put the saved sigmask
144 if (!handled_sig
&& test_thread_flag(TIF_RESTORE_SIGMASK
)) {
145 clear_thread_flag(TIF_RESTORE_SIGMASK
);
146 sigprocmask(SIG_SETMASK
, ¤t
->saved_sigmask
, NULL
);
153 return kern_do_signal(¤t
->thread
.regs
);
157 * Atomically swap in the new signal mask, and wait for a signal.
159 long sys_sigsuspend(int history0
, int history1
, old_sigset_t mask
)
162 spin_lock_irq(¤t
->sighand
->siglock
);
163 current
->saved_sigmask
= current
->blocked
;
164 siginitset(¤t
->blocked
, mask
);
166 spin_unlock_irq(¤t
->sighand
->siglock
);
168 current
->state
= TASK_INTERRUPTIBLE
;
170 set_thread_flag(TIF_RESTORE_SIGMASK
);
171 return -ERESTARTNOHAND
;
174 long sys_sigaltstack(const stack_t __user
*uss
, stack_t __user
*uoss
)
176 return do_sigaltstack(uss
, uoss
, PT_REGS_SP(¤t
->thread
.regs
));