1
2
3
4
5
6
7
8
9
10
11
12#include <linux/rwsem.h>
13#include <linux/sched.h>
14#include <linux/mm.h>
15#include <linux/smp.h>
16#include <linux/kernel.h>
17#include <linux/signal.h>
18#include <linux/errno.h>
19#include <linux/wait.h>
20#include <linux/personality.h>
21#include <linux/ptrace.h>
22#include <linux/unistd.h>
23#include <linux/stddef.h>
24#include <linux/tracehook.h>
25#include <asm/ucontext.h>
26#include <asm/uaccess.h>
27#include <asm/pgtable.h>
28#include <asm/cacheflush.h>
29#include <asm/fpu.h>
30
31#define REG_RET 9
32#define REG_ARG1 2
33#define REG_ARG2 3
34#define REG_ARG3 4
35#define REG_SP 15
36#define REG_PR 18
37#define REF_REG_RET regs->regs[REG_RET]
38#define REF_REG_SP regs->regs[REG_SP]
39#define DEREF_REG_PR regs->regs[REG_PR]
40
41#define DEBUG_SIG 0
42
43static void
44handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
45 struct pt_regs * regs);
46
47static inline void
48handle_syscall_restart(struct pt_regs *regs, struct sigaction *sa)
49{
50
51 if (regs->syscall_nr < 0)
52 return;
53
54
55 switch (regs->regs[REG_RET]) {
56 case -ERESTART_RESTARTBLOCK:
57 case -ERESTARTNOHAND:
58 no_system_call_restart:
59 regs->regs[REG_RET] = -EINTR;
60 break;
61
62 case -ERESTARTSYS:
63 if (!(sa->sa_flags & SA_RESTART))
64 goto no_system_call_restart;
65
66 case -ERESTARTNOINTR:
67
68 regs->regs[REG_RET] = regs->syscall_nr;
69 regs->pc -= 4;
70 break;
71 }
72}
73
74
75
76
77
78
79
80
81
82
83static void do_signal(struct pt_regs *regs)
84{
85 siginfo_t info;
86 int signr;
87 struct k_sigaction ka;
88
89
90
91
92
93
94
95 if (!user_mode(regs))
96 return;
97
98 signr = get_signal_to_deliver(&info, &ka, regs, 0);
99 if (signr > 0) {
100 handle_syscall_restart(regs, &ka.sa);
101
102
103 handle_signal(signr, &info, &ka, regs);
104 return;
105 }
106
107
108 if (regs->syscall_nr >= 0) {
109
110 switch (regs->regs[REG_RET]) {
111 case -ERESTARTNOHAND:
112 case -ERESTARTSYS:
113 case -ERESTARTNOINTR:
114
115 regs->regs[REG_RET] = regs->syscall_nr;
116 regs->pc -= 4;
117 break;
118
119 case -ERESTART_RESTARTBLOCK:
120 regs->regs[REG_RET] = __NR_restart_syscall;
121 regs->pc -= 4;
122 break;
123 }
124 }
125
126
127 restore_saved_sigmask();
128}
129
130
131
132
133struct sigframe {
134 struct sigcontext sc;
135 unsigned long extramask[_NSIG_WORDS-1];
136 long long retcode[2];
137};
138
139struct rt_sigframe {
140 struct siginfo __user *pinfo;
141 void *puc;
142 struct siginfo info;
143 struct ucontext uc;
144 long long retcode[2];
145};
146
147#ifdef CONFIG_SH_FPU
148static inline int
149restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
150{
151 int err = 0;
152 int fpvalid;
153
154 err |= __get_user (fpvalid, &sc->sc_fpvalid);
155 conditional_used_math(fpvalid);
156 if (! fpvalid)
157 return err;
158
159 if (current == last_task_used_math) {
160 last_task_used_math = NULL;
161 regs->sr |= SR_FD;
162 }
163
164 err |= __copy_from_user(¤t->thread.xstate->hardfpu, &sc->sc_fpregs[0],
165 (sizeof(long long) * 32) + (sizeof(int) * 1));
166
167 return err;
168}
169
170static inline int
171setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
172{
173 int err = 0;
174 int fpvalid;
175
176 fpvalid = !!used_math();
177 err |= __put_user(fpvalid, &sc->sc_fpvalid);
178 if (! fpvalid)
179 return err;
180
181 if (current == last_task_used_math) {
182 enable_fpu();
183 save_fpu(current);
184 disable_fpu();
185 last_task_used_math = NULL;
186 regs->sr |= SR_FD;
187 }
188
189 err |= __copy_to_user(&sc->sc_fpregs[0], ¤t->thread.xstate->hardfpu,
190 (sizeof(long long) * 32) + (sizeof(int) * 1));
191 clear_used_math();
192
193 return err;
194}
195#else
196static inline int
197restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
198{
199 return 0;
200}
201static inline int
202setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
203{
204 return 0;
205}
206#endif
207
208static int
209restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
210{
211 unsigned int err = 0;
212 unsigned long long current_sr, new_sr;
213#define SR_MASK 0xffff8cfd
214
215#define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
216
217 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
218 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
219 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
220 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
221 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
222 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
223 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
224 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
225 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
226 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
227 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
228 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
229 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
230 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
231 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
232 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
233 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
234 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
235
236
237
238
239 current_sr = regs->sr;
240 err |= __get_user(new_sr, &sc->sc_sr);
241 regs->sr &= SR_MASK;
242 regs->sr |= (new_sr & ~SR_MASK);
243
244 COPY(pc);
245
246#undef COPY
247
248
249
250 err |= restore_sigcontext_fpu(regs, sc);
251
252 regs->syscall_nr = -1;
253 err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
254 return err;
255}
256
257asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
258 unsigned long r4, unsigned long r5,
259 unsigned long r6, unsigned long r7,
260 struct pt_regs * regs)
261{
262 struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
263 sigset_t set;
264 long long ret;
265
266
267 current_thread_info()->restart_block.fn = do_no_restart_syscall;
268
269 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
270 goto badframe;
271
272 if (__get_user(set.sig[0], &frame->sc.oldmask)
273 || (_NSIG_WORDS > 1
274 && __copy_from_user(&set.sig[1], &frame->extramask,
275 sizeof(frame->extramask))))
276 goto badframe;
277
278 set_current_blocked(&set);
279
280 if (restore_sigcontext(regs, &frame->sc, &ret))
281 goto badframe;
282 regs->pc -= 4;
283
284 return (int) ret;
285
286badframe:
287 force_sig(SIGSEGV, current);
288 return 0;
289}
290
291asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
292 unsigned long r4, unsigned long r5,
293 unsigned long r6, unsigned long r7,
294 struct pt_regs * regs)
295{
296 struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
297 sigset_t set;
298 long long ret;
299
300
301 current_thread_info()->restart_block.fn = do_no_restart_syscall;
302
303 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
304 goto badframe;
305
306 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
307 goto badframe;
308
309 set_current_blocked(&set);
310
311 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
312 goto badframe;
313 regs->pc -= 4;
314
315 if (restore_altstack(&frame->uc.uc_stack))
316 goto badframe;
317
318 return (int) ret;
319
320badframe:
321 force_sig(SIGSEGV, current);
322 return 0;
323}
324
325
326
327
328static int
329setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
330 unsigned long mask)
331{
332 int err = 0;
333
334
335 err |= setup_sigcontext_fpu(regs, sc);
336
337#define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
338
339 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
340 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
341 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
342 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
343 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
344 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
345 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
346 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
347 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
348 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
349 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
350 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
351 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
352 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
353 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
354 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
355 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
356 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
357 COPY(sr); COPY(pc);
358
359#undef COPY
360
361 err |= __put_user(mask, &sc->oldmask);
362
363 return err;
364}
365
366
367
368
369static inline void __user *
370get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
371{
372 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
373 sp = current->sas_ss_sp + current->sas_ss_size;
374
375 return (void __user *)((sp - frame_size) & -8ul);
376}
377
378void sa_default_restorer(void);
379void sa_default_rt_restorer(void);
380
381static int setup_frame(int sig, struct k_sigaction *ka,
382 sigset_t *set, struct pt_regs *regs)
383{
384 struct sigframe __user *frame;
385 int err = 0;
386 int signal;
387
388 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
389
390 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
391 goto give_sigsegv;
392
393 signal = current_thread_info()->exec_domain
394 && current_thread_info()->exec_domain->signal_invmap
395 && sig < 32
396 ? current_thread_info()->exec_domain->signal_invmap[sig]
397 : sig;
398
399 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
400
401
402 if (err)
403 goto give_sigsegv;
404
405 if (_NSIG_WORDS > 1) {
406 err |= __copy_to_user(frame->extramask, &set->sig[1],
407 sizeof(frame->extramask)); }
408
409
410 if (err)
411 goto give_sigsegv;
412
413
414
415 if (ka->sa.sa_flags & SA_RESTORER) {
416
417
418
419 DEREF_REG_PR = neff_sign_extend((unsigned long)
420 ka->sa.sa_restorer | 0x1);
421 } else {
422
423
424
425
426
427
428
429
430
431
432
433 DEREF_REG_PR = neff_sign_extend((unsigned long)
434 frame->retcode | 0x01);
435
436 if (__copy_to_user(frame->retcode,
437 (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
438 goto give_sigsegv;
439
440
441 flush_cache_sigtramp(DEREF_REG_PR-1);
442 }
443
444
445
446
447
448 regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
449 regs->regs[REG_ARG1] = signal;
450
451
452
453
454
455
456
457
458
459
460 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
461 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
462
463 regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
464
465 set_fs(USER_DS);
466
467
468 pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
469 signal, current->comm, current->pid, frame,
470 regs->pc >> 32, regs->pc & 0xffffffff,
471 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
472
473 return 0;
474
475give_sigsegv:
476 force_sigsegv(sig, current);
477 return -EFAULT;
478}
479
480static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
481 sigset_t *set, struct pt_regs *regs)
482{
483 struct rt_sigframe __user *frame;
484 int err = 0;
485 int signal;
486
487 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
488
489 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
490 goto give_sigsegv;
491
492 signal = current_thread_info()->exec_domain
493 && current_thread_info()->exec_domain->signal_invmap
494 && sig < 32
495 ? current_thread_info()->exec_domain->signal_invmap[sig]
496 : sig;
497
498 err |= __put_user(&frame->info, &frame->pinfo);
499 err |= __put_user(&frame->uc, &frame->puc);
500 err |= copy_siginfo_to_user(&frame->info, info);
501
502
503 if (err)
504 goto give_sigsegv;
505
506
507 err |= __put_user(0, &frame->uc.uc_flags);
508 err |= __put_user(0, &frame->uc.uc_link);
509 err |= __save_altstack(&frame->uc.uc_stack, regs->regs[REG_SP]);
510 err |= setup_sigcontext(&frame->uc.uc_mcontext,
511 regs, set->sig[0]);
512 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
513
514
515 if (err)
516 goto give_sigsegv;
517
518
519
520 if (ka->sa.sa_flags & SA_RESTORER) {
521
522
523
524 DEREF_REG_PR = neff_sign_extend((unsigned long)
525 ka->sa.sa_restorer | 0x1);
526 } else {
527
528
529
530
531
532
533
534
535
536
537
538 DEREF_REG_PR = neff_sign_extend((unsigned long)
539 frame->retcode | 0x01);
540
541 if (__copy_to_user(frame->retcode,
542 (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
543 goto give_sigsegv;
544
545
546 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
547 }
548
549
550
551
552
553 regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
554 regs->regs[REG_ARG1] = signal;
555 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
556 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
557 regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
558
559 set_fs(USER_DS);
560
561 pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
562 signal, current->comm, current->pid, frame,
563 regs->pc >> 32, regs->pc & 0xffffffff,
564 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
565
566 return 0;
567
568give_sigsegv:
569 force_sigsegv(sig, current);
570 return -EFAULT;
571}
572
573
574
575
576static void
577handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
578 struct pt_regs * regs)
579{
580 sigset_t *oldset = sigmask_to_save();
581 int ret;
582
583
584 if (ka->sa.sa_flags & SA_SIGINFO)
585 ret = setup_rt_frame(sig, ka, info, oldset, regs);
586 else
587 ret = setup_frame(sig, ka, oldset, regs);
588
589 if (ret)
590 return;
591
592 signal_delivered(sig, info, ka, regs,
593 test_thread_flag(TIF_SINGLESTEP));
594}
595
596asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
597{
598 if (thread_info_flags & _TIF_SIGPENDING)
599 do_signal(regs);
600
601 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
602 clear_thread_flag(TIF_NOTIFY_RESUME);
603 tracehook_notify_resume(regs);
604 }
605}
606