2 * arch/score/kernel/signal.c
4 * Score Processor version.
6 * Copyright (C) 2009 Sunplus Core Technology Co., Ltd.
7 * Chen Liqin <liqin.chen@sunplusct.com>
8 * Lennox Wu <lennox.wu@sunplusct.com>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, see the file COPYING, or write
22 * to the Free Software Foundation, Inc.,
23 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
26 #include <linux/errno.h>
27 #include <linux/signal.h>
28 #include <linux/unistd.h>
29 #include <linux/uaccess.h>
31 #include <asm/syscalls.h>
32 #include <asm/ucontext.h>
34 #include <asm/cacheflush.h>
36 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
39 u32 rs_ass
[4]; /* argument save space */
40 u32 rs_code
[2]; /* signal trampoline */
41 struct siginfo rs_info
;
42 struct ucontext rs_uc
;
45 int setup_sigcontext(struct pt_regs
*regs
, struct sigcontext __user
*sc
)
50 reg
= regs
->cp0_epc
; err
|= __put_user(reg
, &sc
->sc_pc
);
51 err
|= __put_user(regs
->cp0_psr
, &sc
->sc_psr
);
52 err
|= __put_user(regs
->cp0_condition
, &sc
->sc_condition
);
55 #define save_gp_reg(i) { \
56 reg = regs->regs[i]; \
57 err |= __put_user(reg, &sc->sc_regs[i]); \
59 save_gp_reg(0); save_gp_reg(1); save_gp_reg(2);
60 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5);
61 save_gp_reg(6); save_gp_reg(7); save_gp_reg(8);
62 save_gp_reg(9); save_gp_reg(10); save_gp_reg(11);
63 save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
64 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17);
65 save_gp_reg(18); save_gp_reg(19); save_gp_reg(20);
66 save_gp_reg(21); save_gp_reg(22); save_gp_reg(23);
67 save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
68 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29);
71 reg
= regs
->ceh
; err
|= __put_user(reg
, &sc
->sc_mdceh
);
72 reg
= regs
->cel
; err
|= __put_user(reg
, &sc
->sc_mdcel
);
73 err
|= __put_user(regs
->cp0_ecr
, &sc
->sc_ecr
);
74 err
|= __put_user(regs
->cp0_ema
, &sc
->sc_ema
);
79 int restore_sigcontext(struct pt_regs
*regs
, struct sigcontext __user
*sc
)
84 err
|= __get_user(regs
->cp0_epc
, &sc
->sc_pc
);
85 err
|= __get_user(regs
->cp0_condition
, &sc
->sc_condition
);
87 err
|= __get_user(reg
, &sc
->sc_mdceh
);
88 regs
->ceh
= (int) reg
;
89 err
|= __get_user(reg
, &sc
->sc_mdcel
);
90 regs
->cel
= (int) reg
;
92 err
|= __get_user(reg
, &sc
->sc_psr
);
93 regs
->cp0_psr
= (int) reg
;
94 err
|= __get_user(reg
, &sc
->sc_ecr
);
95 regs
->cp0_ecr
= (int) reg
;
96 err
|= __get_user(reg
, &sc
->sc_ema
);
97 regs
->cp0_ema
= (int) reg
;
99 #define restore_gp_reg(i) do { \
100 err |= __get_user(reg, &sc->sc_regs[i]); \
101 regs->regs[i] = reg; \
103 restore_gp_reg(0); restore_gp_reg(1); restore_gp_reg(2);
104 restore_gp_reg(3); restore_gp_reg(4); restore_gp_reg(5);
105 restore_gp_reg(6); restore_gp_reg(7); restore_gp_reg(8);
106 restore_gp_reg(9); restore_gp_reg(10); restore_gp_reg(11);
107 restore_gp_reg(12); restore_gp_reg(13); restore_gp_reg(14);
108 restore_gp_reg(15); restore_gp_reg(16); restore_gp_reg(17);
109 restore_gp_reg(18); restore_gp_reg(19); restore_gp_reg(20);
110 restore_gp_reg(21); restore_gp_reg(22); restore_gp_reg(23);
111 restore_gp_reg(24); restore_gp_reg(25); restore_gp_reg(26);
112 restore_gp_reg(27); restore_gp_reg(28); restore_gp_reg(29);
113 #undef restore_gp_reg
119 * Determine which stack to use..
121 void __user
*get_sigframe(struct k_sigaction
*ka
, struct pt_regs
*regs
,
126 /* Default to using normal stack */
130 /* This is the X/Open sanctioned signal stack switching. */
131 if ((ka
->sa
.sa_flags
& SA_ONSTACK
) && (!on_sig_stack(sp
)))
132 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
134 return (void *)((sp
- frame_size
) & ~7);
137 int score_sigaltstack(struct pt_regs
*regs
)
139 const stack_t
*uss
= (const stack_t
*) regs
->regs
[4];
140 stack_t
*uoss
= (stack_t
*) regs
->regs
[5];
141 unsigned long usp
= regs
->regs
[0];
143 return do_sigaltstack(uss
, uoss
, usp
);
146 void score_rt_sigreturn(struct pt_regs
*regs
)
148 struct rt_sigframe __user
*frame
;
153 frame
= (struct rt_sigframe __user
*) regs
->regs
[0];
154 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
156 if (__copy_from_user(&set
, &frame
->rs_uc
.uc_sigmask
, sizeof(set
)))
159 sigdelsetmask(&set
, ~_BLOCKABLE
);
160 spin_lock_irq(¤t
->sighand
->siglock
);
161 current
->blocked
= set
;
163 spin_unlock_irq(¤t
->sighand
->siglock
);
165 sig
= restore_sigcontext(regs
, &frame
->rs_uc
.uc_mcontext
);
169 force_sig(sig
, current
);
171 if (__copy_from_user(&st
, &frame
->rs_uc
.uc_stack
, sizeof(st
)))
174 /* It is more difficult to avoid calling this function than to
175 call it and ignore errors. */
176 do_sigaltstack((stack_t __user
*)&st
, NULL
, regs
->regs
[0]);
178 __asm__
__volatile__(
180 "la\tr8, syscall_exit\n\t"
182 : : "r" (regs
) : "r8");
185 force_sig(SIGSEGV
, current
);
188 int setup_rt_frame(struct k_sigaction
*ka
, struct pt_regs
*regs
,
189 int signr
, sigset_t
*set
, siginfo_t
*info
)
191 struct rt_sigframe
*frame
;
194 frame
= get_sigframe(ka
, regs
, sizeof(*frame
));
195 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
199 * Set up the return code ...
201 * li v0, __NR_rt_sigreturn
204 err
|= __put_user(0x87788000 + __NR_rt_sigreturn
*2,
206 err
|= __put_user(0x80008002, frame
->rs_code
+ 1);
207 flush_cache_sigtramp((unsigned long) frame
->rs_code
);
209 err
|= copy_siginfo_to_user(&frame
->rs_info
, info
);
210 err
|= __put_user(0, &frame
->rs_uc
.uc_flags
);
211 err
|= __put_user(0, &frame
->rs_uc
.uc_link
);
212 err
|= __put_user((void *)current
->sas_ss_sp
,
213 &frame
->rs_uc
.uc_stack
.ss_sp
);
214 err
|= __put_user(sas_ss_flags(regs
->regs
[0]),
215 &frame
->rs_uc
.uc_stack
.ss_flags
);
216 err
|= __put_user(current
->sas_ss_size
,
217 &frame
->rs_uc
.uc_stack
.ss_size
);
218 err
|= setup_sigcontext(regs
, &frame
->rs_uc
.uc_mcontext
);
219 err
|= __copy_to_user(&frame
->rs_uc
.uc_sigmask
, set
, sizeof(*set
));
224 regs
->regs
[0] = (unsigned long) frame
;
225 regs
->regs
[3] = (unsigned long) frame
->rs_code
;
226 regs
->regs
[4] = signr
;
227 regs
->regs
[5] = (unsigned long) &frame
->rs_info
;
228 regs
->regs
[6] = (unsigned long) &frame
->rs_uc
;
229 regs
->regs
[29] = (unsigned long) ka
->sa
.sa_handler
;
230 regs
->cp0_epc
= (unsigned long) ka
->sa
.sa_handler
;
235 if (signr
== SIGSEGV
)
236 ka
->sa
.sa_handler
= SIG_DFL
;
237 force_sig(SIGSEGV
, current
);
241 int handle_signal(unsigned long sig
, siginfo_t
*info
,
242 struct k_sigaction
*ka
, sigset_t
*oldset
, struct pt_regs
*regs
)
246 if (regs
->is_syscall
) {
247 switch (regs
->regs
[4]) {
248 case ERESTART_RESTARTBLOCK
:
250 regs
->regs
[4] = EINTR
;
253 if (!(ka
->sa
.sa_flags
& SA_RESTART
)) {
254 regs
->regs
[4] = EINTR
;
258 regs
->regs
[4] = regs
->orig_r4
;
259 regs
->regs
[7] = regs
->orig_r7
;
263 regs
->is_syscall
= 0;
267 * Set up the stack frame
269 ret
= setup_rt_frame(ka
, regs
, sig
, oldset
, info
);
271 spin_lock_irq(¤t
->sighand
->siglock
);
272 sigorsets(¤t
->blocked
, ¤t
->blocked
, &ka
->sa
.sa_mask
);
273 if (!(ka
->sa
.sa_flags
& SA_NODEFER
))
274 sigaddset(¤t
->blocked
, sig
);
276 spin_unlock_irq(¤t
->sighand
->siglock
);
281 void do_signal(struct pt_regs
*regs
)
283 struct k_sigaction ka
;
289 * We want the common case to go fast, which is why we may in certain
290 * cases get here from kernel mode. Just return without doing anything
293 if (!user_mode(regs
))
296 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
297 oldset
= ¤t
->saved_sigmask
;
299 oldset
= ¤t
->blocked
;
301 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
303 /* Actually deliver the signal. */
304 if (handle_signal(signr
, &info
, &ka
, oldset
, regs
) == 0) {
306 * A signal was successfully delivered; the saved
307 * sigmask will have been stored in the signal frame,
308 * and will be restored by sigreturn, so we can simply
309 * clear the TIF_RESTORE_SIGMASK flag.
311 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
312 clear_thread_flag(TIF_RESTORE_SIGMASK
);
318 if (regs
->is_syscall
) {
319 if (regs
->regs
[4] == ERESTARTNOHAND
||
320 regs
->regs
[4] == ERESTARTSYS
||
321 regs
->regs
[4] == ERESTARTNOINTR
) {
322 regs
->regs
[4] = regs
->orig_r4
;
323 regs
->regs
[7] = regs
->orig_r7
;
327 if (regs
->regs
[4] == ERESTART_RESTARTBLOCK
) {
328 regs
->regs
[27] = __NR_restart_syscall
;
329 regs
->regs
[4] = regs
->orig_r4
;
330 regs
->regs
[7] = regs
->orig_r7
;
334 regs
->is_syscall
= 0; /* Don't deal with this again. */
338 * If there's no signal to deliver, we just put the saved sigmask
341 if (test_thread_flag(TIF_RESTORE_SIGMASK
)) {
342 clear_thread_flag(TIF_RESTORE_SIGMASK
);
343 sigprocmask(SIG_SETMASK
, ¤t
->saved_sigmask
, NULL
);
348 * notification of userspace execution resumption
349 * - triggered by the TIF_WORK_MASK flags
351 asmlinkage
void do_notify_resume(struct pt_regs
*regs
, void *unused
,
352 __u32 thread_info_flags
)
354 /* deal with pending signal delivery */
355 if (thread_info_flags
& (_TIF_SIGPENDING
| _TIF_RESTORE_SIGMASK
))