1
2
3
4
5
6
7
8
9
10
11
12#include <linux/sched.h>
13#include <linux/mm.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>
29#include <asm/fpu.h>
30#include "sigframe.h"
31
32#define DEBUG_SIG 0
33
34
35
36
37static int restore_sigcontext(struct pt_regs *regs,
38 struct sigcontext __user *sc, long *_d0)
39{
40 unsigned int err = 0;
41
42
43 current->restart_block.fn = do_no_restart_syscall;
44
45 if (is_using_fpu(current))
46 fpu_kill_state(current);
47
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);
53 COPY(lar); COPY(lir);
54 COPY(mdr); COPY(mdrq);
55 COPY(mcvf); COPY(mcrl); COPY(mcrh);
56 COPY(sp); COPY(pc);
57#undef COPY
58
59 {
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 | \
63 EPSW_T | EPSW_nAR)
64#else
65#define USER_EPSW (EPSW_FLAG_Z | EPSW_FLAG_N | EPSW_FLAG_C | EPSW_FLAG_V | \
66 EPSW_nAR)
67#endif
68 err |= __get_user(tmpflags, &sc->epsw);
69 regs->epsw = (regs->epsw & ~USER_EPSW) |
70 (tmpflags & USER_EPSW);
71 regs->orig_d0 = -1;
72 }
73
74 {
75 struct fpucontext *buf;
76 err |= __get_user(buf, &sc->fpucontext);
77 if (buf) {
78 if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
79 goto badframe;
80 err |= fpu_restore_sigcontext(buf);
81 }
82 }
83
84 err |= __get_user(*_d0, &sc->d0);
85 return err;
86
87badframe:
88 return 1;
89}
90
91
92
93
94asmlinkage long sys_sigreturn(void)
95{
96 struct sigframe __user *frame;
97 sigset_t set;
98 long d0;
99
100 frame = (struct sigframe __user *) current_frame()->sp;
101 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
102 goto badframe;
103 if (__get_user(set.sig[0], &frame->sc.oldmask))
104 goto badframe;
105
106 if (_NSIG_WORDS > 1 &&
107 __copy_from_user(&set.sig[1], &frame->extramask,
108 sizeof(frame->extramask)))
109 goto badframe;
110
111 set_current_blocked(&set);
112
113 if (restore_sigcontext(current_frame(), &frame->sc, &d0))
114 goto badframe;
115
116 return d0;
117
118badframe:
119 force_sig(SIGSEGV, current);
120 return 0;
121}
122
123
124
125
126asmlinkage long sys_rt_sigreturn(void)
127{
128 struct rt_sigframe __user *frame;
129 sigset_t set;
130 long d0;
131
132 frame = (struct rt_sigframe __user *) current_frame()->sp;
133 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
134 goto badframe;
135 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
136 goto badframe;
137
138 set_current_blocked(&set);
139
140 if (restore_sigcontext(current_frame(), &frame->uc.uc_mcontext, &d0))
141 goto badframe;
142
143 if (restore_altstack(&frame->uc.uc_stack))
144 goto badframe;
145
146 return d0;
147
148badframe:
149 force_sig(SIGSEGV, current);
150 return 0;
151}
152
153
154
155
156static int setup_sigcontext(struct sigcontext __user *sc,
157 struct fpucontext *fpuctx,
158 struct pt_regs *regs,
159 unsigned long mask)
160{
161 int tmp, err = 0;
162
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);
172#undef COPY
173
174 tmp = fpu_setup_sigcontext(fpuctx);
175 if (tmp < 0)
176 err = 1;
177 else
178 err |= __put_user(tmp ? fpuctx : NULL, &sc->fpucontext);
179
180
181 err |= __put_user(mask, &sc->oldmask);
182
183 return err;
184}
185
186
187
188
189static inline void __user *get_sigframe(struct ksignal *ksig,
190 struct pt_regs *regs,
191 size_t frame_size)
192{
193 unsigned long sp = sigsp(regs->sp, ksig);
194
195 return (void __user *) ((sp - frame_size) & ~7UL);
196}
197
198
199
200
201static int setup_frame(struct ksignal *ksig, sigset_t *set,
202 struct pt_regs *regs)
203{
204 struct sigframe __user *frame;
205 int sig = ksig->sig;
206
207 frame = get_sigframe(ksig, regs, sizeof(*frame));
208
209 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
210 return -EFAULT;
211
212 if (__put_user(sig, &frame->sig) < 0 ||
213 __put_user(&frame->sc, &frame->psc) < 0)
214 return -EFAULT;
215
216 if (setup_sigcontext(&frame->sc, &frame->fpuctx, regs, set->sig[0]))
217 return -EFAULT;
218
219 if (_NSIG_WORDS > 1) {
220 if (__copy_to_user(frame->extramask, &set->sig[1],
221 sizeof(frame->extramask)))
222 return -EFAULT;
223 }
224
225
226
227 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
228 if (__put_user(ksig->ka.sa.sa_restorer, &frame->pretcode))
229 return -EFAULT;
230 } else {
231 if (__put_user((void (*)(void))frame->retcode,
232 &frame->pretcode))
233 return -EFAULT;
234
235 if (__put_user(0x2c, (char *)(frame->retcode + 0)) ||
236 __put_user(__NR_sigreturn, (char *)(frame->retcode + 1)) ||
237 __put_user(0x00, (char *)(frame->retcode + 2)) ||
238 __put_user(0xf0, (char *)(frame->retcode + 3)) ||
239 __put_user(0xe0, (char *)(frame->retcode + 4)))
240 return -EFAULT;
241 flush_icache_range((unsigned long) frame->retcode,
242 (unsigned long) frame->retcode + 5);
243 }
244
245
246 regs->sp = (unsigned long) frame;
247 regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
248 regs->d0 = sig;
249 regs->d1 = (unsigned long) &frame->sc;
250
251#if DEBUG_SIG
252 printk(KERN_DEBUG "SIG deliver %d (%s:%d): sp=%p pc=%lx ra=%p\n",
253 sig, current->comm, current->pid, frame, regs->pc,
254 frame->pretcode);
255#endif
256
257 return 0;
258}
259
260
261
262
263static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
264 struct pt_regs *regs)
265{
266 struct rt_sigframe __user *frame;
267 int sig = ksig->sig;
268
269 frame = get_sigframe(ksig, regs, sizeof(*frame));
270
271 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
272 return -EFAULT;
273
274 if (__put_user(sig, &frame->sig) ||
275 __put_user(&frame->info, &frame->pinfo) ||
276 __put_user(&frame->uc, &frame->puc) ||
277 copy_siginfo_to_user(&frame->info, &ksig->info))
278 return -EFAULT;
279
280
281 if (__put_user(0, &frame->uc.uc_flags) ||
282 __put_user(0, &frame->uc.uc_link) ||
283 __save_altstack(&frame->uc.uc_stack, regs->sp) ||
284 setup_sigcontext(&frame->uc.uc_mcontext,
285 &frame->fpuctx, regs, set->sig[0]) ||
286 __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)))
287 return -EFAULT;
288
289
290
291 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
292 if (__put_user(ksig->ka.sa.sa_restorer, &frame->pretcode))
293 return -EFAULT;
294
295 } else {
296 if (__put_user((void(*)(void))frame->retcode,
297 &frame->pretcode) ||
298
299 __put_user(0x2c, (char *)(frame->retcode + 0)) ||
300 __put_user(__NR_rt_sigreturn,
301 (char *)(frame->retcode + 1)) ||
302 __put_user(0x00, (char *)(frame->retcode + 2)) ||
303 __put_user(0xf0, (char *)(frame->retcode + 3)) ||
304 __put_user(0xe0, (char *)(frame->retcode + 4)))
305 return -EFAULT;
306
307 flush_icache_range((u_long) frame->retcode,
308 (u_long) frame->retcode + 5);
309 }
310
311
312 regs->sp = (unsigned long) frame;
313 regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
314 regs->d0 = sig;
315 regs->d1 = (long) &frame->info;
316
317#if DEBUG_SIG
318 printk(KERN_DEBUG "SIG deliver %d (%s:%d): sp=%p pc=%lx ra=%p\n",
319 sig, current->comm, current->pid, frame, regs->pc,
320 frame->pretcode);
321#endif
322
323 return 0;
324}
325
326static inline void stepback(struct pt_regs *regs)
327{
328 regs->pc -= 2;
329 regs->orig_d0 = -1;
330}
331
332
333
334
335static int handle_signal(struct ksignal *ksig, struct pt_regs *regs)
336{
337 sigset_t *oldset = sigmask_to_save();
338 int ret;
339
340
341 if (regs->orig_d0 >= 0) {
342
343 switch (regs->d0) {
344 case -ERESTART_RESTARTBLOCK:
345 case -ERESTARTNOHAND:
346 regs->d0 = -EINTR;
347 break;
348
349 case -ERESTARTSYS:
350 if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
351 regs->d0 = -EINTR;
352 break;
353 }
354
355
356 case -ERESTARTNOINTR:
357 regs->d0 = regs->orig_d0;
358 stepback(regs);
359 }
360 }
361
362
363 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
364 ret = setup_rt_frame(ksig, oldset, regs);
365 else
366 ret = setup_frame(ksig, oldset, regs);
367
368 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
369 return 0;
370}
371
372
373
374
375static void do_signal(struct pt_regs *regs)
376{
377 struct ksignal ksig;
378
379 if (get_signal(&ksig)) {
380 handle_signal(&ksig, regs);
381 return;
382 }
383
384
385 if (regs->orig_d0 >= 0) {
386
387 switch (regs->d0) {
388 case -ERESTARTNOHAND:
389 case -ERESTARTSYS:
390 case -ERESTARTNOINTR:
391 regs->d0 = regs->orig_d0;
392 stepback(regs);
393 break;
394
395 case -ERESTART_RESTARTBLOCK:
396 regs->d0 = __NR_restart_syscall;
397 stepback(regs);
398 break;
399 }
400 }
401
402
403
404 restore_saved_sigmask();
405}
406
407
408
409
410
411asmlinkage void do_notify_resume(struct pt_regs *regs, u32 thread_info_flags)
412{
413
414 if (thread_info_flags & _TIF_SINGLESTEP) {
415#ifndef CONFIG_MN10300_USING_JTAG
416 regs->epsw |= EPSW_T;
417 clear_thread_flag(TIF_SINGLESTEP);
418#else
419 BUG();
420#endif
421 }
422
423
424 if (thread_info_flags & _TIF_SIGPENDING)
425 do_signal(regs);
426
427 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
428 clear_thread_flag(TIF_NOTIFY_RESUME);
429 tracehook_notify_resume(current_frame());
430 }
431}
432