2 * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC
5 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
6 * Copyright (C) 2001 IBM
7 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
8 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
10 * Derived from "arch/i386/kernel/signal.c"
11 * Copyright (C) 1991, 1992 Linus Torvalds
12 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation; either version
17 * 2 of the License, or (at your option) any later version.
20 #include <linux/sched.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>
30 #include <linux/syscalls.h>
31 #include <linux/compat.h>
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>
40 #include <asm/uaccess.h>
41 #include <asm/cacheflush.h>
42 #include <asm/syscalls.h>
43 #include <asm/sigcontext.h>
45 #include <asm/switch_to.h>
49 #include <asm/unistd.h>
51 #include <asm/ucontext.h>
52 #include <asm/pgtable.h>
60 #define sys_rt_sigreturn compat_sys_rt_sigreturn
61 #define sys_swapcontext compat_sys_swapcontext
62 #define sys_sigreturn compat_sys_sigreturn
64 #define old_sigaction old_sigaction32
65 #define sigcontext sigcontext32
66 #define mcontext mcontext32
67 #define ucontext ucontext32
69 #define __save_altstack __compat_save_altstack
72 * Userspace code may pass a ucontext which doesn't include VSX added
73 * at the end. We need to check for this case.
75 #define UCONTEXTSIZEWITHOUTVSX \
76 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32))
79 * Returning 0 means we return to userspace via
80 * ret_from_except and thus restore all user
81 * registers from *regs. This is what we need
82 * to do when a signal has been delivered.
85 #define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
86 #undef __SIGNAL_FRAMESIZE
87 #define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
89 #define ELF_NVRREG ELF_NVRREG32
92 * Functions for flipping sigsets (thanks to brain dead generic
93 * implementation that makes things simple for little endian only)
95 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
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;
109 return copy_to_user(uset, &cset, sizeof(*uset));
112 static inline int get_sigset_t(sigset_t *set,
113 const compat_sigset_t __user *uset)
117 if (copy_from_user(&s32, uset, sizeof(*uset)))
121 * Swap the 2 words of the 64-bit sigset_t (they are stored
122 * in the "wrong" endian in 32-bit user storage).
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);
133 #define to_user_ptr(p) ptr_to_compat(p)
134 #define from_user_ptr(p) compat_ptr(p)
136 static inline int save_general_regs(struct pt_regs *regs,
137 struct mcontext __user *frame)
139 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
142 WARN_ON(!FULL_REGS(regs));
144 for (i = 0; i <= PT_RESULT; i ++) {
145 if (i == 14 && !FULL_REGS(regs))
147 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
153 static inline int restore_general_regs(struct pt_regs *regs,
154 struct mcontext __user *sr)
156 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
159 for (i = 0; i <= PT_RESULT; i++) {
160 if ((i == PT_MSR) || (i == PT_SOFTE))
162 if (__get_user(gregs[i], &sr->mc_gregs[i]))
168 #else /* CONFIG_PPC64 */
170 #define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
172 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
174 return copy_to_user(uset, set, sizeof(*uset));
177 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
179 return copy_from_user(set, uset, sizeof(*uset));
182 #define to_user_ptr(p) ((unsigned long)(p))
183 #define from_user_ptr(p) ((void __user *)(p))
185 static inline int save_general_regs(struct pt_regs *regs,
186 struct mcontext __user *frame)
188 WARN_ON(!FULL_REGS(regs));
189 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
192 static inline int restore_general_regs(struct pt_regs *regs,
193 struct mcontext __user *sr)
195 /* copy up to but not including MSR */
196 if (__copy_from_user(regs, &sr->mc_gregs,
197 PT_MSR * sizeof(elf_greg_t)))
199 /* copy from orig_r3 (the word after the MSR) up to the end */
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)))
208 * When we have signals to deliver, we set up on the
209 * user stack, going down from the original stack pointer:
210 * an ABI gap of 56 words
212 * a sigcontext struct
213 * a gap of __SIGNAL_FRAMESIZE bytes
215 * Each of these things must be a multiple of 16 bytes in size. The following
216 * structure represent all of this except the __SIGNAL_FRAMESIZE gap
220 struct sigcontext sctx; /* the sigcontext */
221 struct mcontext mctx; /* all the register values */
222 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
223 struct sigcontext sctx_transact;
224 struct mcontext mctx_transact;
227 * Programs using the rs6000/xcoff abi can save up to 19 gp
228 * regs and 18 fp regs below sp before decrementing it.
233 /* We use the mc_pad field for the signal return trampoline. */
237 * When we have rt signals to deliver, we set up on the
238 * user stack, going down from the original stack pointer:
239 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
240 * a gap of __SIGNAL_FRAMESIZE+16 bytes
241 * (the +16 is to get the siginfo and ucontext in the same
242 * positions as in older kernels).
244 * Each of these things must be a multiple of 16 bytes in size.
249 compat_siginfo_t info;
254 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
255 struct ucontext uc_transact;
258 * Programs using the rs6000/xcoff abi can save up to 19 gp
259 * regs and 18 fp regs below sp before decrementing it.
265 unsigned long copy_fpr_to_user(void __user *to,
266 struct task_struct *task)
271 /* save FPR copy to local buffer then write to the thread_struct */
272 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
273 buf[i] = task->thread.TS_FPR(i);
274 buf[i] = task->thread.fp_state.fpscr;
275 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
278 unsigned long copy_fpr_from_user(struct task_struct *task,
284 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
286 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
287 task->thread.TS_FPR(i) = buf[i];
288 task->thread.fp_state.fpscr = buf[i];
293 unsigned long copy_vsx_to_user(void __user *to,
294 struct task_struct *task)
296 u64 buf[ELF_NVSRHALFREG];
299 /* save FPR copy to local buffer then write to the thread_struct */
300 for (i = 0; i < ELF_NVSRHALFREG; i++)
301 buf[i] = task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET];
302 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
305 unsigned long copy_vsx_from_user(struct task_struct *task,
308 u64 buf[ELF_NVSRHALFREG];
311 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
313 for (i = 0; i < ELF_NVSRHALFREG ; i++)
314 task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = buf[i];
318 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
319 unsigned long copy_transact_fpr_to_user(void __user *to,
320 struct task_struct *task)
325 /* save FPR copy to local buffer then write to the thread_struct */
326 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
327 buf[i] = task->thread.TS_TRANS_FPR(i);
328 buf[i] = task->thread.transact_fp.fpscr;
329 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
332 unsigned long copy_transact_fpr_from_user(struct task_struct *task,
338 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
340 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
341 task->thread.TS_TRANS_FPR(i) = buf[i];
342 task->thread.transact_fp.fpscr = buf[i];
347 unsigned long copy_transact_vsx_to_user(void __user *to,
348 struct task_struct *task)
350 u64 buf[ELF_NVSRHALFREG];
353 /* save FPR copy to local buffer then write to the thread_struct */
354 for (i = 0; i < ELF_NVSRHALFREG; i++)
355 buf[i] = task->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET];
356 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
359 unsigned long copy_transact_vsx_from_user(struct task_struct *task,
362 u64 buf[ELF_NVSRHALFREG];
365 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
367 for (i = 0; i < ELF_NVSRHALFREG ; i++)
368 task->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET] = buf[i];
371 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
373 inline unsigned long copy_fpr_to_user(void __user *to,
374 struct task_struct *task)
376 return __copy_to_user(to, task->thread.fp_state.fpr,
377 ELF_NFPREG * sizeof(double));
380 inline unsigned long copy_fpr_from_user(struct task_struct *task,
383 return __copy_from_user(task->thread.fp_state.fpr, from,
384 ELF_NFPREG * sizeof(double));
387 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
388 inline unsigned long copy_transact_fpr_to_user(void __user *to,
389 struct task_struct *task)
391 return __copy_to_user(to, task->thread.transact_fp.fpr,
392 ELF_NFPREG * sizeof(double));
395 inline unsigned long copy_transact_fpr_from_user(struct task_struct *task,
398 return __copy_from_user(task->thread.transact_fp.fpr, from,
399 ELF_NFPREG * sizeof(double));
401 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
405 * Save the current user registers on the user stack.
406 * We only save the altivec/spe registers if the process has used
407 * altivec/spe instructions at some point.
409 static 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)
413 unsigned long msr = regs->msr;
415 /* Make sure floating point registers are stored in regs */
416 flush_fp_to_thread(current);
418 /* save general registers */
419 if (save_general_regs(regs, frame))
422 #ifdef CONFIG_ALTIVEC
423 /* save altivec registers */
424 if (current->thread.used_vr) {
425 flush_altivec_to_thread(current);
426 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state,
427 ELF_NVRREG * sizeof(vector128)))
429 /* set MSR_VEC in the saved MSR value to indicate that
430 frame->mc_vregs contains valid data */
433 /* else assert((regs->msr & MSR_VEC) == 0) */
435 /* We always copy to/from vrsave, it's 0 if we don't have or don't
436 * use altivec. Since VSCR only contains 32 bits saved in the least
437 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
438 * most significant bits of that same vector. --BenH
439 * Note that the current VRSAVE value is in the SPR at this point.
441 if (cpu_has_feature(CPU_FTR_ALTIVEC))
442 current->thread.vrsave = mfspr(SPRN_VRSAVE);
443 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
445 #endif /* CONFIG_ALTIVEC */
446 if (copy_fpr_to_user(&frame->mc_fregs, current))
450 * Copy VSR 0-31 upper half from thread_struct to local
451 * buffer, then write that to userspace. Also set MSR_VSX in
452 * the saved MSR value to indicate that frame->mc_vregs
453 * contains valid data
455 if (current->thread.used_vsr && ctx_has_vsx_region) {
456 __giveup_vsx(current);
457 if (copy_vsx_to_user(&frame->mc_vsregs, current))
460 } else if (!ctx_has_vsx_region)
462 * With a small context structure we can't hold the VSX
463 * registers, hence clear the MSR value to indicate the state
469 #endif /* CONFIG_VSX */
471 /* save spe registers */
472 if (current->thread.used_spe) {
473 flush_spe_to_thread(current);
474 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
475 ELF_NEVRREG * sizeof(u32)))
477 /* set MSR_SPE in the saved MSR value to indicate that
478 frame->mc_vregs contains valid data */
481 /* else assert((regs->msr & MSR_SPE) == 0) */
483 /* We always copy to/from spefscr */
484 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
486 #endif /* CONFIG_SPE */
488 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
490 /* We need to write 0 the MSR top 32 bits in the tm frame so that we
491 * can check it on the restore to see if TM is active
493 if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR]))
497 /* Set up the sigreturn trampoline: li r0,sigret; sc */
498 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
499 || __put_user(0x44000002UL, &frame->tramp[1]))
501 flush_icache_range((unsigned long) &frame->tramp[0],
502 (unsigned long) &frame->tramp[2]);
508 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
510 * Save the current user registers on the user stack.
511 * We only save the altivec/spe registers if the process has used
512 * altivec/spe instructions at some point.
513 * We also save the transactional registers to a second ucontext in the
516 * See save_user_regs() and signal_64.c:setup_tm_sigcontexts().
518 static int save_tm_user_regs(struct pt_regs *regs,
519 struct mcontext __user *frame,
520 struct mcontext __user *tm_frame, int sigret)
522 unsigned long msr = regs->msr;
524 /* Make sure floating point registers are stored in regs */
525 flush_fp_to_thread(current);
527 /* Save both sets of general registers */
528 if (save_general_regs(¤t->thread.ckpt_regs, frame)
529 || save_general_regs(regs, tm_frame))
532 /* Stash the top half of the 64bit MSR into the 32bit MSR word
533 * of the transactional mcontext. This way we have a backward-compatible
534 * MSR in the 'normal' (checkpointed) mcontext and additionally one can
535 * also look at what type of transaction (T or S) was active at the
536 * time of the signal.
538 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
541 #ifdef CONFIG_ALTIVEC
542 /* save altivec registers */
543 if (current->thread.used_vr) {
544 flush_altivec_to_thread(current);
545 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state,
546 ELF_NVRREG * sizeof(vector128)))
549 if (__copy_to_user(&tm_frame->mc_vregs,
550 ¤t->thread.transact_vr,
551 ELF_NVRREG * sizeof(vector128)))
554 if (__copy_to_user(&tm_frame->mc_vregs,
555 ¤t->thread.vr_state,
556 ELF_NVRREG * sizeof(vector128)))
560 /* set MSR_VEC in the saved MSR value to indicate that
561 * frame->mc_vregs contains valid data
566 /* We always copy to/from vrsave, it's 0 if we don't have or don't
567 * use altivec. Since VSCR only contains 32 bits saved in the least
568 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
569 * most significant bits of that same vector. --BenH
571 if (cpu_has_feature(CPU_FTR_ALTIVEC))
572 current->thread.vrsave = mfspr(SPRN_VRSAVE);
573 if (__put_user(current->thread.vrsave,
574 (u32 __user *)&frame->mc_vregs[32]))
577 if (__put_user(current->thread.transact_vrsave,
578 (u32 __user *)&tm_frame->mc_vregs[32]))
581 if (__put_user(current->thread.vrsave,
582 (u32 __user *)&tm_frame->mc_vregs[32]))
585 #endif /* CONFIG_ALTIVEC */
587 if (copy_fpr_to_user(&frame->mc_fregs, current))
590 if (copy_transact_fpr_to_user(&tm_frame->mc_fregs, current))
593 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
599 * Copy VSR 0-31 upper half from thread_struct to local
600 * buffer, then write that to userspace. Also set MSR_VSX in
601 * the saved MSR value to indicate that frame->mc_vregs
602 * contains valid data
604 if (current->thread.used_vsr) {
605 __giveup_vsx(current);
606 if (copy_vsx_to_user(&frame->mc_vsregs, current))
609 if (copy_transact_vsx_to_user(&tm_frame->mc_vsregs,
613 if (copy_vsx_to_user(&tm_frame->mc_vsregs, current))
619 #endif /* CONFIG_VSX */
621 /* SPE regs are not checkpointed with TM, so this section is
622 * simply the same as in save_user_regs().
624 if (current->thread.used_spe) {
625 flush_spe_to_thread(current);
626 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
627 ELF_NEVRREG * sizeof(u32)))
629 /* set MSR_SPE in the saved MSR value to indicate that
630 * frame->mc_vregs contains valid data */
634 /* We always copy to/from spefscr */
635 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
637 #endif /* CONFIG_SPE */
639 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
642 /* Set up the sigreturn trampoline: li r0,sigret; sc */
643 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
644 || __put_user(0x44000002UL, &frame->tramp[1]))
646 flush_icache_range((unsigned long) &frame->tramp[0],
647 (unsigned long) &frame->tramp[2]);
655 * Restore the current user register values from the user stack,
658 static long restore_user_regs(struct pt_regs *regs,
659 struct mcontext __user *sr, int sig)
662 unsigned int save_r2 = 0;
669 * restore general registers but not including MSR or SOFTE. Also
670 * take care of keeping r2 (TLS) intact if not a signal
673 save_r2 = (unsigned int)regs->gpr[2];
674 err = restore_general_regs(regs, sr);
676 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
678 regs->gpr[2] = (unsigned long) save_r2;
682 /* if doing signal return, restore the previous little-endian mode */
684 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
687 * Do this before updating the thread state in
688 * current->thread.fpr/vr/evr. That way, if we get preempted
689 * and another task grabs the FPU/Altivec/SPE, it won't be
690 * tempted to save the current CPU state into the thread_struct
691 * and corrupt what we are writing there.
693 discard_lazy_cpu_state();
695 #ifdef CONFIG_ALTIVEC
697 * Force the process to reload the altivec registers from
698 * current->thread when it next does altivec instructions
700 regs->msr &= ~MSR_VEC;
702 /* restore altivec registers from the stack */
703 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
704 sizeof(sr->mc_vregs)))
706 } else if (current->thread.used_vr)
707 memset(¤t->thread.vr_state, 0,
708 ELF_NVRREG * sizeof(vector128));
710 /* Always get VRSAVE back */
711 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
713 if (cpu_has_feature(CPU_FTR_ALTIVEC))
714 mtspr(SPRN_VRSAVE, current->thread.vrsave);
715 #endif /* CONFIG_ALTIVEC */
716 if (copy_fpr_from_user(current, &sr->mc_fregs))
721 * Force the process to reload the VSX registers from
722 * current->thread when it next does VSX instruction.
724 regs->msr &= ~MSR_VSX;
727 * Restore altivec registers from the stack to a local
728 * buffer, then write this out to the thread_struct
730 if (copy_vsx_from_user(current, &sr->mc_vsregs))
732 } else if (current->thread.used_vsr)
733 for (i = 0; i < 32 ; i++)
734 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
735 #endif /* CONFIG_VSX */
737 * force the process to reload the FP registers from
738 * current->thread when it next does FP instructions
740 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
743 /* force the process to reload the spe registers from
744 current->thread when it next does spe instructions */
745 regs->msr &= ~MSR_SPE;
747 /* restore spe registers from the stack */
748 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
749 ELF_NEVRREG * sizeof(u32)))
751 } else if (current->thread.used_spe)
752 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
754 /* Always get SPEFSCR back */
755 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
757 #endif /* CONFIG_SPE */
762 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
764 * Restore the current user register values from the user stack, except for
765 * MSR, and recheckpoint the original checkpointed register state for processes
768 static long restore_tm_user_regs(struct pt_regs *regs,
769 struct mcontext __user *sr,
770 struct mcontext __user *tm_sr)
773 unsigned long msr, msr_hi;
779 * restore general registers but not including MSR or SOFTE. Also
780 * take care of keeping r2 (TLS) intact if not a signal.
781 * See comment in signal_64.c:restore_tm_sigcontexts();
782 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
783 * were set by the signal delivery.
785 err = restore_general_regs(regs, tm_sr);
786 err |= restore_general_regs(¤t->thread.ckpt_regs, sr);
788 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
790 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
794 /* Restore the previous little-endian mode */
795 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
798 * Do this before updating the thread state in
799 * current->thread.fpr/vr/evr. That way, if we get preempted
800 * and another task grabs the FPU/Altivec/SPE, it won't be
801 * tempted to save the current CPU state into the thread_struct
802 * and corrupt what we are writing there.
804 discard_lazy_cpu_state();
806 #ifdef CONFIG_ALTIVEC
807 regs->msr &= ~MSR_VEC;
809 /* restore altivec registers from the stack */
810 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
811 sizeof(sr->mc_vregs)) ||
812 __copy_from_user(¤t->thread.transact_vr,
814 sizeof(sr->mc_vregs)))
816 } else if (current->thread.used_vr) {
817 memset(¤t->thread.vr_state, 0,
818 ELF_NVRREG * sizeof(vector128));
819 memset(¤t->thread.transact_vr, 0,
820 ELF_NVRREG * sizeof(vector128));
823 /* Always get VRSAVE back */
824 if (__get_user(current->thread.vrsave,
825 (u32 __user *)&sr->mc_vregs[32]) ||
826 __get_user(current->thread.transact_vrsave,
827 (u32 __user *)&tm_sr->mc_vregs[32]))
829 if (cpu_has_feature(CPU_FTR_ALTIVEC))
830 mtspr(SPRN_VRSAVE, current->thread.vrsave);
831 #endif /* CONFIG_ALTIVEC */
833 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
835 if (copy_fpr_from_user(current, &sr->mc_fregs) ||
836 copy_transact_fpr_from_user(current, &tm_sr->mc_fregs))
840 regs->msr &= ~MSR_VSX;
843 * Restore altivec registers from the stack to a local
844 * buffer, then write this out to the thread_struct
846 if (copy_vsx_from_user(current, &sr->mc_vsregs) ||
847 copy_transact_vsx_from_user(current, &tm_sr->mc_vsregs))
849 } else if (current->thread.used_vsr)
850 for (i = 0; i < 32 ; i++) {
851 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
852 current->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET] = 0;
854 #endif /* CONFIG_VSX */
857 /* SPE regs are not checkpointed with TM, so this section is
858 * simply the same as in restore_user_regs().
860 regs->msr &= ~MSR_SPE;
862 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
863 ELF_NEVRREG * sizeof(u32)))
865 } else if (current->thread.used_spe)
866 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
868 /* Always get SPEFSCR back */
869 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
872 #endif /* CONFIG_SPE */
874 /* Now, recheckpoint. This loads up all of the checkpointed (older)
875 * registers, including FP and V[S]Rs. After recheckpointing, the
876 * transactional versions should be loaded.
879 /* This loads the checkpointed FP/VEC state, if used */
880 tm_recheckpoint(¤t->thread, msr);
881 /* Get the top half of the MSR */
882 if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR]))
884 /* Pull in MSR TM from user context */
885 regs->msr = (regs->msr & ~MSR_TS_MASK) | ((msr_hi<<32) & MSR_TS_MASK);
887 /* This loads the speculative FP/VEC state, if used */
889 do_load_up_transact_fpu(¤t->thread);
890 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
892 #ifdef CONFIG_ALTIVEC
894 do_load_up_transact_altivec(¤t->thread);
895 regs->msr |= MSR_VEC;
904 int copy_siginfo_to_user32(struct compat_siginfo __user *d, const siginfo_t *s)
908 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
911 /* If you change siginfo_t structure, please be sure
912 * this code is fixed accordingly.
913 * It should never copy any pad contained in the structure
914 * to avoid security leaks, but must copy the generic
915 * 3 ints plus the relevant union member.
916 * This routine must convert siginfo from 64bit to 32bit as well
919 err = __put_user(s->si_signo, &d->si_signo);
920 err |= __put_user(s->si_errno, &d->si_errno);
921 err |= __put_user((short)s->si_code, &d->si_code);
923 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
925 else switch(s->si_code >> 16) {
926 case __SI_CHLD >> 16:
927 err |= __put_user(s->si_pid, &d->si_pid);
928 err |= __put_user(s->si_uid, &d->si_uid);
929 err |= __put_user(s->si_utime, &d->si_utime);
930 err |= __put_user(s->si_stime, &d->si_stime);
931 err |= __put_user(s->si_status, &d->si_status);
933 case __SI_FAULT >> 16:
934 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
937 case __SI_POLL >> 16:
938 err |= __put_user(s->si_band, &d->si_band);
939 err |= __put_user(s->si_fd, &d->si_fd);
941 case __SI_TIMER >> 16:
942 err |= __put_user(s->si_tid, &d->si_tid);
943 err |= __put_user(s->si_overrun, &d->si_overrun);
944 err |= __put_user(s->si_int, &d->si_int);
946 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
947 case __SI_MESGQ >> 16:
948 err |= __put_user(s->si_int, &d->si_int);
950 case __SI_KILL >> 16:
952 err |= __put_user(s->si_pid, &d->si_pid);
953 err |= __put_user(s->si_uid, &d->si_uid);
959 #define copy_siginfo_to_user copy_siginfo_to_user32
961 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
963 memset(to, 0, sizeof *to);
965 if (copy_from_user(to, from, 3*sizeof(int)) ||
966 copy_from_user(to->_sifields._pad,
967 from->_sifields._pad, SI_PAD_SIZE32))
972 #endif /* CONFIG_PPC64 */
975 * Set up a signal frame for a "real-time" signal handler
976 * (one which gets siginfo).
978 int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
979 siginfo_t *info, sigset_t *oldset,
980 struct pt_regs *regs)
982 struct rt_sigframe __user *rt_sf;
983 struct mcontext __user *frame;
984 struct mcontext __user *tm_frame = NULL;
986 unsigned long newsp = 0;
990 /* Set up Signal Frame */
991 /* Put a Real Time Context onto stack */
992 rt_sf = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*rt_sf), 1);
994 if (unlikely(rt_sf == NULL))
997 /* Put the siginfo & fill in most of the ucontext */
998 if (copy_siginfo_to_user(&rt_sf->info, info)
999 || __put_user(0, &rt_sf->uc.uc_flags)
1000 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
1001 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
1003 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
1006 /* Save user registers on the stack */
1007 frame = &rt_sf->uc.uc_mcontext;
1009 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
1011 tramp = current->mm->context.vdso_base + vdso32_rt_sigtramp;
1013 sigret = __NR_rt_sigreturn;
1014 tramp = (unsigned long) frame->tramp;
1017 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1018 tm_frame = &rt_sf->uc_transact.uc_mcontext;
1019 if (MSR_TM_ACTIVE(regs->msr)) {
1020 if (save_tm_user_regs(regs, frame, tm_frame, sigret))
1026 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
1031 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1032 if (MSR_TM_ACTIVE(regs->msr)) {
1033 if (__put_user((unsigned long)&rt_sf->uc_transact,
1035 || __put_user((unsigned long)tm_frame, &rt_sf->uc_transact.uc_regs))
1040 if (__put_user(0, &rt_sf->uc.uc_link))
1043 current->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1045 /* create a stack frame for the caller of the handler */
1046 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
1047 addr = (void __user *)regs->gpr[1];
1048 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1051 /* Fill registers for signal handler */
1052 regs->gpr[1] = newsp;
1054 regs->gpr[4] = (unsigned long) &rt_sf->info;
1055 regs->gpr[5] = (unsigned long) &rt_sf->uc;
1056 regs->gpr[6] = (unsigned long) rt_sf;
1057 regs->nip = (unsigned long) ka->sa.sa_handler;
1058 /* enter the signal handler in native-endian mode */
1059 regs->msr &= ~MSR_LE;
1060 regs->msr |= (MSR_KERNEL & MSR_LE);
1061 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1062 /* Remove TM bits from thread's MSR. The MSR in the sigcontext
1063 * just indicates to userland that we were doing a transaction, but we
1064 * don't want to return in transactional state:
1066 regs->msr &= ~MSR_TS_MASK;
1072 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
1073 regs, frame, newsp);
1075 if (show_unhandled_signals)
1076 printk_ratelimited(KERN_INFO
1077 "%s[%d]: bad frame in handle_rt_signal32: "
1078 "%p nip %08lx lr %08lx\n",
1079 current->comm, current->pid,
1080 addr, regs->nip, regs->link);
1082 force_sigsegv(sig, current);
1086 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
1089 struct mcontext __user *mcp;
1091 if (get_sigset_t(&set, &ucp->uc_sigmask))
1097 if (__get_user(cmcp, &ucp->uc_regs))
1099 mcp = (struct mcontext __user *)(u64)cmcp;
1100 /* no need to check access_ok(mcp), since mcp < 4GB */
1103 if (__get_user(mcp, &ucp->uc_regs))
1105 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
1108 set_current_blocked(&set);
1109 if (restore_user_regs(regs, mcp, sig))
1115 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1116 static int do_setcontext_tm(struct ucontext __user *ucp,
1117 struct ucontext __user *tm_ucp,
1118 struct pt_regs *regs)
1121 struct mcontext __user *mcp;
1122 struct mcontext __user *tm_mcp;
1126 if (get_sigset_t(&set, &ucp->uc_sigmask))
1129 if (__get_user(cmcp, &ucp->uc_regs) ||
1130 __get_user(tm_cmcp, &tm_ucp->uc_regs))
1132 mcp = (struct mcontext __user *)(u64)cmcp;
1133 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
1134 /* no need to check access_ok(mcp), since mcp < 4GB */
1136 set_current_blocked(&set);
1137 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1144 long sys_swapcontext(struct ucontext __user *old_ctx,
1145 struct ucontext __user *new_ctx,
1146 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
1149 int ctx_has_vsx_region = 0;
1152 unsigned long new_msr = 0;
1155 struct mcontext __user *mcp;
1159 * Get pointer to the real mcontext. No need for
1160 * access_ok since we are dealing with compat
1163 if (__get_user(cmcp, &new_ctx->uc_regs))
1165 mcp = (struct mcontext __user *)(u64)cmcp;
1166 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1170 * Check that the context is not smaller than the original
1171 * size (with VMX but without VSX)
1173 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1176 * If the new context state sets the MSR VSX bits but
1177 * it doesn't provide VSX state.
1179 if ((ctx_size < sizeof(struct ucontext)) &&
1180 (new_msr & MSR_VSX))
1182 /* Does the context have enough room to store VSX data? */
1183 if (ctx_size >= sizeof(struct ucontext))
1184 ctx_has_vsx_region = 1;
1186 /* Context size is for future use. Right now, we only make sure
1187 * we are passed something we understand
1189 if (ctx_size < sizeof(struct ucontext))
1192 if (old_ctx != NULL) {
1193 struct mcontext __user *mctx;
1196 * old_ctx might not be 16-byte aligned, in which
1197 * case old_ctx->uc_mcontext won't be either.
1198 * Because we have the old_ctx->uc_pad2 field
1199 * before old_ctx->uc_mcontext, we need to round down
1200 * from &old_ctx->uc_mcontext to a 16-byte boundary.
1202 mctx = (struct mcontext __user *)
1203 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1204 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
1205 || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
1206 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
1207 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1210 if (new_ctx == NULL)
1212 if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
1213 || __get_user(tmp, (u8 __user *) new_ctx)
1214 || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
1218 * If we get a fault copying the context into the kernel's
1219 * image of the user's registers, we can't just return -EFAULT
1220 * because the user's registers will be corrupted. For instance
1221 * the NIP value may have been updated but not some of the
1222 * other registers. Given that we have done the access_ok
1223 * and successfully read the first and last bytes of the region
1224 * above, this should only happen in an out-of-memory situation
1225 * or if another thread unmaps the region containing the context.
1226 * We kill the task with a SIGSEGV in this situation.
1228 if (do_setcontext(new_ctx, regs, 0))
1231 set_thread_flag(TIF_RESTOREALL);
1235 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1236 struct pt_regs *regs)
1238 struct rt_sigframe __user *rt_sf;
1239 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1240 struct ucontext __user *uc_transact;
1241 unsigned long msr_hi;
1245 /* Always make any pending restarted system calls return -EINTR */
1246 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1248 rt_sf = (struct rt_sigframe __user *)
1249 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1250 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1252 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1253 if (__get_user(tmp, &rt_sf->uc.uc_link))
1255 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1258 struct mcontext __user *mcp;
1260 if (__get_user(cmcp, &uc_transact->uc_regs))
1262 mcp = (struct mcontext __user *)(u64)cmcp;
1263 /* The top 32 bits of the MSR are stashed in the transactional
1265 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1268 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1269 /* We only recheckpoint on return if we're
1273 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1278 /* Fall through, for non-TM restore */
1280 if (do_setcontext(&rt_sf->uc, regs, 1))
1284 * It's not clear whether or why it is desirable to save the
1285 * sigaltstack setting on signal delivery and restore it on
1286 * signal return. But other architectures do this and we have
1287 * always done it up until now so it is probably better not to
1288 * change it. -- paulus
1291 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1294 if (restore_altstack(&rt_sf->uc.uc_stack))
1297 set_thread_flag(TIF_RESTOREALL);
1301 if (show_unhandled_signals)
1302 printk_ratelimited(KERN_INFO
1303 "%s[%d]: bad frame in sys_rt_sigreturn: "
1304 "%p nip %08lx lr %08lx\n",
1305 current->comm, current->pid,
1306 rt_sf, regs->nip, regs->link);
1308 force_sig(SIGSEGV, current);
1313 int sys_debug_setcontext(struct ucontext __user *ctx,
1314 int ndbg, struct sig_dbg_op __user *dbg,
1315 int r6, int r7, int r8,
1316 struct pt_regs *regs)
1318 struct sig_dbg_op op;
1321 unsigned long new_msr = regs->msr;
1322 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1323 unsigned long new_dbcr0 = current->thread.debug.dbcr0;
1326 for (i=0; i<ndbg; i++) {
1327 if (copy_from_user(&op, dbg + i, sizeof(op)))
1329 switch (op.dbg_type) {
1330 case SIG_DBG_SINGLE_STEPPING:
1331 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1334 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1336 new_dbcr0 &= ~DBCR0_IC;
1337 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1338 current->thread.debug.dbcr1)) {
1340 new_dbcr0 &= ~DBCR0_IDM;
1350 case SIG_DBG_BRANCH_TRACING:
1351 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1366 /* We wait until here to actually install the values in the
1367 registers so if we fail in the above loop, it will not
1368 affect the contents of these registers. After this point,
1369 failure is a problem, anyway, and it's very unlikely unless
1370 the user is really doing something wrong. */
1371 regs->msr = new_msr;
1372 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1373 current->thread.debug.dbcr0 = new_dbcr0;
1376 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1377 || __get_user(tmp, (u8 __user *) ctx)
1378 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1382 * If we get a fault copying the context into the kernel's
1383 * image of the user's registers, we can't just return -EFAULT
1384 * because the user's registers will be corrupted. For instance
1385 * the NIP value may have been updated but not some of the
1386 * other registers. Given that we have done the access_ok
1387 * and successfully read the first and last bytes of the region
1388 * above, this should only happen in an out-of-memory situation
1389 * or if another thread unmaps the region containing the context.
1390 * We kill the task with a SIGSEGV in this situation.
1392 if (do_setcontext(ctx, regs, 1)) {
1393 if (show_unhandled_signals)
1394 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1395 "sys_debug_setcontext: %p nip %08lx "
1397 current->comm, current->pid,
1398 ctx, regs->nip, regs->link);
1400 force_sig(SIGSEGV, current);
1405 * It's not clear whether or why it is desirable to save the
1406 * sigaltstack setting on signal delivery and restore it on
1407 * signal return. But other architectures do this and we have
1408 * always done it up until now so it is probably better not to
1409 * change it. -- paulus
1411 restore_altstack(&ctx->uc_stack);
1413 set_thread_flag(TIF_RESTOREALL);
1420 * OK, we're invoking a handler
1422 int handle_signal32(unsigned long sig, struct k_sigaction *ka,
1423 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
1425 struct sigcontext __user *sc;
1426 struct sigframe __user *frame;
1427 struct mcontext __user *tm_mctx = NULL;
1428 unsigned long newsp = 0;
1430 unsigned long tramp;
1432 /* Set up Signal Frame */
1433 frame = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*frame), 1);
1434 if (unlikely(frame == NULL))
1436 sc = (struct sigcontext __user *) &frame->sctx;
1439 #error "Please adjust handle_signal()"
1441 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1442 || __put_user(oldset->sig[0], &sc->oldmask)
1444 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1446 || __put_user(oldset->sig[1], &sc->_unused[3])
1448 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1449 || __put_user(sig, &sc->signal))
1452 if (vdso32_sigtramp && current->mm->context.vdso_base) {
1454 tramp = current->mm->context.vdso_base + vdso32_sigtramp;
1456 sigret = __NR_sigreturn;
1457 tramp = (unsigned long) frame->mctx.tramp;
1460 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1461 tm_mctx = &frame->mctx_transact;
1462 if (MSR_TM_ACTIVE(regs->msr)) {
1463 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1470 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1476 current->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1478 /* create a stack frame for the caller of the handler */
1479 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1480 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1483 regs->gpr[1] = newsp;
1485 regs->gpr[4] = (unsigned long) sc;
1486 regs->nip = (unsigned long) ka->sa.sa_handler;
1487 /* enter the signal handler in big-endian mode */
1488 regs->msr &= ~MSR_LE;
1489 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1490 /* Remove TM bits from thread's MSR. The MSR in the sigcontext
1491 * just indicates to userland that we were doing a transaction, but we
1492 * don't want to return in transactional state:
1494 regs->msr &= ~MSR_TS_MASK;
1500 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1501 regs, frame, newsp);
1503 if (show_unhandled_signals)
1504 printk_ratelimited(KERN_INFO
1505 "%s[%d]: bad frame in handle_signal32: "
1506 "%p nip %08lx lr %08lx\n",
1507 current->comm, current->pid,
1508 frame, regs->nip, regs->link);
1510 force_sigsegv(sig, current);
1515 * Do a signal return; undo the signal stack.
1517 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1518 struct pt_regs *regs)
1520 struct sigframe __user *sf;
1521 struct sigcontext __user *sc;
1522 struct sigcontext sigctx;
1523 struct mcontext __user *sr;
1526 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1527 struct mcontext __user *mcp, *tm_mcp;
1528 unsigned long msr_hi;
1531 /* Always make any pending restarted system calls return -EINTR */
1532 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1534 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1537 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1542 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1543 * unused part of the signal stackframe
1545 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1547 set.sig[0] = sigctx.oldmask;
1548 set.sig[1] = sigctx._unused[3];
1550 set_current_blocked(&set);
1552 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1553 mcp = (struct mcontext __user *)&sf->mctx;
1554 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1555 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1557 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1558 if (!cpu_has_feature(CPU_FTR_TM))
1560 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1565 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1567 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1568 || restore_user_regs(regs, sr, 1))
1572 set_thread_flag(TIF_RESTOREALL);
1576 if (show_unhandled_signals)
1577 printk_ratelimited(KERN_INFO
1578 "%s[%d]: bad frame in sys_sigreturn: "
1579 "%p nip %08lx lr %08lx\n",
1580 current->comm, current->pid,
1581 addr, regs->nip, regs->link);
1583 force_sig(SIGSEGV, current);