new helper: sigmask_to_save()
[linux-3.10.git] / arch / score / kernel / signal.c
1 /*
2  * arch/score/kernel/signal.c
3  *
4  * Score Processor version.
5  *
6  * Copyright (C) 2009 Sunplus Core Technology Co., Ltd.
7  *  Chen Liqin <liqin.chen@sunplusct.com>
8  *  Lennox Wu <lennox.wu@sunplusct.com>
9  *
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.
14  *
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.
19  *
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
24  */
25
26 #include <linux/errno.h>
27 #include <linux/signal.h>
28 #include <linux/ptrace.h>
29 #include <linux/unistd.h>
30 #include <linux/uaccess.h>
31 #include <linux/tracehook.h>
32
33 #include <asm/cacheflush.h>
34 #include <asm/syscalls.h>
35 #include <asm/ucontext.h>
36
37 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
38
39 struct rt_sigframe {
40         u32 rs_ass[4];          /* argument save space */
41         u32 rs_code[2];         /* signal trampoline */
42         struct siginfo rs_info;
43         struct ucontext rs_uc;
44 };
45
46 static int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
47 {
48         int err = 0;
49         unsigned long reg;
50
51         reg = regs->cp0_epc; err |= __put_user(reg, &sc->sc_pc);
52         err |= __put_user(regs->cp0_psr, &sc->sc_psr);
53         err |= __put_user(regs->cp0_condition, &sc->sc_condition);
54
55
56 #define save_gp_reg(i) {                                \
57         reg = regs->regs[i];                            \
58         err |= __put_user(reg, &sc->sc_regs[i]);        \
59 } while (0)
60         save_gp_reg(0); save_gp_reg(1); save_gp_reg(2);
61         save_gp_reg(3); save_gp_reg(4); save_gp_reg(5);
62         save_gp_reg(6); save_gp_reg(7); save_gp_reg(8);
63         save_gp_reg(9); save_gp_reg(10); save_gp_reg(11);
64         save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
65         save_gp_reg(15); save_gp_reg(16); save_gp_reg(17);
66         save_gp_reg(18); save_gp_reg(19); save_gp_reg(20);
67         save_gp_reg(21); save_gp_reg(22); save_gp_reg(23);
68         save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
69         save_gp_reg(27); save_gp_reg(28); save_gp_reg(29);
70 #undef save_gp_reg
71
72         reg = regs->ceh; err |= __put_user(reg, &sc->sc_mdceh);
73         reg = regs->cel; err |= __put_user(reg, &sc->sc_mdcel);
74         err |= __put_user(regs->cp0_ecr, &sc->sc_ecr);
75         err |= __put_user(regs->cp0_ema, &sc->sc_ema);
76
77         return err;
78 }
79
80 static int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
81 {
82         int err = 0;
83         u32 reg;
84
85         err |= __get_user(regs->cp0_epc, &sc->sc_pc);
86         err |= __get_user(regs->cp0_condition, &sc->sc_condition);
87
88         err |= __get_user(reg, &sc->sc_mdceh);
89         regs->ceh = (int) reg;
90         err |= __get_user(reg, &sc->sc_mdcel);
91         regs->cel = (int) reg;
92
93         err |= __get_user(reg, &sc->sc_psr);
94         regs->cp0_psr = (int) reg;
95         err |= __get_user(reg, &sc->sc_ecr);
96         regs->cp0_ecr = (int) reg;
97         err |= __get_user(reg, &sc->sc_ema);
98         regs->cp0_ema = (int) reg;
99
100 #define restore_gp_reg(i) do {                          \
101         err |= __get_user(reg, &sc->sc_regs[i]);        \
102         regs->regs[i] = reg;                            \
103 } while (0)
104         restore_gp_reg(0); restore_gp_reg(1); restore_gp_reg(2);
105         restore_gp_reg(3); restore_gp_reg(4); restore_gp_reg(5);
106         restore_gp_reg(6); restore_gp_reg(7); restore_gp_reg(8);
107         restore_gp_reg(9); restore_gp_reg(10); restore_gp_reg(11);
108         restore_gp_reg(12); restore_gp_reg(13); restore_gp_reg(14);
109         restore_gp_reg(15); restore_gp_reg(16); restore_gp_reg(17);
110         restore_gp_reg(18); restore_gp_reg(19); restore_gp_reg(20);
111         restore_gp_reg(21); restore_gp_reg(22); restore_gp_reg(23);
112         restore_gp_reg(24); restore_gp_reg(25); restore_gp_reg(26);
113         restore_gp_reg(27); restore_gp_reg(28); restore_gp_reg(29);
114 #undef restore_gp_reg
115
116         return err;
117 }
118
119 /*
120  * Determine which stack to use..
121  */
122 static void __user *get_sigframe(struct k_sigaction *ka,
123                         struct pt_regs *regs, size_t frame_size)
124 {
125         unsigned long sp;
126
127         /* Default to using normal stack */
128         sp = regs->regs[0];
129         sp -= 32;
130
131         /* This is the X/Open sanctioned signal stack switching.  */
132         if ((ka->sa.sa_flags & SA_ONSTACK) && (!on_sig_stack(sp)))
133                 sp = current->sas_ss_sp + current->sas_ss_size;
134
135         return (void __user*)((sp - frame_size) & ~7);
136 }
137
138 asmlinkage long
139 score_sigaltstack(struct pt_regs *regs)
140 {
141         const stack_t __user *uss = (const stack_t __user *) regs->regs[4];
142         stack_t __user *uoss = (stack_t __user *) regs->regs[5];
143         unsigned long usp = regs->regs[0];
144
145         return do_sigaltstack(uss, uoss, usp);
146 }
147
148 asmlinkage long
149 score_rt_sigreturn(struct pt_regs *regs)
150 {
151         struct rt_sigframe __user *frame;
152         sigset_t set;
153         stack_t st;
154         int sig;
155
156         /* Always make any pending restarted system calls return -EINTR */
157         current_thread_info()->restart_block.fn = do_no_restart_syscall;
158
159         frame = (struct rt_sigframe __user *) regs->regs[0];
160         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
161                 goto badframe;
162         if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
163                 goto badframe;
164
165         sigdelsetmask(&set, ~_BLOCKABLE);
166         set_current_blocked(&set);
167
168         sig = restore_sigcontext(regs, &frame->rs_uc.uc_mcontext);
169         if (sig < 0)
170                 goto badframe;
171         else if (sig)
172                 force_sig(sig, current);
173
174         if (__copy_from_user(&st, &frame->rs_uc.uc_stack, sizeof(st)))
175                 goto badframe;
176
177         /* It is more difficult to avoid calling this function than to
178            call it and ignore errors.  */
179         do_sigaltstack((stack_t __user *)&st, NULL, regs->regs[0]);
180
181         __asm__ __volatile__(
182                 "mv\tr0, %0\n\t"
183                 "la\tr8, syscall_exit\n\t"
184                 "br\tr8\n\t"
185                 : : "r" (regs) : "r8");
186
187 badframe:
188         force_sig(SIGSEGV, current);
189
190         return 0;
191 }
192
193 static int setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
194                 int signr, sigset_t *set, siginfo_t *info)
195 {
196         struct rt_sigframe __user *frame;
197         int err = 0;
198
199         frame = get_sigframe(ka, regs, sizeof(*frame));
200         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
201                 goto give_sigsegv;
202
203         /*
204          * Set up the return code ...
205          *
206          *         li      v0, __NR_rt_sigreturn
207          *         syscall
208          */
209         err |= __put_user(0x87788000 + __NR_rt_sigreturn*2,
210                         frame->rs_code + 0);
211         err |= __put_user(0x80008002, frame->rs_code + 1);
212         flush_cache_sigtramp((unsigned long) frame->rs_code);
213
214         err |= copy_siginfo_to_user(&frame->rs_info, info);
215         err |= __put_user(0, &frame->rs_uc.uc_flags);
216         err |= __put_user(NULL, &frame->rs_uc.uc_link);
217         err |= __put_user((void __user *)current->sas_ss_sp,
218                                 &frame->rs_uc.uc_stack.ss_sp);
219         err |= __put_user(sas_ss_flags(regs->regs[0]),
220                                 &frame->rs_uc.uc_stack.ss_flags);
221         err |= __put_user(current->sas_ss_size,
222                                 &frame->rs_uc.uc_stack.ss_size);
223         err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
224         err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
225
226         if (err)
227                 goto give_sigsegv;
228
229         regs->regs[0] = (unsigned long) frame;
230         regs->regs[3] = (unsigned long) frame->rs_code;
231         regs->regs[4] = signr;
232         regs->regs[5] = (unsigned long) &frame->rs_info;
233         regs->regs[6] = (unsigned long) &frame->rs_uc;
234         regs->regs[29] = (unsigned long) ka->sa.sa_handler;
235         regs->cp0_epc = (unsigned long) ka->sa.sa_handler;
236
237         return 0;
238
239 give_sigsegv:
240         force_sigsegv(signr, current);
241         return -EFAULT;
242 }
243
244 static int handle_signal(unsigned long sig, siginfo_t *info,
245         struct k_sigaction *ka, struct pt_regs *regs)
246 {
247         int ret;
248
249         if (regs->is_syscall) {
250                 switch (regs->regs[4]) {
251                 case ERESTART_RESTARTBLOCK:
252                 case ERESTARTNOHAND:
253                         regs->regs[4] = EINTR;
254                         break;
255                 case ERESTARTSYS:
256                         if (!(ka->sa.sa_flags & SA_RESTART)) {
257                                 regs->regs[4] = EINTR;
258                                 break;
259                         }
260                 case ERESTARTNOINTR:
261                         regs->regs[4] = regs->orig_r4;
262                         regs->regs[7] = regs->orig_r7;
263                         regs->cp0_epc -= 8;
264                 }
265
266                 regs->is_syscall = 0;
267         }
268
269         /*
270          * Set up the stack frame
271          */
272         ret = setup_rt_frame(ka, regs, sig, sigmask_to_save(), info);
273
274         if (ret == 0)
275                 block_sigmask(ka, sig);
276
277         return ret;
278 }
279
280 static void do_signal(struct pt_regs *regs)
281 {
282         struct k_sigaction ka;
283         siginfo_t info;
284         int signr;
285
286         /*
287          * We want the common case to go fast, which is why we may in certain
288          * cases get here from kernel mode. Just return without doing anything
289          * if so.
290          */
291         if (!user_mode(regs))
292                 return;
293
294         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
295         if (signr > 0) {
296                 /* Actually deliver the signal.  */
297                 if (handle_signal(signr, &info, &ka, regs) == 0) {
298                         /*
299                          * A signal was successfully delivered; the saved
300                          * sigmask will have been stored in the signal frame,
301                          * and will be restored by sigreturn, so we can simply
302                          * clear the TIF_RESTORE_SIGMASK flag.
303                          */
304                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
305                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
306                 }
307
308                 return;
309         }
310
311         if (regs->is_syscall) {
312                 if (regs->regs[4] == ERESTARTNOHAND ||
313                     regs->regs[4] == ERESTARTSYS ||
314                     regs->regs[4] == ERESTARTNOINTR) {
315                         regs->regs[4] = regs->orig_r4;
316                         regs->regs[7] = regs->orig_r7;
317                         regs->cp0_epc -= 8;
318                 }
319
320                 if (regs->regs[4] == ERESTART_RESTARTBLOCK) {
321                         regs->regs[27] = __NR_restart_syscall;
322                         regs->regs[4] = regs->orig_r4;
323                         regs->regs[7] = regs->orig_r7;
324                         regs->cp0_epc -= 8;
325                 }
326
327                 regs->is_syscall = 0;   /* Don't deal with this again.  */
328         }
329
330         /*
331          * If there's no signal to deliver, we just put the saved sigmask
332          * back
333          */
334         restore_saved_sigmask();
335 }
336
337 /*
338  * notification of userspace execution resumption
339  * - triggered by the TIF_WORK_MASK flags
340  */
341 asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
342                                 __u32 thread_info_flags)
343 {
344         /* deal with pending signal delivery */
345         if (thread_info_flags & _TIF_SIGPENDING)
346                 do_signal(regs);
347         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
348                 clear_thread_flag(TIF_NOTIFY_RESUME);
349                 tracehook_notify_resume(regs);
350         }
351 }