linux-user/riscv/signal.c

   1 /*
   2  *  Emulation of Linux signals
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include "qemu/osdep.h"
  20 #include "qemu.h"
  21 #include "user-internals.h"
  22 #include "signal-common.h"
  23 #include "linux-user/trace.h"
  24
  25 /* Signal handler invocation must be transparent for the code being
  26    interrupted. Complete CPU (hart) state is saved on entry and restored
  27    before returning from the handler. Process sigmask is also saved to block
  28    signals while the handler is running. The handler gets its own stack,
  29    which also doubles as storage for the CPU state and sigmask.
  30
  31    The code below is qemu re-implementation of arch/riscv/kernel/signal.c */
  32
  33 struct target_sigcontext {
  34     abi_long pc;
  35     abi_long gpr[31]; /* x0 is not present, so all offsets must be -1 */
  36     uint64_t fpr[32];
  37     uint32_t fcsr;
  38 }; /* cf. riscv-linux:arch/riscv/include/uapi/asm/ptrace.h */
  39
  40 struct target_ucontext {
  41     unsigned long uc_flags;
  42     struct target_ucontext *uc_link;
  43     target_stack_t uc_stack;
  44     target_sigset_t uc_sigmask;
  45     uint8_t   __unused[1024 / 8 - sizeof(target_sigset_t)];
  46     struct target_sigcontext uc_mcontext QEMU_ALIGNED(16);
  47 };
  48
  49 struct target_rt_sigframe {
  50     struct target_siginfo info;
  51     struct target_ucontext uc;
  52 };
  53
  54 static abi_ulong get_sigframe(struct target_sigaction *ka,
  55                               CPURISCVState *regs, size_t framesize)
  56 {
  57     abi_ulong sp = get_sp_from_cpustate(regs);
  58
  59     /* If we are on the alternate signal stack and would overflow it, don't.
  60        Return an always-bogus address instead so we will die with SIGSEGV. */
  61     if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize))) {
  62         return -1L;
  63     }
  64
  65     /* This is the X/Open sanctioned signal stack switching.  */
  66     sp = target_sigsp(sp, ka) - framesize;
  67
  68     /* XXX: kernel aligns with 0xf ? */
  69     sp &= ~3UL; /* align sp on 4-byte boundary */
  70
  71     return sp;
  72 }
  73
  74 static void setup_sigcontext(struct target_sigcontext *sc, CPURISCVState *env)
  75 {
  76     int i;
  77
  78     __put_user(env->pc, &sc->pc);
  79
  80     for (i = 1; i < 32; i++) {
  81         __put_user(env->gpr[i], &sc->gpr[i - 1]);
  82     }
  83     for (i = 0; i < 32; i++) {
  84         __put_user(env->fpr[i], &sc->fpr[i]);
  85     }
  86
  87     uint32_t fcsr = riscv_csr_read(env, CSR_FCSR);
  88     __put_user(fcsr, &sc->fcsr);
  89 }
  90
  91 static void setup_ucontext(struct target_ucontext *uc,
  92                            CPURISCVState *env, target_sigset_t *set)
  93 {
  94     __put_user(0,    &(uc->uc_flags));
  95     __put_user(0,    &(uc->uc_link));
  96
  97     target_save_altstack(&uc->uc_stack, env);
  98
  99     int i;
 100     for (i = 0; i < TARGET_NSIG_WORDS; i++) {
 101         __put_user(set->sig[i], &(uc->uc_sigmask.sig[i]));
 102     }
 103
 104     setup_sigcontext(&uc->uc_mcontext, env);
 105 }
 106
 107 void setup_rt_frame(int sig, struct target_sigaction *ka,
 108                     target_siginfo_t *info,
 109                     target_sigset_t *set, CPURISCVState *env)
 110 {
 111     abi_ulong frame_addr;
 112     struct target_rt_sigframe *frame;
 113
 114     frame_addr = get_sigframe(ka, env, sizeof(*frame));
 115     trace_user_setup_rt_frame(env, frame_addr);
 116
 117     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
 118         goto badframe;
 119     }
 120
 121     setup_ucontext(&frame->uc, env, set);
 122     tswap_siginfo(&frame->info, info);
 123
 124     env->pc = ka->_sa_handler;
 125     env->gpr[xSP] = frame_addr;
 126     env->gpr[xA0] = sig;
 127     env->gpr[xA1] = frame_addr + offsetof(struct target_rt_sigframe, info);
 128     env->gpr[xA2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
 129     env->gpr[xRA] = default_rt_sigreturn;
 130
 131     return;
 132
 133 badframe:
 134     unlock_user_struct(frame, frame_addr, 1);
 135     if (sig == TARGET_SIGSEGV) {
 136         ka->_sa_handler = TARGET_SIG_DFL;
 137     }
 138     force_sig(TARGET_SIGSEGV);
 139 }
 140
 141 static void restore_sigcontext(CPURISCVState *env, struct target_sigcontext *sc)
 142 {
 143     int i;
 144
 145     __get_user(env->pc, &sc->pc);
 146
 147     for (i = 1; i < 32; ++i) {
 148         __get_user(env->gpr[i], &sc->gpr[i - 1]);
 149     }
 150     for (i = 0; i < 32; ++i) {
 151         __get_user(env->fpr[i], &sc->fpr[i]);
 152     }
 153
 154     uint32_t fcsr;
 155     __get_user(fcsr, &sc->fcsr);
 156     riscv_csr_write(env, CSR_FCSR, fcsr);
 157 }
 158
 159 static void restore_ucontext(CPURISCVState *env, struct target_ucontext *uc)
 160 {
 161     sigset_t blocked;
 162     target_sigset_t target_set;
 163     int i;
 164
 165     target_sigemptyset(&target_set);
 166     for (i = 0; i < TARGET_NSIG_WORDS; i++) {
 167         __get_user(target_set.sig[i], &(uc->uc_sigmask.sig[i]));
 168     }
 169
 170     target_to_host_sigset_internal(&blocked, &target_set);
 171     set_sigmask(&blocked);
 172
 173     restore_sigcontext(env, &uc->uc_mcontext);
 174 }
 175
 176 long do_rt_sigreturn(CPURISCVState *env)
 177 {
 178     struct target_rt_sigframe *frame;
 179     abi_ulong frame_addr;
 180
 181     frame_addr = env->gpr[xSP];
 182     trace_user_do_sigreturn(env, frame_addr);
 183     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
 184         goto badframe;
 185     }
 186
 187     restore_ucontext(env, &frame->uc);
 188     target_restore_altstack(&frame->uc.uc_stack, env);
 189
 190     unlock_user_struct(frame, frame_addr, 0);
 191     return -TARGET_QEMU_ESIGRETURN;
 192
 193 badframe:
 194     unlock_user_struct(frame, frame_addr, 0);
 195     force_sig(TARGET_SIGSEGV);
 196     return 0;
 197 }
 198
 199 void setup_sigtramp(abi_ulong sigtramp_page)
 200 {
 201     uint32_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 8, 0);
 202     assert(tramp != NULL);
 203
 204     __put_user(0x08b00893, tramp + 0);  /* li a7, 139 = __NR_rt_sigreturn */
 205     __put_user(0x00000073, tramp + 1);  /* ecall */
 206
 207     default_rt_sigreturn = sigtramp_page;
 208     unlock_user(tramp, sigtramp_page, 8);
 209 }