mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git
synced 2025-01-08 15:04:45 +00:00
LoongArch: Add signal handling support
Add ucontext/sigcontext definition and signal handling support for LoongArch. Cc: Eric Biederman <ebiederm@xmission.com> Cc: Al Viro <viro@zeniv.linux.org.uk> Reviewed-by: WANG Xuerui <git@xen0n.name> Reviewed-by: Jiaxun Yang <jiaxun.yang@flygoat.com> Signed-off-by: Huacai Chen <chenhuacai@loongson.cn>
This commit is contained in:
Huacai Chen
parent
be769645a2
commit
b74baf4ad0
44
arch/loongarch/include/uapi/asm/sigcontext.h
Normal file
44
arch/loongarch/include/uapi/asm/sigcontext.h
Normal file
@ -0,0 +1,44 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
|
||||
/*
|
||||
* Author: Hanlu Li <lihanlu@loongson.cn>
|
||||
* Huacai Chen <chenhuacai@loongson.cn>
|
||||
*
|
||||
* Copyright (C) 2020-2022 Loongson Technology Corporation Limited
|
||||
*/
|
||||
#ifndef _UAPI_ASM_SIGCONTEXT_H
|
||||
#define _UAPI_ASM_SIGCONTEXT_H
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/posix_types.h>
|
||||
|
||||
/* FP context was used */
|
||||
#define SC_USED_FP (1 << 0)
|
||||
/* Address error was due to memory load */
|
||||
#define SC_ADDRERR_RD (1 << 30)
|
||||
/* Address error was due to memory store */
|
||||
#define SC_ADDRERR_WR (1 << 31)
|
||||
|
||||
struct sigcontext {
|
||||
__u64 sc_pc;
|
||||
__u64 sc_regs[32];
|
||||
__u32 sc_flags;
|
||||
__u64 sc_extcontext[0] __attribute__((__aligned__(16)));
|
||||
};
|
||||
|
||||
#define CONTEXT_INFO_ALIGN 16
|
||||
struct sctx_info {
|
||||
__u32 magic;
|
||||
__u32 size;
|
||||
__u64 padding; /* padding to 16 bytes */
|
||||
};
|
||||
|
||||
/* FPU context */
|
||||
#define FPU_CTX_MAGIC 0x46505501
|
||||
#define FPU_CTX_ALIGN 8
|
||||
struct fpu_context {
|
||||
__u64 regs[32];
|
||||
__u64 fcc;
|
||||
__u32 fcsr;
|
||||
};
|
||||
|
||||
#endif /* _UAPI_ASM_SIGCONTEXT_H */
|
||||
13
arch/loongarch/include/uapi/asm/signal.h
Normal file
13
arch/loongarch/include/uapi/asm/signal.h
Normal file
@ -0,0 +1,13 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
/*
|
||||
* Copyright (C) 2020-2022 Loongson Technology Corporation Limited
|
||||
*/
|
||||
#ifndef _UAPI_ASM_SIGNAL_H
|
||||
#define _UAPI_ASM_SIGNAL_H
|
||||
|
||||
#define MINSIGSTKSZ 4096
|
||||
#define SIGSTKSZ 16384
|
||||
|
||||
#include <asm-generic/signal.h>
|
||||
|
||||
#endif
|
||||
35
arch/loongarch/include/uapi/asm/ucontext.h
Normal file
35
arch/loongarch/include/uapi/asm/ucontext.h
Normal file
@ -0,0 +1,35 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
#ifndef __LOONGARCH_UAPI_ASM_UCONTEXT_H
|
||||
#define __LOONGARCH_UAPI_ASM_UCONTEXT_H
|
||||
|
||||
/**
|
||||
* struct ucontext - user context structure
|
||||
* @uc_flags:
|
||||
* @uc_link:
|
||||
* @uc_stack:
|
||||
* @uc_mcontext: holds basic processor state
|
||||
* @uc_sigmask:
|
||||
* @uc_extcontext: holds extended processor state
|
||||
*/
|
||||
struct ucontext {
|
||||
unsigned long uc_flags;
|
||||
struct ucontext *uc_link;
|
||||
stack_t uc_stack;
|
||||
sigset_t uc_sigmask;
|
||||
/* There's some padding here to allow sigset_t to be expanded in the
|
||||
* future. Though this is unlikely, other architectures put uc_sigmask
|
||||
* at the end of this structure and explicitly state it can be
|
||||
* expanded, so we didn't want to box ourselves in here. */
|
||||
__u8 __unused[1024 / 8 - sizeof(sigset_t)];
|
||||
/* We can't put uc_sigmask at the end of this structure because we need
|
||||
* to be able to expand sigcontext in the future. For example, the
|
||||
* vector ISA extension will almost certainly add ISA state. We want
|
||||
* to ensure all user-visible ISA state can be saved and restored via a
|
||||
* ucontext, so we're putting this at the end in order to allow for
|
||||
* infinite extensibility. Since we know this will be extended and we
|
||||
* assume sigset_t won't be extended an extreme amount, we're
|
||||
* prioritizing this. */
|
||||
struct sigcontext uc_mcontext;
|
||||
};
|
||||
|
||||
#endif /* __LOONGARCH_UAPI_ASM_UCONTEXT_H */
|
||||
566
arch/loongarch/kernel/signal.c
Normal file
566
arch/loongarch/kernel/signal.c
Normal file
@ -0,0 +1,566 @@
|
||||
// SPDX-License-Identifier: GPL-2.0+
|
||||
/*
|
||||
* Author: Hanlu Li <lihanlu@loongson.cn>
|
||||
* Huacai Chen <chenhuacai@loongson.cn>
|
||||
* Copyright (C) 2020-2022 Loongson Technology Corporation Limited
|
||||
*
|
||||
* Derived from MIPS:
|
||||
* Copyright (C) 1991, 1992 Linus Torvalds
|
||||
* Copyright (C) 1994 - 2000 Ralf Baechle
|
||||
* Copyright (C) 1999, 2000 Silicon Graphics, Inc.
|
||||
* Copyright (C) 2014, Imagination Technologies Ltd.
|
||||
*/
|
||||
#include <linux/audit.h>
|
||||
#include <linux/cache.h>
|
||||
#include <linux/context_tracking.h>
|
||||
#include <linux/irqflags.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/personality.h>
|
||||
#include <linux/smp.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/signal.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/wait.h>
|
||||
#include <linux/ptrace.h>
|
||||
#include <linux/unistd.h>
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/syscalls.h>
|
||||
#include <linux/uaccess.h>
|
||||
|
||||
#include <asm/asm.h>
|
||||
#include <asm/cacheflush.h>
|
||||
#include <asm/cpu-features.h>
|
||||
#include <asm/fpu.h>
|
||||
#include <asm/ucontext.h>
|
||||
#include <asm/vdso.h>
|
||||
|
||||
#ifdef DEBUG_SIG
|
||||
# define DEBUGP(fmt, args...) printk("%s: " fmt, __func__, ##args)
|
||||
#else
|
||||
# define DEBUGP(fmt, args...)
|
||||
#endif
|
||||
|
||||
/* Make sure we will not lose FPU ownership */
|
||||
#define lock_fpu_owner() ({ preempt_disable(); pagefault_disable(); })
|
||||
#define unlock_fpu_owner() ({ pagefault_enable(); preempt_enable(); })
|
||||
|
||||
/* Assembly functions to move context to/from the FPU */
|
||||
extern asmlinkage int
|
||||
_save_fp_context(void __user *fpregs, void __user *fcc, void __user *csr);
|
||||
extern asmlinkage int
|
||||
_restore_fp_context(void __user *fpregs, void __user *fcc, void __user *csr);
|
||||
|
||||
struct rt_sigframe {
|
||||
struct siginfo rs_info;
|
||||
struct ucontext rs_uctx;
|
||||
};
|
||||
|
||||
struct _ctx_layout {
|
||||
struct sctx_info *addr;
|
||||
unsigned int size;
|
||||
};
|
||||
|
||||
struct extctx_layout {
|
||||
unsigned long size;
|
||||
unsigned int flags;
|
||||
struct _ctx_layout fpu;
|
||||
struct _ctx_layout end;
|
||||
};
|
||||
|
||||
static void __user *get_ctx_through_ctxinfo(struct sctx_info *info)
|
||||
{
|
||||
return (void __user *)((char *)info + sizeof(struct sctx_info));
|
||||
}
|
||||
|
||||
/*
|
||||
* Thread saved context copy to/from a signal context presumed to be on the
|
||||
* user stack, and therefore accessed with appropriate macros from uaccess.h.
|
||||
*/
|
||||
static int copy_fpu_to_sigcontext(struct fpu_context __user *ctx)
|
||||
{
|
||||
int i;
|
||||
int err = 0;
|
||||
uint64_t __user *regs = (uint64_t *)&ctx->regs;
|
||||
uint64_t __user *fcc = &ctx->fcc;
|
||||
uint32_t __user *fcsr = &ctx->fcsr;
|
||||
|
||||
for (i = 0; i < NUM_FPU_REGS; i++) {
|
||||
err |=
|
||||
__put_user(get_fpr64(¤t->thread.fpu.fpr[i], 0),
|
||||
®s[i]);
|
||||
}
|
||||
err |= __put_user(current->thread.fpu.fcc, fcc);
|
||||
err |= __put_user(current->thread.fpu.fcsr, fcsr);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int copy_fpu_from_sigcontext(struct fpu_context __user *ctx)
|
||||
{
|
||||
int i;
|
||||
int err = 0;
|
||||
u64 fpr_val;
|
||||
uint64_t __user *regs = (uint64_t *)&ctx->regs;
|
||||
uint64_t __user *fcc = &ctx->fcc;
|
||||
uint32_t __user *fcsr = &ctx->fcsr;
|
||||
|
||||
for (i = 0; i < NUM_FPU_REGS; i++) {
|
||||
err |= __get_user(fpr_val, ®s[i]);
|
||||
set_fpr64(¤t->thread.fpu.fpr[i], 0, fpr_val);
|
||||
}
|
||||
err |= __get_user(current->thread.fpu.fcc, fcc);
|
||||
err |= __get_user(current->thread.fpu.fcsr, fcsr);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/*
|
||||
* Wrappers for the assembly _{save,restore}_fp_context functions.
|
||||
*/
|
||||
static int save_hw_fpu_context(struct fpu_context __user *ctx)
|
||||
{
|
||||
uint64_t __user *regs = (uint64_t *)&ctx->regs;
|
||||
uint64_t __user *fcc = &ctx->fcc;
|
||||
uint32_t __user *fcsr = &ctx->fcsr;
|
||||
|
||||
return _save_fp_context(regs, fcc, fcsr);
|
||||
}
|
||||
|
||||
static int restore_hw_fpu_context(struct fpu_context __user *ctx)
|
||||
{
|
||||
uint64_t __user *regs = (uint64_t *)&ctx->regs;
|
||||
uint64_t __user *fcc = &ctx->fcc;
|
||||
uint32_t __user *fcsr = &ctx->fcsr;
|
||||
|
||||
return _restore_fp_context(regs, fcc, fcsr);
|
||||
}
|
||||
|
||||
static int fcsr_pending(unsigned int __user *fcsr)
|
||||
{
|
||||
int err, sig = 0;
|
||||
unsigned int csr, enabled;
|
||||
|
||||
err = __get_user(csr, fcsr);
|
||||
enabled = ((csr & FPU_CSR_ALL_E) << 24);
|
||||
/*
|
||||
* If the signal handler set some FPU exceptions, clear it and
|
||||
* send SIGFPE.
|
||||
*/
|
||||
if (csr & enabled) {
|
||||
csr &= ~enabled;
|
||||
err |= __put_user(csr, fcsr);
|
||||
sig = SIGFPE;
|
||||
}
|
||||
return err ?: sig;
|
||||
}
|
||||
|
||||
/*
|
||||
* Helper routines
|
||||
*/
|
||||
static int protected_save_fpu_context(struct extctx_layout *extctx)
|
||||
{
|
||||
int err = 0;
|
||||
struct sctx_info __user *info = extctx->fpu.addr;
|
||||
struct fpu_context __user *fpu_ctx = (struct fpu_context *)get_ctx_through_ctxinfo(info);
|
||||
uint64_t __user *regs = (uint64_t *)&fpu_ctx->regs;
|
||||
uint64_t __user *fcc = &fpu_ctx->fcc;
|
||||
uint32_t __user *fcsr = &fpu_ctx->fcsr;
|
||||
|
||||
while (1) {
|
||||
lock_fpu_owner();
|
||||
if (is_fpu_owner())
|
||||
err = save_hw_fpu_context(fpu_ctx);
|
||||
else
|
||||
err = copy_fpu_to_sigcontext(fpu_ctx);
|
||||
unlock_fpu_owner();
|
||||
|
||||
err |= __put_user(FPU_CTX_MAGIC, &info->magic);
|
||||
err |= __put_user(extctx->fpu.size, &info->size);
|
||||
|
||||
if (likely(!err))
|
||||
break;
|
||||
/* Touch the FPU context and try again */
|
||||
err = __put_user(0, ®s[0]) |
|
||||
__put_user(0, ®s[31]) |
|
||||
__put_user(0, fcc) |
|
||||
__put_user(0, fcsr);
|
||||
if (err)
|
||||
return err; /* really bad sigcontext */
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int protected_restore_fpu_context(struct extctx_layout *extctx)
|
||||
{
|
||||
int err = 0, sig = 0, tmp __maybe_unused;
|
||||
struct sctx_info __user *info = extctx->fpu.addr;
|
||||
struct fpu_context __user *fpu_ctx = (struct fpu_context *)get_ctx_through_ctxinfo(info);
|
||||
uint64_t __user *regs = (uint64_t *)&fpu_ctx->regs;
|
||||
uint64_t __user *fcc = &fpu_ctx->fcc;
|
||||
uint32_t __user *fcsr = &fpu_ctx->fcsr;
|
||||
|
||||
err = sig = fcsr_pending(fcsr);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
while (1) {
|
||||
lock_fpu_owner();
|
||||
if (is_fpu_owner())
|
||||
err = restore_hw_fpu_context(fpu_ctx);
|
||||
else
|
||||
err = copy_fpu_from_sigcontext(fpu_ctx);
|
||||
unlock_fpu_owner();
|
||||
|
||||
if (likely(!err))
|
||||
break;
|
||||
/* Touch the FPU context and try again */
|
||||
err = __get_user(tmp, ®s[0]) |
|
||||
__get_user(tmp, ®s[31]) |
|
||||
__get_user(tmp, fcc) |
|
||||
__get_user(tmp, fcsr);
|
||||
if (err)
|
||||
break; /* really bad sigcontext */
|
||||
}
|
||||
|
||||
return err ?: sig;
|
||||
}
|
||||
|
||||
static int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc,
|
||||
struct extctx_layout *extctx)
|
||||
{
|
||||
int i, err = 0;
|
||||
struct sctx_info __user *info;
|
||||
|
||||
err |= __put_user(regs->csr_era, &sc->sc_pc);
|
||||
err |= __put_user(extctx->flags, &sc->sc_flags);
|
||||
|
||||
err |= __put_user(0, &sc->sc_regs[0]);
|
||||
for (i = 1; i < 32; i++)
|
||||
err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
|
||||
|
||||
if (extctx->fpu.addr)
|
||||
err |= protected_save_fpu_context(extctx);
|
||||
|
||||
/* Set the "end" magic */
|
||||
info = (struct sctx_info *)extctx->end.addr;
|
||||
err |= __put_user(0, &info->magic);
|
||||
err |= __put_user(0, &info->size);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int parse_extcontext(struct sigcontext __user *sc, struct extctx_layout *extctx)
|
||||
{
|
||||
int err = 0;
|
||||
unsigned int magic, size;
|
||||
struct sctx_info __user *info = (struct sctx_info __user *)&sc->sc_extcontext;
|
||||
|
||||
while(1) {
|
||||
err |= __get_user(magic, &info->magic);
|
||||
err |= __get_user(size, &info->size);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
switch (magic) {
|
||||
case 0: /* END */
|
||||
goto done;
|
||||
|
||||
case FPU_CTX_MAGIC:
|
||||
if (size < (sizeof(struct sctx_info) +
|
||||
sizeof(struct fpu_context)))
|
||||
goto invalid;
|
||||
extctx->fpu.addr = info;
|
||||
break;
|
||||
|
||||
default:
|
||||
goto invalid;
|
||||
}
|
||||
|
||||
info = (struct sctx_info *)((char *)info + size);
|
||||
}
|
||||
|
||||
done:
|
||||
return 0;
|
||||
|
||||
invalid:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
|
||||
{
|
||||
int i, err = 0;
|
||||
struct extctx_layout extctx;
|
||||
|
||||
memset(&extctx, 0, sizeof(struct extctx_layout));
|
||||
|
||||
err = __get_user(extctx.flags, &sc->sc_flags);
|
||||
if (err)
|
||||
goto bad;
|
||||
|
||||
err = parse_extcontext(sc, &extctx);
|
||||
if (err)
|
||||
goto bad;
|
||||
|
||||
conditional_used_math(extctx.flags & SC_USED_FP);
|
||||
|
||||
/*
|
||||
* The signal handler may have used FPU; give it up if the program
|
||||
* doesn't want it following sigreturn.
|
||||
*/
|
||||
if (!(extctx.flags & SC_USED_FP))
|
||||
lose_fpu(0);
|
||||
|
||||
/* Always make any pending restarted system calls return -EINTR */
|
||||
current->restart_block.fn = do_no_restart_syscall;
|
||||
|
||||
err |= __get_user(regs->csr_era, &sc->sc_pc);
|
||||
for (i = 1; i < 32; i++)
|
||||
err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
|
||||
|
||||
if (extctx.fpu.addr)
|
||||
err |= protected_restore_fpu_context(&extctx);
|
||||
|
||||
bad:
|
||||
return err;
|
||||
}
|
||||
|
||||
static unsigned int handle_flags(void)
|
||||
{
|
||||
unsigned int flags = 0;
|
||||
|
||||
flags = used_math() ? SC_USED_FP : 0;
|
||||
|
||||
switch (current->thread.error_code) {
|
||||
case 1:
|
||||
flags |= SC_ADDRERR_RD;
|
||||
break;
|
||||
case 2:
|
||||
flags |= SC_ADDRERR_WR;
|
||||
break;
|
||||
}
|
||||
|
||||
return flags;
|
||||
}
|
||||
|
||||
static unsigned long extframe_alloc(struct extctx_layout *extctx,
|
||||
struct _ctx_layout *layout,
|
||||
size_t size, unsigned int align, unsigned long base)
|
||||
{
|
||||
unsigned long new_base = base - size;
|
||||
|
||||
new_base = round_down(new_base, (align < 16 ? 16 : align));
|
||||
new_base -= sizeof(struct sctx_info);
|
||||
|
||||
layout->addr = (void *)new_base;
|
||||
layout->size = (unsigned int)(base - new_base);
|
||||
extctx->size += layout->size;
|
||||
|
||||
return new_base;
|
||||
}
|
||||
|
||||
static unsigned long setup_extcontext(struct extctx_layout *extctx, unsigned long sp)
|
||||
{
|
||||
unsigned long new_sp = sp;
|
||||
|
||||
memset(extctx, 0, sizeof(struct extctx_layout));
|
||||
|
||||
extctx->flags = handle_flags();
|
||||
|
||||
/* Grow down, alloc "end" context info first. */
|
||||
new_sp -= sizeof(struct sctx_info);
|
||||
extctx->end.addr = (void *)new_sp;
|
||||
extctx->end.size = (unsigned int)sizeof(struct sctx_info);
|
||||
extctx->size += extctx->end.size;
|
||||
|
||||
if (extctx->flags & SC_USED_FP) {
|
||||
if (cpu_has_fpu)
|
||||
new_sp = extframe_alloc(extctx, &extctx->fpu,
|
||||
sizeof(struct fpu_context), FPU_CTX_ALIGN, new_sp);
|
||||
}
|
||||
|
||||
return new_sp;
|
||||
}
|
||||
|
||||
void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs,
|
||||
struct extctx_layout *extctx)
|
||||
{
|
||||
unsigned long sp;
|
||||
|
||||
/* Default to using normal stack */
|
||||
sp = regs->regs[3];
|
||||
|
||||
/*
|
||||
* If we are on the alternate signal stack and would overflow it, don't.
|
||||
* Return an always-bogus address instead so we will die with SIGSEGV.
|
||||
*/
|
||||
if (on_sig_stack(sp) &&
|
||||
!likely(on_sig_stack(sp - sizeof(struct rt_sigframe))))
|
||||
return (void __user __force *)(-1UL);
|
||||
|
||||
sp = sigsp(sp, ksig);
|
||||
sp = round_down(sp, 16);
|
||||
sp = setup_extcontext(extctx, sp);
|
||||
sp -= sizeof(struct rt_sigframe);
|
||||
|
||||
if (!IS_ALIGNED(sp, 16))
|
||||
BUG();
|
||||
|
||||
return (void __user *)sp;
|
||||
}
|
||||
|
||||
/*
|
||||
* Atomically swap in the new signal mask, and wait for a signal.
|
||||
*/
|
||||
|
||||
asmlinkage long sys_rt_sigreturn(void)
|
||||
{
|
||||
int sig;
|
||||
sigset_t set;
|
||||
struct pt_regs *regs;
|
||||
struct rt_sigframe __user *frame;
|
||||
|
||||
regs = current_pt_regs();
|
||||
frame = (struct rt_sigframe __user *)regs->regs[3];
|
||||
if (!access_ok(frame, sizeof(*frame)))
|
||||
goto badframe;
|
||||
if (__copy_from_user(&set, &frame->rs_uctx.uc_sigmask, sizeof(set)))
|
||||
goto badframe;
|
||||
|
||||
set_current_blocked(&set);
|
||||
|
||||
sig = restore_sigcontext(regs, &frame->rs_uctx.uc_mcontext);
|
||||
if (sig < 0)
|
||||
goto badframe;
|
||||
else if (sig)
|
||||
force_sig(sig);
|
||||
|
||||
regs->regs[0] = 0; /* No syscall restarting */
|
||||
if (restore_altstack(&frame->rs_uctx.uc_stack))
|
||||
goto badframe;
|
||||
|
||||
return regs->regs[4];
|
||||
|
||||
badframe:
|
||||
force_sig(SIGSEGV);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int setup_rt_frame(void *sig_return, struct ksignal *ksig,
|
||||
struct pt_regs *regs, sigset_t *set)
|
||||
{
|
||||
int err = 0;
|
||||
struct extctx_layout extctx;
|
||||
struct rt_sigframe __user *frame;
|
||||
|
||||
frame = get_sigframe(ksig, regs, &extctx);
|
||||
if (!access_ok(frame, sizeof(*frame) + extctx.size))
|
||||
return -EFAULT;
|
||||
|
||||
/* Create siginfo. */
|
||||
err |= copy_siginfo_to_user(&frame->rs_info, &ksig->info);
|
||||
|
||||
/* Create the ucontext. */
|
||||
err |= __put_user(0, &frame->rs_uctx.uc_flags);
|
||||
err |= __put_user(NULL, &frame->rs_uctx.uc_link);
|
||||
err |= __save_altstack(&frame->rs_uctx.uc_stack, regs->regs[3]);
|
||||
err |= setup_sigcontext(regs, &frame->rs_uctx.uc_mcontext, &extctx);
|
||||
err |= __copy_to_user(&frame->rs_uctx.uc_sigmask, set, sizeof(*set));
|
||||
|
||||
if (err)
|
||||
return -EFAULT;
|
||||
|
||||
/*
|
||||
* Arguments to signal handler:
|
||||
*
|
||||
* a0 = signal number
|
||||
* a1 = pointer to siginfo
|
||||
* a2 = pointer to ucontext
|
||||
*
|
||||
* c0_era point to the signal handler, $r3 (sp) points to
|
||||
* the struct rt_sigframe.
|
||||
*/
|
||||
regs->regs[4] = ksig->sig;
|
||||
regs->regs[5] = (unsigned long) &frame->rs_info;
|
||||
regs->regs[6] = (unsigned long) &frame->rs_uctx;
|
||||
regs->regs[3] = (unsigned long) frame;
|
||||
regs->regs[1] = (unsigned long) sig_return;
|
||||
regs->csr_era = (unsigned long) ksig->ka.sa.sa_handler;
|
||||
|
||||
DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
|
||||
current->comm, current->pid,
|
||||
frame, regs->csr_era, regs->regs[1]);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
|
||||
{
|
||||
int ret;
|
||||
sigset_t *oldset = sigmask_to_save();
|
||||
void *vdso = current->mm->context.vdso;
|
||||
|
||||
/* Are we from a system call? */
|
||||
if (regs->regs[0]) {
|
||||
switch (regs->regs[4]) {
|
||||
case -ERESTART_RESTARTBLOCK:
|
||||
case -ERESTARTNOHAND:
|
||||
regs->regs[4] = -EINTR;
|
||||
break;
|
||||
case -ERESTARTSYS:
|
||||
if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
|
||||
regs->regs[4] = -EINTR;
|
||||
break;
|
||||
}
|
||||
fallthrough;
|
||||
case -ERESTARTNOINTR:
|
||||
regs->regs[4] = regs->orig_a0;
|
||||
regs->csr_era -= 4;
|
||||
}
|
||||
|
||||
regs->regs[0] = 0; /* Don't deal with this again. */
|
||||
}
|
||||
|
||||
rseq_signal_deliver(ksig, regs);
|
||||
|
||||
ret = setup_rt_frame(vdso + current->thread.vdso->offset_sigreturn, ksig, regs, oldset);
|
||||
|
||||
signal_setup_done(ret, ksig, 0);
|
||||
}
|
||||
|
||||
void arch_do_signal_or_restart(struct pt_regs *regs, bool has_signal)
|
||||
{
|
||||
struct ksignal ksig;
|
||||
|
||||
if (has_signal && get_signal(&ksig)) {
|
||||
/* Whee! Actually deliver the signal. */
|
||||
handle_signal(&ksig, regs);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Are we from a system call? */
|
||||
if (regs->regs[0]) {
|
||||
switch (regs->regs[4]) {
|
||||
case -ERESTARTNOHAND:
|
||||
case -ERESTARTSYS:
|
||||
case -ERESTARTNOINTR:
|
||||
regs->regs[4] = regs->orig_a0;
|
||||
regs->csr_era -= 4;
|
||||
break;
|
||||
|
||||
case -ERESTART_RESTARTBLOCK:
|
||||
regs->regs[4] = regs->orig_a0;
|
||||
regs->regs[11] = __NR_restart_syscall;
|
||||
regs->csr_era -= 4;
|
||||
break;
|
||||
}
|
||||
regs->regs[0] = 0; /* Don't deal with this again. */
|
||||
}
|
||||
|
||||
/*
|
||||
* If there's no signal to deliver, we just put the saved sigmask
|
||||
* back
|
||||
*/
|
||||
restore_saved_sigmask();
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user