linux-user/loongarch64/signal.c

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * LoongArch emulation of Linux signals
   4  *
   5  * Copyright (c) 2021 Loongson Technology Corporation Limited
   6  */
   7
   8 #include "qemu/osdep.h"
   9 #include "qemu.h"
  10 #include "user-internals.h"
  11 #include "signal-common.h"
  12 #include "linux-user/trace.h"
  13
  14 #include "target/loongarch/internals.h"
  15 #include "target/loongarch/vec.h"
  16
  17 /* FP context was used */
  18 #define SC_USED_FP              (1 << 0)
  19
  20 struct target_sigcontext {
  21     uint64_t sc_pc;
  22     uint64_t sc_regs[32];
  23     uint32_t sc_flags;
  24     uint64_t sc_extcontext[0]   QEMU_ALIGNED(16);
  25 };
  26
  27
  28 #define FPU_CTX_MAGIC           0x46505501
  29 #define FPU_CTX_ALIGN           8
  30 struct target_fpu_context {
  31     uint64_t regs[32];
  32     uint64_t fcc;
  33     uint32_t fcsr;
  34 } QEMU_ALIGNED(FPU_CTX_ALIGN);
  35
  36 #define CONTEXT_INFO_ALIGN      16
  37 struct target_sctx_info {
  38     uint32_t magic;
  39     uint32_t size;
  40     uint64_t padding;
  41 } QEMU_ALIGNED(CONTEXT_INFO_ALIGN);
  42
  43 struct target_ucontext {
  44     abi_ulong tuc_flags;
  45     abi_ptr tuc_link;
  46     target_stack_t tuc_stack;
  47     target_sigset_t tuc_sigmask;
  48     uint8_t __unused[1024 / 8 - sizeof(target_sigset_t)];
  49     struct target_sigcontext tuc_mcontext;
  50 };
  51
  52 struct target_rt_sigframe {
  53     struct target_siginfo        rs_info;
  54     struct target_ucontext       rs_uc;
  55 };
  56
  57 /*
  58  * These two structures are not present in guest memory, are private
  59  * to the signal implementation, but are largely copied from the
  60  * kernel's signal implementation.
  61  */
  62 struct ctx_layout {
  63     void *haddr;
  64     abi_ptr gaddr;
  65     unsigned int size;
  66 };
  67
  68 struct extctx_layout {
  69     unsigned int size;
  70     unsigned int flags;
  71     struct ctx_layout fpu;
  72     struct ctx_layout end;
  73 };
  74
  75 static abi_ptr extframe_alloc(struct extctx_layout *extctx,
  76                               struct ctx_layout *sctx, unsigned size,
  77                               unsigned align, abi_ptr orig_sp)
  78 {
  79     abi_ptr sp = orig_sp;
  80
  81     sp -= sizeof(struct target_sctx_info) + size;
  82     align = MAX(align, CONTEXT_INFO_ALIGN);
  83     sp = ROUND_DOWN(sp, align);
  84     sctx->gaddr = sp;
  85
  86     size = orig_sp - sp;
  87     sctx->size = size;
  88     extctx->size += size;
  89
  90     return sp;
  91 }
  92
  93 static abi_ptr setup_extcontext(struct extctx_layout *extctx, abi_ptr sp)
  94 {
  95     memset(extctx, 0, sizeof(struct extctx_layout));
  96
  97     /* Grow down, alloc "end" context info first. */
  98     sp = extframe_alloc(extctx, &extctx->end, 0, CONTEXT_INFO_ALIGN, sp);
  99
 100     /* For qemu, there is no lazy fp context switch, so fp always present. */
 101     extctx->flags = SC_USED_FP;
 102     sp = extframe_alloc(extctx, &extctx->fpu,
 103                         sizeof(struct target_rt_sigframe), FPU_CTX_ALIGN, sp);
 104
 105     return sp;
 106 }
 107
 108 static void setup_sigframe(CPULoongArchState *env,
 109                            struct target_sigcontext *sc,
 110                            struct extctx_layout *extctx)
 111 {
 112     struct target_sctx_info *info;
 113     struct target_fpu_context *fpu_ctx;
 114     int i;
 115
 116     __put_user(extctx->flags, &sc->sc_flags);
 117     __put_user(env->pc, &sc->sc_pc);
 118     __put_user(0, &sc->sc_regs[0]);
 119     for (i = 1; i < 32; ++i) {
 120         __put_user(env->gpr[i], &sc->sc_regs[i]);
 121     }
 122
 123     /*
 124      * Set fpu context
 125      */
 126     info = extctx->fpu.haddr;
 127     __put_user(FPU_CTX_MAGIC, &info->magic);
 128     __put_user(extctx->fpu.size, &info->size);
 129
 130     fpu_ctx = (struct target_fpu_context *)(info + 1);
 131     for (i = 0; i < 32; ++i) {
 132         __put_user(env->fpr[i].vreg.D(0), &fpu_ctx->regs[i]);
 133     }
 134     __put_user(read_fcc(env), &fpu_ctx->fcc);
 135     __put_user(env->fcsr0, &fpu_ctx->fcsr);
 136
 137     /*
 138      * Set end context
 139      */
 140     info = extctx->end.haddr;
 141     __put_user(0, &info->magic);
 142     __put_user(extctx->end.size, &info->size);
 143 }
 144
 145 static bool parse_extcontext(struct extctx_layout *extctx, abi_ptr frame)
 146 {
 147     memset(extctx, 0, sizeof(*extctx));
 148
 149     while (1) {
 150         uint32_t magic, size;
 151
 152         if (get_user_u32(magic, frame) || get_user_u32(size, frame + 4)) {
 153             return false;
 154         }
 155
 156         switch (magic) {
 157         case 0: /* END */
 158             extctx->end.gaddr = frame;
 159             extctx->end.size = size;
 160             extctx->size += size;
 161             return true;
 162
 163         case FPU_CTX_MAGIC:
 164             if (size < (sizeof(struct target_sctx_info) +
 165                         sizeof(struct target_fpu_context))) {
 166                 return false;
 167             }
 168             extctx->fpu.gaddr = frame;
 169             extctx->fpu.size = size;
 170             extctx->size += size;
 171             break;
 172         default:
 173             return false;
 174         }
 175
 176         frame += size;
 177     }
 178 }
 179
 180 static void restore_sigframe(CPULoongArchState *env,
 181                              struct target_sigcontext *sc,
 182                              struct extctx_layout *extctx)
 183 {
 184     int i;
 185
 186     __get_user(env->pc, &sc->sc_pc);
 187     for (i = 1; i < 32; ++i) {
 188         __get_user(env->gpr[i], &sc->sc_regs[i]);
 189     }
 190
 191     if (extctx->fpu.haddr) {
 192         struct target_fpu_context *fpu_ctx =
 193             extctx->fpu.haddr + sizeof(struct target_sctx_info);
 194         uint64_t fcc;
 195
 196         for (i = 0; i < 32; ++i) {
 197             __get_user(env->fpr[i].vreg.D(0), &fpu_ctx->regs[i]);
 198         }
 199         __get_user(fcc, &fpu_ctx->fcc);
 200         write_fcc(env, fcc);
 201         __get_user(env->fcsr0, &fpu_ctx->fcsr);
 202         restore_fp_status(env);
 203     }
 204 }
 205
 206 /*
 207  * Determine which stack to use.
 208  */
 209 static abi_ptr get_sigframe(struct target_sigaction *ka,
 210                             CPULoongArchState *env,
 211                             struct extctx_layout *extctx)
 212 {
 213     abi_ulong sp;
 214
 215     sp = target_sigsp(get_sp_from_cpustate(env), ka);
 216     sp = ROUND_DOWN(sp, 16);
 217     sp = setup_extcontext(extctx, sp);
 218     sp -= sizeof(struct target_rt_sigframe);
 219
 220     assert(QEMU_IS_ALIGNED(sp, 16));
 221
 222     return sp;
 223 }
 224
 225 void setup_rt_frame(int sig, struct target_sigaction *ka,
 226                     target_siginfo_t *info,
 227                     target_sigset_t *set, CPULoongArchState *env)
 228 {
 229     struct target_rt_sigframe *frame;
 230     struct extctx_layout extctx;
 231     abi_ptr frame_addr;
 232     int i;
 233
 234     frame_addr = get_sigframe(ka, env, &extctx);
 235     trace_user_setup_rt_frame(env, frame_addr);
 236
 237     frame = lock_user(VERIFY_WRITE, frame_addr,
 238                       sizeof(*frame) + extctx.size, 0);
 239     if (!frame) {
 240         force_sigsegv(sig);
 241         return;
 242     }
 243     extctx.fpu.haddr = (void *)frame + (extctx.fpu.gaddr - frame_addr);
 244     extctx.end.haddr = (void *)frame + (extctx.end.gaddr - frame_addr);
 245
 246     tswap_siginfo(&frame->rs_info, info);
 247
 248     __put_user(0, &frame->rs_uc.tuc_flags);
 249     __put_user(0, &frame->rs_uc.tuc_link);
 250     target_save_altstack(&frame->rs_uc.tuc_stack, env);
 251
 252     setup_sigframe(env, &frame->rs_uc.tuc_mcontext, &extctx);
 253
 254     for (i = 0; i < TARGET_NSIG_WORDS; i++) {
 255         __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]);
 256     }
 257
 258     env->gpr[4] = sig;
 259     env->gpr[5] = frame_addr + offsetof(struct target_rt_sigframe, rs_info);
 260     env->gpr[6] = frame_addr + offsetof(struct target_rt_sigframe, rs_uc);
 261     env->gpr[3] = frame_addr;
 262     env->gpr[1] = default_rt_sigreturn;
 263
 264     env->pc = ka->_sa_handler;
 265     unlock_user(frame, frame_addr, sizeof(*frame) + extctx.size);
 266 }
 267
 268 long do_rt_sigreturn(CPULoongArchState *env)
 269 {
 270     struct target_rt_sigframe *frame;
 271     struct extctx_layout extctx;
 272     abi_ulong frame_addr;
 273     sigset_t blocked;
 274
 275     frame_addr = env->gpr[3];
 276     trace_user_do_rt_sigreturn(env, frame_addr);
 277
 278     if (!parse_extcontext(&extctx, frame_addr + sizeof(*frame))) {
 279         goto badframe;
 280     }
 281
 282     frame = lock_user(VERIFY_READ, frame_addr,
 283                       sizeof(*frame) + extctx.size, 1);
 284     if (!frame) {
 285         goto badframe;
 286     }
 287     if (extctx.fpu.gaddr) {
 288         extctx.fpu.haddr = (void *)frame + (extctx.fpu.gaddr - frame_addr);
 289     }
 290
 291     target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask);
 292     set_sigmask(&blocked);
 293
 294     restore_sigframe(env, &frame->rs_uc.tuc_mcontext, &extctx);
 295
 296     target_restore_altstack(&frame->rs_uc.tuc_stack, env);
 297
 298     unlock_user(frame, frame_addr, 0);
 299     return -QEMU_ESIGRETURN;
 300
 301  badframe:
 302     force_sig(TARGET_SIGSEGV);
 303     return -QEMU_ESIGRETURN;
 304 }
 305
 306 void setup_sigtramp(abi_ulong sigtramp_page)
 307 {
 308     uint32_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 8, 0);
 309     assert(tramp != NULL);
 310
 311     __put_user(0x03822c0b, tramp + 0);  /* ori     a7, zero, 0x8b */
 312     __put_user(0x002b0000, tramp + 1);  /* syscall 0 */
 313
 314     default_rt_sigreturn = sigtramp_page;
 315     unlock_user(tramp, sigtramp_page, 8);
 316 }