From: <ltaylorsimpson@gmail.com>
To: "'Brian Cain'" <brian.cain@oss.qualcomm.com>, <qemu-devel@nongnu.org>
Cc: richard.henderson@linaro.org, philmd@linaro.org,
matheus.bernardino@oss.qualcomm.com, ale@rev.ng, anjo@rev.ng,
marco.liebel@oss.qualcomm.com, alex.bennee@linaro.org,
quic_mburton@quicinc.com, sid.manning@oss.qualcomm.com,
"'Alex Rønne Petersen'" <alex@alexrp.com>,
"'Laurent Vivier'" <laurent@vivier.eu>
Subject: RE: [PATCH 1/2] linux-user/hexagon: Fix sigcontext
Date: Wed, 8 Oct 2025 15:46:17 -0600 [thread overview]
Message-ID: <023e01dc389c$faf84320$f0e8c960$@gmail.com> (raw)
In-Reply-To: <20251008014754.3565553-1-brian.cain@oss.qualcomm.com>
> -----Original Message-----
> From: Brian Cain <brian.cain@oss.qualcomm.com>
> Sent: Tuesday, October 7, 2025 7:48 PM
> To: qemu-devel@nongnu.org
> Cc: brian.cain@oss.qualcomm.com; richard.henderson@linaro.org;
> philmd@linaro.org; matheus.bernardino@oss.qualcomm.com; ale@rev.ng;
> anjo@rev.ng; marco.liebel@oss.qualcomm.com; ltaylorsimpson@gmail.com;
> alex.bennee@linaro.org; quic_mburton@quicinc.com;
> sid.manning@oss.qualcomm.com; Alex Rønne Petersen <alex@alexrp.com>;
> Laurent Vivier <laurent@vivier.eu>
> Subject: [PATCH 1/2] linux-user/hexagon: Fix sigcontext
>
> In order to correspond with the kernel, we've now (1) moved the preds[] to
> the right offset and combined the representation as a single ulong "p3_0", (2),
> added the cs{0,1} registers, (3) added a pad for 48 words, (4) added the user
> regs structure to an 8-byte aligned target_sigcontext structure.
Should you include the other control registers also (e.g., framekey)? Perhaps this is a bug in the kernel as well?
>
> Co-authored-by: Alex Rønne Petersen <alex@alexrp.com>
> Signed-off-by: Brian Cain <brian.cain@oss.qualcomm.com>
> ---
> linux-user/hexagon/signal.c | 199 ++++++++++++++++++++----------------
> 1 file changed, 111 insertions(+), 88 deletions(-)
>
> diff --git a/linux-user/hexagon/signal.c b/linux-user/hexagon/signal.c index
> 492b51f155..6c3dbf91fa 100644
> --- a/linux-user/hexagon/signal.c
> +++ b/linux-user/hexagon/signal.c
> @@ -23,7 +23,7 @@
> #include "signal-common.h"
> #include "linux-user/trace.h"
>
> -struct target_sigcontext {
> +struct target_user_regs_struct {
> target_ulong r0, r1, r2, r3;
> target_ulong r4, r5, r6, r7;
> target_ulong r8, r9, r10, r11;
Consider creating an array for these, then use a for loop below.
> @@ -39,14 +39,21 @@ struct target_sigcontext {
> target_ulong m0;
> target_ulong m1;
> target_ulong usr;
> + target_ulong p3_0;
> target_ulong gp;
> target_ulong ugp;
> target_ulong pc;
> target_ulong cause;
> target_ulong badva;
> - target_ulong pred[NUM_PREGS];
> + target_ulong cs0;
> + target_ulong cs1;
> + target_ulong pad1;
> };
>
> +struct target_sigcontext {
> + struct target_user_regs_struct sc_regs; }
> +__attribute__((aligned(8)));
> +
> struct target_ucontext {
> unsigned long uc_flags;
> target_ulong uc_link; /* target pointer */ @@ -76,53 +83,63 @@ static
> abi_ulong get_sigframe(struct target_sigaction *ka,
>
> static void setup_sigcontext(struct target_sigcontext *sc, CPUHexagonState
> *env) {
> - __put_user(env->gpr[HEX_REG_R00], &sc->r0);
> - __put_user(env->gpr[HEX_REG_R01], &sc->r1);
> - __put_user(env->gpr[HEX_REG_R02], &sc->r2);
> - __put_user(env->gpr[HEX_REG_R03], &sc->r3);
> - __put_user(env->gpr[HEX_REG_R04], &sc->r4);
> - __put_user(env->gpr[HEX_REG_R05], &sc->r5);
> - __put_user(env->gpr[HEX_REG_R06], &sc->r6);
> - __put_user(env->gpr[HEX_REG_R07], &sc->r7);
> - __put_user(env->gpr[HEX_REG_R08], &sc->r8);
> - __put_user(env->gpr[HEX_REG_R09], &sc->r9);
> - __put_user(env->gpr[HEX_REG_R10], &sc->r10);
> - __put_user(env->gpr[HEX_REG_R11], &sc->r11);
> - __put_user(env->gpr[HEX_REG_R12], &sc->r12);
> - __put_user(env->gpr[HEX_REG_R13], &sc->r13);
> - __put_user(env->gpr[HEX_REG_R14], &sc->r14);
> - __put_user(env->gpr[HEX_REG_R15], &sc->r15);
> - __put_user(env->gpr[HEX_REG_R16], &sc->r16);
> - __put_user(env->gpr[HEX_REG_R17], &sc->r17);
> - __put_user(env->gpr[HEX_REG_R18], &sc->r18);
> - __put_user(env->gpr[HEX_REG_R19], &sc->r19);
> - __put_user(env->gpr[HEX_REG_R20], &sc->r20);
> - __put_user(env->gpr[HEX_REG_R21], &sc->r21);
> - __put_user(env->gpr[HEX_REG_R22], &sc->r22);
> - __put_user(env->gpr[HEX_REG_R23], &sc->r23);
> - __put_user(env->gpr[HEX_REG_R24], &sc->r24);
> - __put_user(env->gpr[HEX_REG_R25], &sc->r25);
> - __put_user(env->gpr[HEX_REG_R26], &sc->r26);
> - __put_user(env->gpr[HEX_REG_R27], &sc->r27);
> - __put_user(env->gpr[HEX_REG_R28], &sc->r28);
> - __put_user(env->gpr[HEX_REG_R29], &sc->r29);
> - __put_user(env->gpr[HEX_REG_R30], &sc->r30);
> - __put_user(env->gpr[HEX_REG_R31], &sc->r31);
> - __put_user(env->gpr[HEX_REG_SA0], &sc->sa0);
> - __put_user(env->gpr[HEX_REG_LC0], &sc->lc0);
> - __put_user(env->gpr[HEX_REG_SA1], &sc->sa1);
> - __put_user(env->gpr[HEX_REG_LC1], &sc->lc1);
> - __put_user(env->gpr[HEX_REG_M0], &sc->m0);
> - __put_user(env->gpr[HEX_REG_M1], &sc->m1);
> - __put_user(env->gpr[HEX_REG_USR], &sc->usr);
> - __put_user(env->gpr[HEX_REG_GP], &sc->gp);
> - __put_user(env->gpr[HEX_REG_UGP], &sc->ugp);
> - __put_user(env->gpr[HEX_REG_PC], &sc->pc);
> + __put_user(env->gpr[HEX_REG_R00], &sc->sc_regs.r0);
> + __put_user(env->gpr[HEX_REG_R01], &sc->sc_regs.r1);
> + __put_user(env->gpr[HEX_REG_R02], &sc->sc_regs.r2);
> + __put_user(env->gpr[HEX_REG_R03], &sc->sc_regs.r3);
> + __put_user(env->gpr[HEX_REG_R04], &sc->sc_regs.r4);
> + __put_user(env->gpr[HEX_REG_R05], &sc->sc_regs.r5);
> + __put_user(env->gpr[HEX_REG_R06], &sc->sc_regs.r6);
> + __put_user(env->gpr[HEX_REG_R07], &sc->sc_regs.r7);
> + __put_user(env->gpr[HEX_REG_R08], &sc->sc_regs.r8);
> + __put_user(env->gpr[HEX_REG_R09], &sc->sc_regs.r9);
> + __put_user(env->gpr[HEX_REG_R10], &sc->sc_regs.r10);
> + __put_user(env->gpr[HEX_REG_R11], &sc->sc_regs.r11);
> + __put_user(env->gpr[HEX_REG_R12], &sc->sc_regs.r12);
> + __put_user(env->gpr[HEX_REG_R13], &sc->sc_regs.r13);
> + __put_user(env->gpr[HEX_REG_R14], &sc->sc_regs.r14);
> + __put_user(env->gpr[HEX_REG_R15], &sc->sc_regs.r15);
> + __put_user(env->gpr[HEX_REG_R16], &sc->sc_regs.r16);
> + __put_user(env->gpr[HEX_REG_R17], &sc->sc_regs.r17);
> + __put_user(env->gpr[HEX_REG_R18], &sc->sc_regs.r18);
> + __put_user(env->gpr[HEX_REG_R19], &sc->sc_regs.r19);
> + __put_user(env->gpr[HEX_REG_R20], &sc->sc_regs.r20);
> + __put_user(env->gpr[HEX_REG_R21], &sc->sc_regs.r21);
> + __put_user(env->gpr[HEX_REG_R22], &sc->sc_regs.r22);
> + __put_user(env->gpr[HEX_REG_R23], &sc->sc_regs.r23);
> + __put_user(env->gpr[HEX_REG_R24], &sc->sc_regs.r24);
> + __put_user(env->gpr[HEX_REG_R25], &sc->sc_regs.r25);
> + __put_user(env->gpr[HEX_REG_R26], &sc->sc_regs.r26);
> + __put_user(env->gpr[HEX_REG_R27], &sc->sc_regs.r27);
> + __put_user(env->gpr[HEX_REG_R28], &sc->sc_regs.r28);
> + __put_user(env->gpr[HEX_REG_R29], &sc->sc_regs.r29);
> + __put_user(env->gpr[HEX_REG_R30], &sc->sc_regs.r30);
> + __put_user(env->gpr[HEX_REG_R31], &sc->sc_regs.r31);
Replace the above with a for loop when the GPRs are declared as an array.
> + __put_user(env->gpr[HEX_REG_SA0], &sc->sc_regs.sa0);
> + __put_user(env->gpr[HEX_REG_LC0], &sc->sc_regs.lc0);
> + __put_user(env->gpr[HEX_REG_SA1], &sc->sc_regs.sa1);
> + __put_user(env->gpr[HEX_REG_LC1], &sc->sc_regs.lc1);
> + __put_user(env->gpr[HEX_REG_M0], &sc->sc_regs.m0);
> + __put_user(env->gpr[HEX_REG_M1], &sc->sc_regs.m1);
> + __put_user(env->gpr[HEX_REG_USR], &sc->sc_regs.usr);
> + __put_user(env->gpr[HEX_REG_GP], &sc->sc_regs.gp);
> + __put_user(env->gpr[HEX_REG_UGP], &sc->sc_regs.ugp);
> + __put_user(env->gpr[HEX_REG_PC], &sc->sc_regs.pc);
>
> + /* Consolidate predicates into p3_0 */
> + target_ulong preds = 0;
> int i;
> for (i = 0; i < NUM_PREGS; i++) {
> - __put_user(env->pred[i], &(sc->pred[i]));
> + preds |= (env->pred[i] & 0xff) << (i * 8);
> }
> + __put_user(preds, &sc->sc_regs.p3_0);
> +
> + /* Set cause and badva to 0 - these are set by kernel on exceptions */
> + __put_user(0, &sc->sc_regs.cause);
> + __put_user(0, &sc->sc_regs.badva);
Strange that we have this if they are ignored. Perhaps it's to match the kernel behavior.
> +
> + __put_user(env->gpr[HEX_REG_CS0], &sc->sc_regs.cs0);
> + __put_user(env->gpr[HEX_REG_CS1], &sc->sc_regs.cs1);
> }
>
> static void setup_ucontext(struct target_ucontext *uc, @@ -192,53 +209,59
> @@ badframe:
> static void restore_sigcontext(CPUHexagonState *env,
> struct target_sigcontext *sc) {
> - __get_user(env->gpr[HEX_REG_R00], &sc->r0);
> - __get_user(env->gpr[HEX_REG_R01], &sc->r1);
> - __get_user(env->gpr[HEX_REG_R02], &sc->r2);
> - __get_user(env->gpr[HEX_REG_R03], &sc->r3);
> - __get_user(env->gpr[HEX_REG_R04], &sc->r4);
> - __get_user(env->gpr[HEX_REG_R05], &sc->r5);
> - __get_user(env->gpr[HEX_REG_R06], &sc->r6);
> - __get_user(env->gpr[HEX_REG_R07], &sc->r7);
> - __get_user(env->gpr[HEX_REG_R08], &sc->r8);
> - __get_user(env->gpr[HEX_REG_R09], &sc->r9);
> - __get_user(env->gpr[HEX_REG_R10], &sc->r10);
> - __get_user(env->gpr[HEX_REG_R11], &sc->r11);
> - __get_user(env->gpr[HEX_REG_R12], &sc->r12);
> - __get_user(env->gpr[HEX_REG_R13], &sc->r13);
> - __get_user(env->gpr[HEX_REG_R14], &sc->r14);
> - __get_user(env->gpr[HEX_REG_R15], &sc->r15);
> - __get_user(env->gpr[HEX_REG_R16], &sc->r16);
> - __get_user(env->gpr[HEX_REG_R17], &sc->r17);
> - __get_user(env->gpr[HEX_REG_R18], &sc->r18);
> - __get_user(env->gpr[HEX_REG_R19], &sc->r19);
> - __get_user(env->gpr[HEX_REG_R20], &sc->r20);
> - __get_user(env->gpr[HEX_REG_R21], &sc->r21);
> - __get_user(env->gpr[HEX_REG_R22], &sc->r22);
> - __get_user(env->gpr[HEX_REG_R23], &sc->r23);
> - __get_user(env->gpr[HEX_REG_R24], &sc->r24);
> - __get_user(env->gpr[HEX_REG_R25], &sc->r25);
> - __get_user(env->gpr[HEX_REG_R26], &sc->r26);
> - __get_user(env->gpr[HEX_REG_R27], &sc->r27);
> - __get_user(env->gpr[HEX_REG_R28], &sc->r28);
> - __get_user(env->gpr[HEX_REG_R29], &sc->r29);
> - __get_user(env->gpr[HEX_REG_R30], &sc->r30);
> - __get_user(env->gpr[HEX_REG_R31], &sc->r31);
> - __get_user(env->gpr[HEX_REG_SA0], &sc->sa0);
> - __get_user(env->gpr[HEX_REG_LC0], &sc->lc0);
> - __get_user(env->gpr[HEX_REG_SA1], &sc->sa1);
> - __get_user(env->gpr[HEX_REG_LC1], &sc->lc1);
> - __get_user(env->gpr[HEX_REG_M0], &sc->m0);
> - __get_user(env->gpr[HEX_REG_M1], &sc->m1);
> - __get_user(env->gpr[HEX_REG_USR], &sc->usr);
> - __get_user(env->gpr[HEX_REG_GP], &sc->gp);
> - __get_user(env->gpr[HEX_REG_UGP], &sc->ugp);
> - __get_user(env->gpr[HEX_REG_PC], &sc->pc);
> + __get_user(env->gpr[HEX_REG_R00], &sc->sc_regs.r0);
> + __get_user(env->gpr[HEX_REG_R01], &sc->sc_regs.r1);
> + __get_user(env->gpr[HEX_REG_R02], &sc->sc_regs.r2);
> + __get_user(env->gpr[HEX_REG_R03], &sc->sc_regs.r3);
> + __get_user(env->gpr[HEX_REG_R04], &sc->sc_regs.r4);
> + __get_user(env->gpr[HEX_REG_R05], &sc->sc_regs.r5);
> + __get_user(env->gpr[HEX_REG_R06], &sc->sc_regs.r6);
> + __get_user(env->gpr[HEX_REG_R07], &sc->sc_regs.r7);
> + __get_user(env->gpr[HEX_REG_R08], &sc->sc_regs.r8);
> + __get_user(env->gpr[HEX_REG_R09], &sc->sc_regs.r9);
> + __get_user(env->gpr[HEX_REG_R10], &sc->sc_regs.r10);
> + __get_user(env->gpr[HEX_REG_R11], &sc->sc_regs.r11);
> + __get_user(env->gpr[HEX_REG_R12], &sc->sc_regs.r12);
> + __get_user(env->gpr[HEX_REG_R13], &sc->sc_regs.r13);
> + __get_user(env->gpr[HEX_REG_R14], &sc->sc_regs.r14);
> + __get_user(env->gpr[HEX_REG_R15], &sc->sc_regs.r15);
> + __get_user(env->gpr[HEX_REG_R16], &sc->sc_regs.r16);
> + __get_user(env->gpr[HEX_REG_R17], &sc->sc_regs.r17);
> + __get_user(env->gpr[HEX_REG_R18], &sc->sc_regs.r18);
> + __get_user(env->gpr[HEX_REG_R19], &sc->sc_regs.r19);
> + __get_user(env->gpr[HEX_REG_R20], &sc->sc_regs.r20);
> + __get_user(env->gpr[HEX_REG_R21], &sc->sc_regs.r21);
> + __get_user(env->gpr[HEX_REG_R22], &sc->sc_regs.r22);
> + __get_user(env->gpr[HEX_REG_R23], &sc->sc_regs.r23);
> + __get_user(env->gpr[HEX_REG_R24], &sc->sc_regs.r24);
> + __get_user(env->gpr[HEX_REG_R25], &sc->sc_regs.r25);
> + __get_user(env->gpr[HEX_REG_R26], &sc->sc_regs.r26);
> + __get_user(env->gpr[HEX_REG_R27], &sc->sc_regs.r27);
> + __get_user(env->gpr[HEX_REG_R28], &sc->sc_regs.r28);
> + __get_user(env->gpr[HEX_REG_R29], &sc->sc_regs.r29);
> + __get_user(env->gpr[HEX_REG_R30], &sc->sc_regs.r30);
> + __get_user(env->gpr[HEX_REG_R31], &sc->sc_regs.r31);
Replace the above with a for loop when the GPRs are declared as an array.
> + __get_user(env->gpr[HEX_REG_SA0], &sc->sc_regs.sa0);
> + __get_user(env->gpr[HEX_REG_LC0], &sc->sc_regs.lc0);
> + __get_user(env->gpr[HEX_REG_SA1], &sc->sc_regs.sa1);
> + __get_user(env->gpr[HEX_REG_LC1], &sc->sc_regs.lc1);
> + __get_user(env->gpr[HEX_REG_M0], &sc->sc_regs.m0);
> + __get_user(env->gpr[HEX_REG_M1], &sc->sc_regs.m1);
> + __get_user(env->gpr[HEX_REG_USR], &sc->sc_regs.usr);
> + __get_user(env->gpr[HEX_REG_GP], &sc->sc_regs.gp);
> + __get_user(env->gpr[HEX_REG_UGP], &sc->sc_regs.ugp);
> + __get_user(env->gpr[HEX_REG_PC], &sc->sc_regs.pc);
>
> + /* Restore predicates from p3_0 */
> + target_ulong preds;
> + __get_user(preds, &sc->sc_regs.p3_0);
> int i;
> for (i = 0; i < NUM_PREGS; i++) {
> - __get_user(env->pred[i], &(sc->pred[i]));
> + env->pred[i] = (preds >> (i * 8)) & 0xff;
> }
> +
> + __get_user(env->gpr[HEX_REG_CS0], &sc->sc_regs.cs0);
> + __get_user(env->gpr[HEX_REG_CS1], &sc->sc_regs.cs1);
> }
>
> static void restore_ucontext(CPUHexagonState *env, struct target_ucontext
> *uc)
> --
> 2.34.1
prev parent reply other threads:[~2025-10-08 21:48 UTC|newest]
Thread overview: 8+ messages / expand[flat|nested] mbox.gz Atom feed top
2025-10-08 1:47 [PATCH 1/2] linux-user/hexagon: Fix sigcontext Brian Cain
2025-10-08 1:47 ` [PATCH 2/2] tests/tcg/hexagon: Add cs{0,1} coverage Brian Cain
2025-10-08 15:03 ` Anton Johansson via
2025-10-08 21:51 ` ltaylorsimpson
2025-10-10 18:40 ` Brian Cain
2025-10-08 15:27 ` [PATCH 1/2] linux-user/hexagon: Fix sigcontext Anton Johansson via
2025-10-08 16:02 ` Richard Henderson
2025-10-08 21:46 ` ltaylorsimpson [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to='023e01dc389c$faf84320$f0e8c960$@gmail.com' \
--to=ltaylorsimpson@gmail.com \
--cc=ale@rev.ng \
--cc=alex.bennee@linaro.org \
--cc=alex@alexrp.com \
--cc=anjo@rev.ng \
--cc=brian.cain@oss.qualcomm.com \
--cc=laurent@vivier.eu \
--cc=marco.liebel@oss.qualcomm.com \
--cc=matheus.bernardino@oss.qualcomm.com \
--cc=philmd@linaro.org \
--cc=qemu-devel@nongnu.org \
--cc=quic_mburton@quicinc.com \
--cc=richard.henderson@linaro.org \
--cc=sid.manning@oss.qualcomm.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.