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/pagemap.h>
29 #include <linux/ratelimit.h>
30 #include <linux/syscalls.h>
32 #include <linux/compat.h>
34 #include <linux/wait.h>
35 #include <linux/unistd.h>
36 #include <linux/stddef.h>
37 #include <linux/tty.h>
38 #include <linux/binfmts.h>
41 #include <linux/uaccess.h>
42 #include <asm/cacheflush.h>
43 #include <asm/syscalls.h>
44 #include <asm/sigcontext.h>
46 #include <asm/switch_to.h>
48 #include <asm/asm-prototypes.h>
51 #include <asm/unistd.h>
53 #include <asm/ucontext.h>
54 #include <asm/pgtable.h>
61 #define old_sigaction old_sigaction32
62 #define sigcontext sigcontext32
63 #define mcontext mcontext32
64 #define ucontext ucontext32
66 #define __save_altstack __compat_save_altstack
69 * Userspace code may pass a ucontext which doesn't include VSX added
70 * at the end. We need to check for this case.
72 #define UCONTEXTSIZEWITHOUTVSX \
73 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32))
76 * Returning 0 means we return to userspace via
77 * ret_from_except and thus restore all user
78 * registers from *regs. This is what we need
79 * to do when a signal has been delivered.
82 #define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
83 #undef __SIGNAL_FRAMESIZE
84 #define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
86 #define ELF_NVRREG ELF_NVRREG32
89 * Functions for flipping sigsets (thanks to brain dead generic
90 * implementation that makes things simple for little endian only)
92 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
94 return put_compat_sigset(uset, set, sizeof(*uset));
97 static inline int get_sigset_t(sigset_t *set,
98 const compat_sigset_t __user *uset)
100 return get_compat_sigset(set, uset);
103 #define to_user_ptr(p) ptr_to_compat(p)
104 #define from_user_ptr(p) compat_ptr(p)
106 static inline int save_general_regs(struct pt_regs *regs,
107 struct mcontext __user *frame)
109 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
111 /* Force usr to alway see softe as 1 (interrupts enabled) */
112 elf_greg_t64 softe = 0x1;
114 WARN_ON(!FULL_REGS(regs));
116 for (i = 0; i <= PT_RESULT; i ++) {
117 if (i == 14 && !FULL_REGS(regs))
119 if ( i == PT_SOFTE) {
120 if(__put_user((unsigned int)softe, &frame->mc_gregs[i]))
125 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
131 static inline int restore_general_regs(struct pt_regs *regs,
132 struct mcontext __user *sr)
134 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
137 for (i = 0; i <= PT_RESULT; i++) {
138 if ((i == PT_MSR) || (i == PT_SOFTE))
140 if (__get_user(gregs[i], &sr->mc_gregs[i]))
146 #else /* CONFIG_PPC64 */
148 #define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
150 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
152 return copy_to_user(uset, set, sizeof(*uset));
155 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
157 return copy_from_user(set, uset, sizeof(*uset));
160 #define to_user_ptr(p) ((unsigned long)(p))
161 #define from_user_ptr(p) ((void __user *)(p))
163 static inline int save_general_regs(struct pt_regs *regs,
164 struct mcontext __user *frame)
166 WARN_ON(!FULL_REGS(regs));
167 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
170 static inline int restore_general_regs(struct pt_regs *regs,
171 struct mcontext __user *sr)
173 /* copy up to but not including MSR */
174 if (__copy_from_user(regs, &sr->mc_gregs,
175 PT_MSR * sizeof(elf_greg_t)))
177 /* copy from orig_r3 (the word after the MSR) up to the end */
178 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
179 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
186 * When we have signals to deliver, we set up on the
187 * user stack, going down from the original stack pointer:
188 * an ABI gap of 56 words
190 * a sigcontext struct
191 * a gap of __SIGNAL_FRAMESIZE bytes
193 * Each of these things must be a multiple of 16 bytes in size. The following
194 * structure represent all of this except the __SIGNAL_FRAMESIZE gap
198 struct sigcontext sctx; /* the sigcontext */
199 struct mcontext mctx; /* all the register values */
200 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
201 struct sigcontext sctx_transact;
202 struct mcontext mctx_transact;
205 * Programs using the rs6000/xcoff abi can save up to 19 gp
206 * regs and 18 fp regs below sp before decrementing it.
211 /* We use the mc_pad field for the signal return trampoline. */
215 * When we have rt signals to deliver, we set up on the
216 * user stack, going down from the original stack pointer:
217 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
218 * a gap of __SIGNAL_FRAMESIZE+16 bytes
219 * (the +16 is to get the siginfo and ucontext in the same
220 * positions as in older kernels).
222 * Each of these things must be a multiple of 16 bytes in size.
227 compat_siginfo_t info;
232 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
233 struct ucontext uc_transact;
236 * Programs using the rs6000/xcoff abi can save up to 19 gp
237 * regs and 18 fp regs below sp before decrementing it.
243 unsigned long copy_fpr_to_user(void __user *to,
244 struct task_struct *task)
249 /* save FPR copy to local buffer then write to the thread_struct */
250 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
251 buf[i] = task->thread.TS_FPR(i);
252 buf[i] = task->thread.fp_state.fpscr;
253 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
256 unsigned long copy_fpr_from_user(struct task_struct *task,
262 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
264 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
265 task->thread.TS_FPR(i) = buf[i];
266 task->thread.fp_state.fpscr = buf[i];
271 unsigned long copy_vsx_to_user(void __user *to,
272 struct task_struct *task)
274 u64 buf[ELF_NVSRHALFREG];
277 /* save FPR copy to local buffer then write to the thread_struct */
278 for (i = 0; i < ELF_NVSRHALFREG; i++)
279 buf[i] = task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET];
280 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
283 unsigned long copy_vsx_from_user(struct task_struct *task,
286 u64 buf[ELF_NVSRHALFREG];
289 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
291 for (i = 0; i < ELF_NVSRHALFREG ; i++)
292 task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = buf[i];
296 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
297 unsigned long copy_ckfpr_to_user(void __user *to,
298 struct task_struct *task)
303 /* save FPR copy to local buffer then write to the thread_struct */
304 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
305 buf[i] = task->thread.TS_CKFPR(i);
306 buf[i] = task->thread.ckfp_state.fpscr;
307 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
310 unsigned long copy_ckfpr_from_user(struct task_struct *task,
316 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
318 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
319 task->thread.TS_CKFPR(i) = buf[i];
320 task->thread.ckfp_state.fpscr = buf[i];
325 unsigned long copy_ckvsx_to_user(void __user *to,
326 struct task_struct *task)
328 u64 buf[ELF_NVSRHALFREG];
331 /* save FPR copy to local buffer then write to the thread_struct */
332 for (i = 0; i < ELF_NVSRHALFREG; i++)
333 buf[i] = task->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET];
334 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
337 unsigned long copy_ckvsx_from_user(struct task_struct *task,
340 u64 buf[ELF_NVSRHALFREG];
343 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
345 for (i = 0; i < ELF_NVSRHALFREG ; i++)
346 task->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = buf[i];
349 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
351 inline unsigned long copy_fpr_to_user(void __user *to,
352 struct task_struct *task)
354 return __copy_to_user(to, task->thread.fp_state.fpr,
355 ELF_NFPREG * sizeof(double));
358 inline unsigned long copy_fpr_from_user(struct task_struct *task,
361 return __copy_from_user(task->thread.fp_state.fpr, from,
362 ELF_NFPREG * sizeof(double));
365 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
366 inline unsigned long copy_ckfpr_to_user(void __user *to,
367 struct task_struct *task)
369 return __copy_to_user(to, task->thread.ckfp_state.fpr,
370 ELF_NFPREG * sizeof(double));
373 inline unsigned long copy_ckfpr_from_user(struct task_struct *task,
376 return __copy_from_user(task->thread.ckfp_state.fpr, from,
377 ELF_NFPREG * sizeof(double));
379 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
383 * Save the current user registers on the user stack.
384 * We only save the altivec/spe registers if the process has used
385 * altivec/spe instructions at some point.
387 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
388 struct mcontext __user *tm_frame, int sigret,
389 int ctx_has_vsx_region)
391 unsigned long msr = regs->msr;
393 /* Make sure floating point registers are stored in regs */
394 flush_fp_to_thread(current);
396 /* save general registers */
397 if (save_general_regs(regs, frame))
400 #ifdef CONFIG_ALTIVEC
401 /* save altivec registers */
402 if (current->thread.used_vr) {
403 flush_altivec_to_thread(current);
404 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state,
405 ELF_NVRREG * sizeof(vector128)))
407 /* set MSR_VEC in the saved MSR value to indicate that
408 frame->mc_vregs contains valid data */
411 /* else assert((regs->msr & MSR_VEC) == 0) */
413 /* We always copy to/from vrsave, it's 0 if we don't have or don't
414 * use altivec. Since VSCR only contains 32 bits saved in the least
415 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
416 * most significant bits of that same vector. --BenH
417 * Note that the current VRSAVE value is in the SPR at this point.
419 if (cpu_has_feature(CPU_FTR_ALTIVEC))
420 current->thread.vrsave = mfspr(SPRN_VRSAVE);
421 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
423 #endif /* CONFIG_ALTIVEC */
424 if (copy_fpr_to_user(&frame->mc_fregs, current))
428 * Clear the MSR VSX bit to indicate there is no valid state attached
429 * to this context, except in the specific case below where we set it.
434 * Copy VSR 0-31 upper half from thread_struct to local
435 * buffer, then write that to userspace. Also set MSR_VSX in
436 * the saved MSR value to indicate that frame->mc_vregs
437 * contains valid data
439 if (current->thread.used_vsr && ctx_has_vsx_region) {
440 flush_vsx_to_thread(current);
441 if (copy_vsx_to_user(&frame->mc_vsregs, current))
445 #endif /* CONFIG_VSX */
447 /* save spe registers */
448 if (current->thread.used_spe) {
449 flush_spe_to_thread(current);
450 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
451 ELF_NEVRREG * sizeof(u32)))
453 /* set MSR_SPE in the saved MSR value to indicate that
454 frame->mc_vregs contains valid data */
457 /* else assert((regs->msr & MSR_SPE) == 0) */
459 /* We always copy to/from spefscr */
460 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
462 #endif /* CONFIG_SPE */
464 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
466 /* We need to write 0 the MSR top 32 bits in the tm frame so that we
467 * can check it on the restore to see if TM is active
469 if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR]))
473 /* Set up the sigreturn trampoline: li r0,sigret; sc */
474 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
475 || __put_user(0x44000002UL, &frame->tramp[1]))
477 flush_icache_range((unsigned long) &frame->tramp[0],
478 (unsigned long) &frame->tramp[2]);
484 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
486 * Save the current user registers on the user stack.
487 * We only save the altivec/spe registers if the process has used
488 * altivec/spe instructions at some point.
489 * We also save the transactional registers to a second ucontext in the
492 * See save_user_regs() and signal_64.c:setup_tm_sigcontexts().
494 static int save_tm_user_regs(struct pt_regs *regs,
495 struct mcontext __user *frame,
496 struct mcontext __user *tm_frame, int sigret,
499 WARN_ON(tm_suspend_disabled);
501 /* Save both sets of general registers */
502 if (save_general_regs(¤t->thread.ckpt_regs, frame)
503 || save_general_regs(regs, tm_frame))
506 /* Stash the top half of the 64bit MSR into the 32bit MSR word
507 * of the transactional mcontext. This way we have a backward-compatible
508 * MSR in the 'normal' (checkpointed) mcontext and additionally one can
509 * also look at what type of transaction (T or S) was active at the
510 * time of the signal.
512 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
515 #ifdef CONFIG_ALTIVEC
516 /* save altivec registers */
517 if (current->thread.used_vr) {
518 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.ckvr_state,
519 ELF_NVRREG * sizeof(vector128)))
522 if (__copy_to_user(&tm_frame->mc_vregs,
523 ¤t->thread.vr_state,
524 ELF_NVRREG * sizeof(vector128)))
527 if (__copy_to_user(&tm_frame->mc_vregs,
528 ¤t->thread.ckvr_state,
529 ELF_NVRREG * sizeof(vector128)))
533 /* set MSR_VEC in the saved MSR value to indicate that
534 * frame->mc_vregs contains valid data
539 /* We always copy to/from vrsave, it's 0 if we don't have or don't
540 * use altivec. Since VSCR only contains 32 bits saved in the least
541 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
542 * most significant bits of that same vector. --BenH
544 if (cpu_has_feature(CPU_FTR_ALTIVEC))
545 current->thread.ckvrsave = mfspr(SPRN_VRSAVE);
546 if (__put_user(current->thread.ckvrsave,
547 (u32 __user *)&frame->mc_vregs[32]))
550 if (__put_user(current->thread.vrsave,
551 (u32 __user *)&tm_frame->mc_vregs[32]))
554 if (__put_user(current->thread.ckvrsave,
555 (u32 __user *)&tm_frame->mc_vregs[32]))
558 #endif /* CONFIG_ALTIVEC */
560 if (copy_ckfpr_to_user(&frame->mc_fregs, current))
563 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
566 if (copy_ckfpr_to_user(&tm_frame->mc_fregs, current))
572 * Copy VSR 0-31 upper half from thread_struct to local
573 * buffer, then write that to userspace. Also set MSR_VSX in
574 * the saved MSR value to indicate that frame->mc_vregs
575 * contains valid data
577 if (current->thread.used_vsr) {
578 if (copy_ckvsx_to_user(&frame->mc_vsregs, current))
581 if (copy_vsx_to_user(&tm_frame->mc_vsregs,
585 if (copy_ckvsx_to_user(&tm_frame->mc_vsregs, current))
591 #endif /* CONFIG_VSX */
593 /* SPE regs are not checkpointed with TM, so this section is
594 * simply the same as in save_user_regs().
596 if (current->thread.used_spe) {
597 flush_spe_to_thread(current);
598 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
599 ELF_NEVRREG * sizeof(u32)))
601 /* set MSR_SPE in the saved MSR value to indicate that
602 * frame->mc_vregs contains valid data */
606 /* We always copy to/from spefscr */
607 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
609 #endif /* CONFIG_SPE */
611 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
614 /* Set up the sigreturn trampoline: li r0,sigret; sc */
615 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
616 || __put_user(0x44000002UL, &frame->tramp[1]))
618 flush_icache_range((unsigned long) &frame->tramp[0],
619 (unsigned long) &frame->tramp[2]);
627 * Restore the current user register values from the user stack,
630 static long restore_user_regs(struct pt_regs *regs,
631 struct mcontext __user *sr, int sig)
634 unsigned int save_r2 = 0;
641 * restore general registers but not including MSR or SOFTE. Also
642 * take care of keeping r2 (TLS) intact if not a signal
645 save_r2 = (unsigned int)regs->gpr[2];
646 err = restore_general_regs(regs, sr);
648 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
650 regs->gpr[2] = (unsigned long) save_r2;
654 /* if doing signal return, restore the previous little-endian mode */
656 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
658 #ifdef CONFIG_ALTIVEC
660 * Force the process to reload the altivec registers from
661 * current->thread when it next does altivec instructions
663 regs->msr &= ~MSR_VEC;
665 /* restore altivec registers from the stack */
666 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
667 sizeof(sr->mc_vregs)))
669 current->thread.used_vr = true;
670 } else if (current->thread.used_vr)
671 memset(¤t->thread.vr_state, 0,
672 ELF_NVRREG * sizeof(vector128));
674 /* Always get VRSAVE back */
675 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
677 if (cpu_has_feature(CPU_FTR_ALTIVEC))
678 mtspr(SPRN_VRSAVE, current->thread.vrsave);
679 #endif /* CONFIG_ALTIVEC */
680 if (copy_fpr_from_user(current, &sr->mc_fregs))
685 * Force the process to reload the VSX registers from
686 * current->thread when it next does VSX instruction.
688 regs->msr &= ~MSR_VSX;
691 * Restore altivec registers from the stack to a local
692 * buffer, then write this out to the thread_struct
694 if (copy_vsx_from_user(current, &sr->mc_vsregs))
696 current->thread.used_vsr = true;
697 } else if (current->thread.used_vsr)
698 for (i = 0; i < 32 ; i++)
699 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
700 #endif /* CONFIG_VSX */
702 * force the process to reload the FP registers from
703 * current->thread when it next does FP instructions
705 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
708 /* force the process to reload the spe registers from
709 current->thread when it next does spe instructions */
710 regs->msr &= ~MSR_SPE;
712 /* restore spe registers from the stack */
713 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
714 ELF_NEVRREG * sizeof(u32)))
716 current->thread.used_spe = true;
717 } else if (current->thread.used_spe)
718 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
720 /* Always get SPEFSCR back */
721 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
723 #endif /* CONFIG_SPE */
728 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
730 * Restore the current user register values from the user stack, except for
731 * MSR, and recheckpoint the original checkpointed register state for processes
734 static long restore_tm_user_regs(struct pt_regs *regs,
735 struct mcontext __user *sr,
736 struct mcontext __user *tm_sr)
739 unsigned long msr, msr_hi;
744 if (tm_suspend_disabled)
747 * restore general registers but not including MSR or SOFTE. Also
748 * take care of keeping r2 (TLS) intact if not a signal.
749 * See comment in signal_64.c:restore_tm_sigcontexts();
750 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
751 * were set by the signal delivery.
753 err = restore_general_regs(regs, tm_sr);
754 err |= restore_general_regs(¤t->thread.ckpt_regs, sr);
756 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
758 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
762 /* Restore the previous little-endian mode */
763 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
765 #ifdef CONFIG_ALTIVEC
766 regs->msr &= ~MSR_VEC;
768 /* restore altivec registers from the stack */
769 if (__copy_from_user(¤t->thread.ckvr_state, &sr->mc_vregs,
770 sizeof(sr->mc_vregs)) ||
771 __copy_from_user(¤t->thread.vr_state,
773 sizeof(sr->mc_vregs)))
775 current->thread.used_vr = true;
776 } else if (current->thread.used_vr) {
777 memset(¤t->thread.vr_state, 0,
778 ELF_NVRREG * sizeof(vector128));
779 memset(¤t->thread.ckvr_state, 0,
780 ELF_NVRREG * sizeof(vector128));
783 /* Always get VRSAVE back */
784 if (__get_user(current->thread.ckvrsave,
785 (u32 __user *)&sr->mc_vregs[32]) ||
786 __get_user(current->thread.vrsave,
787 (u32 __user *)&tm_sr->mc_vregs[32]))
789 if (cpu_has_feature(CPU_FTR_ALTIVEC))
790 mtspr(SPRN_VRSAVE, current->thread.ckvrsave);
791 #endif /* CONFIG_ALTIVEC */
793 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
795 if (copy_fpr_from_user(current, &sr->mc_fregs) ||
796 copy_ckfpr_from_user(current, &tm_sr->mc_fregs))
800 regs->msr &= ~MSR_VSX;
803 * Restore altivec registers from the stack to a local
804 * buffer, then write this out to the thread_struct
806 if (copy_vsx_from_user(current, &tm_sr->mc_vsregs) ||
807 copy_ckvsx_from_user(current, &sr->mc_vsregs))
809 current->thread.used_vsr = true;
810 } else if (current->thread.used_vsr)
811 for (i = 0; i < 32 ; i++) {
812 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
813 current->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
815 #endif /* CONFIG_VSX */
818 /* SPE regs are not checkpointed with TM, so this section is
819 * simply the same as in restore_user_regs().
821 regs->msr &= ~MSR_SPE;
823 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
824 ELF_NEVRREG * sizeof(u32)))
826 current->thread.used_spe = true;
827 } else if (current->thread.used_spe)
828 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
830 /* Always get SPEFSCR back */
831 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
834 #endif /* CONFIG_SPE */
836 /* Get the top half of the MSR from the user context */
837 if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR]))
840 /* If TM bits are set to the reserved value, it's an invalid context */
841 if (MSR_TM_RESV(msr_hi))
845 * Disabling preemption, since it is unsafe to be preempted
846 * with MSR[TS] set without recheckpointing.
852 * After regs->MSR[TS] being updated, make sure that get_user(),
853 * put_user() or similar functions are *not* called. These
854 * functions can generate page faults which will cause the process
855 * to be de-scheduled with MSR[TS] set but without calling
856 * tm_recheckpoint(). This can cause a bug.
858 * Pull in the MSR TM bits from the user context
860 regs->msr = (regs->msr & ~MSR_TS_MASK) | (msr_hi & MSR_TS_MASK);
861 /* Now, recheckpoint. This loads up all of the checkpointed (older)
862 * registers, including FP and V[S]Rs. After recheckpointing, the
863 * transactional versions should be loaded.
866 /* Make sure the transaction is marked as failed */
867 current->thread.tm_texasr |= TEXASR_FS;
868 /* This loads the checkpointed FP/VEC state, if used */
869 tm_recheckpoint(¤t->thread);
871 /* This loads the speculative FP/VEC state, if used */
872 msr_check_and_set(msr & (MSR_FP | MSR_VEC));
874 load_fp_state(¤t->thread.fp_state);
875 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
877 #ifdef CONFIG_ALTIVEC
879 load_vr_state(¤t->thread.vr_state);
880 regs->msr |= MSR_VEC;
892 #define copy_siginfo_to_user copy_siginfo_to_user32
894 #endif /* CONFIG_PPC64 */
897 * Set up a signal frame for a "real-time" signal handler
898 * (one which gets siginfo).
900 int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
901 struct task_struct *tsk)
903 struct rt_sigframe __user *rt_sf;
904 struct mcontext __user *frame;
905 struct mcontext __user *tm_frame = NULL;
907 unsigned long newsp = 0;
910 struct pt_regs *regs = tsk->thread.regs;
911 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
912 /* Save the thread's msr before get_tm_stackpointer() changes it */
913 unsigned long msr = regs->msr;
916 BUG_ON(tsk != current);
918 /* Set up Signal Frame */
919 /* Put a Real Time Context onto stack */
920 rt_sf = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*rt_sf), 1);
922 if (unlikely(rt_sf == NULL))
925 /* Put the siginfo & fill in most of the ucontext */
926 if (copy_siginfo_to_user(&rt_sf->info, &ksig->info)
927 || __put_user(0, &rt_sf->uc.uc_flags)
928 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
929 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
931 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
934 /* Save user registers on the stack */
935 frame = &rt_sf->uc.uc_mcontext;
937 if (vdso32_rt_sigtramp && tsk->mm->context.vdso_base) {
939 tramp = tsk->mm->context.vdso_base + vdso32_rt_sigtramp;
941 sigret = __NR_rt_sigreturn;
942 tramp = (unsigned long) frame->tramp;
945 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
946 tm_frame = &rt_sf->uc_transact.uc_mcontext;
947 if (MSR_TM_ACTIVE(msr)) {
948 if (__put_user((unsigned long)&rt_sf->uc_transact,
949 &rt_sf->uc.uc_link) ||
950 __put_user((unsigned long)tm_frame,
951 &rt_sf->uc_transact.uc_regs))
953 if (save_tm_user_regs(regs, frame, tm_frame, sigret, msr))
959 if (__put_user(0, &rt_sf->uc.uc_link))
961 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
966 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
968 /* create a stack frame for the caller of the handler */
969 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
970 addr = (void __user *)regs->gpr[1];
971 if (put_user(regs->gpr[1], (u32 __user *)newsp))
974 /* Fill registers for signal handler */
975 regs->gpr[1] = newsp;
976 regs->gpr[3] = ksig->sig;
977 regs->gpr[4] = (unsigned long) &rt_sf->info;
978 regs->gpr[5] = (unsigned long) &rt_sf->uc;
979 regs->gpr[6] = (unsigned long) rt_sf;
980 regs->nip = (unsigned long) ksig->ka.sa.sa_handler;
981 /* enter the signal handler in native-endian mode */
982 regs->msr &= ~MSR_LE;
983 regs->msr |= (MSR_KERNEL & MSR_LE);
987 if (show_unhandled_signals)
988 printk_ratelimited(KERN_INFO
989 "%s[%d]: bad frame in handle_rt_signal32: "
990 "%p nip %08lx lr %08lx\n",
992 addr, regs->nip, regs->link);
997 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
1000 struct mcontext __user *mcp;
1002 if (get_sigset_t(&set, &ucp->uc_sigmask))
1008 if (__get_user(cmcp, &ucp->uc_regs))
1010 mcp = (struct mcontext __user *)(u64)cmcp;
1011 /* no need to check access_ok(mcp), since mcp < 4GB */
1014 if (__get_user(mcp, &ucp->uc_regs))
1016 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
1019 set_current_blocked(&set);
1020 if (restore_user_regs(regs, mcp, sig))
1026 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1027 static int do_setcontext_tm(struct ucontext __user *ucp,
1028 struct ucontext __user *tm_ucp,
1029 struct pt_regs *regs)
1032 struct mcontext __user *mcp;
1033 struct mcontext __user *tm_mcp;
1037 if (get_sigset_t(&set, &ucp->uc_sigmask))
1040 if (__get_user(cmcp, &ucp->uc_regs) ||
1041 __get_user(tm_cmcp, &tm_ucp->uc_regs))
1043 mcp = (struct mcontext __user *)(u64)cmcp;
1044 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
1045 /* no need to check access_ok(mcp), since mcp < 4GB */
1047 set_current_blocked(&set);
1048 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1056 COMPAT_SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
1057 struct ucontext __user *, new_ctx, int, ctx_size)
1059 SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
1060 struct ucontext __user *, new_ctx, long, ctx_size)
1063 struct pt_regs *regs = current_pt_regs();
1064 int ctx_has_vsx_region = 0;
1067 unsigned long new_msr = 0;
1070 struct mcontext __user *mcp;
1074 * Get pointer to the real mcontext. No need for
1075 * access_ok since we are dealing with compat
1078 if (__get_user(cmcp, &new_ctx->uc_regs))
1080 mcp = (struct mcontext __user *)(u64)cmcp;
1081 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1085 * Check that the context is not smaller than the original
1086 * size (with VMX but without VSX)
1088 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1091 * If the new context state sets the MSR VSX bits but
1092 * it doesn't provide VSX state.
1094 if ((ctx_size < sizeof(struct ucontext)) &&
1095 (new_msr & MSR_VSX))
1097 /* Does the context have enough room to store VSX data? */
1098 if (ctx_size >= sizeof(struct ucontext))
1099 ctx_has_vsx_region = 1;
1101 /* Context size is for future use. Right now, we only make sure
1102 * we are passed something we understand
1104 if (ctx_size < sizeof(struct ucontext))
1107 if (old_ctx != NULL) {
1108 struct mcontext __user *mctx;
1111 * old_ctx might not be 16-byte aligned, in which
1112 * case old_ctx->uc_mcontext won't be either.
1113 * Because we have the old_ctx->uc_pad2 field
1114 * before old_ctx->uc_mcontext, we need to round down
1115 * from &old_ctx->uc_mcontext to a 16-byte boundary.
1117 mctx = (struct mcontext __user *)
1118 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1119 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
1120 || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
1121 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
1122 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1125 if (new_ctx == NULL)
1127 if (!access_ok(VERIFY_READ, new_ctx, ctx_size) ||
1128 fault_in_pages_readable((u8 __user *)new_ctx, ctx_size))
1132 * If we get a fault copying the context into the kernel's
1133 * image of the user's registers, we can't just return -EFAULT
1134 * because the user's registers will be corrupted. For instance
1135 * the NIP value may have been updated but not some of the
1136 * other registers. Given that we have done the access_ok
1137 * and successfully read the first and last bytes of the region
1138 * above, this should only happen in an out-of-memory situation
1139 * or if another thread unmaps the region containing the context.
1140 * We kill the task with a SIGSEGV in this situation.
1142 if (do_setcontext(new_ctx, regs, 0))
1145 set_thread_flag(TIF_RESTOREALL);
1150 COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
1152 SYSCALL_DEFINE0(rt_sigreturn)
1155 struct rt_sigframe __user *rt_sf;
1156 struct pt_regs *regs = current_pt_regs();
1157 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1158 struct ucontext __user *uc_transact;
1159 unsigned long msr_hi;
1163 /* Always make any pending restarted system calls return -EINTR */
1164 current->restart_block.fn = do_no_restart_syscall;
1166 rt_sf = (struct rt_sigframe __user *)
1167 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1168 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1171 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1173 * If there is a transactional state then throw it away.
1174 * The purpose of a sigreturn is to destroy all traces of the
1175 * signal frame, this includes any transactional state created
1176 * within in. We only check for suspended as we can never be
1177 * active in the kernel, we are active, there is nothing better to
1178 * do than go ahead and Bad Thing later.
1179 * The cause is not important as there will never be a
1180 * recheckpoint so it's not user visible.
1182 if (MSR_TM_SUSPENDED(mfmsr()))
1183 tm_reclaim_current(0);
1185 if (__get_user(tmp, &rt_sf->uc.uc_link))
1187 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1190 struct mcontext __user *mcp;
1192 if (__get_user(cmcp, &uc_transact->uc_regs))
1194 mcp = (struct mcontext __user *)(u64)cmcp;
1195 /* The top 32 bits of the MSR are stashed in the transactional
1197 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1200 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1201 /* Trying to start TM on non TM system */
1202 if (!cpu_has_feature(CPU_FTR_TM))
1204 /* We only recheckpoint on return if we're
1208 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1213 /* Fall through, for non-TM restore */
1215 if (do_setcontext(&rt_sf->uc, regs, 1))
1219 * It's not clear whether or why it is desirable to save the
1220 * sigaltstack setting on signal delivery and restore it on
1221 * signal return. But other architectures do this and we have
1222 * always done it up until now so it is probably better not to
1223 * change it. -- paulus
1226 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1229 if (restore_altstack(&rt_sf->uc.uc_stack))
1232 set_thread_flag(TIF_RESTOREALL);
1236 if (show_unhandled_signals)
1237 printk_ratelimited(KERN_INFO
1238 "%s[%d]: bad frame in sys_rt_sigreturn: "
1239 "%p nip %08lx lr %08lx\n",
1240 current->comm, current->pid,
1241 rt_sf, regs->nip, regs->link);
1243 force_sig(SIGSEGV, current);
1248 SYSCALL_DEFINE3(debug_setcontext, struct ucontext __user *, ctx,
1249 int, ndbg, struct sig_dbg_op __user *, dbg)
1251 struct pt_regs *regs = current_pt_regs();
1252 struct sig_dbg_op op;
1254 unsigned long new_msr = regs->msr;
1255 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1256 unsigned long new_dbcr0 = current->thread.debug.dbcr0;
1259 for (i=0; i<ndbg; i++) {
1260 if (copy_from_user(&op, dbg + i, sizeof(op)))
1262 switch (op.dbg_type) {
1263 case SIG_DBG_SINGLE_STEPPING:
1264 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1267 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1269 new_dbcr0 &= ~DBCR0_IC;
1270 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1271 current->thread.debug.dbcr1)) {
1273 new_dbcr0 &= ~DBCR0_IDM;
1283 case SIG_DBG_BRANCH_TRACING:
1284 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1299 /* We wait until here to actually install the values in the
1300 registers so if we fail in the above loop, it will not
1301 affect the contents of these registers. After this point,
1302 failure is a problem, anyway, and it's very unlikely unless
1303 the user is really doing something wrong. */
1304 regs->msr = new_msr;
1305 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1306 current->thread.debug.dbcr0 = new_dbcr0;
1309 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx)) ||
1310 fault_in_pages_readable((u8 __user *)ctx, sizeof(*ctx)))
1314 * If we get a fault copying the context into the kernel's
1315 * image of the user's registers, we can't just return -EFAULT
1316 * because the user's registers will be corrupted. For instance
1317 * the NIP value may have been updated but not some of the
1318 * other registers. Given that we have done the access_ok
1319 * and successfully read the first and last bytes of the region
1320 * above, this should only happen in an out-of-memory situation
1321 * or if another thread unmaps the region containing the context.
1322 * We kill the task with a SIGSEGV in this situation.
1324 if (do_setcontext(ctx, regs, 1)) {
1325 if (show_unhandled_signals)
1326 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1327 "sys_debug_setcontext: %p nip %08lx "
1329 current->comm, current->pid,
1330 ctx, regs->nip, regs->link);
1332 force_sig(SIGSEGV, current);
1337 * It's not clear whether or why it is desirable to save the
1338 * sigaltstack setting on signal delivery and restore it on
1339 * signal return. But other architectures do this and we have
1340 * always done it up until now so it is probably better not to
1341 * change it. -- paulus
1343 restore_altstack(&ctx->uc_stack);
1345 set_thread_flag(TIF_RESTOREALL);
1352 * OK, we're invoking a handler
1354 int handle_signal32(struct ksignal *ksig, sigset_t *oldset,
1355 struct task_struct *tsk)
1357 struct sigcontext __user *sc;
1358 struct sigframe __user *frame;
1359 struct mcontext __user *tm_mctx = NULL;
1360 unsigned long newsp = 0;
1362 unsigned long tramp;
1363 struct pt_regs *regs = tsk->thread.regs;
1364 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1365 /* Save the thread's msr before get_tm_stackpointer() changes it */
1366 unsigned long msr = regs->msr;
1369 BUG_ON(tsk != current);
1371 /* Set up Signal Frame */
1372 frame = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*frame), 1);
1373 if (unlikely(frame == NULL))
1375 sc = (struct sigcontext __user *) &frame->sctx;
1378 #error "Please adjust handle_signal()"
1380 if (__put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler)
1381 || __put_user(oldset->sig[0], &sc->oldmask)
1383 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1385 || __put_user(oldset->sig[1], &sc->_unused[3])
1387 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1388 || __put_user(ksig->sig, &sc->signal))
1391 if (vdso32_sigtramp && tsk->mm->context.vdso_base) {
1393 tramp = tsk->mm->context.vdso_base + vdso32_sigtramp;
1395 sigret = __NR_sigreturn;
1396 tramp = (unsigned long) frame->mctx.tramp;
1399 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1400 tm_mctx = &frame->mctx_transact;
1401 if (MSR_TM_ACTIVE(msr)) {
1402 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1409 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1415 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1417 /* create a stack frame for the caller of the handler */
1418 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1419 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1422 regs->gpr[1] = newsp;
1423 regs->gpr[3] = ksig->sig;
1424 regs->gpr[4] = (unsigned long) sc;
1425 regs->nip = (unsigned long) (unsigned long)ksig->ka.sa.sa_handler;
1426 /* enter the signal handler in big-endian mode */
1427 regs->msr &= ~MSR_LE;
1431 if (show_unhandled_signals)
1432 printk_ratelimited(KERN_INFO
1433 "%s[%d]: bad frame in handle_signal32: "
1434 "%p nip %08lx lr %08lx\n",
1435 tsk->comm, tsk->pid,
1436 frame, regs->nip, regs->link);
1442 * Do a signal return; undo the signal stack.
1445 COMPAT_SYSCALL_DEFINE0(sigreturn)
1447 SYSCALL_DEFINE0(sigreturn)
1450 struct pt_regs *regs = current_pt_regs();
1451 struct sigframe __user *sf;
1452 struct sigcontext __user *sc;
1453 struct sigcontext sigctx;
1454 struct mcontext __user *sr;
1457 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1458 struct mcontext __user *mcp, *tm_mcp;
1459 unsigned long msr_hi;
1462 /* Always make any pending restarted system calls return -EINTR */
1463 current->restart_block.fn = do_no_restart_syscall;
1465 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1468 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1473 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1474 * unused part of the signal stackframe
1476 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1478 set.sig[0] = sigctx.oldmask;
1479 set.sig[1] = sigctx._unused[3];
1481 set_current_blocked(&set);
1483 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1484 mcp = (struct mcontext __user *)&sf->mctx;
1485 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1486 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1488 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1489 if (!cpu_has_feature(CPU_FTR_TM))
1491 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1496 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1498 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1499 || restore_user_regs(regs, sr, 1))
1503 set_thread_flag(TIF_RESTOREALL);
1507 if (show_unhandled_signals)
1508 printk_ratelimited(KERN_INFO
1509 "%s[%d]: bad frame in sys_sigreturn: "
1510 "%p nip %08lx lr %08lx\n",
1511 current->comm, current->pid,
1512 addr, regs->nip, regs->link);
1514 force_sig(SIGSEGV, current);