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 0,sigret; sc */
474 if (__put_user(PPC_INST_ADDI + sigret, &frame->tramp[0])
475 || __put_user(PPC_INST_SC, &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 0,sigret; sc */
623 if (__put_user(PPC_INST_ADDI + sigret, &frame->tramp[0])
624 || __put_user(PPC_INST_SC, &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))
853 * Disabling preemption, since it is unsafe to be preempted
854 * with MSR[TS] set without recheckpointing.
860 * After regs->MSR[TS] being updated, make sure that get_user(),
861 * put_user() or similar functions are *not* called. These
862 * functions can generate page faults which will cause the process
863 * to be de-scheduled with MSR[TS] set but without calling
864 * tm_recheckpoint(). This can cause a bug.
866 * Pull in the MSR TM bits from the user context
868 regs->msr = (regs->msr & ~MSR_TS_MASK) | (msr_hi & MSR_TS_MASK);
869 /* Now, recheckpoint. This loads up all of the checkpointed (older)
870 * registers, including FP and V[S]Rs. After recheckpointing, the
871 * transactional versions should be loaded.
874 /* Make sure the transaction is marked as failed */
875 current->thread.tm_texasr |= TEXASR_FS;
876 /* This loads the checkpointed FP/VEC state, if used */
877 tm_recheckpoint(¤t->thread);
879 /* This loads the speculative FP/VEC state, if used */
880 msr_check_and_set(msr & (MSR_FP | MSR_VEC));
882 load_fp_state(¤t->thread.fp_state);
883 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
885 #ifdef CONFIG_ALTIVEC
887 load_vr_state(¤t->thread.vr_state);
888 regs->msr |= MSR_VEC;
900 #define copy_siginfo_to_user copy_siginfo_to_user32
902 #endif /* CONFIG_PPC64 */
905 * Set up a signal frame for a "real-time" signal handler
906 * (one which gets siginfo).
908 int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
909 struct task_struct *tsk)
911 struct rt_sigframe __user *rt_sf;
912 struct mcontext __user *frame;
913 struct mcontext __user *tm_frame = NULL;
915 unsigned long newsp = 0;
918 struct pt_regs *regs = tsk->thread.regs;
920 BUG_ON(tsk != current);
922 /* Set up Signal Frame */
923 /* Put a Real Time Context onto stack */
924 rt_sf = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*rt_sf), 1);
926 if (unlikely(rt_sf == NULL))
929 /* Put the siginfo & fill in most of the ucontext */
930 if (copy_siginfo_to_user(&rt_sf->info, &ksig->info)
931 || __put_user(0, &rt_sf->uc.uc_flags)
932 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
933 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
935 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
938 /* Save user registers on the stack */
939 frame = &rt_sf->uc.uc_mcontext;
941 if (vdso32_rt_sigtramp && tsk->mm->context.vdso_base) {
943 tramp = tsk->mm->context.vdso_base + vdso32_rt_sigtramp;
945 sigret = __NR_rt_sigreturn;
946 tramp = (unsigned long) frame->tramp;
949 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
950 tm_frame = &rt_sf->uc_transact.uc_mcontext;
951 if (MSR_TM_ACTIVE(regs->msr)) {
952 if (__put_user((unsigned long)&rt_sf->uc_transact,
953 &rt_sf->uc.uc_link) ||
954 __put_user((unsigned long)tm_frame,
955 &rt_sf->uc_transact.uc_regs))
957 if (save_tm_user_regs(regs, frame, tm_frame, sigret))
963 if (__put_user(0, &rt_sf->uc.uc_link))
965 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
970 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
972 /* create a stack frame for the caller of the handler */
973 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
974 addr = (void __user *)regs->gpr[1];
975 if (put_user(regs->gpr[1], (u32 __user *)newsp))
978 /* Fill registers for signal handler */
979 regs->gpr[1] = newsp;
980 regs->gpr[3] = ksig->sig;
981 regs->gpr[4] = (unsigned long) &rt_sf->info;
982 regs->gpr[5] = (unsigned long) &rt_sf->uc;
983 regs->gpr[6] = (unsigned long) rt_sf;
984 regs->nip = (unsigned long) ksig->ka.sa.sa_handler;
985 /* enter the signal handler in native-endian mode */
986 regs->msr &= ~MSR_LE;
987 regs->msr |= (MSR_KERNEL & MSR_LE);
991 if (show_unhandled_signals)
992 printk_ratelimited(KERN_INFO
993 "%s[%d]: bad frame in handle_rt_signal32: "
994 "%p nip %08lx lr %08lx\n",
996 addr, regs->nip, regs->link);
1001 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
1004 struct mcontext __user *mcp;
1006 if (get_sigset_t(&set, &ucp->uc_sigmask))
1012 if (__get_user(cmcp, &ucp->uc_regs))
1014 mcp = (struct mcontext __user *)(u64)cmcp;
1015 /* no need to check access_ok(mcp), since mcp < 4GB */
1018 if (__get_user(mcp, &ucp->uc_regs))
1020 if (!access_ok(mcp, sizeof(*mcp)))
1023 set_current_blocked(&set);
1024 if (restore_user_regs(regs, mcp, sig))
1030 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1031 static int do_setcontext_tm(struct ucontext __user *ucp,
1032 struct ucontext __user *tm_ucp,
1033 struct pt_regs *regs)
1036 struct mcontext __user *mcp;
1037 struct mcontext __user *tm_mcp;
1041 if (get_sigset_t(&set, &ucp->uc_sigmask))
1044 if (__get_user(cmcp, &ucp->uc_regs) ||
1045 __get_user(tm_cmcp, &tm_ucp->uc_regs))
1047 mcp = (struct mcontext __user *)(u64)cmcp;
1048 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
1049 /* no need to check access_ok(mcp), since mcp < 4GB */
1051 set_current_blocked(&set);
1052 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1060 COMPAT_SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
1061 struct ucontext __user *, new_ctx, int, ctx_size)
1063 SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
1064 struct ucontext __user *, new_ctx, long, ctx_size)
1067 struct pt_regs *regs = current_pt_regs();
1068 int ctx_has_vsx_region = 0;
1071 unsigned long new_msr = 0;
1074 struct mcontext __user *mcp;
1078 * Get pointer to the real mcontext. No need for
1079 * access_ok since we are dealing with compat
1082 if (__get_user(cmcp, &new_ctx->uc_regs))
1084 mcp = (struct mcontext __user *)(u64)cmcp;
1085 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1089 * Check that the context is not smaller than the original
1090 * size (with VMX but without VSX)
1092 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1095 * If the new context state sets the MSR VSX bits but
1096 * it doesn't provide VSX state.
1098 if ((ctx_size < sizeof(struct ucontext)) &&
1099 (new_msr & MSR_VSX))
1101 /* Does the context have enough room to store VSX data? */
1102 if (ctx_size >= sizeof(struct ucontext))
1103 ctx_has_vsx_region = 1;
1105 /* Context size is for future use. Right now, we only make sure
1106 * we are passed something we understand
1108 if (ctx_size < sizeof(struct ucontext))
1111 if (old_ctx != NULL) {
1112 struct mcontext __user *mctx;
1115 * old_ctx might not be 16-byte aligned, in which
1116 * case old_ctx->uc_mcontext won't be either.
1117 * Because we have the old_ctx->uc_pad2 field
1118 * before old_ctx->uc_mcontext, we need to round down
1119 * from &old_ctx->uc_mcontext to a 16-byte boundary.
1121 mctx = (struct mcontext __user *)
1122 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1123 if (!access_ok(old_ctx, ctx_size)
1124 || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
1125 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
1126 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1129 if (new_ctx == NULL)
1131 if (!access_ok(new_ctx, ctx_size) ||
1132 fault_in_pages_readable((u8 __user *)new_ctx, ctx_size))
1136 * If we get a fault copying the context into the kernel's
1137 * image of the user's registers, we can't just return -EFAULT
1138 * because the user's registers will be corrupted. For instance
1139 * the NIP value may have been updated but not some of the
1140 * other registers. Given that we have done the access_ok
1141 * and successfully read the first and last bytes of the region
1142 * above, this should only happen in an out-of-memory situation
1143 * or if another thread unmaps the region containing the context.
1144 * We kill the task with a SIGSEGV in this situation.
1146 if (do_setcontext(new_ctx, regs, 0))
1149 set_thread_flag(TIF_RESTOREALL);
1154 COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
1156 SYSCALL_DEFINE0(rt_sigreturn)
1159 struct rt_sigframe __user *rt_sf;
1160 struct pt_regs *regs = current_pt_regs();
1162 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1163 struct ucontext __user *uc_transact;
1164 unsigned long msr_hi;
1167 /* Always make any pending restarted system calls return -EINTR */
1168 current->restart_block.fn = do_no_restart_syscall;
1170 rt_sf = (struct rt_sigframe __user *)
1171 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1172 if (!access_ok(rt_sf, sizeof(*rt_sf)))
1175 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1177 * If there is a transactional state then throw it away.
1178 * The purpose of a sigreturn is to destroy all traces of the
1179 * signal frame, this includes any transactional state created
1180 * within in. We only check for suspended as we can never be
1181 * active in the kernel, we are active, there is nothing better to
1182 * do than go ahead and Bad Thing later.
1183 * The cause is not important as there will never be a
1184 * recheckpoint so it's not user visible.
1186 if (MSR_TM_SUSPENDED(mfmsr()))
1187 tm_reclaim_current(0);
1189 if (__get_user(tmp, &rt_sf->uc.uc_link))
1191 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1194 struct mcontext __user *mcp;
1196 if (__get_user(cmcp, &uc_transact->uc_regs))
1198 mcp = (struct mcontext __user *)(u64)cmcp;
1199 /* The top 32 bits of the MSR are stashed in the transactional
1201 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1204 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1205 /* We only recheckpoint on return if we're
1209 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1215 * Unset regs->msr because ucontext MSR TS is not
1216 * set, and recheckpoint was not called. This avoid
1217 * hitting a TM Bad thing at RFID
1219 regs->msr &= ~MSR_TS_MASK;
1221 /* Fall through, for non-TM restore */
1224 if (do_setcontext(&rt_sf->uc, regs, 1))
1228 * It's not clear whether or why it is desirable to save the
1229 * sigaltstack setting on signal delivery and restore it on
1230 * signal return. But other architectures do this and we have
1231 * always done it up until now so it is probably better not to
1232 * change it. -- paulus
1235 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1238 if (restore_altstack(&rt_sf->uc.uc_stack))
1241 set_thread_flag(TIF_RESTOREALL);
1245 if (show_unhandled_signals)
1246 printk_ratelimited(KERN_INFO
1247 "%s[%d]: bad frame in sys_rt_sigreturn: "
1248 "%p nip %08lx lr %08lx\n",
1249 current->comm, current->pid,
1250 rt_sf, regs->nip, regs->link);
1252 force_sig(SIGSEGV, current);
1257 SYSCALL_DEFINE3(debug_setcontext, struct ucontext __user *, ctx,
1258 int, ndbg, struct sig_dbg_op __user *, dbg)
1260 struct pt_regs *regs = current_pt_regs();
1261 struct sig_dbg_op op;
1263 unsigned long new_msr = regs->msr;
1264 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1265 unsigned long new_dbcr0 = current->thread.debug.dbcr0;
1268 for (i=0; i<ndbg; i++) {
1269 if (copy_from_user(&op, dbg + i, sizeof(op)))
1271 switch (op.dbg_type) {
1272 case SIG_DBG_SINGLE_STEPPING:
1273 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1276 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1278 new_dbcr0 &= ~DBCR0_IC;
1279 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1280 current->thread.debug.dbcr1)) {
1282 new_dbcr0 &= ~DBCR0_IDM;
1292 case SIG_DBG_BRANCH_TRACING:
1293 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1308 /* We wait until here to actually install the values in the
1309 registers so if we fail in the above loop, it will not
1310 affect the contents of these registers. After this point,
1311 failure is a problem, anyway, and it's very unlikely unless
1312 the user is really doing something wrong. */
1313 regs->msr = new_msr;
1314 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1315 current->thread.debug.dbcr0 = new_dbcr0;
1318 if (!access_ok(ctx, sizeof(*ctx)) ||
1319 fault_in_pages_readable((u8 __user *)ctx, sizeof(*ctx)))
1323 * If we get a fault copying the context into the kernel's
1324 * image of the user's registers, we can't just return -EFAULT
1325 * because the user's registers will be corrupted. For instance
1326 * the NIP value may have been updated but not some of the
1327 * other registers. Given that we have done the access_ok
1328 * and successfully read the first and last bytes of the region
1329 * above, this should only happen in an out-of-memory situation
1330 * or if another thread unmaps the region containing the context.
1331 * We kill the task with a SIGSEGV in this situation.
1333 if (do_setcontext(ctx, regs, 1)) {
1334 if (show_unhandled_signals)
1335 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1336 "sys_debug_setcontext: %p nip %08lx "
1338 current->comm, current->pid,
1339 ctx, regs->nip, regs->link);
1341 force_sig(SIGSEGV, current);
1346 * It's not clear whether or why it is desirable to save the
1347 * sigaltstack setting on signal delivery and restore it on
1348 * signal return. But other architectures do this and we have
1349 * always done it up until now so it is probably better not to
1350 * change it. -- paulus
1352 restore_altstack(&ctx->uc_stack);
1354 set_thread_flag(TIF_RESTOREALL);
1361 * OK, we're invoking a handler
1363 int handle_signal32(struct ksignal *ksig, sigset_t *oldset,
1364 struct task_struct *tsk)
1366 struct sigcontext __user *sc;
1367 struct sigframe __user *frame;
1368 struct mcontext __user *tm_mctx = NULL;
1369 unsigned long newsp = 0;
1371 unsigned long tramp;
1372 struct pt_regs *regs = tsk->thread.regs;
1374 BUG_ON(tsk != current);
1376 /* Set up Signal Frame */
1377 frame = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*frame), 1);
1378 if (unlikely(frame == NULL))
1380 sc = (struct sigcontext __user *) &frame->sctx;
1383 #error "Please adjust handle_signal()"
1385 if (__put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler)
1386 || __put_user(oldset->sig[0], &sc->oldmask)
1388 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1390 || __put_user(oldset->sig[1], &sc->_unused[3])
1392 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1393 || __put_user(ksig->sig, &sc->signal))
1396 if (vdso32_sigtramp && tsk->mm->context.vdso_base) {
1398 tramp = tsk->mm->context.vdso_base + vdso32_sigtramp;
1400 sigret = __NR_sigreturn;
1401 tramp = (unsigned long) frame->mctx.tramp;
1404 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1405 tm_mctx = &frame->mctx_transact;
1406 if (MSR_TM_ACTIVE(regs->msr)) {
1407 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1414 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1420 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1422 /* create a stack frame for the caller of the handler */
1423 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1424 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1427 regs->gpr[1] = newsp;
1428 regs->gpr[3] = ksig->sig;
1429 regs->gpr[4] = (unsigned long) sc;
1430 regs->nip = (unsigned long) (unsigned long)ksig->ka.sa.sa_handler;
1431 /* enter the signal handler in big-endian mode */
1432 regs->msr &= ~MSR_LE;
1436 if (show_unhandled_signals)
1437 printk_ratelimited(KERN_INFO
1438 "%s[%d]: bad frame in handle_signal32: "
1439 "%p nip %08lx lr %08lx\n",
1440 tsk->comm, tsk->pid,
1441 frame, regs->nip, regs->link);
1447 * Do a signal return; undo the signal stack.
1450 COMPAT_SYSCALL_DEFINE0(sigreturn)
1452 SYSCALL_DEFINE0(sigreturn)
1455 struct pt_regs *regs = current_pt_regs();
1456 struct sigframe __user *sf;
1457 struct sigcontext __user *sc;
1458 struct sigcontext sigctx;
1459 struct mcontext __user *sr;
1462 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1463 struct mcontext __user *mcp, *tm_mcp;
1464 unsigned long msr_hi;
1467 /* Always make any pending restarted system calls return -EINTR */
1468 current->restart_block.fn = do_no_restart_syscall;
1470 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1473 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1478 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1479 * unused part of the signal stackframe
1481 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1483 set.sig[0] = sigctx.oldmask;
1484 set.sig[1] = sigctx._unused[3];
1486 set_current_blocked(&set);
1488 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1489 mcp = (struct mcontext __user *)&sf->mctx;
1490 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1491 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1493 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1494 if (!cpu_has_feature(CPU_FTR_TM))
1496 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1501 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1503 if (!access_ok(sr, sizeof(*sr))
1504 || restore_user_regs(regs, sr, 1))
1508 set_thread_flag(TIF_RESTOREALL);
1512 if (show_unhandled_signals)
1513 printk_ratelimited(KERN_INFO
1514 "%s[%d]: bad frame in sys_sigreturn: "
1515 "%p nip %08lx lr %08lx\n",
1516 current->comm, current->pid,
1517 addr, regs->nip, regs->link);
1519 force_sig(SIGSEGV, current);