2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* PowerPC version
|
|
|
|
* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
|
|
|
|
*
|
|
|
|
* Derived from "arch/i386/kernel/signal.c"
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
* 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#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/wait.h>
|
|
|
|
#include <linux/unistd.h>
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/elf.h>
|
|
|
|
#include <linux/ptrace.h>
|
2011-06-04 05:36:54 +00:00
|
|
|
#include <linux/ratelimit.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <asm/sigcontext.h>
|
|
|
|
#include <asm/ucontext.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/unistd.h>
|
|
|
|
#include <asm/cacheflush.h>
|
2006-03-22 23:00:08 +00:00
|
|
|
#include <asm/syscalls.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/vdso.h>
|
2012-03-28 17:30:02 +00:00
|
|
|
#include <asm/switch_to.h>
|
2013-02-13 16:21:41 +00:00
|
|
|
#include <asm/tm.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-06-04 05:15:49 +00:00
|
|
|
#include "signal.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
2005-05-06 02:10:04 +00:00
|
|
|
#define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
|
2005-04-16 22:20:36 +00:00
|
|
|
#define FP_REGS_SIZE sizeof(elf_fpregset_t)
|
|
|
|
|
|
|
|
#define TRAMP_TRACEBACK 3
|
|
|
|
#define TRAMP_SIZE 6
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When we have signals to deliver, we set up on the user stack,
|
|
|
|
* going down from the original stack pointer:
|
|
|
|
* 1) a rt_sigframe struct which contains the ucontext
|
|
|
|
* 2) a gap of __SIGNAL_FRAMESIZE bytes which acts as a dummy caller
|
|
|
|
* frame for the signal handler.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct rt_sigframe {
|
|
|
|
/* sys_rt_sigreturn requires the ucontext be the first field */
|
|
|
|
struct ucontext uc;
|
2013-02-13 16:21:41 +00:00
|
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
|
|
struct ucontext uc_transact;
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long _unused[2];
|
|
|
|
unsigned int tramp[TRAMP_SIZE];
|
2006-02-01 10:28:09 +00:00
|
|
|
struct siginfo __user *pinfo;
|
|
|
|
void __user *puc;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct siginfo info;
|
2014-02-26 06:07:38 +00:00
|
|
|
/* New 64 bit little-endian ABI allows redzone of 512 bytes below sp */
|
|
|
|
char abigap[USER_REDZONE_SIZE];
|
2005-04-16 22:20:36 +00:00
|
|
|
} __attribute__ ((aligned (16)));
|
|
|
|
|
2007-10-12 00:20:07 +00:00
|
|
|
static const char fmt32[] = KERN_INFO \
|
|
|
|
"%s[%d]: bad frame in %s: %08lx nip %08lx lr %08lx\n";
|
|
|
|
static const char fmt64[] = KERN_INFO \
|
|
|
|
"%s[%d]: bad frame in %s: %016lx nip %016lx lr %016lx\n";
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Set up the sigcontext for the signal frame.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static long setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
|
2008-10-23 00:42:36 +00:00
|
|
|
int signr, sigset_t *set, unsigned long handler,
|
|
|
|
int ctx_has_vsx_region)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
/* When CONFIG_ALTIVEC is set, we _always_ setup v_regs even if the
|
|
|
|
* process never used altivec yet (MSR_VEC is zero in pt_regs of
|
|
|
|
* the context). This is very important because we must ensure we
|
|
|
|
* don't lose the VRSAVE content that may have been set prior to
|
|
|
|
* the process doing its first vector operation
|
2012-09-20 01:48:00 +00:00
|
|
|
* Userland shall check AT_HWCAP to know whether it can rely on the
|
2005-04-16 22:20:36 +00:00
|
|
|
* v_regs pointer or not
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
elf_vrreg_t __user *v_regs = (elf_vrreg_t __user *)(((unsigned long)sc->vmx_reserve + 15) & ~0xful);
|
|
|
|
#endif
|
2008-06-02 06:22:59 +00:00
|
|
|
unsigned long msr = regs->msr;
|
2005-04-16 22:20:36 +00:00
|
|
|
long err = 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
err |= __put_user(v_regs, &sc->v_regs);
|
|
|
|
|
|
|
|
/* save altivec registers */
|
|
|
|
if (current->thread.used_vr) {
|
|
|
|
flush_altivec_to_thread(current);
|
|
|
|
/* Copy 33 vec registers (vr0..31 and vscr) to the stack */
|
2013-09-10 10:20:42 +00:00
|
|
|
err |= __copy_to_user(v_regs, ¤t->thread.vr_state,
|
|
|
|
33 * sizeof(vector128));
|
2005-04-16 22:20:36 +00:00
|
|
|
/* set MSR_VEC in the MSR value in the frame to indicate that sc->v_reg)
|
|
|
|
* contains valid data.
|
|
|
|
*/
|
2008-06-02 06:22:59 +00:00
|
|
|
msr |= MSR_VEC;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
/* We always copy to/from vrsave, it's 0 if we don't have or don't
|
|
|
|
* use altivec.
|
|
|
|
*/
|
2013-08-05 04:13:16 +00:00
|
|
|
if (cpu_has_feature(CPU_FTR_ALTIVEC))
|
|
|
|
current->thread.vrsave = mfspr(SPRN_VRSAVE);
|
2005-04-16 22:20:36 +00:00
|
|
|
err |= __put_user(current->thread.vrsave, (u32 __user *)&v_regs[33]);
|
|
|
|
#else /* CONFIG_ALTIVEC */
|
|
|
|
err |= __put_user(0, &sc->v_regs);
|
|
|
|
#endif /* CONFIG_ALTIVEC */
|
2008-06-25 04:07:18 +00:00
|
|
|
flush_fp_to_thread(current);
|
2008-07-02 04:06:37 +00:00
|
|
|
/* copy fpr regs and fpscr */
|
|
|
|
err |= copy_fpr_to_user(&sc->fp_regs, current);
|
2013-11-25 00:12:20 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
2008-06-25 04:07:18 +00:00
|
|
|
#ifdef CONFIG_VSX
|
2008-06-25 04:07:18 +00:00
|
|
|
/*
|
|
|
|
* Copy VSX low doubleword to local buffer for formatting,
|
|
|
|
* then out to userspace. Update v_regs to point after the
|
|
|
|
* VMX data.
|
|
|
|
*/
|
2008-10-23 00:42:36 +00:00
|
|
|
if (current->thread.used_vsr && ctx_has_vsx_region) {
|
2008-07-11 06:29:12 +00:00
|
|
|
__giveup_vsx(current);
|
2008-06-25 04:07:18 +00:00
|
|
|
v_regs += ELF_NVRREG;
|
2008-07-02 04:06:37 +00:00
|
|
|
err |= copy_vsx_to_user(v_regs, current);
|
2008-06-25 04:07:18 +00:00
|
|
|
/* set MSR_VSX in the MSR value in the frame to
|
|
|
|
* indicate that sc->vs_reg) contains valid data.
|
|
|
|
*/
|
|
|
|
msr |= MSR_VSX;
|
|
|
|
}
|
2008-06-25 04:07:18 +00:00
|
|
|
#endif /* CONFIG_VSX */
|
2005-04-16 22:20:36 +00:00
|
|
|
err |= __put_user(&sc->gp_regs, &sc->regs);
|
2006-03-08 02:24:22 +00:00
|
|
|
WARN_ON(!FULL_REGS(regs));
|
2005-04-16 22:20:36 +00:00
|
|
|
err |= __copy_to_user(&sc->gp_regs, regs, GP_REGS_SIZE);
|
2008-06-02 06:22:59 +00:00
|
|
|
err |= __put_user(msr, &sc->gp_regs[PT_MSR]);
|
2005-04-16 22:20:36 +00:00
|
|
|
err |= __put_user(signr, &sc->signal);
|
|
|
|
err |= __put_user(handler, &sc->handler);
|
|
|
|
if (set != NULL)
|
|
|
|
err |= __put_user(set->sig[0], &sc->oldmask);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-02-13 16:21:41 +00:00
|
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
|
|
/*
|
|
|
|
* As above, but Transactional Memory is in use, so deliver sigcontexts
|
|
|
|
* containing checkpointed and transactional register states.
|
|
|
|
*
|
2013-05-26 18:09:41 +00:00
|
|
|
* To do this, we treclaim (done before entering here) to gather both sets of
|
|
|
|
* registers and set up the 'normal' sigcontext registers with rolled-back
|
|
|
|
* register values such that a simple signal handler sees a correct
|
|
|
|
* checkpointed register state. If interested, a TM-aware sighandler can
|
|
|
|
* examine the transactional registers in the 2nd sigcontext to determine the
|
|
|
|
* real origin of the signal.
|
2013-02-13 16:21:41 +00:00
|
|
|
*/
|
|
|
|
static long setup_tm_sigcontexts(struct sigcontext __user *sc,
|
|
|
|
struct sigcontext __user *tm_sc,
|
|
|
|
struct pt_regs *regs,
|
|
|
|
int signr, sigset_t *set, unsigned long handler)
|
|
|
|
{
|
|
|
|
/* When CONFIG_ALTIVEC is set, we _always_ setup v_regs even if the
|
|
|
|
* process never used altivec yet (MSR_VEC is zero in pt_regs of
|
|
|
|
* the context). This is very important because we must ensure we
|
|
|
|
* don't lose the VRSAVE content that may have been set prior to
|
|
|
|
* the process doing its first vector operation
|
|
|
|
* Userland shall check AT_HWCAP to know wether it can rely on the
|
|
|
|
* v_regs pointer or not.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
elf_vrreg_t __user *v_regs = (elf_vrreg_t __user *)
|
|
|
|
(((unsigned long)sc->vmx_reserve + 15) & ~0xful);
|
|
|
|
elf_vrreg_t __user *tm_v_regs = (elf_vrreg_t __user *)
|
|
|
|
(((unsigned long)tm_sc->vmx_reserve + 15) & ~0xful);
|
|
|
|
#endif
|
|
|
|
unsigned long msr = regs->msr;
|
|
|
|
long err = 0;
|
|
|
|
|
|
|
|
BUG_ON(!MSR_TM_ACTIVE(regs->msr));
|
|
|
|
|
powerpc: Don't corrupt transactional state when using FP/VMX in kernel
Currently, when we have a process using the transactional memory
facilities on POWER8 (that is, the processor is in transactional
or suspended state), and the process enters the kernel and the
kernel then uses the floating-point or vector (VMX/Altivec) facility,
we end up corrupting the user-visible FP/VMX/VSX state. This
happens, for example, if a page fault causes a copy-on-write
operation, because the copy_page function will use VMX to do the
copy on POWER8. The test program below demonstrates the bug.
The bug happens because when FP/VMX state for a transactional process
is stored in the thread_struct, we store the checkpointed state in
.fp_state/.vr_state and the transactional (current) state in
.transact_fp/.transact_vr. However, when the kernel wants to use
FP/VMX, it calls enable_kernel_fp() or enable_kernel_altivec(),
which saves the current state in .fp_state/.vr_state. Furthermore,
when we return to the user process we return with FP/VMX/VSX
disabled. The next time the process uses FP/VMX/VSX, we don't know
which set of state (the current register values, .fp_state/.vr_state,
or .transact_fp/.transact_vr) we should be using, since we have no
way to tell if we are still in the same transaction, and if not,
whether the previous transaction succeeded or failed.
Thus it is necessary to strictly adhere to the rule that if FP has
been enabled at any point in a transaction, we must keep FP enabled
for the user process with the current transactional state in the
FP registers, until we detect that it is no longer in a transaction.
Similarly for VMX; once enabled it must stay enabled until the
process is no longer transactional.
In order to keep this rule, we add a new thread_info flag which we
test when returning from the kernel to userspace, called TIF_RESTORE_TM.
This flag indicates that there is FP/VMX/VSX state to be restored
before entering userspace, and when it is set the .tm_orig_msr field
in the thread_struct indicates what state needs to be restored.
The restoration is done by restore_tm_state(). The TIF_RESTORE_TM
bit is set by new giveup_fpu/altivec_maybe_transactional helpers,
which are called from enable_kernel_fp/altivec, giveup_vsx, and
flush_fp/altivec_to_thread instead of giveup_fpu/altivec.
The other thing to be done is to get the transactional FP/VMX/VSX
state from .fp_state/.vr_state when doing reclaim, if that state
has been saved there by giveup_fpu/altivec_maybe_transactional.
Having done this, we set the FP/VMX bit in the thread's MSR after
reclaim to indicate that that part of the state is now valid
(having been reclaimed from the processor's checkpointed state).
Finally, in the signal handling code, we move the clearing of the
transactional state bits in the thread's MSR a bit earlier, before
calling flush_fp_to_thread(), so that we don't unnecessarily set
the TIF_RESTORE_TM bit.
This is the test program:
/* Michael Neuling 4/12/2013
*
* See if the altivec state is leaked out of an aborted transaction due to
* kernel vmx copy loops.
*
* gcc -m64 htm_vmxcopy.c -o htm_vmxcopy
*
*/
/* We don't use all of these, but for reference: */
int main(int argc, char *argv[])
{
long double vecin = 1.3;
long double vecout;
unsigned long pgsize = getpagesize();
int i;
int fd;
int size = pgsize*16;
char tmpfile[] = "/tmp/page_faultXXXXXX";
char buf[pgsize];
char *a;
uint64_t aborted = 0;
fd = mkstemp(tmpfile);
assert(fd >= 0);
memset(buf, 0, pgsize);
for (i = 0; i < size; i += pgsize)
assert(write(fd, buf, pgsize) == pgsize);
unlink(tmpfile);
a = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
assert(a != MAP_FAILED);
asm __volatile__(
"lxvd2x 40,0,%[vecinptr] ; " // set 40 to initial value
TBEGIN
"beq 3f ;"
TSUSPEND
"xxlxor 40,40,40 ; " // set 40 to 0
"std 5, 0(%[map]) ;" // cause kernel vmx copy page
TABORT
TRESUME
TEND
"li %[res], 0 ;"
"b 5f ;"
"3: ;" // Abort handler
"li %[res], 1 ;"
"5: ;"
"stxvd2x 40,0,%[vecoutptr] ; "
: [res]"=r"(aborted)
: [vecinptr]"r"(&vecin),
[vecoutptr]"r"(&vecout),
[map]"r"(a)
: "memory", "r0", "r3", "r4", "r5", "r6", "r7");
if (aborted && (vecin != vecout)){
printf("FAILED: vector state leaked on abort %f != %f\n",
(double)vecin, (double)vecout);
exit(1);
}
munmap(a, size);
close(fd);
printf("PASSED!\n");
return 0;
}
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-01-13 04:56:29 +00:00
|
|
|
/* Remove TM bits from thread's MSR. The MSR in the sigcontext
|
|
|
|
* just indicates to userland that we were doing a transaction, but we
|
|
|
|
* don't want to return in transactional state. This also ensures
|
|
|
|
* that flush_fp_to_thread won't set TIF_RESTORE_TM again.
|
|
|
|
*/
|
|
|
|
regs->msr &= ~MSR_TS_MASK;
|
|
|
|
|
2013-02-13 16:21:41 +00:00
|
|
|
flush_fp_to_thread(current);
|
|
|
|
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
err |= __put_user(v_regs, &sc->v_regs);
|
|
|
|
err |= __put_user(tm_v_regs, &tm_sc->v_regs);
|
|
|
|
|
|
|
|
/* save altivec registers */
|
|
|
|
if (current->thread.used_vr) {
|
|
|
|
flush_altivec_to_thread(current);
|
|
|
|
/* Copy 33 vec registers (vr0..31 and vscr) to the stack */
|
2013-09-10 10:20:42 +00:00
|
|
|
err |= __copy_to_user(v_regs, ¤t->thread.vr_state,
|
2013-02-13 16:21:41 +00:00
|
|
|
33 * sizeof(vector128));
|
|
|
|
/* If VEC was enabled there are transactional VRs valid too,
|
|
|
|
* else they're a copy of the checkpointed VRs.
|
|
|
|
*/
|
|
|
|
if (msr & MSR_VEC)
|
|
|
|
err |= __copy_to_user(tm_v_regs,
|
2013-09-10 10:20:42 +00:00
|
|
|
¤t->thread.transact_vr,
|
2013-02-13 16:21:41 +00:00
|
|
|
33 * sizeof(vector128));
|
|
|
|
else
|
|
|
|
err |= __copy_to_user(tm_v_regs,
|
2013-09-10 10:20:42 +00:00
|
|
|
¤t->thread.vr_state,
|
2013-02-13 16:21:41 +00:00
|
|
|
33 * sizeof(vector128));
|
|
|
|
|
|
|
|
/* set MSR_VEC in the MSR value in the frame to indicate
|
|
|
|
* that sc->v_reg 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.
|
|
|
|
*/
|
2013-08-05 04:13:16 +00:00
|
|
|
if (cpu_has_feature(CPU_FTR_ALTIVEC))
|
|
|
|
current->thread.vrsave = mfspr(SPRN_VRSAVE);
|
2013-02-13 16:21:41 +00:00
|
|
|
err |= __put_user(current->thread.vrsave, (u32 __user *)&v_regs[33]);
|
|
|
|
if (msr & MSR_VEC)
|
|
|
|
err |= __put_user(current->thread.transact_vrsave,
|
|
|
|
(u32 __user *)&tm_v_regs[33]);
|
|
|
|
else
|
|
|
|
err |= __put_user(current->thread.vrsave,
|
|
|
|
(u32 __user *)&tm_v_regs[33]);
|
|
|
|
|
|
|
|
#else /* CONFIG_ALTIVEC */
|
|
|
|
err |= __put_user(0, &sc->v_regs);
|
|
|
|
err |= __put_user(0, &tm_sc->v_regs);
|
|
|
|
#endif /* CONFIG_ALTIVEC */
|
|
|
|
|
|
|
|
/* copy fpr regs and fpscr */
|
|
|
|
err |= copy_fpr_to_user(&sc->fp_regs, current);
|
|
|
|
if (msr & MSR_FP)
|
|
|
|
err |= copy_transact_fpr_to_user(&tm_sc->fp_regs, current);
|
|
|
|
else
|
|
|
|
err |= copy_fpr_to_user(&tm_sc->fp_regs, current);
|
|
|
|
|
|
|
|
#ifdef CONFIG_VSX
|
|
|
|
/*
|
|
|
|
* Copy VSX low doubleword to local buffer for formatting,
|
|
|
|
* then out to userspace. Update v_regs to point after the
|
|
|
|
* VMX data.
|
|
|
|
*/
|
|
|
|
if (current->thread.used_vsr) {
|
|
|
|
__giveup_vsx(current);
|
|
|
|
v_regs += ELF_NVRREG;
|
|
|
|
tm_v_regs += ELF_NVRREG;
|
|
|
|
|
|
|
|
err |= copy_vsx_to_user(v_regs, current);
|
|
|
|
|
|
|
|
if (msr & MSR_VSX)
|
|
|
|
err |= copy_transact_vsx_to_user(tm_v_regs, current);
|
|
|
|
else
|
|
|
|
err |= copy_vsx_to_user(tm_v_regs, current);
|
|
|
|
|
|
|
|
/* set MSR_VSX in the MSR value in the frame to
|
|
|
|
* indicate that sc->vs_reg) contains valid data.
|
|
|
|
*/
|
|
|
|
msr |= MSR_VSX;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_VSX */
|
|
|
|
|
|
|
|
err |= __put_user(&sc->gp_regs, &sc->regs);
|
|
|
|
err |= __put_user(&tm_sc->gp_regs, &tm_sc->regs);
|
|
|
|
WARN_ON(!FULL_REGS(regs));
|
|
|
|
err |= __copy_to_user(&tm_sc->gp_regs, regs, GP_REGS_SIZE);
|
|
|
|
err |= __copy_to_user(&sc->gp_regs,
|
|
|
|
¤t->thread.ckpt_regs, GP_REGS_SIZE);
|
|
|
|
err |= __put_user(msr, &tm_sc->gp_regs[PT_MSR]);
|
|
|
|
err |= __put_user(msr, &sc->gp_regs[PT_MSR]);
|
|
|
|
err |= __put_user(signr, &sc->signal);
|
|
|
|
err |= __put_user(handler, &sc->handler);
|
|
|
|
if (set != NULL)
|
|
|
|
err |= __put_user(set->sig[0], &sc->oldmask);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Restore the sigcontext from the signal frame.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static long restore_sigcontext(struct pt_regs *regs, sigset_t *set, int sig,
|
|
|
|
struct sigcontext __user *sc)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
elf_vrreg_t __user *v_regs;
|
|
|
|
#endif
|
|
|
|
unsigned long err = 0;
|
|
|
|
unsigned long save_r13 = 0;
|
|
|
|
unsigned long msr;
|
2008-07-02 04:06:37 +00:00
|
|
|
#ifdef CONFIG_VSX
|
|
|
|
int i;
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* If this is not a signal return, we preserve the TLS in r13 */
|
|
|
|
if (!sig)
|
|
|
|
save_r13 = regs->gpr[13];
|
|
|
|
|
2008-06-27 06:18:27 +00:00
|
|
|
/* copy the GPRs */
|
|
|
|
err |= __copy_from_user(regs->gpr, sc->gp_regs, sizeof(regs->gpr));
|
|
|
|
err |= __get_user(regs->nip, &sc->gp_regs[PT_NIP]);
|
2006-06-07 06:14:40 +00:00
|
|
|
/* get MSR separately, transfer the LE bit if doing signal return */
|
|
|
|
err |= __get_user(msr, &sc->gp_regs[PT_MSR]);
|
|
|
|
if (sig)
|
|
|
|
regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
|
2008-06-27 06:18:27 +00:00
|
|
|
err |= __get_user(regs->orig_gpr3, &sc->gp_regs[PT_ORIG_R3]);
|
|
|
|
err |= __get_user(regs->ctr, &sc->gp_regs[PT_CTR]);
|
|
|
|
err |= __get_user(regs->link, &sc->gp_regs[PT_LNK]);
|
|
|
|
err |= __get_user(regs->xer, &sc->gp_regs[PT_XER]);
|
|
|
|
err |= __get_user(regs->ccr, &sc->gp_regs[PT_CCR]);
|
2006-06-07 06:14:40 +00:00
|
|
|
/* skip SOFTE */
|
2010-09-20 20:48:57 +00:00
|
|
|
regs->trap = 0;
|
2008-06-27 06:18:27 +00:00
|
|
|
err |= __get_user(regs->dar, &sc->gp_regs[PT_DAR]);
|
|
|
|
err |= __get_user(regs->dsisr, &sc->gp_regs[PT_DSISR]);
|
|
|
|
err |= __get_user(regs->result, &sc->gp_regs[PT_RESULT]);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!sig)
|
|
|
|
regs->gpr[13] = save_r13;
|
|
|
|
if (set != NULL)
|
|
|
|
err |= __get_user(set->sig[0], &sc->oldmask);
|
|
|
|
|
2006-01-11 11:11:39 +00:00
|
|
|
/*
|
|
|
|
* Do this before updating the thread state in
|
|
|
|
* current->thread.fpr/vr. That way, if we get preempted
|
|
|
|
* and another task grabs the FPU/Altivec, it won't be
|
|
|
|
* tempted to save the current CPU state into the thread_struct
|
|
|
|
* and corrupt what we are writing there.
|
|
|
|
*/
|
|
|
|
discard_lazy_cpu_state();
|
|
|
|
|
2007-06-26 04:49:11 +00:00
|
|
|
/*
|
|
|
|
* Force reload of FP/VEC.
|
|
|
|
* This has to be done before copying stuff into current->thread.fpr/vr
|
|
|
|
* for the reasons explained in the previous comment.
|
|
|
|
*/
|
2008-06-25 04:07:18 +00:00
|
|
|
regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1 | MSR_VEC | MSR_VSX);
|
2007-06-26 04:49:11 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
err |= __get_user(v_regs, &sc->v_regs);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2006-06-09 03:02:59 +00:00
|
|
|
if (v_regs && !access_ok(VERIFY_READ, v_regs, 34 * sizeof(vector128)))
|
|
|
|
return -EFAULT;
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Copy 33 vec registers (vr0..31 and vscr) from the stack */
|
2013-08-06 16:01:24 +00:00
|
|
|
if (v_regs != NULL && (msr & MSR_VEC) != 0)
|
2013-09-10 10:20:42 +00:00
|
|
|
err |= __copy_from_user(¤t->thread.vr_state, v_regs,
|
2005-04-16 22:20:36 +00:00
|
|
|
33 * sizeof(vector128));
|
|
|
|
else if (current->thread.used_vr)
|
2013-09-10 10:20:42 +00:00
|
|
|
memset(¤t->thread.vr_state, 0, 33 * sizeof(vector128));
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Always get VRSAVE back */
|
2013-08-06 16:01:24 +00:00
|
|
|
if (v_regs != NULL)
|
2005-04-16 22:20:36 +00:00
|
|
|
err |= __get_user(current->thread.vrsave, (u32 __user *)&v_regs[33]);
|
|
|
|
else
|
|
|
|
current->thread.vrsave = 0;
|
2013-08-05 04:13:16 +00:00
|
|
|
if (cpu_has_feature(CPU_FTR_ALTIVEC))
|
|
|
|
mtspr(SPRN_VRSAVE, current->thread.vrsave);
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* CONFIG_ALTIVEC */
|
2008-06-25 04:07:18 +00:00
|
|
|
/* restore floating point */
|
2008-07-02 04:06:37 +00:00
|
|
|
err |= copy_fpr_from_user(current, &sc->fp_regs);
|
|
|
|
#ifdef CONFIG_VSX
|
2008-06-25 04:07:18 +00:00
|
|
|
/*
|
|
|
|
* Get additional VSX data. Update v_regs to point after the
|
|
|
|
* VMX data. Copy VSX low doubleword from userspace to local
|
|
|
|
* buffer for formatting, then into the taskstruct.
|
|
|
|
*/
|
|
|
|
v_regs += ELF_NVRREG;
|
|
|
|
if ((msr & MSR_VSX) != 0)
|
2008-07-02 04:06:37 +00:00
|
|
|
err |= copy_vsx_from_user(current, v_regs);
|
2008-06-25 04:07:18 +00:00
|
|
|
else
|
2008-07-02 04:06:37 +00:00
|
|
|
for (i = 0; i < 32 ; i++)
|
2013-09-10 10:20:42 +00:00
|
|
|
current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
|
2008-06-25 04:07:18 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-02-13 16:21:41 +00:00
|
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
|
|
/*
|
|
|
|
* Restore the two sigcontexts from the frame of a transactional processes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static long restore_tm_sigcontexts(struct pt_regs *regs,
|
|
|
|
struct sigcontext __user *sc,
|
|
|
|
struct sigcontext __user *tm_sc)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
elf_vrreg_t __user *v_regs, *tm_v_regs;
|
|
|
|
#endif
|
|
|
|
unsigned long err = 0;
|
|
|
|
unsigned long msr;
|
|
|
|
#ifdef CONFIG_VSX
|
|
|
|
int i;
|
|
|
|
#endif
|
|
|
|
/* copy the GPRs */
|
|
|
|
err |= __copy_from_user(regs->gpr, tm_sc->gp_regs, sizeof(regs->gpr));
|
|
|
|
err |= __copy_from_user(¤t->thread.ckpt_regs, sc->gp_regs,
|
|
|
|
sizeof(regs->gpr));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TFHAR is restored from the checkpointed 'wound-back' ucontext's NIP.
|
|
|
|
* TEXASR was set by the signal delivery reclaim, as was TFIAR.
|
|
|
|
* Users doing anything abhorrent like thread-switching w/ signals for
|
|
|
|
* TM-Suspended code will have to back TEXASR/TFIAR up themselves.
|
|
|
|
* For the case of getting a signal and simply returning from it,
|
|
|
|
* we don't need to re-copy them here.
|
|
|
|
*/
|
|
|
|
err |= __get_user(regs->nip, &tm_sc->gp_regs[PT_NIP]);
|
|
|
|
err |= __get_user(current->thread.tm_tfhar, &sc->gp_regs[PT_NIP]);
|
|
|
|
|
|
|
|
/* get MSR separately, transfer the LE bit if doing signal return */
|
|
|
|
err |= __get_user(msr, &sc->gp_regs[PT_MSR]);
|
2013-06-09 11:23:19 +00:00
|
|
|
/* pull in MSR TM from user context */
|
|
|
|
regs->msr = (regs->msr & ~MSR_TS_MASK) | (msr & MSR_TS_MASK);
|
|
|
|
|
|
|
|
/* pull in MSR LE from user context */
|
2013-02-13 16:21:41 +00:00
|
|
|
regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
|
|
|
|
|
|
|
|
/* The following non-GPR non-FPR non-VR state is also checkpointed: */
|
|
|
|
err |= __get_user(regs->ctr, &tm_sc->gp_regs[PT_CTR]);
|
|
|
|
err |= __get_user(regs->link, &tm_sc->gp_regs[PT_LNK]);
|
|
|
|
err |= __get_user(regs->xer, &tm_sc->gp_regs[PT_XER]);
|
|
|
|
err |= __get_user(regs->ccr, &tm_sc->gp_regs[PT_CCR]);
|
|
|
|
err |= __get_user(current->thread.ckpt_regs.ctr,
|
|
|
|
&sc->gp_regs[PT_CTR]);
|
|
|
|
err |= __get_user(current->thread.ckpt_regs.link,
|
|
|
|
&sc->gp_regs[PT_LNK]);
|
|
|
|
err |= __get_user(current->thread.ckpt_regs.xer,
|
|
|
|
&sc->gp_regs[PT_XER]);
|
|
|
|
err |= __get_user(current->thread.ckpt_regs.ccr,
|
|
|
|
&sc->gp_regs[PT_CCR]);
|
|
|
|
|
|
|
|
/* These regs are not checkpointed; they can go in 'regs'. */
|
|
|
|
err |= __get_user(regs->trap, &sc->gp_regs[PT_TRAP]);
|
|
|
|
err |= __get_user(regs->dar, &sc->gp_regs[PT_DAR]);
|
|
|
|
err |= __get_user(regs->dsisr, &sc->gp_regs[PT_DSISR]);
|
|
|
|
err |= __get_user(regs->result, &sc->gp_regs[PT_RESULT]);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do this before updating the thread state in
|
|
|
|
* current->thread.fpr/vr. That way, if we get preempted
|
|
|
|
* and another task grabs the FPU/Altivec, it won't be
|
|
|
|
* tempted to save the current CPU state into the thread_struct
|
|
|
|
* and corrupt what we are writing there.
|
|
|
|
*/
|
|
|
|
discard_lazy_cpu_state();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Force reload of FP/VEC.
|
|
|
|
* This has to be done before copying stuff into current->thread.fpr/vr
|
|
|
|
* for the reasons explained in the previous comment.
|
|
|
|
*/
|
|
|
|
regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1 | MSR_VEC | MSR_VSX);
|
|
|
|
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
err |= __get_user(v_regs, &sc->v_regs);
|
|
|
|
err |= __get_user(tm_v_regs, &tm_sc->v_regs);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
if (v_regs && !access_ok(VERIFY_READ, v_regs, 34 * sizeof(vector128)))
|
|
|
|
return -EFAULT;
|
|
|
|
if (tm_v_regs && !access_ok(VERIFY_READ,
|
|
|
|
tm_v_regs, 34 * sizeof(vector128)))
|
|
|
|
return -EFAULT;
|
|
|
|
/* Copy 33 vec registers (vr0..31 and vscr) from the stack */
|
2013-08-06 16:01:24 +00:00
|
|
|
if (v_regs != NULL && tm_v_regs != NULL && (msr & MSR_VEC) != 0) {
|
2013-09-10 10:20:42 +00:00
|
|
|
err |= __copy_from_user(¤t->thread.vr_state, v_regs,
|
2013-02-13 16:21:41 +00:00
|
|
|
33 * sizeof(vector128));
|
2013-09-10 10:20:42 +00:00
|
|
|
err |= __copy_from_user(¤t->thread.transact_vr, tm_v_regs,
|
2013-02-13 16:21:41 +00:00
|
|
|
33 * sizeof(vector128));
|
|
|
|
}
|
|
|
|
else if (current->thread.used_vr) {
|
2013-09-10 10:20:42 +00:00
|
|
|
memset(¤t->thread.vr_state, 0, 33 * sizeof(vector128));
|
|
|
|
memset(¤t->thread.transact_vr, 0, 33 * sizeof(vector128));
|
2013-02-13 16:21:41 +00:00
|
|
|
}
|
|
|
|
/* Always get VRSAVE back */
|
2013-08-06 16:01:24 +00:00
|
|
|
if (v_regs != NULL && tm_v_regs != NULL) {
|
2013-02-13 16:21:41 +00:00
|
|
|
err |= __get_user(current->thread.vrsave,
|
|
|
|
(u32 __user *)&v_regs[33]);
|
|
|
|
err |= __get_user(current->thread.transact_vrsave,
|
|
|
|
(u32 __user *)&tm_v_regs[33]);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
current->thread.vrsave = 0;
|
|
|
|
current->thread.transact_vrsave = 0;
|
|
|
|
}
|
2013-08-05 04:13:16 +00:00
|
|
|
if (cpu_has_feature(CPU_FTR_ALTIVEC))
|
|
|
|
mtspr(SPRN_VRSAVE, current->thread.vrsave);
|
2013-02-13 16:21:41 +00:00
|
|
|
#endif /* CONFIG_ALTIVEC */
|
|
|
|
/* restore floating point */
|
|
|
|
err |= copy_fpr_from_user(current, &sc->fp_regs);
|
|
|
|
err |= copy_transact_fpr_from_user(current, &tm_sc->fp_regs);
|
|
|
|
#ifdef CONFIG_VSX
|
|
|
|
/*
|
|
|
|
* Get additional VSX data. Update v_regs to point after the
|
|
|
|
* VMX data. Copy VSX low doubleword from userspace to local
|
|
|
|
* buffer for formatting, then into the taskstruct.
|
|
|
|
*/
|
|
|
|
if (v_regs && ((msr & MSR_VSX) != 0)) {
|
|
|
|
v_regs += ELF_NVRREG;
|
|
|
|
tm_v_regs += ELF_NVRREG;
|
|
|
|
err |= copy_vsx_from_user(current, v_regs);
|
|
|
|
err |= copy_transact_vsx_from_user(current, tm_v_regs);
|
|
|
|
} else {
|
|
|
|
for (i = 0; i < 32 ; i++) {
|
2013-09-10 10:20:42 +00:00
|
|
|
current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
|
|
|
|
current->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET] = 0;
|
2013-02-13 16:21:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
tm_enable();
|
2014-04-04 09:19:48 +00:00
|
|
|
/* Make sure the transaction is marked as failed */
|
|
|
|
current->thread.tm_texasr |= TEXASR_FS;
|
2013-02-13 16:21:41 +00:00
|
|
|
/* This loads the checkpointed FP/VEC state, if used */
|
|
|
|
tm_recheckpoint(¤t->thread, msr);
|
|
|
|
|
|
|
|
/* This loads the speculative FP/VEC state, if used */
|
|
|
|
if (msr & MSR_FP) {
|
|
|
|
do_load_up_transact_fpu(¤t->thread);
|
|
|
|
regs->msr |= (MSR_FP | current->thread.fpexc_mode);
|
|
|
|
}
|
2013-04-09 06:18:55 +00:00
|
|
|
#ifdef CONFIG_ALTIVEC
|
2013-02-13 16:21:41 +00:00
|
|
|
if (msr & MSR_VEC) {
|
|
|
|
do_load_up_transact_altivec(¤t->thread);
|
|
|
|
regs->msr |= MSR_VEC;
|
|
|
|
}
|
2013-04-09 06:18:55 +00:00
|
|
|
#endif
|
2013-02-13 16:21:41 +00:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Setup the trampoline code on the stack
|
|
|
|
*/
|
|
|
|
static long setup_trampoline(unsigned int syscall, unsigned int __user *tramp)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
long err = 0;
|
|
|
|
|
|
|
|
/* addi r1, r1, __SIGNAL_FRAMESIZE # Pop the dummy stackframe */
|
|
|
|
err |= __put_user(0x38210000UL | (__SIGNAL_FRAMESIZE & 0xffff), &tramp[0]);
|
|
|
|
/* li r0, __NR_[rt_]sigreturn| */
|
|
|
|
err |= __put_user(0x38000000UL | (syscall & 0xffff), &tramp[1]);
|
|
|
|
/* sc */
|
|
|
|
err |= __put_user(0x44000002UL, &tramp[2]);
|
|
|
|
|
|
|
|
/* Minimal traceback info */
|
|
|
|
for (i=TRAMP_TRACEBACK; i < TRAMP_SIZE ;i++)
|
|
|
|
err |= __put_user(0, &tramp[i]);
|
|
|
|
|
|
|
|
if (!err)
|
|
|
|
flush_icache_range((unsigned long) &tramp[0],
|
|
|
|
(unsigned long) &tramp[TRAMP_SIZE]);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-07-08 08:43:41 +00:00
|
|
|
/*
|
|
|
|
* 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) - 32*sizeof(long))
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Handle {get,set,swap}_context operations
|
|
|
|
*/
|
|
|
|
int sys_swapcontext(struct ucontext __user *old_ctx,
|
|
|
|
struct ucontext __user *new_ctx,
|
|
|
|
long ctx_size, long r6, long r7, long r8, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
unsigned char tmp;
|
|
|
|
sigset_t set;
|
2008-07-08 08:43:41 +00:00
|
|
|
unsigned long new_msr = 0;
|
2008-10-23 00:42:36 +00:00
|
|
|
int ctx_has_vsx_region = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-08 08:43:41 +00:00
|
|
|
if (new_ctx &&
|
2008-10-23 00:42:36 +00:00
|
|
|
get_user(new_msr, &new_ctx->uc_mcontext.gp_regs[PT_MSR]))
|
2008-07-08 08:43:41 +00:00
|
|
|
return -EFAULT;
|
|
|
|
/*
|
|
|
|
* Check that the context is not smaller than the original
|
|
|
|
* size (with VMX but without VSX)
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-07-08 08:43:41 +00:00
|
|
|
if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
2008-07-08 08:43:41 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
2008-10-23 00:42:36 +00:00
|
|
|
/* Does the context have enough room to store VSX data? */
|
|
|
|
if (ctx_size >= sizeof(struct ucontext))
|
|
|
|
ctx_has_vsx_region = 1;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (old_ctx != NULL) {
|
2008-10-23 00:42:36 +00:00
|
|
|
if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
|
|
|
|
|| setup_sigcontext(&old_ctx->uc_mcontext, regs, 0, NULL, 0,
|
|
|
|
ctx_has_vsx_region)
|
2005-04-16 22:20:36 +00:00
|
|
|
|| __copy_to_user(&old_ctx->uc_sigmask,
|
|
|
|
¤t->blocked, sizeof(sigset_t)))
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
if (new_ctx == NULL)
|
|
|
|
return 0;
|
2008-10-23 00:42:36 +00:00
|
|
|
if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
|
2005-04-16 22:20:36 +00:00
|
|
|
|| __get_user(tmp, (u8 __user *) new_ctx)
|
2008-10-23 00:42:36 +00:00
|
|
|
|| __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
|
2005-04-16 22:20:36 +00:00
|
|
|
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 (__copy_from_user(&set, &new_ctx->uc_sigmask, sizeof(set)))
|
|
|
|
do_exit(SIGSEGV);
|
2012-04-27 18:09:19 +00:00
|
|
|
set_current_blocked(&set);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (restore_sigcontext(regs, NULL, 0, &new_ctx->uc_mcontext))
|
|
|
|
do_exit(SIGSEGV);
|
|
|
|
|
|
|
|
/* This returns like rt_sigreturn */
|
[PATCH] syscall entry/exit revamp
This cleanup patch speeds up the null syscall path on ppc64 by about 3%,
and brings the ppc32 and ppc64 code slightly closer together.
The ppc64 code was checking current_thread_info()->flags twice in the
syscall exit path; once for TIF_SYSCALL_T_OR_A before disabling
interrupts, and then again for TIF_SIGPENDING|TIF_NEED_RESCHED etc after
disabling interrupts. Now we do the same as ppc32 -- check the flags
only once in the fast path, and re-enable interrupts if necessary in the
ptrace case.
The patch abolishes the 'syscall_noerror' member of struct thread_info
and replaces it with a TIF_NOERROR bit in the flags, which is handled in
the slow path. This shortens the syscall entry code, which no longer
needs to clear syscall_noerror.
The patch adds a TIF_SAVE_NVGPRS flag which causes the syscall exit slow
path to save the non-volatile GPRs into a signal frame. This removes the
need for the assembly wrappers around sys_sigsuspend(),
sys_rt_sigsuspend(), et al which existed solely to save those registers
in advance. It also means I don't have to add new wrappers for ppoll()
and pselect(), which is what I was supposed to be doing when I got
distracted into this...
Finally, it unifies the ppc64 and ppc32 methods of handling syscall exit
directly into a signal handler (as required by sigsuspend et al) by
introducing a TIF_RESTOREALL flag which causes _all_ the registers to be
reloaded from the pt_regs by taking the ret_from_exception path, instead
of the normal syscall exit path which stomps on the callee-saved GPRs.
It appears to pass an LTP test run on ppc64, and passes basic testing on
ppc32 too. Brief tests of ptrace functionality with strace and gdb also
appear OK. I wouldn't send it to Linus for 2.6.15 just yet though :)
Signed-off-by: David Woodhouse <dwmw2@infradead.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-11-15 18:52:18 +00:00
|
|
|
set_thread_flag(TIF_RESTOREALL);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do a signal return; undo the signal stack.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int sys_rt_sigreturn(unsigned long r3, unsigned long r4, unsigned long r5,
|
|
|
|
unsigned long r6, unsigned long r7, unsigned long r8,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
struct ucontext __user *uc = (struct ucontext __user *)regs->gpr[1];
|
|
|
|
sigset_t set;
|
2013-02-13 16:21:41 +00:00
|
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
|
|
unsigned long msr;
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Always make any pending restarted system calls return -EINTR */
|
|
|
|
current_thread_info()->restart_block.fn = do_no_restart_syscall;
|
|
|
|
|
|
|
|
if (!access_ok(VERIFY_READ, uc, sizeof(*uc)))
|
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
if (__copy_from_user(&set, &uc->uc_sigmask, sizeof(set)))
|
|
|
|
goto badframe;
|
2012-04-27 18:09:19 +00:00
|
|
|
set_current_blocked(&set);
|
2013-02-13 16:21:41 +00:00
|
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
|
|
if (__get_user(msr, &uc->uc_mcontext.gp_regs[PT_MSR]))
|
|
|
|
goto badframe;
|
2013-06-09 11:23:19 +00:00
|
|
|
if (MSR_TM_ACTIVE(msr)) {
|
2013-02-13 16:21:41 +00:00
|
|
|
/* We recheckpoint on return. */
|
|
|
|
struct ucontext __user *uc_transact;
|
|
|
|
if (__get_user(uc_transact, &uc->uc_link))
|
|
|
|
goto badframe;
|
|
|
|
if (restore_tm_sigcontexts(regs, &uc->uc_mcontext,
|
|
|
|
&uc_transact->uc_mcontext))
|
|
|
|
goto badframe;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
/* Fall through, for non-TM restore */
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
if (restore_sigcontext(regs, NULL, 1, &uc->uc_mcontext))
|
|
|
|
goto badframe;
|
|
|
|
|
2012-12-23 08:26:46 +00:00
|
|
|
if (restore_altstack(&uc->uc_stack))
|
|
|
|
goto badframe;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
[PATCH] syscall entry/exit revamp
This cleanup patch speeds up the null syscall path on ppc64 by about 3%,
and brings the ppc32 and ppc64 code slightly closer together.
The ppc64 code was checking current_thread_info()->flags twice in the
syscall exit path; once for TIF_SYSCALL_T_OR_A before disabling
interrupts, and then again for TIF_SIGPENDING|TIF_NEED_RESCHED etc after
disabling interrupts. Now we do the same as ppc32 -- check the flags
only once in the fast path, and re-enable interrupts if necessary in the
ptrace case.
The patch abolishes the 'syscall_noerror' member of struct thread_info
and replaces it with a TIF_NOERROR bit in the flags, which is handled in
the slow path. This shortens the syscall entry code, which no longer
needs to clear syscall_noerror.
The patch adds a TIF_SAVE_NVGPRS flag which causes the syscall exit slow
path to save the non-volatile GPRs into a signal frame. This removes the
need for the assembly wrappers around sys_sigsuspend(),
sys_rt_sigsuspend(), et al which existed solely to save those registers
in advance. It also means I don't have to add new wrappers for ppoll()
and pselect(), which is what I was supposed to be doing when I got
distracted into this...
Finally, it unifies the ppc64 and ppc32 methods of handling syscall exit
directly into a signal handler (as required by sigsuspend et al) by
introducing a TIF_RESTOREALL flag which causes _all_ the registers to be
reloaded from the pt_regs by taking the ret_from_exception path, instead
of the normal syscall exit path which stomps on the callee-saved GPRs.
It appears to pass an LTP test run on ppc64, and passes basic testing on
ppc32 too. Brief tests of ptrace functionality with strace and gdb also
appear OK. I wouldn't send it to Linus for 2.6.15 just yet though :)
Signed-off-by: David Woodhouse <dwmw2@infradead.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-11-15 18:52:18 +00:00
|
|
|
set_thread_flag(TIF_RESTOREALL);
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
badframe:
|
2011-06-04 05:36:54 +00:00
|
|
|
if (show_unhandled_signals)
|
|
|
|
printk_ratelimited(regs->msr & MSR_64BIT ? fmt64 : fmt32,
|
|
|
|
current->comm, current->pid, "rt_sigreturn",
|
|
|
|
(long)uc, regs->nip, regs->link);
|
2007-10-12 00:20:07 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
force_sig(SIGSEGV, current);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-06-04 05:15:52 +00:00
|
|
|
int handle_rt_signal64(int signr, struct k_sigaction *ka, siginfo_t *info,
|
2005-04-16 22:20:36 +00:00
|
|
|
sigset_t *set, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
struct rt_sigframe __user *frame;
|
|
|
|
unsigned long newsp = 0;
|
|
|
|
long err = 0;
|
|
|
|
|
2013-05-26 18:09:41 +00:00
|
|
|
frame = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*frame), 0);
|
2007-06-04 07:22:48 +00:00
|
|
|
if (unlikely(frame == NULL))
|
2005-04-16 22:20:36 +00:00
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
err |= __put_user(&frame->info, &frame->pinfo);
|
|
|
|
err |= __put_user(&frame->uc, &frame->puc);
|
|
|
|
err |= copy_siginfo_to_user(&frame->info, info);
|
|
|
|
if (err)
|
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
/* Create the ucontext. */
|
|
|
|
err |= __put_user(0, &frame->uc.uc_flags);
|
2012-12-23 08:26:46 +00:00
|
|
|
err |= __save_altstack(&frame->uc.uc_stack, regs->gpr[1]);
|
2013-02-13 16:21:41 +00:00
|
|
|
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
|
|
|
if (MSR_TM_ACTIVE(regs->msr)) {
|
|
|
|
/* The ucontext_t passed to userland points to the second
|
|
|
|
* ucontext_t (for transactional state) with its uc_link ptr.
|
|
|
|
*/
|
|
|
|
err |= __put_user(&frame->uc_transact, &frame->uc.uc_link);
|
|
|
|
err |= setup_tm_sigcontexts(&frame->uc.uc_mcontext,
|
|
|
|
&frame->uc_transact.uc_mcontext,
|
|
|
|
regs, signr,
|
|
|
|
NULL,
|
|
|
|
(unsigned long)ka->sa.sa_handler);
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
err |= __put_user(0, &frame->uc.uc_link);
|
|
|
|
err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, signr,
|
|
|
|
NULL, (unsigned long)ka->sa.sa_handler,
|
|
|
|
1);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
|
|
|
|
if (err)
|
|
|
|
goto badframe;
|
|
|
|
|
2005-11-14 10:55:15 +00:00
|
|
|
/* Make sure signal handler doesn't get spurious FP exceptions */
|
2013-09-10 10:20:42 +00:00
|
|
|
current->thread.fp_state.fpscr = 0;
|
2005-11-14 10:55:15 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Set up to return from userspace. */
|
2006-05-30 03:51:37 +00:00
|
|
|
if (vdso64_rt_sigtramp && current->mm->context.vdso_base) {
|
|
|
|
regs->link = current->mm->context.vdso_base + vdso64_rt_sigtramp;
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
err |= setup_trampoline(__NR_rt_sigreturn, &frame->tramp[0]);
|
|
|
|
if (err)
|
|
|
|
goto badframe;
|
|
|
|
regs->link = (unsigned long) &frame->tramp[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate a dummy caller frame for the signal handler. */
|
2007-06-04 07:22:48 +00:00
|
|
|
newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
|
2005-04-16 22:20:36 +00:00
|
|
|
err |= put_user(regs->gpr[1], (unsigned long __user *)newsp);
|
|
|
|
|
|
|
|
/* Set up "regs" so we "return" to the signal handler. */
|
2013-11-20 11:15:03 +00:00
|
|
|
if (is_elf2_task()) {
|
|
|
|
regs->nip = (unsigned long) ka->sa.sa_handler;
|
|
|
|
regs->gpr[12] = regs->nip;
|
|
|
|
} else {
|
|
|
|
/* Handler is *really* a pointer to the function descriptor for
|
|
|
|
* the signal routine. The first entry in the function
|
|
|
|
* descriptor is the entry address of signal and the second
|
|
|
|
* entry is the TOC value we need to use.
|
|
|
|
*/
|
|
|
|
func_descr_t __user *funct_desc_ptr =
|
|
|
|
(func_descr_t __user *) ka->sa.sa_handler;
|
|
|
|
|
|
|
|
err |= get_user(regs->nip, &funct_desc_ptr->entry);
|
|
|
|
err |= get_user(regs->gpr[2], &funct_desc_ptr->toc);
|
|
|
|
}
|
|
|
|
|
2013-09-23 02:04:43 +00:00
|
|
|
/* enter the signal handler in native-endian mode */
|
2006-06-07 06:14:40 +00:00
|
|
|
regs->msr &= ~MSR_LE;
|
2013-09-23 02:04:43 +00:00
|
|
|
regs->msr |= (MSR_KERNEL & MSR_LE);
|
2005-04-16 22:20:36 +00:00
|
|
|
regs->gpr[1] = newsp;
|
|
|
|
regs->gpr[3] = signr;
|
|
|
|
regs->result = 0;
|
|
|
|
if (ka->sa.sa_flags & SA_SIGINFO) {
|
|
|
|
err |= get_user(regs->gpr[4], (unsigned long __user *)&frame->pinfo);
|
|
|
|
err |= get_user(regs->gpr[5], (unsigned long __user *)&frame->puc);
|
|
|
|
regs->gpr[6] = (unsigned long) frame;
|
|
|
|
} else {
|
|
|
|
regs->gpr[4] = (unsigned long)&frame->uc.uc_mcontext;
|
|
|
|
}
|
|
|
|
if (err)
|
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
badframe:
|
2011-06-04 05:36:54 +00:00
|
|
|
if (show_unhandled_signals)
|
|
|
|
printk_ratelimited(regs->msr & MSR_64BIT ? fmt64 : fmt32,
|
|
|
|
current->comm, current->pid, "setup_rt_frame",
|
|
|
|
(long)frame, regs->nip, regs->link);
|
2007-10-12 00:20:07 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
force_sigsegv(signr, current);
|
|
|
|
return 0;
|
|
|
|
}
|