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 #ifdef CONFIG_ALTIVEC
358 if (cpu_has_feature(CPU_FTR_ALTIVEC))
359 current->thread.ckvrsave = mfspr(SPRN_VRSAVE);
362 if (current->thread.used_spe)
363 flush_spe_to_thread(current);
367 static int save_tm_user_regs_unsafe(struct pt_regs *regs, struct mcontext __user *frame,
368 struct mcontext __user *tm_frame, unsigned long msr)
370 /* Save both sets of general registers */
371 unsafe_save_general_regs(¤t->thread.ckpt_regs, frame, failed);
372 unsafe_save_general_regs(regs, tm_frame, failed);
374 /* Stash the top half of the 64bit MSR into the 32bit MSR word
375 * of the transactional mcontext. This way we have a backward-compatible
376 * MSR in the 'normal' (checkpointed) mcontext and additionally one can
377 * also look at what type of transaction (T or S) was active at the
378 * time of the signal.
380 unsafe_put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR], failed);
382 #ifdef CONFIG_ALTIVEC
383 /* save altivec registers */
384 if (current->thread.used_vr) {
385 unsafe_copy_to_user(&frame->mc_vregs, ¤t->thread.ckvr_state,
386 ELF_NVRREG * sizeof(vector128), failed);
388 unsafe_copy_to_user(&tm_frame->mc_vregs,
389 ¤t->thread.vr_state,
390 ELF_NVRREG * sizeof(vector128), failed);
392 unsafe_copy_to_user(&tm_frame->mc_vregs,
393 ¤t->thread.ckvr_state,
394 ELF_NVRREG * sizeof(vector128), failed);
396 /* set MSR_VEC in the saved MSR value to indicate that
397 * frame->mc_vregs contains valid data
402 /* We always copy to/from vrsave, it's 0 if we don't have or don't
403 * use altivec. Since VSCR only contains 32 bits saved in the least
404 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
405 * most significant bits of that same vector. --BenH
407 unsafe_put_user(current->thread.ckvrsave,
408 (u32 __user *)&frame->mc_vregs[32], failed);
410 unsafe_put_user(current->thread.vrsave,
411 (u32 __user *)&tm_frame->mc_vregs[32], failed);
413 unsafe_put_user(current->thread.ckvrsave,
414 (u32 __user *)&tm_frame->mc_vregs[32], failed);
415 #endif /* CONFIG_ALTIVEC */
417 unsafe_copy_ckfpr_to_user(&frame->mc_fregs, current, failed);
419 unsafe_copy_fpr_to_user(&tm_frame->mc_fregs, current, failed);
421 unsafe_copy_ckfpr_to_user(&tm_frame->mc_fregs, current, failed);
425 * Copy VSR 0-31 upper half from thread_struct to local
426 * buffer, then write that to userspace. Also set MSR_VSX in
427 * the saved MSR value to indicate that frame->mc_vregs
428 * contains valid data
430 if (current->thread.used_vsr) {
431 unsafe_copy_ckvsx_to_user(&frame->mc_vsregs, current, failed);
433 unsafe_copy_vsx_to_user(&tm_frame->mc_vsregs, current, failed);
435 unsafe_copy_ckvsx_to_user(&tm_frame->mc_vsregs, current, failed);
439 #endif /* CONFIG_VSX */
441 /* SPE regs are not checkpointed with TM, so this section is
442 * simply the same as in __unsafe_save_user_regs().
444 if (current->thread.used_spe) {
445 unsafe_copy_to_user(&frame->mc_vregs, current->thread.evr,
446 ELF_NEVRREG * sizeof(u32), failed);
447 /* set MSR_SPE in the saved MSR value to indicate that
448 * frame->mc_vregs contains valid data */
452 /* We always copy to/from spefscr */
453 unsafe_put_user(current->thread.spefscr,
454 (u32 __user *)&frame->mc_vregs + ELF_NEVRREG, failed);
455 #endif /* CONFIG_SPE */
457 unsafe_put_user(msr, &frame->mc_gregs[PT_MSR], failed);
465 static void prepare_save_tm_user_regs(void) { }
467 static int save_tm_user_regs_unsafe(struct pt_regs *regs, struct mcontext __user *frame,
468 struct mcontext __user *tm_frame, unsigned long msr)
474 #define unsafe_save_tm_user_regs(regs, frame, tm_frame, msr, label) do { \
475 if (save_tm_user_regs_unsafe(regs, frame, tm_frame, msr)) \
480 * Restore the current user register values from the user stack,
483 static long restore_user_regs(struct pt_regs *regs,
484 struct mcontext __user *sr, int sig)
486 unsigned int save_r2 = 0;
492 if (!user_read_access_begin(sr, sizeof(*sr)))
495 * restore general registers but not including MSR or SOFTE. Also
496 * take care of keeping r2 (TLS) intact if not a signal
499 save_r2 = (unsigned int)regs->gpr[2];
500 unsafe_restore_general_regs(regs, sr, failed);
501 set_trap_norestart(regs);
502 unsafe_get_user(msr, &sr->mc_gregs[PT_MSR], failed);
504 regs->gpr[2] = (unsigned long) save_r2;
506 /* if doing signal return, restore the previous little-endian mode */
508 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
510 #ifdef CONFIG_ALTIVEC
512 * Force the process to reload the altivec registers from
513 * current->thread when it next does altivec instructions
515 regs->msr &= ~MSR_VEC;
517 /* restore altivec registers from the stack */
518 unsafe_copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
519 sizeof(sr->mc_vregs), failed);
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 unsafe_get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32], failed);
527 if (cpu_has_feature(CPU_FTR_ALTIVEC))
528 mtspr(SPRN_VRSAVE, current->thread.vrsave);
529 #endif /* CONFIG_ALTIVEC */
530 unsafe_copy_fpr_from_user(current, &sr->mc_fregs, failed);
534 * Force the process to reload the VSX registers from
535 * current->thread when it next does VSX instruction.
537 regs->msr &= ~MSR_VSX;
540 * Restore altivec registers from the stack to a local
541 * buffer, then write this out to the thread_struct
543 unsafe_copy_vsx_from_user(current, &sr->mc_vsregs, failed);
544 current->thread.used_vsr = true;
545 } else if (current->thread.used_vsr)
546 for (i = 0; i < 32 ; i++)
547 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
548 #endif /* CONFIG_VSX */
550 * force the process to reload the FP registers from
551 * current->thread when it next does FP instructions
553 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
556 /* force the process to reload the spe registers from
557 current->thread when it next does spe instructions */
558 regs->msr &= ~MSR_SPE;
560 /* restore spe registers from the stack */
561 unsafe_copy_from_user(current->thread.evr, &sr->mc_vregs,
562 ELF_NEVRREG * sizeof(u32), failed);
563 current->thread.used_spe = true;
564 } else if (current->thread.used_spe)
565 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
567 /* Always get SPEFSCR back */
568 unsafe_get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG, failed);
569 #endif /* CONFIG_SPE */
571 user_read_access_end();
575 user_read_access_end();
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)
589 unsigned long msr, msr_hi;
594 if (tm_suspend_disabled)
597 * restore general registers but not including MSR or SOFTE. Also
598 * take care of keeping r2 (TLS) intact if not a signal.
599 * See comment in signal_64.c:restore_tm_sigcontexts();
600 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
601 * were set by the signal delivery.
603 if (!user_read_access_begin(sr, sizeof(*sr)))
606 unsafe_restore_general_regs(¤t->thread.ckpt_regs, sr, failed);
607 unsafe_get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP], failed);
608 unsafe_get_user(msr, &sr->mc_gregs[PT_MSR], failed);
610 /* Restore the previous little-endian mode */
611 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
613 #ifdef CONFIG_ALTIVEC
614 regs->msr &= ~MSR_VEC;
616 /* restore altivec registers from the stack */
617 unsafe_copy_from_user(¤t->thread.ckvr_state, &sr->mc_vregs,
618 sizeof(sr->mc_vregs), failed);
619 current->thread.used_vr = true;
620 } else if (current->thread.used_vr) {
621 memset(¤t->thread.vr_state, 0,
622 ELF_NVRREG * sizeof(vector128));
623 memset(¤t->thread.ckvr_state, 0,
624 ELF_NVRREG * sizeof(vector128));
627 /* Always get VRSAVE back */
628 unsafe_get_user(current->thread.ckvrsave,
629 (u32 __user *)&sr->mc_vregs[32], failed);
630 if (cpu_has_feature(CPU_FTR_ALTIVEC))
631 mtspr(SPRN_VRSAVE, current->thread.ckvrsave);
632 #endif /* CONFIG_ALTIVEC */
634 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
636 unsafe_copy_fpr_from_user(current, &sr->mc_fregs, failed);
639 regs->msr &= ~MSR_VSX;
642 * Restore altivec registers from the stack to a local
643 * buffer, then write this out to the thread_struct
645 unsafe_copy_ckvsx_from_user(current, &sr->mc_vsregs, failed);
646 current->thread.used_vsr = true;
647 } else if (current->thread.used_vsr)
648 for (i = 0; i < 32 ; i++) {
649 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
650 current->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
652 #endif /* CONFIG_VSX */
655 /* SPE regs are not checkpointed with TM, so this section is
656 * simply the same as in restore_user_regs().
658 regs->msr &= ~MSR_SPE;
660 unsafe_copy_from_user(current->thread.evr, &sr->mc_vregs,
661 ELF_NEVRREG * sizeof(u32), failed);
662 current->thread.used_spe = true;
663 } else if (current->thread.used_spe)
664 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
666 /* Always get SPEFSCR back */
667 unsafe_get_user(current->thread.spefscr,
668 (u32 __user *)&sr->mc_vregs + ELF_NEVRREG, failed);
669 #endif /* CONFIG_SPE */
671 user_read_access_end();
673 if (!user_read_access_begin(tm_sr, sizeof(*tm_sr)))
676 unsafe_restore_general_regs(regs, tm_sr, failed);
678 #ifdef CONFIG_ALTIVEC
679 /* restore altivec registers from the stack */
681 unsafe_copy_from_user(¤t->thread.vr_state, &tm_sr->mc_vregs,
682 sizeof(sr->mc_vregs), failed);
684 /* Always get VRSAVE back */
685 unsafe_get_user(current->thread.vrsave,
686 (u32 __user *)&tm_sr->mc_vregs[32], failed);
687 #endif /* CONFIG_ALTIVEC */
689 unsafe_copy_ckfpr_from_user(current, &tm_sr->mc_fregs, failed);
694 * Restore altivec registers from the stack to a local
695 * buffer, then write this out to the thread_struct
697 unsafe_copy_vsx_from_user(current, &tm_sr->mc_vsregs, failed);
698 current->thread.used_vsr = true;
700 #endif /* CONFIG_VSX */
702 /* Get the top half of the MSR from the user context */
703 unsafe_get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR], failed);
706 user_read_access_end();
708 /* If TM bits are set to the reserved value, it's an invalid context */
709 if (MSR_TM_RESV(msr_hi))
713 * Disabling preemption, since it is unsafe to be preempted
714 * with MSR[TS] set without recheckpointing.
720 * After regs->MSR[TS] being updated, make sure that get_user(),
721 * put_user() or similar functions are *not* called. These
722 * functions can generate page faults which will cause the process
723 * to be de-scheduled with MSR[TS] set but without calling
724 * tm_recheckpoint(). This can cause a bug.
726 * Pull in the MSR TM bits from the user context
728 regs->msr = (regs->msr & ~MSR_TS_MASK) | (msr_hi & MSR_TS_MASK);
729 /* Now, recheckpoint. This loads up all of the checkpointed (older)
730 * registers, including FP and V[S]Rs. After recheckpointing, the
731 * transactional versions should be loaded.
734 /* Make sure the transaction is marked as failed */
735 current->thread.tm_texasr |= TEXASR_FS;
736 /* This loads the checkpointed FP/VEC state, if used */
737 tm_recheckpoint(¤t->thread);
739 /* This loads the speculative FP/VEC state, if used */
740 msr_check_and_set(msr & (MSR_FP | MSR_VEC));
742 load_fp_state(¤t->thread.fp_state);
743 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
745 #ifdef CONFIG_ALTIVEC
747 load_vr_state(¤t->thread.vr_state);
748 regs->msr |= MSR_VEC;
757 user_read_access_end();
761 static long restore_tm_user_regs(struct pt_regs *regs, struct mcontext __user *sr,
762 struct mcontext __user *tm_sr)
770 #define copy_siginfo_to_user copy_siginfo_to_user32
772 #endif /* CONFIG_PPC64 */
775 * Set up a signal frame for a "real-time" signal handler
776 * (one which gets siginfo).
778 int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
779 struct task_struct *tsk)
781 struct rt_sigframe __user *frame;
782 struct mcontext __user *mctx;
783 struct mcontext __user *tm_mctx = NULL;
784 unsigned long newsp = 0;
786 struct pt_regs *regs = tsk->thread.regs;
787 /* Save the thread's msr before get_tm_stackpointer() changes it */
788 unsigned long msr = regs->msr;
790 /* Set up Signal Frame */
791 frame = get_sigframe(ksig, tsk, sizeof(*frame), 1);
792 mctx = &frame->uc.uc_mcontext;
793 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
794 tm_mctx = &frame->uc_transact.uc_mcontext;
796 if (MSR_TM_ACTIVE(msr))
797 prepare_save_tm_user_regs();
799 prepare_save_user_regs(1);
801 if (!user_access_begin(frame, sizeof(*frame)))
804 /* Put the siginfo & fill in most of the ucontext */
805 unsafe_put_user(0, &frame->uc.uc_flags, failed);
807 unsafe_compat_save_altstack(&frame->uc.uc_stack, regs->gpr[1], failed);
809 unsafe_save_altstack(&frame->uc.uc_stack, regs->gpr[1], failed);
811 unsafe_put_user(to_user_ptr(&frame->uc.uc_mcontext), &frame->uc.uc_regs, failed);
813 if (MSR_TM_ACTIVE(msr)) {
814 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
815 unsafe_put_user((unsigned long)&frame->uc_transact,
816 &frame->uc.uc_link, failed);
817 unsafe_put_user((unsigned long)tm_mctx,
818 &frame->uc_transact.uc_regs, failed);
820 unsafe_save_tm_user_regs(regs, mctx, tm_mctx, msr, failed);
822 unsafe_put_user(0, &frame->uc.uc_link, failed);
823 unsafe_save_user_regs(regs, mctx, tm_mctx, 1, failed);
826 /* Save user registers on the stack */
827 if (tsk->mm->context.vdso) {
828 tramp = VDSO32_SYMBOL(tsk->mm->context.vdso, sigtramp_rt32);
830 tramp = (unsigned long)mctx->mc_pad;
831 /* Set up the sigreturn trampoline: li r0,sigret; sc */
832 unsafe_put_user(PPC_INST_ADDI + __NR_rt_sigreturn, &mctx->mc_pad[0],
834 unsafe_put_user(PPC_INST_SC, &mctx->mc_pad[1], failed);
835 asm("dcbst %y0; sync; icbi %y0; sync" :: "Z" (mctx->mc_pad[0]));
837 unsafe_put_sigset_t(&frame->uc.uc_sigmask, oldset, failed);
841 if (copy_siginfo_to_user(&frame->info, &ksig->info))
846 #ifdef CONFIG_PPC_FPU_REGS
847 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
850 /* create a stack frame for the caller of the handler */
851 newsp = ((unsigned long)frame) - (__SIGNAL_FRAMESIZE + 16);
852 if (put_user(regs->gpr[1], (u32 __user *)newsp))
855 /* Fill registers for signal handler */
856 regs->gpr[1] = newsp;
857 regs->gpr[3] = ksig->sig;
858 regs->gpr[4] = (unsigned long)&frame->info;
859 regs->gpr[5] = (unsigned long)&frame->uc;
860 regs->gpr[6] = (unsigned long)frame;
861 regs->nip = (unsigned long) ksig->ka.sa.sa_handler;
862 /* enter the signal handler in native-endian mode */
863 regs->msr &= ~MSR_LE;
864 regs->msr |= (MSR_KERNEL & MSR_LE);
871 signal_fault(tsk, regs, "handle_rt_signal32", frame);
877 * OK, we're invoking a handler
879 int handle_signal32(struct ksignal *ksig, sigset_t *oldset,
880 struct task_struct *tsk)
882 struct sigcontext __user *sc;
883 struct sigframe __user *frame;
884 struct mcontext __user *mctx;
885 struct mcontext __user *tm_mctx = NULL;
886 unsigned long newsp = 0;
888 struct pt_regs *regs = tsk->thread.regs;
889 /* Save the thread's msr before get_tm_stackpointer() changes it */
890 unsigned long msr = regs->msr;
892 /* Set up Signal Frame */
893 frame = get_sigframe(ksig, tsk, sizeof(*frame), 1);
895 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
896 tm_mctx = &frame->mctx_transact;
898 if (MSR_TM_ACTIVE(msr))
899 prepare_save_tm_user_regs();
901 prepare_save_user_regs(1);
903 if (!user_access_begin(frame, sizeof(*frame)))
905 sc = (struct sigcontext __user *) &frame->sctx;
908 #error "Please adjust handle_signal()"
910 unsafe_put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler, failed);
911 unsafe_put_user(oldset->sig[0], &sc->oldmask, failed);
913 unsafe_put_user((oldset->sig[0] >> 32), &sc->_unused[3], failed);
915 unsafe_put_user(oldset->sig[1], &sc->_unused[3], failed);
917 unsafe_put_user(to_user_ptr(mctx), &sc->regs, failed);
918 unsafe_put_user(ksig->sig, &sc->signal, failed);
920 if (MSR_TM_ACTIVE(msr))
921 unsafe_save_tm_user_regs(regs, mctx, tm_mctx, msr, failed);
923 unsafe_save_user_regs(regs, mctx, tm_mctx, 1, failed);
925 if (tsk->mm->context.vdso) {
926 tramp = VDSO32_SYMBOL(tsk->mm->context.vdso, sigtramp32);
928 tramp = (unsigned long)mctx->mc_pad;
929 /* Set up the sigreturn trampoline: li r0,sigret; sc */
930 unsafe_put_user(PPC_INST_ADDI + __NR_sigreturn, &mctx->mc_pad[0], failed);
931 unsafe_put_user(PPC_INST_SC, &mctx->mc_pad[1], failed);
932 asm("dcbst %y0; sync; icbi %y0; sync" :: "Z" (mctx->mc_pad[0]));
938 #ifdef CONFIG_PPC_FPU_REGS
939 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
942 /* create a stack frame for the caller of the handler */
943 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
944 if (put_user(regs->gpr[1], (u32 __user *)newsp))
947 regs->gpr[1] = newsp;
948 regs->gpr[3] = ksig->sig;
949 regs->gpr[4] = (unsigned long) sc;
950 regs->nip = (unsigned long)ksig->ka.sa.sa_handler;
951 /* enter the signal handler in native-endian mode */
952 regs->msr &= ~MSR_LE;
953 regs->msr |= (MSR_KERNEL & MSR_LE);
960 signal_fault(tsk, regs, "handle_signal32", frame);
965 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
968 struct mcontext __user *mcp;
970 if (!user_read_access_begin(ucp, sizeof(*ucp)))
973 unsafe_get_sigset_t(&set, &ucp->uc_sigmask, failed);
978 unsafe_get_user(cmcp, &ucp->uc_regs, failed);
979 mcp = (struct mcontext __user *)(u64)cmcp;
982 unsafe_get_user(mcp, &ucp->uc_regs, failed);
984 user_read_access_end();
986 set_current_blocked(&set);
987 if (restore_user_regs(regs, mcp, sig))
993 user_read_access_end();
997 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
998 static int do_setcontext_tm(struct ucontext __user *ucp,
999 struct ucontext __user *tm_ucp,
1000 struct pt_regs *regs)
1003 struct mcontext __user *mcp;
1004 struct mcontext __user *tm_mcp;
1008 if (!user_read_access_begin(ucp, sizeof(*ucp)))
1011 unsafe_get_sigset_t(&set, &ucp->uc_sigmask, failed);
1012 unsafe_get_user(cmcp, &ucp->uc_regs, failed);
1014 user_read_access_end();
1016 if (__get_user(tm_cmcp, &tm_ucp->uc_regs))
1018 mcp = (struct mcontext __user *)(u64)cmcp;
1019 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
1020 /* no need to check access_ok(mcp), since mcp < 4GB */
1022 set_current_blocked(&set);
1023 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1029 user_read_access_end();
1035 COMPAT_SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
1036 struct ucontext __user *, new_ctx, int, ctx_size)
1038 SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
1039 struct ucontext __user *, new_ctx, long, ctx_size)
1042 struct pt_regs *regs = current_pt_regs();
1043 int ctx_has_vsx_region = 0;
1046 unsigned long new_msr = 0;
1049 struct mcontext __user *mcp;
1053 * Get pointer to the real mcontext. No need for
1054 * access_ok since we are dealing with compat
1057 if (__get_user(cmcp, &new_ctx->uc_regs))
1059 mcp = (struct mcontext __user *)(u64)cmcp;
1060 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1064 * Check that the context is not smaller than the original
1065 * size (with VMX but without VSX)
1067 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1070 * If the new context state sets the MSR VSX bits but
1071 * it doesn't provide VSX state.
1073 if ((ctx_size < sizeof(struct ucontext)) &&
1074 (new_msr & MSR_VSX))
1076 /* Does the context have enough room to store VSX data? */
1077 if (ctx_size >= sizeof(struct ucontext))
1078 ctx_has_vsx_region = 1;
1080 /* Context size is for future use. Right now, we only make sure
1081 * we are passed something we understand
1083 if (ctx_size < sizeof(struct ucontext))
1086 if (old_ctx != NULL) {
1087 struct mcontext __user *mctx;
1090 * old_ctx might not be 16-byte aligned, in which
1091 * case old_ctx->uc_mcontext won't be either.
1092 * Because we have the old_ctx->uc_pad2 field
1093 * before old_ctx->uc_mcontext, we need to round down
1094 * from &old_ctx->uc_mcontext to a 16-byte boundary.
1096 mctx = (struct mcontext __user *)
1097 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1098 prepare_save_user_regs(ctx_has_vsx_region);
1099 if (!user_write_access_begin(old_ctx, ctx_size))
1101 unsafe_save_user_regs(regs, mctx, NULL, ctx_has_vsx_region, failed);
1102 unsafe_put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked, failed);
1103 unsafe_put_user(to_user_ptr(mctx), &old_ctx->uc_regs, failed);
1104 user_write_access_end();
1106 if (new_ctx == NULL)
1108 if (!access_ok(new_ctx, ctx_size) ||
1109 fault_in_pages_readable((u8 __user *)new_ctx, ctx_size))
1113 * If we get a fault copying the context into the kernel's
1114 * image of the user's registers, we can't just return -EFAULT
1115 * because the user's registers will be corrupted. For instance
1116 * the NIP value may have been updated but not some of the
1117 * other registers. Given that we have done the access_ok
1118 * and successfully read the first and last bytes of the region
1119 * above, this should only happen in an out-of-memory situation
1120 * or if another thread unmaps the region containing the context.
1121 * We kill the task with a SIGSEGV in this situation.
1123 if (do_setcontext(new_ctx, regs, 0))
1126 set_thread_flag(TIF_RESTOREALL);
1130 user_write_access_end();
1135 COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
1137 SYSCALL_DEFINE0(rt_sigreturn)
1140 struct rt_sigframe __user *rt_sf;
1141 struct pt_regs *regs = current_pt_regs();
1143 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1144 struct ucontext __user *uc_transact;
1145 unsigned long msr_hi;
1148 /* Always make any pending restarted system calls return -EINTR */
1149 current->restart_block.fn = do_no_restart_syscall;
1151 rt_sf = (struct rt_sigframe __user *)
1152 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1153 if (!access_ok(rt_sf, sizeof(*rt_sf)))
1156 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1158 * If there is a transactional state then throw it away.
1159 * The purpose of a sigreturn is to destroy all traces of the
1160 * signal frame, this includes any transactional state created
1161 * within in. We only check for suspended as we can never be
1162 * active in the kernel, we are active, there is nothing better to
1163 * do than go ahead and Bad Thing later.
1164 * The cause is not important as there will never be a
1165 * recheckpoint so it's not user visible.
1167 if (MSR_TM_SUSPENDED(mfmsr()))
1168 tm_reclaim_current(0);
1170 if (__get_user(tmp, &rt_sf->uc.uc_link))
1172 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1175 struct mcontext __user *mcp;
1177 if (__get_user(cmcp, &uc_transact->uc_regs))
1179 mcp = (struct mcontext __user *)(u64)cmcp;
1180 /* The top 32 bits of the MSR are stashed in the transactional
1182 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1185 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1186 /* Trying to start TM on non TM system */
1187 if (!cpu_has_feature(CPU_FTR_TM))
1189 /* We only recheckpoint on return if we're
1193 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1199 * Unset regs->msr because ucontext MSR TS is not
1200 * set, and recheckpoint was not called. This avoid
1201 * hitting a TM Bad thing at RFID
1203 regs->msr &= ~MSR_TS_MASK;
1205 /* Fall through, for non-TM restore */
1208 if (do_setcontext(&rt_sf->uc, regs, 1))
1212 * It's not clear whether or why it is desirable to save the
1213 * sigaltstack setting on signal delivery and restore it on
1214 * signal return. But other architectures do this and we have
1215 * always done it up until now so it is probably better not to
1216 * change it. -- paulus
1219 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1222 if (restore_altstack(&rt_sf->uc.uc_stack))
1225 set_thread_flag(TIF_RESTOREALL);
1229 signal_fault(current, regs, "sys_rt_sigreturn", rt_sf);
1236 SYSCALL_DEFINE3(debug_setcontext, struct ucontext __user *, ctx,
1237 int, ndbg, struct sig_dbg_op __user *, dbg)
1239 struct pt_regs *regs = current_pt_regs();
1240 struct sig_dbg_op op;
1242 unsigned long new_msr = regs->msr;
1243 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1244 unsigned long new_dbcr0 = current->thread.debug.dbcr0;
1247 for (i=0; i<ndbg; i++) {
1248 if (copy_from_user(&op, dbg + i, sizeof(op)))
1250 switch (op.dbg_type) {
1251 case SIG_DBG_SINGLE_STEPPING:
1252 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1255 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1257 new_dbcr0 &= ~DBCR0_IC;
1258 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1259 current->thread.debug.dbcr1)) {
1261 new_dbcr0 &= ~DBCR0_IDM;
1271 case SIG_DBG_BRANCH_TRACING:
1272 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1287 /* We wait until here to actually install the values in the
1288 registers so if we fail in the above loop, it will not
1289 affect the contents of these registers. After this point,
1290 failure is a problem, anyway, and it's very unlikely unless
1291 the user is really doing something wrong. */
1292 regs->msr = new_msr;
1293 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1294 current->thread.debug.dbcr0 = new_dbcr0;
1297 if (!access_ok(ctx, sizeof(*ctx)) ||
1298 fault_in_pages_readable((u8 __user *)ctx, sizeof(*ctx)))
1302 * If we get a fault copying the context into the kernel's
1303 * image of the user's registers, we can't just return -EFAULT
1304 * because the user's registers will be corrupted. For instance
1305 * the NIP value may have been updated but not some of the
1306 * other registers. Given that we have done the access_ok
1307 * and successfully read the first and last bytes of the region
1308 * above, this should only happen in an out-of-memory situation
1309 * or if another thread unmaps the region containing the context.
1310 * We kill the task with a SIGSEGV in this situation.
1312 if (do_setcontext(ctx, regs, 1)) {
1313 signal_fault(current, regs, "sys_debug_setcontext", ctx);
1320 * It's not clear whether or why it is desirable to save the
1321 * sigaltstack setting on signal delivery and restore it on
1322 * signal return. But other architectures do this and we have
1323 * always done it up until now so it is probably better not to
1324 * change it. -- paulus
1326 restore_altstack(&ctx->uc_stack);
1328 set_thread_flag(TIF_RESTOREALL);
1335 * Do a signal return; undo the signal stack.
1338 COMPAT_SYSCALL_DEFINE0(sigreturn)
1340 SYSCALL_DEFINE0(sigreturn)
1343 struct pt_regs *regs = current_pt_regs();
1344 struct sigframe __user *sf;
1345 struct sigcontext __user *sc;
1346 struct sigcontext sigctx;
1347 struct mcontext __user *sr;
1349 struct mcontext __user *mcp;
1350 struct mcontext __user *tm_mcp = NULL;
1351 unsigned long long msr_hi = 0;
1353 /* Always make any pending restarted system calls return -EINTR */
1354 current->restart_block.fn = do_no_restart_syscall;
1356 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1358 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1363 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1364 * unused part of the signal stackframe
1366 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1368 set.sig[0] = sigctx.oldmask;
1369 set.sig[1] = sigctx._unused[3];
1371 set_current_blocked(&set);
1373 mcp = (struct mcontext __user *)&sf->mctx;
1374 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1375 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1376 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1379 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1380 if (!cpu_has_feature(CPU_FTR_TM))
1382 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1385 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1386 if (restore_user_regs(regs, sr, 1)) {
1387 signal_fault(current, regs, "sys_sigreturn", sr);
1394 set_thread_flag(TIF_RESTOREALL);
1398 signal_fault(current, regs, "sys_sigreturn", sc);