From nobody Tue Feb 10 22:17:56 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 49B70C433F5 for ; Sat, 14 May 2022 08:08:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229846AbiENIIR (ORCPT ); Sat, 14 May 2022 04:08:17 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44330 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229942AbiENIGj (ORCPT ); Sat, 14 May 2022 04:06:39 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D93413DDFF; Sat, 14 May 2022 01:05:45 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 6476C60B55; Sat, 14 May 2022 08:05:45 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id E8CDFC34118; Sat, 14 May 2022 08:05:38 +0000 (UTC) From: Huacai Chen To: Arnd Bergmann , Andy Lutomirski , Thomas Gleixner , Peter Zijlstra , Andrew Morton , David Airlie , Jonathan Corbet , Linus Torvalds Cc: linux-arch@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, Xuefeng Li , Yanteng Si , Huacai Chen , Guo Ren , Xuerui Wang , Jiaxun Yang , Stephen Rothwell , Huacai Chen , Eric Biederman , Al Viro Subject: [PATCH V10 14/22] LoongArch: Add signal handling support Date: Sat, 14 May 2022 16:03:54 +0800 Message-Id: <20220514080402.2650181-15-chenhuacai@loongson.cn> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20220514080402.2650181-1-chenhuacai@loongson.cn> References: <20220514080402.2650181-1-chenhuacai@loongson.cn> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add ucontext/sigcontext definition and signal handling support for LoongArch. Cc: Eric Biederman Cc: Al Viro Signed-off-by: Huacai Chen Reviewed-by: WANG Xuerui --- arch/loongarch/include/uapi/asm/sigcontext.h | 63 ++ arch/loongarch/include/uapi/asm/signal.h | 13 + arch/loongarch/include/uapi/asm/ucontext.h | 35 ++ arch/loongarch/kernel/signal.c | 568 +++++++++++++++++++ 4 files changed, 679 insertions(+) create mode 100644 arch/loongarch/include/uapi/asm/sigcontext.h create mode 100644 arch/loongarch/include/uapi/asm/signal.h create mode 100644 arch/loongarch/include/uapi/asm/ucontext.h create mode 100644 arch/loongarch/kernel/signal.c diff --git a/arch/loongarch/include/uapi/asm/sigcontext.h b/arch/loongarch/= include/uapi/asm/sigcontext.h new file mode 100644 index 000000000000..efeb8b3f8236 --- /dev/null +++ b/arch/loongarch/include/uapi/asm/sigcontext.h @@ -0,0 +1,63 @@ +/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ +/* + * Author: Hanlu Li + * Huacai Chen + * + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited + */ +#ifndef _UAPI_ASM_SIGCONTEXT_H +#define _UAPI_ASM_SIGCONTEXT_H + +#include +#include + +/* FP context was used */ +#define USED_FP (1 << 0) +/* Load/Store access flags for address error */ +#define ADRERR_RD (1 << 30) +#define ADRERR_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 _ctxinfo { + __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; +}; + +/* LSX context */ +#define LSX_CTX_MAGIC 0x53580001 +#define LSX_CTX_ALIGN 16 +struct lsx_context { + __u64 regs[2*32]; + __u64 fcc; + __u32 fcsr; + __u32 vcsr; +}; + +/* LASX context */ +#define LASX_CTX_MAGIC 0x41535801 +#define LASX_CTX_ALIGN 32 +struct lasx_context { + __u64 regs[4*32]; + __u64 fcc; + __u32 fcsr; + __u32 vcsr; +}; + +#endif /* _UAPI_ASM_SIGCONTEXT_H */ diff --git a/arch/loongarch/include/uapi/asm/signal.h b/arch/loongarch/incl= ude/uapi/asm/signal.h new file mode 100644 index 000000000000..992d965aa13f --- /dev/null +++ b/arch/loongarch/include/uapi/asm/signal.h @@ -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 + +#endif diff --git a/arch/loongarch/include/uapi/asm/ucontext.h b/arch/loongarch/in= clude/uapi/asm/ucontext.h new file mode 100644 index 000000000000..12577e22b1c7 --- /dev/null +++ b/arch/loongarch/include/uapi/asm/ucontext.h @@ -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 */ diff --git a/arch/loongarch/kernel/signal.c b/arch/loongarch/kernel/signal.c new file mode 100644 index 000000000000..489e169e1d13 --- /dev/null +++ b/arch/loongarch/kernel/signal.c @@ -0,0 +1,568 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Author: Hanlu Li + * Huacai Chen + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#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 *cs= r); + +struct rt_sigframe { + struct siginfo rs_info; + struct ucontext rs_uctx; +}; + +struct _ctx_layout { + struct _ctxinfo *addr; + unsigned int size; +}; + +struct extctx_layout { + unsigned long size; + unsigned int flags; + struct _ctx_layout fpu; + struct _ctx_layout lsx; + struct _ctx_layout lasx; + struct _ctx_layout end; +}; + +static void __user *get_ctx_through_ctxinfo(struct _ctxinfo *info) +{ + return (void __user *)((char *)info + sizeof(struct _ctxinfo)); +} + +/* + * 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 =3D 0; + uint64_t __user *regs =3D (uint64_t *)&ctx->regs; + uint64_t __user *fcc =3D &ctx->fcc; + uint32_t __user *fcsr =3D &ctx->fcsr; + + for (i =3D 0; i < NUM_FPU_REGS; i++) { + err |=3D + __put_user(get_fpr64(¤t->thread.fpu.fpr[i], 0), + ®s[i]); + } + err |=3D __put_user(current->thread.fpu.fcc, fcc); + err |=3D __put_user(current->thread.fpu.fcsr, fcsr); + + return err; +} + +static int copy_fpu_from_sigcontext(struct fpu_context __user *ctx) +{ + int i; + int err =3D 0; + u64 fpr_val; + uint64_t __user *regs =3D (uint64_t *)&ctx->regs; + uint64_t __user *fcc =3D &ctx->fcc; + uint32_t __user *fcsr =3D &ctx->fcsr; + + for (i =3D 0; i < NUM_FPU_REGS; i++) { + err |=3D __get_user(fpr_val, ®s[i]); + set_fpr64(¤t->thread.fpu.fpr[i], 0, fpr_val); + } + err |=3D __get_user(current->thread.fpu.fcc, fcc); + err |=3D __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 =3D (uint64_t *)&ctx->regs; + uint64_t __user *fcc =3D &ctx->fcc; + uint32_t __user *fcsr =3D &ctx->fcsr; + + return _save_fp_context(regs, fcc, fcsr); +} + +static int restore_hw_fpu_context(struct fpu_context __user *ctx) +{ + uint64_t __user *regs =3D (uint64_t *)&ctx->regs; + uint64_t __user *fcc =3D &ctx->fcc; + uint32_t __user *fcsr =3D &ctx->fcsr; + + return _restore_fp_context(regs, fcc, fcsr); +} + +int fpcsr_pending(unsigned int __user *fpcsr) +{ + int err, sig =3D 0; + unsigned int csr, enabled; + + err =3D __get_user(csr, fpcsr); + enabled =3D ((csr & FPU_CSR_ALL_E) << 24); + /* + * If the signal handler set some FPU exceptions, clear it and + * send SIGFPE. + */ + if (csr & enabled) { + csr &=3D ~enabled; + err |=3D __put_user(csr, fpcsr); + sig =3D SIGFPE; + } + return err ?: sig; +} + +/* + * Helper routines + */ +static int protected_save_fpu_context(struct extctx_layout *extctx) +{ + int err =3D 0; + struct _ctxinfo __user *info =3D extctx->fpu.addr; + struct fpu_context __user *fpu_ctx =3D (struct fpu_context *)get_ctx_thro= ugh_ctxinfo(info); + uint64_t __user *regs =3D (uint64_t *)&fpu_ctx->regs; + uint64_t __user *fcc =3D &fpu_ctx->fcc; + uint32_t __user *fcsr =3D &fpu_ctx->fcsr; + + while (1) { + lock_fpu_owner(); + if (is_fpu_owner()) + err =3D save_hw_fpu_context(fpu_ctx); + else + err =3D copy_fpu_to_sigcontext(fpu_ctx); + unlock_fpu_owner(); + + err |=3D __put_user(FPU_CTX_MAGIC, &info->magic); + err |=3D __put_user(extctx->fpu.size, &info->size); + + if (likely(!err)) + break; + /* Touch the FPU context and try again */ + err =3D __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 =3D 0, sig =3D 0, tmp __maybe_unused; + struct _ctxinfo __user *info =3D extctx->fpu.addr; + struct fpu_context __user *fpu_ctx =3D (struct fpu_context *)get_ctx_thro= ugh_ctxinfo(info); + uint64_t __user *regs =3D (uint64_t *)&fpu_ctx->regs; + uint64_t __user *fcc =3D &fpu_ctx->fcc; + uint32_t __user *fcsr =3D &fpu_ctx->fcsr; + + err =3D sig =3D fpcsr_pending(fcsr); + if (err < 0) + return err; + + while (1) { + lock_fpu_owner(); + if (is_fpu_owner()) + err =3D restore_hw_fpu_context(fpu_ctx); + else + err =3D copy_fpu_from_sigcontext(fpu_ctx); + unlock_fpu_owner(); + + if (likely(!err)) + break; + /* Touch the FPU context and try again */ + err =3D __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 =3D 0; + struct _ctxinfo __user *info; + + err |=3D __put_user(regs->csr_era, &sc->sc_pc); + err |=3D __put_user(extctx->flags, &sc->sc_flags); + + err |=3D __put_user(0, &sc->sc_regs[0]); + for (i =3D 1; i < 32; i++) + err |=3D __put_user(regs->regs[i], &sc->sc_regs[i]); + + if (extctx->fpu.addr) + err |=3D protected_save_fpu_context(extctx); + + /* Set the "end" magic */ + info =3D (struct _ctxinfo *)extctx->end.addr; + err |=3D __put_user(0, &info->magic); + err |=3D __put_user(0, &info->size); + + return err; +} + +static int parse_extcontext(struct sigcontext __user *sc, struct extctx_la= yout *extctx) +{ + int err =3D 0; + unsigned int magic, size; + struct _ctxinfo __user *info =3D (struct _ctxinfo __user *)&sc->sc_extcon= text; + + while(1) { + err |=3D __get_user(magic, &info->magic); + err |=3D __get_user(size, &info->size); + if (err) + return err; + + switch (magic) { + case 0: /* END */ + goto done; + + case FPU_CTX_MAGIC: + if (size < (sizeof(struct _ctxinfo) + + sizeof(struct fpu_context))) + goto invalid; + extctx->fpu.addr =3D info; + break; + + default: + goto invalid; + } + + info =3D (struct _ctxinfo *)((char *)info + size); + } + +done: + return 0; + +invalid: + return -EINVAL; +} + +static int restore_sigcontext(struct pt_regs *regs, struct sigcontext __us= er *sc) +{ + int i, err =3D 0; + struct extctx_layout extctx; + + memset(&extctx, 0, sizeof(struct extctx_layout)); + + err =3D __get_user(extctx.flags, &sc->sc_flags); + if (err) + goto bad; + + err =3D parse_extcontext(sc, &extctx); + if (err) + goto bad; + + conditional_used_math(extctx.flags & USED_FP); + + /* + * The signal handler may have used FPU; give it up if the program + * doesn't want it following sigreturn. + */ + if (!(extctx.flags & USED_FP)) + lose_fpu(0); + + /* Always make any pending restarted system calls return -EINTR */ + current->restart_block.fn =3D do_no_restart_syscall; + + err |=3D __get_user(regs->csr_era, &sc->sc_pc); + for (i =3D 1; i < 32; i++) + err |=3D __get_user(regs->regs[i], &sc->sc_regs[i]); + + if (extctx.fpu.addr) + err |=3D protected_restore_fpu_context(&extctx); + +bad: + return err; +} + +static unsigned int handle_flags(void) +{ + unsigned int flags =3D 0; + + flags |=3D used_math() ? USED_FP : 0; + + switch (current->thread.error_code) { + case 1: + flags |=3D ADRERR_RD; + break; + case 2: + flags |=3D ADRERR_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 =3D base - size; + + new_base =3D round_down(new_base, (align < 16 ? 16 : align)); + new_base -=3D sizeof(struct _ctxinfo); + + layout->addr =3D (void *)new_base; + layout->size =3D (unsigned int)(base - new_base); + extctx->size +=3D layout->size; + + return new_base; +} + +static unsigned long setup_extcontext(struct extctx_layout *extctx, unsign= ed long sp) +{ + unsigned long new_sp =3D sp; + + memset(extctx, 0, sizeof(struct extctx_layout)); + + extctx->flags =3D handle_flags(); + + /* Grow down, alloc "end" context info first. */ + new_sp -=3D sizeof(struct _ctxinfo); + extctx->end.addr =3D (void *)new_sp; + extctx->end.size =3D (unsigned int)sizeof(struct _ctxinfo); + extctx->size +=3D extctx->end.size; + + if (extctx->flags & USED_FP) { + if (cpu_has_fpu) + new_sp =3D 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 =3D 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 =3D sigsp(sp, ksig); + sp =3D round_down(sp, 16); + sp =3D setup_extcontext(extctx, sp); + sp -=3D 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 =3D current_pt_regs(); + frame =3D (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 =3D restore_sigcontext(regs, &frame->rs_uctx.uc_mcontext); + if (sig < 0) + goto badframe; + else if (sig) + force_sig(sig); + + regs->regs[0] =3D 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 =3D 0; + struct extctx_layout extctx; + struct rt_sigframe __user *frame; + + frame =3D get_sigframe(ksig, regs, &extctx); + if (!access_ok(frame, sizeof(*frame) + extctx.size)) + return -EFAULT; + + /* Create siginfo. */ + err |=3D copy_siginfo_to_user(&frame->rs_info, &ksig->info); + + /* Create the ucontext. */ + err |=3D __put_user(0, &frame->rs_uctx.uc_flags); + err |=3D __put_user(NULL, &frame->rs_uctx.uc_link); + err |=3D __save_altstack(&frame->rs_uctx.uc_stack, regs->regs[3]); + err |=3D setup_sigcontext(regs, &frame->rs_uctx.uc_mcontext, &extctx); + err |=3D __copy_to_user(&frame->rs_uctx.uc_sigmask, set, sizeof(*set)); + + if (err) + return -EFAULT; + + /* + * Arguments to signal handler: + * + * a0 =3D signal number + * a1 =3D pointer to siginfo + * a2 =3D pointer to ucontext + * + * c0_era point to the signal handler, $r3 (sp) points to + * the struct rt_sigframe. + */ + regs->regs[4] =3D ksig->sig; + regs->regs[5] =3D (unsigned long) &frame->rs_info; + regs->regs[6] =3D (unsigned long) &frame->rs_uctx; + regs->regs[3] =3D (unsigned long) frame; + regs->regs[1] =3D (unsigned long) sig_return; + regs->csr_era =3D (unsigned long) ksig->ka.sa.sa_handler; + + DEBUGP("SIG deliver (%s:%d): sp=3D0x%p pc=3D0x%lx ra=3D0x%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 =3D sigmask_to_save(); + void *vdso =3D 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] =3D -EINTR; + break; + case -ERESTARTSYS: + if (!(ksig->ka.sa.sa_flags & SA_RESTART)) { + regs->regs[4] =3D -EINTR; + break; + } + fallthrough; + case -ERESTARTNOINTR: + regs->regs[4] =3D regs->orig_a0; + regs->csr_era -=3D 4; + } + + regs->regs[0] =3D 0; /* Don't deal with this again. */ + } + + rseq_signal_deliver(ksig, regs); + + ret =3D setup_rt_frame(vdso + current->thread.vdso->offset_sigreturn, ksi= g, 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] =3D regs->orig_a0; + regs->csr_era -=3D 4; + break; + + case -ERESTART_RESTARTBLOCK: + regs->regs[4] =3D regs->orig_a0; + regs->regs[11] =3D __NR_restart_syscall; + regs->csr_era -=3D 4; + break; + } + regs->regs[0] =3D 0; /* Don't deal with this again. */ + } + + /* + * If there's no signal to deliver, we just put the saved sigmask + * back + */ + restore_saved_sigmask(); +} --=20 2.27.0