1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC
6 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
7 * Copyright (C) 2001 IBM
8 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
9 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
11 * Derived from "arch/i386/kernel/signal.c"
12 * Copyright (C) 1991, 1992 Linus Torvalds
13 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
16 #include <linux/sched.h>
18 #include <linux/smp.h>
19 #include <linux/kernel.h>
20 #include <linux/signal.h>
21 #include <linux/errno.h>
22 #include <linux/elf.h>
23 #include <linux/ptrace.h>
24 #include <linux/pagemap.h>
25 #include <linux/ratelimit.h>
26 #include <linux/syscalls.h>
28 #include <linux/compat.h>
30 #include <linux/wait.h>
31 #include <linux/unistd.h>
32 #include <linux/stddef.h>
33 #include <linux/tty.h>
34 #include <linux/binfmts.h>
37 #include <linux/uaccess.h>
38 #include <asm/cacheflush.h>
39 #include <asm/syscalls.h>
40 #include <asm/sigcontext.h>
42 #include <asm/switch_to.h>
44 #include <asm/asm-prototypes.h>
47 #include <asm/unistd.h>
49 #include <asm/ucontext.h>
56 #define old_sigaction old_sigaction32
57 #define sigcontext sigcontext32
58 #define mcontext mcontext32
59 #define ucontext ucontext32
61 #define __save_altstack __compat_save_altstack
64 * Userspace code may pass a ucontext which doesn't include VSX added
65 * at the end. We need to check for this case.
67 #define UCONTEXTSIZEWITHOUTVSX \
68 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32))
71 * Returning 0 means we return to userspace via
72 * ret_from_except and thus restore all user
73 * registers from *regs. This is what we need
74 * to do when a signal has been delivered.
77 #define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
78 #undef __SIGNAL_FRAMESIZE
79 #define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
81 #define ELF_NVRREG ELF_NVRREG32
84 * Functions for flipping sigsets (thanks to brain dead generic
85 * implementation that makes things simple for little endian only)
87 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
89 return put_compat_sigset(uset, set, sizeof(*uset));
92 static inline int get_sigset_t(sigset_t *set,
93 const compat_sigset_t __user *uset)
95 return get_compat_sigset(set, uset);
98 #define to_user_ptr(p) ptr_to_compat(p)
99 #define from_user_ptr(p) compat_ptr(p)
101 static inline int save_general_regs(struct pt_regs *regs,
102 struct mcontext __user *frame)
104 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
107 WARN_ON(!FULL_REGS(regs));
109 for (i = 0; i <= PT_RESULT; i ++) {
110 /* Force usr to alway see softe as 1 (interrupts enabled) */
116 if (__put_user(val, &frame->mc_gregs[i]))
122 static inline int restore_general_regs(struct pt_regs *regs,
123 struct mcontext __user *sr)
125 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
128 for (i = 0; i <= PT_RESULT; i++) {
129 if ((i == PT_MSR) || (i == PT_SOFTE))
131 if (__get_user(gregs[i], &sr->mc_gregs[i]))
137 #else /* CONFIG_PPC64 */
139 #define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
141 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
143 return copy_to_user(uset, set, sizeof(*uset));
146 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
148 return copy_from_user(set, uset, sizeof(*uset));
151 #define to_user_ptr(p) ((unsigned long)(p))
152 #define from_user_ptr(p) ((void __user *)(p))
154 static inline int save_general_regs(struct pt_regs *regs,
155 struct mcontext __user *frame)
157 WARN_ON(!FULL_REGS(regs));
158 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
161 static inline int restore_general_regs(struct pt_regs *regs,
162 struct mcontext __user *sr)
164 /* copy up to but not including MSR */
165 if (__copy_from_user(regs, &sr->mc_gregs,
166 PT_MSR * sizeof(elf_greg_t)))
168 /* copy from orig_r3 (the word after the MSR) up to the end */
169 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
170 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
177 * When we have signals to deliver, we set up on the
178 * user stack, going down from the original stack pointer:
179 * an ABI gap of 56 words
181 * a sigcontext struct
182 * a gap of __SIGNAL_FRAMESIZE bytes
184 * Each of these things must be a multiple of 16 bytes in size. The following
185 * structure represent all of this except the __SIGNAL_FRAMESIZE gap
189 struct sigcontext sctx; /* the sigcontext */
190 struct mcontext mctx; /* all the register values */
191 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
192 struct sigcontext sctx_transact;
193 struct mcontext mctx_transact;
196 * Programs using the rs6000/xcoff abi can save up to 19 gp
197 * regs and 18 fp regs below sp before decrementing it.
202 /* We use the mc_pad field for the signal return trampoline. */
206 * When we have rt signals to deliver, we set up on the
207 * user stack, going down from the original stack pointer:
208 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
209 * a gap of __SIGNAL_FRAMESIZE+16 bytes
210 * (the +16 is to get the siginfo and ucontext in the same
211 * positions as in older kernels).
213 * Each of these things must be a multiple of 16 bytes in size.
218 compat_siginfo_t info;
223 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
224 struct ucontext uc_transact;
227 * Programs using the rs6000/xcoff abi can save up to 19 gp
228 * regs and 18 fp regs below sp before decrementing it.
234 * Save the current user registers on the user stack.
235 * We only save the altivec/spe registers if the process has used
236 * altivec/spe instructions at some point.
238 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
239 struct mcontext __user *tm_frame, int sigret,
240 int ctx_has_vsx_region)
242 unsigned long msr = regs->msr;
244 /* Make sure floating point registers are stored in regs */
245 flush_fp_to_thread(current);
247 /* save general registers */
248 if (save_general_regs(regs, frame))
251 #ifdef CONFIG_ALTIVEC
252 /* save altivec registers */
253 if (current->thread.used_vr) {
254 flush_altivec_to_thread(current);
255 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state,
256 ELF_NVRREG * sizeof(vector128)))
258 /* set MSR_VEC in the saved MSR value to indicate that
259 frame->mc_vregs contains valid data */
262 /* else assert((regs->msr & MSR_VEC) == 0) */
264 /* We always copy to/from vrsave, it's 0 if we don't have or don't
265 * use altivec. Since VSCR only contains 32 bits saved in the least
266 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
267 * most significant bits of that same vector. --BenH
268 * Note that the current VRSAVE value is in the SPR at this point.
270 if (cpu_has_feature(CPU_FTR_ALTIVEC))
271 current->thread.vrsave = mfspr(SPRN_VRSAVE);
272 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
274 #endif /* CONFIG_ALTIVEC */
275 if (copy_fpr_to_user(&frame->mc_fregs, current))
279 * Clear the MSR VSX bit to indicate there is no valid state attached
280 * to this context, except in the specific case below where we set it.
285 * Copy VSR 0-31 upper half from thread_struct to local
286 * buffer, then write that to userspace. Also set MSR_VSX in
287 * the saved MSR value to indicate that frame->mc_vregs
288 * contains valid data
290 if (current->thread.used_vsr && ctx_has_vsx_region) {
291 flush_vsx_to_thread(current);
292 if (copy_vsx_to_user(&frame->mc_vsregs, current))
296 #endif /* CONFIG_VSX */
298 /* save spe registers */
299 if (current->thread.used_spe) {
300 flush_spe_to_thread(current);
301 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
302 ELF_NEVRREG * sizeof(u32)))
304 /* set MSR_SPE in the saved MSR value to indicate that
305 frame->mc_vregs contains valid data */
308 /* else assert((regs->msr & MSR_SPE) == 0) */
310 /* We always copy to/from spefscr */
311 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
313 #endif /* CONFIG_SPE */
315 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
317 /* We need to write 0 the MSR top 32 bits in the tm frame so that we
318 * can check it on the restore to see if TM is active
320 if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR]))
324 /* Set up the sigreturn trampoline: li 0,sigret; sc */
325 if (__put_user(PPC_INST_ADDI + sigret, &frame->tramp[0])
326 || __put_user(PPC_INST_SC, &frame->tramp[1]))
328 flush_icache_range((unsigned long) &frame->tramp[0],
329 (unsigned long) &frame->tramp[2]);
335 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
337 * Save the current user registers on the user stack.
338 * We only save the altivec/spe registers if the process has used
339 * altivec/spe instructions at some point.
340 * We also save the transactional registers to a second ucontext in the
343 * See save_user_regs() and signal_64.c:setup_tm_sigcontexts().
345 static int save_tm_user_regs(struct pt_regs *regs,
346 struct mcontext __user *frame,
347 struct mcontext __user *tm_frame, int sigret,
350 WARN_ON(tm_suspend_disabled);
352 /* Save both sets of general registers */
353 if (save_general_regs(¤t->thread.ckpt_regs, frame)
354 || save_general_regs(regs, tm_frame))
357 /* Stash the top half of the 64bit MSR into the 32bit MSR word
358 * of the transactional mcontext. This way we have a backward-compatible
359 * MSR in the 'normal' (checkpointed) mcontext and additionally one can
360 * also look at what type of transaction (T or S) was active at the
361 * time of the signal.
363 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
366 #ifdef CONFIG_ALTIVEC
367 /* save altivec registers */
368 if (current->thread.used_vr) {
369 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.ckvr_state,
370 ELF_NVRREG * sizeof(vector128)))
373 if (__copy_to_user(&tm_frame->mc_vregs,
374 ¤t->thread.vr_state,
375 ELF_NVRREG * sizeof(vector128)))
378 if (__copy_to_user(&tm_frame->mc_vregs,
379 ¤t->thread.ckvr_state,
380 ELF_NVRREG * sizeof(vector128)))
384 /* set MSR_VEC in the saved MSR value to indicate that
385 * frame->mc_vregs contains valid data
390 /* We always copy to/from vrsave, it's 0 if we don't have or don't
391 * use altivec. Since VSCR only contains 32 bits saved in the least
392 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
393 * most significant bits of that same vector. --BenH
395 if (cpu_has_feature(CPU_FTR_ALTIVEC))
396 current->thread.ckvrsave = mfspr(SPRN_VRSAVE);
397 if (__put_user(current->thread.ckvrsave,
398 (u32 __user *)&frame->mc_vregs[32]))
401 if (__put_user(current->thread.vrsave,
402 (u32 __user *)&tm_frame->mc_vregs[32]))
405 if (__put_user(current->thread.ckvrsave,
406 (u32 __user *)&tm_frame->mc_vregs[32]))
409 #endif /* CONFIG_ALTIVEC */
411 if (copy_ckfpr_to_user(&frame->mc_fregs, current))
414 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
417 if (copy_ckfpr_to_user(&tm_frame->mc_fregs, current))
423 * Copy VSR 0-31 upper half from thread_struct to local
424 * buffer, then write that to userspace. Also set MSR_VSX in
425 * the saved MSR value to indicate that frame->mc_vregs
426 * contains valid data
428 if (current->thread.used_vsr) {
429 if (copy_ckvsx_to_user(&frame->mc_vsregs, current))
432 if (copy_vsx_to_user(&tm_frame->mc_vsregs,
436 if (copy_ckvsx_to_user(&tm_frame->mc_vsregs, current))
442 #endif /* CONFIG_VSX */
444 /* SPE regs are not checkpointed with TM, so this section is
445 * simply the same as in save_user_regs().
447 if (current->thread.used_spe) {
448 flush_spe_to_thread(current);
449 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
450 ELF_NEVRREG * sizeof(u32)))
452 /* set MSR_SPE in the saved MSR value to indicate that
453 * frame->mc_vregs contains valid data */
457 /* We always copy to/from spefscr */
458 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
460 #endif /* CONFIG_SPE */
462 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
465 /* Set up the sigreturn trampoline: li 0,sigret; sc */
466 if (__put_user(PPC_INST_ADDI + sigret, &frame->tramp[0])
467 || __put_user(PPC_INST_SC, &frame->tramp[1]))
469 flush_icache_range((unsigned long) &frame->tramp[0],
470 (unsigned long) &frame->tramp[2]);
478 * Restore the current user register values from the user stack,
481 static long restore_user_regs(struct pt_regs *regs,
482 struct mcontext __user *sr, int sig)
485 unsigned int save_r2 = 0;
492 * restore general registers but not including MSR or SOFTE. Also
493 * take care of keeping r2 (TLS) intact if not a signal
496 save_r2 = (unsigned int)regs->gpr[2];
497 err = restore_general_regs(regs, sr);
498 set_trap_norestart(regs);
499 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
501 regs->gpr[2] = (unsigned long) save_r2;
505 /* if doing signal return, restore the previous little-endian mode */
507 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
509 #ifdef CONFIG_ALTIVEC
511 * Force the process to reload the altivec registers from
512 * current->thread when it next does altivec instructions
514 regs->msr &= ~MSR_VEC;
516 /* restore altivec registers from the stack */
517 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
518 sizeof(sr->mc_vregs)))
520 current->thread.used_vr = true;
521 } else if (current->thread.used_vr)
522 memset(¤t->thread.vr_state, 0,
523 ELF_NVRREG * sizeof(vector128));
525 /* Always get VRSAVE back */
526 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
528 if (cpu_has_feature(CPU_FTR_ALTIVEC))
529 mtspr(SPRN_VRSAVE, current->thread.vrsave);
530 #endif /* CONFIG_ALTIVEC */
531 if (copy_fpr_from_user(current, &sr->mc_fregs))
536 * Force the process to reload the VSX registers from
537 * current->thread when it next does VSX instruction.
539 regs->msr &= ~MSR_VSX;
542 * Restore altivec registers from the stack to a local
543 * buffer, then write this out to the thread_struct
545 if (copy_vsx_from_user(current, &sr->mc_vsregs))
547 current->thread.used_vsr = true;
548 } else if (current->thread.used_vsr)
549 for (i = 0; i < 32 ; i++)
550 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
551 #endif /* CONFIG_VSX */
553 * force the process to reload the FP registers from
554 * current->thread when it next does FP instructions
556 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
559 /* force the process to reload the spe registers from
560 current->thread when it next does spe instructions */
561 regs->msr &= ~MSR_SPE;
563 /* restore spe registers from the stack */
564 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
565 ELF_NEVRREG * sizeof(u32)))
567 current->thread.used_spe = true;
568 } else if (current->thread.used_spe)
569 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
571 /* Always get SPEFSCR back */
572 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
574 #endif /* CONFIG_SPE */
579 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
581 * Restore the current user register values from the user stack, except for
582 * MSR, and recheckpoint the original checkpointed register state for processes
585 static long restore_tm_user_regs(struct pt_regs *regs,
586 struct mcontext __user *sr,
587 struct mcontext __user *tm_sr)
590 unsigned long msr, msr_hi;
595 if (tm_suspend_disabled)
598 * restore general registers but not including MSR or SOFTE. Also
599 * take care of keeping r2 (TLS) intact if not a signal.
600 * See comment in signal_64.c:restore_tm_sigcontexts();
601 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
602 * were set by the signal delivery.
604 err = restore_general_regs(regs, tm_sr);
605 err |= restore_general_regs(¤t->thread.ckpt_regs, sr);
607 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
609 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
613 /* Restore the previous little-endian mode */
614 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
616 #ifdef CONFIG_ALTIVEC
617 regs->msr &= ~MSR_VEC;
619 /* restore altivec registers from the stack */
620 if (__copy_from_user(¤t->thread.ckvr_state, &sr->mc_vregs,
621 sizeof(sr->mc_vregs)) ||
622 __copy_from_user(¤t->thread.vr_state,
624 sizeof(sr->mc_vregs)))
626 current->thread.used_vr = true;
627 } else if (current->thread.used_vr) {
628 memset(¤t->thread.vr_state, 0,
629 ELF_NVRREG * sizeof(vector128));
630 memset(¤t->thread.ckvr_state, 0,
631 ELF_NVRREG * sizeof(vector128));
634 /* Always get VRSAVE back */
635 if (__get_user(current->thread.ckvrsave,
636 (u32 __user *)&sr->mc_vregs[32]) ||
637 __get_user(current->thread.vrsave,
638 (u32 __user *)&tm_sr->mc_vregs[32]))
640 if (cpu_has_feature(CPU_FTR_ALTIVEC))
641 mtspr(SPRN_VRSAVE, current->thread.ckvrsave);
642 #endif /* CONFIG_ALTIVEC */
644 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
646 if (copy_fpr_from_user(current, &sr->mc_fregs) ||
647 copy_ckfpr_from_user(current, &tm_sr->mc_fregs))
651 regs->msr &= ~MSR_VSX;
654 * Restore altivec registers from the stack to a local
655 * buffer, then write this out to the thread_struct
657 if (copy_vsx_from_user(current, &tm_sr->mc_vsregs) ||
658 copy_ckvsx_from_user(current, &sr->mc_vsregs))
660 current->thread.used_vsr = true;
661 } else if (current->thread.used_vsr)
662 for (i = 0; i < 32 ; i++) {
663 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
664 current->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
666 #endif /* CONFIG_VSX */
669 /* SPE regs are not checkpointed with TM, so this section is
670 * simply the same as in restore_user_regs().
672 regs->msr &= ~MSR_SPE;
674 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
675 ELF_NEVRREG * sizeof(u32)))
677 current->thread.used_spe = true;
678 } else if (current->thread.used_spe)
679 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
681 /* Always get SPEFSCR back */
682 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
685 #endif /* CONFIG_SPE */
687 /* Get the top half of the MSR from the user context */
688 if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR]))
691 /* If TM bits are set to the reserved value, it's an invalid context */
692 if (MSR_TM_RESV(msr_hi))
696 * Disabling preemption, since it is unsafe to be preempted
697 * with MSR[TS] set without recheckpointing.
703 * After regs->MSR[TS] being updated, make sure that get_user(),
704 * put_user() or similar functions are *not* called. These
705 * functions can generate page faults which will cause the process
706 * to be de-scheduled with MSR[TS] set but without calling
707 * tm_recheckpoint(). This can cause a bug.
709 * Pull in the MSR TM bits from the user context
711 regs->msr = (regs->msr & ~MSR_TS_MASK) | (msr_hi & MSR_TS_MASK);
712 /* Now, recheckpoint. This loads up all of the checkpointed (older)
713 * registers, including FP and V[S]Rs. After recheckpointing, the
714 * transactional versions should be loaded.
717 /* Make sure the transaction is marked as failed */
718 current->thread.tm_texasr |= TEXASR_FS;
719 /* This loads the checkpointed FP/VEC state, if used */
720 tm_recheckpoint(¤t->thread);
722 /* This loads the speculative FP/VEC state, if used */
723 msr_check_and_set(msr & (MSR_FP | MSR_VEC));
725 load_fp_state(¤t->thread.fp_state);
726 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
728 #ifdef CONFIG_ALTIVEC
730 load_vr_state(¤t->thread.vr_state);
731 regs->msr |= MSR_VEC;
743 #define copy_siginfo_to_user copy_siginfo_to_user32
745 #endif /* CONFIG_PPC64 */
748 * Set up a signal frame for a "real-time" signal handler
749 * (one which gets siginfo).
751 int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
752 struct task_struct *tsk)
754 struct rt_sigframe __user *rt_sf;
755 struct mcontext __user *frame;
756 struct mcontext __user *tm_frame = NULL;
758 unsigned long newsp = 0;
761 struct pt_regs *regs = tsk->thread.regs;
762 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
763 /* Save the thread's msr before get_tm_stackpointer() changes it */
764 unsigned long msr = regs->msr;
767 BUG_ON(tsk != current);
769 /* Set up Signal Frame */
770 /* Put a Real Time Context onto stack */
771 rt_sf = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*rt_sf), 1);
773 if (unlikely(rt_sf == NULL))
776 /* Put the siginfo & fill in most of the ucontext */
777 if (copy_siginfo_to_user(&rt_sf->info, &ksig->info)
778 || __put_user(0, &rt_sf->uc.uc_flags)
779 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
780 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
782 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
785 /* Save user registers on the stack */
786 frame = &rt_sf->uc.uc_mcontext;
788 if (vdso32_rt_sigtramp && tsk->mm->context.vdso_base) {
790 tramp = tsk->mm->context.vdso_base + vdso32_rt_sigtramp;
792 sigret = __NR_rt_sigreturn;
793 tramp = (unsigned long) frame->tramp;
796 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
797 tm_frame = &rt_sf->uc_transact.uc_mcontext;
798 if (MSR_TM_ACTIVE(msr)) {
799 if (__put_user((unsigned long)&rt_sf->uc_transact,
800 &rt_sf->uc.uc_link) ||
801 __put_user((unsigned long)tm_frame,
802 &rt_sf->uc_transact.uc_regs))
804 if (save_tm_user_regs(regs, frame, tm_frame, sigret, msr))
810 if (__put_user(0, &rt_sf->uc.uc_link))
812 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
817 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
819 /* create a stack frame for the caller of the handler */
820 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
821 addr = (void __user *)regs->gpr[1];
822 if (put_user(regs->gpr[1], (u32 __user *)newsp))
825 /* Fill registers for signal handler */
826 regs->gpr[1] = newsp;
827 regs->gpr[3] = ksig->sig;
828 regs->gpr[4] = (unsigned long) &rt_sf->info;
829 regs->gpr[5] = (unsigned long) &rt_sf->uc;
830 regs->gpr[6] = (unsigned long) rt_sf;
831 regs->nip = (unsigned long) ksig->ka.sa.sa_handler;
832 /* enter the signal handler in native-endian mode */
833 regs->msr &= ~MSR_LE;
834 regs->msr |= (MSR_KERNEL & MSR_LE);
838 if (show_unhandled_signals)
839 printk_ratelimited(KERN_INFO
840 "%s[%d]: bad frame in handle_rt_signal32: "
841 "%p nip %08lx lr %08lx\n",
843 addr, regs->nip, regs->link);
848 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
851 struct mcontext __user *mcp;
853 if (get_sigset_t(&set, &ucp->uc_sigmask))
859 if (__get_user(cmcp, &ucp->uc_regs))
861 mcp = (struct mcontext __user *)(u64)cmcp;
862 /* no need to check access_ok(mcp), since mcp < 4GB */
865 if (__get_user(mcp, &ucp->uc_regs))
867 if (!access_ok(mcp, sizeof(*mcp)))
870 set_current_blocked(&set);
871 if (restore_user_regs(regs, mcp, sig))
877 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
878 static int do_setcontext_tm(struct ucontext __user *ucp,
879 struct ucontext __user *tm_ucp,
880 struct pt_regs *regs)
883 struct mcontext __user *mcp;
884 struct mcontext __user *tm_mcp;
888 if (get_sigset_t(&set, &ucp->uc_sigmask))
891 if (__get_user(cmcp, &ucp->uc_regs) ||
892 __get_user(tm_cmcp, &tm_ucp->uc_regs))
894 mcp = (struct mcontext __user *)(u64)cmcp;
895 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
896 /* no need to check access_ok(mcp), since mcp < 4GB */
898 set_current_blocked(&set);
899 if (restore_tm_user_regs(regs, mcp, tm_mcp))
907 COMPAT_SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
908 struct ucontext __user *, new_ctx, int, ctx_size)
910 SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
911 struct ucontext __user *, new_ctx, long, ctx_size)
914 struct pt_regs *regs = current_pt_regs();
915 int ctx_has_vsx_region = 0;
918 unsigned long new_msr = 0;
921 struct mcontext __user *mcp;
925 * Get pointer to the real mcontext. No need for
926 * access_ok since we are dealing with compat
929 if (__get_user(cmcp, &new_ctx->uc_regs))
931 mcp = (struct mcontext __user *)(u64)cmcp;
932 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
936 * Check that the context is not smaller than the original
937 * size (with VMX but without VSX)
939 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
942 * If the new context state sets the MSR VSX bits but
943 * it doesn't provide VSX state.
945 if ((ctx_size < sizeof(struct ucontext)) &&
948 /* Does the context have enough room to store VSX data? */
949 if (ctx_size >= sizeof(struct ucontext))
950 ctx_has_vsx_region = 1;
952 /* Context size is for future use. Right now, we only make sure
953 * we are passed something we understand
955 if (ctx_size < sizeof(struct ucontext))
958 if (old_ctx != NULL) {
959 struct mcontext __user *mctx;
962 * old_ctx might not be 16-byte aligned, in which
963 * case old_ctx->uc_mcontext won't be either.
964 * Because we have the old_ctx->uc_pad2 field
965 * before old_ctx->uc_mcontext, we need to round down
966 * from &old_ctx->uc_mcontext to a 16-byte boundary.
968 mctx = (struct mcontext __user *)
969 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
970 if (!access_ok(old_ctx, ctx_size)
971 || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
972 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
973 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
978 if (!access_ok(new_ctx, ctx_size) ||
979 fault_in_pages_readable((u8 __user *)new_ctx, ctx_size))
983 * If we get a fault copying the context into the kernel's
984 * image of the user's registers, we can't just return -EFAULT
985 * because the user's registers will be corrupted. For instance
986 * the NIP value may have been updated but not some of the
987 * other registers. Given that we have done the access_ok
988 * and successfully read the first and last bytes of the region
989 * above, this should only happen in an out-of-memory situation
990 * or if another thread unmaps the region containing the context.
991 * We kill the task with a SIGSEGV in this situation.
993 if (do_setcontext(new_ctx, regs, 0))
996 set_thread_flag(TIF_RESTOREALL);
1001 COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
1003 SYSCALL_DEFINE0(rt_sigreturn)
1006 struct rt_sigframe __user *rt_sf;
1007 struct pt_regs *regs = current_pt_regs();
1009 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1010 struct ucontext __user *uc_transact;
1011 unsigned long msr_hi;
1014 /* Always make any pending restarted system calls return -EINTR */
1015 current->restart_block.fn = do_no_restart_syscall;
1017 rt_sf = (struct rt_sigframe __user *)
1018 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1019 if (!access_ok(rt_sf, sizeof(*rt_sf)))
1022 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1024 * If there is a transactional state then throw it away.
1025 * The purpose of a sigreturn is to destroy all traces of the
1026 * signal frame, this includes any transactional state created
1027 * within in. We only check for suspended as we can never be
1028 * active in the kernel, we are active, there is nothing better to
1029 * do than go ahead and Bad Thing later.
1030 * The cause is not important as there will never be a
1031 * recheckpoint so it's not user visible.
1033 if (MSR_TM_SUSPENDED(mfmsr()))
1034 tm_reclaim_current(0);
1036 if (__get_user(tmp, &rt_sf->uc.uc_link))
1038 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1041 struct mcontext __user *mcp;
1043 if (__get_user(cmcp, &uc_transact->uc_regs))
1045 mcp = (struct mcontext __user *)(u64)cmcp;
1046 /* The top 32 bits of the MSR are stashed in the transactional
1048 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1051 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1052 /* Trying to start TM on non TM system */
1053 if (!cpu_has_feature(CPU_FTR_TM))
1055 /* We only recheckpoint on return if we're
1059 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1065 * Unset regs->msr because ucontext MSR TS is not
1066 * set, and recheckpoint was not called. This avoid
1067 * hitting a TM Bad thing at RFID
1069 regs->msr &= ~MSR_TS_MASK;
1071 /* Fall through, for non-TM restore */
1074 if (do_setcontext(&rt_sf->uc, regs, 1))
1078 * It's not clear whether or why it is desirable to save the
1079 * sigaltstack setting on signal delivery and restore it on
1080 * signal return. But other architectures do this and we have
1081 * always done it up until now so it is probably better not to
1082 * change it. -- paulus
1085 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1088 if (restore_altstack(&rt_sf->uc.uc_stack))
1091 set_thread_flag(TIF_RESTOREALL);
1095 if (show_unhandled_signals)
1096 printk_ratelimited(KERN_INFO
1097 "%s[%d]: bad frame in sys_rt_sigreturn: "
1098 "%p nip %08lx lr %08lx\n",
1099 current->comm, current->pid,
1100 rt_sf, regs->nip, regs->link);
1107 SYSCALL_DEFINE3(debug_setcontext, struct ucontext __user *, ctx,
1108 int, ndbg, struct sig_dbg_op __user *, dbg)
1110 struct pt_regs *regs = current_pt_regs();
1111 struct sig_dbg_op op;
1113 unsigned long new_msr = regs->msr;
1114 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1115 unsigned long new_dbcr0 = current->thread.debug.dbcr0;
1118 for (i=0; i<ndbg; i++) {
1119 if (copy_from_user(&op, dbg + i, sizeof(op)))
1121 switch (op.dbg_type) {
1122 case SIG_DBG_SINGLE_STEPPING:
1123 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1126 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1128 new_dbcr0 &= ~DBCR0_IC;
1129 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1130 current->thread.debug.dbcr1)) {
1132 new_dbcr0 &= ~DBCR0_IDM;
1142 case SIG_DBG_BRANCH_TRACING:
1143 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1158 /* We wait until here to actually install the values in the
1159 registers so if we fail in the above loop, it will not
1160 affect the contents of these registers. After this point,
1161 failure is a problem, anyway, and it's very unlikely unless
1162 the user is really doing something wrong. */
1163 regs->msr = new_msr;
1164 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1165 current->thread.debug.dbcr0 = new_dbcr0;
1168 if (!access_ok(ctx, sizeof(*ctx)) ||
1169 fault_in_pages_readable((u8 __user *)ctx, sizeof(*ctx)))
1173 * If we get a fault copying the context into the kernel's
1174 * image of the user's registers, we can't just return -EFAULT
1175 * because the user's registers will be corrupted. For instance
1176 * the NIP value may have been updated but not some of the
1177 * other registers. Given that we have done the access_ok
1178 * and successfully read the first and last bytes of the region
1179 * above, this should only happen in an out-of-memory situation
1180 * or if another thread unmaps the region containing the context.
1181 * We kill the task with a SIGSEGV in this situation.
1183 if (do_setcontext(ctx, regs, 1)) {
1184 if (show_unhandled_signals)
1185 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1186 "sys_debug_setcontext: %p nip %08lx "
1188 current->comm, current->pid,
1189 ctx, regs->nip, regs->link);
1196 * It's not clear whether or why it is desirable to save the
1197 * sigaltstack setting on signal delivery and restore it on
1198 * signal return. But other architectures do this and we have
1199 * always done it up until now so it is probably better not to
1200 * change it. -- paulus
1202 restore_altstack(&ctx->uc_stack);
1204 set_thread_flag(TIF_RESTOREALL);
1211 * OK, we're invoking a handler
1213 int handle_signal32(struct ksignal *ksig, sigset_t *oldset,
1214 struct task_struct *tsk)
1216 struct sigcontext __user *sc;
1217 struct sigframe __user *frame;
1218 struct mcontext __user *tm_mctx = NULL;
1219 unsigned long newsp = 0;
1221 unsigned long tramp;
1222 struct pt_regs *regs = tsk->thread.regs;
1223 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1224 /* Save the thread's msr before get_tm_stackpointer() changes it */
1225 unsigned long msr = regs->msr;
1228 BUG_ON(tsk != current);
1230 /* Set up Signal Frame */
1231 frame = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*frame), 1);
1232 if (unlikely(frame == NULL))
1234 sc = (struct sigcontext __user *) &frame->sctx;
1237 #error "Please adjust handle_signal()"
1239 if (__put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler)
1240 || __put_user(oldset->sig[0], &sc->oldmask)
1242 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1244 || __put_user(oldset->sig[1], &sc->_unused[3])
1246 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1247 || __put_user(ksig->sig, &sc->signal))
1250 if (vdso32_sigtramp && tsk->mm->context.vdso_base) {
1252 tramp = tsk->mm->context.vdso_base + vdso32_sigtramp;
1254 sigret = __NR_sigreturn;
1255 tramp = (unsigned long) frame->mctx.tramp;
1258 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1259 tm_mctx = &frame->mctx_transact;
1260 if (MSR_TM_ACTIVE(msr)) {
1261 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1268 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1274 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1276 /* create a stack frame for the caller of the handler */
1277 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1278 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1281 regs->gpr[1] = newsp;
1282 regs->gpr[3] = ksig->sig;
1283 regs->gpr[4] = (unsigned long) sc;
1284 regs->nip = (unsigned long) (unsigned long)ksig->ka.sa.sa_handler;
1285 /* enter the signal handler in big-endian mode */
1286 regs->msr &= ~MSR_LE;
1290 if (show_unhandled_signals)
1291 printk_ratelimited(KERN_INFO
1292 "%s[%d]: bad frame in handle_signal32: "
1293 "%p nip %08lx lr %08lx\n",
1294 tsk->comm, tsk->pid,
1295 frame, regs->nip, regs->link);
1301 * Do a signal return; undo the signal stack.
1304 COMPAT_SYSCALL_DEFINE0(sigreturn)
1306 SYSCALL_DEFINE0(sigreturn)
1309 struct pt_regs *regs = current_pt_regs();
1310 struct sigframe __user *sf;
1311 struct sigcontext __user *sc;
1312 struct sigcontext sigctx;
1313 struct mcontext __user *sr;
1316 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1317 struct mcontext __user *mcp, *tm_mcp;
1318 unsigned long msr_hi;
1321 /* Always make any pending restarted system calls return -EINTR */
1322 current->restart_block.fn = do_no_restart_syscall;
1324 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1327 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1332 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1333 * unused part of the signal stackframe
1335 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1337 set.sig[0] = sigctx.oldmask;
1338 set.sig[1] = sigctx._unused[3];
1340 set_current_blocked(&set);
1342 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1343 mcp = (struct mcontext __user *)&sf->mctx;
1344 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1345 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1347 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1348 if (!cpu_has_feature(CPU_FTR_TM))
1350 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1355 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1357 if (!access_ok(sr, sizeof(*sr))
1358 || restore_user_regs(regs, sr, 1))
1362 set_thread_flag(TIF_RESTOREALL);
1366 if (show_unhandled_signals)
1367 printk_ratelimited(KERN_INFO
1368 "%s[%d]: bad frame in sys_sigreturn: "
1369 "%p nip %08lx lr %08lx\n",
1370 current->comm, current->pid,
1371 addr, regs->nip, regs->link);