1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/sched.h>
21#include <linux/mm.h>
22#include <linux/smp.h>
23#include <linux/kernel.h>
24#include <linux/signal.h>
25#include <linux/errno.h>
26#include <linux/elf.h>
27#include <linux/ptrace.h>
28#ifdef CONFIG_PPC64
29#include <linux/syscalls.h>
30#include <linux/compat.h>
31#else
32#include <linux/wait.h>
33#include <linux/unistd.h>
34#include <linux/stddef.h>
35#include <linux/tty.h>
36#include <linux/binfmts.h>
37#include <linux/freezer.h>
38#endif
39
40#include <asm/uaccess.h>
41#include <asm/cacheflush.h>
42#include <asm/syscalls.h>
43#include <asm/sigcontext.h>
44#include <asm/vdso.h>
45#ifdef CONFIG_PPC64
46#include "ppc32.h"
47#include <asm/unistd.h>
48#else
49#include <asm/ucontext.h>
50#include <asm/pgtable.h>
51#endif
52
53#include "signal.h"
54
55#undef DEBUG_SIG
56
57#ifdef CONFIG_PPC64
58#define sys_sigsuspend compat_sys_sigsuspend
59#define sys_rt_sigsuspend compat_sys_rt_sigsuspend
60#define sys_rt_sigreturn compat_sys_rt_sigreturn
61#define sys_sigaction compat_sys_sigaction
62#define sys_swapcontext compat_sys_swapcontext
63#define sys_sigreturn compat_sys_sigreturn
64
65#define old_sigaction old_sigaction32
66#define sigcontext sigcontext32
67#define mcontext mcontext32
68#define ucontext ucontext32
69
70
71
72
73
74#define UCONTEXTSIZEWITHOUTVSX \
75 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32))
76
77
78
79
80
81
82
83
84#define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
85#undef __SIGNAL_FRAMESIZE
86#define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
87#undef ELF_NVRREG
88#define ELF_NVRREG ELF_NVRREG32
89
90
91
92
93
94static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
95{
96 compat_sigset_t cset;
97
98 switch (_NSIG_WORDS) {
99 case 4: cset.sig[5] = set->sig[3] & 0xffffffffull;
100 cset.sig[7] = set->sig[3] >> 32;
101 case 3: cset.sig[4] = set->sig[2] & 0xffffffffull;
102 cset.sig[5] = set->sig[2] >> 32;
103 case 2: cset.sig[2] = set->sig[1] & 0xffffffffull;
104 cset.sig[3] = set->sig[1] >> 32;
105 case 1: cset.sig[0] = set->sig[0] & 0xffffffffull;
106 cset.sig[1] = set->sig[0] >> 32;
107 }
108 return copy_to_user(uset, &cset, sizeof(*uset));
109}
110
111static inline int get_sigset_t(sigset_t *set,
112 const compat_sigset_t __user *uset)
113{
114 compat_sigset_t s32;
115
116 if (copy_from_user(&s32, uset, sizeof(*uset)))
117 return -EFAULT;
118
119
120
121
122
123 switch (_NSIG_WORDS) {
124 case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
125 case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
126 case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
127 case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
128 }
129 return 0;
130}
131
132static inline int get_old_sigaction(struct k_sigaction *new_ka,
133 struct old_sigaction __user *act)
134{
135 compat_old_sigset_t mask;
136 compat_uptr_t handler, restorer;
137
138 if (get_user(handler, &act->sa_handler) ||
139 __get_user(restorer, &act->sa_restorer) ||
140 __get_user(new_ka->sa.sa_flags, &act->sa_flags) ||
141 __get_user(mask, &act->sa_mask))
142 return -EFAULT;
143 new_ka->sa.sa_handler = compat_ptr(handler);
144 new_ka->sa.sa_restorer = compat_ptr(restorer);
145 siginitset(&new_ka->sa.sa_mask, mask);
146 return 0;
147}
148
149#define to_user_ptr(p) ptr_to_compat(p)
150#define from_user_ptr(p) compat_ptr(p)
151
152static inline int save_general_regs(struct pt_regs *regs,
153 struct mcontext __user *frame)
154{
155 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
156 int i;
157
158 WARN_ON(!FULL_REGS(regs));
159
160 for (i = 0; i <= PT_RESULT; i ++) {
161 if (i == 14 && !FULL_REGS(regs))
162 i = 32;
163 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
164 return -EFAULT;
165 }
166 return 0;
167}
168
169static inline int restore_general_regs(struct pt_regs *regs,
170 struct mcontext __user *sr)
171{
172 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
173 int i;
174
175 for (i = 0; i <= PT_RESULT; i++) {
176 if ((i == PT_MSR) || (i == PT_SOFTE))
177 continue;
178 if (__get_user(gregs[i], &sr->mc_gregs[i]))
179 return -EFAULT;
180 }
181 return 0;
182}
183
184#else
185
186#define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
187
188static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
189{
190 return copy_to_user(uset, set, sizeof(*uset));
191}
192
193static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
194{
195 return copy_from_user(set, uset, sizeof(*uset));
196}
197
198static inline int get_old_sigaction(struct k_sigaction *new_ka,
199 struct old_sigaction __user *act)
200{
201 old_sigset_t mask;
202
203 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
204 __get_user(new_ka->sa.sa_handler, &act->sa_handler) ||
205 __get_user(new_ka->sa.sa_restorer, &act->sa_restorer))
206 return -EFAULT;
207 __get_user(new_ka->sa.sa_flags, &act->sa_flags);
208 __get_user(mask, &act->sa_mask);
209 siginitset(&new_ka->sa.sa_mask, mask);
210 return 0;
211}
212
213#define to_user_ptr(p) ((unsigned long)(p))
214#define from_user_ptr(p) ((void __user *)(p))
215
216static inline int save_general_regs(struct pt_regs *regs,
217 struct mcontext __user *frame)
218{
219 WARN_ON(!FULL_REGS(regs));
220 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
221}
222
223static inline int restore_general_regs(struct pt_regs *regs,
224 struct mcontext __user *sr)
225{
226
227 if (__copy_from_user(regs, &sr->mc_gregs,
228 PT_MSR * sizeof(elf_greg_t)))
229 return -EFAULT;
230
231 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
232 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
233 return -EFAULT;
234 return 0;
235}
236
237#endif
238
239
240
241
242long sys_sigsuspend(old_sigset_t mask)
243{
244 mask &= _BLOCKABLE;
245 spin_lock_irq(¤t->sighand->siglock);
246 current->saved_sigmask = current->blocked;
247 siginitset(¤t->blocked, mask);
248 recalc_sigpending();
249 spin_unlock_irq(¤t->sighand->siglock);
250
251 current->state = TASK_INTERRUPTIBLE;
252 schedule();
253 set_restore_sigmask();
254 return -ERESTARTNOHAND;
255}
256
257long sys_sigaction(int sig, struct old_sigaction __user *act,
258 struct old_sigaction __user *oact)
259{
260 struct k_sigaction new_ka, old_ka;
261 int ret;
262
263#ifdef CONFIG_PPC64
264 if (sig < 0)
265 sig = -sig;
266#endif
267
268 if (act) {
269 if (get_old_sigaction(&new_ka, act))
270 return -EFAULT;
271 }
272
273 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
274 if (!ret && oact) {
275 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
276 __put_user(to_user_ptr(old_ka.sa.sa_handler),
277 &oact->sa_handler) ||
278 __put_user(to_user_ptr(old_ka.sa.sa_restorer),
279 &oact->sa_restorer) ||
280 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
281 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
282 return -EFAULT;
283 }
284
285 return ret;
286}
287
288
289
290
291
292
293
294
295
296
297
298
299
300struct sigframe {
301 struct sigcontext sctx;
302 struct mcontext mctx;
303
304
305
306
307 int abigap[56];
308};
309
310
311#define tramp mc_pad
312
313
314
315
316
317
318
319
320
321
322
323
324struct rt_sigframe {
325#ifdef CONFIG_PPC64
326 compat_siginfo_t info;
327#else
328 struct siginfo info;
329#endif
330 struct ucontext uc;
331
332
333
334
335 int abigap[56];
336};
337
338#ifdef CONFIG_VSX
339unsigned long copy_fpr_to_user(void __user *to,
340 struct task_struct *task)
341{
342 double buf[ELF_NFPREG];
343 int i;
344
345
346 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
347 buf[i] = task->thread.TS_FPR(i);
348 memcpy(&buf[i], &task->thread.fpscr, sizeof(double));
349 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
350}
351
352unsigned long copy_fpr_from_user(struct task_struct *task,
353 void __user *from)
354{
355 double buf[ELF_NFPREG];
356 int i;
357
358 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
359 return 1;
360 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
361 task->thread.TS_FPR(i) = buf[i];
362 memcpy(&task->thread.fpscr, &buf[i], sizeof(double));
363
364 return 0;
365}
366
367unsigned long copy_vsx_to_user(void __user *to,
368 struct task_struct *task)
369{
370 double buf[ELF_NVSRHALFREG];
371 int i;
372
373
374 for (i = 0; i < ELF_NVSRHALFREG; i++)
375 buf[i] = task->thread.fpr[i][TS_VSRLOWOFFSET];
376 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
377}
378
379unsigned long copy_vsx_from_user(struct task_struct *task,
380 void __user *from)
381{
382 double buf[ELF_NVSRHALFREG];
383 int i;
384
385 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
386 return 1;
387 for (i = 0; i < ELF_NVSRHALFREG ; i++)
388 task->thread.fpr[i][TS_VSRLOWOFFSET] = buf[i];
389 return 0;
390}
391#else
392inline unsigned long copy_fpr_to_user(void __user *to,
393 struct task_struct *task)
394{
395 return __copy_to_user(to, task->thread.fpr,
396 ELF_NFPREG * sizeof(double));
397}
398
399inline unsigned long copy_fpr_from_user(struct task_struct *task,
400 void __user *from)
401{
402 return __copy_from_user(task->thread.fpr, from,
403 ELF_NFPREG * sizeof(double));
404}
405#endif
406
407
408
409
410
411
412static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
413 int sigret, int ctx_has_vsx_region)
414{
415 unsigned long msr = regs->msr;
416
417
418 flush_fp_to_thread(current);
419
420
421 if (save_general_regs(regs, frame))
422 return 1;
423
424#ifdef CONFIG_ALTIVEC
425
426 if (current->thread.used_vr) {
427 flush_altivec_to_thread(current);
428 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
429 ELF_NVRREG * sizeof(vector128)))
430 return 1;
431
432
433 msr |= MSR_VEC;
434 }
435
436
437
438
439
440
441
442 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
443 return 1;
444#endif
445 if (copy_fpr_to_user(&frame->mc_fregs, current))
446 return 1;
447#ifdef CONFIG_VSX
448
449
450
451
452
453
454 if (current->thread.used_vsr && ctx_has_vsx_region) {
455 __giveup_vsx(current);
456 if (copy_vsx_to_user(&frame->mc_vsregs, current))
457 return 1;
458 msr |= MSR_VSX;
459 }
460#endif
461#ifdef CONFIG_SPE
462
463 if (current->thread.used_spe) {
464 flush_spe_to_thread(current);
465 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
466 ELF_NEVRREG * sizeof(u32)))
467 return 1;
468
469
470 msr |= MSR_SPE;
471 }
472
473
474
475 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
476 return 1;
477#endif
478
479 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
480 return 1;
481 if (sigret) {
482
483 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
484 || __put_user(0x44000002UL, &frame->tramp[1]))
485 return 1;
486 flush_icache_range((unsigned long) &frame->tramp[0],
487 (unsigned long) &frame->tramp[2]);
488 }
489
490 return 0;
491}
492
493
494
495
496
497static long restore_user_regs(struct pt_regs *regs,
498 struct mcontext __user *sr, int sig)
499{
500 long err;
501 unsigned int save_r2 = 0;
502 unsigned long msr;
503#ifdef CONFIG_VSX
504 int i;
505#endif
506
507
508
509
510
511 if (!sig)
512 save_r2 = (unsigned int)regs->gpr[2];
513 err = restore_general_regs(regs, sr);
514 regs->trap = 0;
515 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
516 if (!sig)
517 regs->gpr[2] = (unsigned long) save_r2;
518 if (err)
519 return 1;
520
521
522 if (sig)
523 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
524
525
526
527
528
529
530
531
532 discard_lazy_cpu_state();
533
534#ifdef CONFIG_ALTIVEC
535
536
537
538
539 regs->msr &= ~MSR_VEC;
540 if (msr & MSR_VEC) {
541
542 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
543 sizeof(sr->mc_vregs)))
544 return 1;
545 } else if (current->thread.used_vr)
546 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
547
548
549 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
550 return 1;
551#endif
552 if (copy_fpr_from_user(current, &sr->mc_fregs))
553 return 1;
554
555#ifdef CONFIG_VSX
556
557
558
559
560 regs->msr &= ~MSR_VSX;
561 if (msr & MSR_VSX) {
562
563
564
565
566 if (copy_vsx_from_user(current, &sr->mc_vsregs))
567 return 1;
568 } else if (current->thread.used_vsr)
569 for (i = 0; i < 32 ; i++)
570 current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
571#endif
572
573
574
575
576 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
577
578#ifdef CONFIG_SPE
579
580
581 regs->msr &= ~MSR_SPE;
582 if (msr & MSR_SPE) {
583
584 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
585 ELF_NEVRREG * sizeof(u32)))
586 return 1;
587 } else if (current->thread.used_spe)
588 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
589
590
591 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
592 return 1;
593#endif
594
595 return 0;
596}
597
598#ifdef CONFIG_PPC64
599long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
600 struct sigaction32 __user *oact, size_t sigsetsize)
601{
602 struct k_sigaction new_ka, old_ka;
603 int ret;
604
605
606 if (sigsetsize != sizeof(compat_sigset_t))
607 return -EINVAL;
608
609 if (act) {
610 compat_uptr_t handler;
611
612 ret = get_user(handler, &act->sa_handler);
613 new_ka.sa.sa_handler = compat_ptr(handler);
614 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
615 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
616 if (ret)
617 return -EFAULT;
618 }
619
620 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
621 if (!ret && oact) {
622 ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler);
623 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
624 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
625 }
626 return ret;
627}
628
629
630
631
632
633
634
635
636long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
637 compat_sigset_t __user *oset, size_t sigsetsize)
638{
639 sigset_t s;
640 sigset_t __user *up;
641 int ret;
642 mm_segment_t old_fs = get_fs();
643
644 if (set) {
645 if (get_sigset_t(&s, set))
646 return -EFAULT;
647 }
648
649 set_fs(KERNEL_DS);
650
651 up = (sigset_t __user *) &s;
652 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
653 sigsetsize);
654 set_fs(old_fs);
655 if (ret)
656 return ret;
657 if (oset) {
658 if (put_sigset_t(oset, &s))
659 return -EFAULT;
660 }
661 return 0;
662}
663
664long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
665{
666 sigset_t s;
667 int ret;
668 mm_segment_t old_fs = get_fs();
669
670 set_fs(KERNEL_DS);
671
672 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
673 set_fs(old_fs);
674 if (!ret) {
675 if (put_sigset_t(set, &s))
676 return -EFAULT;
677 }
678 return ret;
679}
680
681
682int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
683{
684 int err;
685
686 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
687 return -EFAULT;
688
689
690
691
692
693
694
695
696
697 err = __put_user(s->si_signo, &d->si_signo);
698 err |= __put_user(s->si_errno, &d->si_errno);
699 err |= __put_user((short)s->si_code, &d->si_code);
700 if (s->si_code < 0)
701 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
702 SI_PAD_SIZE32);
703 else switch(s->si_code >> 16) {
704 case __SI_CHLD >> 16:
705 err |= __put_user(s->si_pid, &d->si_pid);
706 err |= __put_user(s->si_uid, &d->si_uid);
707 err |= __put_user(s->si_utime, &d->si_utime);
708 err |= __put_user(s->si_stime, &d->si_stime);
709 err |= __put_user(s->si_status, &d->si_status);
710 break;
711 case __SI_FAULT >> 16:
712 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
713 &d->si_addr);
714 break;
715 case __SI_POLL >> 16:
716 err |= __put_user(s->si_band, &d->si_band);
717 err |= __put_user(s->si_fd, &d->si_fd);
718 break;
719 case __SI_TIMER >> 16:
720 err |= __put_user(s->si_tid, &d->si_tid);
721 err |= __put_user(s->si_overrun, &d->si_overrun);
722 err |= __put_user(s->si_int, &d->si_int);
723 break;
724 case __SI_RT >> 16:
725 case __SI_MESGQ >> 16:
726 err |= __put_user(s->si_int, &d->si_int);
727
728 case __SI_KILL >> 16:
729 default:
730 err |= __put_user(s->si_pid, &d->si_pid);
731 err |= __put_user(s->si_uid, &d->si_uid);
732 break;
733 }
734 return err;
735}
736
737#define copy_siginfo_to_user copy_siginfo_to_user32
738
739int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
740{
741 memset(to, 0, sizeof *to);
742
743 if (copy_from_user(to, from, 3*sizeof(int)) ||
744 copy_from_user(to->_sifields._pad,
745 from->_sifields._pad, SI_PAD_SIZE32))
746 return -EFAULT;
747
748 return 0;
749}
750
751
752
753
754
755
756
757
758long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
759{
760 siginfo_t info;
761 int ret;
762 mm_segment_t old_fs = get_fs();
763
764 ret = copy_siginfo_from_user32(&info, uinfo);
765 if (unlikely(ret))
766 return ret;
767
768 set_fs (KERNEL_DS);
769
770 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
771 set_fs (old_fs);
772 return ret;
773}
774
775
776
777
778
779
780
781int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
782 int r6, int r7, int r8, struct pt_regs *regs)
783{
784 stack_32_t __user * newstack = compat_ptr(__new);
785 stack_32_t __user * oldstack = compat_ptr(__old);
786 stack_t uss, uoss;
787 int ret;
788 mm_segment_t old_fs;
789 unsigned long sp;
790 compat_uptr_t ss_sp;
791
792
793
794
795
796 sp = regs->gpr[1];
797
798
799 if (newstack) {
800 if (get_user(ss_sp, &newstack->ss_sp) ||
801 __get_user(uss.ss_flags, &newstack->ss_flags) ||
802 __get_user(uss.ss_size, &newstack->ss_size))
803 return -EFAULT;
804 uss.ss_sp = compat_ptr(ss_sp);
805 }
806
807 old_fs = get_fs();
808 set_fs(KERNEL_DS);
809
810 ret = do_sigaltstack(
811 newstack ? (stack_t __user *) &uss : NULL,
812 oldstack ? (stack_t __user *) &uoss : NULL,
813 sp);
814 set_fs(old_fs);
815
816 if (!ret && oldstack &&
817 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) ||
818 __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
819 __put_user(uoss.ss_size, &oldstack->ss_size)))
820 return -EFAULT;
821 return ret;
822}
823#endif
824
825
826
827
828
829int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
830 siginfo_t *info, sigset_t *oldset,
831 struct pt_regs *regs)
832{
833 struct rt_sigframe __user *rt_sf;
834 struct mcontext __user *frame;
835 void __user *addr;
836 unsigned long newsp = 0;
837
838
839
840 rt_sf = get_sigframe(ka, regs, sizeof(*rt_sf), 1);
841 addr = rt_sf;
842 if (unlikely(rt_sf == NULL))
843 goto badframe;
844
845
846 if (copy_siginfo_to_user(&rt_sf->info, info)
847 || __put_user(0, &rt_sf->uc.uc_flags)
848 || __put_user(0, &rt_sf->uc.uc_link)
849 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
850 || __put_user(sas_ss_flags(regs->gpr[1]),
851 &rt_sf->uc.uc_stack.ss_flags)
852 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
853 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
854 &rt_sf->uc.uc_regs)
855 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
856 goto badframe;
857
858
859 frame = &rt_sf->uc.uc_mcontext;
860 addr = frame;
861 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
862 if (save_user_regs(regs, frame, 0, 1))
863 goto badframe;
864 regs->link = current->mm->context.vdso_base + vdso32_rt_sigtramp;
865 } else {
866 if (save_user_regs(regs, frame, __NR_rt_sigreturn, 1))
867 goto badframe;
868 regs->link = (unsigned long) frame->tramp;
869 }
870
871 current->thread.fpscr.val = 0;
872
873
874 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
875 addr = (void __user *)regs->gpr[1];
876 if (put_user(regs->gpr[1], (u32 __user *)newsp))
877 goto badframe;
878
879
880 regs->gpr[1] = newsp;
881 regs->gpr[3] = sig;
882 regs->gpr[4] = (unsigned long) &rt_sf->info;
883 regs->gpr[5] = (unsigned long) &rt_sf->uc;
884 regs->gpr[6] = (unsigned long) rt_sf;
885 regs->nip = (unsigned long) ka->sa.sa_handler;
886
887 regs->msr &= ~MSR_LE;
888 return 1;
889
890badframe:
891#ifdef DEBUG_SIG
892 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
893 regs, frame, newsp);
894#endif
895 if (show_unhandled_signals && printk_ratelimit())
896 printk(KERN_INFO "%s[%d]: bad frame in handle_rt_signal32: "
897 "%p nip %08lx lr %08lx\n",
898 current->comm, current->pid,
899 addr, regs->nip, regs->link);
900
901 force_sigsegv(sig, current);
902 return 0;
903}
904
905static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
906{
907 sigset_t set;
908 struct mcontext __user *mcp;
909
910 if (get_sigset_t(&set, &ucp->uc_sigmask))
911 return -EFAULT;
912#ifdef CONFIG_PPC64
913 {
914 u32 cmcp;
915
916 if (__get_user(cmcp, &ucp->uc_regs))
917 return -EFAULT;
918 mcp = (struct mcontext __user *)(u64)cmcp;
919
920 }
921#else
922 if (__get_user(mcp, &ucp->uc_regs))
923 return -EFAULT;
924 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
925 return -EFAULT;
926#endif
927 restore_sigmask(&set);
928 if (restore_user_regs(regs, mcp, sig))
929 return -EFAULT;
930
931 return 0;
932}
933
934long sys_swapcontext(struct ucontext __user *old_ctx,
935 struct ucontext __user *new_ctx,
936 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
937{
938 unsigned char tmp;
939 int ctx_has_vsx_region = 0;
940
941#ifdef CONFIG_PPC64
942 unsigned long new_msr = 0;
943
944 if (new_ctx) {
945 struct mcontext __user *mcp;
946 u32 cmcp;
947
948
949
950
951
952
953 if (__get_user(cmcp, &new_ctx->uc_regs))
954 return -EFAULT;
955 mcp = (struct mcontext __user *)(u64)cmcp;
956 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
957 return -EFAULT;
958 }
959
960
961
962
963 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
964 return -EINVAL;
965
966
967
968
969 if ((ctx_size < sizeof(struct ucontext)) &&
970 (new_msr & MSR_VSX))
971 return -EINVAL;
972
973 if (ctx_size >= sizeof(struct ucontext))
974 ctx_has_vsx_region = 1;
975#else
976
977
978
979 if (ctx_size < sizeof(struct ucontext))
980 return -EINVAL;
981#endif
982 if (old_ctx != NULL) {
983 struct mcontext __user *mctx;
984
985
986
987
988
989
990
991
992 mctx = (struct mcontext __user *)
993 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
994 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
995 || save_user_regs(regs, mctx, 0, ctx_has_vsx_region)
996 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
997 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
998 return -EFAULT;
999 }
1000 if (new_ctx == NULL)
1001 return 0;
1002 if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
1003 || __get_user(tmp, (u8 __user *) new_ctx)
1004 || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
1005 return -EFAULT;
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018 if (do_setcontext(new_ctx, regs, 0))
1019 do_exit(SIGSEGV);
1020
1021 set_thread_flag(TIF_RESTOREALL);
1022 return 0;
1023}
1024
1025long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1026 struct pt_regs *regs)
1027{
1028 struct rt_sigframe __user *rt_sf;
1029
1030
1031 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1032
1033 rt_sf = (struct rt_sigframe __user *)
1034 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1035 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1036 goto bad;
1037 if (do_setcontext(&rt_sf->uc, regs, 1))
1038 goto bad;
1039
1040
1041
1042
1043
1044
1045
1046
1047#ifdef CONFIG_PPC64
1048
1049
1050
1051
1052
1053 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
1054#else
1055 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
1056#endif
1057 set_thread_flag(TIF_RESTOREALL);
1058 return 0;
1059
1060 bad:
1061 if (show_unhandled_signals && printk_ratelimit())
1062 printk(KERN_INFO "%s[%d]: bad frame in sys_rt_sigreturn: "
1063 "%p nip %08lx lr %08lx\n",
1064 current->comm, current->pid,
1065 rt_sf, regs->nip, regs->link);
1066
1067 force_sig(SIGSEGV, current);
1068 return 0;
1069}
1070
1071#ifdef CONFIG_PPC32
1072int sys_debug_setcontext(struct ucontext __user *ctx,
1073 int ndbg, struct sig_dbg_op __user *dbg,
1074 int r6, int r7, int r8,
1075 struct pt_regs *regs)
1076{
1077 struct sig_dbg_op op;
1078 int i;
1079 unsigned char tmp;
1080 unsigned long new_msr = regs->msr;
1081#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1082 unsigned long new_dbcr0 = current->thread.dbcr0;
1083#endif
1084
1085 for (i=0; i<ndbg; i++) {
1086 if (copy_from_user(&op, dbg + i, sizeof(op)))
1087 return -EFAULT;
1088 switch (op.dbg_type) {
1089 case SIG_DBG_SINGLE_STEPPING:
1090#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1091 if (op.dbg_value) {
1092 new_msr |= MSR_DE;
1093 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1094 } else {
1095 new_dbcr0 &= ~DBCR0_IC;
1096 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1097 current->thread.dbcr1)) {
1098 new_msr &= ~MSR_DE;
1099 new_dbcr0 &= ~DBCR0_IDM;
1100 }
1101 }
1102#else
1103 if (op.dbg_value)
1104 new_msr |= MSR_SE;
1105 else
1106 new_msr &= ~MSR_SE;
1107#endif
1108 break;
1109 case SIG_DBG_BRANCH_TRACING:
1110#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1111 return -EINVAL;
1112#else
1113 if (op.dbg_value)
1114 new_msr |= MSR_BE;
1115 else
1116 new_msr &= ~MSR_BE;
1117#endif
1118 break;
1119
1120 default:
1121 return -EINVAL;
1122 }
1123 }
1124
1125
1126
1127
1128
1129
1130 regs->msr = new_msr;
1131#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1132 current->thread.dbcr0 = new_dbcr0;
1133#endif
1134
1135 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1136 || __get_user(tmp, (u8 __user *) ctx)
1137 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1138 return -EFAULT;
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151 if (do_setcontext(ctx, regs, 1)) {
1152 if (show_unhandled_signals && printk_ratelimit())
1153 printk(KERN_INFO "%s[%d]: bad frame in "
1154 "sys_debug_setcontext: %p nip %08lx "
1155 "lr %08lx\n",
1156 current->comm, current->pid,
1157 ctx, regs->nip, regs->link);
1158
1159 force_sig(SIGSEGV, current);
1160 goto out;
1161 }
1162
1163
1164
1165
1166
1167
1168
1169
1170 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1171
1172 set_thread_flag(TIF_RESTOREALL);
1173 out:
1174 return 0;
1175}
1176#endif
1177
1178
1179
1180
1181int handle_signal32(unsigned long sig, struct k_sigaction *ka,
1182 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
1183{
1184 struct sigcontext __user *sc;
1185 struct sigframe __user *frame;
1186 unsigned long newsp = 0;
1187
1188
1189 frame = get_sigframe(ka, regs, sizeof(*frame), 1);
1190 if (unlikely(frame == NULL))
1191 goto badframe;
1192 sc = (struct sigcontext __user *) &frame->sctx;
1193
1194#if _NSIG != 64
1195#error "Please adjust handle_signal()"
1196#endif
1197 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1198 || __put_user(oldset->sig[0], &sc->oldmask)
1199#ifdef CONFIG_PPC64
1200 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1201#else
1202 || __put_user(oldset->sig[1], &sc->_unused[3])
1203#endif
1204 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1205 || __put_user(sig, &sc->signal))
1206 goto badframe;
1207
1208 if (vdso32_sigtramp && current->mm->context.vdso_base) {
1209 if (save_user_regs(regs, &frame->mctx, 0, 1))
1210 goto badframe;
1211 regs->link = current->mm->context.vdso_base + vdso32_sigtramp;
1212 } else {
1213 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn, 1))
1214 goto badframe;
1215 regs->link = (unsigned long) frame->mctx.tramp;
1216 }
1217
1218 current->thread.fpscr.val = 0;
1219
1220
1221 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1222 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1223 goto badframe;
1224
1225 regs->gpr[1] = newsp;
1226 regs->gpr[3] = sig;
1227 regs->gpr[4] = (unsigned long) sc;
1228 regs->nip = (unsigned long) ka->sa.sa_handler;
1229
1230 regs->msr &= ~MSR_LE;
1231
1232 return 1;
1233
1234badframe:
1235#ifdef DEBUG_SIG
1236 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1237 regs, frame, newsp);
1238#endif
1239 if (show_unhandled_signals && printk_ratelimit())
1240 printk(KERN_INFO "%s[%d]: bad frame in handle_signal32: "
1241 "%p nip %08lx lr %08lx\n",
1242 current->comm, current->pid,
1243 frame, regs->nip, regs->link);
1244
1245 force_sigsegv(sig, current);
1246 return 0;
1247}
1248
1249
1250
1251
1252long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1253 struct pt_regs *regs)
1254{
1255 struct sigcontext __user *sc;
1256 struct sigcontext sigctx;
1257 struct mcontext __user *sr;
1258 void __user *addr;
1259 sigset_t set;
1260
1261
1262 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1263
1264 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1265 addr = sc;
1266 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1267 goto badframe;
1268
1269#ifdef CONFIG_PPC64
1270
1271
1272
1273
1274 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1275#else
1276 set.sig[0] = sigctx.oldmask;
1277 set.sig[1] = sigctx._unused[3];
1278#endif
1279 restore_sigmask(&set);
1280
1281 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1282 addr = sr;
1283 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1284 || restore_user_regs(regs, sr, 1))
1285 goto badframe;
1286
1287 set_thread_flag(TIF_RESTOREALL);
1288 return 0;
1289
1290badframe:
1291 if (show_unhandled_signals && printk_ratelimit())
1292 printk(KERN_INFO "%s[%d]: bad frame in sys_sigreturn: "
1293 "%p nip %08lx lr %08lx\n",
1294 current->comm, current->pid,
1295 addr, regs->nip, regs->link);
1296
1297 force_sig(SIGSEGV, current);
1298 return 0;
1299}
1300