2019-06-02 23:44:50 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2012-03-05 04:49:32 -07:00
|
|
|
/*
|
|
|
|
|
* Based on arch/arm/kernel/signal.c
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 1995-2009 Russell King
|
|
|
|
|
* Copyright (C) 2012 ARM Ltd.
|
|
|
|
|
* Modified by Will Deacon <will.deacon@arm.com>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/compat.h>
|
|
|
|
|
#include <linux/signal.h>
|
|
|
|
|
#include <linux/syscalls.h>
|
|
|
|
|
#include <linux/ratelimit.h>
|
|
|
|
|
|
2014-04-06 16:04:12 -06:00
|
|
|
#include <asm/esr.h>
|
2012-03-05 04:49:32 -07:00
|
|
|
#include <asm/fpsimd.h>
|
|
|
|
|
#include <asm/signal32.h>
|
2018-02-20 08:05:17 -07:00
|
|
|
#include <asm/traps.h>
|
2016-12-24 12:46:01 -07:00
|
|
|
#include <linux/uaccess.h>
|
2014-01-30 10:56:56 -07:00
|
|
|
#include <asm/unistd.h>
|
2019-06-21 03:52:41 -06:00
|
|
|
#include <asm/vdso.h>
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
struct compat_vfp_sigframe {
|
|
|
|
|
compat_ulong_t magic;
|
|
|
|
|
compat_ulong_t size;
|
|
|
|
|
struct compat_user_vfp {
|
|
|
|
|
compat_u64 fpregs[32];
|
|
|
|
|
compat_ulong_t fpscr;
|
|
|
|
|
} ufp;
|
|
|
|
|
struct compat_user_vfp_exc {
|
|
|
|
|
compat_ulong_t fpexc;
|
|
|
|
|
compat_ulong_t fpinst;
|
|
|
|
|
compat_ulong_t fpinst2;
|
|
|
|
|
} ufp_exc;
|
|
|
|
|
} __attribute__((__aligned__(8)));
|
|
|
|
|
|
|
|
|
|
#define VFP_MAGIC 0x56465001
|
|
|
|
|
#define VFP_STORAGE_SIZE sizeof(struct compat_vfp_sigframe)
|
|
|
|
|
|
2014-04-06 16:04:12 -06:00
|
|
|
#define FSR_WRITE_SHIFT (11)
|
|
|
|
|
|
2012-03-05 04:49:32 -07:00
|
|
|
struct compat_aux_sigframe {
|
|
|
|
|
struct compat_vfp_sigframe vfp;
|
|
|
|
|
|
|
|
|
|
/* Something that isn't a valid magic number for any coprocessor. */
|
|
|
|
|
unsigned long end_magic;
|
|
|
|
|
} __attribute__((__aligned__(8)));
|
|
|
|
|
|
|
|
|
|
#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
|
|
|
|
|
|
|
|
|
|
static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
|
|
|
|
|
{
|
|
|
|
|
compat_sigset_t cset;
|
|
|
|
|
|
|
|
|
|
cset.sig[0] = set->sig[0] & 0xffffffffull;
|
|
|
|
|
cset.sig[1] = set->sig[0] >> 32;
|
|
|
|
|
|
|
|
|
|
return copy_to_user(uset, &cset, sizeof(*uset));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int get_sigset_t(sigset_t *set,
|
|
|
|
|
const compat_sigset_t __user *uset)
|
|
|
|
|
{
|
|
|
|
|
compat_sigset_t s32;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&s32, uset, sizeof(*uset)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* VFP save/restore code.
|
2015-09-15 05:07:06 -06:00
|
|
|
*
|
|
|
|
|
* We have to be careful with endianness, since the fpsimd context-switch
|
|
|
|
|
* code operates on 128-bit (Q) register values whereas the compat ABI
|
|
|
|
|
* uses an array of 64-bit (D) registers. Consequently, we need to swap
|
|
|
|
|
* the two halves of each Q register when running on a big-endian CPU.
|
2012-03-05 04:49:32 -07:00
|
|
|
*/
|
2015-09-15 05:07:06 -06:00
|
|
|
union __fpsimd_vreg {
|
|
|
|
|
__uint128_t raw;
|
|
|
|
|
struct {
|
|
|
|
|
#ifdef __AARCH64EB__
|
|
|
|
|
u64 hi;
|
|
|
|
|
u64 lo;
|
|
|
|
|
#else
|
|
|
|
|
u64 lo;
|
|
|
|
|
u64 hi;
|
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
2012-03-05 04:49:32 -07:00
|
|
|
static int compat_preserve_vfp_context(struct compat_vfp_sigframe __user *frame)
|
|
|
|
|
{
|
2018-03-28 03:50:49 -06:00
|
|
|
struct user_fpsimd_state const *fpsimd =
|
|
|
|
|
¤t->thread.uw.fpsimd_state;
|
2012-03-05 04:49:32 -07:00
|
|
|
compat_ulong_t magic = VFP_MAGIC;
|
|
|
|
|
compat_ulong_t size = VFP_STORAGE_SIZE;
|
|
|
|
|
compat_ulong_t fpscr, fpexc;
|
2015-09-15 05:07:06 -06:00
|
|
|
int i, err = 0;
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Save the hardware registers to the fpsimd_state structure.
|
|
|
|
|
* Note that this also saves V16-31, which aren't visible
|
|
|
|
|
* in AArch32.
|
|
|
|
|
*/
|
arm64/sve: Signal handling support
This patch implements support for saving and restoring the SVE
registers around signals.
A fixed-size header struct sve_context is always included in the
signal frame encoding the thread's vector length at the time of
signal delivery, optionally followed by a variable-layout structure
encoding the SVE registers.
Because of the need to preserve backwards compatibility, the FPSIMD
view of the SVE registers is always dumped as a struct
fpsimd_context in the usual way, in addition to any sve_context.
The SVE vector registers are dumped in full, including bits 127:0
of each register which alias the corresponding FPSIMD vector
registers in the hardware. To avoid any ambiguity about which
alias to restore during sigreturn, the kernel always restores bits
127:0 of each SVE vector register from the fpsimd_context in the
signal frame (which must be present): userspace needs to take this
into account if it wants to modify the SVE vector register contents
on return from a signal.
FPSR and FPCR, which are used by both FPSIMD and SVE, are not
included in sve_context because they are always present in
fpsimd_context anyway.
For signal delivery, a new helper
fpsimd_signal_preserve_current_state() is added to update _both_
the FPSIMD and SVE views in the task struct, to make it easier to
populate this information into the signal frame. Because of the
redundancy between the two views of the state, only one is updated
otherwise.
Reviewed-by: Catalin Marinas <catalin.marinas@arm.com>
Signed-off-by: Dave Martin <Dave.Martin@arm.com>
Cc: Alex Bennée <alex.bennee@linaro.org>
Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: Will Deacon <will.deacon@arm.com>
Signed-off-by: Will Deacon <will.deacon@arm.com>
2017-10-31 09:51:07 -06:00
|
|
|
fpsimd_signal_preserve_current_state();
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
/* Place structure header on the stack */
|
|
|
|
|
__put_user_error(magic, &frame->magic, err);
|
|
|
|
|
__put_user_error(size, &frame->size, err);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Now copy the FP registers. Since the registers are packed,
|
|
|
|
|
* we can copy the prefix we want (V0-V15) as it is.
|
|
|
|
|
*/
|
2015-09-15 05:07:06 -06:00
|
|
|
for (i = 0; i < ARRAY_SIZE(frame->ufp.fpregs); i += 2) {
|
|
|
|
|
union __fpsimd_vreg vreg = {
|
|
|
|
|
.raw = fpsimd->vregs[i >> 1],
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
__put_user_error(vreg.lo, &frame->ufp.fpregs[i], err);
|
|
|
|
|
__put_user_error(vreg.hi, &frame->ufp.fpregs[i + 1], err);
|
|
|
|
|
}
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
/* Create an AArch32 fpscr from the fpsr and the fpcr. */
|
|
|
|
|
fpscr = (fpsimd->fpsr & VFP_FPSCR_STAT_MASK) |
|
|
|
|
|
(fpsimd->fpcr & VFP_FPSCR_CTRL_MASK);
|
|
|
|
|
__put_user_error(fpscr, &frame->ufp.fpscr, err);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The exception register aren't available so we fake up a
|
|
|
|
|
* basic FPEXC and zero everything else.
|
|
|
|
|
*/
|
|
|
|
|
fpexc = (1 << 30);
|
|
|
|
|
__put_user_error(fpexc, &frame->ufp_exc.fpexc, err);
|
|
|
|
|
__put_user_error(0, &frame->ufp_exc.fpinst, err);
|
|
|
|
|
__put_user_error(0, &frame->ufp_exc.fpinst2, err);
|
|
|
|
|
|
|
|
|
|
return err ? -EFAULT : 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int compat_restore_vfp_context(struct compat_vfp_sigframe __user *frame)
|
|
|
|
|
{
|
arm64: fpsimd: Fix state leakage when migrating after sigreturn
When refactoring the sigreturn code to handle SVE, I changed the
sigreturn implementation to store the new FPSIMD state from the
user sigframe into task_struct before reloading the state into the
CPU regs. This makes it easier to convert the data for SVE when
needed.
However, it turns out that the fpsimd_state structure passed into
fpsimd_update_current_state is not fully initialised, so assigning
the structure as a whole corrupts current->thread.fpsimd_state.cpu
with uninitialised data.
This means that if the garbage data written to .cpu happens to be a
valid cpu number, and the task is subsequently migrated to the cpu
identified by the that number, and then tries to enter userspace,
the CPU FPSIMD regs will be assumed to be correct for the task and
not reloaded as they should be. This can result in returning to
userspace with the FPSIMD registers containing data that is stale or
that belongs to another task or to the kernel.
Knowingly handing around a kernel structure that is incompletely
initialised with user data is a potential source of mistakes,
especially across source file boundaries. To help avoid a repeat
of this issue, this patch adapts the relevant internal API to hand
around the user-accessible subset only: struct user_fpsimd_state.
To avoid future surprises, this patch also converts all uses of
struct fpsimd_state that really only access the user subset, to use
struct user_fpsimd_state. A few missing consts are added to
function prototypes for good measure.
Thanks to Will for spotting the cause of the bug here.
Reported-by: Geert Uytterhoeven <geert@linux-m68k.org>
Signed-off-by: Dave Martin <Dave.Martin@arm.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Signed-off-by: Catalin Marinas <catalin.marinas@arm.com>
2017-12-15 11:34:38 -07:00
|
|
|
struct user_fpsimd_state fpsimd;
|
2012-03-05 04:49:32 -07:00
|
|
|
compat_ulong_t magic = VFP_MAGIC;
|
|
|
|
|
compat_ulong_t size = VFP_STORAGE_SIZE;
|
|
|
|
|
compat_ulong_t fpscr;
|
2015-09-15 05:07:06 -06:00
|
|
|
int i, err = 0;
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
__get_user_error(magic, &frame->magic, err);
|
|
|
|
|
__get_user_error(size, &frame->size, err);
|
|
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2015-09-15 05:07:06 -06:00
|
|
|
/* Copy the FP registers into the start of the fpsimd_state. */
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(frame->ufp.fpregs); i += 2) {
|
|
|
|
|
union __fpsimd_vreg vreg;
|
|
|
|
|
|
|
|
|
|
__get_user_error(vreg.lo, &frame->ufp.fpregs[i], err);
|
|
|
|
|
__get_user_error(vreg.hi, &frame->ufp.fpregs[i + 1], err);
|
|
|
|
|
fpsimd.vregs[i >> 1] = vreg.raw;
|
|
|
|
|
}
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
/* Extract the fpsr and the fpcr from the fpscr */
|
|
|
|
|
__get_user_error(fpscr, &frame->ufp.fpscr, err);
|
|
|
|
|
fpsimd.fpsr = fpscr & VFP_FPSCR_STAT_MASK;
|
|
|
|
|
fpsimd.fpcr = fpscr & VFP_FPSCR_CTRL_MASK;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We don't need to touch the exception register, so
|
|
|
|
|
* reload the hardware state.
|
|
|
|
|
*/
|
2014-02-24 07:26:27 -07:00
|
|
|
if (!err)
|
|
|
|
|
fpsimd_update_current_state(&fpsimd);
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
return err ? -EFAULT : 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int compat_restore_sigframe(struct pt_regs *regs,
|
|
|
|
|
struct compat_sigframe __user *sf)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
sigset_t set;
|
|
|
|
|
struct compat_aux_sigframe __user *aux;
|
2018-07-05 08:16:50 -06:00
|
|
|
unsigned long psr;
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
err = get_sigset_t(&set, &sf->uc.uc_sigmask);
|
|
|
|
|
if (err == 0) {
|
|
|
|
|
sigdelsetmask(&set, ~_BLOCKABLE);
|
|
|
|
|
set_current_blocked(&set);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
__get_user_error(regs->regs[0], &sf->uc.uc_mcontext.arm_r0, err);
|
|
|
|
|
__get_user_error(regs->regs[1], &sf->uc.uc_mcontext.arm_r1, err);
|
|
|
|
|
__get_user_error(regs->regs[2], &sf->uc.uc_mcontext.arm_r2, err);
|
|
|
|
|
__get_user_error(regs->regs[3], &sf->uc.uc_mcontext.arm_r3, err);
|
|
|
|
|
__get_user_error(regs->regs[4], &sf->uc.uc_mcontext.arm_r4, err);
|
|
|
|
|
__get_user_error(regs->regs[5], &sf->uc.uc_mcontext.arm_r5, err);
|
|
|
|
|
__get_user_error(regs->regs[6], &sf->uc.uc_mcontext.arm_r6, err);
|
|
|
|
|
__get_user_error(regs->regs[7], &sf->uc.uc_mcontext.arm_r7, err);
|
|
|
|
|
__get_user_error(regs->regs[8], &sf->uc.uc_mcontext.arm_r8, err);
|
|
|
|
|
__get_user_error(regs->regs[9], &sf->uc.uc_mcontext.arm_r9, err);
|
|
|
|
|
__get_user_error(regs->regs[10], &sf->uc.uc_mcontext.arm_r10, err);
|
|
|
|
|
__get_user_error(regs->regs[11], &sf->uc.uc_mcontext.arm_fp, err);
|
|
|
|
|
__get_user_error(regs->regs[12], &sf->uc.uc_mcontext.arm_ip, err);
|
|
|
|
|
__get_user_error(regs->compat_sp, &sf->uc.uc_mcontext.arm_sp, err);
|
|
|
|
|
__get_user_error(regs->compat_lr, &sf->uc.uc_mcontext.arm_lr, err);
|
|
|
|
|
__get_user_error(regs->pc, &sf->uc.uc_mcontext.arm_pc, err);
|
2018-07-05 08:16:50 -06:00
|
|
|
__get_user_error(psr, &sf->uc.uc_mcontext.arm_cpsr, err);
|
|
|
|
|
|
|
|
|
|
regs->pstate = compat_psr_to_pstate(psr);
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Avoid compat_sys_sigreturn() restarting.
|
|
|
|
|
*/
|
2017-08-01 08:35:54 -06:00
|
|
|
forget_syscall(regs);
|
2012-03-05 04:49:32 -07:00
|
|
|
|
2016-03-01 07:18:50 -07:00
|
|
|
err |= !valid_user_regs(®s->user_regs, current);
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
aux = (struct compat_aux_sigframe __user *) sf->uc.uc_regspace;
|
|
|
|
|
if (err == 0)
|
|
|
|
|
err |= compat_restore_vfp_context(&aux->vfp);
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-11 07:56:53 -06:00
|
|
|
COMPAT_SYSCALL_DEFINE0(sigreturn)
|
2012-03-05 04:49:32 -07:00
|
|
|
{
|
2018-07-11 07:56:41 -06:00
|
|
|
struct pt_regs *regs = current_pt_regs();
|
2012-03-05 04:49:32 -07:00
|
|
|
struct compat_sigframe __user *frame;
|
|
|
|
|
|
|
|
|
|
/* Always make any pending restarted system calls return -EINTR */
|
2015-02-12 16:01:14 -07:00
|
|
|
current->restart_block.fn = do_no_restart_syscall;
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Since we stacked the signal on a 64-bit boundary,
|
|
|
|
|
* then 'sp' should be word aligned here. If it's
|
|
|
|
|
* not, then the user is trying to mess with us.
|
|
|
|
|
*/
|
|
|
|
|
if (regs->compat_sp & 7)
|
|
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
|
|
frame = (struct compat_sigframe __user *)regs->compat_sp;
|
|
|
|
|
|
Remove 'type' argument from access_ok() function
Nobody has actually used the type (VERIFY_READ vs VERIFY_WRITE) argument
of the user address range verification function since we got rid of the
old racy i386-only code to walk page tables by hand.
It existed because the original 80386 would not honor the write protect
bit when in kernel mode, so you had to do COW by hand before doing any
user access. But we haven't supported that in a long time, and these
days the 'type' argument is a purely historical artifact.
A discussion about extending 'user_access_begin()' to do the range
checking resulted this patch, because there is no way we're going to
move the old VERIFY_xyz interface to that model. And it's best done at
the end of the merge window when I've done most of my merges, so let's
just get this done once and for all.
This patch was mostly done with a sed-script, with manual fix-ups for
the cases that weren't of the trivial 'access_ok(VERIFY_xyz' form.
There were a couple of notable cases:
- csky still had the old "verify_area()" name as an alias.
- the iter_iov code had magical hardcoded knowledge of the actual
values of VERIFY_{READ,WRITE} (not that they mattered, since nothing
really used it)
- microblaze used the type argument for a debug printout
but other than those oddities this should be a total no-op patch.
I tried to fix up all architectures, did fairly extensive grepping for
access_ok() uses, and the changes are trivial, but I may have missed
something. Any missed conversion should be trivially fixable, though.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-01-03 19:57:57 -07:00
|
|
|
if (!access_ok(frame, sizeof (*frame)))
|
2012-03-05 04:49:32 -07:00
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
|
|
if (compat_restore_sigframe(regs, frame))
|
|
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
|
|
return regs->regs[0];
|
|
|
|
|
|
|
|
|
|
badframe:
|
2018-02-20 08:05:17 -07:00
|
|
|
arm64_notify_segfault(regs->compat_sp);
|
2012-03-05 04:49:32 -07:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-11 07:56:53 -06:00
|
|
|
COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
|
2012-03-05 04:49:32 -07:00
|
|
|
{
|
2018-07-11 07:56:41 -06:00
|
|
|
struct pt_regs *regs = current_pt_regs();
|
2012-03-05 04:49:32 -07:00
|
|
|
struct compat_rt_sigframe __user *frame;
|
|
|
|
|
|
|
|
|
|
/* Always make any pending restarted system calls return -EINTR */
|
2015-02-12 16:01:14 -07:00
|
|
|
current->restart_block.fn = do_no_restart_syscall;
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Since we stacked the signal on a 64-bit boundary,
|
|
|
|
|
* then 'sp' should be word aligned here. If it's
|
|
|
|
|
* not, then the user is trying to mess with us.
|
|
|
|
|
*/
|
|
|
|
|
if (regs->compat_sp & 7)
|
|
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
|
|
frame = (struct compat_rt_sigframe __user *)regs->compat_sp;
|
|
|
|
|
|
Remove 'type' argument from access_ok() function
Nobody has actually used the type (VERIFY_READ vs VERIFY_WRITE) argument
of the user address range verification function since we got rid of the
old racy i386-only code to walk page tables by hand.
It existed because the original 80386 would not honor the write protect
bit when in kernel mode, so you had to do COW by hand before doing any
user access. But we haven't supported that in a long time, and these
days the 'type' argument is a purely historical artifact.
A discussion about extending 'user_access_begin()' to do the range
checking resulted this patch, because there is no way we're going to
move the old VERIFY_xyz interface to that model. And it's best done at
the end of the merge window when I've done most of my merges, so let's
just get this done once and for all.
This patch was mostly done with a sed-script, with manual fix-ups for
the cases that weren't of the trivial 'access_ok(VERIFY_xyz' form.
There were a couple of notable cases:
- csky still had the old "verify_area()" name as an alias.
- the iter_iov code had magical hardcoded knowledge of the actual
values of VERIFY_{READ,WRITE} (not that they mattered, since nothing
really used it)
- microblaze used the type argument for a debug printout
but other than those oddities this should be a total no-op patch.
I tried to fix up all architectures, did fairly extensive grepping for
access_ok() uses, and the changes are trivial, but I may have missed
something. Any missed conversion should be trivially fixable, though.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-01-03 19:57:57 -07:00
|
|
|
if (!access_ok(frame, sizeof (*frame)))
|
2012-03-05 04:49:32 -07:00
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
|
|
if (compat_restore_sigframe(regs, &frame->sig))
|
|
|
|
|
goto badframe;
|
|
|
|
|
|
2012-12-22 23:56:45 -07:00
|
|
|
if (compat_restore_altstack(&frame->sig.uc.uc_stack))
|
2012-03-05 04:49:32 -07:00
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
|
|
return regs->regs[0];
|
|
|
|
|
|
|
|
|
|
badframe:
|
2018-02-20 08:05:17 -07:00
|
|
|
arm64_notify_segfault(regs->compat_sp);
|
2012-03-05 04:49:32 -07:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-05 05:31:20 -07:00
|
|
|
static void __user *compat_get_sigframe(struct ksignal *ksig,
|
2012-11-23 04:01:05 -07:00
|
|
|
struct pt_regs *regs,
|
|
|
|
|
int framesize)
|
2012-03-05 04:49:32 -07:00
|
|
|
{
|
2014-03-05 05:31:20 -07:00
|
|
|
compat_ulong_t sp = sigsp(regs->compat_sp, ksig);
|
2012-03-05 04:49:32 -07:00
|
|
|
void __user *frame;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* ATPCS B01 mandates 8-byte alignment
|
|
|
|
|
*/
|
|
|
|
|
frame = compat_ptr((compat_uptr_t)((sp - framesize) & ~7));
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Check that we can actually write to the signal frame.
|
|
|
|
|
*/
|
Remove 'type' argument from access_ok() function
Nobody has actually used the type (VERIFY_READ vs VERIFY_WRITE) argument
of the user address range verification function since we got rid of the
old racy i386-only code to walk page tables by hand.
It existed because the original 80386 would not honor the write protect
bit when in kernel mode, so you had to do COW by hand before doing any
user access. But we haven't supported that in a long time, and these
days the 'type' argument is a purely historical artifact.
A discussion about extending 'user_access_begin()' to do the range
checking resulted this patch, because there is no way we're going to
move the old VERIFY_xyz interface to that model. And it's best done at
the end of the merge window when I've done most of my merges, so let's
just get this done once and for all.
This patch was mostly done with a sed-script, with manual fix-ups for
the cases that weren't of the trivial 'access_ok(VERIFY_xyz' form.
There were a couple of notable cases:
- csky still had the old "verify_area()" name as an alias.
- the iter_iov code had magical hardcoded knowledge of the actual
values of VERIFY_{READ,WRITE} (not that they mattered, since nothing
really used it)
- microblaze used the type argument for a debug printout
but other than those oddities this should be a total no-op patch.
I tried to fix up all architectures, did fairly extensive grepping for
access_ok() uses, and the changes are trivial, but I may have missed
something. Any missed conversion should be trivially fixable, though.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-01-03 19:57:57 -07:00
|
|
|
if (!access_ok(frame, framesize))
|
2012-03-05 04:49:32 -07:00
|
|
|
frame = NULL;
|
|
|
|
|
|
|
|
|
|
return frame;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-23 04:01:03 -07:00
|
|
|
static void compat_setup_return(struct pt_regs *regs, struct k_sigaction *ka,
|
|
|
|
|
compat_ulong_t __user *rc, void __user *frame,
|
|
|
|
|
int usig)
|
2012-03-05 04:49:32 -07:00
|
|
|
{
|
|
|
|
|
compat_ulong_t handler = ptr_to_compat(ka->sa.sa_handler);
|
|
|
|
|
compat_ulong_t retcode;
|
2018-07-05 08:16:52 -06:00
|
|
|
compat_ulong_t spsr = regs->pstate & ~(PSR_f | PSR_AA32_E_BIT);
|
2012-03-05 04:49:32 -07:00
|
|
|
int thumb;
|
|
|
|
|
|
|
|
|
|
/* Check if the handler is written for ARM or Thumb */
|
|
|
|
|
thumb = handler & 1;
|
|
|
|
|
|
2013-11-05 10:07:18 -07:00
|
|
|
if (thumb)
|
2018-07-05 08:16:52 -06:00
|
|
|
spsr |= PSR_AA32_T_BIT;
|
2013-11-05 10:07:18 -07:00
|
|
|
else
|
2018-07-05 08:16:52 -06:00
|
|
|
spsr &= ~PSR_AA32_T_BIT;
|
2013-11-05 10:07:18 -07:00
|
|
|
|
|
|
|
|
/* The IT state must be cleared for both ARM and Thumb-2 */
|
2018-07-05 08:16:52 -06:00
|
|
|
spsr &= ~PSR_AA32_IT_MASK;
|
2012-03-05 04:49:32 -07:00
|
|
|
|
2015-01-21 05:43:11 -07:00
|
|
|
/* Restore the original endianness */
|
2018-07-05 08:16:52 -06:00
|
|
|
spsr |= PSR_AA32_ENDSTATE;
|
2015-01-21 05:43:11 -07:00
|
|
|
|
2012-03-05 04:49:32 -07:00
|
|
|
if (ka->sa.sa_flags & SA_RESTORER) {
|
|
|
|
|
retcode = ptr_to_compat(ka->sa.sa_restorer);
|
|
|
|
|
} else {
|
|
|
|
|
/* Set up sigreturn pointer */
|
2019-06-21 03:52:41 -06:00
|
|
|
#ifdef CONFIG_COMPAT_VDSO
|
|
|
|
|
void *vdso_base = current->mm->context.vdso;
|
|
|
|
|
void *vdso_trampoline;
|
|
|
|
|
|
|
|
|
|
if (ka->sa.sa_flags & SA_SIGINFO) {
|
|
|
|
|
if (thumb) {
|
|
|
|
|
vdso_trampoline = VDSO_SYMBOL(vdso_base,
|
|
|
|
|
compat_rt_sigreturn_thumb);
|
|
|
|
|
} else {
|
|
|
|
|
vdso_trampoline = VDSO_SYMBOL(vdso_base,
|
|
|
|
|
compat_rt_sigreturn_arm);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (thumb) {
|
|
|
|
|
vdso_trampoline = VDSO_SYMBOL(vdso_base,
|
|
|
|
|
compat_sigreturn_thumb);
|
|
|
|
|
} else {
|
|
|
|
|
vdso_trampoline = VDSO_SYMBOL(vdso_base,
|
|
|
|
|
compat_sigreturn_arm);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retcode = ptr_to_compat(vdso_trampoline) + thumb;
|
|
|
|
|
#else
|
2012-03-05 04:49:32 -07:00
|
|
|
unsigned int idx = thumb << 1;
|
|
|
|
|
|
|
|
|
|
if (ka->sa.sa_flags & SA_SIGINFO)
|
|
|
|
|
idx += 3;
|
|
|
|
|
|
2019-04-15 03:49:34 -06:00
|
|
|
retcode = (unsigned long)current->mm->context.vdso +
|
2012-03-05 04:49:32 -07:00
|
|
|
(idx << 2) + thumb;
|
2019-06-21 03:52:41 -06:00
|
|
|
#endif
|
2012-03-05 04:49:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
regs->regs[0] = usig;
|
|
|
|
|
regs->compat_sp = ptr_to_compat(frame);
|
|
|
|
|
regs->compat_lr = retcode;
|
|
|
|
|
regs->pc = handler;
|
|
|
|
|
regs->pstate = spsr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int compat_setup_sigframe(struct compat_sigframe __user *sf,
|
|
|
|
|
struct pt_regs *regs, sigset_t *set)
|
|
|
|
|
{
|
|
|
|
|
struct compat_aux_sigframe __user *aux;
|
2018-07-05 08:16:50 -06:00
|
|
|
unsigned long psr = pstate_to_compat_psr(regs->pstate);
|
2012-03-05 04:49:32 -07:00
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
|
|
__put_user_error(regs->regs[0], &sf->uc.uc_mcontext.arm_r0, err);
|
|
|
|
|
__put_user_error(regs->regs[1], &sf->uc.uc_mcontext.arm_r1, err);
|
|
|
|
|
__put_user_error(regs->regs[2], &sf->uc.uc_mcontext.arm_r2, err);
|
|
|
|
|
__put_user_error(regs->regs[3], &sf->uc.uc_mcontext.arm_r3, err);
|
|
|
|
|
__put_user_error(regs->regs[4], &sf->uc.uc_mcontext.arm_r4, err);
|
|
|
|
|
__put_user_error(regs->regs[5], &sf->uc.uc_mcontext.arm_r5, err);
|
|
|
|
|
__put_user_error(regs->regs[6], &sf->uc.uc_mcontext.arm_r6, err);
|
|
|
|
|
__put_user_error(regs->regs[7], &sf->uc.uc_mcontext.arm_r7, err);
|
|
|
|
|
__put_user_error(regs->regs[8], &sf->uc.uc_mcontext.arm_r8, err);
|
|
|
|
|
__put_user_error(regs->regs[9], &sf->uc.uc_mcontext.arm_r9, err);
|
|
|
|
|
__put_user_error(regs->regs[10], &sf->uc.uc_mcontext.arm_r10, err);
|
|
|
|
|
__put_user_error(regs->regs[11], &sf->uc.uc_mcontext.arm_fp, err);
|
|
|
|
|
__put_user_error(regs->regs[12], &sf->uc.uc_mcontext.arm_ip, err);
|
|
|
|
|
__put_user_error(regs->compat_sp, &sf->uc.uc_mcontext.arm_sp, err);
|
|
|
|
|
__put_user_error(regs->compat_lr, &sf->uc.uc_mcontext.arm_lr, err);
|
|
|
|
|
__put_user_error(regs->pc, &sf->uc.uc_mcontext.arm_pc, err);
|
2018-07-05 08:16:50 -06:00
|
|
|
__put_user_error(psr, &sf->uc.uc_mcontext.arm_cpsr, err);
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
__put_user_error((compat_ulong_t)0, &sf->uc.uc_mcontext.trap_no, err);
|
2014-04-06 16:04:12 -06:00
|
|
|
/* set the compat FSR WnR */
|
2014-11-24 05:31:40 -07:00
|
|
|
__put_user_error(!!(current->thread.fault_code & ESR_ELx_WNR) <<
|
2014-04-06 16:04:12 -06:00
|
|
|
FSR_WRITE_SHIFT, &sf->uc.uc_mcontext.error_code, err);
|
2012-03-05 04:49:32 -07:00
|
|
|
__put_user_error(current->thread.fault_address, &sf->uc.uc_mcontext.fault_address, err);
|
|
|
|
|
__put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
|
|
|
|
|
|
|
|
|
|
err |= put_sigset_t(&sf->uc.uc_sigmask, set);
|
|
|
|
|
|
|
|
|
|
aux = (struct compat_aux_sigframe __user *) sf->uc.uc_regspace;
|
|
|
|
|
|
|
|
|
|
if (err == 0)
|
|
|
|
|
err |= compat_preserve_vfp_context(&aux->vfp);
|
|
|
|
|
__put_user_error(0, &aux->end_magic, err);
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 32-bit signal handling routines called from signal.c
|
|
|
|
|
*/
|
2013-10-06 14:52:44 -06:00
|
|
|
int compat_setup_rt_frame(int usig, struct ksignal *ksig,
|
2012-03-05 04:49:32 -07:00
|
|
|
sigset_t *set, struct pt_regs *regs)
|
|
|
|
|
{
|
|
|
|
|
struct compat_rt_sigframe __user *frame;
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
2014-03-05 05:31:20 -07:00
|
|
|
frame = compat_get_sigframe(ksig, regs, sizeof(*frame));
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
if (!frame)
|
|
|
|
|
return 1;
|
|
|
|
|
|
2013-10-06 14:52:44 -06:00
|
|
|
err |= copy_siginfo_to_user32(&frame->info, &ksig->info);
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
__put_user_error(0, &frame->sig.uc.uc_flags, err);
|
2013-02-06 04:42:23 -07:00
|
|
|
__put_user_error(0, &frame->sig.uc.uc_link, err);
|
2012-03-05 04:49:32 -07:00
|
|
|
|
2012-12-22 23:56:45 -07:00
|
|
|
err |= __compat_save_altstack(&frame->sig.uc.uc_stack, regs->compat_sp);
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
err |= compat_setup_sigframe(&frame->sig, regs, set);
|
|
|
|
|
|
|
|
|
|
if (err == 0) {
|
2013-10-06 14:52:44 -06:00
|
|
|
compat_setup_return(regs, &ksig->ka, frame->sig.retcode, frame, usig);
|
2012-03-05 04:49:32 -07:00
|
|
|
regs->regs[1] = (compat_ulong_t)(unsigned long)&frame->info;
|
|
|
|
|
regs->regs[2] = (compat_ulong_t)(unsigned long)&frame->sig.uc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-06 14:52:44 -06:00
|
|
|
int compat_setup_frame(int usig, struct ksignal *ksig, sigset_t *set,
|
2012-03-05 04:49:32 -07:00
|
|
|
struct pt_regs *regs)
|
|
|
|
|
{
|
|
|
|
|
struct compat_sigframe __user *frame;
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
2014-03-05 05:31:20 -07:00
|
|
|
frame = compat_get_sigframe(ksig, regs, sizeof(*frame));
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
if (!frame)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
__put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
|
|
|
|
|
|
|
|
|
|
err |= compat_setup_sigframe(frame, regs, set);
|
|
|
|
|
if (err == 0)
|
2013-10-06 14:52:44 -06:00
|
|
|
compat_setup_return(regs, &ksig->ka, frame->retcode, frame, usig);
|
2012-03-05 04:49:32 -07:00
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void compat_setup_restart_syscall(struct pt_regs *regs)
|
|
|
|
|
{
|
2012-10-10 08:16:13 -06:00
|
|
|
regs->regs[7] = __NR_compat_restart_syscall;
|
2012-03-05 04:49:32 -07:00
|
|
|
}
|