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)
498 unsigned long msr = regs->msr;
500 WARN_ON(tm_suspend_disabled);
502 /* Remove TM bits from thread's MSR. The MSR in the sigcontext
503 * just indicates to userland that we were doing a transaction, but we
504 * don't want to return in transactional state. This also ensures
505 * that flush_fp_to_thread won't set TIF_RESTORE_TM again.
507 regs->msr &= ~MSR_TS_MASK;
509 /* Save both sets of general registers */
510 if (save_general_regs(¤t->thread.ckpt_regs, frame)
511 || save_general_regs(regs, tm_frame))
514 /* Stash the top half of the 64bit MSR into the 32bit MSR word
515 * of the transactional mcontext. This way we have a backward-compatible
516 * MSR in the 'normal' (checkpointed) mcontext and additionally one can
517 * also look at what type of transaction (T or S) was active at the
518 * time of the signal.
520 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
523 #ifdef CONFIG_ALTIVEC
524 /* save altivec registers */
525 if (current->thread.used_vr) {
526 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.ckvr_state,
527 ELF_NVRREG * sizeof(vector128)))
530 if (__copy_to_user(&tm_frame->mc_vregs,
531 ¤t->thread.vr_state,
532 ELF_NVRREG * sizeof(vector128)))
535 if (__copy_to_user(&tm_frame->mc_vregs,
536 ¤t->thread.ckvr_state,
537 ELF_NVRREG * sizeof(vector128)))
541 /* set MSR_VEC in the saved MSR value to indicate that
542 * frame->mc_vregs contains valid data
547 /* We always copy to/from vrsave, it's 0 if we don't have or don't
548 * use altivec. Since VSCR only contains 32 bits saved in the least
549 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
550 * most significant bits of that same vector. --BenH
552 if (cpu_has_feature(CPU_FTR_ALTIVEC))
553 current->thread.ckvrsave = mfspr(SPRN_VRSAVE);
554 if (__put_user(current->thread.ckvrsave,
555 (u32 __user *)&frame->mc_vregs[32]))
558 if (__put_user(current->thread.vrsave,
559 (u32 __user *)&tm_frame->mc_vregs[32]))
562 if (__put_user(current->thread.ckvrsave,
563 (u32 __user *)&tm_frame->mc_vregs[32]))
566 #endif /* CONFIG_ALTIVEC */
568 if (copy_ckfpr_to_user(&frame->mc_fregs, current))
571 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
574 if (copy_ckfpr_to_user(&tm_frame->mc_fregs, current))
580 * Copy VSR 0-31 upper half from thread_struct to local
581 * buffer, then write that to userspace. Also set MSR_VSX in
582 * the saved MSR value to indicate that frame->mc_vregs
583 * contains valid data
585 if (current->thread.used_vsr) {
586 if (copy_ckvsx_to_user(&frame->mc_vsregs, current))
589 if (copy_vsx_to_user(&tm_frame->mc_vsregs,
593 if (copy_ckvsx_to_user(&tm_frame->mc_vsregs, current))
599 #endif /* CONFIG_VSX */
601 /* SPE regs are not checkpointed with TM, so this section is
602 * simply the same as in save_user_regs().
604 if (current->thread.used_spe) {
605 flush_spe_to_thread(current);
606 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
607 ELF_NEVRREG * sizeof(u32)))
609 /* set MSR_SPE in the saved MSR value to indicate that
610 * frame->mc_vregs contains valid data */
614 /* We always copy to/from spefscr */
615 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
617 #endif /* CONFIG_SPE */
619 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
622 /* Set up the sigreturn trampoline: li r0,sigret; sc */
623 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
624 || __put_user(0x44000002UL, &frame->tramp[1]))
626 flush_icache_range((unsigned long) &frame->tramp[0],
627 (unsigned long) &frame->tramp[2]);
635 * Restore the current user register values from the user stack,
638 static long restore_user_regs(struct pt_regs *regs,
639 struct mcontext __user *sr, int sig)
642 unsigned int save_r2 = 0;
649 * restore general registers but not including MSR or SOFTE. Also
650 * take care of keeping r2 (TLS) intact if not a signal
653 save_r2 = (unsigned int)regs->gpr[2];
654 err = restore_general_regs(regs, sr);
656 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
658 regs->gpr[2] = (unsigned long) save_r2;
662 /* if doing signal return, restore the previous little-endian mode */
664 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
666 #ifdef CONFIG_ALTIVEC
668 * Force the process to reload the altivec registers from
669 * current->thread when it next does altivec instructions
671 regs->msr &= ~MSR_VEC;
673 /* restore altivec registers from the stack */
674 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
675 sizeof(sr->mc_vregs)))
677 current->thread.used_vr = true;
678 } else if (current->thread.used_vr)
679 memset(¤t->thread.vr_state, 0,
680 ELF_NVRREG * sizeof(vector128));
682 /* Always get VRSAVE back */
683 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
685 if (cpu_has_feature(CPU_FTR_ALTIVEC))
686 mtspr(SPRN_VRSAVE, current->thread.vrsave);
687 #endif /* CONFIG_ALTIVEC */
688 if (copy_fpr_from_user(current, &sr->mc_fregs))
693 * Force the process to reload the VSX registers from
694 * current->thread when it next does VSX instruction.
696 regs->msr &= ~MSR_VSX;
699 * Restore altivec registers from the stack to a local
700 * buffer, then write this out to the thread_struct
702 if (copy_vsx_from_user(current, &sr->mc_vsregs))
704 current->thread.used_vsr = true;
705 } else if (current->thread.used_vsr)
706 for (i = 0; i < 32 ; i++)
707 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
708 #endif /* CONFIG_VSX */
710 * force the process to reload the FP registers from
711 * current->thread when it next does FP instructions
713 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
716 /* force the process to reload the spe registers from
717 current->thread when it next does spe instructions */
718 regs->msr &= ~MSR_SPE;
720 /* restore spe registers from the stack */
721 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
722 ELF_NEVRREG * sizeof(u32)))
724 current->thread.used_spe = true;
725 } else if (current->thread.used_spe)
726 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
728 /* Always get SPEFSCR back */
729 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
731 #endif /* CONFIG_SPE */
736 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
738 * Restore the current user register values from the user stack, except for
739 * MSR, and recheckpoint the original checkpointed register state for processes
742 static long restore_tm_user_regs(struct pt_regs *regs,
743 struct mcontext __user *sr,
744 struct mcontext __user *tm_sr)
747 unsigned long msr, msr_hi;
752 if (tm_suspend_disabled)
755 * restore general registers but not including MSR or SOFTE. Also
756 * take care of keeping r2 (TLS) intact if not a signal.
757 * See comment in signal_64.c:restore_tm_sigcontexts();
758 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
759 * were set by the signal delivery.
761 err = restore_general_regs(regs, tm_sr);
762 err |= restore_general_regs(¤t->thread.ckpt_regs, sr);
764 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
766 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
770 /* Restore the previous little-endian mode */
771 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
773 #ifdef CONFIG_ALTIVEC
774 regs->msr &= ~MSR_VEC;
776 /* restore altivec registers from the stack */
777 if (__copy_from_user(¤t->thread.ckvr_state, &sr->mc_vregs,
778 sizeof(sr->mc_vregs)) ||
779 __copy_from_user(¤t->thread.vr_state,
781 sizeof(sr->mc_vregs)))
783 current->thread.used_vr = true;
784 } else if (current->thread.used_vr) {
785 memset(¤t->thread.vr_state, 0,
786 ELF_NVRREG * sizeof(vector128));
787 memset(¤t->thread.ckvr_state, 0,
788 ELF_NVRREG * sizeof(vector128));
791 /* Always get VRSAVE back */
792 if (__get_user(current->thread.ckvrsave,
793 (u32 __user *)&sr->mc_vregs[32]) ||
794 __get_user(current->thread.vrsave,
795 (u32 __user *)&tm_sr->mc_vregs[32]))
797 if (cpu_has_feature(CPU_FTR_ALTIVEC))
798 mtspr(SPRN_VRSAVE, current->thread.ckvrsave);
799 #endif /* CONFIG_ALTIVEC */
801 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
803 if (copy_fpr_from_user(current, &sr->mc_fregs) ||
804 copy_ckfpr_from_user(current, &tm_sr->mc_fregs))
808 regs->msr &= ~MSR_VSX;
811 * Restore altivec registers from the stack to a local
812 * buffer, then write this out to the thread_struct
814 if (copy_vsx_from_user(current, &tm_sr->mc_vsregs) ||
815 copy_ckvsx_from_user(current, &sr->mc_vsregs))
817 current->thread.used_vsr = true;
818 } else if (current->thread.used_vsr)
819 for (i = 0; i < 32 ; i++) {
820 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
821 current->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
823 #endif /* CONFIG_VSX */
826 /* SPE regs are not checkpointed with TM, so this section is
827 * simply the same as in restore_user_regs().
829 regs->msr &= ~MSR_SPE;
831 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
832 ELF_NEVRREG * sizeof(u32)))
834 current->thread.used_spe = true;
835 } else if (current->thread.used_spe)
836 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
838 /* Always get SPEFSCR back */
839 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
842 #endif /* CONFIG_SPE */
844 /* Get the top half of the MSR from the user context */
845 if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR]))
848 /* If TM bits are set to the reserved value, it's an invalid context */
849 if (MSR_TM_RESV(msr_hi))
851 /* Pull in the MSR TM bits from the user context */
852 regs->msr = (regs->msr & ~MSR_TS_MASK) | (msr_hi & MSR_TS_MASK);
853 /* Now, recheckpoint. This loads up all of the checkpointed (older)
854 * registers, including FP and V[S]Rs. After recheckpointing, the
855 * transactional versions should be loaded.
858 /* Make sure the transaction is marked as failed */
859 current->thread.tm_texasr |= TEXASR_FS;
860 /* This loads the checkpointed FP/VEC state, if used */
861 tm_recheckpoint(¤t->thread);
863 /* This loads the speculative FP/VEC state, if used */
864 msr_check_and_set(msr & (MSR_FP | MSR_VEC));
866 load_fp_state(¤t->thread.fp_state);
867 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
869 #ifdef CONFIG_ALTIVEC
871 load_vr_state(¤t->thread.vr_state);
872 regs->msr |= MSR_VEC;
882 #define copy_siginfo_to_user copy_siginfo_to_user32
884 #endif /* CONFIG_PPC64 */
887 * Set up a signal frame for a "real-time" signal handler
888 * (one which gets siginfo).
890 int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
891 struct task_struct *tsk)
893 struct rt_sigframe __user *rt_sf;
894 struct mcontext __user *frame;
895 struct mcontext __user *tm_frame = NULL;
897 unsigned long newsp = 0;
900 struct pt_regs *regs = tsk->thread.regs;
902 BUG_ON(tsk != current);
904 /* Set up Signal Frame */
905 /* Put a Real Time Context onto stack */
906 rt_sf = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*rt_sf), 1);
908 if (unlikely(rt_sf == NULL))
911 /* Put the siginfo & fill in most of the ucontext */
912 if (copy_siginfo_to_user(&rt_sf->info, &ksig->info)
913 || __put_user(0, &rt_sf->uc.uc_flags)
914 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
915 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
917 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
920 /* Save user registers on the stack */
921 frame = &rt_sf->uc.uc_mcontext;
923 if (vdso32_rt_sigtramp && tsk->mm->context.vdso_base) {
925 tramp = tsk->mm->context.vdso_base + vdso32_rt_sigtramp;
927 sigret = __NR_rt_sigreturn;
928 tramp = (unsigned long) frame->tramp;
931 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
932 tm_frame = &rt_sf->uc_transact.uc_mcontext;
933 if (MSR_TM_ACTIVE(regs->msr)) {
934 if (__put_user((unsigned long)&rt_sf->uc_transact,
935 &rt_sf->uc.uc_link) ||
936 __put_user((unsigned long)tm_frame,
937 &rt_sf->uc_transact.uc_regs))
939 if (save_tm_user_regs(regs, frame, tm_frame, sigret))
945 if (__put_user(0, &rt_sf->uc.uc_link))
947 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
952 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
954 /* create a stack frame for the caller of the handler */
955 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
956 addr = (void __user *)regs->gpr[1];
957 if (put_user(regs->gpr[1], (u32 __user *)newsp))
960 /* Fill registers for signal handler */
961 regs->gpr[1] = newsp;
962 regs->gpr[3] = ksig->sig;
963 regs->gpr[4] = (unsigned long) &rt_sf->info;
964 regs->gpr[5] = (unsigned long) &rt_sf->uc;
965 regs->gpr[6] = (unsigned long) rt_sf;
966 regs->nip = (unsigned long) ksig->ka.sa.sa_handler;
967 /* enter the signal handler in native-endian mode */
968 regs->msr &= ~MSR_LE;
969 regs->msr |= (MSR_KERNEL & MSR_LE);
973 if (show_unhandled_signals)
974 printk_ratelimited(KERN_INFO
975 "%s[%d]: bad frame in handle_rt_signal32: "
976 "%p nip %08lx lr %08lx\n",
978 addr, regs->nip, regs->link);
983 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
986 struct mcontext __user *mcp;
988 if (get_sigset_t(&set, &ucp->uc_sigmask))
994 if (__get_user(cmcp, &ucp->uc_regs))
996 mcp = (struct mcontext __user *)(u64)cmcp;
997 /* no need to check access_ok(mcp), since mcp < 4GB */
1000 if (__get_user(mcp, &ucp->uc_regs))
1002 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
1005 set_current_blocked(&set);
1006 if (restore_user_regs(regs, mcp, sig))
1012 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1013 static int do_setcontext_tm(struct ucontext __user *ucp,
1014 struct ucontext __user *tm_ucp,
1015 struct pt_regs *regs)
1018 struct mcontext __user *mcp;
1019 struct mcontext __user *tm_mcp;
1023 if (get_sigset_t(&set, &ucp->uc_sigmask))
1026 if (__get_user(cmcp, &ucp->uc_regs) ||
1027 __get_user(tm_cmcp, &tm_ucp->uc_regs))
1029 mcp = (struct mcontext __user *)(u64)cmcp;
1030 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
1031 /* no need to check access_ok(mcp), since mcp < 4GB */
1033 set_current_blocked(&set);
1034 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1042 COMPAT_SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
1043 struct ucontext __user *, new_ctx, int, ctx_size)
1045 SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
1046 struct ucontext __user *, new_ctx, long, ctx_size)
1049 struct pt_regs *regs = current_pt_regs();
1050 int ctx_has_vsx_region = 0;
1053 unsigned long new_msr = 0;
1056 struct mcontext __user *mcp;
1060 * Get pointer to the real mcontext. No need for
1061 * access_ok since we are dealing with compat
1064 if (__get_user(cmcp, &new_ctx->uc_regs))
1066 mcp = (struct mcontext __user *)(u64)cmcp;
1067 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1071 * Check that the context is not smaller than the original
1072 * size (with VMX but without VSX)
1074 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1077 * If the new context state sets the MSR VSX bits but
1078 * it doesn't provide VSX state.
1080 if ((ctx_size < sizeof(struct ucontext)) &&
1081 (new_msr & MSR_VSX))
1083 /* Does the context have enough room to store VSX data? */
1084 if (ctx_size >= sizeof(struct ucontext))
1085 ctx_has_vsx_region = 1;
1087 /* Context size is for future use. Right now, we only make sure
1088 * we are passed something we understand
1090 if (ctx_size < sizeof(struct ucontext))
1093 if (old_ctx != NULL) {
1094 struct mcontext __user *mctx;
1097 * old_ctx might not be 16-byte aligned, in which
1098 * case old_ctx->uc_mcontext won't be either.
1099 * Because we have the old_ctx->uc_pad2 field
1100 * before old_ctx->uc_mcontext, we need to round down
1101 * from &old_ctx->uc_mcontext to a 16-byte boundary.
1103 mctx = (struct mcontext __user *)
1104 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1105 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
1106 || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
1107 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
1108 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1111 if (new_ctx == NULL)
1113 if (!access_ok(VERIFY_READ, new_ctx, ctx_size) ||
1114 fault_in_pages_readable((u8 __user *)new_ctx, ctx_size))
1118 * If we get a fault copying the context into the kernel's
1119 * image of the user's registers, we can't just return -EFAULT
1120 * because the user's registers will be corrupted. For instance
1121 * the NIP value may have been updated but not some of the
1122 * other registers. Given that we have done the access_ok
1123 * and successfully read the first and last bytes of the region
1124 * above, this should only happen in an out-of-memory situation
1125 * or if another thread unmaps the region containing the context.
1126 * We kill the task with a SIGSEGV in this situation.
1128 if (do_setcontext(new_ctx, regs, 0))
1131 set_thread_flag(TIF_RESTOREALL);
1136 COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
1138 SYSCALL_DEFINE0(rt_sigreturn)
1141 struct rt_sigframe __user *rt_sf;
1142 struct pt_regs *regs = current_pt_regs();
1143 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1144 struct ucontext __user *uc_transact;
1145 unsigned long msr_hi;
1149 /* Always make any pending restarted system calls return -EINTR */
1150 current->restart_block.fn = do_no_restart_syscall;
1152 rt_sf = (struct rt_sigframe __user *)
1153 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1154 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1157 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1159 * If there is a transactional state then throw it away.
1160 * The purpose of a sigreturn is to destroy all traces of the
1161 * signal frame, this includes any transactional state created
1162 * within in. We only check for suspended as we can never be
1163 * active in the kernel, we are active, there is nothing better to
1164 * do than go ahead and Bad Thing later.
1165 * The cause is not important as there will never be a
1166 * recheckpoint so it's not user visible.
1168 if (MSR_TM_SUSPENDED(mfmsr()))
1169 tm_reclaim_current(0);
1171 if (__get_user(tmp, &rt_sf->uc.uc_link))
1173 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1176 struct mcontext __user *mcp;
1178 if (__get_user(cmcp, &uc_transact->uc_regs))
1180 mcp = (struct mcontext __user *)(u64)cmcp;
1181 /* The top 32 bits of the MSR are stashed in the transactional
1183 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1186 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1187 /* We only recheckpoint on return if we're
1191 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1196 /* Fall through, for non-TM restore */
1198 if (do_setcontext(&rt_sf->uc, regs, 1))
1202 * It's not clear whether or why it is desirable to save the
1203 * sigaltstack setting on signal delivery and restore it on
1204 * signal return. But other architectures do this and we have
1205 * always done it up until now so it is probably better not to
1206 * change it. -- paulus
1209 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1212 if (restore_altstack(&rt_sf->uc.uc_stack))
1215 set_thread_flag(TIF_RESTOREALL);
1219 if (show_unhandled_signals)
1220 printk_ratelimited(KERN_INFO
1221 "%s[%d]: bad frame in sys_rt_sigreturn: "
1222 "%p nip %08lx lr %08lx\n",
1223 current->comm, current->pid,
1224 rt_sf, regs->nip, regs->link);
1226 force_sig(SIGSEGV, current);
1231 SYSCALL_DEFINE3(debug_setcontext, struct ucontext __user *, ctx,
1232 int, ndbg, struct sig_dbg_op __user *, dbg)
1234 struct pt_regs *regs = current_pt_regs();
1235 struct sig_dbg_op op;
1237 unsigned long new_msr = regs->msr;
1238 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1239 unsigned long new_dbcr0 = current->thread.debug.dbcr0;
1242 for (i=0; i<ndbg; i++) {
1243 if (copy_from_user(&op, dbg + i, sizeof(op)))
1245 switch (op.dbg_type) {
1246 case SIG_DBG_SINGLE_STEPPING:
1247 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1250 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1252 new_dbcr0 &= ~DBCR0_IC;
1253 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1254 current->thread.debug.dbcr1)) {
1256 new_dbcr0 &= ~DBCR0_IDM;
1266 case SIG_DBG_BRANCH_TRACING:
1267 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1282 /* We wait until here to actually install the values in the
1283 registers so if we fail in the above loop, it will not
1284 affect the contents of these registers. After this point,
1285 failure is a problem, anyway, and it's very unlikely unless
1286 the user is really doing something wrong. */
1287 regs->msr = new_msr;
1288 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1289 current->thread.debug.dbcr0 = new_dbcr0;
1292 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx)) ||
1293 fault_in_pages_readable((u8 __user *)ctx, sizeof(*ctx)))
1297 * If we get a fault copying the context into the kernel's
1298 * image of the user's registers, we can't just return -EFAULT
1299 * because the user's registers will be corrupted. For instance
1300 * the NIP value may have been updated but not some of the
1301 * other registers. Given that we have done the access_ok
1302 * and successfully read the first and last bytes of the region
1303 * above, this should only happen in an out-of-memory situation
1304 * or if another thread unmaps the region containing the context.
1305 * We kill the task with a SIGSEGV in this situation.
1307 if (do_setcontext(ctx, regs, 1)) {
1308 if (show_unhandled_signals)
1309 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1310 "sys_debug_setcontext: %p nip %08lx "
1312 current->comm, current->pid,
1313 ctx, regs->nip, regs->link);
1315 force_sig(SIGSEGV, current);
1320 * It's not clear whether or why it is desirable to save the
1321 * sigaltstack setting on signal delivery and restore it on
1322 * signal return. But other architectures do this and we have
1323 * always done it up until now so it is probably better not to
1324 * change it. -- paulus
1326 restore_altstack(&ctx->uc_stack);
1328 set_thread_flag(TIF_RESTOREALL);
1335 * OK, we're invoking a handler
1337 int handle_signal32(struct ksignal *ksig, sigset_t *oldset,
1338 struct task_struct *tsk)
1340 struct sigcontext __user *sc;
1341 struct sigframe __user *frame;
1342 struct mcontext __user *tm_mctx = NULL;
1343 unsigned long newsp = 0;
1345 unsigned long tramp;
1346 struct pt_regs *regs = tsk->thread.regs;
1348 BUG_ON(tsk != current);
1350 /* Set up Signal Frame */
1351 frame = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*frame), 1);
1352 if (unlikely(frame == NULL))
1354 sc = (struct sigcontext __user *) &frame->sctx;
1357 #error "Please adjust handle_signal()"
1359 if (__put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler)
1360 || __put_user(oldset->sig[0], &sc->oldmask)
1362 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1364 || __put_user(oldset->sig[1], &sc->_unused[3])
1366 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1367 || __put_user(ksig->sig, &sc->signal))
1370 if (vdso32_sigtramp && tsk->mm->context.vdso_base) {
1372 tramp = tsk->mm->context.vdso_base + vdso32_sigtramp;
1374 sigret = __NR_sigreturn;
1375 tramp = (unsigned long) frame->mctx.tramp;
1378 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1379 tm_mctx = &frame->mctx_transact;
1380 if (MSR_TM_ACTIVE(regs->msr)) {
1381 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1388 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1394 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1396 /* create a stack frame for the caller of the handler */
1397 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1398 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1401 regs->gpr[1] = newsp;
1402 regs->gpr[3] = ksig->sig;
1403 regs->gpr[4] = (unsigned long) sc;
1404 regs->nip = (unsigned long) (unsigned long)ksig->ka.sa.sa_handler;
1405 /* enter the signal handler in big-endian mode */
1406 regs->msr &= ~MSR_LE;
1410 if (show_unhandled_signals)
1411 printk_ratelimited(KERN_INFO
1412 "%s[%d]: bad frame in handle_signal32: "
1413 "%p nip %08lx lr %08lx\n",
1414 tsk->comm, tsk->pid,
1415 frame, regs->nip, regs->link);
1421 * Do a signal return; undo the signal stack.
1424 COMPAT_SYSCALL_DEFINE0(sigreturn)
1426 SYSCALL_DEFINE0(sigreturn)
1429 struct pt_regs *regs = current_pt_regs();
1430 struct sigframe __user *sf;
1431 struct sigcontext __user *sc;
1432 struct sigcontext sigctx;
1433 struct mcontext __user *sr;
1436 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1437 struct mcontext __user *mcp, *tm_mcp;
1438 unsigned long msr_hi;
1441 /* Always make any pending restarted system calls return -EINTR */
1442 current->restart_block.fn = do_no_restart_syscall;
1444 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1447 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1452 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1453 * unused part of the signal stackframe
1455 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1457 set.sig[0] = sigctx.oldmask;
1458 set.sig[1] = sigctx._unused[3];
1460 set_current_blocked(&set);
1462 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1463 mcp = (struct mcontext __user *)&sf->mctx;
1464 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1465 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1467 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1468 if (!cpu_has_feature(CPU_FTR_TM))
1470 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1475 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1477 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1478 || restore_user_regs(regs, sr, 1))
1482 set_thread_flag(TIF_RESTOREALL);
1486 if (show_unhandled_signals)
1487 printk_ratelimited(KERN_INFO
1488 "%s[%d]: bad frame in sys_sigreturn: "
1489 "%p nip %08lx lr %08lx\n",
1490 current->comm, current->pid,
1491 addr, regs->nip, regs->link);
1493 force_sig(SIGSEGV, current);