2 * linux/arch/sh/kernel/signal.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
6 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
8 * SuperH version: Copyright (C) 1999, 2000 Niibe Yutaka & Kaz Kojima
11 #include <linux/sched.h>
13 #include <linux/smp.h>
14 #include <linux/kernel.h>
15 #include <linux/signal.h>
16 #include <linux/errno.h>
17 #include <linux/wait.h>
18 #include <linux/ptrace.h>
19 #include <linux/unistd.h>
20 #include <linux/stddef.h>
21 #include <linux/tty.h>
22 #include <linux/elf.h>
23 #include <linux/personality.h>
24 #include <linux/binfmts.h>
26 #include <linux/tracehook.h>
27 #include <asm/ucontext.h>
28 #include <asm/uaccess.h>
29 #include <asm/pgtable.h>
30 #include <asm/cacheflush.h>
31 #include <asm/syscalls.h>
34 struct fdpic_func_descriptor
{
40 * The following define adds a 64 byte gap between the signal
41 * stack frame and previous contents of the stack. This allows
42 * frame unwinding in a function epilogue but only if a frame
43 * pointer is used in the function. This is necessary because
44 * current gcc compilers (<4.3) do not generate unwind info on
45 * SH for function epilogues.
47 #define UNWINDGUARD 64
50 * Do a signal return; undo the signal stack.
53 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
54 #if defined(CONFIG_CPU_SH2)
55 #define TRAP_NOARG 0xc320 /* Syscall w/no args (NR in R3) */
57 #define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) */
59 #define OR_R0_R0 0x200b /* or r0,r0 (insert to avoid hardware bug) */
64 unsigned long extramask
[_NSIG_WORDS
-1];
76 static inline int restore_sigcontext_fpu(struct sigcontext __user
*sc
)
78 struct task_struct
*tsk
= current
;
80 if (!(boot_cpu_data
.flags
& CPU_HAS_FPU
))
84 return __copy_from_user(&tsk
->thread
.xstate
->hardfpu
, &sc
->sc_fpregs
[0],
85 sizeof(long)*(16*2+2));
88 static inline int save_sigcontext_fpu(struct sigcontext __user
*sc
,
91 struct task_struct
*tsk
= current
;
93 if (!(boot_cpu_data
.flags
& CPU_HAS_FPU
))
97 return __put_user(0, &sc
->sc_ownedfp
);
99 if (__put_user(1, &sc
->sc_ownedfp
))
102 /* This will cause a "finit" to be triggered by the next
103 attempted FPU operation by the 'current' process.
107 unlazy_fpu(tsk
, regs
);
108 return __copy_to_user(&sc
->sc_fpregs
[0], &tsk
->thread
.xstate
->hardfpu
,
109 sizeof(long)*(16*2+2));
111 #endif /* CONFIG_SH_FPU */
114 restore_sigcontext(struct pt_regs
*regs
, struct sigcontext __user
*sc
, int *r0_p
)
116 unsigned int err
= 0;
118 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
120 COPY(regs
[2]); COPY(regs
[3]);
121 COPY(regs
[4]); COPY(regs
[5]);
122 COPY(regs
[6]); COPY(regs
[7]);
123 COPY(regs
[8]); COPY(regs
[9]);
124 COPY(regs
[10]); COPY(regs
[11]);
125 COPY(regs
[12]); COPY(regs
[13]);
126 COPY(regs
[14]); COPY(regs
[15]);
127 COPY(gbr
); COPY(mach
);
128 COPY(macl
); COPY(pr
);
133 if (boot_cpu_data
.flags
& CPU_HAS_FPU
) {
135 struct task_struct
*tsk
= current
;
137 regs
->sr
|= SR_FD
; /* Release FPU */
138 clear_fpu(tsk
, regs
);
140 err
|= __get_user (owned_fp
, &sc
->sc_ownedfp
);
142 err
|= restore_sigcontext_fpu(sc
);
146 regs
->tra
= -1; /* disable syscall checks */
147 err
|= __get_user(*r0_p
, &sc
->sc_regs
[0]);
151 asmlinkage
int sys_sigreturn(void)
153 struct pt_regs
*regs
= current_pt_regs();
154 struct sigframe __user
*frame
= (struct sigframe __user
*)regs
->regs
[15];
158 /* Always make any pending restarted system calls return -EINTR */
159 current
->restart_block
.fn
= do_no_restart_syscall
;
161 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
164 if (__get_user(set
.sig
[0], &frame
->sc
.oldmask
)
166 && __copy_from_user(&set
.sig
[1], &frame
->extramask
,
167 sizeof(frame
->extramask
))))
170 set_current_blocked(&set
);
172 if (restore_sigcontext(regs
, &frame
->sc
, &r0
))
177 force_sig(SIGSEGV
, current
);
181 asmlinkage
int sys_rt_sigreturn(void)
183 struct pt_regs
*regs
= current_pt_regs();
184 struct rt_sigframe __user
*frame
= (struct rt_sigframe __user
*)regs
->regs
[15];
188 /* Always make any pending restarted system calls return -EINTR */
189 current
->restart_block
.fn
= do_no_restart_syscall
;
191 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
194 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
197 set_current_blocked(&set
);
199 if (restore_sigcontext(regs
, &frame
->uc
.uc_mcontext
, &r0
))
202 if (restore_altstack(&frame
->uc
.uc_stack
))
208 force_sig(SIGSEGV
, current
);
213 * Set up a signal frame.
217 setup_sigcontext(struct sigcontext __user
*sc
, struct pt_regs
*regs
,
222 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
223 COPY(regs
[0]); COPY(regs
[1]);
224 COPY(regs
[2]); COPY(regs
[3]);
225 COPY(regs
[4]); COPY(regs
[5]);
226 COPY(regs
[6]); COPY(regs
[7]);
227 COPY(regs
[8]); COPY(regs
[9]);
228 COPY(regs
[10]); COPY(regs
[11]);
229 COPY(regs
[12]); COPY(regs
[13]);
230 COPY(regs
[14]); COPY(regs
[15]);
231 COPY(gbr
); COPY(mach
);
232 COPY(macl
); COPY(pr
);
237 err
|= save_sigcontext_fpu(sc
, regs
);
240 /* non-iBCS2 extensions.. */
241 err
|= __put_user(mask
, &sc
->oldmask
);
247 * Determine which stack to use..
249 static inline void __user
*
250 get_sigframe(struct k_sigaction
*ka
, unsigned long sp
, size_t frame_size
)
252 if (ka
->sa
.sa_flags
& SA_ONSTACK
) {
253 if (sas_ss_flags(sp
) == 0)
254 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
257 return (void __user
*)((sp
- (frame_size
+UNWINDGUARD
)) & -8ul);
260 /* These symbols are defined with the addresses in the vsyscall page.
261 See vsyscall-trapa.S. */
262 extern void __kernel_sigreturn(void);
263 extern void __kernel_rt_sigreturn(void);
265 static int setup_frame(struct ksignal
*ksig
, sigset_t
*set
,
266 struct pt_regs
*regs
)
268 struct sigframe __user
*frame
;
269 int err
= 0, sig
= ksig
->sig
;
271 frame
= get_sigframe(&ksig
->ka
, regs
->regs
[15], sizeof(*frame
));
273 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
276 err
|= setup_sigcontext(&frame
->sc
, regs
, set
->sig
[0]);
279 err
|= __copy_to_user(frame
->extramask
, &set
->sig
[1],
280 sizeof(frame
->extramask
));
282 /* Set up to return from userspace. If provided, use a stub
283 already in userspace. */
284 if (ksig
->ka
.sa
.sa_flags
& SA_RESTORER
) {
285 regs
->pr
= (unsigned long) ksig
->ka
.sa
.sa_restorer
;
286 #ifdef CONFIG_VSYSCALL
287 } else if (likely(current
->mm
->context
.vdso
)) {
288 regs
->pr
= VDSO_SYM(&__kernel_sigreturn
);
291 /* Generate return code (system call to sigreturn) */
292 err
|= __put_user(MOVW(7), &frame
->retcode
[0]);
293 err
|= __put_user(TRAP_NOARG
, &frame
->retcode
[1]);
294 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[2]);
295 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[3]);
296 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[4]);
297 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[5]);
298 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[6]);
299 err
|= __put_user((__NR_sigreturn
), &frame
->retcode
[7]);
300 regs
->pr
= (unsigned long) frame
->retcode
;
301 flush_icache_range(regs
->pr
, regs
->pr
+ sizeof(frame
->retcode
));
307 /* Set up registers for signal handler */
308 regs
->regs
[15] = (unsigned long) frame
;
309 regs
->regs
[4] = sig
; /* Arg for signal handler */
311 regs
->regs
[6] = (unsigned long) &frame
->sc
;
313 if (current
->personality
& FDPIC_FUNCPTRS
) {
314 struct fdpic_func_descriptor __user
*funcptr
=
315 (struct fdpic_func_descriptor __user
*)ksig
->ka
.sa
.sa_handler
;
317 err
|= __get_user(regs
->pc
, &funcptr
->text
);
318 err
|= __get_user(regs
->regs
[12], &funcptr
->GOT
);
320 regs
->pc
= (unsigned long)ksig
->ka
.sa
.sa_handler
;
325 pr_debug("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lx\n",
326 current
->comm
, task_pid_nr(current
), frame
, regs
->pc
, regs
->pr
);
331 static int setup_rt_frame(struct ksignal
*ksig
, sigset_t
*set
,
332 struct pt_regs
*regs
)
334 struct rt_sigframe __user
*frame
;
335 int err
= 0, sig
= ksig
->sig
;
337 frame
= get_sigframe(&ksig
->ka
, regs
->regs
[15], sizeof(*frame
));
339 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
342 err
|= copy_siginfo_to_user(&frame
->info
, &ksig
->info
);
344 /* Create the ucontext. */
345 err
|= __put_user(0, &frame
->uc
.uc_flags
);
346 err
|= __put_user(NULL
, &frame
->uc
.uc_link
);
347 err
|= __save_altstack(&frame
->uc
.uc_stack
, regs
->regs
[15]);
348 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
,
350 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
352 /* Set up to return from userspace. If provided, use a stub
353 already in userspace. */
354 if (ksig
->ka
.sa
.sa_flags
& SA_RESTORER
) {
355 regs
->pr
= (unsigned long) ksig
->ka
.sa
.sa_restorer
;
356 #ifdef CONFIG_VSYSCALL
357 } else if (likely(current
->mm
->context
.vdso
)) {
358 regs
->pr
= VDSO_SYM(&__kernel_rt_sigreturn
);
361 /* Generate return code (system call to rt_sigreturn) */
362 err
|= __put_user(MOVW(7), &frame
->retcode
[0]);
363 err
|= __put_user(TRAP_NOARG
, &frame
->retcode
[1]);
364 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[2]);
365 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[3]);
366 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[4]);
367 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[5]);
368 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[6]);
369 err
|= __put_user((__NR_rt_sigreturn
), &frame
->retcode
[7]);
370 regs
->pr
= (unsigned long) frame
->retcode
;
371 flush_icache_range(regs
->pr
, regs
->pr
+ sizeof(frame
->retcode
));
377 /* Set up registers for signal handler */
378 regs
->regs
[15] = (unsigned long) frame
;
379 regs
->regs
[4] = sig
; /* Arg for signal handler */
380 regs
->regs
[5] = (unsigned long) &frame
->info
;
381 regs
->regs
[6] = (unsigned long) &frame
->uc
;
383 if (current
->personality
& FDPIC_FUNCPTRS
) {
384 struct fdpic_func_descriptor __user
*funcptr
=
385 (struct fdpic_func_descriptor __user
*)ksig
->ka
.sa
.sa_handler
;
387 err
|= __get_user(regs
->pc
, &funcptr
->text
);
388 err
|= __get_user(regs
->regs
[12], &funcptr
->GOT
);
390 regs
->pc
= (unsigned long)ksig
->ka
.sa
.sa_handler
;
395 pr_debug("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lx\n",
396 current
->comm
, task_pid_nr(current
), frame
, regs
->pc
, regs
->pr
);
402 handle_syscall_restart(unsigned long save_r0
, struct pt_regs
*regs
,
403 struct sigaction
*sa
)
405 /* If we're not from a syscall, bail out */
409 /* check for system call restart.. */
410 switch (regs
->regs
[0]) {
411 case -ERESTART_RESTARTBLOCK
:
412 case -ERESTARTNOHAND
:
413 no_system_call_restart
:
414 regs
->regs
[0] = -EINTR
;
418 if (!(sa
->sa_flags
& SA_RESTART
))
419 goto no_system_call_restart
;
421 case -ERESTARTNOINTR
:
422 regs
->regs
[0] = save_r0
;
423 regs
->pc
-= instruction_size(__raw_readw(regs
->pc
- 4));
429 * OK, we're invoking a handler
432 handle_signal(struct ksignal
*ksig
, struct pt_regs
*regs
, unsigned int save_r0
)
434 sigset_t
*oldset
= sigmask_to_save();
437 /* Set up the stack frame */
438 if (ksig
->ka
.sa
.sa_flags
& SA_SIGINFO
)
439 ret
= setup_rt_frame(ksig
, oldset
, regs
);
441 ret
= setup_frame(ksig
, oldset
, regs
);
443 signal_setup_done(ret
, ksig
, test_thread_flag(TIF_SINGLESTEP
));
447 * Note that 'init' is a special process: it doesn't get signals it doesn't
448 * want to handle. Thus you cannot kill init even with a SIGKILL even by
451 * Note that we go through the signals twice: once to check the signals that
452 * the kernel can handle, and then we build all the user-level signal handling
453 * stack-frames in one go after that.
455 static void do_signal(struct pt_regs
*regs
, unsigned int save_r0
)
460 * We want the common case to go fast, which
461 * is why we may in certain cases get here from
462 * kernel mode. Just return without doing anything
465 if (!user_mode(regs
))
468 if (get_signal(&ksig
)) {
469 handle_syscall_restart(save_r0
, regs
, &ksig
.ka
.sa
);
471 /* Whee! Actually deliver the signal. */
472 handle_signal(&ksig
, regs
, save_r0
);
476 /* Did we come from a system call? */
477 if (regs
->tra
>= 0) {
478 /* Restart the system call - no handlers present */
479 if (regs
->regs
[0] == -ERESTARTNOHAND
||
480 regs
->regs
[0] == -ERESTARTSYS
||
481 regs
->regs
[0] == -ERESTARTNOINTR
) {
482 regs
->regs
[0] = save_r0
;
483 regs
->pc
-= instruction_size(__raw_readw(regs
->pc
- 4));
484 } else if (regs
->regs
[0] == -ERESTART_RESTARTBLOCK
) {
485 regs
->pc
-= instruction_size(__raw_readw(regs
->pc
- 4));
486 regs
->regs
[3] = __NR_restart_syscall
;
491 * If there's no signal to deliver, we just put the saved sigmask
494 restore_saved_sigmask();
497 asmlinkage
void do_notify_resume(struct pt_regs
*regs
, unsigned int save_r0
,
498 unsigned long thread_info_flags
)
500 /* deal with pending signal delivery */
501 if (thread_info_flags
& _TIF_SIGPENDING
)
502 do_signal(regs
, save_r0
);
504 if (thread_info_flags
& _TIF_NOTIFY_RESUME
) {
505 clear_thread_flag(TIF_NOTIFY_RESUME
);
506 tracehook_notify_resume(regs
);