1
2
3
4
5
6
7
8
9
10
11#include <linux/cache.h>
12#include <linux/context_tracking.h>
13#include <linux/irqflags.h>
14#include <linux/sched.h>
15#include <linux/mm.h>
16#include <linux/personality.h>
17#include <linux/smp.h>
18#include <linux/kernel.h>
19#include <linux/signal.h>
20#include <linux/errno.h>
21#include <linux/wait.h>
22#include <linux/ptrace.h>
23#include <linux/unistd.h>
24#include <linux/compiler.h>
25#include <linux/syscalls.h>
26#include <linux/uaccess.h>
27#include <linux/tracehook.h>
28
29#include <asm/abi.h>
30#include <asm/asm.h>
31#include <linux/bitops.h>
32#include <asm/cacheflush.h>
33#include <asm/fpu.h>
34#include <asm/sim.h>
35#include <asm/ucontext.h>
36#include <asm/cpu-features.h>
37#include <asm/war.h>
38#include <asm/vdso.h>
39#include <asm/dsp.h>
40#include <asm/inst.h>
41
42#include "signal-common.h"
43
44static int (*save_fp_context)(struct sigcontext __user *sc);
45static int (*restore_fp_context)(struct sigcontext __user *sc);
46
47extern asmlinkage int _save_fp_context(struct sigcontext __user *sc);
48extern asmlinkage int _restore_fp_context(struct sigcontext __user *sc);
49
50struct sigframe {
51 u32 sf_ass[4];
52 u32 sf_pad[2];
53 struct sigcontext sf_sc;
54 sigset_t sf_mask;
55};
56
57struct rt_sigframe {
58 u32 rs_ass[4];
59 u32 rs_pad[2];
60 struct siginfo rs_info;
61 struct ucontext rs_uc;
62};
63
64
65
66
67
68static int copy_fp_to_sigcontext(struct sigcontext __user *sc)
69{
70 int i;
71 int err = 0;
72
73 for (i = 0; i < NUM_FPU_REGS; i++) {
74 err |=
75 __put_user(get_fpr64(¤t->thread.fpu.fpr[i], 0),
76 &sc->sc_fpregs[i]);
77 }
78 err |= __put_user(current->thread.fpu.fcr31, &sc->sc_fpc_csr);
79
80 return err;
81}
82
83static int copy_fp_from_sigcontext(struct sigcontext __user *sc)
84{
85 int i;
86 int err = 0;
87 u64 fpr_val;
88
89 for (i = 0; i < NUM_FPU_REGS; i++) {
90 err |= __get_user(fpr_val, &sc->sc_fpregs[i]);
91 set_fpr64(¤t->thread.fpu.fpr[i], 0, fpr_val);
92 }
93 err |= __get_user(current->thread.fpu.fcr31, &sc->sc_fpc_csr);
94
95 return err;
96}
97
98
99
100
101static int protected_save_fp_context(struct sigcontext __user *sc)
102{
103 int err;
104#ifndef CONFIG_EVA
105 while (1) {
106 lock_fpu_owner();
107 if (is_fpu_owner()) {
108 err = save_fp_context(sc);
109 unlock_fpu_owner();
110 } else {
111 unlock_fpu_owner();
112 err = copy_fp_to_sigcontext(sc);
113 }
114 if (likely(!err))
115 break;
116
117 err = __put_user(0, &sc->sc_fpregs[0]) |
118 __put_user(0, &sc->sc_fpregs[31]) |
119 __put_user(0, &sc->sc_fpc_csr);
120 if (err)
121 break;
122 }
123#else
124
125
126
127
128 lose_fpu(1);
129 err = save_fp_context(sc);
130#endif
131 return err;
132}
133
134static int protected_restore_fp_context(struct sigcontext __user *sc)
135{
136 int err, tmp __maybe_unused;
137#ifndef CONFIG_EVA
138 while (1) {
139 lock_fpu_owner();
140 if (is_fpu_owner()) {
141 err = restore_fp_context(sc);
142 unlock_fpu_owner();
143 } else {
144 unlock_fpu_owner();
145 err = copy_fp_from_sigcontext(sc);
146 }
147 if (likely(!err))
148 break;
149
150 err = __get_user(tmp, &sc->sc_fpregs[0]) |
151 __get_user(tmp, &sc->sc_fpregs[31]) |
152 __get_user(tmp, &sc->sc_fpc_csr);
153 if (err)
154 break;
155 }
156#else
157
158
159
160
161 lose_fpu(0);
162 err = restore_fp_context(sc);
163#endif
164 return err;
165}
166
167int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
168{
169 int err = 0;
170 int i;
171 unsigned int used_math;
172
173 err |= __put_user(regs->cp0_epc, &sc->sc_pc);
174
175 err |= __put_user(0, &sc->sc_regs[0]);
176 for (i = 1; i < 32; i++)
177 err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
178
179#ifdef CONFIG_CPU_HAS_SMARTMIPS
180 err |= __put_user(regs->acx, &sc->sc_acx);
181#endif
182 err |= __put_user(regs->hi, &sc->sc_mdhi);
183 err |= __put_user(regs->lo, &sc->sc_mdlo);
184 if (cpu_has_dsp) {
185 err |= __put_user(mfhi1(), &sc->sc_hi1);
186 err |= __put_user(mflo1(), &sc->sc_lo1);
187 err |= __put_user(mfhi2(), &sc->sc_hi2);
188 err |= __put_user(mflo2(), &sc->sc_lo2);
189 err |= __put_user(mfhi3(), &sc->sc_hi3);
190 err |= __put_user(mflo3(), &sc->sc_lo3);
191 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
192 }
193
194 used_math = !!used_math();
195 err |= __put_user(used_math, &sc->sc_used_math);
196
197 if (used_math) {
198
199
200
201
202 err |= protected_save_fp_context(sc);
203 }
204 return err;
205}
206
207int fpcsr_pending(unsigned int __user *fpcsr)
208{
209 int err, sig = 0;
210 unsigned int csr, enabled;
211
212 err = __get_user(csr, fpcsr);
213 enabled = FPU_CSR_UNI_X | ((csr & FPU_CSR_ALL_E) << 5);
214
215
216
217
218 if (csr & enabled) {
219 csr &= ~enabled;
220 err |= __put_user(csr, fpcsr);
221 sig = SIGFPE;
222 }
223 return err ?: sig;
224}
225
226static int
227check_and_restore_fp_context(struct sigcontext __user *sc)
228{
229 int err, sig;
230
231 err = sig = fpcsr_pending(&sc->sc_fpc_csr);
232 if (err > 0)
233 err = 0;
234 err |= protected_restore_fp_context(sc);
235 return err ?: sig;
236}
237
238int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
239{
240 unsigned int used_math;
241 unsigned long treg;
242 int err = 0;
243 int i;
244
245
246 current->restart_block.fn = do_no_restart_syscall;
247
248 err |= __get_user(regs->cp0_epc, &sc->sc_pc);
249
250#ifdef CONFIG_CPU_HAS_SMARTMIPS
251 err |= __get_user(regs->acx, &sc->sc_acx);
252#endif
253 err |= __get_user(regs->hi, &sc->sc_mdhi);
254 err |= __get_user(regs->lo, &sc->sc_mdlo);
255 if (cpu_has_dsp) {
256 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
257 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
258 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
259 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
260 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
261 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
262 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
263 }
264
265 for (i = 1; i < 32; i++)
266 err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
267
268 err |= __get_user(used_math, &sc->sc_used_math);
269 conditional_used_math(used_math);
270
271 if (used_math) {
272
273 if (!err)
274 err = check_and_restore_fp_context(sc);
275 } else {
276
277 lose_fpu(0);
278 }
279
280 return err;
281}
282
283void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs,
284 size_t frame_size)
285{
286 unsigned long sp;
287
288
289 sp = regs->regs[29];
290
291
292
293
294
295
296 sp -= 32;
297
298 sp = sigsp(sp, ksig);
299
300 return (void __user *)((sp - frame_size) & (ICACHE_REFILLS_WORKAROUND_WAR ? ~(cpu_icache_line_size()-1) : ALMASK));
301}
302
303
304
305
306
307#ifdef CONFIG_TRAD_SIGNALS
308SYSCALL_DEFINE1(sigsuspend, sigset_t __user *, uset)
309{
310 return sys_rt_sigsuspend(uset, sizeof(sigset_t));
311}
312#endif
313
314#ifdef CONFIG_TRAD_SIGNALS
315SYSCALL_DEFINE3(sigaction, int, sig, const struct sigaction __user *, act,
316 struct sigaction __user *, oact)
317{
318 struct k_sigaction new_ka, old_ka;
319 int ret;
320 int err = 0;
321
322 if (act) {
323 old_sigset_t mask;
324
325 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
326 return -EFAULT;
327 err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
328 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
329 err |= __get_user(mask, &act->sa_mask.sig[0]);
330 if (err)
331 return -EFAULT;
332
333 siginitset(&new_ka.sa.sa_mask, mask);
334 }
335
336 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
337
338 if (!ret && oact) {
339 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
340 return -EFAULT;
341 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
342 err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
343 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
344 err |= __put_user(0, &oact->sa_mask.sig[1]);
345 err |= __put_user(0, &oact->sa_mask.sig[2]);
346 err |= __put_user(0, &oact->sa_mask.sig[3]);
347 if (err)
348 return -EFAULT;
349 }
350
351 return ret;
352}
353#endif
354
355#ifdef CONFIG_TRAD_SIGNALS
356asmlinkage void sys_sigreturn(nabi_no_regargs struct pt_regs regs)
357{
358 struct sigframe __user *frame;
359 sigset_t blocked;
360 int sig;
361
362 frame = (struct sigframe __user *) regs.regs[29];
363 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
364 goto badframe;
365 if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
366 goto badframe;
367
368 set_current_blocked(&blocked);
369
370 sig = restore_sigcontext(®s, &frame->sf_sc);
371 if (sig < 0)
372 goto badframe;
373 else if (sig)
374 force_sig(sig, current);
375
376
377
378
379 __asm__ __volatile__(
380 "move\t$29, %0\n\t"
381 "j\tsyscall_exit"
382 :
383 :"r" (®s));
384
385
386badframe:
387 force_sig(SIGSEGV, current);
388}
389#endif
390
391asmlinkage void sys_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
392{
393 struct rt_sigframe __user *frame;
394 sigset_t set;
395 int sig;
396
397 frame = (struct rt_sigframe __user *) regs.regs[29];
398 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
399 goto badframe;
400 if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
401 goto badframe;
402
403 set_current_blocked(&set);
404
405 sig = restore_sigcontext(®s, &frame->rs_uc.uc_mcontext);
406 if (sig < 0)
407 goto badframe;
408 else if (sig)
409 force_sig(sig, current);
410
411 if (restore_altstack(&frame->rs_uc.uc_stack))
412 goto badframe;
413
414
415
416
417 __asm__ __volatile__(
418 "move\t$29, %0\n\t"
419 "j\tsyscall_exit"
420 :
421 :"r" (®s));
422
423
424badframe:
425 force_sig(SIGSEGV, current);
426}
427
428#ifdef CONFIG_TRAD_SIGNALS
429static int setup_frame(void *sig_return, struct ksignal *ksig,
430 struct pt_regs *regs, sigset_t *set)
431{
432 struct sigframe __user *frame;
433 int err = 0;
434
435 frame = get_sigframe(ksig, regs, sizeof(*frame));
436 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
437 return -EFAULT;
438
439 err |= setup_sigcontext(regs, &frame->sf_sc);
440 err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
441 if (err)
442 return -EFAULT;
443
444
445
446
447
448
449
450
451
452
453
454 regs->regs[ 4] = ksig->sig;
455 regs->regs[ 5] = 0;
456 regs->regs[ 6] = (unsigned long) &frame->sf_sc;
457 regs->regs[29] = (unsigned long) frame;
458 regs->regs[31] = (unsigned long) sig_return;
459 regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
460
461 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
462 current->comm, current->pid,
463 frame, regs->cp0_epc, regs->regs[31]);
464 return 0;
465}
466#endif
467
468static int setup_rt_frame(void *sig_return, struct ksignal *ksig,
469 struct pt_regs *regs, sigset_t *set)
470{
471 struct rt_sigframe __user *frame;
472 int err = 0;
473
474 frame = get_sigframe(ksig, regs, sizeof(*frame));
475 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
476 return -EFAULT;
477
478
479 err |= copy_siginfo_to_user(&frame->rs_info, &ksig->info);
480
481
482 err |= __put_user(0, &frame->rs_uc.uc_flags);
483 err |= __put_user(NULL, &frame->rs_uc.uc_link);
484 err |= __save_altstack(&frame->rs_uc.uc_stack, regs->regs[29]);
485 err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
486 err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
487
488 if (err)
489 return -EFAULT;
490
491
492
493
494
495
496
497
498
499
500
501 regs->regs[ 4] = ksig->sig;
502 regs->regs[ 5] = (unsigned long) &frame->rs_info;
503 regs->regs[ 6] = (unsigned long) &frame->rs_uc;
504 regs->regs[29] = (unsigned long) frame;
505 regs->regs[31] = (unsigned long) sig_return;
506 regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
507
508 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
509 current->comm, current->pid,
510 frame, regs->cp0_epc, regs->regs[31]);
511
512 return 0;
513}
514
515struct mips_abi mips_abi = {
516#ifdef CONFIG_TRAD_SIGNALS
517 .setup_frame = setup_frame,
518 .signal_return_offset = offsetof(struct mips_vdso, signal_trampoline),
519#endif
520 .setup_rt_frame = setup_rt_frame,
521 .rt_signal_return_offset =
522 offsetof(struct mips_vdso, rt_signal_trampoline),
523 .restart = __NR_restart_syscall
524};
525
526static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
527{
528 sigset_t *oldset = sigmask_to_save();
529 int ret;
530 struct mips_abi *abi = current->thread.abi;
531#ifdef CONFIG_CPU_MICROMIPS
532 void *vdso;
533 unsigned long tmp = (unsigned long)current->mm->context.vdso;
534
535 set_isa16_mode(tmp);
536 vdso = (void *)tmp;
537#else
538 void *vdso = current->mm->context.vdso;
539#endif
540
541 if (regs->regs[0]) {
542 switch(regs->regs[2]) {
543 case ERESTART_RESTARTBLOCK:
544 case ERESTARTNOHAND:
545 regs->regs[2] = EINTR;
546 break;
547 case ERESTARTSYS:
548 if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
549 regs->regs[2] = EINTR;
550 break;
551 }
552
553 case ERESTARTNOINTR:
554 regs->regs[7] = regs->regs[26];
555 regs->regs[2] = regs->regs[0];
556 regs->cp0_epc -= 4;
557 }
558
559 regs->regs[0] = 0;
560 }
561
562 if (sig_uses_siginfo(&ksig->ka))
563 ret = abi->setup_rt_frame(vdso + abi->rt_signal_return_offset,
564 ksig, regs, oldset);
565 else
566 ret = abi->setup_frame(vdso + abi->signal_return_offset, ksig,
567 regs, oldset);
568
569 signal_setup_done(ret, ksig, 0);
570}
571
572static void do_signal(struct pt_regs *regs)
573{
574 struct ksignal ksig;
575
576 if (get_signal(&ksig)) {
577
578 handle_signal(&ksig, regs);
579 return;
580 }
581
582 if (regs->regs[0]) {
583 switch (regs->regs[2]) {
584 case ERESTARTNOHAND:
585 case ERESTARTSYS:
586 case ERESTARTNOINTR:
587 regs->regs[2] = regs->regs[0];
588 regs->regs[7] = regs->regs[26];
589 regs->cp0_epc -= 4;
590 break;
591
592 case ERESTART_RESTARTBLOCK:
593 regs->regs[2] = current->thread.abi->restart;
594 regs->regs[7] = regs->regs[26];
595 regs->cp0_epc -= 4;
596 break;
597 }
598 regs->regs[0] = 0;
599 }
600
601
602
603
604
605 restore_saved_sigmask();
606}
607
608
609
610
611
612asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
613 __u32 thread_info_flags)
614{
615 local_irq_enable();
616
617 user_exit();
618
619
620 if (thread_info_flags & _TIF_SIGPENDING)
621 do_signal(regs);
622
623 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
624 clear_thread_flag(TIF_NOTIFY_RESUME);
625 tracehook_notify_resume(regs);
626 }
627
628 user_enter();
629}
630
631#ifdef CONFIG_SMP
632#ifndef CONFIG_EVA
633static int smp_save_fp_context(struct sigcontext __user *sc)
634{
635 return raw_cpu_has_fpu
636 ? _save_fp_context(sc)
637 : copy_fp_to_sigcontext(sc);
638}
639
640static int smp_restore_fp_context(struct sigcontext __user *sc)
641{
642 return raw_cpu_has_fpu
643 ? _restore_fp_context(sc)
644 : copy_fp_from_sigcontext(sc);
645}
646#endif
647#endif
648
649static int signal_setup(void)
650{
651#ifndef CONFIG_EVA
652#ifdef CONFIG_SMP
653
654 save_fp_context = smp_save_fp_context;
655 restore_fp_context = smp_restore_fp_context;
656#else
657 if (cpu_has_fpu) {
658 save_fp_context = _save_fp_context;
659 restore_fp_context = _restore_fp_context;
660 } else {
661 save_fp_context = copy_fp_to_sigcontext;
662 restore_fp_context = copy_fp_from_sigcontext;
663 }
664#endif
665#else
666 save_fp_context = copy_fp_to_sigcontext;
667 restore_fp_context = copy_fp_from_sigcontext;
668#endif
669
670 return 0;
671}
672
673arch_initcall(signal_setup);
674