1 /* MN10300 Signal handling
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public Licence
8 * as published by the Free Software Foundation; either version
9 * 2 of the Licence, or (at your option) any later version.
12 #include <linux/sched.h>
14 #include <linux/smp.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 <linux/tty.h>
23 #include <linux/personality.h>
24 #include <linux/suspend.h>
25 #include <linux/tracehook.h>
26 #include <asm/cacheflush.h>
27 #include <asm/ucontext.h>
28 #include <asm/uaccess.h>
35 * do a signal return; undo the signal stack.
37 static int restore_sigcontext(struct pt_regs
*regs
,
38 struct sigcontext __user
*sc
, long *_d0
)
42 /* Always make any pending restarted system calls return -EINTR */
43 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
45 if (is_using_fpu(current
))
46 fpu_kill_state(current
);
48 #define COPY(x) err |= __get_user(regs->x, &sc->x)
49 COPY(d1
); COPY(d2
); COPY(d3
);
50 COPY(a0
); COPY(a1
); COPY(a2
); COPY(a3
);
51 COPY(e0
); COPY(e1
); COPY(e2
); COPY(e3
);
52 COPY(e4
); COPY(e5
); COPY(e6
); COPY(e7
);
54 COPY(mdr
); COPY(mdrq
);
55 COPY(mcvf
); COPY(mcrl
); COPY(mcrh
);
60 unsigned int tmpflags
;
61 #ifndef CONFIG_MN10300_USING_JTAG
62 #define USER_EPSW (EPSW_FLAG_Z | EPSW_FLAG_N | EPSW_FLAG_C | EPSW_FLAG_V | \
65 #define USER_EPSW (EPSW_FLAG_Z | EPSW_FLAG_N | EPSW_FLAG_C | EPSW_FLAG_V | \
68 err
|= __get_user(tmpflags
, &sc
->epsw
);
69 regs
->epsw
= (regs
->epsw
& ~USER_EPSW
) |
70 (tmpflags
& USER_EPSW
);
71 regs
->orig_d0
= -1; /* disable syscall checks */
75 struct fpucontext
*buf
;
76 err
|= __get_user(buf
, &sc
->fpucontext
);
78 if (verify_area(VERIFY_READ
, buf
, sizeof(*buf
)))
80 err
|= fpu_restore_sigcontext(buf
);
84 err
|= __get_user(*_d0
, &sc
->d0
);
92 * standard signal return syscall
94 asmlinkage
long sys_sigreturn(void)
96 struct sigframe __user
*frame
;
100 frame
= (struct sigframe __user
*) current_frame()->sp
;
101 if (verify_area(VERIFY_READ
, frame
, sizeof(*frame
)))
103 if (__get_user(set
.sig
[0], &frame
->sc
.oldmask
))
106 if (_NSIG_WORDS
> 1 &&
107 __copy_from_user(&set
.sig
[1], &frame
->extramask
,
108 sizeof(frame
->extramask
)))
111 set_current_blocked(&set
);
113 if (restore_sigcontext(current_frame(), &frame
->sc
, &d0
))
119 force_sig(SIGSEGV
, current
);
124 * realtime signal return syscall
126 asmlinkage
long sys_rt_sigreturn(void)
128 struct rt_sigframe __user
*frame
;
132 frame
= (struct rt_sigframe __user
*) current_frame()->sp
;
133 if (verify_area(VERIFY_READ
, frame
, sizeof(*frame
)))
135 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
138 set_current_blocked(&set
);
140 if (restore_sigcontext(current_frame(), &frame
->uc
.uc_mcontext
, &d0
))
143 if (restore_altstack(&frame
->uc
.uc_stack
))
149 force_sig(SIGSEGV
, current
);
154 * store the userspace context into a signal frame
156 static int setup_sigcontext(struct sigcontext __user
*sc
,
157 struct fpucontext
*fpuctx
,
158 struct pt_regs
*regs
,
163 #define COPY(x) err |= __put_user(regs->x, &sc->x)
164 COPY(d0
); COPY(d1
); COPY(d2
); COPY(d3
);
165 COPY(a0
); COPY(a1
); COPY(a2
); COPY(a3
);
166 COPY(e0
); COPY(e1
); COPY(e2
); COPY(e3
);
167 COPY(e4
); COPY(e5
); COPY(e6
); COPY(e7
);
168 COPY(lar
); COPY(lir
);
169 COPY(mdr
); COPY(mdrq
);
170 COPY(mcvf
); COPY(mcrl
); COPY(mcrh
);
171 COPY(sp
); COPY(epsw
); COPY(pc
);
174 tmp
= fpu_setup_sigcontext(fpuctx
);
178 err
|= __put_user(tmp
? fpuctx
: NULL
, &sc
->fpucontext
);
180 /* non-iBCS2 extensions.. */
181 err
|= __put_user(mask
, &sc
->oldmask
);
187 * determine which stack to use..
189 static inline void __user
*get_sigframe(struct k_sigaction
*ka
,
190 struct pt_regs
*regs
,
195 /* default to using normal stack */
198 /* this is the X/Open sanctioned signal stack switching. */
199 if (ka
->sa
.sa_flags
& SA_ONSTACK
) {
200 if (sas_ss_flags(sp
) == 0)
201 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
204 return (void __user
*) ((sp
- frame_size
) & ~7UL);
208 * set up a normal signal frame
210 static int setup_frame(int sig
, struct k_sigaction
*ka
, sigset_t
*set
,
211 struct pt_regs
*regs
)
213 struct sigframe __user
*frame
;
216 frame
= get_sigframe(ka
, regs
, sizeof(*frame
));
218 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
223 current_thread_info()->exec_domain
&&
224 current_thread_info()->exec_domain
->signal_invmap
)
225 rsig
= current_thread_info()->exec_domain
->signal_invmap
[sig
];
227 if (__put_user(rsig
, &frame
->sig
) < 0 ||
228 __put_user(&frame
->sc
, &frame
->psc
) < 0)
231 if (setup_sigcontext(&frame
->sc
, &frame
->fpuctx
, regs
, set
->sig
[0]))
234 if (_NSIG_WORDS
> 1) {
235 if (__copy_to_user(frame
->extramask
, &set
->sig
[1],
236 sizeof(frame
->extramask
)))
240 /* set up to return from userspace. If provided, use a stub already in
242 if (ka
->sa
.sa_flags
& SA_RESTORER
) {
243 if (__put_user(ka
->sa
.sa_restorer
, &frame
->pretcode
))
246 if (__put_user((void (*)(void))frame
->retcode
,
249 /* this is mov $,d0; syscall 0 */
250 if (__put_user(0x2c, (char *)(frame
->retcode
+ 0)) ||
251 __put_user(__NR_sigreturn
, (char *)(frame
->retcode
+ 1)) ||
252 __put_user(0x00, (char *)(frame
->retcode
+ 2)) ||
253 __put_user(0xf0, (char *)(frame
->retcode
+ 3)) ||
254 __put_user(0xe0, (char *)(frame
->retcode
+ 4)))
256 flush_icache_range((unsigned long) frame
->retcode
,
257 (unsigned long) frame
->retcode
+ 5);
260 /* set up registers for signal handler */
261 regs
->sp
= (unsigned long) frame
;
262 regs
->pc
= (unsigned long) ka
->sa
.sa_handler
;
264 regs
->d1
= (unsigned long) &frame
->sc
;
267 printk(KERN_DEBUG
"SIG deliver %d (%s:%d): sp=%p pc=%lx ra=%p\n",
268 sig
, current
->comm
, current
->pid
, frame
, regs
->pc
,
275 force_sigsegv(sig
, current
);
280 * set up a realtime signal frame
282 static int setup_rt_frame(int sig
, struct k_sigaction
*ka
, siginfo_t
*info
,
283 sigset_t
*set
, struct pt_regs
*regs
)
285 struct rt_sigframe __user
*frame
;
288 frame
= get_sigframe(ka
, regs
, sizeof(*frame
));
290 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
295 current_thread_info()->exec_domain
&&
296 current_thread_info()->exec_domain
->signal_invmap
)
297 rsig
= current_thread_info()->exec_domain
->signal_invmap
[sig
];
299 if (__put_user(rsig
, &frame
->sig
) ||
300 __put_user(&frame
->info
, &frame
->pinfo
) ||
301 __put_user(&frame
->uc
, &frame
->puc
) ||
302 copy_siginfo_to_user(&frame
->info
, info
))
305 /* create the ucontext. */
306 if (__put_user(0, &frame
->uc
.uc_flags
) ||
307 __put_user(0, &frame
->uc
.uc_link
) ||
308 __save_altstack(&frame
->uc
.uc_stack
, regs
->sp
) ||
309 setup_sigcontext(&frame
->uc
.uc_mcontext
,
310 &frame
->fpuctx
, regs
, set
->sig
[0]) ||
311 __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
)))
314 /* set up to return from userspace. If provided, use a stub already in
316 if (ka
->sa
.sa_flags
& SA_RESTORER
) {
317 if (__put_user(ka
->sa
.sa_restorer
, &frame
->pretcode
))
320 if (__put_user((void(*)(void))frame
->retcode
,
322 /* This is mov $,d0; syscall 0 */
323 __put_user(0x2c, (char *)(frame
->retcode
+ 0)) ||
324 __put_user(__NR_rt_sigreturn
,
325 (char *)(frame
->retcode
+ 1)) ||
326 __put_user(0x00, (char *)(frame
->retcode
+ 2)) ||
327 __put_user(0xf0, (char *)(frame
->retcode
+ 3)) ||
328 __put_user(0xe0, (char *)(frame
->retcode
+ 4)))
331 flush_icache_range((u_long
) frame
->retcode
,
332 (u_long
) frame
->retcode
+ 5);
335 /* Set up registers for signal handler */
336 regs
->sp
= (unsigned long) frame
;
337 regs
->pc
= (unsigned long) ka
->sa
.sa_handler
;
339 regs
->d1
= (long) &frame
->info
;
342 printk(KERN_DEBUG
"SIG deliver %d (%s:%d): sp=%p pc=%lx ra=%p\n",
343 sig
, current
->comm
, current
->pid
, frame
, regs
->pc
,
350 force_sigsegv(sig
, current
);
354 static inline void stepback(struct pt_regs
*regs
)
361 * handle the actual delivery of a signal to userspace
363 static int handle_signal(int sig
,
364 siginfo_t
*info
, struct k_sigaction
*ka
,
365 struct pt_regs
*regs
)
367 sigset_t
*oldset
= sigmask_to_save();
370 /* Are we from a system call? */
371 if (regs
->orig_d0
>= 0) {
372 /* If so, check system call restarting.. */
374 case -ERESTART_RESTARTBLOCK
:
375 case -ERESTARTNOHAND
:
380 if (!(ka
->sa
.sa_flags
& SA_RESTART
)) {
386 case -ERESTARTNOINTR
:
387 regs
->d0
= regs
->orig_d0
;
392 /* Set up the stack frame */
393 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
394 ret
= setup_rt_frame(sig
, ka
, info
, oldset
, regs
);
396 ret
= setup_frame(sig
, ka
, oldset
, regs
);
400 signal_delivered(sig
, info
, ka
, regs
,
401 test_thread_flag(TIF_SINGLESTEP
));
406 * handle a potential signal
408 static void do_signal(struct pt_regs
*regs
)
410 struct k_sigaction ka
;
414 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
416 if (handle_signal(signr
, &info
, &ka
, regs
) == 0) {
422 /* did we come from a system call? */
423 if (regs
->orig_d0
>= 0) {
424 /* restart the system call - no handlers present */
426 case -ERESTARTNOHAND
:
428 case -ERESTARTNOINTR
:
429 regs
->d0
= regs
->orig_d0
;
433 case -ERESTART_RESTARTBLOCK
:
434 regs
->d0
= __NR_restart_syscall
;
440 /* if there's no signal to deliver, we just put the saved sigmask
442 restore_saved_sigmask();
446 * notification of userspace execution resumption
447 * - triggered by current->work.notify_resume
449 asmlinkage
void do_notify_resume(struct pt_regs
*regs
, u32 thread_info_flags
)
451 /* Pending single-step? */
452 if (thread_info_flags
& _TIF_SINGLESTEP
) {
453 #ifndef CONFIG_MN10300_USING_JTAG
454 regs
->epsw
|= EPSW_T
;
455 clear_thread_flag(TIF_SINGLESTEP
);
457 BUG(); /* no h/w single-step if using JTAG unit */
461 /* deal with pending signal delivery */
462 if (thread_info_flags
& _TIF_SIGPENDING
)
465 if (thread_info_flags
& _TIF_NOTIFY_RESUME
) {
466 clear_thread_flag(TIF_NOTIFY_RESUME
);
467 tracehook_notify_resume(current_frame());