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