xref: /openbmc/qemu/linux-user/aarch64/signal.c (revision cde3c425)
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         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 }
749