2 * Common signal handling code for both 32 and 64 bits
4 * Copyright (c) 2007 Benjamin Herrenschmidt, IBM Coproration
5 * Extracted from signal_32.c and signal_64.c
7 * This file is subject to the terms and conditions of the GNU General
8 * Public License. See the file README.legal in the main directory of
9 * this archive for more details.
12 #include <linux/tracehook.h>
13 #include <linux/signal.h>
14 #include <linux/uprobes.h>
15 #include <linux/key.h>
16 #include <linux/context_tracking.h>
17 #include <asm/hw_breakpoint.h>
18 #include <asm/uaccess.h>
19 #include <asm/unistd.h>
20 #include <asm/debug.h>
25 /* Log an error when sending an unhandled signal to a process. Controlled
26 * through debug.exception-trace sysctl.
29 int show_unhandled_signals
= 1;
32 * Allocate space for the signal frame
34 void __user
* get_sigframe(struct k_sigaction
*ka
, unsigned long sp
,
35 size_t frame_size
, int is_32
)
37 unsigned long oldsp
, newsp
;
39 /* Default to using normal stack */
40 oldsp
= get_clean_sp(sp
, is_32
);
42 /* Check for alt stack */
43 if ((ka
->sa
.sa_flags
& SA_ONSTACK
) &&
44 current
->sas_ss_size
&& !on_sig_stack(oldsp
))
45 oldsp
= (current
->sas_ss_sp
+ current
->sas_ss_size
);
47 /* Get aligned frame */
48 newsp
= (oldsp
- frame_size
) & ~0xFUL
;
51 if (!access_ok(VERIFY_WRITE
, (void __user
*)newsp
, oldsp
- newsp
))
54 return (void __user
*)newsp
;
57 static void check_syscall_restart(struct pt_regs
*regs
, struct k_sigaction
*ka
,
60 unsigned long ret
= regs
->gpr
[3];
64 if (TRAP(regs
) != 0x0C00)
67 /* error signalled ? */
68 if (!(regs
->ccr
& 0x10000000))
72 case ERESTART_RESTARTBLOCK
:
74 /* ERESTARTNOHAND means that the syscall should only be
75 * restarted if there was no handler for the signal, and since
76 * we only get here if there is a handler, we dont restart.
78 restart
= !has_handler
;
81 /* ERESTARTSYS means to restart the syscall if there is no
82 * handler or the handler was registered with SA_RESTART
84 restart
= !has_handler
|| (ka
->sa
.sa_flags
& SA_RESTART
) != 0;
87 /* ERESTARTNOINTR means that the syscall should be
88 * called again after the signal handler returns.
95 if (ret
== ERESTART_RESTARTBLOCK
)
96 regs
->gpr
[0] = __NR_restart_syscall
;
98 regs
->gpr
[3] = regs
->orig_gpr3
;
102 regs
->result
= -EINTR
;
103 regs
->gpr
[3] = EINTR
;
104 regs
->ccr
|= 0x10000000;
108 static int do_signal(struct pt_regs
*regs
)
110 sigset_t
*oldset
= sigmask_to_save();
113 struct k_sigaction ka
;
115 int is32
= is_32bit_task();
117 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
119 /* Is there any syscall restart business here ? */
120 check_syscall_restart(regs
, &ka
, signr
> 0);
123 /* No signal to deliver -- put the saved sigmask back */
124 restore_saved_sigmask();
126 return 0; /* no signals delivered */
129 #ifndef CONFIG_PPC_ADV_DEBUG_REGS
131 * Reenable the DABR before delivering the signal to
132 * user space. The DABR will have been cleared if it
133 * triggered inside the kernel.
135 if (current
->thread
.hw_brk
.address
&&
136 current
->thread
.hw_brk
.type
)
137 set_breakpoint(¤t
->thread
.hw_brk
);
139 /* Re-enable the breakpoints for the signal stack */
140 thread_change_pc(current
, regs
);
143 if (ka
.sa
.sa_flags
& SA_SIGINFO
)
144 ret
= handle_rt_signal32(signr
, &ka
, &info
, oldset
,
147 ret
= handle_signal32(signr
, &ka
, &info
, oldset
,
150 ret
= handle_rt_signal64(signr
, &ka
, &info
, oldset
, regs
);
155 signal_delivered(signr
, &info
, &ka
, regs
,
156 test_thread_flag(TIF_SINGLESTEP
));
162 void do_notify_resume(struct pt_regs
*regs
, unsigned long thread_info_flags
)
166 if (thread_info_flags
& _TIF_UPROBE
)
167 uprobe_notify_resume(regs
);
169 if (thread_info_flags
& _TIF_SIGPENDING
)
172 if (thread_info_flags
& _TIF_NOTIFY_RESUME
) {
173 clear_thread_flag(TIF_NOTIFY_RESUME
);
174 tracehook_notify_resume(regs
);
180 unsigned long get_tm_stackpointer(struct pt_regs
*regs
)
182 /* When in an active transaction that takes a signal, we need to be
183 * careful with the stack. It's possible that the stack has moved back
184 * up after the tbegin. The obvious case here is when the tbegin is
185 * called inside a function that returns before a tend. In this case,
186 * the stack is part of the checkpointed transactional memory state.
187 * If we write over this non transactionally or in suspend, we are in
188 * trouble because if we get a tm abort, the program counter and stack
189 * pointer will be back at the tbegin but our in memory stack won't be
192 * To avoid this, when taking a signal in an active transaction, we
193 * need to use the stack pointer from the checkpointed state, rather
194 * than the speculated state. This ensures that the signal context
195 * (written tm suspended) will be written below the stack required for
196 * the rollback. The transaction is aborted becuase of the treclaim,
197 * so any memory written between the tbegin and the signal will be
198 * rolled back anyway.
200 * For signals taken in non-TM or suspended mode, we use the
201 * normal/non-checkpointed stack pointer.
204 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
205 if (MSR_TM_ACTIVE(regs
->msr
)) {
206 tm_reclaim_current(TM_CAUSE_SIGNAL
);
207 if (MSR_TM_TRANSACTIONAL(regs
->msr
))
208 return current
->thread
.ckpt_regs
.gpr
[1];