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>
47 #include <asm/asm-prototypes.h>
50 #include <asm/unistd.h>
52 #include <asm/ucontext.h>
53 #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_ckfpr_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_CKFPR(i);
328 buf[i] = task->thread.ckfp_state.fpscr;
329 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
332 unsigned long copy_ckfpr_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_CKFPR(i) = buf[i];
342 task->thread.ckfp_state.fpscr = buf[i];
347 unsigned long copy_ckvsx_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.ckfp_state.fpr[i][TS_VSRLOWOFFSET];
356 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
359 unsigned long copy_ckvsx_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.ckfp_state.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_ckfpr_to_user(void __user *to,
389 struct task_struct *task)
391 return __copy_to_user(to, task->thread.ckfp_state.fpr,
392 ELF_NFPREG * sizeof(double));
395 inline unsigned long copy_ckfpr_from_user(struct task_struct *task,
398 return __copy_from_user(task->thread.ckfp_state.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 * Clear the MSR VSX bit to indicate there is no valid state attached
451 * to this context, except in the specific case below where we set it.
456 * Copy VSR 0-31 upper half from thread_struct to local
457 * buffer, then write that to userspace. Also set MSR_VSX in
458 * the saved MSR value to indicate that frame->mc_vregs
459 * contains valid data
461 if (current->thread.used_vsr && ctx_has_vsx_region) {
462 flush_vsx_to_thread(current);
463 if (copy_vsx_to_user(&frame->mc_vsregs, current))
467 #endif /* CONFIG_VSX */
469 /* save spe registers */
470 if (current->thread.used_spe) {
471 flush_spe_to_thread(current);
472 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
473 ELF_NEVRREG * sizeof(u32)))
475 /* set MSR_SPE in the saved MSR value to indicate that
476 frame->mc_vregs contains valid data */
479 /* else assert((regs->msr & MSR_SPE) == 0) */
481 /* We always copy to/from spefscr */
482 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
484 #endif /* CONFIG_SPE */
486 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
488 /* We need to write 0 the MSR top 32 bits in the tm frame so that we
489 * can check it on the restore to see if TM is active
491 if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR]))
495 /* Set up the sigreturn trampoline: li r0,sigret; sc */
496 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
497 || __put_user(0x44000002UL, &frame->tramp[1]))
499 flush_icache_range((unsigned long) &frame->tramp[0],
500 (unsigned long) &frame->tramp[2]);
506 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
508 * Save the current user registers on the user stack.
509 * We only save the altivec/spe registers if the process has used
510 * altivec/spe instructions at some point.
511 * We also save the transactional registers to a second ucontext in the
514 * See save_user_regs() and signal_64.c:setup_tm_sigcontexts().
516 static int save_tm_user_regs(struct pt_regs *regs,
517 struct mcontext __user *frame,
518 struct mcontext __user *tm_frame, int sigret)
520 unsigned long msr = regs->msr;
522 /* Remove TM bits from thread's MSR. The MSR in the sigcontext
523 * just indicates to userland that we were doing a transaction, but we
524 * don't want to return in transactional state. This also ensures
525 * that flush_fp_to_thread won't set TIF_RESTORE_TM again.
527 regs->msr &= ~MSR_TS_MASK;
529 /* Save both sets of general registers */
530 if (save_general_regs(¤t->thread.ckpt_regs, frame)
531 || save_general_regs(regs, tm_frame))
534 /* Stash the top half of the 64bit MSR into the 32bit MSR word
535 * of the transactional mcontext. This way we have a backward-compatible
536 * MSR in the 'normal' (checkpointed) mcontext and additionally one can
537 * also look at what type of transaction (T or S) was active at the
538 * time of the signal.
540 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
543 #ifdef CONFIG_ALTIVEC
544 /* save altivec registers */
545 if (current->thread.used_vr) {
546 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.ckvr_state,
547 ELF_NVRREG * sizeof(vector128)))
550 if (__copy_to_user(&tm_frame->mc_vregs,
551 ¤t->thread.vr_state,
552 ELF_NVRREG * sizeof(vector128)))
555 if (__copy_to_user(&tm_frame->mc_vregs,
556 ¤t->thread.ckvr_state,
557 ELF_NVRREG * sizeof(vector128)))
561 /* set MSR_VEC in the saved MSR value to indicate that
562 * frame->mc_vregs contains valid data
567 /* We always copy to/from vrsave, it's 0 if we don't have or don't
568 * use altivec. Since VSCR only contains 32 bits saved in the least
569 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
570 * most significant bits of that same vector. --BenH
572 if (cpu_has_feature(CPU_FTR_ALTIVEC))
573 current->thread.ckvrsave = mfspr(SPRN_VRSAVE);
574 if (__put_user(current->thread.ckvrsave,
575 (u32 __user *)&frame->mc_vregs[32]))
578 if (__put_user(current->thread.vrsave,
579 (u32 __user *)&tm_frame->mc_vregs[32]))
582 if (__put_user(current->thread.ckvrsave,
583 (u32 __user *)&tm_frame->mc_vregs[32]))
586 #endif /* CONFIG_ALTIVEC */
588 if (copy_ckfpr_to_user(&frame->mc_fregs, current))
591 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
594 if (copy_ckfpr_to_user(&tm_frame->mc_fregs, current))
600 * Copy VSR 0-31 upper half from thread_struct to local
601 * buffer, then write that to userspace. Also set MSR_VSX in
602 * the saved MSR value to indicate that frame->mc_vregs
603 * contains valid data
605 if (current->thread.used_vsr) {
606 if (copy_ckvsx_to_user(&frame->mc_vsregs, current))
609 if (copy_vsx_to_user(&tm_frame->mc_vsregs,
613 if (copy_ckvsx_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);
686 #ifdef CONFIG_ALTIVEC
688 * Force the process to reload the altivec registers from
689 * current->thread when it next does altivec instructions
691 regs->msr &= ~MSR_VEC;
693 /* restore altivec registers from the stack */
694 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
695 sizeof(sr->mc_vregs)))
697 current->thread.used_vr = true;
698 } else if (current->thread.used_vr)
699 memset(¤t->thread.vr_state, 0,
700 ELF_NVRREG * sizeof(vector128));
702 /* Always get VRSAVE back */
703 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
705 if (cpu_has_feature(CPU_FTR_ALTIVEC))
706 mtspr(SPRN_VRSAVE, current->thread.vrsave);
707 #endif /* CONFIG_ALTIVEC */
708 if (copy_fpr_from_user(current, &sr->mc_fregs))
713 * Force the process to reload the VSX registers from
714 * current->thread when it next does VSX instruction.
716 regs->msr &= ~MSR_VSX;
719 * Restore altivec registers from the stack to a local
720 * buffer, then write this out to the thread_struct
722 if (copy_vsx_from_user(current, &sr->mc_vsregs))
724 current->thread.used_vsr = true;
725 } else if (current->thread.used_vsr)
726 for (i = 0; i < 32 ; i++)
727 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
728 #endif /* CONFIG_VSX */
730 * force the process to reload the FP registers from
731 * current->thread when it next does FP instructions
733 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
736 /* force the process to reload the spe registers from
737 current->thread when it next does spe instructions */
738 regs->msr &= ~MSR_SPE;
740 /* restore spe registers from the stack */
741 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
742 ELF_NEVRREG * sizeof(u32)))
744 current->thread.used_spe = true;
745 } else if (current->thread.used_spe)
746 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
748 /* Always get SPEFSCR back */
749 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
751 #endif /* CONFIG_SPE */
756 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
758 * Restore the current user register values from the user stack, except for
759 * MSR, and recheckpoint the original checkpointed register state for processes
762 static long restore_tm_user_regs(struct pt_regs *regs,
763 struct mcontext __user *sr,
764 struct mcontext __user *tm_sr)
767 unsigned long msr, msr_hi;
773 * restore general registers but not including MSR or SOFTE. Also
774 * take care of keeping r2 (TLS) intact if not a signal.
775 * See comment in signal_64.c:restore_tm_sigcontexts();
776 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
777 * were set by the signal delivery.
779 err = restore_general_regs(regs, tm_sr);
780 err |= restore_general_regs(¤t->thread.ckpt_regs, sr);
782 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
784 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
788 /* Restore the previous little-endian mode */
789 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
791 #ifdef CONFIG_ALTIVEC
792 regs->msr &= ~MSR_VEC;
794 /* restore altivec registers from the stack */
795 if (__copy_from_user(¤t->thread.ckvr_state, &sr->mc_vregs,
796 sizeof(sr->mc_vregs)) ||
797 __copy_from_user(¤t->thread.vr_state,
799 sizeof(sr->mc_vregs)))
801 current->thread.used_vr = true;
802 } else if (current->thread.used_vr) {
803 memset(¤t->thread.vr_state, 0,
804 ELF_NVRREG * sizeof(vector128));
805 memset(¤t->thread.ckvr_state, 0,
806 ELF_NVRREG * sizeof(vector128));
809 /* Always get VRSAVE back */
810 if (__get_user(current->thread.ckvrsave,
811 (u32 __user *)&sr->mc_vregs[32]) ||
812 __get_user(current->thread.vrsave,
813 (u32 __user *)&tm_sr->mc_vregs[32]))
815 if (cpu_has_feature(CPU_FTR_ALTIVEC))
816 mtspr(SPRN_VRSAVE, current->thread.ckvrsave);
817 #endif /* CONFIG_ALTIVEC */
819 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
821 if (copy_fpr_from_user(current, &sr->mc_fregs) ||
822 copy_ckfpr_from_user(current, &tm_sr->mc_fregs))
826 regs->msr &= ~MSR_VSX;
829 * Restore altivec registers from the stack to a local
830 * buffer, then write this out to the thread_struct
832 if (copy_vsx_from_user(current, &tm_sr->mc_vsregs) ||
833 copy_ckvsx_from_user(current, &sr->mc_vsregs))
835 current->thread.used_vsr = true;
836 } else if (current->thread.used_vsr)
837 for (i = 0; i < 32 ; i++) {
838 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
839 current->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
841 #endif /* CONFIG_VSX */
844 /* SPE regs are not checkpointed with TM, so this section is
845 * simply the same as in restore_user_regs().
847 regs->msr &= ~MSR_SPE;
849 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
850 ELF_NEVRREG * sizeof(u32)))
852 current->thread.used_spe = true;
853 } else if (current->thread.used_spe)
854 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
856 /* Always get SPEFSCR back */
857 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
860 #endif /* CONFIG_SPE */
862 /* Get the top half of the MSR from the user context */
863 if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR]))
866 /* If TM bits are set to the reserved value, it's an invalid context */
867 if (MSR_TM_RESV(msr_hi))
871 * Disabling preemption, since it is unsafe to be preempted
872 * with MSR[TS] set without recheckpointing.
878 * After regs->MSR[TS] being updated, make sure that get_user(),
879 * put_user() or similar functions are *not* called. These
880 * functions can generate page faults which will cause the process
881 * to be de-scheduled with MSR[TS] set but without calling
882 * tm_recheckpoint(). This can cause a bug.
884 * Pull in the MSR TM bits from the user context
886 regs->msr = (regs->msr & ~MSR_TS_MASK) | (msr_hi & MSR_TS_MASK);
887 /* Now, recheckpoint. This loads up all of the checkpointed (older)
888 * registers, including FP and V[S]Rs. After recheckpointing, the
889 * transactional versions should be loaded.
892 /* Make sure the transaction is marked as failed */
893 current->thread.tm_texasr |= TEXASR_FS;
894 /* This loads the checkpointed FP/VEC state, if used */
895 tm_recheckpoint(¤t->thread, msr);
897 /* This loads the speculative FP/VEC state, if used */
898 msr_check_and_set(msr & (MSR_FP | MSR_VEC));
900 load_fp_state(¤t->thread.fp_state);
901 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
903 #ifdef CONFIG_ALTIVEC
905 load_vr_state(¤t->thread.vr_state);
906 regs->msr |= MSR_VEC;
917 int copy_siginfo_to_user32(struct compat_siginfo __user *d, const siginfo_t *s)
921 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
924 /* If you change siginfo_t structure, please be sure
925 * this code is fixed accordingly.
926 * It should never copy any pad contained in the structure
927 * to avoid security leaks, but must copy the generic
928 * 3 ints plus the relevant union member.
929 * This routine must convert siginfo from 64bit to 32bit as well
932 err = __put_user(s->si_signo, &d->si_signo);
933 err |= __put_user(s->si_errno, &d->si_errno);
934 err |= __put_user((short)s->si_code, &d->si_code);
936 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
938 else switch(s->si_code >> 16) {
939 case __SI_CHLD >> 16:
940 err |= __put_user(s->si_pid, &d->si_pid);
941 err |= __put_user(s->si_uid, &d->si_uid);
942 err |= __put_user(s->si_utime, &d->si_utime);
943 err |= __put_user(s->si_stime, &d->si_stime);
944 err |= __put_user(s->si_status, &d->si_status);
946 case __SI_FAULT >> 16:
947 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
950 case __SI_POLL >> 16:
951 err |= __put_user(s->si_band, &d->si_band);
952 err |= __put_user(s->si_fd, &d->si_fd);
954 case __SI_TIMER >> 16:
955 err |= __put_user(s->si_tid, &d->si_tid);
956 err |= __put_user(s->si_overrun, &d->si_overrun);
957 err |= __put_user(s->si_int, &d->si_int);
960 err |= __put_user(ptr_to_compat(s->si_call_addr), &d->si_call_addr);
961 err |= __put_user(s->si_syscall, &d->si_syscall);
962 err |= __put_user(s->si_arch, &d->si_arch);
964 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
965 case __SI_MESGQ >> 16:
966 err |= __put_user(s->si_int, &d->si_int);
968 case __SI_KILL >> 16:
970 err |= __put_user(s->si_pid, &d->si_pid);
971 err |= __put_user(s->si_uid, &d->si_uid);
977 #define copy_siginfo_to_user copy_siginfo_to_user32
979 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
981 if (copy_from_user(to, from, 3*sizeof(int)) ||
982 copy_from_user(to->_sifields._pad,
983 from->_sifields._pad, SI_PAD_SIZE32))
988 #endif /* CONFIG_PPC64 */
991 * Set up a signal frame for a "real-time" signal handler
992 * (one which gets siginfo).
994 int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
995 struct task_struct *tsk)
997 struct rt_sigframe __user *rt_sf;
998 struct mcontext __user *frame;
999 struct mcontext __user *tm_frame = NULL;
1001 unsigned long newsp = 0;
1003 unsigned long tramp;
1004 struct pt_regs *regs = tsk->thread.regs;
1006 BUG_ON(tsk != current);
1008 /* Set up Signal Frame */
1009 /* Put a Real Time Context onto stack */
1010 rt_sf = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*rt_sf), 1);
1012 if (unlikely(rt_sf == NULL))
1015 /* Put the siginfo & fill in most of the ucontext */
1016 if (copy_siginfo_to_user(&rt_sf->info, &ksig->info)
1017 || __put_user(0, &rt_sf->uc.uc_flags)
1018 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
1019 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
1021 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
1024 /* Save user registers on the stack */
1025 frame = &rt_sf->uc.uc_mcontext;
1027 if (vdso32_rt_sigtramp && tsk->mm->context.vdso_base) {
1029 tramp = tsk->mm->context.vdso_base + vdso32_rt_sigtramp;
1031 sigret = __NR_rt_sigreturn;
1032 tramp = (unsigned long) frame->tramp;
1035 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1036 tm_frame = &rt_sf->uc_transact.uc_mcontext;
1037 if (MSR_TM_ACTIVE(regs->msr)) {
1038 if (__put_user((unsigned long)&rt_sf->uc_transact,
1039 &rt_sf->uc.uc_link) ||
1040 __put_user((unsigned long)tm_frame,
1041 &rt_sf->uc_transact.uc_regs))
1043 if (save_tm_user_regs(regs, frame, tm_frame, sigret))
1049 if (__put_user(0, &rt_sf->uc.uc_link))
1051 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
1056 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1058 /* create a stack frame for the caller of the handler */
1059 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
1060 addr = (void __user *)regs->gpr[1];
1061 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1064 /* Fill registers for signal handler */
1065 regs->gpr[1] = newsp;
1066 regs->gpr[3] = ksig->sig;
1067 regs->gpr[4] = (unsigned long) &rt_sf->info;
1068 regs->gpr[5] = (unsigned long) &rt_sf->uc;
1069 regs->gpr[6] = (unsigned long) rt_sf;
1070 regs->nip = (unsigned long) ksig->ka.sa.sa_handler;
1071 /* enter the signal handler in native-endian mode */
1072 regs->msr &= ~MSR_LE;
1073 regs->msr |= (MSR_KERNEL & MSR_LE);
1077 if (show_unhandled_signals)
1078 printk_ratelimited(KERN_INFO
1079 "%s[%d]: bad frame in handle_rt_signal32: "
1080 "%p nip %08lx lr %08lx\n",
1081 tsk->comm, tsk->pid,
1082 addr, regs->nip, regs->link);
1087 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
1090 struct mcontext __user *mcp;
1092 if (get_sigset_t(&set, &ucp->uc_sigmask))
1098 if (__get_user(cmcp, &ucp->uc_regs))
1100 mcp = (struct mcontext __user *)(u64)cmcp;
1101 /* no need to check access_ok(mcp), since mcp < 4GB */
1104 if (__get_user(mcp, &ucp->uc_regs))
1106 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
1109 set_current_blocked(&set);
1110 if (restore_user_regs(regs, mcp, sig))
1116 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1117 static int do_setcontext_tm(struct ucontext __user *ucp,
1118 struct ucontext __user *tm_ucp,
1119 struct pt_regs *regs)
1122 struct mcontext __user *mcp;
1123 struct mcontext __user *tm_mcp;
1127 if (get_sigset_t(&set, &ucp->uc_sigmask))
1130 if (__get_user(cmcp, &ucp->uc_regs) ||
1131 __get_user(tm_cmcp, &tm_ucp->uc_regs))
1133 mcp = (struct mcontext __user *)(u64)cmcp;
1134 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
1135 /* no need to check access_ok(mcp), since mcp < 4GB */
1137 set_current_blocked(&set);
1138 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1145 long sys_swapcontext(struct ucontext __user *old_ctx,
1146 struct ucontext __user *new_ctx,
1147 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
1150 int ctx_has_vsx_region = 0;
1153 unsigned long new_msr = 0;
1156 struct mcontext __user *mcp;
1160 * Get pointer to the real mcontext. No need for
1161 * access_ok since we are dealing with compat
1164 if (__get_user(cmcp, &new_ctx->uc_regs))
1166 mcp = (struct mcontext __user *)(u64)cmcp;
1167 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1171 * Check that the context is not smaller than the original
1172 * size (with VMX but without VSX)
1174 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1177 * If the new context state sets the MSR VSX bits but
1178 * it doesn't provide VSX state.
1180 if ((ctx_size < sizeof(struct ucontext)) &&
1181 (new_msr & MSR_VSX))
1183 /* Does the context have enough room to store VSX data? */
1184 if (ctx_size >= sizeof(struct ucontext))
1185 ctx_has_vsx_region = 1;
1187 /* Context size is for future use. Right now, we only make sure
1188 * we are passed something we understand
1190 if (ctx_size < sizeof(struct ucontext))
1193 if (old_ctx != NULL) {
1194 struct mcontext __user *mctx;
1197 * old_ctx might not be 16-byte aligned, in which
1198 * case old_ctx->uc_mcontext won't be either.
1199 * Because we have the old_ctx->uc_pad2 field
1200 * before old_ctx->uc_mcontext, we need to round down
1201 * from &old_ctx->uc_mcontext to a 16-byte boundary.
1203 mctx = (struct mcontext __user *)
1204 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1205 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
1206 || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
1207 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
1208 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1211 if (new_ctx == NULL)
1213 if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
1214 || __get_user(tmp, (u8 __user *) new_ctx)
1215 || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
1219 * If we get a fault copying the context into the kernel's
1220 * image of the user's registers, we can't just return -EFAULT
1221 * because the user's registers will be corrupted. For instance
1222 * the NIP value may have been updated but not some of the
1223 * other registers. Given that we have done the access_ok
1224 * and successfully read the first and last bytes of the region
1225 * above, this should only happen in an out-of-memory situation
1226 * or if another thread unmaps the region containing the context.
1227 * We kill the task with a SIGSEGV in this situation.
1229 if (do_setcontext(new_ctx, regs, 0))
1232 set_thread_flag(TIF_RESTOREALL);
1236 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1237 struct pt_regs *regs)
1239 struct rt_sigframe __user *rt_sf;
1240 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1241 struct ucontext __user *uc_transact;
1242 unsigned long msr_hi;
1246 /* Always make any pending restarted system calls return -EINTR */
1247 current->restart_block.fn = do_no_restart_syscall;
1249 rt_sf = (struct rt_sigframe __user *)
1250 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1251 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1254 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1256 * If there is a transactional state then throw it away.
1257 * The purpose of a sigreturn is to destroy all traces of the
1258 * signal frame, this includes any transactional state created
1259 * within in. We only check for suspended as we can never be
1260 * active in the kernel, we are active, there is nothing better to
1261 * do than go ahead and Bad Thing later.
1262 * The cause is not important as there will never be a
1263 * recheckpoint so it's not user visible.
1265 if (MSR_TM_SUSPENDED(mfmsr()))
1266 tm_reclaim_current(0);
1268 if (__get_user(tmp, &rt_sf->uc.uc_link))
1270 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1273 struct mcontext __user *mcp;
1275 if (__get_user(cmcp, &uc_transact->uc_regs))
1277 mcp = (struct mcontext __user *)(u64)cmcp;
1278 /* The top 32 bits of the MSR are stashed in the transactional
1280 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1283 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1284 /* Trying to start TM on non TM system */
1285 if (!cpu_has_feature(CPU_FTR_TM))
1287 /* We only recheckpoint on return if we're
1291 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1296 /* Fall through, for non-TM restore */
1298 if (do_setcontext(&rt_sf->uc, regs, 1))
1302 * It's not clear whether or why it is desirable to save the
1303 * sigaltstack setting on signal delivery and restore it on
1304 * signal return. But other architectures do this and we have
1305 * always done it up until now so it is probably better not to
1306 * change it. -- paulus
1309 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1312 if (restore_altstack(&rt_sf->uc.uc_stack))
1315 set_thread_flag(TIF_RESTOREALL);
1319 if (show_unhandled_signals)
1320 printk_ratelimited(KERN_INFO
1321 "%s[%d]: bad frame in sys_rt_sigreturn: "
1322 "%p nip %08lx lr %08lx\n",
1323 current->comm, current->pid,
1324 rt_sf, regs->nip, regs->link);
1326 force_sig(SIGSEGV, current);
1331 int sys_debug_setcontext(struct ucontext __user *ctx,
1332 int ndbg, struct sig_dbg_op __user *dbg,
1333 int r6, int r7, int r8,
1334 struct pt_regs *regs)
1336 struct sig_dbg_op op;
1339 unsigned long new_msr = regs->msr;
1340 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1341 unsigned long new_dbcr0 = current->thread.debug.dbcr0;
1344 for (i=0; i<ndbg; i++) {
1345 if (copy_from_user(&op, dbg + i, sizeof(op)))
1347 switch (op.dbg_type) {
1348 case SIG_DBG_SINGLE_STEPPING:
1349 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1352 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1354 new_dbcr0 &= ~DBCR0_IC;
1355 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1356 current->thread.debug.dbcr1)) {
1358 new_dbcr0 &= ~DBCR0_IDM;
1368 case SIG_DBG_BRANCH_TRACING:
1369 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1384 /* We wait until here to actually install the values in the
1385 registers so if we fail in the above loop, it will not
1386 affect the contents of these registers. After this point,
1387 failure is a problem, anyway, and it's very unlikely unless
1388 the user is really doing something wrong. */
1389 regs->msr = new_msr;
1390 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1391 current->thread.debug.dbcr0 = new_dbcr0;
1394 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1395 || __get_user(tmp, (u8 __user *) ctx)
1396 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1400 * If we get a fault copying the context into the kernel's
1401 * image of the user's registers, we can't just return -EFAULT
1402 * because the user's registers will be corrupted. For instance
1403 * the NIP value may have been updated but not some of the
1404 * other registers. Given that we have done the access_ok
1405 * and successfully read the first and last bytes of the region
1406 * above, this should only happen in an out-of-memory situation
1407 * or if another thread unmaps the region containing the context.
1408 * We kill the task with a SIGSEGV in this situation.
1410 if (do_setcontext(ctx, regs, 1)) {
1411 if (show_unhandled_signals)
1412 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1413 "sys_debug_setcontext: %p nip %08lx "
1415 current->comm, current->pid,
1416 ctx, regs->nip, regs->link);
1418 force_sig(SIGSEGV, current);
1423 * It's not clear whether or why it is desirable to save the
1424 * sigaltstack setting on signal delivery and restore it on
1425 * signal return. But other architectures do this and we have
1426 * always done it up until now so it is probably better not to
1427 * change it. -- paulus
1429 restore_altstack(&ctx->uc_stack);
1431 set_thread_flag(TIF_RESTOREALL);
1438 * OK, we're invoking a handler
1440 int handle_signal32(struct ksignal *ksig, sigset_t *oldset,
1441 struct task_struct *tsk)
1443 struct sigcontext __user *sc;
1444 struct sigframe __user *frame;
1445 struct mcontext __user *tm_mctx = NULL;
1446 unsigned long newsp = 0;
1448 unsigned long tramp;
1449 struct pt_regs *regs = tsk->thread.regs;
1451 BUG_ON(tsk != current);
1453 /* Set up Signal Frame */
1454 frame = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*frame), 1);
1455 if (unlikely(frame == NULL))
1457 sc = (struct sigcontext __user *) &frame->sctx;
1460 #error "Please adjust handle_signal()"
1462 if (__put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler)
1463 || __put_user(oldset->sig[0], &sc->oldmask)
1465 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1467 || __put_user(oldset->sig[1], &sc->_unused[3])
1469 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1470 || __put_user(ksig->sig, &sc->signal))
1473 if (vdso32_sigtramp && tsk->mm->context.vdso_base) {
1475 tramp = tsk->mm->context.vdso_base + vdso32_sigtramp;
1477 sigret = __NR_sigreturn;
1478 tramp = (unsigned long) frame->mctx.tramp;
1481 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1482 tm_mctx = &frame->mctx_transact;
1483 if (MSR_TM_ACTIVE(regs->msr)) {
1484 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1491 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1497 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1499 /* create a stack frame for the caller of the handler */
1500 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1501 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1504 regs->gpr[1] = newsp;
1505 regs->gpr[3] = ksig->sig;
1506 regs->gpr[4] = (unsigned long) sc;
1507 regs->nip = (unsigned long) (unsigned long)ksig->ka.sa.sa_handler;
1508 /* enter the signal handler in big-endian mode */
1509 regs->msr &= ~MSR_LE;
1513 if (show_unhandled_signals)
1514 printk_ratelimited(KERN_INFO
1515 "%s[%d]: bad frame in handle_signal32: "
1516 "%p nip %08lx lr %08lx\n",
1517 tsk->comm, tsk->pid,
1518 frame, regs->nip, regs->link);
1524 * Do a signal return; undo the signal stack.
1526 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1527 struct pt_regs *regs)
1529 struct sigframe __user *sf;
1530 struct sigcontext __user *sc;
1531 struct sigcontext sigctx;
1532 struct mcontext __user *sr;
1535 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1536 struct mcontext __user *mcp, *tm_mcp;
1537 unsigned long msr_hi;
1540 /* Always make any pending restarted system calls return -EINTR */
1541 current->restart_block.fn = do_no_restart_syscall;
1543 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1546 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1551 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1552 * unused part of the signal stackframe
1554 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1556 set.sig[0] = sigctx.oldmask;
1557 set.sig[1] = sigctx._unused[3];
1559 set_current_blocked(&set);
1561 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1562 mcp = (struct mcontext __user *)&sf->mctx;
1563 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1564 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1566 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1567 if (!cpu_has_feature(CPU_FTR_TM))
1569 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1574 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1576 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1577 || restore_user_regs(regs, sr, 1))
1581 set_thread_flag(TIF_RESTOREALL);
1585 if (show_unhandled_signals)
1586 printk_ratelimited(KERN_INFO
1587 "%s[%d]: bad frame in sys_sigreturn: "
1588 "%p nip %08lx lr %08lx\n",
1589 current->comm, current->pid,
1590 addr, regs->nip, regs->link);
1592 force_sig(SIGSEGV, current);