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
62 * Userspace code may pass a ucontext which doesn't include VSX added
63 * at the end. We need to check for this case.
65 #define UCONTEXTSIZEWITHOUTVSX \
66 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32))
69 * Returning 0 means we return to userspace via
70 * ret_from_except and thus restore all user
71 * registers from *regs. This is what we need
72 * to do when a signal has been delivered.
75 #define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
76 #undef __SIGNAL_FRAMESIZE
77 #define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
79 #define ELF_NVRREG ELF_NVRREG32
82 * Functions for flipping sigsets (thanks to brain dead generic
83 * implementation that makes things simple for little endian only)
85 #define unsafe_put_sigset_t unsafe_put_compat_sigset
86 #define unsafe_get_sigset_t unsafe_get_compat_sigset
88 #define to_user_ptr(p) ptr_to_compat(p)
89 #define from_user_ptr(p) compat_ptr(p)
91 static __always_inline int
92 __unsafe_save_general_regs(struct pt_regs *regs, struct mcontext __user *frame)
94 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
97 for (i = 0; i <= PT_RESULT; i ++) {
98 /* Force usr to alway see softe as 1 (interrupts enabled) */
104 unsafe_put_user(val, &frame->mc_gregs[i], failed);
112 static __always_inline int
113 __unsafe_restore_general_regs(struct pt_regs *regs, struct mcontext __user *sr)
115 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
118 for (i = 0; i <= PT_RESULT; i++) {
119 if ((i == PT_MSR) || (i == PT_SOFTE))
121 unsafe_get_user(gregs[i], &sr->mc_gregs[i], failed);
129 #else /* CONFIG_PPC64 */
131 #define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
133 #define unsafe_put_sigset_t(uset, set, label) do { \
134 sigset_t __user *__us = uset ; \
135 const sigset_t *__s = set; \
137 unsafe_copy_to_user(__us, __s, sizeof(*__us), label); \
140 #define unsafe_get_sigset_t unsafe_get_user_sigset
142 #define to_user_ptr(p) ((unsigned long)(p))
143 #define from_user_ptr(p) ((void __user *)(p))
145 static __always_inline int
146 __unsafe_save_general_regs(struct pt_regs *regs, struct mcontext __user *frame)
148 unsafe_copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE, failed);
155 static __always_inline
156 int __unsafe_restore_general_regs(struct pt_regs *regs, struct mcontext __user *sr)
158 /* copy up to but not including MSR */
159 unsafe_copy_from_user(regs, &sr->mc_gregs, PT_MSR * sizeof(elf_greg_t), failed);
161 /* copy from orig_r3 (the word after the MSR) up to the end */
162 unsafe_copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
163 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t), failed);
172 #define unsafe_save_general_regs(regs, frame, label) do { \
173 if (__unsafe_save_general_regs(regs, frame)) \
177 #define unsafe_restore_general_regs(regs, frame, label) do { \
178 if (__unsafe_restore_general_regs(regs, frame)) \
183 * When we have signals to deliver, we set up on the
184 * user stack, going down from the original stack pointer:
185 * an ABI gap of 56 words
187 * a sigcontext struct
188 * a gap of __SIGNAL_FRAMESIZE bytes
190 * Each of these things must be a multiple of 16 bytes in size. The following
191 * structure represent all of this except the __SIGNAL_FRAMESIZE gap
195 struct sigcontext sctx; /* the sigcontext */
196 struct mcontext mctx; /* all the register values */
197 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
198 struct sigcontext sctx_transact;
199 struct mcontext mctx_transact;
202 * Programs using the rs6000/xcoff abi can save up to 19 gp
203 * regs and 18 fp regs below sp before decrementing it.
209 * When we have rt signals to deliver, we set up on the
210 * user stack, going down from the original stack pointer:
211 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
212 * a gap of __SIGNAL_FRAMESIZE+16 bytes
213 * (the +16 is to get the siginfo and ucontext in the same
214 * positions as in older kernels).
216 * Each of these things must be a multiple of 16 bytes in size.
221 compat_siginfo_t info;
226 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
227 struct ucontext uc_transact;
230 * Programs using the rs6000/xcoff abi can save up to 19 gp
231 * regs and 18 fp regs below sp before decrementing it.
237 * Save the current user registers on the user stack.
238 * We only save the altivec/spe registers if the process has used
239 * altivec/spe instructions at some point.
241 static void prepare_save_user_regs(int ctx_has_vsx_region)
243 /* Make sure floating point registers are stored in regs */
244 flush_fp_to_thread(current);
245 #ifdef CONFIG_ALTIVEC
246 if (current->thread.used_vr)
247 flush_altivec_to_thread(current);
248 if (cpu_has_feature(CPU_FTR_ALTIVEC))
249 current->thread.vrsave = mfspr(SPRN_VRSAVE);
252 if (current->thread.used_vsr && ctx_has_vsx_region)
253 flush_vsx_to_thread(current);
256 if (current->thread.used_spe)
257 flush_spe_to_thread(current);
261 static int __unsafe_save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
262 struct mcontext __user *tm_frame, int ctx_has_vsx_region)
264 unsigned long msr = regs->msr;
266 /* save general registers */
267 unsafe_save_general_regs(regs, frame, failed);
269 #ifdef CONFIG_ALTIVEC
270 /* save altivec registers */
271 if (current->thread.used_vr) {
272 unsafe_copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state,
273 ELF_NVRREG * sizeof(vector128), failed);
274 /* set MSR_VEC in the saved MSR value to indicate that
275 frame->mc_vregs contains valid data */
278 /* else assert((regs->msr & MSR_VEC) == 0) */
280 /* We always copy to/from vrsave, it's 0 if we don't have or don't
281 * use altivec. Since VSCR only contains 32 bits saved in the least
282 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
283 * most significant bits of that same vector. --BenH
284 * Note that the current VRSAVE value is in the SPR at this point.
286 unsafe_put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32],
288 #endif /* CONFIG_ALTIVEC */
289 unsafe_copy_fpr_to_user(&frame->mc_fregs, current, failed);
292 * Clear the MSR VSX bit to indicate there is no valid state attached
293 * to this context, except in the specific case below where we set it.
298 * Copy VSR 0-31 upper half from thread_struct to local
299 * buffer, then write that to userspace. Also set MSR_VSX in
300 * the saved MSR value to indicate that frame->mc_vregs
301 * contains valid data
303 if (current->thread.used_vsr && ctx_has_vsx_region) {
304 unsafe_copy_vsx_to_user(&frame->mc_vsregs, current, failed);
307 #endif /* CONFIG_VSX */
309 /* save spe registers */
310 if (current->thread.used_spe) {
311 unsafe_copy_to_user(&frame->mc_vregs, current->thread.evr,
312 ELF_NEVRREG * sizeof(u32), failed);
313 /* set MSR_SPE in the saved MSR value to indicate that
314 frame->mc_vregs contains valid data */
317 /* else assert((regs->msr & MSR_SPE) == 0) */
319 /* We always copy to/from spefscr */
320 unsafe_put_user(current->thread.spefscr,
321 (u32 __user *)&frame->mc_vregs + ELF_NEVRREG, failed);
322 #endif /* CONFIG_SPE */
324 unsafe_put_user(msr, &frame->mc_gregs[PT_MSR], failed);
326 /* We need to write 0 the MSR top 32 bits in the tm frame so that we
327 * can check it on the restore to see if TM is active
330 unsafe_put_user(0, &tm_frame->mc_gregs[PT_MSR], failed);
338 #define unsafe_save_user_regs(regs, frame, tm_frame, has_vsx, label) do { \
339 if (__unsafe_save_user_regs(regs, frame, tm_frame, has_vsx)) \
343 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
345 * Save the current user registers on the user stack.
346 * We only save the altivec/spe registers if the process has used
347 * altivec/spe instructions at some point.
348 * We also save the transactional registers to a second ucontext in the
351 * See __unsafe_save_user_regs() and signal_64.c:setup_tm_sigcontexts().
353 static void prepare_save_tm_user_regs(void)
355 WARN_ON(tm_suspend_disabled);
357 if (cpu_has_feature(CPU_FTR_ALTIVEC))
358 current->thread.ckvrsave = mfspr(SPRN_VRSAVE);
361 static int save_tm_user_regs_unsafe(struct pt_regs *regs, struct mcontext __user *frame,
362 struct mcontext __user *tm_frame, unsigned long msr)
364 /* Save both sets of general registers */
365 unsafe_save_general_regs(¤t->thread.ckpt_regs, frame, failed);
366 unsafe_save_general_regs(regs, tm_frame, failed);
368 /* Stash the top half of the 64bit MSR into the 32bit MSR word
369 * of the transactional mcontext. This way we have a backward-compatible
370 * MSR in the 'normal' (checkpointed) mcontext and additionally one can
371 * also look at what type of transaction (T or S) was active at the
372 * time of the signal.
374 unsafe_put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR], failed);
376 /* save altivec registers */
377 if (current->thread.used_vr) {
378 unsafe_copy_to_user(&frame->mc_vregs, ¤t->thread.ckvr_state,
379 ELF_NVRREG * sizeof(vector128), failed);
381 unsafe_copy_to_user(&tm_frame->mc_vregs,
382 ¤t->thread.vr_state,
383 ELF_NVRREG * sizeof(vector128), failed);
385 unsafe_copy_to_user(&tm_frame->mc_vregs,
386 ¤t->thread.ckvr_state,
387 ELF_NVRREG * sizeof(vector128), failed);
389 /* set MSR_VEC in the saved MSR value to indicate that
390 * frame->mc_vregs contains valid data
395 /* We always copy to/from vrsave, it's 0 if we don't have or don't
396 * use altivec. Since VSCR only contains 32 bits saved in the least
397 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
398 * most significant bits of that same vector. --BenH
400 unsafe_put_user(current->thread.ckvrsave,
401 (u32 __user *)&frame->mc_vregs[32], failed);
403 unsafe_put_user(current->thread.vrsave,
404 (u32 __user *)&tm_frame->mc_vregs[32], failed);
406 unsafe_put_user(current->thread.ckvrsave,
407 (u32 __user *)&tm_frame->mc_vregs[32], failed);
409 unsafe_copy_ckfpr_to_user(&frame->mc_fregs, current, failed);
411 unsafe_copy_fpr_to_user(&tm_frame->mc_fregs, current, failed);
413 unsafe_copy_ckfpr_to_user(&tm_frame->mc_fregs, current, failed);
416 * Copy VSR 0-31 upper half from thread_struct to local
417 * buffer, then write that to userspace. Also set MSR_VSX in
418 * the saved MSR value to indicate that frame->mc_vregs
419 * contains valid data
421 if (current->thread.used_vsr) {
422 unsafe_copy_ckvsx_to_user(&frame->mc_vsregs, current, failed);
424 unsafe_copy_vsx_to_user(&tm_frame->mc_vsregs, current, failed);
426 unsafe_copy_ckvsx_to_user(&tm_frame->mc_vsregs, current, failed);
431 unsafe_put_user(msr, &frame->mc_gregs[PT_MSR], failed);
439 static void prepare_save_tm_user_regs(void) { }
441 static int save_tm_user_regs_unsafe(struct pt_regs *regs, struct mcontext __user *frame,
442 struct mcontext __user *tm_frame, unsigned long msr)
448 #define unsafe_save_tm_user_regs(regs, frame, tm_frame, msr, label) do { \
449 if (save_tm_user_regs_unsafe(regs, frame, tm_frame, msr)) \
454 * Restore the current user register values from the user stack,
457 static long restore_user_regs(struct pt_regs *regs,
458 struct mcontext __user *sr, int sig)
460 unsigned int save_r2 = 0;
466 if (!user_read_access_begin(sr, sizeof(*sr)))
469 * restore general registers but not including MSR or SOFTE. Also
470 * take care of keeping r2 (TLS) intact if not a signal
473 save_r2 = (unsigned int)regs->gpr[2];
474 unsafe_restore_general_regs(regs, sr, failed);
475 set_trap_norestart(regs);
476 unsafe_get_user(msr, &sr->mc_gregs[PT_MSR], failed);
478 regs->gpr[2] = (unsigned long) save_r2;
480 /* if doing signal return, restore the previous little-endian mode */
482 regs_set_return_msr(regs, (regs->msr & ~MSR_LE) | (msr & MSR_LE));
484 #ifdef CONFIG_ALTIVEC
486 * Force the process to reload the altivec registers from
487 * current->thread when it next does altivec instructions
489 regs_set_return_msr(regs, regs->msr & ~MSR_VEC);
491 /* restore altivec registers from the stack */
492 unsafe_copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
493 sizeof(sr->mc_vregs), failed);
494 current->thread.used_vr = true;
495 } else if (current->thread.used_vr)
496 memset(¤t->thread.vr_state, 0,
497 ELF_NVRREG * sizeof(vector128));
499 /* Always get VRSAVE back */
500 unsafe_get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32], failed);
501 if (cpu_has_feature(CPU_FTR_ALTIVEC))
502 mtspr(SPRN_VRSAVE, current->thread.vrsave);
503 #endif /* CONFIG_ALTIVEC */
504 unsafe_copy_fpr_from_user(current, &sr->mc_fregs, failed);
508 * Force the process to reload the VSX registers from
509 * current->thread when it next does VSX instruction.
511 regs_set_return_msr(regs, regs->msr & ~MSR_VSX);
514 * Restore altivec registers from the stack to a local
515 * buffer, then write this out to the thread_struct
517 unsafe_copy_vsx_from_user(current, &sr->mc_vsregs, failed);
518 current->thread.used_vsr = true;
519 } else if (current->thread.used_vsr)
520 for (i = 0; i < 32 ; i++)
521 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
522 #endif /* CONFIG_VSX */
524 * force the process to reload the FP registers from
525 * current->thread when it next does FP instructions
527 regs_set_return_msr(regs, regs->msr & ~(MSR_FP | MSR_FE0 | MSR_FE1));
530 /* force the process to reload the spe registers from
531 current->thread when it next does spe instructions */
532 regs_set_return_msr(regs, regs->msr & ~MSR_SPE);
534 /* restore spe registers from the stack */
535 unsafe_copy_from_user(current->thread.evr, &sr->mc_vregs,
536 ELF_NEVRREG * sizeof(u32), failed);
537 current->thread.used_spe = true;
538 } else if (current->thread.used_spe)
539 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
541 /* Always get SPEFSCR back */
542 unsafe_get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG, failed);
543 #endif /* CONFIG_SPE */
545 user_read_access_end();
549 user_read_access_end();
553 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
555 * Restore the current user register values from the user stack, except for
556 * MSR, and recheckpoint the original checkpointed register state for processes
559 static long restore_tm_user_regs(struct pt_regs *regs,
560 struct mcontext __user *sr,
561 struct mcontext __user *tm_sr)
563 unsigned long msr, msr_hi;
566 if (tm_suspend_disabled)
569 * restore general registers but not including MSR or SOFTE. Also
570 * take care of keeping r2 (TLS) intact if not a signal.
571 * See comment in signal_64.c:restore_tm_sigcontexts();
572 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
573 * were set by the signal delivery.
575 if (!user_read_access_begin(sr, sizeof(*sr)))
578 unsafe_restore_general_regs(¤t->thread.ckpt_regs, sr, failed);
579 unsafe_get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP], failed);
580 unsafe_get_user(msr, &sr->mc_gregs[PT_MSR], failed);
582 /* Restore the previous little-endian mode */
583 regs_set_return_msr(regs, (regs->msr & ~MSR_LE) | (msr & MSR_LE));
585 regs_set_return_msr(regs, regs->msr & ~MSR_VEC);
587 /* restore altivec registers from the stack */
588 unsafe_copy_from_user(¤t->thread.ckvr_state, &sr->mc_vregs,
589 sizeof(sr->mc_vregs), failed);
590 current->thread.used_vr = true;
591 } else if (current->thread.used_vr) {
592 memset(¤t->thread.vr_state, 0,
593 ELF_NVRREG * sizeof(vector128));
594 memset(¤t->thread.ckvr_state, 0,
595 ELF_NVRREG * sizeof(vector128));
598 /* Always get VRSAVE back */
599 unsafe_get_user(current->thread.ckvrsave,
600 (u32 __user *)&sr->mc_vregs[32], failed);
601 if (cpu_has_feature(CPU_FTR_ALTIVEC))
602 mtspr(SPRN_VRSAVE, current->thread.ckvrsave);
604 regs_set_return_msr(regs, regs->msr & ~(MSR_FP | MSR_FE0 | MSR_FE1));
606 unsafe_copy_fpr_from_user(current, &sr->mc_fregs, failed);
608 regs_set_return_msr(regs, regs->msr & ~MSR_VSX);
611 * Restore altivec registers from the stack to a local
612 * buffer, then write this out to the thread_struct
614 unsafe_copy_ckvsx_from_user(current, &sr->mc_vsregs, failed);
615 current->thread.used_vsr = true;
616 } else if (current->thread.used_vsr)
617 for (i = 0; i < 32 ; i++) {
618 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
619 current->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
622 user_read_access_end();
624 if (!user_read_access_begin(tm_sr, sizeof(*tm_sr)))
627 unsafe_restore_general_regs(regs, tm_sr, failed);
629 /* restore altivec registers from the stack */
631 unsafe_copy_from_user(¤t->thread.vr_state, &tm_sr->mc_vregs,
632 sizeof(sr->mc_vregs), failed);
634 /* Always get VRSAVE back */
635 unsafe_get_user(current->thread.vrsave,
636 (u32 __user *)&tm_sr->mc_vregs[32], failed);
638 unsafe_copy_ckfpr_from_user(current, &tm_sr->mc_fregs, failed);
642 * Restore altivec registers from the stack to a local
643 * buffer, then write this out to the thread_struct
645 unsafe_copy_vsx_from_user(current, &tm_sr->mc_vsregs, failed);
646 current->thread.used_vsr = true;
649 /* Get the top half of the MSR from the user context */
650 unsafe_get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR], failed);
653 user_read_access_end();
655 /* If TM bits are set to the reserved value, it's an invalid context */
656 if (MSR_TM_RESV(msr_hi))
660 * Disabling preemption, since it is unsafe to be preempted
661 * with MSR[TS] set without recheckpointing.
667 * After regs->MSR[TS] being updated, make sure that get_user(),
668 * put_user() or similar functions are *not* called. These
669 * functions can generate page faults which will cause the process
670 * to be de-scheduled with MSR[TS] set but without calling
671 * tm_recheckpoint(). This can cause a bug.
673 * Pull in the MSR TM bits from the user context
675 regs_set_return_msr(regs, (regs->msr & ~MSR_TS_MASK) | (msr_hi & MSR_TS_MASK));
676 /* Now, recheckpoint. This loads up all of the checkpointed (older)
677 * registers, including FP and V[S]Rs. After recheckpointing, the
678 * transactional versions should be loaded.
681 /* Make sure the transaction is marked as failed */
682 current->thread.tm_texasr |= TEXASR_FS;
683 /* This loads the checkpointed FP/VEC state, if used */
684 tm_recheckpoint(¤t->thread);
686 /* This loads the speculative FP/VEC state, if used */
687 msr_check_and_set(msr & (MSR_FP | MSR_VEC));
689 load_fp_state(¤t->thread.fp_state);
690 regs_set_return_msr(regs, regs->msr | (MSR_FP | current->thread.fpexc_mode));
693 load_vr_state(¤t->thread.vr_state);
694 regs_set_return_msr(regs, regs->msr | MSR_VEC);
702 user_read_access_end();
706 static long restore_tm_user_regs(struct pt_regs *regs, struct mcontext __user *sr,
707 struct mcontext __user *tm_sr)
715 #define copy_siginfo_to_user copy_siginfo_to_user32
717 #endif /* CONFIG_PPC64 */
720 * Set up a signal frame for a "real-time" signal handler
721 * (one which gets siginfo).
723 int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
724 struct task_struct *tsk)
726 struct rt_sigframe __user *frame;
727 struct mcontext __user *mctx;
728 struct mcontext __user *tm_mctx = NULL;
729 unsigned long newsp = 0;
731 struct pt_regs *regs = tsk->thread.regs;
732 /* Save the thread's msr before get_tm_stackpointer() changes it */
733 unsigned long msr = regs->msr;
735 /* Set up Signal Frame */
736 frame = get_sigframe(ksig, tsk, sizeof(*frame), 1);
737 mctx = &frame->uc.uc_mcontext;
738 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
739 tm_mctx = &frame->uc_transact.uc_mcontext;
741 if (MSR_TM_ACTIVE(msr))
742 prepare_save_tm_user_regs();
744 prepare_save_user_regs(1);
746 if (!user_access_begin(frame, sizeof(*frame)))
749 /* Put the siginfo & fill in most of the ucontext */
750 unsafe_put_user(0, &frame->uc.uc_flags, failed);
752 unsafe_compat_save_altstack(&frame->uc.uc_stack, regs->gpr[1], failed);
754 unsafe_save_altstack(&frame->uc.uc_stack, regs->gpr[1], failed);
756 unsafe_put_user(to_user_ptr(&frame->uc.uc_mcontext), &frame->uc.uc_regs, failed);
758 if (MSR_TM_ACTIVE(msr)) {
759 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
760 unsafe_put_user((unsigned long)&frame->uc_transact,
761 &frame->uc.uc_link, failed);
762 unsafe_put_user((unsigned long)tm_mctx,
763 &frame->uc_transact.uc_regs, failed);
765 unsafe_save_tm_user_regs(regs, mctx, tm_mctx, msr, failed);
767 unsafe_put_user(0, &frame->uc.uc_link, failed);
768 unsafe_save_user_regs(regs, mctx, tm_mctx, 1, failed);
771 /* Save user registers on the stack */
772 if (tsk->mm->context.vdso) {
773 tramp = VDSO32_SYMBOL(tsk->mm->context.vdso, sigtramp_rt32);
775 tramp = (unsigned long)mctx->mc_pad;
776 unsafe_put_user(PPC_RAW_LI(_R0, __NR_rt_sigreturn), &mctx->mc_pad[0], failed);
777 unsafe_put_user(PPC_RAW_SC(), &mctx->mc_pad[1], failed);
778 asm("dcbst %y0; sync; icbi %y0; sync" :: "Z" (mctx->mc_pad[0]));
780 unsafe_put_sigset_t(&frame->uc.uc_sigmask, oldset, failed);
784 if (copy_siginfo_to_user(&frame->info, &ksig->info))
789 #ifdef CONFIG_PPC_FPU_REGS
790 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
793 /* create a stack frame for the caller of the handler */
794 newsp = ((unsigned long)frame) - (__SIGNAL_FRAMESIZE + 16);
795 if (put_user(regs->gpr[1], (u32 __user *)newsp))
798 /* Fill registers for signal handler */
799 regs->gpr[1] = newsp;
800 regs->gpr[3] = ksig->sig;
801 regs->gpr[4] = (unsigned long)&frame->info;
802 regs->gpr[5] = (unsigned long)&frame->uc;
803 regs->gpr[6] = (unsigned long)frame;
804 regs_set_return_ip(regs, (unsigned long) ksig->ka.sa.sa_handler);
805 /* enter the signal handler in native-endian mode */
806 regs_set_return_msr(regs, (regs->msr & ~MSR_LE) | (MSR_KERNEL & MSR_LE));
814 signal_fault(tsk, regs, "handle_rt_signal32", frame);
820 * OK, we're invoking a handler
822 int handle_signal32(struct ksignal *ksig, sigset_t *oldset,
823 struct task_struct *tsk)
825 struct sigcontext __user *sc;
826 struct sigframe __user *frame;
827 struct mcontext __user *mctx;
828 struct mcontext __user *tm_mctx = NULL;
829 unsigned long newsp = 0;
831 struct pt_regs *regs = tsk->thread.regs;
832 /* Save the thread's msr before get_tm_stackpointer() changes it */
833 unsigned long msr = regs->msr;
835 /* Set up Signal Frame */
836 frame = get_sigframe(ksig, tsk, sizeof(*frame), 1);
838 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
839 tm_mctx = &frame->mctx_transact;
841 if (MSR_TM_ACTIVE(msr))
842 prepare_save_tm_user_regs();
844 prepare_save_user_regs(1);
846 if (!user_access_begin(frame, sizeof(*frame)))
848 sc = (struct sigcontext __user *) &frame->sctx;
851 #error "Please adjust handle_signal()"
853 unsafe_put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler, failed);
854 unsafe_put_user(oldset->sig[0], &sc->oldmask, failed);
856 unsafe_put_user((oldset->sig[0] >> 32), &sc->_unused[3], failed);
858 unsafe_put_user(oldset->sig[1], &sc->_unused[3], failed);
860 unsafe_put_user(to_user_ptr(mctx), &sc->regs, failed);
861 unsafe_put_user(ksig->sig, &sc->signal, failed);
863 if (MSR_TM_ACTIVE(msr))
864 unsafe_save_tm_user_regs(regs, mctx, tm_mctx, msr, failed);
866 unsafe_save_user_regs(regs, mctx, tm_mctx, 1, failed);
868 if (tsk->mm->context.vdso) {
869 tramp = VDSO32_SYMBOL(tsk->mm->context.vdso, sigtramp32);
871 tramp = (unsigned long)mctx->mc_pad;
872 unsafe_put_user(PPC_RAW_LI(_R0, __NR_sigreturn), &mctx->mc_pad[0], failed);
873 unsafe_put_user(PPC_RAW_SC(), &mctx->mc_pad[1], failed);
874 asm("dcbst %y0; sync; icbi %y0; sync" :: "Z" (mctx->mc_pad[0]));
880 #ifdef CONFIG_PPC_FPU_REGS
881 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
884 /* create a stack frame for the caller of the handler */
885 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
886 if (put_user(regs->gpr[1], (u32 __user *)newsp))
889 regs->gpr[1] = newsp;
890 regs->gpr[3] = ksig->sig;
891 regs->gpr[4] = (unsigned long) sc;
892 regs_set_return_ip(regs, (unsigned long) ksig->ka.sa.sa_handler);
893 /* enter the signal handler in native-endian mode */
894 regs_set_return_msr(regs, (regs->msr & ~MSR_LE) | (MSR_KERNEL & MSR_LE));
902 signal_fault(tsk, regs, "handle_signal32", frame);
907 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
910 struct mcontext __user *mcp;
912 if (!user_read_access_begin(ucp, sizeof(*ucp)))
915 unsafe_get_sigset_t(&set, &ucp->uc_sigmask, failed);
920 unsafe_get_user(cmcp, &ucp->uc_regs, failed);
921 mcp = (struct mcontext __user *)(u64)cmcp;
924 unsafe_get_user(mcp, &ucp->uc_regs, failed);
926 user_read_access_end();
928 set_current_blocked(&set);
929 if (restore_user_regs(regs, mcp, sig))
935 user_read_access_end();
939 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
940 static int do_setcontext_tm(struct ucontext __user *ucp,
941 struct ucontext __user *tm_ucp,
942 struct pt_regs *regs)
945 struct mcontext __user *mcp;
946 struct mcontext __user *tm_mcp;
950 if (!user_read_access_begin(ucp, sizeof(*ucp)))
953 unsafe_get_sigset_t(&set, &ucp->uc_sigmask, failed);
954 unsafe_get_user(cmcp, &ucp->uc_regs, failed);
956 user_read_access_end();
958 if (__get_user(tm_cmcp, &tm_ucp->uc_regs))
960 mcp = (struct mcontext __user *)(u64)cmcp;
961 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
962 /* no need to check access_ok(mcp), since mcp < 4GB */
964 set_current_blocked(&set);
965 if (restore_tm_user_regs(regs, mcp, tm_mcp))
971 user_read_access_end();
977 COMPAT_SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
978 struct ucontext __user *, new_ctx, int, ctx_size)
980 SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
981 struct ucontext __user *, new_ctx, long, ctx_size)
984 struct pt_regs *regs = current_pt_regs();
985 int ctx_has_vsx_region = 0;
988 unsigned long new_msr = 0;
991 struct mcontext __user *mcp;
995 * Get pointer to the real mcontext. No need for
996 * access_ok since we are dealing with compat
999 if (__get_user(cmcp, &new_ctx->uc_regs))
1001 mcp = (struct mcontext __user *)(u64)cmcp;
1002 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1006 * Check that the context is not smaller than the original
1007 * size (with VMX but without VSX)
1009 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1012 * If the new context state sets the MSR VSX bits but
1013 * it doesn't provide VSX state.
1015 if ((ctx_size < sizeof(struct ucontext)) &&
1016 (new_msr & MSR_VSX))
1018 /* Does the context have enough room to store VSX data? */
1019 if (ctx_size >= sizeof(struct ucontext))
1020 ctx_has_vsx_region = 1;
1022 /* Context size is for future use. Right now, we only make sure
1023 * we are passed something we understand
1025 if (ctx_size < sizeof(struct ucontext))
1028 if (old_ctx != NULL) {
1029 struct mcontext __user *mctx;
1032 * old_ctx might not be 16-byte aligned, in which
1033 * case old_ctx->uc_mcontext won't be either.
1034 * Because we have the old_ctx->uc_pad2 field
1035 * before old_ctx->uc_mcontext, we need to round down
1036 * from &old_ctx->uc_mcontext to a 16-byte boundary.
1038 mctx = (struct mcontext __user *)
1039 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1040 prepare_save_user_regs(ctx_has_vsx_region);
1041 if (!user_write_access_begin(old_ctx, ctx_size))
1043 unsafe_save_user_regs(regs, mctx, NULL, ctx_has_vsx_region, failed);
1044 unsafe_put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked, failed);
1045 unsafe_put_user(to_user_ptr(mctx), &old_ctx->uc_regs, failed);
1046 user_write_access_end();
1048 if (new_ctx == NULL)
1050 if (!access_ok(new_ctx, ctx_size) ||
1051 fault_in_readable((char __user *)new_ctx, ctx_size))
1055 * If we get a fault copying the context into the kernel's
1056 * image of the user's registers, we can't just return -EFAULT
1057 * because the user's registers will be corrupted. For instance
1058 * the NIP value may have been updated but not some of the
1059 * other registers. Given that we have done the access_ok
1060 * and successfully read the first and last bytes of the region
1061 * above, this should only happen in an out-of-memory situation
1062 * or if another thread unmaps the region containing the context.
1063 * We kill the task with a SIGSEGV in this situation.
1065 if (do_setcontext(new_ctx, regs, 0)) {
1066 force_exit_sig(SIGSEGV);
1070 set_thread_flag(TIF_RESTOREALL);
1074 user_write_access_end();
1079 COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
1081 SYSCALL_DEFINE0(rt_sigreturn)
1084 struct rt_sigframe __user *rt_sf;
1085 struct pt_regs *regs = current_pt_regs();
1087 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1088 struct ucontext __user *uc_transact;
1089 unsigned long msr_hi;
1092 /* Always make any pending restarted system calls return -EINTR */
1093 current->restart_block.fn = do_no_restart_syscall;
1095 rt_sf = (struct rt_sigframe __user *)
1096 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1097 if (!access_ok(rt_sf, sizeof(*rt_sf)))
1100 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1102 * If there is a transactional state then throw it away.
1103 * The purpose of a sigreturn is to destroy all traces of the
1104 * signal frame, this includes any transactional state created
1105 * within in. We only check for suspended as we can never be
1106 * active in the kernel, we are active, there is nothing better to
1107 * do than go ahead and Bad Thing later.
1108 * The cause is not important as there will never be a
1109 * recheckpoint so it's not user visible.
1111 if (MSR_TM_SUSPENDED(mfmsr()))
1112 tm_reclaim_current(0);
1114 if (__get_user(tmp, &rt_sf->uc.uc_link))
1116 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1119 struct mcontext __user *mcp;
1121 if (__get_user(cmcp, &uc_transact->uc_regs))
1123 mcp = (struct mcontext __user *)(u64)cmcp;
1124 /* The top 32 bits of the MSR are stashed in the transactional
1126 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1129 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1130 /* Trying to start TM on non TM system */
1131 if (!cpu_has_feature(CPU_FTR_TM))
1133 /* We only recheckpoint on return if we're
1137 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1143 * Unset regs->msr because ucontext MSR TS is not
1144 * set, and recheckpoint was not called. This avoid
1145 * hitting a TM Bad thing at RFID
1147 regs_set_return_msr(regs, regs->msr & ~MSR_TS_MASK);
1149 /* Fall through, for non-TM restore */
1152 if (do_setcontext(&rt_sf->uc, regs, 1))
1156 * It's not clear whether or why it is desirable to save the
1157 * sigaltstack setting on signal delivery and restore it on
1158 * signal return. But other architectures do this and we have
1159 * always done it up until now so it is probably better not to
1160 * change it. -- paulus
1163 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1166 if (restore_altstack(&rt_sf->uc.uc_stack))
1169 set_thread_flag(TIF_RESTOREALL);
1173 signal_fault(current, regs, "sys_rt_sigreturn", rt_sf);
1180 SYSCALL_DEFINE3(debug_setcontext, struct ucontext __user *, ctx,
1181 int, ndbg, struct sig_dbg_op __user *, dbg)
1183 struct pt_regs *regs = current_pt_regs();
1184 struct sig_dbg_op op;
1186 unsigned long new_msr = regs->msr;
1187 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1188 unsigned long new_dbcr0 = current->thread.debug.dbcr0;
1191 for (i=0; i<ndbg; i++) {
1192 if (copy_from_user(&op, dbg + i, sizeof(op)))
1194 switch (op.dbg_type) {
1195 case SIG_DBG_SINGLE_STEPPING:
1196 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1199 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1201 new_dbcr0 &= ~DBCR0_IC;
1202 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1203 current->thread.debug.dbcr1)) {
1205 new_dbcr0 &= ~DBCR0_IDM;
1215 case SIG_DBG_BRANCH_TRACING:
1216 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1231 /* We wait until here to actually install the values in the
1232 registers so if we fail in the above loop, it will not
1233 affect the contents of these registers. After this point,
1234 failure is a problem, anyway, and it's very unlikely unless
1235 the user is really doing something wrong. */
1236 regs_set_return_msr(regs, new_msr);
1237 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1238 current->thread.debug.dbcr0 = new_dbcr0;
1241 if (!access_ok(ctx, sizeof(*ctx)) ||
1242 fault_in_readable((char __user *)ctx, sizeof(*ctx)))
1246 * If we get a fault copying the context into the kernel's
1247 * image of the user's registers, we can't just return -EFAULT
1248 * because the user's registers will be corrupted. For instance
1249 * the NIP value may have been updated but not some of the
1250 * other registers. Given that we have done the access_ok
1251 * and successfully read the first and last bytes of the region
1252 * above, this should only happen in an out-of-memory situation
1253 * or if another thread unmaps the region containing the context.
1254 * We kill the task with a SIGSEGV in this situation.
1256 if (do_setcontext(ctx, regs, 1)) {
1257 signal_fault(current, regs, "sys_debug_setcontext", ctx);
1264 * It's not clear whether or why it is desirable to save the
1265 * sigaltstack setting on signal delivery and restore it on
1266 * signal return. But other architectures do this and we have
1267 * always done it up until now so it is probably better not to
1268 * change it. -- paulus
1270 restore_altstack(&ctx->uc_stack);
1272 set_thread_flag(TIF_RESTOREALL);
1279 * Do a signal return; undo the signal stack.
1282 COMPAT_SYSCALL_DEFINE0(sigreturn)
1284 SYSCALL_DEFINE0(sigreturn)
1287 struct pt_regs *regs = current_pt_regs();
1288 struct sigframe __user *sf;
1289 struct sigcontext __user *sc;
1290 struct sigcontext sigctx;
1291 struct mcontext __user *sr;
1293 struct mcontext __user *mcp;
1294 struct mcontext __user *tm_mcp = NULL;
1295 unsigned long long msr_hi = 0;
1297 /* Always make any pending restarted system calls return -EINTR */
1298 current->restart_block.fn = do_no_restart_syscall;
1300 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1302 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1307 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1308 * unused part of the signal stackframe
1310 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1312 set.sig[0] = sigctx.oldmask;
1313 set.sig[1] = sigctx._unused[3];
1315 set_current_blocked(&set);
1317 mcp = (struct mcontext __user *)&sf->mctx;
1318 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1319 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1320 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1323 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1324 if (!cpu_has_feature(CPU_FTR_TM))
1326 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1329 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1330 if (restore_user_regs(regs, sr, 1)) {
1331 signal_fault(current, regs, "sys_sigreturn", sr);
1338 set_thread_flag(TIF_RESTOREALL);
1342 signal_fault(current, regs, "sys_sigreturn", sc);