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 "signal-common.h" 22 #include "linux-user/trace.h" 23 24 struct target_sigcontext { 25 uint64_t fault_address; 26 /* AArch64 registers */ 27 uint64_t regs[31]; 28 uint64_t sp; 29 uint64_t pc; 30 uint64_t pstate; 31 /* 4K reserved for FP/SIMD state and future expansion */ 32 char __reserved[4096] __attribute__((__aligned__(16))); 33 }; 34 35 struct target_ucontext { 36 abi_ulong tuc_flags; 37 abi_ulong tuc_link; 38 target_stack_t tuc_stack; 39 target_sigset_t tuc_sigmask; 40 /* glibc uses a 1024-bit sigset_t */ 41 char __unused[1024 / 8 - sizeof(target_sigset_t)]; 42 /* last for future expansion */ 43 struct target_sigcontext tuc_mcontext; 44 }; 45 46 /* 47 * Header to be used at the beginning of structures extending the user 48 * context. Such structures must be placed after the rt_sigframe on the stack 49 * and be 16-byte aligned. The last structure must be a dummy one with the 50 * magic and size set to 0. 51 */ 52 struct target_aarch64_ctx { 53 uint32_t magic; 54 uint32_t size; 55 }; 56 57 #define TARGET_FPSIMD_MAGIC 0x46508001 58 59 struct target_fpsimd_context { 60 struct target_aarch64_ctx head; 61 uint32_t fpsr; 62 uint32_t fpcr; 63 uint64_t vregs[32 * 2]; /* really uint128_t vregs[32] */ 64 }; 65 66 #define TARGET_EXTRA_MAGIC 0x45585401 67 68 struct target_extra_context { 69 struct target_aarch64_ctx head; 70 uint64_t datap; /* 16-byte aligned pointer to extra space cast to __u64 */ 71 uint32_t size; /* size in bytes of the extra space */ 72 uint32_t reserved[3]; 73 }; 74 75 #define TARGET_SVE_MAGIC 0x53564501 76 77 struct target_sve_context { 78 struct target_aarch64_ctx head; 79 uint16_t vl; 80 uint16_t reserved[3]; 81 /* The actual SVE data immediately follows. It is layed out 82 * according to TARGET_SVE_SIG_{Z,P}REG_OFFSET, based off of 83 * the original struct pointer. 84 */ 85 }; 86 87 #define TARGET_SVE_VQ_BYTES 16 88 89 #define TARGET_SVE_SIG_ZREG_SIZE(VQ) ((VQ) * TARGET_SVE_VQ_BYTES) 90 #define TARGET_SVE_SIG_PREG_SIZE(VQ) ((VQ) * (TARGET_SVE_VQ_BYTES / 8)) 91 92 #define TARGET_SVE_SIG_REGS_OFFSET \ 93 QEMU_ALIGN_UP(sizeof(struct target_sve_context), TARGET_SVE_VQ_BYTES) 94 #define TARGET_SVE_SIG_ZREG_OFFSET(VQ, N) \ 95 (TARGET_SVE_SIG_REGS_OFFSET + TARGET_SVE_SIG_ZREG_SIZE(VQ) * (N)) 96 #define TARGET_SVE_SIG_PREG_OFFSET(VQ, N) \ 97 (TARGET_SVE_SIG_ZREG_OFFSET(VQ, 32) + TARGET_SVE_SIG_PREG_SIZE(VQ) * (N)) 98 #define TARGET_SVE_SIG_FFR_OFFSET(VQ) \ 99 (TARGET_SVE_SIG_PREG_OFFSET(VQ, 16)) 100 #define TARGET_SVE_SIG_CONTEXT_SIZE(VQ) \ 101 (TARGET_SVE_SIG_PREG_OFFSET(VQ, 17)) 102 103 struct target_rt_sigframe { 104 struct target_siginfo info; 105 struct target_ucontext uc; 106 }; 107 108 struct target_rt_frame_record { 109 uint64_t fp; 110 uint64_t lr; 111 uint32_t tramp[2]; 112 }; 113 114 static void target_setup_general_frame(struct target_rt_sigframe *sf, 115 CPUARMState *env, target_sigset_t *set) 116 { 117 int i; 118 119 __put_user(0, &sf->uc.tuc_flags); 120 __put_user(0, &sf->uc.tuc_link); 121 122 target_save_altstack(&sf->uc.tuc_stack, env); 123 124 for (i = 0; i < 31; i++) { 125 __put_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]); 126 } 127 __put_user(env->xregs[31], &sf->uc.tuc_mcontext.sp); 128 __put_user(env->pc, &sf->uc.tuc_mcontext.pc); 129 __put_user(pstate_read(env), &sf->uc.tuc_mcontext.pstate); 130 131 __put_user(env->exception.vaddress, &sf->uc.tuc_mcontext.fault_address); 132 133 for (i = 0; i < TARGET_NSIG_WORDS; i++) { 134 __put_user(set->sig[i], &sf->uc.tuc_sigmask.sig[i]); 135 } 136 } 137 138 static void target_setup_fpsimd_record(struct target_fpsimd_context *fpsimd, 139 CPUARMState *env) 140 { 141 int i; 142 143 __put_user(TARGET_FPSIMD_MAGIC, &fpsimd->head.magic); 144 __put_user(sizeof(struct target_fpsimd_context), &fpsimd->head.size); 145 __put_user(vfp_get_fpsr(env), &fpsimd->fpsr); 146 __put_user(vfp_get_fpcr(env), &fpsimd->fpcr); 147 148 for (i = 0; i < 32; i++) { 149 uint64_t *q = aa64_vfp_qreg(env, i); 150 #ifdef TARGET_WORDS_BIGENDIAN 151 __put_user(q[0], &fpsimd->vregs[i * 2 + 1]); 152 __put_user(q[1], &fpsimd->vregs[i * 2]); 153 #else 154 __put_user(q[0], &fpsimd->vregs[i * 2]); 155 __put_user(q[1], &fpsimd->vregs[i * 2 + 1]); 156 #endif 157 } 158 } 159 160 static void target_setup_extra_record(struct target_extra_context *extra, 161 uint64_t datap, uint32_t extra_size) 162 { 163 __put_user(TARGET_EXTRA_MAGIC, &extra->head.magic); 164 __put_user(sizeof(struct target_extra_context), &extra->head.size); 165 __put_user(datap, &extra->datap); 166 __put_user(extra_size, &extra->size); 167 } 168 169 static void target_setup_end_record(struct target_aarch64_ctx *end) 170 { 171 __put_user(0, &end->magic); 172 __put_user(0, &end->size); 173 } 174 175 static void target_setup_sve_record(struct target_sve_context *sve, 176 CPUARMState *env, int vq, int size) 177 { 178 int i, j; 179 180 __put_user(TARGET_SVE_MAGIC, &sve->head.magic); 181 __put_user(size, &sve->head.size); 182 __put_user(vq * TARGET_SVE_VQ_BYTES, &sve->vl); 183 184 /* Note that SVE regs are stored as a byte stream, with each byte element 185 * at a subsequent address. This corresponds to a little-endian store 186 * of our 64-bit hunks. 187 */ 188 for (i = 0; i < 32; ++i) { 189 uint64_t *z = (void *)sve + TARGET_SVE_SIG_ZREG_OFFSET(vq, i); 190 for (j = 0; j < vq * 2; ++j) { 191 __put_user_e(env->vfp.zregs[i].d[j], z + j, le); 192 } 193 } 194 for (i = 0; i <= 16; ++i) { 195 uint16_t *p = (void *)sve + TARGET_SVE_SIG_PREG_OFFSET(vq, i); 196 for (j = 0; j < vq; ++j) { 197 uint64_t r = env->vfp.pregs[i].p[j >> 2]; 198 __put_user_e(r >> ((j & 3) * 16), p + j, le); 199 } 200 } 201 } 202 203 static void target_restore_general_frame(CPUARMState *env, 204 struct target_rt_sigframe *sf) 205 { 206 sigset_t set; 207 uint64_t pstate; 208 int i; 209 210 target_to_host_sigset(&set, &sf->uc.tuc_sigmask); 211 set_sigmask(&set); 212 213 for (i = 0; i < 31; i++) { 214 __get_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]); 215 } 216 217 __get_user(env->xregs[31], &sf->uc.tuc_mcontext.sp); 218 __get_user(env->pc, &sf->uc.tuc_mcontext.pc); 219 __get_user(pstate, &sf->uc.tuc_mcontext.pstate); 220 pstate_write(env, pstate); 221 } 222 223 static void target_restore_fpsimd_record(CPUARMState *env, 224 struct target_fpsimd_context *fpsimd) 225 { 226 uint32_t fpsr, fpcr; 227 int i; 228 229 __get_user(fpsr, &fpsimd->fpsr); 230 vfp_set_fpsr(env, fpsr); 231 __get_user(fpcr, &fpsimd->fpcr); 232 vfp_set_fpcr(env, fpcr); 233 234 for (i = 0; i < 32; i++) { 235 uint64_t *q = aa64_vfp_qreg(env, i); 236 #ifdef TARGET_WORDS_BIGENDIAN 237 __get_user(q[0], &fpsimd->vregs[i * 2 + 1]); 238 __get_user(q[1], &fpsimd->vregs[i * 2]); 239 #else 240 __get_user(q[0], &fpsimd->vregs[i * 2]); 241 __get_user(q[1], &fpsimd->vregs[i * 2 + 1]); 242 #endif 243 } 244 } 245 246 static void target_restore_sve_record(CPUARMState *env, 247 struct target_sve_context *sve, int vq) 248 { 249 int i, j; 250 251 /* Note that SVE regs are stored as a byte stream, with each byte element 252 * at a subsequent address. This corresponds to a little-endian load 253 * of our 64-bit hunks. 254 */ 255 for (i = 0; i < 32; ++i) { 256 uint64_t *z = (void *)sve + TARGET_SVE_SIG_ZREG_OFFSET(vq, i); 257 for (j = 0; j < vq * 2; ++j) { 258 __get_user_e(env->vfp.zregs[i].d[j], z + j, le); 259 } 260 } 261 for (i = 0; i <= 16; ++i) { 262 uint16_t *p = (void *)sve + TARGET_SVE_SIG_PREG_OFFSET(vq, i); 263 for (j = 0; j < vq; ++j) { 264 uint16_t r; 265 __get_user_e(r, p + j, le); 266 if (j & 3) { 267 env->vfp.pregs[i].p[j >> 2] |= (uint64_t)r << ((j & 3) * 16); 268 } else { 269 env->vfp.pregs[i].p[j >> 2] = r; 270 } 271 } 272 } 273 } 274 275 static int target_restore_sigframe(CPUARMState *env, 276 struct target_rt_sigframe *sf) 277 { 278 struct target_aarch64_ctx *ctx, *extra = NULL; 279 struct target_fpsimd_context *fpsimd = NULL; 280 struct target_sve_context *sve = NULL; 281 uint64_t extra_datap = 0; 282 bool used_extra = false; 283 bool err = false; 284 int vq = 0, sve_size = 0; 285 286 target_restore_general_frame(env, sf); 287 288 ctx = (struct target_aarch64_ctx *)sf->uc.tuc_mcontext.__reserved; 289 while (ctx) { 290 uint32_t magic, size, extra_size; 291 292 __get_user(magic, &ctx->magic); 293 __get_user(size, &ctx->size); 294 switch (magic) { 295 case 0: 296 if (size != 0) { 297 err = true; 298 goto exit; 299 } 300 if (used_extra) { 301 ctx = NULL; 302 } else { 303 ctx = extra; 304 used_extra = true; 305 } 306 continue; 307 308 case TARGET_FPSIMD_MAGIC: 309 if (fpsimd || size != sizeof(struct target_fpsimd_context)) { 310 err = true; 311 goto exit; 312 } 313 fpsimd = (struct target_fpsimd_context *)ctx; 314 break; 315 316 case TARGET_SVE_MAGIC: 317 if (cpu_isar_feature(aa64_sve, env_archcpu(env))) { 318 vq = (env->vfp.zcr_el[1] & 0xf) + 1; 319 sve_size = QEMU_ALIGN_UP(TARGET_SVE_SIG_CONTEXT_SIZE(vq), 16); 320 if (!sve && size == sve_size) { 321 sve = (struct target_sve_context *)ctx; 322 break; 323 } 324 } 325 err = true; 326 goto exit; 327 328 case TARGET_EXTRA_MAGIC: 329 if (extra || size != sizeof(struct target_extra_context)) { 330 err = true; 331 goto exit; 332 } 333 __get_user(extra_datap, 334 &((struct target_extra_context *)ctx)->datap); 335 __get_user(extra_size, 336 &((struct target_extra_context *)ctx)->size); 337 extra = lock_user(VERIFY_READ, extra_datap, extra_size, 0); 338 break; 339 340 default: 341 /* Unknown record -- we certainly didn't generate it. 342 * Did we in fact get out of sync? 343 */ 344 err = true; 345 goto exit; 346 } 347 ctx = (void *)ctx + size; 348 } 349 350 /* Require FPSIMD always. */ 351 if (fpsimd) { 352 target_restore_fpsimd_record(env, fpsimd); 353 } else { 354 err = true; 355 } 356 357 /* SVE data, if present, overwrites FPSIMD data. */ 358 if (sve) { 359 target_restore_sve_record(env, sve, vq); 360 } 361 362 exit: 363 unlock_user(extra, extra_datap, 0); 364 return err; 365 } 366 367 static abi_ulong get_sigframe(struct target_sigaction *ka, 368 CPUARMState *env, int size) 369 { 370 abi_ulong sp; 371 372 sp = target_sigsp(get_sp_from_cpustate(env), ka); 373 374 sp = (sp - size) & ~15; 375 376 return sp; 377 } 378 379 typedef struct { 380 int total_size; 381 int extra_base; 382 int extra_size; 383 int std_end_ofs; 384 int extra_ofs; 385 int extra_end_ofs; 386 } target_sigframe_layout; 387 388 static int alloc_sigframe_space(int this_size, target_sigframe_layout *l) 389 { 390 /* Make sure there will always be space for the end marker. */ 391 const int std_size = sizeof(struct target_rt_sigframe) 392 - sizeof(struct target_aarch64_ctx); 393 int this_loc = l->total_size; 394 395 if (l->extra_base) { 396 /* Once we have begun an extra space, all allocations go there. */ 397 l->extra_size += this_size; 398 } else if (this_size + this_loc > std_size) { 399 /* This allocation does not fit in the standard space. */ 400 /* Allocate the extra record. */ 401 l->extra_ofs = this_loc; 402 l->total_size += sizeof(struct target_extra_context); 403 404 /* Allocate the standard end record. */ 405 l->std_end_ofs = l->total_size; 406 l->total_size += sizeof(struct target_aarch64_ctx); 407 408 /* Allocate the requested record. */ 409 l->extra_base = this_loc = l->total_size; 410 l->extra_size = this_size; 411 } 412 l->total_size += this_size; 413 414 return this_loc; 415 } 416 417 static void target_setup_frame(int usig, struct target_sigaction *ka, 418 target_siginfo_t *info, target_sigset_t *set, 419 CPUARMState *env) 420 { 421 target_sigframe_layout layout = { 422 /* Begin with the size pointing to the reserved space. */ 423 .total_size = offsetof(struct target_rt_sigframe, 424 uc.tuc_mcontext.__reserved), 425 }; 426 int fpsimd_ofs, fr_ofs, sve_ofs = 0, vq = 0, sve_size = 0; 427 struct target_rt_sigframe *frame; 428 struct target_rt_frame_record *fr; 429 abi_ulong frame_addr, return_addr; 430 431 /* FPSIMD record is always in the standard space. */ 432 fpsimd_ofs = alloc_sigframe_space(sizeof(struct target_fpsimd_context), 433 &layout); 434 435 /* SVE state needs saving only if it exists. */ 436 if (cpu_isar_feature(aa64_sve, env_archcpu(env))) { 437 vq = (env->vfp.zcr_el[1] & 0xf) + 1; 438 sve_size = QEMU_ALIGN_UP(TARGET_SVE_SIG_CONTEXT_SIZE(vq), 16); 439 sve_ofs = alloc_sigframe_space(sve_size, &layout); 440 } 441 442 if (layout.extra_ofs) { 443 /* Reserve space for the extra end marker. The standard end marker 444 * will have been allocated when we allocated the extra record. 445 */ 446 layout.extra_end_ofs 447 = alloc_sigframe_space(sizeof(struct target_aarch64_ctx), &layout); 448 } else { 449 /* Reserve space for the standard end marker. 450 * Do not use alloc_sigframe_space because we cheat 451 * std_size therein to reserve space for this. 452 */ 453 layout.std_end_ofs = layout.total_size; 454 layout.total_size += sizeof(struct target_aarch64_ctx); 455 } 456 457 /* We must always provide at least the standard 4K reserved space, 458 * even if we don't use all of it (this is part of the ABI) 459 */ 460 layout.total_size = MAX(layout.total_size, 461 sizeof(struct target_rt_sigframe)); 462 463 /* Reserve space for the return code. On a real system this would 464 * be within the VDSO. So, despite the name this is not a "real" 465 * record within the frame. 466 */ 467 fr_ofs = layout.total_size; 468 layout.total_size += sizeof(struct target_rt_frame_record); 469 470 frame_addr = get_sigframe(ka, env, layout.total_size); 471 trace_user_setup_frame(env, frame_addr); 472 frame = lock_user(VERIFY_WRITE, frame_addr, layout.total_size, 0); 473 if (!frame) { 474 goto give_sigsegv; 475 } 476 477 target_setup_general_frame(frame, env, set); 478 target_setup_fpsimd_record((void *)frame + fpsimd_ofs, env); 479 target_setup_end_record((void *)frame + layout.std_end_ofs); 480 if (layout.extra_ofs) { 481 target_setup_extra_record((void *)frame + layout.extra_ofs, 482 frame_addr + layout.extra_base, 483 layout.extra_size); 484 target_setup_end_record((void *)frame + layout.extra_end_ofs); 485 } 486 if (sve_ofs) { 487 target_setup_sve_record((void *)frame + sve_ofs, env, vq, sve_size); 488 } 489 490 /* Set up the stack frame for unwinding. */ 491 fr = (void *)frame + fr_ofs; 492 __put_user(env->xregs[29], &fr->fp); 493 __put_user(env->xregs[30], &fr->lr); 494 495 if (ka->sa_flags & TARGET_SA_RESTORER) { 496 return_addr = ka->sa_restorer; 497 } else { 498 /* 499 * mov x8,#__NR_rt_sigreturn; svc #0 500 * Since these are instructions they need to be put as little-endian 501 * regardless of target default or current CPU endianness. 502 */ 503 __put_user_e(0xd2801168, &fr->tramp[0], le); 504 __put_user_e(0xd4000001, &fr->tramp[1], le); 505 return_addr = frame_addr + fr_ofs 506 + offsetof(struct target_rt_frame_record, tramp); 507 } 508 env->xregs[0] = usig; 509 env->xregs[31] = frame_addr; 510 env->xregs[29] = frame_addr + fr_ofs; 511 env->pc = ka->_sa_handler; 512 env->xregs[30] = return_addr; 513 if (info) { 514 tswap_siginfo(&frame->info, info); 515 env->xregs[1] = frame_addr + offsetof(struct target_rt_sigframe, info); 516 env->xregs[2] = frame_addr + offsetof(struct target_rt_sigframe, uc); 517 } 518 519 unlock_user(frame, frame_addr, layout.total_size); 520 return; 521 522 give_sigsegv: 523 unlock_user(frame, frame_addr, layout.total_size); 524 force_sigsegv(usig); 525 } 526 527 void setup_rt_frame(int sig, struct target_sigaction *ka, 528 target_siginfo_t *info, target_sigset_t *set, 529 CPUARMState *env) 530 { 531 target_setup_frame(sig, ka, info, set, env); 532 } 533 534 void setup_frame(int sig, struct target_sigaction *ka, 535 target_sigset_t *set, CPUARMState *env) 536 { 537 target_setup_frame(sig, ka, 0, set, env); 538 } 539 540 long do_rt_sigreturn(CPUARMState *env) 541 { 542 struct target_rt_sigframe *frame = NULL; 543 abi_ulong frame_addr = env->xregs[31]; 544 545 trace_user_do_rt_sigreturn(env, frame_addr); 546 if (frame_addr & 15) { 547 goto badframe; 548 } 549 550 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 551 goto badframe; 552 } 553 554 if (target_restore_sigframe(env, frame)) { 555 goto badframe; 556 } 557 558 if (do_sigaltstack(frame_addr + 559 offsetof(struct target_rt_sigframe, uc.tuc_stack), 560 0, get_sp_from_cpustate(env)) == -EFAULT) { 561 goto badframe; 562 } 563 564 unlock_user_struct(frame, frame_addr, 0); 565 return -TARGET_QEMU_ESIGRETURN; 566 567 badframe: 568 unlock_user_struct(frame, frame_addr, 0); 569 force_sig(TARGET_SIGSEGV); 570 return -TARGET_QEMU_ESIGRETURN; 571 } 572 573 long do_sigreturn(CPUARMState *env) 574 { 575 return do_rt_sigreturn(env); 576 } 577