2 * Common signal handling code for both 32 and 64 bits
4 * Copyright (c) 2007 Benjamin Herrenschmidt, IBM Corporation
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 ksignal
*ksig
, 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
);
41 oldsp
= sigsp(oldsp
, ksig
);
42 newsp
= (oldsp
- frame_size
) & ~0xFUL
;
45 if (!access_ok(VERIFY_WRITE
, (void __user
*)newsp
, oldsp
- newsp
))
48 return (void __user
*)newsp
;
51 static void check_syscall_restart(struct pt_regs
*regs
, struct k_sigaction
*ka
,
54 unsigned long ret
= regs
->gpr
[3];
58 if (TRAP(regs
) != 0x0C00)
61 /* error signalled ? */
62 if (!(regs
->ccr
& 0x10000000))
66 case ERESTART_RESTARTBLOCK
:
68 /* ERESTARTNOHAND means that the syscall should only be
69 * restarted if there was no handler for the signal, and since
70 * we only get here if there is a handler, we dont restart.
72 restart
= !has_handler
;
75 /* ERESTARTSYS means to restart the syscall if there is no
76 * handler or the handler was registered with SA_RESTART
78 restart
= !has_handler
|| (ka
->sa
.sa_flags
& SA_RESTART
) != 0;
81 /* ERESTARTNOINTR means that the syscall should be
82 * called again after the signal handler returns.
89 if (ret
== ERESTART_RESTARTBLOCK
)
90 regs
->gpr
[0] = __NR_restart_syscall
;
92 regs
->gpr
[3] = regs
->orig_gpr3
;
96 regs
->result
= -EINTR
;
98 regs
->ccr
|= 0x10000000;
102 static void do_signal(struct task_struct
*tsk
)
104 sigset_t
*oldset
= sigmask_to_save();
105 struct ksignal ksig
= { .sig
= 0 };
107 int is32
= is_32bit_task();
109 BUG_ON(tsk
!= current
);
113 /* Is there any syscall restart business here ? */
114 check_syscall_restart(tsk
->thread
.regs
, &ksig
.ka
, ksig
.sig
> 0);
117 /* No signal to deliver -- put the saved sigmask back */
118 restore_saved_sigmask();
119 tsk
->thread
.regs
->trap
= 0;
120 return; /* no signals delivered */
123 #ifndef CONFIG_PPC_ADV_DEBUG_REGS
125 * Reenable the DABR before delivering the signal to
126 * user space. The DABR will have been cleared if it
127 * triggered inside the kernel.
129 if (tsk
->thread
.hw_brk
.address
&& tsk
->thread
.hw_brk
.type
)
130 __set_breakpoint(&tsk
->thread
.hw_brk
);
132 /* Re-enable the breakpoints for the signal stack */
133 thread_change_pc(tsk
, tsk
->thread
.regs
);
136 if (ksig
.ka
.sa
.sa_flags
& SA_SIGINFO
)
137 ret
= handle_rt_signal32(&ksig
, oldset
, tsk
);
139 ret
= handle_signal32(&ksig
, oldset
, tsk
);
141 ret
= handle_rt_signal64(&ksig
, oldset
, tsk
);
144 tsk
->thread
.regs
->trap
= 0;
145 signal_setup_done(ret
, &ksig
, test_thread_flag(TIF_SINGLESTEP
));
148 void do_notify_resume(struct pt_regs
*regs
, unsigned long thread_info_flags
)
152 if (thread_info_flags
& _TIF_UPROBE
)
153 uprobe_notify_resume(regs
);
155 if (thread_info_flags
& _TIF_SIGPENDING
) {
156 BUG_ON(regs
!= current
->thread
.regs
);
160 if (thread_info_flags
& _TIF_NOTIFY_RESUME
) {
161 clear_thread_flag(TIF_NOTIFY_RESUME
);
162 tracehook_notify_resume(regs
);
168 unsigned long get_tm_stackpointer(struct task_struct
*tsk
)
170 /* When in an active transaction that takes a signal, we need to be
171 * careful with the stack. It's possible that the stack has moved back
172 * up after the tbegin. The obvious case here is when the tbegin is
173 * called inside a function that returns before a tend. In this case,
174 * the stack is part of the checkpointed transactional memory state.
175 * If we write over this non transactionally or in suspend, we are in
176 * trouble because if we get a tm abort, the program counter and stack
177 * pointer will be back at the tbegin but our in memory stack won't be
180 * To avoid this, when taking a signal in an active transaction, we
181 * need to use the stack pointer from the checkpointed state, rather
182 * than the speculated state. This ensures that the signal context
183 * (written tm suspended) will be written below the stack required for
184 * the rollback. The transaction is aborted because of the treclaim,
185 * so any memory written between the tbegin and the signal will be
186 * rolled back anyway.
188 * For signals taken in non-TM or suspended mode, we use the
189 * normal/non-checkpointed stack pointer.
192 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
193 BUG_ON(tsk
!= current
);
195 if (MSR_TM_ACTIVE(tsk
->thread
.regs
->msr
)) {
196 tm_reclaim_current(TM_CAUSE_SIGNAL
);
197 if (MSR_TM_TRANSACTIONAL(tsk
->thread
.regs
->msr
))
198 return tsk
->thread
.ckpt_regs
.gpr
[1];
201 return tsk
->thread
.regs
->gpr
[1];