gdbstub: add support for switchable endianness
cover gdbstub: add support for switchable endianness
To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.
For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.
$ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...
Changbin Du (3):
gdbstub: add basic infrastructure to support switchable endianness
arm: gdbstub: add support for switchable endianness
riscv: gdbstub: add support for switchable endianness
configs/targets/aarch64-softmmu.mak | 1 + configs/targets/arm-softmmu.mak | 1 + configs/targets/riscv32-softmmu.mak | 1 + configs/targets/riscv64-softmmu.mak | 1 + gdbstub.c | 11 +++++ include/exec/gdbstub.h | 72 +++++++++++++++++++++-------- qemu-options.hx | 7 ++- softmmu/vl.c | 50 +++++++++++++++++++- target/arm/gdbstub.c | 2 +- target/arm/gdbstub64.c | 2 +- target/riscv/gdbstub.c | 12 ++--- 11 files changed, 131 insertions(+), 29 deletions(-)
Signature · 1 line
2.32.0
PATCH 1/3 gdbstub: add basic infrastructure to support switchable endianness
Some architectures (e.g. ARM versions 3 and above, RISC-V, PowerPC, Alpha, MIPS, IA-64...) allow switchable endianness. Now our emulation code can handle both endianness well, but the gdbstub can only handle one of them.
For example, it is problematic to debug a ARM big endian guest on x86 host. This because the GDB remote protocol transfers values in target byte order but qemu always take it as little endian on x86 host.
To support switchable endianness targets, this patch introduces:
- a new sub-option 'endianness' for '-gdb'.
- common interfaces to swap byte order according to host and target byte order.
- a new configuration option TARGET_SWICHABLE_ENDIANNESS.
For example, to debug a arm64 big endian target, you could start qemu as below:
$ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...
Latter we will add switchable endianness support for ARM and RISC-V targets. For other switchable targets them can be supported in future.
--- gdbstub.c | 11 +++++++ include/exec/gdbstub.h | 72 +++++++++++++++++++++++++++++++----------- qemu-options.hx | 7 ++-- softmmu/vl.c | 50 ++++++++++++++++++++++++++++- 4 files changed, 119 insertions(+), 21 deletions(-)
gdbstub.c +11 -0
@@ -62,6 +62,17 @@static int phy_memory_mode;#endif +#ifdef HOST_WORDS_BIGENDIAN +const bool gdb_host_bigendian = true; +#else +const bool gdb_host_bigendian = false; +#endif +#ifdef TARGET_WORDS_BIGENDIAN +bool gdb_target_bigendian = true; +#else +bool gdb_target_bigendian = false; +#endif +static inline int target_memory_rw_debug (CPUState *cpu,target_ulong addr,uint8_t *buf,int len,bool is_write) {
include/exec/gdbstub.h +54 -18
114 lines not on this page · raw message
qemu-options.hx +5 -2
@@ -3954,9 +3954,12 @@ SRST ERST DEF("gdb", HAS_ARG, QEMU_OPTION_gdb, \ - "-gdb dev accept gdb connection on 'dev'. (QEMU defaults to starting\n" + "-gdb [dev=]device[,endianness=default|little|big]\n" + " accept gdb connection on 'dev'. (QEMU defaults to starting\n" " the guest without waiting for gdb to connect; use -S too\n" - " if you want it to not start execution.)\n", + " if you want it to not start execution.) The 'endianness'\n" + " specifies the endianness mode of the target which supports\n" + " switchable endianness.\n", QEMU_ARCH_ALL) SRST ``-gdb dev``
softmmu/vl.c +49 -1
68 lines not on this page · raw message
Signature · 1 line
2.32.0
PATCH 2/3 arm: gdbstub: add support for switchable endianness
In reply to Changbin DuApply new gdbstub interfaces we added previously to support both little and big endian guest debugging for ARM. And enable the TARGET_SWICHABLE_ENDIANNESS option.
--- configs/targets/aarch64-softmmu.mak | 1 + configs/targets/arm-softmmu.mak | 1 + target/arm/gdbstub.c | 2 +- target/arm/gdbstub64.c | 2 +- 4 files changed, 4 insertions(+), 2 deletions(-)
configs/targets/aarch64-softmmu.mak +1 -0
@@ -3,3 +3,4 @@ TARGET_BASE_ARCH=arm TARGET_SUPPORTS_MTTCG=y TARGET_XML_FILES= gdb-xml/aarch64-core.xml gdb-xml/aarch64-fpu.xml gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml TARGET_NEED_FDT=y +TARGET_SWICHABLE_ENDIANNESS=y
configs/targets/arm-softmmu.mak +1 -0
@@ -2,3 +2,4 @@ TARGET_ARCH=arm TARGET_SUPPORTS_MTTCG=y TARGET_XML_FILES= gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml TARGET_NEED_FDT=y +TARGET_SWICHABLE_ENDIANNESS=y
target/arm/gdbstub.c +1 -1
@@ -74,7 +74,7 @@ int arm_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)CPUARMState *env = &cpu->env;uint32_t tmp; - tmp =ldl_p (mem_buf); + tmp =gdb_read_reg32 (mem_buf);/* Mask out low bit of PC to workaround gdb bugs. This will probably cause problems if we ever implement the Jazelle DBX extensions. */
target/arm/gdbstub64.c +1 -1
@@ -47,7 +47,7 @@ int aarch64_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)CPUARMState *env = &cpu->env;uint64_t tmp; - tmp =ldq_p (mem_buf); + tmp =gdb_read_reg64 (mem_buf);if (n <31 ) {/* Core integer register. */
Signature · 1 line
2.32.0
PATCH 3/3 riscv: gdbstub: add support for switchable endianness
In reply to Changbin DuApply new gdbstub interfaces we added previously to support both little and big endian guest debugging for RISC-V. And enable the TARGET_SWICHABLE_ENDIANNESS option.
--- configs/targets/riscv32-softmmu.mak | 1 + configs/targets/riscv64-softmmu.mak | 1 + target/riscv/gdbstub.c | 12 ++++++------ 3 files changed, 8 insertions(+), 6 deletions(-)
configs/targets/riscv32-softmmu.mak +1 -0
@@ -3,3 +3,4 @@ TARGET_BASE_ARCH=riscv TARGET_SUPPORTS_MTTCG=y TARGET_XML_FILES= gdb-xml/riscv-32bit-cpu.xml gdb-xml/riscv-32bit-fpu.xml gdb-xml/riscv-64bit-fpu.xml gdb-xml/riscv-32bit-virtual.xml TARGET_NEED_FDT=y +TARGET_SWICHABLE_ENDIANNESS=y
configs/targets/riscv64-softmmu.mak +1 -0
@@ -3,3 +3,4 @@ TARGET_BASE_ARCH=riscv TARGET_SUPPORTS_MTTCG=y TARGET_XML_FILES= gdb-xml/riscv-64bit-cpu.xml gdb-xml/riscv-32bit-fpu.xml gdb-xml/riscv-64bit-fpu.xml gdb-xml/riscv-64bit-virtual.xml TARGET_NEED_FDT=y +TARGET_SWICHABLE_ENDIANNESS=y
target/riscv/gdbstub.c +6 -6
@@ -42,10 +42,10 @@ int riscv_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)/* discard writes to x0 */ return sizeof (target_ulong); }else if (n <32 ) { - env->gpr[n] =ldtul_p (mem_buf); + env->gpr[n] =gdb_read_regl (mem_buf);return sizeof (target_ulong); }else if (n ==32 ) { - env->pc =ldtul_p (mem_buf); + env->pc =gdb_read_regl (mem_buf);return sizeof (target_ulong); }return 0 ;
@@ -81,11 +81,11 @@ static int riscv_gdb_get_fpu(CPURISCVState *env, GByteArray *buf, int n)static int riscv_gdb_set_fpu (CPURISCVState *env,uint8_t *mem_buf,int n) {if (n <32 ) { - env->fpr[n] =ldq_p (mem_buf);/* always 64-bit */ + env->fpr[n] =gdb_read_reg64 (mem_buf);/* always 64-bit */ return sizeof (uint64_t );/* there is hole between ft11 and fflags in fpu.xml */ }else if (n <36 && n >32 ) { -target_ulong val =ldtul_p (mem_buf); +target_ulong val =gdb_read_regl (mem_buf);int result;/* * CSR_FFLAGS is at index 1 in csr_register, and gdb says it is FP
@@ -118,7 +118,7 @@ static int riscv_gdb_get_csr(CPURISCVState *env, GByteArray *buf, int n)static int riscv_gdb_set_csr (CPURISCVState *env,uint8_t *mem_buf,int n) {if (n <CSR_TABLE_SIZE ) { -target_ulong val =ldtul_p (mem_buf); +target_ulong val =gdb_read_regl (mem_buf);int result; result =riscv_csrrw_debug (env, n,NULL , val,-1 );
@@ -145,7 +145,7 @@ static int riscv_gdb_set_virtual(CPURISCVState *cs, uint8_t *mem_buf, int n) {if (n ==0 ) {#ifndef CONFIG_USER_ONLY - cs->priv =ldtul_p (mem_buf) &0x3 ; + cs->priv =gdb_read_regl (mem_buf) &0x3 ;if (cs->priv ==PRV_H ) { cs->priv =PRV_S ; }
Signature · 1 line
2.32.0
Quoted 8 lines · Changbin Du
To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.
For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.
$ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...
I don't understand why you need all that. Maybe you aren't using gdb-multiarch?
You can install it or start it via QEMU Debian Docker image:
$ docker run -it --rm -v /tmp:/tmp -u $UID --network=host \
registry.gitlab.com/qemu-project/qemu/qemu/debian10 \
gdb-multiarch -q \
--ex 'set architecture aarch64' \
--ex 'set endian big'
The target architecture is assumed to be aarch64
The target is assumed to be big endian
(gdb) target remote 172.17.0.1:1234
(gdb)Quoted 16 lines · Philippe Mathieu-Daudé
Quoted 8 lines · Changbin Du
To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.
For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.
$ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...I don't understand why you need all that. Maybe you aren't using gdb-multiarch?
You can install it or start it via QEMU Debian Docker image:
Quoted 8 lines
$ docker run -it --rm -v /tmp:/tmp -u $UID --network=host \
registry.gitlab.com/qemu-project/qemu/qemu/debian10 \
gdb-multiarch -q \
--ex 'set architecture aarch64' \
--ex 'set endian big'
The target architecture is assumed to be aarch64
The target is assumed to be big endian
(gdb) target remote 172.17.0.1:1234I don't think that will help, because an AArch64 CPU (at least in the boards we model) will always start up in little-endian, and our gdbstub will always transfer register data etc in little-endian order, because gdb cannot cope with a target that isn't always the same endianness. Fixing this requires gdb changes to be more capable of handling dynamic target changes (this would also help with eg debugging across 32<->64 bit switches); as I understand it that gdb work would be pretty significant, and at least for aarch64 pretty much nobody cares about big-endian, so nobody's got round to doing it yet.
Our target/ppc/gdbstub.c code takes a different tack: it always sends register data in the same order the CPU is currently in, which has a different set of cases when it goes wrong.
thanks
-- PMM
Quoted 37 lines · Peter Maydell
Quoted 16 lines · Philippe Mathieu-Daudé
Quoted 8 lines · Changbin Du
To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.
For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.
$ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...I don't understand why you need all that. Maybe you aren't using gdb-multiarch?
You can install it or start it via QEMU Debian Docker image:
Quoted 8 lines
$ docker run -it --rm -v /tmp:/tmp -u $UID --network=host \ registry.gitlab.com/qemu-project/qemu/qemu/debian10 \ gdb-multiarch -q \ --ex 'set architecture aarch64' \ --ex 'set endian big' The target architecture is assumed to be aarch64 The target is assumed to be big endian (gdb) target remote 172.17.0.1:1234I don't think that will help, because an AArch64 CPU (at least in the boards we model) will always start up in little-endian, and our gdbstub will always transfer register data etc in little-endian order, because gdb cannot cope with a target that isn't always the same endianness. Fixing this requires gdb changes to be more capable of handling dynamic target changes (this would also help with eg debugging across 32<->64 bit switches); as I understand it that gdb work would be pretty significant, and at least for aarch64 pretty much nobody cares about big-endian, so nobody's got round to doing it yet.
Quoted 4 lines
Our
target/ppc/gdbstub.ccode takes a different tack: it always sends register data in the same order the CPU is currently in, which has a different set of cases when it goes wrong.
I remember having tested the 'setend be' instruction (from
https://github.com/pcrost/arm-be-test) 3 years ago using it. Connected as little endian, set breakpoint, on BP hit disconnect, set big-endian, reconnect, keep single-stepping (in the same gdb session).
I doubt anything changed since.
Quoted 26 lines · Peter Maydell
Quoted 16 lines · Philippe Mathieu-Daudé
Quoted 8 lines · Changbin Du
To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.
For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.
$ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...I don't understand why you need all that. Maybe you aren't using gdb-multiarch?
You can install it or start it via QEMU Debian Docker image:
Quoted 8 lines
$ docker run -it --rm -v /tmp:/tmp -u $UID --network=host \ registry.gitlab.com/qemu-project/qemu/qemu/debian10 \ gdb-multiarch -q \ --ex 'set architecture aarch64' \ --ex 'set endian big' The target architecture is assumed to be aarch64 The target is assumed to be big endian (gdb) target remote 172.17.0.1:1234
Quoted 5 lines
I don't think that will help, because an AArch64 CPU (at least in the boards we model) will always start up in little-endian, and our gdbstub will always transfer register data etc in little-endian order, because gdb cannot cope with a target that isn't always the same endianness. Fixing this requires gdb
Yes, that's the problem.
Quoted 6 lines
changes to be more capable of handling dynamic target changes (this would also help with eg debugging across 32<->64 bit switches); as I understand it that gdb work would be pretty significant, and at least for aarch64 pretty much nobody cares about big-endian, so nobody's got round to doing it yet.
Mostly we do not care dynamic target changes because nearly all OS will setup endianness mode by its first instruction. And dynamic changes for gdb is hard since the byte order of debugging info in elf is fixed. And currently the GDB remote protocol does not support querying endianness info from remote.
So usually we needn't change byte order during a debug session, but we just want the qemu gdbstub can send data in and handle data it received in right byte order. This patch does this work with the help of users via the option 'endianness='.
Quoted 5 lines
Our
target/ppc/gdbstub.ccode takes a different tack: it always sends register data in the same order the CPU is currently in, which has a different set of cases when it goes wrong.
Yes, I tried to do this before. But as I said above GDB unable to handle dynamic target changing. Maybe we can take this way as 'endianness=default'? Anyway, this requires each target provides a interface to determine the current byte order.
Quoted 2 lines
thanks
-- PMM
Signature · 2 lines
Cheers, Changbin Du
Quoted 8 lines · Changbin Du
Quoted 6 lines · Peter Maydell
changes to be more capable of handling dynamic target changes (this would also help with eg debugging across 32<->64 bit switches); as I understand it that gdb work would be pretty significant, and at least for aarch64 pretty much nobody cares about big-endian, so nobody's got round to doing it yet.
Quoted 8 lines
Mostly we do not care dynamic target changes because nearly all OS will setup endianness mode by its first instruction. And dynamic changes for gdb is hard since the byte order of debugging info in elf is fixed. And currently the GDB remote protocol does not support querying endianness info from remote.
So usually we needn't change byte order during a debug session, but we just want the qemu gdbstub can send data in and handle data it received in right byte order. This patch does this work with the help of users via the option 'endianness='.
I'm not a huge fan of putting in workarounds that deal with the problem for specific cases and require users to tweak options settings, rather than solving the problem in a more general way that would let it all Just Work for all cases.
-- PMM
Quoted 14 lines · Peter Maydell
Quoted 13 lines · Changbin Du
Quoted 6 lines · Peter Maydell
changes to be more capable of handling dynamic target changes (this would also help with eg debugging across 32<->64 bit switches); as I understand it that gdb work would be pretty significant, and at least for aarch64 pretty much nobody cares about big-endian, so nobody's got round to doing it yet.
Mostly we do not care dynamic target changes because nearly all OS will setup endianness mode by its first instruction. And dynamic changes for gdb is hard since the byte order of debugging info in elf is fixed. And currently the GDB remote protocol does not support querying endianness info from remote.
Quoted 9 lines
Quoted 3 lines
So usually we needn't change byte order during a debug session, but we just want the qemu gdbstub can send data in and handle data it received in right byte order. This patch does this work with the help of users via the option 'endianness='.
I'm not a huge fan of putting in workarounds that deal with the problem for specific cases and require users to tweak options settings, rather than solving the problem in a more general way that would let it all Just Work for all cases.
Probably we can add a new callback 'gdb_get_endianness' for CPUClass, and use this callback to determine if bswap is needed every time we read/write cpu registers. What's your thought?
Quoted 1 line
-- PMM
Signature · 2 lines
Cheers, Changbin Du
Quoted 20 lines · Changbin Du
Quoted 18 lines · Peter Maydell
Quoted 16 lines · Changbin Du
Quoted 6 lines · Peter Maydell
changes to be more capable of handling dynamic target changes (this would also help with eg debugging across 32<->64 bit switches); as I understand it that gdb work would be pretty significant, and at least for aarch64 pretty much nobody cares about big-endian, so nobody's got round to doing it yet.
Mostly we do not care dynamic target changes because nearly all OS will setup endianness mode by its first instruction. And dynamic changes for gdb is hard since the byte order of debugging info in elf is fixed. And currently the GDB remote protocol does not support querying endianness info from remote.
So usually we needn't change byte order during a debug session, but we just want the qemu gdbstub can send data in and handle data it received in right byte order. This patch does this work with the help of users via the option 'endianness='.
Quoted 8 lines
Quoted 5 lines
I'm not a huge fan of putting in workarounds that deal with the problem for specific cases and require users to tweak options settings, rather than solving the problem in a more general way that would let it all Just Work for all cases.
Probably we can add a new callback '
gdb_get_endianness' for CPUClass, and use this callback to determine if bswap is needed every time we read/write cpu registers. What's your thought?
I think that you need to start by talking to the gdb folks about how debugging a dynamic endianness target should work. Fixing this probably goes something like:
* agree on design for how dynamic endianness, 32-64 mode changes, etc, should be handled by gdb
* make gdb changes
* document required gdbstub protocol enhancements (ie how the stub tells gdb about endianness changes, whether this changes how we send register information, memory data, etc)
* implement those changes in QEMU
You seem to be trying to start with the final step, not the first one :-)
-- PMM
Quoted 5 lines · Philippe Mathieu-Daudé
Quoted 4 lines · Changbin Du
To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.
Quoted 8 lines
Quoted 4 lines
For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.
$ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...I don't understand why you need all that. Maybe you aren't using gdb-multiarch?
Nope, my gdb support all architectures.
Quoted 12 lines
You can install it or start it via QEMU Debian Docker image:
$ docker run -it --rm -v /tmp:/tmp -u $UID --network=host \ registry.gitlab.com/qemu-project/qemu/qemu/debian10 \ gdb-multiarch -q \ --ex 'set architecture aarch64' \ --ex 'set endian big' The target architecture is assumed to be aarch64 The target is assumed to be big endian (gdb) target remote 172.17.0.1:1234 (gdb)
The gdb has no problem to read endianness and arch info from elf. The problem is how qemu gdbstub handles the byte order it received.
Now let's try to debug a big-enadian aarch64 linux kernel.
1) start qemu with '-gdb tcp::1234'
$ gdb-multiarch vmlinux (gdb) target remote :1234 Remote debugging using :1234 0x0000004000000000 in ?? () => 0x0000004000000000: Cannot access memory at address 0x4000000000 (gdb) ni Cannot access memory at address 0x4000000000 (gdb) show architecture The target architecture is set to "auto" (currently "aarch64"). (gdb) show endian The target endianness is set automatically (currently big endian).
You see it an't work, not to mention adding breakpoints.
2) start qemu with '-gdb tcp::1234,endianness=big'
$ gdb-multiarch vmlinux (gdb) target remote :1234 Remote debugging using :1234 0x0000000040000000 in ?? () => 0x0000000040000000: c0 00 00 58 ldr x0, 0x40000018 (gdb) ni 0x0000000040000004 in ?? () => 0x0000000040000004: e1 03 1f aa mov x1, xzr (gdb) b start_kernel Breakpoint 1 at 0xffff800011130ee8 (2 locations) (gdb) c Continuing.
Thread 1 hit Breakpoint 1, 0xffff800011130ee8 in start_kernel ()
=> 0xffff800011130ee8 <start_kernel+0>: 5f 24 03 d5 bti c
(gdb) bt
#0 0xffff800011130ee8 in start_kernel ()
#1 0xffff8000111303c8 in __primary_switched () at arch/arm64/kernel/head.S:467 Backtrace stopped: previous frame identical to this frame (corrupt stack?)
okay, now it works fine.
Signature · 2 lines
Cheers, Changbin Du
Quoted 4 lines · Changbin Du
To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.
As I understand it, fixing this problem requires support from gdb, not merely changes to QEMU. You would need to be able to have QEMU tell gdb "the guest's endianness is now little/big" and have gdb cope with that change.
Quoted 4 lines
For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.
$ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...
I don't feel like this is the right approach. QEMU already knows the endianness of the guest at any point.
thanks
-- PMM