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)
268 double buf[ELF_NFPREG];
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 memcpy(&buf[i], &task->thread.fpscr, sizeof(double));
275 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
278 unsigned long copy_fpr_from_user(struct task_struct *task,
281 double buf[ELF_NFPREG];
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 memcpy(&task->thread.fpscr, &buf[i], sizeof(double));
293 unsigned long copy_vsx_to_user(void __user *to,
294 struct task_struct *task)
296 double 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.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 double 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.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)
322 double buf[ELF_NFPREG];
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 memcpy(&buf[i], &task->thread.transact_fpscr, sizeof(double));
329 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
332 unsigned long copy_transact_fpr_from_user(struct task_struct *task,
335 double buf[ELF_NFPREG];
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 memcpy(&task->thread.transact_fpscr, &buf[i], sizeof(double));
347 unsigned long copy_transact_vsx_to_user(void __user *to,
348 struct task_struct *task)
350 double 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_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 double 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_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.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.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_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_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, current->thread.vr,
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))
461 #endif /* CONFIG_VSX */
463 /* save spe registers */
464 if (current->thread.used_spe) {
465 flush_spe_to_thread(current);
466 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
467 ELF_NEVRREG * sizeof(u32)))
469 /* set MSR_SPE in the saved MSR value to indicate that
470 frame->mc_vregs contains valid data */
473 /* else assert((regs->msr & MSR_SPE) == 0) */
475 /* We always copy to/from spefscr */
476 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
478 #endif /* CONFIG_SPE */
480 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
482 /* We need to write 0 the MSR top 32 bits in the tm frame so that we
483 * can check it on the restore to see if TM is active
485 if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR]))
489 /* Set up the sigreturn trampoline: li r0,sigret; sc */
490 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
491 || __put_user(0x44000002UL, &frame->tramp[1]))
493 flush_icache_range((unsigned long) &frame->tramp[0],
494 (unsigned long) &frame->tramp[2]);
500 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
502 * Save the current user registers on the user stack.
503 * We only save the altivec/spe registers if the process has used
504 * altivec/spe instructions at some point.
505 * We also save the transactional registers to a second ucontext in the
508 * See save_user_regs() and signal_64.c:setup_tm_sigcontexts().
510 static int save_tm_user_regs(struct pt_regs *regs,
511 struct mcontext __user *frame,
512 struct mcontext __user *tm_frame, int sigret)
514 unsigned long msr = regs->msr;
516 /* Make sure floating point registers are stored in regs */
517 flush_fp_to_thread(current);
519 /* Save both sets of general registers */
520 if (save_general_regs(¤t->thread.ckpt_regs, frame)
521 || save_general_regs(regs, tm_frame))
524 /* Stash the top half of the 64bit MSR into the 32bit MSR word
525 * of the transactional mcontext. This way we have a backward-compatible
526 * MSR in the 'normal' (checkpointed) mcontext and additionally one can
527 * also look at what type of transaction (T or S) was active at the
528 * time of the signal.
530 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
533 #ifdef CONFIG_ALTIVEC
534 /* save altivec registers */
535 if (current->thread.used_vr) {
536 flush_altivec_to_thread(current);
537 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
538 ELF_NVRREG * sizeof(vector128)))
541 if (__copy_to_user(&tm_frame->mc_vregs,
542 current->thread.transact_vr,
543 ELF_NVRREG * sizeof(vector128)))
546 if (__copy_to_user(&tm_frame->mc_vregs,
548 ELF_NVRREG * sizeof(vector128)))
552 /* set MSR_VEC in the saved MSR value to indicate that
553 * frame->mc_vregs contains valid data
558 /* We always copy to/from vrsave, it's 0 if we don't have or don't
559 * use altivec. Since VSCR only contains 32 bits saved in the least
560 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
561 * most significant bits of that same vector. --BenH
563 if (cpu_has_feature(CPU_FTR_ALTIVEC))
564 current->thread.vrsave = mfspr(SPRN_VRSAVE);
565 if (__put_user(current->thread.vrsave,
566 (u32 __user *)&frame->mc_vregs[32]))
569 if (__put_user(current->thread.transact_vrsave,
570 (u32 __user *)&tm_frame->mc_vregs[32]))
573 if (__put_user(current->thread.vrsave,
574 (u32 __user *)&tm_frame->mc_vregs[32]))
577 #endif /* CONFIG_ALTIVEC */
579 if (copy_fpr_to_user(&frame->mc_fregs, current))
582 if (copy_transact_fpr_to_user(&tm_frame->mc_fregs, current))
585 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
591 * Copy VSR 0-31 upper half from thread_struct to local
592 * buffer, then write that to userspace. Also set MSR_VSX in
593 * the saved MSR value to indicate that frame->mc_vregs
594 * contains valid data
596 if (current->thread.used_vsr) {
597 __giveup_vsx(current);
598 if (copy_vsx_to_user(&frame->mc_vsregs, current))
601 if (copy_transact_vsx_to_user(&tm_frame->mc_vsregs,
605 if (copy_vsx_to_user(&tm_frame->mc_vsregs, current))
611 #endif /* CONFIG_VSX */
613 /* SPE regs are not checkpointed with TM, so this section is
614 * simply the same as in save_user_regs().
616 if (current->thread.used_spe) {
617 flush_spe_to_thread(current);
618 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
619 ELF_NEVRREG * sizeof(u32)))
621 /* set MSR_SPE in the saved MSR value to indicate that
622 * frame->mc_vregs contains valid data */
626 /* We always copy to/from spefscr */
627 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
629 #endif /* CONFIG_SPE */
631 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
634 /* Set up the sigreturn trampoline: li r0,sigret; sc */
635 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
636 || __put_user(0x44000002UL, &frame->tramp[1]))
638 flush_icache_range((unsigned long) &frame->tramp[0],
639 (unsigned long) &frame->tramp[2]);
647 * Restore the current user register values from the user stack,
650 static long restore_user_regs(struct pt_regs *regs,
651 struct mcontext __user *sr, int sig)
654 unsigned int save_r2 = 0;
661 * restore general registers but not including MSR or SOFTE. Also
662 * take care of keeping r2 (TLS) intact if not a signal
665 save_r2 = (unsigned int)regs->gpr[2];
666 err = restore_general_regs(regs, sr);
668 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
670 regs->gpr[2] = (unsigned long) save_r2;
674 /* if doing signal return, restore the previous little-endian mode */
676 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
679 * Do this before updating the thread state in
680 * current->thread.fpr/vr/evr. That way, if we get preempted
681 * and another task grabs the FPU/Altivec/SPE, it won't be
682 * tempted to save the current CPU state into the thread_struct
683 * and corrupt what we are writing there.
685 discard_lazy_cpu_state();
687 #ifdef CONFIG_ALTIVEC
689 * Force the process to reload the altivec registers from
690 * current->thread when it next does altivec instructions
692 regs->msr &= ~MSR_VEC;
694 /* restore altivec registers from the stack */
695 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
696 sizeof(sr->mc_vregs)))
698 } else if (current->thread.used_vr)
699 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
701 /* Always get VRSAVE back */
702 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
704 if (cpu_has_feature(CPU_FTR_ALTIVEC))
705 mtspr(SPRN_VRSAVE, current->thread.vrsave);
706 #endif /* CONFIG_ALTIVEC */
707 if (copy_fpr_from_user(current, &sr->mc_fregs))
712 * Force the process to reload the VSX registers from
713 * current->thread when it next does VSX instruction.
715 regs->msr &= ~MSR_VSX;
718 * Restore altivec registers from the stack to a local
719 * buffer, then write this out to the thread_struct
721 if (copy_vsx_from_user(current, &sr->mc_vsregs))
723 } else if (current->thread.used_vsr)
724 for (i = 0; i < 32 ; i++)
725 current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
726 #endif /* CONFIG_VSX */
728 * force the process to reload the FP registers from
729 * current->thread when it next does FP instructions
731 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
734 /* force the process to reload the spe registers from
735 current->thread when it next does spe instructions */
736 regs->msr &= ~MSR_SPE;
738 /* restore spe registers from the stack */
739 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
740 ELF_NEVRREG * sizeof(u32)))
742 } else if (current->thread.used_spe)
743 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
745 /* Always get SPEFSCR back */
746 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
748 #endif /* CONFIG_SPE */
753 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
755 * Restore the current user register values from the user stack, except for
756 * MSR, and recheckpoint the original checkpointed register state for processes
759 static long restore_tm_user_regs(struct pt_regs *regs,
760 struct mcontext __user *sr,
761 struct mcontext __user *tm_sr)
764 unsigned long msr, msr_hi;
770 * restore general registers but not including MSR or SOFTE. Also
771 * take care of keeping r2 (TLS) intact if not a signal.
772 * See comment in signal_64.c:restore_tm_sigcontexts();
773 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
774 * were set by the signal delivery.
776 err = restore_general_regs(regs, tm_sr);
777 err |= restore_general_regs(¤t->thread.ckpt_regs, sr);
779 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
781 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
785 /* Restore the previous little-endian mode */
786 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
789 * Do this before updating the thread state in
790 * current->thread.fpr/vr/evr. That way, if we get preempted
791 * and another task grabs the FPU/Altivec/SPE, it won't be
792 * tempted to save the current CPU state into the thread_struct
793 * and corrupt what we are writing there.
795 discard_lazy_cpu_state();
797 #ifdef CONFIG_ALTIVEC
798 regs->msr &= ~MSR_VEC;
800 /* restore altivec registers from the stack */
801 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
802 sizeof(sr->mc_vregs)) ||
803 __copy_from_user(current->thread.transact_vr,
805 sizeof(sr->mc_vregs)))
807 } else if (current->thread.used_vr) {
808 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
809 memset(current->thread.transact_vr, 0,
810 ELF_NVRREG * sizeof(vector128));
813 /* Always get VRSAVE back */
814 if (__get_user(current->thread.vrsave,
815 (u32 __user *)&sr->mc_vregs[32]) ||
816 __get_user(current->thread.transact_vrsave,
817 (u32 __user *)&tm_sr->mc_vregs[32]))
819 if (cpu_has_feature(CPU_FTR_ALTIVEC))
820 mtspr(SPRN_VRSAVE, current->thread.vrsave);
821 #endif /* CONFIG_ALTIVEC */
823 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
825 if (copy_fpr_from_user(current, &sr->mc_fregs) ||
826 copy_transact_fpr_from_user(current, &tm_sr->mc_fregs))
830 regs->msr &= ~MSR_VSX;
833 * Restore altivec registers from the stack to a local
834 * buffer, then write this out to the thread_struct
836 if (copy_vsx_from_user(current, &sr->mc_vsregs) ||
837 copy_transact_vsx_from_user(current, &tm_sr->mc_vsregs))
839 } else if (current->thread.used_vsr)
840 for (i = 0; i < 32 ; i++) {
841 current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
842 current->thread.transact_fpr[i][TS_VSRLOWOFFSET] = 0;
844 #endif /* CONFIG_VSX */
847 /* SPE regs are not checkpointed with TM, so this section is
848 * simply the same as in restore_user_regs().
850 regs->msr &= ~MSR_SPE;
852 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
853 ELF_NEVRREG * sizeof(u32)))
855 } else if (current->thread.used_spe)
856 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
858 /* Always get SPEFSCR back */
859 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
862 #endif /* CONFIG_SPE */
864 /* Now, recheckpoint. This loads up all of the checkpointed (older)
865 * registers, including FP and V[S]Rs. After recheckpointing, the
866 * transactional versions should be loaded.
869 /* This loads the checkpointed FP/VEC state, if used */
870 tm_recheckpoint(¤t->thread, msr);
871 /* Get the top half of the MSR */
872 if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR]))
874 /* Pull in MSR TM from user context */
875 regs->msr = (regs->msr & ~MSR_TS_MASK) | ((msr_hi<<32) & MSR_TS_MASK);
877 /* This loads the speculative FP/VEC state, if used */
879 do_load_up_transact_fpu(¤t->thread);
880 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
882 #ifdef CONFIG_ALTIVEC
884 do_load_up_transact_altivec(¤t->thread);
885 regs->msr |= MSR_VEC;
894 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
898 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
901 /* If you change siginfo_t structure, please be sure
902 * this code is fixed accordingly.
903 * It should never copy any pad contained in the structure
904 * to avoid security leaks, but must copy the generic
905 * 3 ints plus the relevant union member.
906 * This routine must convert siginfo from 64bit to 32bit as well
909 err = __put_user(s->si_signo, &d->si_signo);
910 err |= __put_user(s->si_errno, &d->si_errno);
911 err |= __put_user((short)s->si_code, &d->si_code);
913 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
915 else switch(s->si_code >> 16) {
916 case __SI_CHLD >> 16:
917 err |= __put_user(s->si_pid, &d->si_pid);
918 err |= __put_user(s->si_uid, &d->si_uid);
919 err |= __put_user(s->si_utime, &d->si_utime);
920 err |= __put_user(s->si_stime, &d->si_stime);
921 err |= __put_user(s->si_status, &d->si_status);
923 case __SI_FAULT >> 16:
924 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
927 case __SI_POLL >> 16:
928 err |= __put_user(s->si_band, &d->si_band);
929 err |= __put_user(s->si_fd, &d->si_fd);
931 case __SI_TIMER >> 16:
932 err |= __put_user(s->si_tid, &d->si_tid);
933 err |= __put_user(s->si_overrun, &d->si_overrun);
934 err |= __put_user(s->si_int, &d->si_int);
936 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
937 case __SI_MESGQ >> 16:
938 err |= __put_user(s->si_int, &d->si_int);
940 case __SI_KILL >> 16:
942 err |= __put_user(s->si_pid, &d->si_pid);
943 err |= __put_user(s->si_uid, &d->si_uid);
949 #define copy_siginfo_to_user copy_siginfo_to_user32
951 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
953 memset(to, 0, sizeof *to);
955 if (copy_from_user(to, from, 3*sizeof(int)) ||
956 copy_from_user(to->_sifields._pad,
957 from->_sifields._pad, SI_PAD_SIZE32))
962 #endif /* CONFIG_PPC64 */
965 * Set up a signal frame for a "real-time" signal handler
966 * (one which gets siginfo).
968 int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
969 siginfo_t *info, sigset_t *oldset,
970 struct pt_regs *regs)
972 struct rt_sigframe __user *rt_sf;
973 struct mcontext __user *frame;
974 struct mcontext __user *tm_frame = NULL;
976 unsigned long newsp = 0;
980 /* Set up Signal Frame */
981 /* Put a Real Time Context onto stack */
982 rt_sf = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*rt_sf), 1);
984 if (unlikely(rt_sf == NULL))
987 /* Put the siginfo & fill in most of the ucontext */
988 if (copy_siginfo_to_user(&rt_sf->info, info)
989 || __put_user(0, &rt_sf->uc.uc_flags)
990 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
991 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
993 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
996 /* Save user registers on the stack */
997 frame = &rt_sf->uc.uc_mcontext;
999 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
1001 tramp = current->mm->context.vdso_base + vdso32_rt_sigtramp;
1003 sigret = __NR_rt_sigreturn;
1004 tramp = (unsigned long) frame->tramp;
1007 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1008 tm_frame = &rt_sf->uc_transact.uc_mcontext;
1009 if (MSR_TM_ACTIVE(regs->msr)) {
1010 if (save_tm_user_regs(regs, frame, tm_frame, sigret))
1016 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
1021 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1022 if (MSR_TM_ACTIVE(regs->msr)) {
1023 if (__put_user((unsigned long)&rt_sf->uc_transact,
1025 || __put_user((unsigned long)tm_frame, &rt_sf->uc_transact.uc_regs))
1030 if (__put_user(0, &rt_sf->uc.uc_link))
1033 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1035 /* create a stack frame for the caller of the handler */
1036 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
1037 addr = (void __user *)regs->gpr[1];
1038 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1041 /* Fill registers for signal handler */
1042 regs->gpr[1] = newsp;
1044 regs->gpr[4] = (unsigned long) &rt_sf->info;
1045 regs->gpr[5] = (unsigned long) &rt_sf->uc;
1046 regs->gpr[6] = (unsigned long) rt_sf;
1047 regs->nip = (unsigned long) ka->sa.sa_handler;
1048 /* enter the signal handler in native-endian mode */
1049 regs->msr &= ~MSR_LE;
1050 regs->msr |= (MSR_KERNEL & MSR_LE);
1051 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1052 /* Remove TM bits from thread's MSR. The MSR in the sigcontext
1053 * just indicates to userland that we were doing a transaction, but we
1054 * don't want to return in transactional state:
1056 regs->msr &= ~MSR_TS_MASK;
1062 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
1063 regs, frame, newsp);
1065 if (show_unhandled_signals)
1066 printk_ratelimited(KERN_INFO
1067 "%s[%d]: bad frame in handle_rt_signal32: "
1068 "%p nip %08lx lr %08lx\n",
1069 current->comm, current->pid,
1070 addr, regs->nip, regs->link);
1072 force_sigsegv(sig, current);
1076 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
1079 struct mcontext __user *mcp;
1081 if (get_sigset_t(&set, &ucp->uc_sigmask))
1087 if (__get_user(cmcp, &ucp->uc_regs))
1089 mcp = (struct mcontext __user *)(u64)cmcp;
1090 /* no need to check access_ok(mcp), since mcp < 4GB */
1093 if (__get_user(mcp, &ucp->uc_regs))
1095 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
1098 set_current_blocked(&set);
1099 if (restore_user_regs(regs, mcp, sig))
1105 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1106 static int do_setcontext_tm(struct ucontext __user *ucp,
1107 struct ucontext __user *tm_ucp,
1108 struct pt_regs *regs)
1111 struct mcontext __user *mcp;
1112 struct mcontext __user *tm_mcp;
1116 if (get_sigset_t(&set, &ucp->uc_sigmask))
1119 if (__get_user(cmcp, &ucp->uc_regs) ||
1120 __get_user(tm_cmcp, &tm_ucp->uc_regs))
1122 mcp = (struct mcontext __user *)(u64)cmcp;
1123 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
1124 /* no need to check access_ok(mcp), since mcp < 4GB */
1126 set_current_blocked(&set);
1127 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1134 long sys_swapcontext(struct ucontext __user *old_ctx,
1135 struct ucontext __user *new_ctx,
1136 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
1139 int ctx_has_vsx_region = 0;
1142 unsigned long new_msr = 0;
1145 struct mcontext __user *mcp;
1149 * Get pointer to the real mcontext. No need for
1150 * access_ok since we are dealing with compat
1153 if (__get_user(cmcp, &new_ctx->uc_regs))
1155 mcp = (struct mcontext __user *)(u64)cmcp;
1156 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1160 * Check that the context is not smaller than the original
1161 * size (with VMX but without VSX)
1163 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1166 * If the new context state sets the MSR VSX bits but
1167 * it doesn't provide VSX state.
1169 if ((ctx_size < sizeof(struct ucontext)) &&
1170 (new_msr & MSR_VSX))
1172 /* Does the context have enough room to store VSX data? */
1173 if (ctx_size >= sizeof(struct ucontext))
1174 ctx_has_vsx_region = 1;
1176 /* Context size is for future use. Right now, we only make sure
1177 * we are passed something we understand
1179 if (ctx_size < sizeof(struct ucontext))
1182 if (old_ctx != NULL) {
1183 struct mcontext __user *mctx;
1186 * old_ctx might not be 16-byte aligned, in which
1187 * case old_ctx->uc_mcontext won't be either.
1188 * Because we have the old_ctx->uc_pad2 field
1189 * before old_ctx->uc_mcontext, we need to round down
1190 * from &old_ctx->uc_mcontext to a 16-byte boundary.
1192 mctx = (struct mcontext __user *)
1193 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1194 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
1195 || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
1196 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
1197 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1200 if (new_ctx == NULL)
1202 if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
1203 || __get_user(tmp, (u8 __user *) new_ctx)
1204 || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
1208 * If we get a fault copying the context into the kernel's
1209 * image of the user's registers, we can't just return -EFAULT
1210 * because the user's registers will be corrupted. For instance
1211 * the NIP value may have been updated but not some of the
1212 * other registers. Given that we have done the access_ok
1213 * and successfully read the first and last bytes of the region
1214 * above, this should only happen in an out-of-memory situation
1215 * or if another thread unmaps the region containing the context.
1216 * We kill the task with a SIGSEGV in this situation.
1218 if (do_setcontext(new_ctx, regs, 0))
1221 set_thread_flag(TIF_RESTOREALL);
1225 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1226 struct pt_regs *regs)
1228 struct rt_sigframe __user *rt_sf;
1229 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1230 struct ucontext __user *uc_transact;
1231 unsigned long msr_hi;
1235 /* Always make any pending restarted system calls return -EINTR */
1236 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1238 rt_sf = (struct rt_sigframe __user *)
1239 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1240 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1242 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1243 if (__get_user(tmp, &rt_sf->uc.uc_link))
1245 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1248 struct mcontext __user *mcp;
1250 if (__get_user(cmcp, &uc_transact->uc_regs))
1252 mcp = (struct mcontext __user *)(u64)cmcp;
1253 /* The top 32 bits of the MSR are stashed in the transactional
1255 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1258 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1259 /* We only recheckpoint on return if we're
1263 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1268 /* Fall through, for non-TM restore */
1270 if (do_setcontext(&rt_sf->uc, regs, 1))
1274 * It's not clear whether or why it is desirable to save the
1275 * sigaltstack setting on signal delivery and restore it on
1276 * signal return. But other architectures do this and we have
1277 * always done it up until now so it is probably better not to
1278 * change it. -- paulus
1281 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1284 if (restore_altstack(&rt_sf->uc.uc_stack))
1287 set_thread_flag(TIF_RESTOREALL);
1291 if (show_unhandled_signals)
1292 printk_ratelimited(KERN_INFO
1293 "%s[%d]: bad frame in sys_rt_sigreturn: "
1294 "%p nip %08lx lr %08lx\n",
1295 current->comm, current->pid,
1296 rt_sf, regs->nip, regs->link);
1298 force_sig(SIGSEGV, current);
1303 int sys_debug_setcontext(struct ucontext __user *ctx,
1304 int ndbg, struct sig_dbg_op __user *dbg,
1305 int r6, int r7, int r8,
1306 struct pt_regs *regs)
1308 struct sig_dbg_op op;
1311 unsigned long new_msr = regs->msr;
1312 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1313 unsigned long new_dbcr0 = current->thread.dbcr0;
1316 for (i=0; i<ndbg; i++) {
1317 if (copy_from_user(&op, dbg + i, sizeof(op)))
1319 switch (op.dbg_type) {
1320 case SIG_DBG_SINGLE_STEPPING:
1321 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1324 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1326 new_dbcr0 &= ~DBCR0_IC;
1327 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1328 current->thread.dbcr1)) {
1330 new_dbcr0 &= ~DBCR0_IDM;
1340 case SIG_DBG_BRANCH_TRACING:
1341 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1356 /* We wait until here to actually install the values in the
1357 registers so if we fail in the above loop, it will not
1358 affect the contents of these registers. After this point,
1359 failure is a problem, anyway, and it's very unlikely unless
1360 the user is really doing something wrong. */
1361 regs->msr = new_msr;
1362 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1363 current->thread.dbcr0 = new_dbcr0;
1366 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1367 || __get_user(tmp, (u8 __user *) ctx)
1368 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1372 * If we get a fault copying the context into the kernel's
1373 * image of the user's registers, we can't just return -EFAULT
1374 * because the user's registers will be corrupted. For instance
1375 * the NIP value may have been updated but not some of the
1376 * other registers. Given that we have done the access_ok
1377 * and successfully read the first and last bytes of the region
1378 * above, this should only happen in an out-of-memory situation
1379 * or if another thread unmaps the region containing the context.
1380 * We kill the task with a SIGSEGV in this situation.
1382 if (do_setcontext(ctx, regs, 1)) {
1383 if (show_unhandled_signals)
1384 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1385 "sys_debug_setcontext: %p nip %08lx "
1387 current->comm, current->pid,
1388 ctx, regs->nip, regs->link);
1390 force_sig(SIGSEGV, current);
1395 * It's not clear whether or why it is desirable to save the
1396 * sigaltstack setting on signal delivery and restore it on
1397 * signal return. But other architectures do this and we have
1398 * always done it up until now so it is probably better not to
1399 * change it. -- paulus
1401 restore_altstack(&ctx->uc_stack);
1403 set_thread_flag(TIF_RESTOREALL);
1410 * OK, we're invoking a handler
1412 int handle_signal32(unsigned long sig, struct k_sigaction *ka,
1413 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
1415 struct sigcontext __user *sc;
1416 struct sigframe __user *frame;
1417 struct mcontext __user *tm_mctx = NULL;
1418 unsigned long newsp = 0;
1420 unsigned long tramp;
1422 /* Set up Signal Frame */
1423 frame = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*frame), 1);
1424 if (unlikely(frame == NULL))
1426 sc = (struct sigcontext __user *) &frame->sctx;
1429 #error "Please adjust handle_signal()"
1431 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1432 || __put_user(oldset->sig[0], &sc->oldmask)
1434 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1436 || __put_user(oldset->sig[1], &sc->_unused[3])
1438 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1439 || __put_user(sig, &sc->signal))
1442 if (vdso32_sigtramp && current->mm->context.vdso_base) {
1444 tramp = current->mm->context.vdso_base + vdso32_sigtramp;
1446 sigret = __NR_sigreturn;
1447 tramp = (unsigned long) frame->mctx.tramp;
1450 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1451 tm_mctx = &frame->mctx_transact;
1452 if (MSR_TM_ACTIVE(regs->msr)) {
1453 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1460 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1466 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1468 /* create a stack frame for the caller of the handler */
1469 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1470 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1473 regs->gpr[1] = newsp;
1475 regs->gpr[4] = (unsigned long) sc;
1476 regs->nip = (unsigned long) ka->sa.sa_handler;
1477 /* enter the signal handler in big-endian mode */
1478 regs->msr &= ~MSR_LE;
1479 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1480 /* Remove TM bits from thread's MSR. The MSR in the sigcontext
1481 * just indicates to userland that we were doing a transaction, but we
1482 * don't want to return in transactional state:
1484 regs->msr &= ~MSR_TS_MASK;
1490 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1491 regs, frame, newsp);
1493 if (show_unhandled_signals)
1494 printk_ratelimited(KERN_INFO
1495 "%s[%d]: bad frame in handle_signal32: "
1496 "%p nip %08lx lr %08lx\n",
1497 current->comm, current->pid,
1498 frame, regs->nip, regs->link);
1500 force_sigsegv(sig, current);
1505 * Do a signal return; undo the signal stack.
1507 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1508 struct pt_regs *regs)
1510 struct sigframe __user *sf;
1511 struct sigcontext __user *sc;
1512 struct sigcontext sigctx;
1513 struct mcontext __user *sr;
1516 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1517 struct mcontext __user *mcp, *tm_mcp;
1518 unsigned long msr_hi;
1521 /* Always make any pending restarted system calls return -EINTR */
1522 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1524 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1527 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1532 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1533 * unused part of the signal stackframe
1535 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1537 set.sig[0] = sigctx.oldmask;
1538 set.sig[1] = sigctx._unused[3];
1540 set_current_blocked(&set);
1542 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1543 mcp = (struct mcontext __user *)&sf->mctx;
1544 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1545 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1547 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1548 if (!cpu_has_feature(CPU_FTR_TM))
1550 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1555 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1557 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1558 || restore_user_regs(regs, sr, 1))
1562 set_thread_flag(TIF_RESTOREALL);
1566 if (show_unhandled_signals)
1567 printk_ratelimited(KERN_INFO
1568 "%s[%d]: bad frame in sys_sigreturn: "
1569 "%p nip %08lx lr %08lx\n",
1570 current->comm, current->pid,
1571 addr, regs->nip, regs->link);
1573 force_sig(SIGSEGV, current);