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#include <linux/ratelimit.h>
29#ifdef CONFIG_PPC64
30#include <linux/syscalls.h>
31#include <linux/compat.h>
32#else
33#include <linux/wait.h>
34#include <linux/unistd.h>
35#include <linux/stddef.h>
36#include <linux/tty.h>
37#include <linux/binfmts.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#include <asm/switch_to.h>
46#include <asm/tm.h>
47#ifdef CONFIG_PPC64
48#include "ppc32.h"
49#include <asm/unistd.h>
50#else
51#include <asm/ucontext.h>
52#include <asm/pgtable.h>
53#endif
54
55#include "signal.h"
56
57#undef DEBUG_SIG
58
59#ifdef CONFIG_PPC64
60#define sys_rt_sigreturn compat_sys_rt_sigreturn
61#define sys_swapcontext compat_sys_swapcontext
62#define sys_sigreturn compat_sys_sigreturn
63
64#define old_sigaction old_sigaction32
65#define sigcontext sigcontext32
66#define mcontext mcontext32
67#define ucontext ucontext32
68
69#define __save_altstack __compat_save_altstack
70
71
72
73
74
75#define UCONTEXTSIZEWITHOUTVSX \
76 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32))
77
78
79
80
81
82
83
84
85#define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
86#undef __SIGNAL_FRAMESIZE
87#define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
88#undef ELF_NVRREG
89#define ELF_NVRREG ELF_NVRREG32
90
91
92
93
94
95static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
96{
97 compat_sigset_t cset;
98
99 switch (_NSIG_WORDS) {
100 case 4: cset.sig[6] = set->sig[3] & 0xffffffffull;
101 cset.sig[7] = set->sig[3] >> 32;
102 case 3: cset.sig[4] = set->sig[2] & 0xffffffffull;
103 cset.sig[5] = set->sig[2] >> 32;
104 case 2: cset.sig[2] = set->sig[1] & 0xffffffffull;
105 cset.sig[3] = set->sig[1] >> 32;
106 case 1: cset.sig[0] = set->sig[0] & 0xffffffffull;
107 cset.sig[1] = set->sig[0] >> 32;
108 }
109 return copy_to_user(uset, &cset, sizeof(*uset));
110}
111
112static inline int get_sigset_t(sigset_t *set,
113 const compat_sigset_t __user *uset)
114{
115 compat_sigset_t s32;
116
117 if (copy_from_user(&s32, uset, sizeof(*uset)))
118 return -EFAULT;
119
120
121
122
123
124 switch (_NSIG_WORDS) {
125 case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
126 case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
127 case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
128 case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
129 }
130 return 0;
131}
132
133#define to_user_ptr(p) ptr_to_compat(p)
134#define from_user_ptr(p) compat_ptr(p)
135
136static inline int save_general_regs(struct pt_regs *regs,
137 struct mcontext __user *frame)
138{
139 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
140 int i;
141
142 WARN_ON(!FULL_REGS(regs));
143
144 for (i = 0; i <= PT_RESULT; i ++) {
145 if (i == 14 && !FULL_REGS(regs))
146 i = 32;
147 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
148 return -EFAULT;
149 }
150 return 0;
151}
152
153static inline int restore_general_regs(struct pt_regs *regs,
154 struct mcontext __user *sr)
155{
156 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
157 int i;
158
159 for (i = 0; i <= PT_RESULT; i++) {
160 if ((i == PT_MSR) || (i == PT_SOFTE))
161 continue;
162 if (__get_user(gregs[i], &sr->mc_gregs[i]))
163 return -EFAULT;
164 }
165 return 0;
166}
167
168#else
169
170#define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
171
172static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
173{
174 return copy_to_user(uset, set, sizeof(*uset));
175}
176
177static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
178{
179 return copy_from_user(set, uset, sizeof(*uset));
180}
181
182#define to_user_ptr(p) ((unsigned long)(p))
183#define from_user_ptr(p) ((void __user *)(p))
184
185static inline int save_general_regs(struct pt_regs *regs,
186 struct mcontext __user *frame)
187{
188 WARN_ON(!FULL_REGS(regs));
189 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
190}
191
192static inline int restore_general_regs(struct pt_regs *regs,
193 struct mcontext __user *sr)
194{
195
196 if (__copy_from_user(regs, &sr->mc_gregs,
197 PT_MSR * sizeof(elf_greg_t)))
198 return -EFAULT;
199
200 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
201 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
202 return -EFAULT;
203 return 0;
204}
205#endif
206
207
208
209
210
211
212
213
214
215
216
217
218
219struct sigframe {
220 struct sigcontext sctx;
221 struct mcontext mctx;
222#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
223 struct sigcontext sctx_transact;
224 struct mcontext mctx_transact;
225#endif
226
227
228
229
230 int abigap[56];
231};
232
233
234#define tramp mc_pad
235
236
237
238
239
240
241
242
243
244
245
246
247struct rt_sigframe {
248#ifdef CONFIG_PPC64
249 compat_siginfo_t info;
250#else
251 struct siginfo info;
252#endif
253 struct ucontext uc;
254#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
255 struct ucontext uc_transact;
256#endif
257
258
259
260
261 int abigap[56];
262};
263
264#ifdef CONFIG_VSX
265unsigned long copy_fpr_to_user(void __user *to,
266 struct task_struct *task)
267{
268 double buf[ELF_NFPREG];
269 int i;
270
271
272 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
273 buf[i] = task->thread.TS_FPR(i);
274 memcpy(&buf[i], &task->thread.fpscr, sizeof(double));
275 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
276}
277
278unsigned long copy_fpr_from_user(struct task_struct *task,
279 void __user *from)
280{
281 double buf[ELF_NFPREG];
282 int i;
283
284 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
285 return 1;
286 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
287 task->thread.TS_FPR(i) = buf[i];
288 memcpy(&task->thread.fpscr, &buf[i], sizeof(double));
289
290 return 0;
291}
292
293unsigned long copy_vsx_to_user(void __user *to,
294 struct task_struct *task)
295{
296 double buf[ELF_NVSRHALFREG];
297 int i;
298
299
300 for (i = 0; i < ELF_NVSRHALFREG; i++)
301 buf[i] = task->thread.fpr[i][TS_VSRLOWOFFSET];
302 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
303}
304
305unsigned long copy_vsx_from_user(struct task_struct *task,
306 void __user *from)
307{
308 double buf[ELF_NVSRHALFREG];
309 int i;
310
311 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
312 return 1;
313 for (i = 0; i < ELF_NVSRHALFREG ; i++)
314 task->thread.fpr[i][TS_VSRLOWOFFSET] = buf[i];
315 return 0;
316}
317
318#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
319unsigned long copy_transact_fpr_to_user(void __user *to,
320 struct task_struct *task)
321{
322 double buf[ELF_NFPREG];
323 int i;
324
325
326 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
327 buf[i] = task->thread.TS_TRANS_FPR(i);
328 memcpy(&buf[i], &task->thread.transact_fpscr, sizeof(double));
329 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
330}
331
332unsigned long copy_transact_fpr_from_user(struct task_struct *task,
333 void __user *from)
334{
335 double buf[ELF_NFPREG];
336 int i;
337
338 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
339 return 1;
340 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
341 task->thread.TS_TRANS_FPR(i) = buf[i];
342 memcpy(&task->thread.transact_fpscr, &buf[i], sizeof(double));
343
344 return 0;
345}
346
347unsigned long copy_transact_vsx_to_user(void __user *to,
348 struct task_struct *task)
349{
350 double buf[ELF_NVSRHALFREG];
351 int i;
352
353
354 for (i = 0; i < ELF_NVSRHALFREG; i++)
355 buf[i] = task->thread.transact_fpr[i][TS_VSRLOWOFFSET];
356 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
357}
358
359unsigned long copy_transact_vsx_from_user(struct task_struct *task,
360 void __user *from)
361{
362 double buf[ELF_NVSRHALFREG];
363 int i;
364
365 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
366 return 1;
367 for (i = 0; i < ELF_NVSRHALFREG ; i++)
368 task->thread.transact_fpr[i][TS_VSRLOWOFFSET] = buf[i];
369 return 0;
370}
371#endif
372#else
373inline unsigned long copy_fpr_to_user(void __user *to,
374 struct task_struct *task)
375{
376 return __copy_to_user(to, task->thread.fpr,
377 ELF_NFPREG * sizeof(double));
378}
379
380inline unsigned long copy_fpr_from_user(struct task_struct *task,
381 void __user *from)
382{
383 return __copy_from_user(task->thread.fpr, from,
384 ELF_NFPREG * sizeof(double));
385}
386
387#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
388inline unsigned long copy_transact_fpr_to_user(void __user *to,
389 struct task_struct *task)
390{
391 return __copy_to_user(to, task->thread.transact_fpr,
392 ELF_NFPREG * sizeof(double));
393}
394
395inline unsigned long copy_transact_fpr_from_user(struct task_struct *task,
396 void __user *from)
397{
398 return __copy_from_user(task->thread.transact_fpr, from,
399 ELF_NFPREG * sizeof(double));
400}
401#endif
402#endif
403
404
405
406
407
408
409static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
410 struct mcontext __user *tm_frame, int sigret,
411 int ctx_has_vsx_region)
412{
413 unsigned long msr = regs->msr;
414
415
416 flush_fp_to_thread(current);
417
418
419 if (save_general_regs(regs, frame))
420 return 1;
421
422#ifdef CONFIG_ALTIVEC
423
424 if (current->thread.used_vr) {
425 flush_altivec_to_thread(current);
426 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
427 ELF_NVRREG * sizeof(vector128)))
428 return 1;
429
430
431 msr |= MSR_VEC;
432 }
433
434
435
436
437
438
439
440 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
441 return 1;
442#endif
443 if (copy_fpr_to_user(&frame->mc_fregs, current))
444 return 1;
445#ifdef CONFIG_VSX
446
447
448
449
450
451
452 if (current->thread.used_vsr && ctx_has_vsx_region) {
453 __giveup_vsx(current);
454 if (copy_vsx_to_user(&frame->mc_vsregs, current))
455 return 1;
456 msr |= MSR_VSX;
457 }
458#endif
459#ifdef CONFIG_SPE
460
461 if (current->thread.used_spe) {
462 flush_spe_to_thread(current);
463 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
464 ELF_NEVRREG * sizeof(u32)))
465 return 1;
466
467
468 msr |= MSR_SPE;
469 }
470
471
472
473 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
474 return 1;
475#endif
476
477 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
478 return 1;
479
480
481
482 if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR]))
483 return 1;
484
485 if (sigret) {
486
487 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
488 || __put_user(0x44000002UL, &frame->tramp[1]))
489 return 1;
490 flush_icache_range((unsigned long) &frame->tramp[0],
491 (unsigned long) &frame->tramp[2]);
492 }
493
494 return 0;
495}
496
497#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
498
499
500
501
502
503
504
505
506
507static int save_tm_user_regs(struct pt_regs *regs,
508 struct mcontext __user *frame,
509 struct mcontext __user *tm_frame, int sigret)
510{
511 unsigned long msr = regs->msr;
512
513
514 flush_fp_to_thread(current);
515
516
517 if (save_general_regs(¤t->thread.ckpt_regs, frame)
518 || save_general_regs(regs, tm_frame))
519 return 1;
520
521
522
523
524
525
526
527 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
528 return 1;
529
530#ifdef CONFIG_ALTIVEC
531
532 if (current->thread.used_vr) {
533 flush_altivec_to_thread(current);
534 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
535 ELF_NVRREG * sizeof(vector128)))
536 return 1;
537 if (msr & MSR_VEC) {
538 if (__copy_to_user(&tm_frame->mc_vregs,
539 current->thread.transact_vr,
540 ELF_NVRREG * sizeof(vector128)))
541 return 1;
542 } else {
543 if (__copy_to_user(&tm_frame->mc_vregs,
544 current->thread.vr,
545 ELF_NVRREG * sizeof(vector128)))
546 return 1;
547 }
548
549
550
551
552 msr |= MSR_VEC;
553 }
554
555
556
557
558
559
560 if (__put_user(current->thread.vrsave,
561 (u32 __user *)&frame->mc_vregs[32]))
562 return 1;
563 if (msr & MSR_VEC) {
564 if (__put_user(current->thread.transact_vrsave,
565 (u32 __user *)&tm_frame->mc_vregs[32]))
566 return 1;
567 } else {
568 if (__put_user(current->thread.vrsave,
569 (u32 __user *)&tm_frame->mc_vregs[32]))
570 return 1;
571 }
572#endif
573
574 if (copy_fpr_to_user(&frame->mc_fregs, current))
575 return 1;
576 if (msr & MSR_FP) {
577 if (copy_transact_fpr_to_user(&tm_frame->mc_fregs, current))
578 return 1;
579 } else {
580 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
581 return 1;
582 }
583
584#ifdef CONFIG_VSX
585
586
587
588
589
590
591 if (current->thread.used_vsr) {
592 __giveup_vsx(current);
593 if (copy_vsx_to_user(&frame->mc_vsregs, current))
594 return 1;
595 if (msr & MSR_VSX) {
596 if (copy_transact_vsx_to_user(&tm_frame->mc_vsregs,
597 current))
598 return 1;
599 } else {
600 if (copy_vsx_to_user(&tm_frame->mc_vsregs, current))
601 return 1;
602 }
603
604 msr |= MSR_VSX;
605 }
606#endif
607#ifdef CONFIG_SPE
608
609
610
611 if (current->thread.used_spe) {
612 flush_spe_to_thread(current);
613 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
614 ELF_NEVRREG * sizeof(u32)))
615 return 1;
616
617
618 msr |= MSR_SPE;
619 }
620
621
622 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
623 return 1;
624#endif
625
626 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
627 return 1;
628 if (sigret) {
629
630 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
631 || __put_user(0x44000002UL, &frame->tramp[1]))
632 return 1;
633 flush_icache_range((unsigned long) &frame->tramp[0],
634 (unsigned long) &frame->tramp[2]);
635 }
636
637 return 0;
638}
639#endif
640
641
642
643
644
645static long restore_user_regs(struct pt_regs *regs,
646 struct mcontext __user *sr, int sig)
647{
648 long err;
649 unsigned int save_r2 = 0;
650 unsigned long msr;
651#ifdef CONFIG_VSX
652 int i;
653#endif
654
655
656
657
658
659 if (!sig)
660 save_r2 = (unsigned int)regs->gpr[2];
661 err = restore_general_regs(regs, sr);
662 regs->trap = 0;
663 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
664 if (!sig)
665 regs->gpr[2] = (unsigned long) save_r2;
666 if (err)
667 return 1;
668
669
670 if (sig)
671 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
672
673
674
675
676
677
678
679
680 discard_lazy_cpu_state();
681
682#ifdef CONFIG_ALTIVEC
683
684
685
686
687 regs->msr &= ~MSR_VEC;
688 if (msr & MSR_VEC) {
689
690 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
691 sizeof(sr->mc_vregs)))
692 return 1;
693 } else if (current->thread.used_vr)
694 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
695
696
697 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
698 return 1;
699#endif
700 if (copy_fpr_from_user(current, &sr->mc_fregs))
701 return 1;
702
703#ifdef CONFIG_VSX
704
705
706
707
708 regs->msr &= ~MSR_VSX;
709 if (msr & MSR_VSX) {
710
711
712
713
714 if (copy_vsx_from_user(current, &sr->mc_vsregs))
715 return 1;
716 } else if (current->thread.used_vsr)
717 for (i = 0; i < 32 ; i++)
718 current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
719#endif
720
721
722
723
724 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
725
726#ifdef CONFIG_SPE
727
728
729 regs->msr &= ~MSR_SPE;
730 if (msr & MSR_SPE) {
731
732 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
733 ELF_NEVRREG * sizeof(u32)))
734 return 1;
735 } else if (current->thread.used_spe)
736 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
737
738
739 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
740 return 1;
741#endif
742
743 return 0;
744}
745
746#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
747
748
749
750
751
752static long restore_tm_user_regs(struct pt_regs *regs,
753 struct mcontext __user *sr,
754 struct mcontext __user *tm_sr)
755{
756 long err;
757 unsigned long msr, msr_hi;
758#ifdef CONFIG_VSX
759 int i;
760#endif
761
762
763
764
765
766
767
768
769 err = restore_general_regs(regs, tm_sr);
770 err |= restore_general_regs(¤t->thread.ckpt_regs, sr);
771
772 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
773
774 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
775 if (err)
776 return 1;
777
778
779 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
780
781
782
783
784
785
786
787
788 discard_lazy_cpu_state();
789
790#ifdef CONFIG_ALTIVEC
791 regs->msr &= ~MSR_VEC;
792 if (msr & MSR_VEC) {
793
794 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
795 sizeof(sr->mc_vregs)) ||
796 __copy_from_user(current->thread.transact_vr,
797 &tm_sr->mc_vregs,
798 sizeof(sr->mc_vregs)))
799 return 1;
800 } else if (current->thread.used_vr) {
801 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
802 memset(current->thread.transact_vr, 0,
803 ELF_NVRREG * sizeof(vector128));
804 }
805
806
807 if (__get_user(current->thread.vrsave,
808 (u32 __user *)&sr->mc_vregs[32]) ||
809 __get_user(current->thread.transact_vrsave,
810 (u32 __user *)&tm_sr->mc_vregs[32]))
811 return 1;
812#endif
813
814 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
815
816 if (copy_fpr_from_user(current, &sr->mc_fregs) ||
817 copy_transact_fpr_from_user(current, &tm_sr->mc_fregs))
818 return 1;
819
820#ifdef CONFIG_VSX
821 regs->msr &= ~MSR_VSX;
822 if (msr & MSR_VSX) {
823
824
825
826
827 if (copy_vsx_from_user(current, &sr->mc_vsregs) ||
828 copy_transact_vsx_from_user(current, &tm_sr->mc_vsregs))
829 return 1;
830 } else if (current->thread.used_vsr)
831 for (i = 0; i < 32 ; i++) {
832 current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
833 current->thread.transact_fpr[i][TS_VSRLOWOFFSET] = 0;
834 }
835#endif
836
837#ifdef CONFIG_SPE
838
839
840
841 regs->msr &= ~MSR_SPE;
842 if (msr & MSR_SPE) {
843 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
844 ELF_NEVRREG * sizeof(u32)))
845 return 1;
846 } else if (current->thread.used_spe)
847 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
848
849
850 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
851 + ELF_NEVRREG))
852 return 1;
853#endif
854
855
856
857
858
859 tm_enable();
860
861 tm_recheckpoint(¤t->thread, msr);
862
863 if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR]))
864 return 1;
865
866 regs->msr = (regs->msr & ~MSR_TS_MASK) | ((msr_hi<<32) & MSR_TS_MASK);
867
868
869 if (msr & MSR_FP) {
870 do_load_up_transact_fpu(¤t->thread);
871 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
872 }
873#ifdef CONFIG_ALTIVEC
874 if (msr & MSR_VEC) {
875 do_load_up_transact_altivec(¤t->thread);
876 regs->msr |= MSR_VEC;
877 }
878#endif
879
880 return 0;
881}
882#endif
883
884#ifdef CONFIG_PPC64
885int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
886{
887 int err;
888
889 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
890 return -EFAULT;
891
892
893
894
895
896
897
898
899
900 err = __put_user(s->si_signo, &d->si_signo);
901 err |= __put_user(s->si_errno, &d->si_errno);
902 err |= __put_user((short)s->si_code, &d->si_code);
903 if (s->si_code < 0)
904 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
905 SI_PAD_SIZE32);
906 else switch(s->si_code >> 16) {
907 case __SI_CHLD >> 16:
908 err |= __put_user(s->si_pid, &d->si_pid);
909 err |= __put_user(s->si_uid, &d->si_uid);
910 err |= __put_user(s->si_utime, &d->si_utime);
911 err |= __put_user(s->si_stime, &d->si_stime);
912 err |= __put_user(s->si_status, &d->si_status);
913 break;
914 case __SI_FAULT >> 16:
915 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
916 &d->si_addr);
917 break;
918 case __SI_POLL >> 16:
919 err |= __put_user(s->si_band, &d->si_band);
920 err |= __put_user(s->si_fd, &d->si_fd);
921 break;
922 case __SI_TIMER >> 16:
923 err |= __put_user(s->si_tid, &d->si_tid);
924 err |= __put_user(s->si_overrun, &d->si_overrun);
925 err |= __put_user(s->si_int, &d->si_int);
926 break;
927 case __SI_RT >> 16:
928 case __SI_MESGQ >> 16:
929 err |= __put_user(s->si_int, &d->si_int);
930
931 case __SI_KILL >> 16:
932 default:
933 err |= __put_user(s->si_pid, &d->si_pid);
934 err |= __put_user(s->si_uid, &d->si_uid);
935 break;
936 }
937 return err;
938}
939
940#define copy_siginfo_to_user copy_siginfo_to_user32
941
942int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
943{
944 memset(to, 0, sizeof *to);
945
946 if (copy_from_user(to, from, 3*sizeof(int)) ||
947 copy_from_user(to->_sifields._pad,
948 from->_sifields._pad, SI_PAD_SIZE32))
949 return -EFAULT;
950
951 return 0;
952}
953#endif
954
955
956
957
958
959int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
960 siginfo_t *info, sigset_t *oldset,
961 struct pt_regs *regs)
962{
963 struct rt_sigframe __user *rt_sf;
964 struct mcontext __user *frame;
965 struct mcontext __user *tm_frame = NULL;
966 void __user *addr;
967 unsigned long newsp = 0;
968 int sigret;
969 unsigned long tramp;
970
971
972
973 rt_sf = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*rt_sf), 1);
974 addr = rt_sf;
975 if (unlikely(rt_sf == NULL))
976 goto badframe;
977
978
979 if (copy_siginfo_to_user(&rt_sf->info, info)
980 || __put_user(0, &rt_sf->uc.uc_flags)
981 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
982 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
983 &rt_sf->uc.uc_regs)
984 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
985 goto badframe;
986
987
988 frame = &rt_sf->uc.uc_mcontext;
989 addr = frame;
990 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
991 sigret = 0;
992 tramp = current->mm->context.vdso_base + vdso32_rt_sigtramp;
993 } else {
994 sigret = __NR_rt_sigreturn;
995 tramp = (unsigned long) frame->tramp;
996 }
997
998#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
999 tm_frame = &rt_sf->uc_transact.uc_mcontext;
1000 if (MSR_TM_ACTIVE(regs->msr)) {
1001 if (save_tm_user_regs(regs, frame, tm_frame, sigret))
1002 goto badframe;
1003 }
1004 else
1005#endif
1006 {
1007 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
1008 goto badframe;
1009 }
1010 regs->link = tramp;
1011
1012#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1013 if (MSR_TM_ACTIVE(regs->msr)) {
1014 if (__put_user((unsigned long)&rt_sf->uc_transact,
1015 &rt_sf->uc.uc_link)
1016 || __put_user((unsigned long)tm_frame, &rt_sf->uc_transact.uc_regs))
1017 goto badframe;
1018 }
1019 else
1020#endif
1021 if (__put_user(0, &rt_sf->uc.uc_link))
1022 goto badframe;
1023
1024 current->thread.fpscr.val = 0;
1025
1026
1027 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
1028 addr = (void __user *)regs->gpr[1];
1029 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1030 goto badframe;
1031
1032
1033 regs->gpr[1] = newsp;
1034 regs->gpr[3] = sig;
1035 regs->gpr[4] = (unsigned long) &rt_sf->info;
1036 regs->gpr[5] = (unsigned long) &rt_sf->uc;
1037 regs->gpr[6] = (unsigned long) rt_sf;
1038 regs->nip = (unsigned long) ka->sa.sa_handler;
1039
1040 regs->msr &= ~MSR_LE;
1041#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1042
1043
1044
1045
1046 regs->msr &= ~MSR_TS_MASK;
1047#endif
1048 return 1;
1049
1050badframe:
1051#ifdef DEBUG_SIG
1052 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
1053 regs, frame, newsp);
1054#endif
1055 if (show_unhandled_signals)
1056 printk_ratelimited(KERN_INFO
1057 "%s[%d]: bad frame in handle_rt_signal32: "
1058 "%p nip %08lx lr %08lx\n",
1059 current->comm, current->pid,
1060 addr, regs->nip, regs->link);
1061
1062 force_sigsegv(sig, current);
1063 return 0;
1064}
1065
1066static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
1067{
1068 sigset_t set;
1069 struct mcontext __user *mcp;
1070
1071 if (get_sigset_t(&set, &ucp->uc_sigmask))
1072 return -EFAULT;
1073#ifdef CONFIG_PPC64
1074 {
1075 u32 cmcp;
1076
1077 if (__get_user(cmcp, &ucp->uc_regs))
1078 return -EFAULT;
1079 mcp = (struct mcontext __user *)(u64)cmcp;
1080
1081 }
1082#else
1083 if (__get_user(mcp, &ucp->uc_regs))
1084 return -EFAULT;
1085 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
1086 return -EFAULT;
1087#endif
1088 set_current_blocked(&set);
1089 if (restore_user_regs(regs, mcp, sig))
1090 return -EFAULT;
1091
1092 return 0;
1093}
1094
1095#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1096static int do_setcontext_tm(struct ucontext __user *ucp,
1097 struct ucontext __user *tm_ucp,
1098 struct pt_regs *regs)
1099{
1100 sigset_t set;
1101 struct mcontext __user *mcp;
1102 struct mcontext __user *tm_mcp;
1103 u32 cmcp;
1104 u32 tm_cmcp;
1105
1106 if (get_sigset_t(&set, &ucp->uc_sigmask))
1107 return -EFAULT;
1108
1109 if (__get_user(cmcp, &ucp->uc_regs) ||
1110 __get_user(tm_cmcp, &tm_ucp->uc_regs))
1111 return -EFAULT;
1112 mcp = (struct mcontext __user *)(u64)cmcp;
1113 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
1114
1115
1116 set_current_blocked(&set);
1117 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1118 return -EFAULT;
1119
1120 return 0;
1121}
1122#endif
1123
1124long sys_swapcontext(struct ucontext __user *old_ctx,
1125 struct ucontext __user *new_ctx,
1126 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
1127{
1128 unsigned char tmp;
1129 int ctx_has_vsx_region = 0;
1130
1131#ifdef CONFIG_PPC64
1132 unsigned long new_msr = 0;
1133
1134 if (new_ctx) {
1135 struct mcontext __user *mcp;
1136 u32 cmcp;
1137
1138
1139
1140
1141
1142
1143 if (__get_user(cmcp, &new_ctx->uc_regs))
1144 return -EFAULT;
1145 mcp = (struct mcontext __user *)(u64)cmcp;
1146 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1147 return -EFAULT;
1148 }
1149
1150
1151
1152
1153 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1154 return -EINVAL;
1155
1156
1157
1158
1159 if ((ctx_size < sizeof(struct ucontext)) &&
1160 (new_msr & MSR_VSX))
1161 return -EINVAL;
1162
1163 if (ctx_size >= sizeof(struct ucontext))
1164 ctx_has_vsx_region = 1;
1165#else
1166
1167
1168
1169 if (ctx_size < sizeof(struct ucontext))
1170 return -EINVAL;
1171#endif
1172 if (old_ctx != NULL) {
1173 struct mcontext __user *mctx;
1174
1175
1176
1177
1178
1179
1180
1181
1182 mctx = (struct mcontext __user *)
1183 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1184 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
1185 || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
1186 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
1187 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1188 return -EFAULT;
1189 }
1190 if (new_ctx == NULL)
1191 return 0;
1192 if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
1193 || __get_user(tmp, (u8 __user *) new_ctx)
1194 || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
1195 return -EFAULT;
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208 if (do_setcontext(new_ctx, regs, 0))
1209 do_exit(SIGSEGV);
1210
1211 set_thread_flag(TIF_RESTOREALL);
1212 return 0;
1213}
1214
1215long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1216 struct pt_regs *regs)
1217{
1218 struct rt_sigframe __user *rt_sf;
1219#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1220 struct ucontext __user *uc_transact;
1221 unsigned long msr_hi;
1222 unsigned long tmp;
1223 int tm_restore = 0;
1224#endif
1225
1226 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1227
1228 rt_sf = (struct rt_sigframe __user *)
1229 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1230 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1231 goto bad;
1232#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1233 if (__get_user(tmp, &rt_sf->uc.uc_link))
1234 goto bad;
1235 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1236 if (uc_transact) {
1237 u32 cmcp;
1238 struct mcontext __user *mcp;
1239
1240 if (__get_user(cmcp, &uc_transact->uc_regs))
1241 return -EFAULT;
1242 mcp = (struct mcontext __user *)(u64)cmcp;
1243
1244
1245 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1246 goto bad;
1247
1248 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1249
1250
1251
1252 tm_restore = 1;
1253 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1254 goto bad;
1255 }
1256 }
1257 if (!tm_restore)
1258
1259#endif
1260 if (do_setcontext(&rt_sf->uc, regs, 1))
1261 goto bad;
1262
1263
1264
1265
1266
1267
1268
1269
1270#ifdef CONFIG_PPC64
1271 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1272 goto bad;
1273#else
1274 if (restore_altstack(&rt_sf->uc.uc_stack))
1275 goto bad;
1276#endif
1277 set_thread_flag(TIF_RESTOREALL);
1278 return 0;
1279
1280 bad:
1281 if (show_unhandled_signals)
1282 printk_ratelimited(KERN_INFO
1283 "%s[%d]: bad frame in sys_rt_sigreturn: "
1284 "%p nip %08lx lr %08lx\n",
1285 current->comm, current->pid,
1286 rt_sf, regs->nip, regs->link);
1287
1288 force_sig(SIGSEGV, current);
1289 return 0;
1290}
1291
1292#ifdef CONFIG_PPC32
1293int sys_debug_setcontext(struct ucontext __user *ctx,
1294 int ndbg, struct sig_dbg_op __user *dbg,
1295 int r6, int r7, int r8,
1296 struct pt_regs *regs)
1297{
1298 struct sig_dbg_op op;
1299 int i;
1300 unsigned char tmp;
1301 unsigned long new_msr = regs->msr;
1302#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1303 unsigned long new_dbcr0 = current->thread.dbcr0;
1304#endif
1305
1306 for (i=0; i<ndbg; i++) {
1307 if (copy_from_user(&op, dbg + i, sizeof(op)))
1308 return -EFAULT;
1309 switch (op.dbg_type) {
1310 case SIG_DBG_SINGLE_STEPPING:
1311#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1312 if (op.dbg_value) {
1313 new_msr |= MSR_DE;
1314 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1315 } else {
1316 new_dbcr0 &= ~DBCR0_IC;
1317 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1318 current->thread.dbcr1)) {
1319 new_msr &= ~MSR_DE;
1320 new_dbcr0 &= ~DBCR0_IDM;
1321 }
1322 }
1323#else
1324 if (op.dbg_value)
1325 new_msr |= MSR_SE;
1326 else
1327 new_msr &= ~MSR_SE;
1328#endif
1329 break;
1330 case SIG_DBG_BRANCH_TRACING:
1331#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1332 return -EINVAL;
1333#else
1334 if (op.dbg_value)
1335 new_msr |= MSR_BE;
1336 else
1337 new_msr &= ~MSR_BE;
1338#endif
1339 break;
1340
1341 default:
1342 return -EINVAL;
1343 }
1344 }
1345
1346
1347
1348
1349
1350
1351 regs->msr = new_msr;
1352#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1353 current->thread.dbcr0 = new_dbcr0;
1354#endif
1355
1356 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1357 || __get_user(tmp, (u8 __user *) ctx)
1358 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1359 return -EFAULT;
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372 if (do_setcontext(ctx, regs, 1)) {
1373 if (show_unhandled_signals)
1374 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1375 "sys_debug_setcontext: %p nip %08lx "
1376 "lr %08lx\n",
1377 current->comm, current->pid,
1378 ctx, regs->nip, regs->link);
1379
1380 force_sig(SIGSEGV, current);
1381 goto out;
1382 }
1383
1384
1385
1386
1387
1388
1389
1390
1391 restore_altstack(&ctx->uc_stack);
1392
1393 set_thread_flag(TIF_RESTOREALL);
1394 out:
1395 return 0;
1396}
1397#endif
1398
1399
1400
1401
1402int handle_signal32(unsigned long sig, struct k_sigaction *ka,
1403 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
1404{
1405 struct sigcontext __user *sc;
1406 struct sigframe __user *frame;
1407 struct mcontext __user *tm_mctx = NULL;
1408 unsigned long newsp = 0;
1409 int sigret;
1410 unsigned long tramp;
1411
1412
1413 frame = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*frame), 1);
1414 if (unlikely(frame == NULL))
1415 goto badframe;
1416 sc = (struct sigcontext __user *) &frame->sctx;
1417
1418#if _NSIG != 64
1419#error "Please adjust handle_signal()"
1420#endif
1421 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1422 || __put_user(oldset->sig[0], &sc->oldmask)
1423#ifdef CONFIG_PPC64
1424 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1425#else
1426 || __put_user(oldset->sig[1], &sc->_unused[3])
1427#endif
1428 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1429 || __put_user(sig, &sc->signal))
1430 goto badframe;
1431
1432 if (vdso32_sigtramp && current->mm->context.vdso_base) {
1433 sigret = 0;
1434 tramp = current->mm->context.vdso_base + vdso32_sigtramp;
1435 } else {
1436 sigret = __NR_sigreturn;
1437 tramp = (unsigned long) frame->mctx.tramp;
1438 }
1439
1440#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1441 tm_mctx = &frame->mctx_transact;
1442 if (MSR_TM_ACTIVE(regs->msr)) {
1443 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1444 sigret))
1445 goto badframe;
1446 }
1447 else
1448#endif
1449 {
1450 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1451 goto badframe;
1452 }
1453
1454 regs->link = tramp;
1455
1456 current->thread.fpscr.val = 0;
1457
1458
1459 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1460 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1461 goto badframe;
1462
1463 regs->gpr[1] = newsp;
1464 regs->gpr[3] = sig;
1465 regs->gpr[4] = (unsigned long) sc;
1466 regs->nip = (unsigned long) ka->sa.sa_handler;
1467
1468 regs->msr &= ~MSR_LE;
1469#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1470
1471
1472
1473
1474 regs->msr &= ~MSR_TS_MASK;
1475#endif
1476 return 1;
1477
1478badframe:
1479#ifdef DEBUG_SIG
1480 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1481 regs, frame, newsp);
1482#endif
1483 if (show_unhandled_signals)
1484 printk_ratelimited(KERN_INFO
1485 "%s[%d]: bad frame in handle_signal32: "
1486 "%p nip %08lx lr %08lx\n",
1487 current->comm, current->pid,
1488 frame, regs->nip, regs->link);
1489
1490 force_sigsegv(sig, current);
1491 return 0;
1492}
1493
1494
1495
1496
1497long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1498 struct pt_regs *regs)
1499{
1500 struct sigframe __user *sf;
1501 struct sigcontext __user *sc;
1502 struct sigcontext sigctx;
1503 struct mcontext __user *sr;
1504 void __user *addr;
1505 sigset_t set;
1506#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1507 struct mcontext __user *mcp, *tm_mcp;
1508 unsigned long msr_hi;
1509#endif
1510
1511
1512 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1513
1514 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1515 sc = &sf->sctx;
1516 addr = sc;
1517 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1518 goto badframe;
1519
1520#ifdef CONFIG_PPC64
1521
1522
1523
1524
1525 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1526#else
1527 set.sig[0] = sigctx.oldmask;
1528 set.sig[1] = sigctx._unused[3];
1529#endif
1530 set_current_blocked(&set);
1531
1532#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1533 mcp = (struct mcontext __user *)&sf->mctx;
1534 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1535 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1536 goto badframe;
1537 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1538 if (!cpu_has_feature(CPU_FTR_TM))
1539 goto badframe;
1540 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1541 goto badframe;
1542 } else
1543#endif
1544 {
1545 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1546 addr = sr;
1547 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1548 || restore_user_regs(regs, sr, 1))
1549 goto badframe;
1550 }
1551
1552 set_thread_flag(TIF_RESTOREALL);
1553 return 0;
1554
1555badframe:
1556 if (show_unhandled_signals)
1557 printk_ratelimited(KERN_INFO
1558 "%s[%d]: bad frame in sys_sigreturn: "
1559 "%p nip %08lx lr %08lx\n",
1560 current->comm, current->pid,
1561 addr, regs->nip, regs->link);
1562
1563 force_sig(SIGSEGV, current);
1564 return 0;
1565}
1566