linux-user/aarch64/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 #include "target/arm/cpu-features.h"
  25
  26 struct target_sigcontext {
  27     uint64_t fault_address;
  28     /* AArch64 registers */
  29     uint64_t regs[31];
  30     uint64_t sp;
  31     uint64_t pc;
  32     uint64_t pstate;
  33     /* 4K reserved for FP/SIMD state and future expansion */
  34     char __reserved[4096] __attribute__((__aligned__(16)));
  35 };
  36
  37 struct target_ucontext {
  38     abi_ulong tuc_flags;
  39     abi_ulong tuc_link;
  40     target_stack_t tuc_stack;
  41     target_sigset_t tuc_sigmask;
  42     /* glibc uses a 1024-bit sigset_t */
  43     char __unused[1024 / 8 - sizeof(target_sigset_t)];
  44     /* last for future expansion */
  45     struct target_sigcontext tuc_mcontext;
  46 };
  47
  48 /*
  49  * Header to be used at the beginning of structures extending the user
  50  * context. Such structures must be placed after the rt_sigframe on the stack
  51  * and be 16-byte aligned. The last structure must be a dummy one with the
  52  * magic and size set to 0.
  53  */
  54 struct target_aarch64_ctx {
  55     uint32_t magic;
  56     uint32_t size;
  57 };
  58
  59 #define TARGET_FPSIMD_MAGIC 0x46508001
  60
  61 struct target_fpsimd_context {
  62     struct target_aarch64_ctx head;
  63     uint32_t fpsr;
  64     uint32_t fpcr;
  65     uint64_t vregs[32 * 2]; /* really uint128_t vregs[32] */
  66 };
  67
  68 #define TARGET_EXTRA_MAGIC  0x45585401
  69
  70 struct target_extra_context {
  71     struct target_aarch64_ctx head;
  72     uint64_t datap; /* 16-byte aligned pointer to extra space cast to __u64 */
  73     uint32_t size; /* size in bytes of the extra space */
  74     uint32_t reserved[3];
  75 };
  76
  77 #define TARGET_SVE_MAGIC    0x53564501
  78
  79 struct target_sve_context {
  80     struct target_aarch64_ctx head;
  81     uint16_t vl;
  82     uint16_t flags;
  83     uint16_t reserved[2];
  84     /* The actual SVE data immediately follows.  It is laid out
  85      * according to TARGET_SVE_SIG_{Z,P}REG_OFFSET, based off of
  86      * the original struct pointer.
  87      */
  88 };
  89
  90 #define TARGET_SVE_VQ_BYTES  16
  91
  92 #define TARGET_SVE_SIG_ZREG_SIZE(VQ)  ((VQ) * TARGET_SVE_VQ_BYTES)
  93 #define TARGET_SVE_SIG_PREG_SIZE(VQ)  ((VQ) * (TARGET_SVE_VQ_BYTES / 8))
  94
  95 #define TARGET_SVE_SIG_REGS_OFFSET \
  96     QEMU_ALIGN_UP(sizeof(struct target_sve_context), TARGET_SVE_VQ_BYTES)
  97 #define TARGET_SVE_SIG_ZREG_OFFSET(VQ, N) \
  98     (TARGET_SVE_SIG_REGS_OFFSET + TARGET_SVE_SIG_ZREG_SIZE(VQ) * (N))
  99 #define TARGET_SVE_SIG_PREG_OFFSET(VQ, N) \
 100     (TARGET_SVE_SIG_ZREG_OFFSET(VQ, 32) + TARGET_SVE_SIG_PREG_SIZE(VQ) * (N))
 101 #define TARGET_SVE_SIG_FFR_OFFSET(VQ) \
 102     (TARGET_SVE_SIG_PREG_OFFSET(VQ, 16))
 103 #define TARGET_SVE_SIG_CONTEXT_SIZE(VQ) \
 104     (TARGET_SVE_SIG_PREG_OFFSET(VQ, 17))
 105
 106 #define TARGET_SVE_SIG_FLAG_SM  1
 107
 108 #define TARGET_ZA_MAGIC        0x54366345
 109
 110 struct target_za_context {
 111     struct target_aarch64_ctx head;
 112     uint16_t vl;
 113     uint16_t reserved[3];
 114     /* The actual ZA data immediately follows. */
 115 };
 116
 117 #define TARGET_ZA_SIG_REGS_OFFSET \
 118     QEMU_ALIGN_UP(sizeof(struct target_za_context), TARGET_SVE_VQ_BYTES)
 119 #define TARGET_ZA_SIG_ZAV_OFFSET(VQ, N) \
 120     (TARGET_ZA_SIG_REGS_OFFSET + (VQ) * TARGET_SVE_VQ_BYTES * (N))
 121 #define TARGET_ZA_SIG_CONTEXT_SIZE(VQ) \
 122     TARGET_ZA_SIG_ZAV_OFFSET(VQ, VQ * TARGET_SVE_VQ_BYTES)
 123
 124 struct target_rt_sigframe {
 125     struct target_siginfo info;
 126     struct target_ucontext uc;
 127 };
 128
 129 struct target_rt_frame_record {
 130     uint64_t fp;
 131     uint64_t lr;
 132 };
 133
 134 static void target_setup_general_frame(struct target_rt_sigframe *sf,
 135                                        CPUARMState *env, target_sigset_t *set)
 136 {
 137     int i;
 138
 139     __put_user(0, &sf->uc.tuc_flags);
 140     __put_user(0, &sf->uc.tuc_link);
 141
 142     target_save_altstack(&sf->uc.tuc_stack, env);
 143
 144     for (i = 0; i < 31; i++) {
 145         __put_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
 146     }
 147     __put_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
 148     __put_user(env->pc, &sf->uc.tuc_mcontext.pc);
 149     __put_user(pstate_read(env), &sf->uc.tuc_mcontext.pstate);
 150
 151     __put_user(env->exception.vaddress, &sf->uc.tuc_mcontext.fault_address);
 152
 153     for (i = 0; i < TARGET_NSIG_WORDS; i++) {
 154         __put_user(set->sig[i], &sf->uc.tuc_sigmask.sig[i]);
 155     }
 156 }
 157
 158 static void target_setup_fpsimd_record(struct target_fpsimd_context *fpsimd,
 159                                        CPUARMState *env)
 160 {
 161     int i;
 162
 163     __put_user(TARGET_FPSIMD_MAGIC, &fpsimd->head.magic);
 164     __put_user(sizeof(struct target_fpsimd_context), &fpsimd->head.size);
 165     __put_user(vfp_get_fpsr(env), &fpsimd->fpsr);
 166     __put_user(vfp_get_fpcr(env), &fpsimd->fpcr);
 167
 168     for (i = 0; i < 32; i++) {
 169         uint64_t *q = aa64_vfp_qreg(env, i);
 170 #if TARGET_BIG_ENDIAN
 171         __put_user(q[0], &fpsimd->vregs[i * 2 + 1]);
 172         __put_user(q[1], &fpsimd->vregs[i * 2]);
 173 #else
 174         __put_user(q[0], &fpsimd->vregs[i * 2]);
 175         __put_user(q[1], &fpsimd->vregs[i * 2 + 1]);
 176 #endif
 177     }
 178 }
 179
 180 static void target_setup_extra_record(struct target_extra_context *extra,
 181                                       uint64_t datap, uint32_t extra_size)
 182 {
 183     __put_user(TARGET_EXTRA_MAGIC, &extra->head.magic);
 184     __put_user(sizeof(struct target_extra_context), &extra->head.size);
 185     __put_user(datap, &extra->datap);
 186     __put_user(extra_size, &extra->size);
 187 }
 188
 189 static void target_setup_end_record(struct target_aarch64_ctx *end)
 190 {
 191     __put_user(0, &end->magic);
 192     __put_user(0, &end->size);
 193 }
 194
 195 static void target_setup_sve_record(struct target_sve_context *sve,
 196                                     CPUARMState *env, int size)
 197 {
 198     int i, j, vq = sve_vq(env);
 199
 200     memset(sve, 0, sizeof(*sve));
 201     __put_user(TARGET_SVE_MAGIC, &sve->head.magic);
 202     __put_user(size, &sve->head.size);
 203     __put_user(vq * TARGET_SVE_VQ_BYTES, &sve->vl);
 204     if (FIELD_EX64(env->svcr, SVCR, SM)) {
 205         __put_user(TARGET_SVE_SIG_FLAG_SM, &sve->flags);
 206     }
 207
 208     /* Note that SVE regs are stored as a byte stream, with each byte element
 209      * at a subsequent address.  This corresponds to a little-endian store
 210      * of our 64-bit hunks.
 211      */
 212     for (i = 0; i < 32; ++i) {
 213         uint64_t *z = (void *)sve + TARGET_SVE_SIG_ZREG_OFFSET(vq, i);
 214         for (j = 0; j < vq * 2; ++j) {
 215             __put_user_e(env->vfp.zregs[i].d[j], z + j, le);
 216         }
 217     }
 218     for (i = 0; i <= 16; ++i) {
 219         uint16_t *p = (void *)sve + TARGET_SVE_SIG_PREG_OFFSET(vq, i);
 220         for (j = 0; j < vq; ++j) {
 221             uint64_t r = env->vfp.pregs[i].p[j >> 2];
 222             __put_user_e(r >> ((j & 3) * 16), p + j, le);
 223         }
 224     }
 225 }
 226
 227 static void target_setup_za_record(struct target_za_context *za,
 228                                    CPUARMState *env, int size)
 229 {
 230     int vq = sme_vq(env);
 231     int vl = vq * TARGET_SVE_VQ_BYTES;
 232     int i, j;
 233
 234     memset(za, 0, sizeof(*za));
 235     __put_user(TARGET_ZA_MAGIC, &za->head.magic);
 236     __put_user(size, &za->head.size);
 237     __put_user(vl, &za->vl);
 238
 239     if (size == TARGET_ZA_SIG_CONTEXT_SIZE(0)) {
 240         return;
 241     }
 242     assert(size == TARGET_ZA_SIG_CONTEXT_SIZE(vq));
 243
 244     /*
 245      * Note that ZA vectors are stored as a byte stream,
 246      * with each byte element at a subsequent address.
 247      */
 248     for (i = 0; i < vl; ++i) {
 249         uint64_t *z = (void *)za + TARGET_ZA_SIG_ZAV_OFFSET(vq, i);
 250         for (j = 0; j < vq * 2; ++j) {
 251             __put_user_e(env->zarray[i].d[j], z + j, le);
 252         }
 253     }
 254 }
 255
 256 static void target_restore_general_frame(CPUARMState *env,
 257                                          struct target_rt_sigframe *sf)
 258 {
 259     sigset_t set;
 260     uint64_t pstate;
 261     int i;
 262
 263     target_to_host_sigset(&set, &sf->uc.tuc_sigmask);
 264     set_sigmask(&set);
 265
 266     for (i = 0; i < 31; i++) {
 267         __get_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
 268     }
 269
 270     __get_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
 271     __get_user(env->pc, &sf->uc.tuc_mcontext.pc);
 272     __get_user(pstate, &sf->uc.tuc_mcontext.pstate);
 273     pstate_write(env, pstate);
 274 }
 275
 276 static void target_restore_fpsimd_record(CPUARMState *env,
 277                                          struct target_fpsimd_context *fpsimd)
 278 {
 279     uint32_t fpsr, fpcr;
 280     int i;
 281
 282     __get_user(fpsr, &fpsimd->fpsr);
 283     vfp_set_fpsr(env, fpsr);
 284     __get_user(fpcr, &fpsimd->fpcr);
 285     vfp_set_fpcr(env, fpcr);
 286
 287     for (i = 0; i < 32; i++) {
 288         uint64_t *q = aa64_vfp_qreg(env, i);
 289 #if TARGET_BIG_ENDIAN
 290         __get_user(q[0], &fpsimd->vregs[i * 2 + 1]);
 291         __get_user(q[1], &fpsimd->vregs[i * 2]);
 292 #else
 293         __get_user(q[0], &fpsimd->vregs[i * 2]);
 294         __get_user(q[1], &fpsimd->vregs[i * 2 + 1]);
 295 #endif
 296     }
 297 }
 298
 299 static bool target_restore_sve_record(CPUARMState *env,
 300                                       struct target_sve_context *sve,
 301                                       int size, int *svcr)
 302 {
 303     int i, j, vl, vq, flags;
 304     bool sm;
 305
 306     __get_user(vl, &sve->vl);
 307     __get_user(flags, &sve->flags);
 308
 309     sm = flags & TARGET_SVE_SIG_FLAG_SM;
 310
 311     /* The cpu must support Streaming or Non-streaming SVE. */
 312     if (sm
 313         ? !cpu_isar_feature(aa64_sme, env_archcpu(env))
 314         : !cpu_isar_feature(aa64_sve, env_archcpu(env))) {
 315         return false;
 316     }
 317
 318     /*
 319      * Note that we cannot use sve_vq() because that depends on the
 320      * current setting of PSTATE.SM, not the state to be restored.
 321      */
 322     vq = sve_vqm1_for_el_sm(env, 0, sm) + 1;
 323
 324     /* Reject mismatched VL. */
 325     if (vl != vq * TARGET_SVE_VQ_BYTES) {
 326         return false;
 327     }
 328
 329     /* Accept empty record -- used to clear PSTATE.SM. */
 330     if (size <= sizeof(*sve)) {
 331         return true;
 332     }
 333
 334     /* Reject non-empty but incomplete record. */
 335     if (size < TARGET_SVE_SIG_CONTEXT_SIZE(vq)) {
 336         return false;
 337     }
 338
 339     *svcr = FIELD_DP64(*svcr, SVCR, SM, sm);
 340
 341     /*
 342      * Note that SVE regs are stored as a byte stream, with each byte element
 343      * at a subsequent address.  This corresponds to a little-endian load
 344      * of our 64-bit hunks.
 345      */
 346     for (i = 0; i < 32; ++i) {
 347         uint64_t *z = (void *)sve + TARGET_SVE_SIG_ZREG_OFFSET(vq, i);
 348         for (j = 0; j < vq * 2; ++j) {
 349             __get_user_e(env->vfp.zregs[i].d[j], z + j, le);
 350         }
 351     }
 352     for (i = 0; i <= 16; ++i) {
 353         uint16_t *p = (void *)sve + TARGET_SVE_SIG_PREG_OFFSET(vq, i);
 354         for (j = 0; j < vq; ++j) {
 355             uint16_t r;
 356             __get_user_e(r, p + j, le);
 357             if (j & 3) {
 358                 env->vfp.pregs[i].p[j >> 2] |= (uint64_t)r << ((j & 3) * 16);
 359             } else {
 360                 env->vfp.pregs[i].p[j >> 2] = r;
 361             }
 362         }
 363     }
 364     return true;
 365 }
 366
 367 static bool target_restore_za_record(CPUARMState *env,
 368                                      struct target_za_context *za,
 369                                      int size, int *svcr)
 370 {
 371     int i, j, vl, vq;
 372
 373     if (!cpu_isar_feature(aa64_sme, env_archcpu(env))) {
 374         return false;
 375     }
 376
 377     __get_user(vl, &za->vl);
 378     vq = sme_vq(env);
 379
 380     /* Reject mismatched VL. */
 381     if (vl != vq * TARGET_SVE_VQ_BYTES) {
 382         return false;
 383     }
 384
 385     /* Accept empty record -- used to clear PSTATE.ZA. */
 386     if (size <= TARGET_ZA_SIG_CONTEXT_SIZE(0)) {
 387         return true;
 388     }
 389
 390     /* Reject non-empty but incomplete record. */
 391     if (size < TARGET_ZA_SIG_CONTEXT_SIZE(vq)) {
 392         return false;
 393     }
 394
 395     *svcr = FIELD_DP64(*svcr, SVCR, ZA, 1);
 396
 397     for (i = 0; i < vl; ++i) {
 398         uint64_t *z = (void *)za + TARGET_ZA_SIG_ZAV_OFFSET(vq, i);
 399         for (j = 0; j < vq * 2; ++j) {
 400             __get_user_e(env->zarray[i].d[j], z + j, le);
 401         }
 402     }
 403     return true;
 404 }
 405
 406 static int target_restore_sigframe(CPUARMState *env,
 407                                    struct target_rt_sigframe *sf)
 408 {
 409     struct target_aarch64_ctx *ctx, *extra = NULL;
 410     struct target_fpsimd_context *fpsimd = NULL;
 411     struct target_sve_context *sve = NULL;
 412     struct target_za_context *za = NULL;
 413     uint64_t extra_datap = 0;
 414     bool used_extra = false;
 415     int sve_size = 0;
 416     int za_size = 0;
 417     int svcr = 0;
 418
 419     target_restore_general_frame(env, sf);
 420
 421     ctx = (struct target_aarch64_ctx *)sf->uc.tuc_mcontext.__reserved;
 422     while (ctx) {
 423         uint32_t magic, size, extra_size;
 424
 425         __get_user(magic, &ctx->magic);
 426         __get_user(size, &ctx->size);
 427         switch (magic) {
 428         case 0:
 429             if (size != 0) {
 430                 goto err;
 431             }
 432             if (used_extra) {
 433                 ctx = NULL;
 434             } else {
 435                 ctx = extra;
 436                 used_extra = true;
 437             }
 438             continue;
 439
 440         case TARGET_FPSIMD_MAGIC:
 441             if (fpsimd || size != sizeof(struct target_fpsimd_context)) {
 442                 goto err;
 443             }
 444             fpsimd = (struct target_fpsimd_context *)ctx;
 445             break;
 446
 447         case TARGET_SVE_MAGIC:
 448             if (sve || size < sizeof(struct target_sve_context)) {
 449                 goto err;
 450             }
 451             sve = (struct target_sve_context *)ctx;
 452             sve_size = size;
 453             break;
 454
 455         case TARGET_ZA_MAGIC:
 456             if (za || size < sizeof(struct target_za_context)) {
 457                 goto err;
 458             }
 459             za = (struct target_za_context *)ctx;
 460             za_size = size;
 461             break;
 462
 463         case TARGET_EXTRA_MAGIC:
 464             if (extra || size != sizeof(struct target_extra_context)) {
 465                 goto err;
 466             }
 467             __get_user(extra_datap,
 468                        &((struct target_extra_context *)ctx)->datap);
 469             __get_user(extra_size,
 470                        &((struct target_extra_context *)ctx)->size);
 471             extra = lock_user(VERIFY_READ, extra_datap, extra_size, 0);
 472             if (!extra) {
 473                 return 1;
 474             }
 475             break;
 476
 477         default:
 478             /* Unknown record -- we certainly didn't generate it.
 479              * Did we in fact get out of sync?
 480              */
 481             goto err;
 482         }
 483         ctx = (void *)ctx + size;
 484     }
 485
 486     /* Require FPSIMD always.  */
 487     if (fpsimd) {
 488         target_restore_fpsimd_record(env, fpsimd);
 489     } else {
 490         goto err;
 491     }
 492
 493     /* SVE data, if present, overwrites FPSIMD data.  */
 494     if (sve && !target_restore_sve_record(env, sve, sve_size, &svcr)) {
 495         goto err;
 496     }
 497     if (za && !target_restore_za_record(env, za, za_size, &svcr)) {
 498         goto err;
 499     }
 500     if (env->svcr != svcr) {
 501         env->svcr = svcr;
 502         arm_rebuild_hflags(env);
 503     }
 504     unlock_user(extra, extra_datap, 0);
 505     return 0;
 506
 507  err:
 508     unlock_user(extra, extra_datap, 0);
 509     return 1;
 510 }
 511
 512 static abi_ulong get_sigframe(struct target_sigaction *ka,
 513                               CPUARMState *env, int size)
 514 {
 515     abi_ulong sp;
 516
 517     sp = target_sigsp(get_sp_from_cpustate(env), ka);
 518
 519     sp = (sp - size) & ~15;
 520
 521     return sp;
 522 }
 523
 524 typedef struct {
 525     int total_size;
 526     int extra_base;
 527     int extra_size;
 528     int std_end_ofs;
 529     int extra_ofs;
 530     int extra_end_ofs;
 531 } target_sigframe_layout;
 532
 533 static int alloc_sigframe_space(int this_size, target_sigframe_layout *l)
 534 {
 535     /* Make sure there will always be space for the end marker.  */
 536     const int std_size = sizeof(struct target_rt_sigframe)
 537                          - sizeof(struct target_aarch64_ctx);
 538     int this_loc = l->total_size;
 539
 540     if (l->extra_base) {
 541         /* Once we have begun an extra space, all allocations go there.  */
 542         l->extra_size += this_size;
 543     } else if (this_size + this_loc > std_size) {
 544         /* This allocation does not fit in the standard space.  */
 545         /* Allocate the extra record.  */
 546         l->extra_ofs = this_loc;
 547         l->total_size += sizeof(struct target_extra_context);
 548
 549         /* Allocate the standard end record.  */
 550         l->std_end_ofs = l->total_size;
 551         l->total_size += sizeof(struct target_aarch64_ctx);
 552
 553         /* Allocate the requested record.  */
 554         l->extra_base = this_loc = l->total_size;
 555         l->extra_size = this_size;
 556     }
 557     l->total_size += this_size;
 558
 559     return this_loc;
 560 }
 561
 562 static void target_setup_frame(int usig, struct target_sigaction *ka,
 563                                target_siginfo_t *info, target_sigset_t *set,
 564                                CPUARMState *env)
 565 {
 566     target_sigframe_layout layout = {
 567         /* Begin with the size pointing to the reserved space.  */
 568         .total_size = offsetof(struct target_rt_sigframe,
 569                                uc.tuc_mcontext.__reserved),
 570     };
 571     int fpsimd_ofs, fr_ofs, sve_ofs = 0, za_ofs = 0;
 572     int sve_size = 0, za_size = 0;
 573     struct target_rt_sigframe *frame;
 574     struct target_rt_frame_record *fr;
 575     abi_ulong frame_addr, return_addr;
 576
 577     /* FPSIMD record is always in the standard space.  */
 578     fpsimd_ofs = alloc_sigframe_space(sizeof(struct target_fpsimd_context),
 579                                       &layout);
 580
 581     /* SVE state needs saving only if it exists.  */
 582     if (cpu_isar_feature(aa64_sve, env_archcpu(env)) ||
 583         cpu_isar_feature(aa64_sme, env_archcpu(env))) {
 584         sve_size = QEMU_ALIGN_UP(TARGET_SVE_SIG_CONTEXT_SIZE(sve_vq(env)), 16);
 585         sve_ofs = alloc_sigframe_space(sve_size, &layout);
 586     }
 587     if (cpu_isar_feature(aa64_sme, env_archcpu(env))) {
 588         /* ZA state needs saving only if it is enabled.  */
 589         if (FIELD_EX64(env->svcr, SVCR, ZA)) {
 590             za_size = TARGET_ZA_SIG_CONTEXT_SIZE(sme_vq(env));
 591         } else {
 592             za_size = TARGET_ZA_SIG_CONTEXT_SIZE(0);
 593         }
 594         za_ofs = alloc_sigframe_space(za_size, &layout);
 595     }
 596
 597     if (layout.extra_ofs) {
 598         /* Reserve space for the extra end marker.  The standard end marker
 599          * will have been allocated when we allocated the extra record.
 600          */
 601         layout.extra_end_ofs
 602             = alloc_sigframe_space(sizeof(struct target_aarch64_ctx), &layout);
 603     } else {
 604         /* Reserve space for the standard end marker.
 605          * Do not use alloc_sigframe_space because we cheat
 606          * std_size therein to reserve space for this.
 607          */
 608         layout.std_end_ofs = layout.total_size;
 609         layout.total_size += sizeof(struct target_aarch64_ctx);
 610     }
 611
 612     /* We must always provide at least the standard 4K reserved space,
 613      * even if we don't use all of it (this is part of the ABI)
 614      */
 615     layout.total_size = MAX(layout.total_size,
 616                             sizeof(struct target_rt_sigframe));
 617
 618     /*
 619      * Reserve space for the standard frame unwind pair: fp, lr.
 620      * Despite the name this is not a "real" record within the frame.
 621      */
 622     fr_ofs = layout.total_size;
 623     layout.total_size += sizeof(struct target_rt_frame_record);
 624
 625     frame_addr = get_sigframe(ka, env, layout.total_size);
 626     trace_user_setup_frame(env, frame_addr);
 627     frame = lock_user(VERIFY_WRITE, frame_addr, layout.total_size, 0);
 628     if (!frame) {
 629         goto give_sigsegv;
 630     }
 631
 632     target_setup_general_frame(frame, env, set);
 633     target_setup_fpsimd_record((void *)frame + fpsimd_ofs, env);
 634     target_setup_end_record((void *)frame + layout.std_end_ofs);
 635     if (layout.extra_ofs) {
 636         target_setup_extra_record((void *)frame + layout.extra_ofs,
 637                                   frame_addr + layout.extra_base,
 638                                   layout.extra_size);
 639         target_setup_end_record((void *)frame + layout.extra_end_ofs);
 640     }
 641     if (sve_ofs) {
 642         target_setup_sve_record((void *)frame + sve_ofs, env, sve_size);
 643     }
 644     if (za_ofs) {
 645         target_setup_za_record((void *)frame + za_ofs, env, za_size);
 646     }
 647
 648     /* Set up the stack frame for unwinding.  */
 649     fr = (void *)frame + fr_ofs;
 650     __put_user(env->xregs[29], &fr->fp);
 651     __put_user(env->xregs[30], &fr->lr);
 652
 653     if (ka->sa_flags & TARGET_SA_RESTORER) {
 654         return_addr = ka->sa_restorer;
 655     } else {
 656         return_addr = default_rt_sigreturn;
 657     }
 658     env->xregs[0] = usig;
 659     env->xregs[29] = frame_addr + fr_ofs;
 660     env->xregs[30] = return_addr;
 661     env->xregs[31] = frame_addr;
 662     env->pc = ka->_sa_handler;
 663
 664     /* Invoke the signal handler as if by indirect call.  */
 665     if (cpu_isar_feature(aa64_bti, env_archcpu(env))) {
 666         env->btype = 2;
 667     }
 668
 669     /* Invoke the signal handler with both SM and ZA disabled. */
 670     aarch64_set_svcr(env, 0, R_SVCR_SM_MASK | R_SVCR_ZA_MASK);
 671
 672     if (info) {
 673         tswap_siginfo(&frame->info, info);
 674         env->xregs[1] = frame_addr + offsetof(struct target_rt_sigframe, info);
 675         env->xregs[2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
 676     }
 677
 678     unlock_user(frame, frame_addr, layout.total_size);
 679     return;
 680
 681  give_sigsegv:
 682     unlock_user(frame, frame_addr, layout.total_size);
 683     force_sigsegv(usig);
 684 }
 685
 686 void setup_rt_frame(int sig, struct target_sigaction *ka,
 687                     target_siginfo_t *info, target_sigset_t *set,
 688                     CPUARMState *env)
 689 {
 690     target_setup_frame(sig, ka, info, set, env);
 691 }
 692
 693 void setup_frame(int sig, struct target_sigaction *ka,
 694                  target_sigset_t *set, CPUARMState *env)
 695 {
 696     target_setup_frame(sig, ka, 0, set, env);
 697 }
 698
 699 long do_rt_sigreturn(CPUARMState *env)
 700 {
 701     struct target_rt_sigframe *frame = NULL;
 702     abi_ulong frame_addr = env->xregs[31];
 703
 704     trace_user_do_rt_sigreturn(env, frame_addr);
 705     if (frame_addr & 15) {
 706         goto badframe;
 707     }
 708
 709     if  (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
 710         goto badframe;
 711     }
 712
 713     if (target_restore_sigframe(env, frame)) {
 714         goto badframe;
 715     }
 716
 717     target_restore_altstack(&frame->uc.tuc_stack, env);
 718
 719     unlock_user_struct(frame, frame_addr, 0);
 720     return -QEMU_ESIGRETURN;
 721
 722  badframe:
 723     unlock_user_struct(frame, frame_addr, 0);
 724     force_sig(TARGET_SIGSEGV);
 725     return -QEMU_ESIGRETURN;
 726 }
 727
 728 long do_sigreturn(CPUARMState *env)
 729 {
 730     return do_rt_sigreturn(env);
 731 }
 732
 733 void setup_sigtramp(abi_ulong sigtramp_page)
 734 {
 735     uint32_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 8, 0);
 736     assert(tramp != NULL);
 737
 738     /*
 739      * mov x8,#__NR_rt_sigreturn; svc #0
 740      * Since these are instructions they need to be put as little-endian
 741      * regardless of target default or current CPU endianness.
 742      */
 743     __put_user_e(0xd2801168, &tramp[0], le);
 744     __put_user_e(0xd4000001, &tramp[1], le);
 745
 746     default_rt_sigreturn = sigtramp_page;
 747     unlock_user(tramp, sigtramp_page, 8);
 748 }