mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-05 18:39:59 +00:00
![Nicholas Piggin](/assets/img/avatar_default.png)
When an interrupt is taken, the SRR registers are set to return to where it left off. Unless they are modified in the meantime, or the return address or MSR are modified, there is no need to reload these registers when returning from interrupt. Introduce per-CPU flags that track the validity of SRR and HSRR registers. These are cleared when returning from interrupt, when using the registers for something else (e.g., OPAL calls), when adjusting the return address or MSR of a context, and when context switching (which changes the return address and MSR). This improves the performance of interrupt returns. Signed-off-by: Nicholas Piggin <npiggin@gmail.com> [mpe: Fold in fixup patch from Nick] Signed-off-by: Michael Ellerman <mpe@ellerman.id.au> Link: https://lore.kernel.org/r/20210617155116.2167984-5-npiggin@gmail.com
1344 lines
38 KiB
C
1344 lines
38 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* Signal handling for 32bit PPC and 32bit tasks on 64bit PPC
|
|
*
|
|
* PowerPC version
|
|
* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
|
|
* Copyright (C) 2001 IBM
|
|
* Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
|
|
* Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
|
|
*
|
|
* Derived from "arch/i386/kernel/signal.c"
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
* 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
|
|
*/
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/smp.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/signal.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/elf.h>
|
|
#include <linux/ptrace.h>
|
|
#include <linux/pagemap.h>
|
|
#include <linux/ratelimit.h>
|
|
#include <linux/syscalls.h>
|
|
#ifdef CONFIG_PPC64
|
|
#include <linux/compat.h>
|
|
#else
|
|
#include <linux/wait.h>
|
|
#include <linux/unistd.h>
|
|
#include <linux/stddef.h>
|
|
#include <linux/tty.h>
|
|
#include <linux/binfmts.h>
|
|
#endif
|
|
|
|
#include <linux/uaccess.h>
|
|
#include <asm/cacheflush.h>
|
|
#include <asm/syscalls.h>
|
|
#include <asm/sigcontext.h>
|
|
#include <asm/vdso.h>
|
|
#include <asm/switch_to.h>
|
|
#include <asm/tm.h>
|
|
#include <asm/asm-prototypes.h>
|
|
#ifdef CONFIG_PPC64
|
|
#include "ppc32.h"
|
|
#include <asm/unistd.h>
|
|
#else
|
|
#include <asm/ucontext.h>
|
|
#endif
|
|
|
|
#include "signal.h"
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
|
#define old_sigaction old_sigaction32
|
|
#define sigcontext sigcontext32
|
|
#define mcontext mcontext32
|
|
#define ucontext ucontext32
|
|
|
|
/*
|
|
* Userspace code may pass a ucontext which doesn't include VSX added
|
|
* at the end. We need to check for this case.
|
|
*/
|
|
#define UCONTEXTSIZEWITHOUTVSX \
|
|
(sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32))
|
|
|
|
/*
|
|
* Returning 0 means we return to userspace via
|
|
* ret_from_except and thus restore all user
|
|
* registers from *regs. This is what we need
|
|
* to do when a signal has been delivered.
|
|
*/
|
|
|
|
#define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
|
|
#undef __SIGNAL_FRAMESIZE
|
|
#define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
|
|
#undef ELF_NVRREG
|
|
#define ELF_NVRREG ELF_NVRREG32
|
|
|
|
/*
|
|
* Functions for flipping sigsets (thanks to brain dead generic
|
|
* implementation that makes things simple for little endian only)
|
|
*/
|
|
#define unsafe_put_sigset_t unsafe_put_compat_sigset
|
|
#define unsafe_get_sigset_t unsafe_get_compat_sigset
|
|
|
|
#define to_user_ptr(p) ptr_to_compat(p)
|
|
#define from_user_ptr(p) compat_ptr(p)
|
|
|
|
static __always_inline int
|
|
__unsafe_save_general_regs(struct pt_regs *regs, struct mcontext __user *frame)
|
|
{
|
|
elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
|
|
int val, i;
|
|
|
|
for (i = 0; i <= PT_RESULT; i ++) {
|
|
/* Force usr to alway see softe as 1 (interrupts enabled) */
|
|
if (i == PT_SOFTE)
|
|
val = 1;
|
|
else
|
|
val = gregs[i];
|
|
|
|
unsafe_put_user(val, &frame->mc_gregs[i], failed);
|
|
}
|
|
return 0;
|
|
|
|
failed:
|
|
return 1;
|
|
}
|
|
|
|
static __always_inline int
|
|
__unsafe_restore_general_regs(struct pt_regs *regs, struct mcontext __user *sr)
|
|
{
|
|
elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
|
|
int i;
|
|
|
|
for (i = 0; i <= PT_RESULT; i++) {
|
|
if ((i == PT_MSR) || (i == PT_SOFTE))
|
|
continue;
|
|
unsafe_get_user(gregs[i], &sr->mc_gregs[i], failed);
|
|
}
|
|
return 0;
|
|
|
|
failed:
|
|
return 1;
|
|
}
|
|
|
|
#else /* CONFIG_PPC64 */
|
|
|
|
#define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
|
|
|
|
#define unsafe_put_sigset_t(uset, set, label) do { \
|
|
sigset_t __user *__us = uset ; \
|
|
const sigset_t *__s = set; \
|
|
\
|
|
unsafe_copy_to_user(__us, __s, sizeof(*__us), label); \
|
|
} while (0)
|
|
|
|
#define unsafe_get_sigset_t unsafe_get_user_sigset
|
|
|
|
#define to_user_ptr(p) ((unsigned long)(p))
|
|
#define from_user_ptr(p) ((void __user *)(p))
|
|
|
|
static __always_inline int
|
|
__unsafe_save_general_regs(struct pt_regs *regs, struct mcontext __user *frame)
|
|
{
|
|
unsafe_copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE, failed);
|
|
return 0;
|
|
|
|
failed:
|
|
return 1;
|
|
}
|
|
|
|
static __always_inline
|
|
int __unsafe_restore_general_regs(struct pt_regs *regs, struct mcontext __user *sr)
|
|
{
|
|
/* copy up to but not including MSR */
|
|
unsafe_copy_from_user(regs, &sr->mc_gregs, PT_MSR * sizeof(elf_greg_t), failed);
|
|
|
|
/* copy from orig_r3 (the word after the MSR) up to the end */
|
|
unsafe_copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
|
|
GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t), failed);
|
|
|
|
return 0;
|
|
|
|
failed:
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
#define unsafe_save_general_regs(regs, frame, label) do { \
|
|
if (__unsafe_save_general_regs(regs, frame)) \
|
|
goto label; \
|
|
} while (0)
|
|
|
|
#define unsafe_restore_general_regs(regs, frame, label) do { \
|
|
if (__unsafe_restore_general_regs(regs, frame)) \
|
|
goto label; \
|
|
} while (0)
|
|
|
|
/*
|
|
* When we have signals to deliver, we set up on the
|
|
* user stack, going down from the original stack pointer:
|
|
* an ABI gap of 56 words
|
|
* an mcontext struct
|
|
* a sigcontext struct
|
|
* a gap of __SIGNAL_FRAMESIZE bytes
|
|
*
|
|
* Each of these things must be a multiple of 16 bytes in size. The following
|
|
* structure represent all of this except the __SIGNAL_FRAMESIZE gap
|
|
*
|
|
*/
|
|
struct sigframe {
|
|
struct sigcontext sctx; /* the sigcontext */
|
|
struct mcontext mctx; /* all the register values */
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
struct sigcontext sctx_transact;
|
|
struct mcontext mctx_transact;
|
|
#endif
|
|
/*
|
|
* Programs using the rs6000/xcoff abi can save up to 19 gp
|
|
* regs and 18 fp regs below sp before decrementing it.
|
|
*/
|
|
int abigap[56];
|
|
};
|
|
|
|
/*
|
|
* When we have rt signals to deliver, we set up on the
|
|
* user stack, going down from the original stack pointer:
|
|
* one rt_sigframe struct (siginfo + ucontext + ABI gap)
|
|
* a gap of __SIGNAL_FRAMESIZE+16 bytes
|
|
* (the +16 is to get the siginfo and ucontext in the same
|
|
* positions as in older kernels).
|
|
*
|
|
* Each of these things must be a multiple of 16 bytes in size.
|
|
*
|
|
*/
|
|
struct rt_sigframe {
|
|
#ifdef CONFIG_PPC64
|
|
compat_siginfo_t info;
|
|
#else
|
|
struct siginfo info;
|
|
#endif
|
|
struct ucontext uc;
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
struct ucontext uc_transact;
|
|
#endif
|
|
/*
|
|
* Programs using the rs6000/xcoff abi can save up to 19 gp
|
|
* regs and 18 fp regs below sp before decrementing it.
|
|
*/
|
|
int abigap[56];
|
|
};
|
|
|
|
/*
|
|
* Save the current user registers on the user stack.
|
|
* We only save the altivec/spe registers if the process has used
|
|
* altivec/spe instructions at some point.
|
|
*/
|
|
static void prepare_save_user_regs(int ctx_has_vsx_region)
|
|
{
|
|
/* Make sure floating point registers are stored in regs */
|
|
flush_fp_to_thread(current);
|
|
#ifdef CONFIG_ALTIVEC
|
|
if (current->thread.used_vr)
|
|
flush_altivec_to_thread(current);
|
|
if (cpu_has_feature(CPU_FTR_ALTIVEC))
|
|
current->thread.vrsave = mfspr(SPRN_VRSAVE);
|
|
#endif
|
|
#ifdef CONFIG_VSX
|
|
if (current->thread.used_vsr && ctx_has_vsx_region)
|
|
flush_vsx_to_thread(current);
|
|
#endif
|
|
#ifdef CONFIG_SPE
|
|
if (current->thread.used_spe)
|
|
flush_spe_to_thread(current);
|
|
#endif
|
|
}
|
|
|
|
static int __unsafe_save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
|
|
struct mcontext __user *tm_frame, int ctx_has_vsx_region)
|
|
{
|
|
unsigned long msr = regs->msr;
|
|
|
|
/* save general registers */
|
|
unsafe_save_general_regs(regs, frame, failed);
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
/* save altivec registers */
|
|
if (current->thread.used_vr) {
|
|
unsafe_copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state,
|
|
ELF_NVRREG * sizeof(vector128), failed);
|
|
/* set MSR_VEC in the saved MSR value to indicate that
|
|
frame->mc_vregs contains valid data */
|
|
msr |= MSR_VEC;
|
|
}
|
|
/* else assert((regs->msr & MSR_VEC) == 0) */
|
|
|
|
/* We always copy to/from vrsave, it's 0 if we don't have or don't
|
|
* use altivec. Since VSCR only contains 32 bits saved in the least
|
|
* significant bits of a vector, we "cheat" and stuff VRSAVE in the
|
|
* most significant bits of that same vector. --BenH
|
|
* Note that the current VRSAVE value is in the SPR at this point.
|
|
*/
|
|
unsafe_put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32],
|
|
failed);
|
|
#endif /* CONFIG_ALTIVEC */
|
|
unsafe_copy_fpr_to_user(&frame->mc_fregs, current, failed);
|
|
|
|
/*
|
|
* Clear the MSR VSX bit to indicate there is no valid state attached
|
|
* to this context, except in the specific case below where we set it.
|
|
*/
|
|
msr &= ~MSR_VSX;
|
|
#ifdef CONFIG_VSX
|
|
/*
|
|
* Copy VSR 0-31 upper half from thread_struct to local
|
|
* buffer, then write that to userspace. Also set MSR_VSX in
|
|
* the saved MSR value to indicate that frame->mc_vregs
|
|
* contains valid data
|
|
*/
|
|
if (current->thread.used_vsr && ctx_has_vsx_region) {
|
|
unsafe_copy_vsx_to_user(&frame->mc_vsregs, current, failed);
|
|
msr |= MSR_VSX;
|
|
}
|
|
#endif /* CONFIG_VSX */
|
|
#ifdef CONFIG_SPE
|
|
/* save spe registers */
|
|
if (current->thread.used_spe) {
|
|
unsafe_copy_to_user(&frame->mc_vregs, current->thread.evr,
|
|
ELF_NEVRREG * sizeof(u32), failed);
|
|
/* set MSR_SPE in the saved MSR value to indicate that
|
|
frame->mc_vregs contains valid data */
|
|
msr |= MSR_SPE;
|
|
}
|
|
/* else assert((regs->msr & MSR_SPE) == 0) */
|
|
|
|
/* We always copy to/from spefscr */
|
|
unsafe_put_user(current->thread.spefscr,
|
|
(u32 __user *)&frame->mc_vregs + ELF_NEVRREG, failed);
|
|
#endif /* CONFIG_SPE */
|
|
|
|
unsafe_put_user(msr, &frame->mc_gregs[PT_MSR], failed);
|
|
|
|
/* We need to write 0 the MSR top 32 bits in the tm frame so that we
|
|
* can check it on the restore to see if TM is active
|
|
*/
|
|
if (tm_frame)
|
|
unsafe_put_user(0, &tm_frame->mc_gregs[PT_MSR], failed);
|
|
|
|
return 0;
|
|
|
|
failed:
|
|
return 1;
|
|
}
|
|
|
|
#define unsafe_save_user_regs(regs, frame, tm_frame, has_vsx, label) do { \
|
|
if (__unsafe_save_user_regs(regs, frame, tm_frame, has_vsx)) \
|
|
goto label; \
|
|
} while (0)
|
|
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
/*
|
|
* Save the current user registers on the user stack.
|
|
* We only save the altivec/spe registers if the process has used
|
|
* altivec/spe instructions at some point.
|
|
* We also save the transactional registers to a second ucontext in the
|
|
* frame.
|
|
*
|
|
* See __unsafe_save_user_regs() and signal_64.c:setup_tm_sigcontexts().
|
|
*/
|
|
static void prepare_save_tm_user_regs(void)
|
|
{
|
|
WARN_ON(tm_suspend_disabled);
|
|
|
|
if (cpu_has_feature(CPU_FTR_ALTIVEC))
|
|
current->thread.ckvrsave = mfspr(SPRN_VRSAVE);
|
|
}
|
|
|
|
static int save_tm_user_regs_unsafe(struct pt_regs *regs, struct mcontext __user *frame,
|
|
struct mcontext __user *tm_frame, unsigned long msr)
|
|
{
|
|
/* Save both sets of general registers */
|
|
unsafe_save_general_regs(¤t->thread.ckpt_regs, frame, failed);
|
|
unsafe_save_general_regs(regs, tm_frame, failed);
|
|
|
|
/* Stash the top half of the 64bit MSR into the 32bit MSR word
|
|
* of the transactional mcontext. This way we have a backward-compatible
|
|
* MSR in the 'normal' (checkpointed) mcontext and additionally one can
|
|
* also look at what type of transaction (T or S) was active at the
|
|
* time of the signal.
|
|
*/
|
|
unsafe_put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR], failed);
|
|
|
|
/* save altivec registers */
|
|
if (current->thread.used_vr) {
|
|
unsafe_copy_to_user(&frame->mc_vregs, ¤t->thread.ckvr_state,
|
|
ELF_NVRREG * sizeof(vector128), failed);
|
|
if (msr & MSR_VEC)
|
|
unsafe_copy_to_user(&tm_frame->mc_vregs,
|
|
¤t->thread.vr_state,
|
|
ELF_NVRREG * sizeof(vector128), failed);
|
|
else
|
|
unsafe_copy_to_user(&tm_frame->mc_vregs,
|
|
¤t->thread.ckvr_state,
|
|
ELF_NVRREG * sizeof(vector128), failed);
|
|
|
|
/* set MSR_VEC in the saved MSR value to indicate that
|
|
* frame->mc_vregs contains valid data
|
|
*/
|
|
msr |= MSR_VEC;
|
|
}
|
|
|
|
/* We always copy to/from vrsave, it's 0 if we don't have or don't
|
|
* use altivec. Since VSCR only contains 32 bits saved in the least
|
|
* significant bits of a vector, we "cheat" and stuff VRSAVE in the
|
|
* most significant bits of that same vector. --BenH
|
|
*/
|
|
unsafe_put_user(current->thread.ckvrsave,
|
|
(u32 __user *)&frame->mc_vregs[32], failed);
|
|
if (msr & MSR_VEC)
|
|
unsafe_put_user(current->thread.vrsave,
|
|
(u32 __user *)&tm_frame->mc_vregs[32], failed);
|
|
else
|
|
unsafe_put_user(current->thread.ckvrsave,
|
|
(u32 __user *)&tm_frame->mc_vregs[32], failed);
|
|
|
|
unsafe_copy_ckfpr_to_user(&frame->mc_fregs, current, failed);
|
|
if (msr & MSR_FP)
|
|
unsafe_copy_fpr_to_user(&tm_frame->mc_fregs, current, failed);
|
|
else
|
|
unsafe_copy_ckfpr_to_user(&tm_frame->mc_fregs, current, failed);
|
|
|
|
/*
|
|
* Copy VSR 0-31 upper half from thread_struct to local
|
|
* buffer, then write that to userspace. Also set MSR_VSX in
|
|
* the saved MSR value to indicate that frame->mc_vregs
|
|
* contains valid data
|
|
*/
|
|
if (current->thread.used_vsr) {
|
|
unsafe_copy_ckvsx_to_user(&frame->mc_vsregs, current, failed);
|
|
if (msr & MSR_VSX)
|
|
unsafe_copy_vsx_to_user(&tm_frame->mc_vsregs, current, failed);
|
|
else
|
|
unsafe_copy_ckvsx_to_user(&tm_frame->mc_vsregs, current, failed);
|
|
|
|
msr |= MSR_VSX;
|
|
}
|
|
|
|
unsafe_put_user(msr, &frame->mc_gregs[PT_MSR], failed);
|
|
|
|
return 0;
|
|
|
|
failed:
|
|
return 1;
|
|
}
|
|
#else
|
|
static void prepare_save_tm_user_regs(void) { }
|
|
|
|
static int save_tm_user_regs_unsafe(struct pt_regs *regs, struct mcontext __user *frame,
|
|
struct mcontext __user *tm_frame, unsigned long msr)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#define unsafe_save_tm_user_regs(regs, frame, tm_frame, msr, label) do { \
|
|
if (save_tm_user_regs_unsafe(regs, frame, tm_frame, msr)) \
|
|
goto label; \
|
|
} while (0)
|
|
|
|
/*
|
|
* Restore the current user register values from the user stack,
|
|
* (except for MSR).
|
|
*/
|
|
static long restore_user_regs(struct pt_regs *regs,
|
|
struct mcontext __user *sr, int sig)
|
|
{
|
|
unsigned int save_r2 = 0;
|
|
unsigned long msr;
|
|
#ifdef CONFIG_VSX
|
|
int i;
|
|
#endif
|
|
|
|
if (!user_read_access_begin(sr, sizeof(*sr)))
|
|
return 1;
|
|
/*
|
|
* restore general registers but not including MSR or SOFTE. Also
|
|
* take care of keeping r2 (TLS) intact if not a signal
|
|
*/
|
|
if (!sig)
|
|
save_r2 = (unsigned int)regs->gpr[2];
|
|
unsafe_restore_general_regs(regs, sr, failed);
|
|
set_trap_norestart(regs);
|
|
unsafe_get_user(msr, &sr->mc_gregs[PT_MSR], failed);
|
|
if (!sig)
|
|
regs->gpr[2] = (unsigned long) save_r2;
|
|
|
|
/* if doing signal return, restore the previous little-endian mode */
|
|
if (sig)
|
|
regs_set_return_msr(regs, (regs->msr & ~MSR_LE) | (msr & MSR_LE));
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
/*
|
|
* Force the process to reload the altivec registers from
|
|
* current->thread when it next does altivec instructions
|
|
*/
|
|
regs_set_return_msr(regs, regs->msr & ~MSR_VEC);
|
|
if (msr & MSR_VEC) {
|
|
/* restore altivec registers from the stack */
|
|
unsafe_copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
|
|
sizeof(sr->mc_vregs), failed);
|
|
current->thread.used_vr = true;
|
|
} else if (current->thread.used_vr)
|
|
memset(¤t->thread.vr_state, 0,
|
|
ELF_NVRREG * sizeof(vector128));
|
|
|
|
/* Always get VRSAVE back */
|
|
unsafe_get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32], failed);
|
|
if (cpu_has_feature(CPU_FTR_ALTIVEC))
|
|
mtspr(SPRN_VRSAVE, current->thread.vrsave);
|
|
#endif /* CONFIG_ALTIVEC */
|
|
unsafe_copy_fpr_from_user(current, &sr->mc_fregs, failed);
|
|
|
|
#ifdef CONFIG_VSX
|
|
/*
|
|
* Force the process to reload the VSX registers from
|
|
* current->thread when it next does VSX instruction.
|
|
*/
|
|
regs_set_return_msr(regs, regs->msr & ~MSR_VSX);
|
|
if (msr & MSR_VSX) {
|
|
/*
|
|
* Restore altivec registers from the stack to a local
|
|
* buffer, then write this out to the thread_struct
|
|
*/
|
|
unsafe_copy_vsx_from_user(current, &sr->mc_vsregs, failed);
|
|
current->thread.used_vsr = true;
|
|
} else if (current->thread.used_vsr)
|
|
for (i = 0; i < 32 ; i++)
|
|
current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
|
|
#endif /* CONFIG_VSX */
|
|
/*
|
|
* force the process to reload the FP registers from
|
|
* current->thread when it next does FP instructions
|
|
*/
|
|
regs_set_return_msr(regs, regs->msr & ~(MSR_FP | MSR_FE0 | MSR_FE1));
|
|
|
|
#ifdef CONFIG_SPE
|
|
/* force the process to reload the spe registers from
|
|
current->thread when it next does spe instructions */
|
|
regs_set_return_msr(regs, regs->msr & ~MSR_SPE);
|
|
if (msr & MSR_SPE) {
|
|
/* restore spe registers from the stack */
|
|
unsafe_copy_from_user(current->thread.evr, &sr->mc_vregs,
|
|
ELF_NEVRREG * sizeof(u32), failed);
|
|
current->thread.used_spe = true;
|
|
} else if (current->thread.used_spe)
|
|
memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
|
|
|
|
/* Always get SPEFSCR back */
|
|
unsafe_get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG, failed);
|
|
#endif /* CONFIG_SPE */
|
|
|
|
user_read_access_end();
|
|
return 0;
|
|
|
|
failed:
|
|
user_read_access_end();
|
|
return 1;
|
|
}
|
|
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
/*
|
|
* Restore the current user register values from the user stack, except for
|
|
* MSR, and recheckpoint the original checkpointed register state for processes
|
|
* in transactions.
|
|
*/
|
|
static long restore_tm_user_regs(struct pt_regs *regs,
|
|
struct mcontext __user *sr,
|
|
struct mcontext __user *tm_sr)
|
|
{
|
|
unsigned long msr, msr_hi;
|
|
int i;
|
|
|
|
if (tm_suspend_disabled)
|
|
return 1;
|
|
/*
|
|
* restore general registers but not including MSR or SOFTE. Also
|
|
* take care of keeping r2 (TLS) intact if not a signal.
|
|
* See comment in signal_64.c:restore_tm_sigcontexts();
|
|
* TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
|
|
* were set by the signal delivery.
|
|
*/
|
|
if (!user_read_access_begin(sr, sizeof(*sr)))
|
|
return 1;
|
|
|
|
unsafe_restore_general_regs(¤t->thread.ckpt_regs, sr, failed);
|
|
unsafe_get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP], failed);
|
|
unsafe_get_user(msr, &sr->mc_gregs[PT_MSR], failed);
|
|
|
|
/* Restore the previous little-endian mode */
|
|
regs_set_return_msr(regs, (regs->msr & ~MSR_LE) | (msr & MSR_LE));
|
|
|
|
regs_set_return_msr(regs, regs->msr & ~MSR_VEC);
|
|
if (msr & MSR_VEC) {
|
|
/* restore altivec registers from the stack */
|
|
unsafe_copy_from_user(¤t->thread.ckvr_state, &sr->mc_vregs,
|
|
sizeof(sr->mc_vregs), failed);
|
|
current->thread.used_vr = true;
|
|
} else if (current->thread.used_vr) {
|
|
memset(¤t->thread.vr_state, 0,
|
|
ELF_NVRREG * sizeof(vector128));
|
|
memset(¤t->thread.ckvr_state, 0,
|
|
ELF_NVRREG * sizeof(vector128));
|
|
}
|
|
|
|
/* Always get VRSAVE back */
|
|
unsafe_get_user(current->thread.ckvrsave,
|
|
(u32 __user *)&sr->mc_vregs[32], failed);
|
|
if (cpu_has_feature(CPU_FTR_ALTIVEC))
|
|
mtspr(SPRN_VRSAVE, current->thread.ckvrsave);
|
|
|
|
regs_set_return_msr(regs, regs->msr & ~(MSR_FP | MSR_FE0 | MSR_FE1));
|
|
|
|
unsafe_copy_fpr_from_user(current, &sr->mc_fregs, failed);
|
|
|
|
regs_set_return_msr(regs, regs->msr & ~MSR_VSX);
|
|
if (msr & MSR_VSX) {
|
|
/*
|
|
* Restore altivec registers from the stack to a local
|
|
* buffer, then write this out to the thread_struct
|
|
*/
|
|
unsafe_copy_ckvsx_from_user(current, &sr->mc_vsregs, failed);
|
|
current->thread.used_vsr = true;
|
|
} else if (current->thread.used_vsr)
|
|
for (i = 0; i < 32 ; i++) {
|
|
current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
|
|
current->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
|
|
}
|
|
|
|
user_read_access_end();
|
|
|
|
if (!user_read_access_begin(tm_sr, sizeof(*tm_sr)))
|
|
return 1;
|
|
|
|
unsafe_restore_general_regs(regs, tm_sr, failed);
|
|
|
|
/* restore altivec registers from the stack */
|
|
if (msr & MSR_VEC)
|
|
unsafe_copy_from_user(¤t->thread.vr_state, &tm_sr->mc_vregs,
|
|
sizeof(sr->mc_vregs), failed);
|
|
|
|
/* Always get VRSAVE back */
|
|
unsafe_get_user(current->thread.vrsave,
|
|
(u32 __user *)&tm_sr->mc_vregs[32], failed);
|
|
|
|
unsafe_copy_ckfpr_from_user(current, &tm_sr->mc_fregs, failed);
|
|
|
|
if (msr & MSR_VSX) {
|
|
/*
|
|
* Restore altivec registers from the stack to a local
|
|
* buffer, then write this out to the thread_struct
|
|
*/
|
|
unsafe_copy_vsx_from_user(current, &tm_sr->mc_vsregs, failed);
|
|
current->thread.used_vsr = true;
|
|
}
|
|
|
|
/* Get the top half of the MSR from the user context */
|
|
unsafe_get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR], failed);
|
|
msr_hi <<= 32;
|
|
|
|
user_read_access_end();
|
|
|
|
/* If TM bits are set to the reserved value, it's an invalid context */
|
|
if (MSR_TM_RESV(msr_hi))
|
|
return 1;
|
|
|
|
/*
|
|
* Disabling preemption, since it is unsafe to be preempted
|
|
* with MSR[TS] set without recheckpointing.
|
|
*/
|
|
preempt_disable();
|
|
|
|
/*
|
|
* CAUTION:
|
|
* After regs->MSR[TS] being updated, make sure that get_user(),
|
|
* put_user() or similar functions are *not* called. These
|
|
* functions can generate page faults which will cause the process
|
|
* to be de-scheduled with MSR[TS] set but without calling
|
|
* tm_recheckpoint(). This can cause a bug.
|
|
*
|
|
* Pull in the MSR TM bits from the user context
|
|
*/
|
|
regs_set_return_msr(regs, (regs->msr & ~MSR_TS_MASK) | (msr_hi & MSR_TS_MASK));
|
|
/* Now, recheckpoint. This loads up all of the checkpointed (older)
|
|
* registers, including FP and V[S]Rs. After recheckpointing, the
|
|
* transactional versions should be loaded.
|
|
*/
|
|
tm_enable();
|
|
/* Make sure the transaction is marked as failed */
|
|
current->thread.tm_texasr |= TEXASR_FS;
|
|
/* This loads the checkpointed FP/VEC state, if used */
|
|
tm_recheckpoint(¤t->thread);
|
|
|
|
/* This loads the speculative FP/VEC state, if used */
|
|
msr_check_and_set(msr & (MSR_FP | MSR_VEC));
|
|
if (msr & MSR_FP) {
|
|
load_fp_state(¤t->thread.fp_state);
|
|
regs_set_return_msr(regs, regs->msr | (MSR_FP | current->thread.fpexc_mode));
|
|
}
|
|
if (msr & MSR_VEC) {
|
|
load_vr_state(¤t->thread.vr_state);
|
|
regs_set_return_msr(regs, regs->msr | MSR_VEC);
|
|
}
|
|
|
|
preempt_enable();
|
|
|
|
return 0;
|
|
|
|
failed:
|
|
user_read_access_end();
|
|
return 1;
|
|
}
|
|
#else
|
|
static long restore_tm_user_regs(struct pt_regs *regs, struct mcontext __user *sr,
|
|
struct mcontext __user *tm_sr)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
#define copy_siginfo_to_user copy_siginfo_to_user32
|
|
|
|
#endif /* CONFIG_PPC64 */
|
|
|
|
/*
|
|
* Set up a signal frame for a "real-time" signal handler
|
|
* (one which gets siginfo).
|
|
*/
|
|
int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
|
|
struct task_struct *tsk)
|
|
{
|
|
struct rt_sigframe __user *frame;
|
|
struct mcontext __user *mctx;
|
|
struct mcontext __user *tm_mctx = NULL;
|
|
unsigned long newsp = 0;
|
|
unsigned long tramp;
|
|
struct pt_regs *regs = tsk->thread.regs;
|
|
/* Save the thread's msr before get_tm_stackpointer() changes it */
|
|
unsigned long msr = regs->msr;
|
|
|
|
/* Set up Signal Frame */
|
|
frame = get_sigframe(ksig, tsk, sizeof(*frame), 1);
|
|
mctx = &frame->uc.uc_mcontext;
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
tm_mctx = &frame->uc_transact.uc_mcontext;
|
|
#endif
|
|
if (MSR_TM_ACTIVE(msr))
|
|
prepare_save_tm_user_regs();
|
|
else
|
|
prepare_save_user_regs(1);
|
|
|
|
if (!user_access_begin(frame, sizeof(*frame)))
|
|
goto badframe;
|
|
|
|
/* Put the siginfo & fill in most of the ucontext */
|
|
unsafe_put_user(0, &frame->uc.uc_flags, failed);
|
|
#ifdef CONFIG_PPC64
|
|
unsafe_compat_save_altstack(&frame->uc.uc_stack, regs->gpr[1], failed);
|
|
#else
|
|
unsafe_save_altstack(&frame->uc.uc_stack, regs->gpr[1], failed);
|
|
#endif
|
|
unsafe_put_user(to_user_ptr(&frame->uc.uc_mcontext), &frame->uc.uc_regs, failed);
|
|
|
|
if (MSR_TM_ACTIVE(msr)) {
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
unsafe_put_user((unsigned long)&frame->uc_transact,
|
|
&frame->uc.uc_link, failed);
|
|
unsafe_put_user((unsigned long)tm_mctx,
|
|
&frame->uc_transact.uc_regs, failed);
|
|
#endif
|
|
unsafe_save_tm_user_regs(regs, mctx, tm_mctx, msr, failed);
|
|
} else {
|
|
unsafe_put_user(0, &frame->uc.uc_link, failed);
|
|
unsafe_save_user_regs(regs, mctx, tm_mctx, 1, failed);
|
|
}
|
|
|
|
/* Save user registers on the stack */
|
|
if (tsk->mm->context.vdso) {
|
|
tramp = VDSO32_SYMBOL(tsk->mm->context.vdso, sigtramp_rt32);
|
|
} else {
|
|
tramp = (unsigned long)mctx->mc_pad;
|
|
unsafe_put_user(PPC_RAW_LI(_R0, __NR_rt_sigreturn), &mctx->mc_pad[0], failed);
|
|
unsafe_put_user(PPC_RAW_SC(), &mctx->mc_pad[1], failed);
|
|
asm("dcbst %y0; sync; icbi %y0; sync" :: "Z" (mctx->mc_pad[0]));
|
|
}
|
|
unsafe_put_sigset_t(&frame->uc.uc_sigmask, oldset, failed);
|
|
|
|
user_access_end();
|
|
|
|
if (copy_siginfo_to_user(&frame->info, &ksig->info))
|
|
goto badframe;
|
|
|
|
regs->link = tramp;
|
|
|
|
#ifdef CONFIG_PPC_FPU_REGS
|
|
tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
|
|
#endif
|
|
|
|
/* create a stack frame for the caller of the handler */
|
|
newsp = ((unsigned long)frame) - (__SIGNAL_FRAMESIZE + 16);
|
|
if (put_user(regs->gpr[1], (u32 __user *)newsp))
|
|
goto badframe;
|
|
|
|
/* Fill registers for signal handler */
|
|
regs->gpr[1] = newsp;
|
|
regs->gpr[3] = ksig->sig;
|
|
regs->gpr[4] = (unsigned long)&frame->info;
|
|
regs->gpr[5] = (unsigned long)&frame->uc;
|
|
regs->gpr[6] = (unsigned long)frame;
|
|
regs_set_return_ip(regs, (unsigned long) ksig->ka.sa.sa_handler);
|
|
/* enter the signal handler in native-endian mode */
|
|
regs_set_return_msr(regs, (regs->msr & ~MSR_LE) | (MSR_KERNEL & MSR_LE));
|
|
|
|
return 0;
|
|
|
|
failed:
|
|
user_access_end();
|
|
|
|
badframe:
|
|
signal_fault(tsk, regs, "handle_rt_signal32", frame);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* OK, we're invoking a handler
|
|
*/
|
|
int handle_signal32(struct ksignal *ksig, sigset_t *oldset,
|
|
struct task_struct *tsk)
|
|
{
|
|
struct sigcontext __user *sc;
|
|
struct sigframe __user *frame;
|
|
struct mcontext __user *mctx;
|
|
struct mcontext __user *tm_mctx = NULL;
|
|
unsigned long newsp = 0;
|
|
unsigned long tramp;
|
|
struct pt_regs *regs = tsk->thread.regs;
|
|
/* Save the thread's msr before get_tm_stackpointer() changes it */
|
|
unsigned long msr = regs->msr;
|
|
|
|
/* Set up Signal Frame */
|
|
frame = get_sigframe(ksig, tsk, sizeof(*frame), 1);
|
|
mctx = &frame->mctx;
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
tm_mctx = &frame->mctx_transact;
|
|
#endif
|
|
if (MSR_TM_ACTIVE(msr))
|
|
prepare_save_tm_user_regs();
|
|
else
|
|
prepare_save_user_regs(1);
|
|
|
|
if (!user_access_begin(frame, sizeof(*frame)))
|
|
goto badframe;
|
|
sc = (struct sigcontext __user *) &frame->sctx;
|
|
|
|
#if _NSIG != 64
|
|
#error "Please adjust handle_signal()"
|
|
#endif
|
|
unsafe_put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler, failed);
|
|
unsafe_put_user(oldset->sig[0], &sc->oldmask, failed);
|
|
#ifdef CONFIG_PPC64
|
|
unsafe_put_user((oldset->sig[0] >> 32), &sc->_unused[3], failed);
|
|
#else
|
|
unsafe_put_user(oldset->sig[1], &sc->_unused[3], failed);
|
|
#endif
|
|
unsafe_put_user(to_user_ptr(mctx), &sc->regs, failed);
|
|
unsafe_put_user(ksig->sig, &sc->signal, failed);
|
|
|
|
if (MSR_TM_ACTIVE(msr))
|
|
unsafe_save_tm_user_regs(regs, mctx, tm_mctx, msr, failed);
|
|
else
|
|
unsafe_save_user_regs(regs, mctx, tm_mctx, 1, failed);
|
|
|
|
if (tsk->mm->context.vdso) {
|
|
tramp = VDSO32_SYMBOL(tsk->mm->context.vdso, sigtramp32);
|
|
} else {
|
|
tramp = (unsigned long)mctx->mc_pad;
|
|
unsafe_put_user(PPC_RAW_LI(_R0, __NR_sigreturn), &mctx->mc_pad[0], failed);
|
|
unsafe_put_user(PPC_RAW_SC(), &mctx->mc_pad[1], failed);
|
|
asm("dcbst %y0; sync; icbi %y0; sync" :: "Z" (mctx->mc_pad[0]));
|
|
}
|
|
user_access_end();
|
|
|
|
regs->link = tramp;
|
|
|
|
#ifdef CONFIG_PPC_FPU_REGS
|
|
tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
|
|
#endif
|
|
|
|
/* create a stack frame for the caller of the handler */
|
|
newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
|
|
if (put_user(regs->gpr[1], (u32 __user *)newsp))
|
|
goto badframe;
|
|
|
|
regs->gpr[1] = newsp;
|
|
regs->gpr[3] = ksig->sig;
|
|
regs->gpr[4] = (unsigned long) sc;
|
|
regs_set_return_ip(regs, (unsigned long) ksig->ka.sa.sa_handler);
|
|
/* enter the signal handler in native-endian mode */
|
|
regs_set_return_msr(regs, (regs->msr & ~MSR_LE) | (MSR_KERNEL & MSR_LE));
|
|
|
|
return 0;
|
|
|
|
failed:
|
|
user_access_end();
|
|
|
|
badframe:
|
|
signal_fault(tsk, regs, "handle_signal32", frame);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
|
|
{
|
|
sigset_t set;
|
|
struct mcontext __user *mcp;
|
|
|
|
if (!user_read_access_begin(ucp, sizeof(*ucp)))
|
|
return -EFAULT;
|
|
|
|
unsafe_get_sigset_t(&set, &ucp->uc_sigmask, failed);
|
|
#ifdef CONFIG_PPC64
|
|
{
|
|
u32 cmcp;
|
|
|
|
unsafe_get_user(cmcp, &ucp->uc_regs, failed);
|
|
mcp = (struct mcontext __user *)(u64)cmcp;
|
|
}
|
|
#else
|
|
unsafe_get_user(mcp, &ucp->uc_regs, failed);
|
|
#endif
|
|
user_read_access_end();
|
|
|
|
set_current_blocked(&set);
|
|
if (restore_user_regs(regs, mcp, sig))
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
failed:
|
|
user_read_access_end();
|
|
return -EFAULT;
|
|
}
|
|
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
static int do_setcontext_tm(struct ucontext __user *ucp,
|
|
struct ucontext __user *tm_ucp,
|
|
struct pt_regs *regs)
|
|
{
|
|
sigset_t set;
|
|
struct mcontext __user *mcp;
|
|
struct mcontext __user *tm_mcp;
|
|
u32 cmcp;
|
|
u32 tm_cmcp;
|
|
|
|
if (!user_read_access_begin(ucp, sizeof(*ucp)))
|
|
return -EFAULT;
|
|
|
|
unsafe_get_sigset_t(&set, &ucp->uc_sigmask, failed);
|
|
unsafe_get_user(cmcp, &ucp->uc_regs, failed);
|
|
|
|
user_read_access_end();
|
|
|
|
if (__get_user(tm_cmcp, &tm_ucp->uc_regs))
|
|
return -EFAULT;
|
|
mcp = (struct mcontext __user *)(u64)cmcp;
|
|
tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
|
|
/* no need to check access_ok(mcp), since mcp < 4GB */
|
|
|
|
set_current_blocked(&set);
|
|
if (restore_tm_user_regs(regs, mcp, tm_mcp))
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
failed:
|
|
user_read_access_end();
|
|
return -EFAULT;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_PPC64
|
|
COMPAT_SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
|
|
struct ucontext __user *, new_ctx, int, ctx_size)
|
|
#else
|
|
SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
|
|
struct ucontext __user *, new_ctx, long, ctx_size)
|
|
#endif
|
|
{
|
|
struct pt_regs *regs = current_pt_regs();
|
|
int ctx_has_vsx_region = 0;
|
|
|
|
#ifdef CONFIG_PPC64
|
|
unsigned long new_msr = 0;
|
|
|
|
if (new_ctx) {
|
|
struct mcontext __user *mcp;
|
|
u32 cmcp;
|
|
|
|
/*
|
|
* Get pointer to the real mcontext. No need for
|
|
* access_ok since we are dealing with compat
|
|
* pointers.
|
|
*/
|
|
if (__get_user(cmcp, &new_ctx->uc_regs))
|
|
return -EFAULT;
|
|
mcp = (struct mcontext __user *)(u64)cmcp;
|
|
if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
|
|
return -EFAULT;
|
|
}
|
|
/*
|
|
* Check that the context is not smaller than the original
|
|
* size (with VMX but without VSX)
|
|
*/
|
|
if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
|
|
return -EINVAL;
|
|
/*
|
|
* If the new context state sets the MSR VSX bits but
|
|
* it doesn't provide VSX state.
|
|
*/
|
|
if ((ctx_size < sizeof(struct ucontext)) &&
|
|
(new_msr & MSR_VSX))
|
|
return -EINVAL;
|
|
/* Does the context have enough room to store VSX data? */
|
|
if (ctx_size >= sizeof(struct ucontext))
|
|
ctx_has_vsx_region = 1;
|
|
#else
|
|
/* Context size is for future use. Right now, we only make sure
|
|
* we are passed something we understand
|
|
*/
|
|
if (ctx_size < sizeof(struct ucontext))
|
|
return -EINVAL;
|
|
#endif
|
|
if (old_ctx != NULL) {
|
|
struct mcontext __user *mctx;
|
|
|
|
/*
|
|
* old_ctx might not be 16-byte aligned, in which
|
|
* case old_ctx->uc_mcontext won't be either.
|
|
* Because we have the old_ctx->uc_pad2 field
|
|
* before old_ctx->uc_mcontext, we need to round down
|
|
* from &old_ctx->uc_mcontext to a 16-byte boundary.
|
|
*/
|
|
mctx = (struct mcontext __user *)
|
|
((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
|
|
prepare_save_user_regs(ctx_has_vsx_region);
|
|
if (!user_write_access_begin(old_ctx, ctx_size))
|
|
return -EFAULT;
|
|
unsafe_save_user_regs(regs, mctx, NULL, ctx_has_vsx_region, failed);
|
|
unsafe_put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked, failed);
|
|
unsafe_put_user(to_user_ptr(mctx), &old_ctx->uc_regs, failed);
|
|
user_write_access_end();
|
|
}
|
|
if (new_ctx == NULL)
|
|
return 0;
|
|
if (!access_ok(new_ctx, ctx_size) ||
|
|
fault_in_pages_readable((u8 __user *)new_ctx, ctx_size))
|
|
return -EFAULT;
|
|
|
|
/*
|
|
* If we get a fault copying the context into the kernel's
|
|
* image of the user's registers, we can't just return -EFAULT
|
|
* because the user's registers will be corrupted. For instance
|
|
* the NIP value may have been updated but not some of the
|
|
* other registers. Given that we have done the access_ok
|
|
* and successfully read the first and last bytes of the region
|
|
* above, this should only happen in an out-of-memory situation
|
|
* or if another thread unmaps the region containing the context.
|
|
* We kill the task with a SIGSEGV in this situation.
|
|
*/
|
|
if (do_setcontext(new_ctx, regs, 0))
|
|
do_exit(SIGSEGV);
|
|
|
|
set_thread_flag(TIF_RESTOREALL);
|
|
return 0;
|
|
|
|
failed:
|
|
user_write_access_end();
|
|
return -EFAULT;
|
|
}
|
|
|
|
#ifdef CONFIG_PPC64
|
|
COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
|
|
#else
|
|
SYSCALL_DEFINE0(rt_sigreturn)
|
|
#endif
|
|
{
|
|
struct rt_sigframe __user *rt_sf;
|
|
struct pt_regs *regs = current_pt_regs();
|
|
int tm_restore = 0;
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
struct ucontext __user *uc_transact;
|
|
unsigned long msr_hi;
|
|
unsigned long tmp;
|
|
#endif
|
|
/* Always make any pending restarted system calls return -EINTR */
|
|
current->restart_block.fn = do_no_restart_syscall;
|
|
|
|
rt_sf = (struct rt_sigframe __user *)
|
|
(regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
|
|
if (!access_ok(rt_sf, sizeof(*rt_sf)))
|
|
goto bad;
|
|
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
/*
|
|
* If there is a transactional state then throw it away.
|
|
* The purpose of a sigreturn is to destroy all traces of the
|
|
* signal frame, this includes any transactional state created
|
|
* within in. We only check for suspended as we can never be
|
|
* active in the kernel, we are active, there is nothing better to
|
|
* do than go ahead and Bad Thing later.
|
|
* The cause is not important as there will never be a
|
|
* recheckpoint so it's not user visible.
|
|
*/
|
|
if (MSR_TM_SUSPENDED(mfmsr()))
|
|
tm_reclaim_current(0);
|
|
|
|
if (__get_user(tmp, &rt_sf->uc.uc_link))
|
|
goto bad;
|
|
uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
|
|
if (uc_transact) {
|
|
u32 cmcp;
|
|
struct mcontext __user *mcp;
|
|
|
|
if (__get_user(cmcp, &uc_transact->uc_regs))
|
|
return -EFAULT;
|
|
mcp = (struct mcontext __user *)(u64)cmcp;
|
|
/* The top 32 bits of the MSR are stashed in the transactional
|
|
* ucontext. */
|
|
if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
|
|
goto bad;
|
|
|
|
if (MSR_TM_ACTIVE(msr_hi<<32)) {
|
|
/* Trying to start TM on non TM system */
|
|
if (!cpu_has_feature(CPU_FTR_TM))
|
|
goto bad;
|
|
/* We only recheckpoint on return if we're
|
|
* transaction.
|
|
*/
|
|
tm_restore = 1;
|
|
if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
|
|
goto bad;
|
|
}
|
|
}
|
|
if (!tm_restore) {
|
|
/*
|
|
* Unset regs->msr because ucontext MSR TS is not
|
|
* set, and recheckpoint was not called. This avoid
|
|
* hitting a TM Bad thing at RFID
|
|
*/
|
|
regs_set_return_msr(regs, regs->msr & ~MSR_TS_MASK);
|
|
}
|
|
/* Fall through, for non-TM restore */
|
|
#endif
|
|
if (!tm_restore)
|
|
if (do_setcontext(&rt_sf->uc, regs, 1))
|
|
goto bad;
|
|
|
|
/*
|
|
* It's not clear whether or why it is desirable to save the
|
|
* sigaltstack setting on signal delivery and restore it on
|
|
* signal return. But other architectures do this and we have
|
|
* always done it up until now so it is probably better not to
|
|
* change it. -- paulus
|
|
*/
|
|
#ifdef CONFIG_PPC64
|
|
if (compat_restore_altstack(&rt_sf->uc.uc_stack))
|
|
goto bad;
|
|
#else
|
|
if (restore_altstack(&rt_sf->uc.uc_stack))
|
|
goto bad;
|
|
#endif
|
|
set_thread_flag(TIF_RESTOREALL);
|
|
return 0;
|
|
|
|
bad:
|
|
signal_fault(current, regs, "sys_rt_sigreturn", rt_sf);
|
|
|
|
force_sig(SIGSEGV);
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_PPC32
|
|
SYSCALL_DEFINE3(debug_setcontext, struct ucontext __user *, ctx,
|
|
int, ndbg, struct sig_dbg_op __user *, dbg)
|
|
{
|
|
struct pt_regs *regs = current_pt_regs();
|
|
struct sig_dbg_op op;
|
|
int i;
|
|
unsigned long new_msr = regs->msr;
|
|
#ifdef CONFIG_PPC_ADV_DEBUG_REGS
|
|
unsigned long new_dbcr0 = current->thread.debug.dbcr0;
|
|
#endif
|
|
|
|
for (i=0; i<ndbg; i++) {
|
|
if (copy_from_user(&op, dbg + i, sizeof(op)))
|
|
return -EFAULT;
|
|
switch (op.dbg_type) {
|
|
case SIG_DBG_SINGLE_STEPPING:
|
|
#ifdef CONFIG_PPC_ADV_DEBUG_REGS
|
|
if (op.dbg_value) {
|
|
new_msr |= MSR_DE;
|
|
new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
|
|
} else {
|
|
new_dbcr0 &= ~DBCR0_IC;
|
|
if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
|
|
current->thread.debug.dbcr1)) {
|
|
new_msr &= ~MSR_DE;
|
|
new_dbcr0 &= ~DBCR0_IDM;
|
|
}
|
|
}
|
|
#else
|
|
if (op.dbg_value)
|
|
new_msr |= MSR_SE;
|
|
else
|
|
new_msr &= ~MSR_SE;
|
|
#endif
|
|
break;
|
|
case SIG_DBG_BRANCH_TRACING:
|
|
#ifdef CONFIG_PPC_ADV_DEBUG_REGS
|
|
return -EINVAL;
|
|
#else
|
|
if (op.dbg_value)
|
|
new_msr |= MSR_BE;
|
|
else
|
|
new_msr &= ~MSR_BE;
|
|
#endif
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
/* We wait until here to actually install the values in the
|
|
registers so if we fail in the above loop, it will not
|
|
affect the contents of these registers. After this point,
|
|
failure is a problem, anyway, and it's very unlikely unless
|
|
the user is really doing something wrong. */
|
|
regs_set_return_msr(regs, new_msr);
|
|
#ifdef CONFIG_PPC_ADV_DEBUG_REGS
|
|
current->thread.debug.dbcr0 = new_dbcr0;
|
|
#endif
|
|
|
|
if (!access_ok(ctx, sizeof(*ctx)) ||
|
|
fault_in_pages_readable((u8 __user *)ctx, sizeof(*ctx)))
|
|
return -EFAULT;
|
|
|
|
/*
|
|
* If we get a fault copying the context into the kernel's
|
|
* image of the user's registers, we can't just return -EFAULT
|
|
* because the user's registers will be corrupted. For instance
|
|
* the NIP value may have been updated but not some of the
|
|
* other registers. Given that we have done the access_ok
|
|
* and successfully read the first and last bytes of the region
|
|
* above, this should only happen in an out-of-memory situation
|
|
* or if another thread unmaps the region containing the context.
|
|
* We kill the task with a SIGSEGV in this situation.
|
|
*/
|
|
if (do_setcontext(ctx, regs, 1)) {
|
|
signal_fault(current, regs, "sys_debug_setcontext", ctx);
|
|
|
|
force_sig(SIGSEGV);
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* It's not clear whether or why it is desirable to save the
|
|
* sigaltstack setting on signal delivery and restore it on
|
|
* signal return. But other architectures do this and we have
|
|
* always done it up until now so it is probably better not to
|
|
* change it. -- paulus
|
|
*/
|
|
restore_altstack(&ctx->uc_stack);
|
|
|
|
set_thread_flag(TIF_RESTOREALL);
|
|
out:
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Do a signal return; undo the signal stack.
|
|
*/
|
|
#ifdef CONFIG_PPC64
|
|
COMPAT_SYSCALL_DEFINE0(sigreturn)
|
|
#else
|
|
SYSCALL_DEFINE0(sigreturn)
|
|
#endif
|
|
{
|
|
struct pt_regs *regs = current_pt_regs();
|
|
struct sigframe __user *sf;
|
|
struct sigcontext __user *sc;
|
|
struct sigcontext sigctx;
|
|
struct mcontext __user *sr;
|
|
sigset_t set;
|
|
struct mcontext __user *mcp;
|
|
struct mcontext __user *tm_mcp = NULL;
|
|
unsigned long long msr_hi = 0;
|
|
|
|
/* Always make any pending restarted system calls return -EINTR */
|
|
current->restart_block.fn = do_no_restart_syscall;
|
|
|
|
sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
|
|
sc = &sf->sctx;
|
|
if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
|
|
goto badframe;
|
|
|
|
#ifdef CONFIG_PPC64
|
|
/*
|
|
* Note that PPC32 puts the upper 32 bits of the sigmask in the
|
|
* unused part of the signal stackframe
|
|
*/
|
|
set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
|
|
#else
|
|
set.sig[0] = sigctx.oldmask;
|
|
set.sig[1] = sigctx._unused[3];
|
|
#endif
|
|
set_current_blocked(&set);
|
|
|
|
mcp = (struct mcontext __user *)&sf->mctx;
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
|
|
if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
|
|
goto badframe;
|
|
#endif
|
|
if (MSR_TM_ACTIVE(msr_hi<<32)) {
|
|
if (!cpu_has_feature(CPU_FTR_TM))
|
|
goto badframe;
|
|
if (restore_tm_user_regs(regs, mcp, tm_mcp))
|
|
goto badframe;
|
|
} else {
|
|
sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
|
|
if (restore_user_regs(regs, sr, 1)) {
|
|
signal_fault(current, regs, "sys_sigreturn", sr);
|
|
|
|
force_sig(SIGSEGV);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
set_thread_flag(TIF_RESTOREALL);
|
|
return 0;
|
|
|
|
badframe:
|
|
signal_fault(current, regs, "sys_sigreturn", sc);
|
|
|
|
force_sig(SIGSEGV);
|
|
return 0;
|
|
}
|