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 #include "target/loongarch/internals.h"
  14 #include "target/loongarch/vec.h"
  15 #include "vdso-asmoffset.h"
  16
  17 /* FP context was used */
  18 #define SC_USED_FP              (1 << 0)
  19
  20 struct target_sigcontext {
  21     abi_ulong sc_pc;
  22     abi_ulong sc_regs[32];
  23     abi_uint  sc_flags;
  24     abi_ulong sc_extcontext[0]   QEMU_ALIGNED(16);
  25 };
  26
  27 QEMU_BUILD_BUG_ON(sizeof(struct target_sigcontext) != sizeof_sigcontext);
  28 QEMU_BUILD_BUG_ON(offsetof(struct target_sigcontext, sc_pc)
  29                   != offsetof_sigcontext_pc);
  30 QEMU_BUILD_BUG_ON(offsetof(struct target_sigcontext, sc_regs)
  31                   != offsetof_sigcontext_gr);
  32
  33 #define FPU_CTX_MAGIC           0x46505501
  34 #define FPU_CTX_ALIGN           8
  35 struct target_fpu_context {
  36     abi_ulong regs[32];
  37     abi_ulong fcc;
  38     abi_uint  fcsr;
  39 } QEMU_ALIGNED(FPU_CTX_ALIGN);
  40
  41 QEMU_BUILD_BUG_ON(offsetof(struct target_fpu_context, regs)
  42                   != offsetof_fpucontext_fr);
  43
  44 #define LSX_CTX_MAGIC           0x53580001
  45 #define LSX_CTX_ALIGN           16
  46 struct target_lsx_context {
  47     abi_ulong regs[2 * 32];
  48     abi_ulong fcc;
  49     abi_uint  fcsr;
  50 } QEMU_ALIGNED(LSX_CTX_ALIGN);
  51
  52 #define LASX_CTX_MAGIC          0x41535801
  53 #define LASX_CTX_ALIGN          32
  54 struct target_lasx_context {
  55     abi_ulong regs[4 * 32];
  56     abi_ulong fcc;
  57     abi_uint  fcsr;
  58 } QEMU_ALIGNED(LASX_CTX_ALIGN);
  59
  60 #define CONTEXT_INFO_ALIGN      16
  61 struct target_sctx_info {
  62     abi_uint  magic;
  63     abi_uint  size;
  64     abi_ulong padding;
  65 } QEMU_ALIGNED(CONTEXT_INFO_ALIGN);
  66
  67 QEMU_BUILD_BUG_ON(sizeof(struct target_sctx_info) != sizeof_sctx_info);
  68
  69 struct target_ucontext {
  70     abi_ulong tuc_flags;
  71     abi_ptr tuc_link;
  72     target_stack_t tuc_stack;
  73     target_sigset_t tuc_sigmask;
  74     uint8_t __unused[1024 / 8 - sizeof(target_sigset_t)];
  75     struct target_sigcontext tuc_mcontext;
  76 };
  77
  78 struct target_rt_sigframe {
  79     struct target_siginfo        rs_info;
  80     struct target_ucontext       rs_uc;
  81 };
  82
  83 QEMU_BUILD_BUG_ON(sizeof(struct target_rt_sigframe)
  84                   != sizeof_rt_sigframe);
  85 QEMU_BUILD_BUG_ON(offsetof(struct target_rt_sigframe, rs_uc.tuc_mcontext)
  86                   != offsetof_sigcontext);
  87
  88 /*
  89  * These two structures are not present in guest memory, are private
  90  * to the signal implementation, but are largely copied from the
  91  * kernel's signal implementation.
  92  */
  93 struct ctx_layout {
  94     void *haddr;
  95     abi_ptr gaddr;
  96     unsigned int size;
  97 };
  98
  99 struct extctx_layout {
 100     unsigned long size;
 101     unsigned int flags;
 102     struct ctx_layout fpu;
 103     struct ctx_layout lsx;
 104     struct ctx_layout lasx;
 105     struct ctx_layout end;
 106 };
 107
 108 static abi_ptr extframe_alloc(struct extctx_layout *extctx,
 109                               struct ctx_layout *sctx, unsigned size,
 110                               unsigned align, abi_ptr orig_sp)
 111 {
 112     abi_ptr sp = orig_sp;
 113
 114     sp -= sizeof(struct target_sctx_info) + size;
 115     align = MAX(align, CONTEXT_INFO_ALIGN);
 116     sp = ROUND_DOWN(sp, align);
 117     sctx->gaddr = sp;
 118
 119     size = orig_sp - sp;
 120     sctx->size = size;
 121     extctx->size += size;
 122
 123     return sp;
 124 }
 125
 126 static abi_ptr setup_extcontext(CPULoongArchState *env,
 127                                 struct extctx_layout *extctx, abi_ptr sp)
 128 {
 129     memset(extctx, 0, sizeof(struct extctx_layout));
 130
 131     /* Grow down, alloc "end" context info first. */
 132     sp = extframe_alloc(extctx, &extctx->end, 0, CONTEXT_INFO_ALIGN, sp);
 133
 134     /* For qemu, there is no lazy fp context switch, so fp always present. */
 135     extctx->flags = SC_USED_FP;
 136
 137     if (FIELD_EX64(env->CSR_EUEN, CSR_EUEN, ASXE)) {
 138         sp = extframe_alloc(extctx, &extctx->lasx,
 139                         sizeof(struct target_lasx_context), LASX_CTX_ALIGN, sp);
 140     } else if (FIELD_EX64(env->CSR_EUEN, CSR_EUEN, SXE)) {
 141         sp = extframe_alloc(extctx, &extctx->lsx,
 142                         sizeof(struct target_lsx_context), LSX_CTX_ALIGN, sp);
 143     } else {
 144         sp = extframe_alloc(extctx, &extctx->fpu,
 145                         sizeof(struct target_fpu_context), FPU_CTX_ALIGN, sp);
 146     }
 147
 148     return sp;
 149 }
 150
 151 static void setup_sigframe(CPULoongArchState *env,
 152                            struct target_sigcontext *sc,
 153                            struct extctx_layout *extctx)
 154 {
 155     struct target_sctx_info *info;
 156     int i;
 157
 158     __put_user(extctx->flags, &sc->sc_flags);
 159     __put_user(env->pc, &sc->sc_pc);
 160     __put_user(0, &sc->sc_regs[0]);
 161     for (i = 1; i < 32; ++i) {
 162         __put_user(env->gpr[i], &sc->sc_regs[i]);
 163     }
 164
 165     /*
 166      * Set extension context
 167      */
 168
 169     if (FIELD_EX64(env->CSR_EUEN, CSR_EUEN, ASXE)) {
 170         struct target_lasx_context *lasx_ctx;
 171         info = extctx->lasx.haddr;
 172
 173         __put_user(LASX_CTX_MAGIC, &info->magic);
 174         __put_user(extctx->lasx.size, &info->size);
 175
 176         lasx_ctx = (struct target_lasx_context *)(info + 1);
 177
 178         for (i = 0; i < 32; ++i) {
 179             __put_user(env->fpr[i].vreg.UD(0), &lasx_ctx->regs[4 * i]);
 180             __put_user(env->fpr[i].vreg.UD(1), &lasx_ctx->regs[4 * i + 1]);
 181             __put_user(env->fpr[i].vreg.UD(2), &lasx_ctx->regs[4 * i + 2]);
 182             __put_user(env->fpr[i].vreg.UD(3), &lasx_ctx->regs[4 * i + 3]);
 183         }
 184         __put_user(read_fcc(env), &lasx_ctx->fcc);
 185         __put_user(env->fcsr0, &lasx_ctx->fcsr);
 186     } else if (FIELD_EX64(env->CSR_EUEN, CSR_EUEN, SXE)) {
 187         struct target_lsx_context *lsx_ctx;
 188         info = extctx->lsx.haddr;
 189
 190         __put_user(LSX_CTX_MAGIC, &info->magic);
 191         __put_user(extctx->lsx.size, &info->size);
 192
 193         lsx_ctx = (struct target_lsx_context *)(info + 1);
 194
 195         for (i = 0; i < 32; ++i) {
 196             __put_user(env->fpr[i].vreg.UD(0), &lsx_ctx->regs[2 * i]);
 197             __put_user(env->fpr[i].vreg.UD(1), &lsx_ctx->regs[2 * i + 1]);
 198         }
 199         __put_user(read_fcc(env), &lsx_ctx->fcc);
 200         __put_user(env->fcsr0, &lsx_ctx->fcsr);
 201     } else {
 202         struct target_fpu_context *fpu_ctx;
 203         info = extctx->fpu.haddr;
 204
 205         __put_user(FPU_CTX_MAGIC, &info->magic);
 206         __put_user(extctx->fpu.size, &info->size);
 207
 208         fpu_ctx = (struct target_fpu_context *)(info + 1);
 209
 210         for (i = 0; i < 32; ++i) {
 211             __put_user(env->fpr[i].vreg.UD(0), &fpu_ctx->regs[i]);
 212         }
 213         __put_user(read_fcc(env), &fpu_ctx->fcc);
 214         __put_user(env->fcsr0, &fpu_ctx->fcsr);
 215     }
 216
 217     /*
 218      * Set end context
 219      */
 220     info = extctx->end.haddr;
 221     __put_user(0, &info->magic);
 222     __put_user(0, &info->size);
 223 }
 224
 225 static bool parse_extcontext(struct extctx_layout *extctx, abi_ptr frame)
 226 {
 227     memset(extctx, 0, sizeof(*extctx));
 228
 229     while (1) {
 230         abi_uint magic, size;
 231
 232         if (get_user_u32(magic, frame) || get_user_u32(size, frame + 4)) {
 233             return false;
 234         }
 235
 236         switch (magic) {
 237         case 0: /* END */
 238             extctx->end.gaddr = frame;
 239             extctx->end.size = size;
 240             extctx->size += size;
 241             return true;
 242
 243         case FPU_CTX_MAGIC:
 244             if (size < (sizeof(struct target_sctx_info) +
 245                         sizeof(struct target_fpu_context))) {
 246                 return false;
 247             }
 248             extctx->fpu.gaddr = frame;
 249             extctx->fpu.size = size;
 250             extctx->size += size;
 251             break;
 252         case LSX_CTX_MAGIC:
 253             if (size < (sizeof(struct target_sctx_info) +
 254                         sizeof(struct target_lsx_context))) {
 255                 return false;
 256             }
 257             extctx->lsx.gaddr = frame;
 258             extctx->lsx.size = size;
 259             extctx->size += size;
 260             break;
 261         case LASX_CTX_MAGIC:
 262             if (size < (sizeof(struct target_sctx_info) +
 263                         sizeof(struct target_lasx_context))) {
 264                 return false;
 265             }
 266             extctx->lasx.gaddr = frame;
 267             extctx->lasx.size = size;
 268             extctx->size += size;
 269             break;
 270         default:
 271             return false;
 272         }
 273
 274         frame += size;
 275     }
 276 }
 277
 278 static void restore_sigframe(CPULoongArchState *env,
 279                              struct target_sigcontext *sc,
 280                              struct extctx_layout *extctx)
 281 {
 282     int i;
 283     abi_ulong fcc;
 284
 285     __get_user(env->pc, &sc->sc_pc);
 286     for (i = 1; i < 32; ++i) {
 287         __get_user(env->gpr[i], &sc->sc_regs[i]);
 288     }
 289
 290     if (extctx->lasx.haddr) {
 291         struct target_lasx_context *lasx_ctx =
 292             extctx->lasx.haddr + sizeof(struct target_sctx_info);
 293
 294         for (i = 0; i < 32; ++i) {
 295             __get_user(env->fpr[i].vreg.UD(0), &lasx_ctx->regs[4 * i]);
 296             __get_user(env->fpr[i].vreg.UD(1), &lasx_ctx->regs[4 * i + 1]);
 297             __get_user(env->fpr[i].vreg.UD(2), &lasx_ctx->regs[4 * i + 2]);
 298             __get_user(env->fpr[i].vreg.UD(3), &lasx_ctx->regs[4 * i + 3]);
 299         }
 300         __get_user(fcc, &lasx_ctx->fcc);
 301         write_fcc(env, fcc);
 302         __get_user(env->fcsr0, &lasx_ctx->fcsr);
 303         restore_fp_status(env);
 304     } else if (extctx->lsx.haddr) {
 305         struct target_lsx_context *lsx_ctx =
 306             extctx->lsx.haddr + sizeof(struct target_sctx_info);
 307
 308         for (i = 0; i < 32; ++i) {
 309             __get_user(env->fpr[i].vreg.UD(0), &lsx_ctx->regs[2 * i]);
 310             __get_user(env->fpr[i].vreg.UD(1), &lsx_ctx->regs[2 * i + 1]);
 311         }
 312         __get_user(fcc, &lsx_ctx->fcc);
 313         write_fcc(env, fcc);
 314         __get_user(env->fcsr0, &lsx_ctx->fcsr);
 315         restore_fp_status(env);
 316     } else if (extctx->fpu.haddr) {
 317         struct target_fpu_context *fpu_ctx =
 318             extctx->fpu.haddr + sizeof(struct target_sctx_info);
 319
 320         for (i = 0; i < 32; ++i) {
 321             __get_user(env->fpr[i].vreg.UD(0), &fpu_ctx->regs[i]);
 322         }
 323         __get_user(fcc, &fpu_ctx->fcc);
 324         write_fcc(env, fcc);
 325         __get_user(env->fcsr0, &fpu_ctx->fcsr);
 326         restore_fp_status(env);
 327     }
 328 }
 329
 330 /*
 331  * Determine which stack to use.
 332  */
 333 static abi_ptr get_sigframe(struct target_sigaction *ka,
 334                             CPULoongArchState *env,
 335                             struct extctx_layout *extctx)
 336 {
 337     abi_ulong sp;
 338
 339     sp = target_sigsp(get_sp_from_cpustate(env), ka);
 340     sp = ROUND_DOWN(sp, 16);
 341     sp = setup_extcontext(env, extctx, sp);
 342     sp -= sizeof(struct target_rt_sigframe);
 343
 344     assert(QEMU_IS_ALIGNED(sp, 16));
 345
 346     return sp;
 347 }
 348
 349 void setup_rt_frame(int sig, struct target_sigaction *ka,
 350                     target_siginfo_t *info,
 351                     target_sigset_t *set, CPULoongArchState *env)
 352 {
 353     struct target_rt_sigframe *frame;
 354     struct extctx_layout extctx;
 355     abi_ptr frame_addr;
 356     int i;
 357
 358     frame_addr = get_sigframe(ka, env, &extctx);
 359     trace_user_setup_rt_frame(env, frame_addr);
 360
 361     frame = lock_user(VERIFY_WRITE, frame_addr,
 362                       sizeof(*frame) + extctx.size, 0);
 363     if (!frame) {
 364         force_sigsegv(sig);
 365         return;
 366     }
 367
 368     if (FIELD_EX64(env->CSR_EUEN, CSR_EUEN, ASXE)) {
 369         extctx.lasx.haddr = (void *)frame + (extctx.lasx.gaddr - frame_addr);
 370         extctx.end.haddr = (void *)frame + (extctx.end.gaddr - frame_addr);
 371     } else if (FIELD_EX64(env->CSR_EUEN, CSR_EUEN, SXE)) {
 372         extctx.lsx.haddr = (void *)frame + (extctx.lsx.gaddr - frame_addr);
 373         extctx.end.haddr = (void *)frame + (extctx.end.gaddr - frame_addr);
 374     } else {
 375         extctx.fpu.haddr = (void *)frame + (extctx.fpu.gaddr - frame_addr);
 376         extctx.end.haddr = (void *)frame + (extctx.end.gaddr - frame_addr);
 377     }
 378
 379     tswap_siginfo(&frame->rs_info, info);
 380
 381     __put_user(0, &frame->rs_uc.tuc_flags);
 382     __put_user(0, &frame->rs_uc.tuc_link);
 383     target_save_altstack(&frame->rs_uc.tuc_stack, env);
 384
 385     setup_sigframe(env, &frame->rs_uc.tuc_mcontext, &extctx);
 386
 387     for (i = 0; i < TARGET_NSIG_WORDS; i++) {
 388         __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]);
 389     }
 390
 391     env->gpr[4] = sig;
 392     env->gpr[5] = frame_addr + offsetof(struct target_rt_sigframe, rs_info);
 393     env->gpr[6] = frame_addr + offsetof(struct target_rt_sigframe, rs_uc);
 394     env->gpr[3] = frame_addr;
 395     env->gpr[1] = default_rt_sigreturn;
 396
 397     env->pc = ka->_sa_handler;
 398     unlock_user(frame, frame_addr, sizeof(*frame) + extctx.size);
 399 }
 400
 401 long do_rt_sigreturn(CPULoongArchState *env)
 402 {
 403     struct target_rt_sigframe *frame;
 404     struct extctx_layout extctx;
 405     abi_ulong frame_addr;
 406     sigset_t blocked;
 407
 408     frame_addr = env->gpr[3];
 409     trace_user_do_rt_sigreturn(env, frame_addr);
 410
 411     if (!parse_extcontext(&extctx, frame_addr + sizeof(*frame))) {
 412         goto badframe;
 413     }
 414
 415     frame = lock_user(VERIFY_READ, frame_addr,
 416                       sizeof(*frame) + extctx.size, 1);
 417     if (!frame) {
 418         goto badframe;
 419     }
 420
 421     if (extctx.lasx.gaddr) {
 422         extctx.lasx.haddr = (void *)frame + (extctx.lasx.gaddr - frame_addr);
 423     } else if (extctx.lsx.gaddr) {
 424         extctx.lsx.haddr = (void *)frame + (extctx.lsx.gaddr - frame_addr);
 425     } else if (extctx.fpu.gaddr) {
 426         extctx.fpu.haddr = (void *)frame + (extctx.fpu.gaddr - frame_addr);
 427     }
 428
 429     target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask);
 430     set_sigmask(&blocked);
 431
 432     restore_sigframe(env, &frame->rs_uc.tuc_mcontext, &extctx);
 433
 434     target_restore_altstack(&frame->rs_uc.tuc_stack, env);
 435
 436     unlock_user(frame, frame_addr, 0);
 437     return -QEMU_ESIGRETURN;
 438
 439  badframe:
 440     force_sig(TARGET_SIGSEGV);
 441     return -QEMU_ESIGRETURN;
 442 }
 443
 444 void setup_sigtramp(abi_ulong sigtramp_page)
 445 {
 446     uint32_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 8, 0);
 447     assert(tramp != NULL);
 448
 449     __put_user(0x03822c0b, tramp + 0);  /* ori     a7, zero, 0x8b */
 450     __put_user(0x002b0000, tramp + 1);  /* syscall 0 */
 451
 452     default_rt_sigreturn = sigtramp_page;
 453     unlock_user(tramp, sigtramp_page, 8);
 454 }