2003-06-27 19:34:32 +02:00
|
|
|
/*
|
|
|
|
* gdb server stub
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2019-07-05 14:28:19 +02:00
|
|
|
* This implements a subset of the remote protocol as described in:
|
|
|
|
*
|
|
|
|
* https://sourceware.org/gdb/onlinedocs/gdb/Remote-Protocol.html
|
|
|
|
*
|
2005-07-02 16:31:34 +02:00
|
|
|
* Copyright (c) 2003-2005 Fabrice Bellard
|
2003-06-27 19:34:32 +02:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2009-07-16 22:47:01 +02:00
|
|
|
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
2019-07-05 14:28:19 +02:00
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: LGPL-2.0+
|
2003-06-27 19:34:32 +02:00
|
|
|
*/
|
2019-05-23 16:35:06 +02:00
|
|
|
|
2016-01-29 18:50:05 +01:00
|
|
|
#include "qemu/osdep.h"
|
2019-05-23 16:35:06 +02:00
|
|
|
#include "qemu/ctype.h"
|
2016-03-20 18:16:19 +01:00
|
|
|
#include "qemu/cutils.h"
|
2019-05-23 16:35:07 +02:00
|
|
|
#include "qemu/module.h"
|
2023-03-15 18:43:13 +01:00
|
|
|
#include "qemu/error-report.h"
|
2022-09-29 13:42:22 +02:00
|
|
|
#include "trace.h"
|
2021-09-08 17:44:04 +02:00
|
|
|
#include "exec/gdbstub.h"
|
2023-03-03 03:57:57 +01:00
|
|
|
#include "gdbstub/syscalls.h"
|
2016-03-20 18:16:19 +01:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
2023-03-03 03:57:47 +01:00
|
|
|
#include "gdbstub/user.h"
|
2005-04-17 21:16:13 +02:00
|
|
|
#else
|
2019-01-07 16:23:45 +01:00
|
|
|
#include "hw/cpu/cluster.h"
|
2019-05-18 22:54:21 +02:00
|
|
|
#include "hw/boards.h"
|
2005-04-17 21:16:13 +02:00
|
|
|
#endif
|
2004-04-01 01:37:16 +02:00
|
|
|
|
2017-01-10 11:59:55 +01:00
|
|
|
#include "sysemu/hw_accel.h"
|
2019-08-12 07:23:59 +02:00
|
|
|
#include "sysemu/runstate.h"
|
2022-12-19 18:09:43 +01:00
|
|
|
#include "exec/replay-core.h"
|
2023-03-03 03:57:43 +01:00
|
|
|
#include "exec/hwaddr.h"
|
2008-12-18 23:44:13 +01:00
|
|
|
|
2022-09-29 13:42:24 +02:00
|
|
|
#include "internals.h"
|
|
|
|
|
2008-10-11 19:55:29 +02:00
|
|
|
typedef struct GDBRegisterState {
|
|
|
|
int base_reg;
|
|
|
|
int num_regs;
|
2020-03-16 18:21:41 +01:00
|
|
|
gdb_get_reg_cb get_reg;
|
|
|
|
gdb_set_reg_cb set_reg;
|
2008-10-11 19:55:29 +02:00
|
|
|
const char *xml;
|
|
|
|
struct GDBRegisterState *next;
|
|
|
|
} GDBRegisterState;
|
|
|
|
|
2023-03-03 03:57:46 +01:00
|
|
|
GDBState gdbserver_state;
|
2020-03-16 18:21:33 +01:00
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
void gdb_init_gdbserver_state(void)
|
2020-03-16 18:21:33 +01:00
|
|
|
{
|
|
|
|
g_assert(!gdbserver_state.init);
|
|
|
|
memset(&gdbserver_state, 0, sizeof(GDBState));
|
|
|
|
gdbserver_state.init = true;
|
2020-03-16 18:21:35 +01:00
|
|
|
gdbserver_state.str_buf = g_string_new(NULL);
|
2020-03-16 18:21:36 +01:00
|
|
|
gdbserver_state.mem_buf = g_byte_array_sized_new(MAX_PACKET_LENGTH);
|
2020-03-16 18:21:53 +01:00
|
|
|
gdbserver_state.last_packet = g_byte_array_sized_new(MAX_PACKET_LENGTH + 4);
|
2021-11-11 12:06:02 +01:00
|
|
|
|
|
|
|
/*
|
2022-09-29 13:42:23 +02:00
|
|
|
* What single-step modes are supported is accelerator dependent.
|
|
|
|
* By default try to use no IRQs and no timers while single
|
|
|
|
* stepping so as to make single stepping like a typical ICE HW step.
|
2021-11-11 12:06:02 +01:00
|
|
|
*/
|
2022-09-29 13:42:23 +02:00
|
|
|
gdbserver_state.supported_sstep_flags = accel_supported_gdbstub_sstep_flags();
|
2021-11-11 12:06:03 +01:00
|
|
|
gdbserver_state.sstep_flags = SSTEP_ENABLE | SSTEP_NOIRQ | SSTEP_NOTIMER;
|
|
|
|
gdbserver_state.sstep_flags &= gdbserver_state.supported_sstep_flags;
|
2020-03-16 18:21:33 +01:00
|
|
|
}
|
|
|
|
|
2013-06-29 04:18:45 +02:00
|
|
|
bool gdb_has_xml;
|
2008-10-11 19:55:29 +02:00
|
|
|
|
2018-04-08 16:59:33 +02:00
|
|
|
/* writes 2*len+1 bytes in buf */
|
2023-03-03 03:57:45 +01:00
|
|
|
void gdb_memtohex(GString *buf, const uint8_t *mem, int len)
|
2003-06-27 19:34:32 +02:00
|
|
|
{
|
|
|
|
int i, c;
|
|
|
|
for(i = 0; i < len; i++) {
|
|
|
|
c = mem[i];
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_append_c(buf, tohex(c >> 4));
|
|
|
|
g_string_append_c(buf, tohex(c & 0xf));
|
2003-06-27 19:34:32 +02:00
|
|
|
}
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_append_c(buf, '\0');
|
2003-06-27 19:34:32 +02:00
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
void gdb_hextomem(GByteArray *mem, const char *buf, int len)
|
2003-06-27 19:34:32 +02:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i = 0; i < len; i++) {
|
2020-03-16 18:21:36 +01:00
|
|
|
guint8 byte = fromhex(buf[0]) << 4 | fromhex(buf[1]);
|
|
|
|
g_byte_array_append(mem, &byte, 1);
|
2003-06-27 19:34:32 +02:00
|
|
|
buf += 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-03 02:30:37 +01:00
|
|
|
static void hexdump(const char *buf, int len,
|
|
|
|
void (*trace_fn)(size_t ofs, char const *text))
|
|
|
|
{
|
|
|
|
char line_buffer[3 * 16 + 4 + 16 + 1];
|
|
|
|
|
|
|
|
size_t i;
|
|
|
|
for (i = 0; i < len || (i & 0xF); ++i) {
|
|
|
|
size_t byte_ofs = i & 15;
|
|
|
|
|
|
|
|
if (byte_ofs == 0) {
|
|
|
|
memset(line_buffer, ' ', 3 * 16 + 4 + 16);
|
|
|
|
line_buffer[3 * 16 + 4 + 16] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t col_group = (i >> 2) & 3;
|
|
|
|
size_t hex_col = byte_ofs * 3 + col_group;
|
|
|
|
size_t txt_col = 3 * 16 + 4 + byte_ofs;
|
|
|
|
|
|
|
|
if (i < len) {
|
|
|
|
char value = buf[i];
|
|
|
|
|
|
|
|
line_buffer[hex_col + 0] = tohex((value >> 4) & 0xF);
|
|
|
|
line_buffer[hex_col + 1] = tohex((value >> 0) & 0xF);
|
|
|
|
line_buffer[txt_col + 0] = (value >= ' ' && value < 127)
|
|
|
|
? value
|
|
|
|
: '.';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (byte_ofs == 0xF)
|
|
|
|
trace_fn(i & -16, line_buffer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-06-27 19:34:32 +02:00
|
|
|
/* return -1 if error, 0 if OK */
|
2023-03-03 03:57:45 +01:00
|
|
|
int gdb_put_packet_binary(const char *buf, int len, bool dump)
|
2003-06-27 19:34:32 +02:00
|
|
|
{
|
2008-10-11 19:55:29 +02:00
|
|
|
int csum, i;
|
2020-03-16 18:21:53 +01:00
|
|
|
uint8_t footer[3];
|
2003-06-27 19:34:32 +02:00
|
|
|
|
2017-12-03 02:30:37 +01:00
|
|
|
if (dump && trace_event_get_state_backends(TRACE_GDBSTUB_IO_BINARYREPLY)) {
|
|
|
|
hexdump(buf, len, trace_gdbstub_io_binaryreply);
|
|
|
|
}
|
|
|
|
|
2003-06-27 19:34:32 +02:00
|
|
|
for(;;) {
|
2020-03-16 18:21:53 +01:00
|
|
|
g_byte_array_set_size(gdbserver_state.last_packet, 0);
|
|
|
|
g_byte_array_append(gdbserver_state.last_packet,
|
|
|
|
(const uint8_t *) "$", 1);
|
|
|
|
g_byte_array_append(gdbserver_state.last_packet,
|
|
|
|
(const uint8_t *) buf, len);
|
2003-06-27 19:34:32 +02:00
|
|
|
csum = 0;
|
|
|
|
for(i = 0; i < len; i++) {
|
|
|
|
csum += buf[i];
|
|
|
|
}
|
2020-03-16 18:21:53 +01:00
|
|
|
footer[0] = '#';
|
|
|
|
footer[1] = tohex((csum >> 4) & 0xf);
|
|
|
|
footer[2] = tohex((csum) & 0xf);
|
|
|
|
g_byte_array_append(gdbserver_state.last_packet, footer, 3);
|
2003-06-27 19:34:32 +02:00
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_buffer(gdbserver_state.last_packet->data,
|
2020-03-16 18:21:53 +01:00
|
|
|
gdbserver_state.last_packet->len);
|
2003-06-27 19:34:32 +02:00
|
|
|
|
2023-03-03 03:57:49 +01:00
|
|
|
if (gdb_got_immediate_ack()) {
|
2003-06-27 19:34:32 +02:00
|
|
|
break;
|
2023-03-03 03:57:49 +01:00
|
|
|
}
|
2003-06-27 19:34:32 +02:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-11 19:55:29 +02:00
|
|
|
/* return -1 if error, 0 if OK */
|
2023-03-03 03:57:45 +01:00
|
|
|
int gdb_put_packet(const char *buf)
|
2008-10-11 19:55:29 +02:00
|
|
|
{
|
2017-12-03 02:30:37 +01:00
|
|
|
trace_gdbstub_io_reply(buf);
|
2008-05-09 16:40:22 +02:00
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
return gdb_put_packet_binary(buf, strlen(buf), false);
|
2008-10-11 19:55:29 +02:00
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
void gdb_put_strbuf(void)
|
2020-03-16 18:21:35 +01:00
|
|
|
{
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet(gdbserver_state.str_buf->str);
|
2020-03-16 18:21:35 +01:00
|
|
|
}
|
|
|
|
|
2008-10-11 19:55:29 +02:00
|
|
|
/* Encode data using the encoding for 'x' packets. */
|
2023-03-03 03:57:45 +01:00
|
|
|
void gdb_memtox(GString *buf, const char *mem, int len)
|
2008-10-11 19:55:29 +02:00
|
|
|
{
|
|
|
|
char c;
|
|
|
|
|
|
|
|
while (len--) {
|
|
|
|
c = *(mem++);
|
|
|
|
switch (c) {
|
|
|
|
case '#': case '$': case '*': case '}':
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_append_c(buf, '}');
|
|
|
|
g_string_append_c(buf, c ^ 0x20);
|
2008-10-11 19:55:29 +02:00
|
|
|
break;
|
|
|
|
default:
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_append_c(buf, c);
|
2008-10-11 19:55:29 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-10-08 15:16:14 +02:00
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
static uint32_t gdb_get_cpu_pid(CPUState *cpu)
|
2019-01-07 16:23:45 +01:00
|
|
|
{
|
2019-01-29 12:46:06 +01:00
|
|
|
/* TODO: In user mode, we should use the task state PID */
|
|
|
|
if (cpu->cluster_index == UNASSIGNED_CLUSTER_INDEX) {
|
2019-01-07 16:23:45 +01:00
|
|
|
/* Return the default process' PID */
|
2020-03-16 18:21:34 +01:00
|
|
|
int index = gdbserver_state.process_num - 1;
|
|
|
|
return gdbserver_state.processes[index].pid;
|
2019-01-07 16:23:45 +01:00
|
|
|
}
|
2019-01-29 12:46:06 +01:00
|
|
|
return cpu->cluster_index + 1;
|
2019-01-07 16:23:45 +01:00
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
static GDBProcess *gdb_get_process(uint32_t pid)
|
2019-01-07 16:23:45 +01:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!pid) {
|
|
|
|
/* 0 means any process, we take the first one */
|
2020-03-16 18:21:34 +01:00
|
|
|
return &gdbserver_state.processes[0];
|
2019-01-07 16:23:45 +01:00
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
for (i = 0; i < gdbserver_state.process_num; i++) {
|
|
|
|
if (gdbserver_state.processes[i].pid == pid) {
|
|
|
|
return &gdbserver_state.processes[i];
|
2019-01-07 16:23:45 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
static GDBProcess *gdb_get_cpu_process(CPUState *cpu)
|
2019-01-07 16:23:45 +01:00
|
|
|
{
|
2020-03-16 18:21:34 +01:00
|
|
|
return gdb_get_process(gdb_get_cpu_pid(cpu));
|
2019-01-07 16:23:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static CPUState *find_cpu(uint32_t thread_id)
|
|
|
|
{
|
|
|
|
CPUState *cpu;
|
|
|
|
|
|
|
|
CPU_FOREACH(cpu) {
|
2023-03-03 03:57:45 +01:00
|
|
|
if (gdb_get_cpu_index(cpu) == thread_id) {
|
2019-01-07 16:23:45 +01:00
|
|
|
return cpu;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
static CPUState *get_first_cpu_in_process(GDBProcess *process)
|
2019-01-07 16:23:46 +01:00
|
|
|
{
|
|
|
|
CPUState *cpu;
|
|
|
|
|
|
|
|
CPU_FOREACH(cpu) {
|
2020-03-16 18:21:34 +01:00
|
|
|
if (gdb_get_cpu_pid(cpu) == process->pid) {
|
2019-01-07 16:23:46 +01:00
|
|
|
return cpu;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
static CPUState *gdb_next_cpu_in_process(CPUState *cpu)
|
2019-01-07 16:23:46 +01:00
|
|
|
{
|
2020-03-16 18:21:34 +01:00
|
|
|
uint32_t pid = gdb_get_cpu_pid(cpu);
|
2019-01-07 16:23:46 +01:00
|
|
|
cpu = CPU_NEXT(cpu);
|
|
|
|
|
|
|
|
while (cpu) {
|
2020-03-16 18:21:34 +01:00
|
|
|
if (gdb_get_cpu_pid(cpu) == pid) {
|
2019-01-07 16:23:46 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
cpu = CPU_NEXT(cpu);
|
|
|
|
}
|
|
|
|
|
|
|
|
return cpu;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the cpu following @cpu, while ignoring unattached processes. */
|
2020-03-16 18:21:34 +01:00
|
|
|
static CPUState *gdb_next_attached_cpu(CPUState *cpu)
|
2019-01-07 16:23:46 +01:00
|
|
|
{
|
|
|
|
cpu = CPU_NEXT(cpu);
|
|
|
|
|
|
|
|
while (cpu) {
|
2020-03-16 18:21:34 +01:00
|
|
|
if (gdb_get_cpu_process(cpu)->attached) {
|
2019-01-07 16:23:46 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
cpu = CPU_NEXT(cpu);
|
|
|
|
}
|
|
|
|
|
|
|
|
return cpu;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the first attached cpu */
|
2023-03-03 03:57:45 +01:00
|
|
|
CPUState *gdb_first_attached_cpu(void)
|
2019-01-07 16:23:46 +01:00
|
|
|
{
|
|
|
|
CPUState *cpu = first_cpu;
|
2020-03-16 18:21:34 +01:00
|
|
|
GDBProcess *process = gdb_get_cpu_process(cpu);
|
2019-01-07 16:23:46 +01:00
|
|
|
|
|
|
|
if (!process->attached) {
|
2020-03-16 18:21:34 +01:00
|
|
|
return gdb_next_attached_cpu(cpu);
|
2019-01-07 16:23:46 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return cpu;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
static CPUState *gdb_get_cpu(uint32_t pid, uint32_t tid)
|
2019-01-29 12:46:03 +01:00
|
|
|
{
|
|
|
|
GDBProcess *process;
|
|
|
|
CPUState *cpu;
|
|
|
|
|
|
|
|
if (!pid && !tid) {
|
|
|
|
/* 0 means any process/thread, we take the first attached one */
|
2020-03-16 18:21:34 +01:00
|
|
|
return gdb_first_attached_cpu();
|
2019-01-29 12:46:03 +01:00
|
|
|
} else if (pid && !tid) {
|
|
|
|
/* any thread in a specific process */
|
2020-03-16 18:21:34 +01:00
|
|
|
process = gdb_get_process(pid);
|
2019-01-29 12:46:03 +01:00
|
|
|
|
|
|
|
if (process == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!process->attached) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
return get_first_cpu_in_process(process);
|
2019-01-29 12:46:03 +01:00
|
|
|
} else {
|
|
|
|
/* a specific thread */
|
|
|
|
cpu = find_cpu(tid);
|
|
|
|
|
|
|
|
if (cpu == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
process = gdb_get_cpu_process(cpu);
|
2019-01-29 12:46:03 +01:00
|
|
|
|
|
|
|
if (pid && process->pid != pid) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!process->attached) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cpu;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
static const char *get_feature_xml(const char *p, const char **newp,
|
|
|
|
GDBProcess *process)
|
2008-10-11 19:55:29 +02:00
|
|
|
{
|
|
|
|
size_t len;
|
|
|
|
int i;
|
|
|
|
const char *name;
|
2020-03-16 18:21:34 +01:00
|
|
|
CPUState *cpu = get_first_cpu_in_process(process);
|
2019-01-07 16:23:46 +01:00
|
|
|
CPUClass *cc = CPU_GET_CLASS(cpu);
|
2008-10-11 19:55:29 +02:00
|
|
|
|
|
|
|
len = 0;
|
|
|
|
while (p[len] && p[len] != ':')
|
|
|
|
len++;
|
|
|
|
*newp = p + len;
|
|
|
|
|
|
|
|
name = NULL;
|
|
|
|
if (strncmp(p, "target.xml", len) == 0) {
|
2019-01-07 16:23:46 +01:00
|
|
|
char *buf = process->target_xml;
|
|
|
|
const size_t buf_sz = sizeof(process->target_xml);
|
|
|
|
|
2008-10-11 19:55:29 +02:00
|
|
|
/* Generate the XML description for this CPU. */
|
2019-01-07 16:23:46 +01:00
|
|
|
if (!buf[0]) {
|
2008-10-11 19:55:29 +02:00
|
|
|
GDBRegisterState *r;
|
|
|
|
|
2019-01-07 16:23:46 +01:00
|
|
|
pstrcat(buf, buf_sz,
|
2015-12-03 13:14:41 +01:00
|
|
|
"<?xml version=\"1.0\"?>"
|
|
|
|
"<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
|
|
|
|
"<target>");
|
|
|
|
if (cc->gdb_arch_name) {
|
|
|
|
gchar *arch = cc->gdb_arch_name(cpu);
|
2019-01-07 16:23:46 +01:00
|
|
|
pstrcat(buf, buf_sz, "<architecture>");
|
|
|
|
pstrcat(buf, buf_sz, arch);
|
|
|
|
pstrcat(buf, buf_sz, "</architecture>");
|
2015-12-03 13:14:41 +01:00
|
|
|
g_free(arch);
|
|
|
|
}
|
2019-01-07 16:23:46 +01:00
|
|
|
pstrcat(buf, buf_sz, "<xi:include href=\"");
|
|
|
|
pstrcat(buf, buf_sz, cc->gdb_core_xml_file);
|
|
|
|
pstrcat(buf, buf_sz, "\"/>");
|
2013-06-28 21:11:37 +02:00
|
|
|
for (r = cpu->gdb_regs; r; r = r->next) {
|
2019-01-07 16:23:46 +01:00
|
|
|
pstrcat(buf, buf_sz, "<xi:include href=\"");
|
|
|
|
pstrcat(buf, buf_sz, r->xml);
|
|
|
|
pstrcat(buf, buf_sz, "\"/>");
|
2008-10-11 19:55:29 +02:00
|
|
|
}
|
2019-01-07 16:23:46 +01:00
|
|
|
pstrcat(buf, buf_sz, "</target>");
|
2008-10-11 19:55:29 +02:00
|
|
|
}
|
2019-01-07 16:23:46 +01:00
|
|
|
return buf;
|
2008-10-11 19:55:29 +02:00
|
|
|
}
|
2018-05-18 18:48:07 +02:00
|
|
|
if (cc->gdb_get_dynamic_xml) {
|
|
|
|
char *xmlname = g_strndup(p, len);
|
|
|
|
const char *xml = cc->gdb_get_dynamic_xml(cpu, xmlname);
|
|
|
|
|
|
|
|
g_free(xmlname);
|
|
|
|
if (xml) {
|
|
|
|
return xml;
|
|
|
|
}
|
|
|
|
}
|
2008-10-11 19:55:29 +02:00
|
|
|
for (i = 0; ; i++) {
|
|
|
|
name = xml_builtin[i][0];
|
|
|
|
if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return name ? xml_builtin[i][1] : NULL;
|
|
|
|
}
|
2007-10-08 15:16:14 +02:00
|
|
|
|
2020-03-16 18:21:41 +01:00
|
|
|
static int gdb_read_register(CPUState *cpu, GByteArray *buf, int reg)
|
2008-10-11 19:55:29 +02:00
|
|
|
{
|
2013-06-28 23:18:47 +02:00
|
|
|
CPUClass *cc = CPU_GET_CLASS(cpu);
|
2013-06-27 18:25:36 +02:00
|
|
|
CPUArchState *env = cpu->env_ptr;
|
2008-10-11 19:55:29 +02:00
|
|
|
GDBRegisterState *r;
|
2007-10-08 15:16:14 +02:00
|
|
|
|
2013-06-28 23:18:47 +02:00
|
|
|
if (reg < cc->gdb_num_core_regs) {
|
2020-03-16 18:21:41 +01:00
|
|
|
return cc->gdb_read_register(cpu, buf, reg);
|
2013-06-28 23:18:47 +02:00
|
|
|
}
|
2007-10-08 15:16:14 +02:00
|
|
|
|
2013-06-28 21:11:37 +02:00
|
|
|
for (r = cpu->gdb_regs; r; r = r->next) {
|
2008-10-11 19:55:29 +02:00
|
|
|
if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
|
2020-03-16 18:21:41 +01:00
|
|
|
return r->get_reg(env, buf, reg - r->base_reg);
|
2008-10-11 19:55:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
2007-10-08 15:16:14 +02:00
|
|
|
}
|
|
|
|
|
2013-06-27 18:25:36 +02:00
|
|
|
static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
|
2007-10-08 15:16:14 +02:00
|
|
|
{
|
2013-06-28 23:18:47 +02:00
|
|
|
CPUClass *cc = CPU_GET_CLASS(cpu);
|
2013-06-27 18:25:36 +02:00
|
|
|
CPUArchState *env = cpu->env_ptr;
|
2008-10-11 19:55:29 +02:00
|
|
|
GDBRegisterState *r;
|
2007-10-08 15:16:14 +02:00
|
|
|
|
2013-06-28 23:18:47 +02:00
|
|
|
if (reg < cc->gdb_num_core_regs) {
|
2013-06-29 04:18:45 +02:00
|
|
|
return cc->gdb_write_register(cpu, mem_buf, reg);
|
2013-06-28 23:18:47 +02:00
|
|
|
}
|
2008-10-11 19:55:29 +02:00
|
|
|
|
2013-06-28 21:11:37 +02:00
|
|
|
for (r = cpu->gdb_regs; r; r = r->next) {
|
2008-10-11 19:55:29 +02:00
|
|
|
if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
|
|
|
|
return r->set_reg(env, mem_buf, reg - r->base_reg);
|
|
|
|
}
|
|
|
|
}
|
2004-01-04 16:48:38 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-11 19:55:29 +02:00
|
|
|
/* Register a supplemental set of CPU registers. If g_pos is nonzero it
|
|
|
|
specifies the first register number and these registers are included in
|
|
|
|
a standard "g" packet. Direction is relative to gdb, i.e. get_reg is
|
|
|
|
gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
|
|
|
|
*/
|
|
|
|
|
2013-06-28 21:27:39 +02:00
|
|
|
void gdb_register_coprocessor(CPUState *cpu,
|
2020-03-16 18:21:41 +01:00
|
|
|
gdb_get_reg_cb get_reg, gdb_set_reg_cb set_reg,
|
2013-06-28 21:27:39 +02:00
|
|
|
int num_regs, const char *xml, int g_pos)
|
2004-01-04 16:48:38 +01:00
|
|
|
{
|
2008-10-11 19:55:29 +02:00
|
|
|
GDBRegisterState *s;
|
|
|
|
GDBRegisterState **p;
|
|
|
|
|
2013-06-28 21:11:37 +02:00
|
|
|
p = &cpu->gdb_regs;
|
2008-10-11 19:55:29 +02:00
|
|
|
while (*p) {
|
|
|
|
/* Check for duplicates. */
|
|
|
|
if (strcmp((*p)->xml, xml) == 0)
|
|
|
|
return;
|
|
|
|
p = &(*p)->next;
|
|
|
|
}
|
2011-10-18 22:25:38 +02:00
|
|
|
|
|
|
|
s = g_new0(GDBRegisterState, 1);
|
2013-06-28 23:18:47 +02:00
|
|
|
s->base_reg = cpu->gdb_num_regs;
|
2011-10-18 22:25:38 +02:00
|
|
|
s->num_regs = num_regs;
|
|
|
|
s->get_reg = get_reg;
|
|
|
|
s->set_reg = set_reg;
|
|
|
|
s->xml = xml;
|
|
|
|
|
2008-10-11 19:55:29 +02:00
|
|
|
/* Add to end of list. */
|
2013-06-28 23:18:47 +02:00
|
|
|
cpu->gdb_num_regs += num_regs;
|
2008-10-11 19:55:29 +02:00
|
|
|
*p = s;
|
|
|
|
if (g_pos) {
|
|
|
|
if (g_pos != s->base_reg) {
|
2017-01-18 09:03:29 +01:00
|
|
|
error_report("Error: Bad gdb register numbering for '%s', "
|
|
|
|
"expected %d got %d", xml, g_pos, s->base_reg);
|
2013-08-12 18:09:47 +02:00
|
|
|
} else {
|
|
|
|
cpu->gdb_num_g_regs = cpu->gdb_num_regs;
|
2008-10-11 19:55:29 +02:00
|
|
|
}
|
|
|
|
}
|
2004-01-04 16:48:38 +01:00
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
static void gdb_process_breakpoint_remove_all(GDBProcess *p)
|
2019-01-07 16:23:46 +01:00
|
|
|
{
|
2020-03-16 18:21:34 +01:00
|
|
|
CPUState *cpu = get_first_cpu_in_process(p);
|
2019-01-07 16:23:46 +01:00
|
|
|
|
|
|
|
while (cpu) {
|
2022-09-29 13:42:24 +02:00
|
|
|
gdb_breakpoint_remove_all(cpu);
|
2020-03-16 18:21:34 +01:00
|
|
|
cpu = gdb_next_cpu_in_process(cpu);
|
2019-01-07 16:23:46 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-18 21:07:32 +01:00
|
|
|
|
2023-03-03 03:57:54 +01:00
|
|
|
static void gdb_set_cpu_pc(vaddr pc)
|
2009-04-08 23:29:37 +02:00
|
|
|
{
|
2020-03-16 18:21:34 +01:00
|
|
|
CPUState *cpu = gdbserver_state.c_cpu;
|
2013-06-21 19:09:18 +02:00
|
|
|
|
|
|
|
cpu_synchronize_state(cpu);
|
2015-06-24 05:19:21 +02:00
|
|
|
cpu_set_pc(cpu, pc);
|
2009-04-08 23:29:37 +02:00
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
void gdb_append_thread_id(CPUState *cpu, GString *buf)
|
2019-01-07 16:23:45 +01:00
|
|
|
{
|
2020-03-16 18:21:34 +01:00
|
|
|
if (gdbserver_state.multiprocess) {
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_append_printf(buf, "p%02x.%02x",
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_get_cpu_pid(cpu), gdb_get_cpu_index(cpu));
|
2019-01-07 16:23:45 +01:00
|
|
|
} else {
|
2023-03-03 03:57:45 +01:00
|
|
|
g_string_append_printf(buf, "%02x", gdb_get_cpu_index(cpu));
|
2019-01-07 16:23:45 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-07 16:23:45 +01:00
|
|
|
static GDBThreadIdKind read_thread_id(const char *buf, const char **end_buf,
|
|
|
|
uint32_t *pid, uint32_t *tid)
|
|
|
|
{
|
|
|
|
unsigned long p, t;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (*buf == 'p') {
|
|
|
|
buf++;
|
|
|
|
ret = qemu_strtoul(buf, &buf, 16, &p);
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
return GDB_READ_THREAD_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Skip '.' */
|
|
|
|
buf++;
|
|
|
|
} else {
|
|
|
|
p = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = qemu_strtoul(buf, &buf, 16, &t);
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
return GDB_READ_THREAD_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
*end_buf = buf;
|
|
|
|
|
|
|
|
if (p == -1) {
|
|
|
|
return GDB_ALL_PROCESSES;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pid) {
|
|
|
|
*pid = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (t == -1) {
|
|
|
|
return GDB_ALL_THREADS;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tid) {
|
|
|
|
*tid = t;
|
|
|
|
}
|
|
|
|
|
|
|
|
return GDB_ONE_THREAD;
|
|
|
|
}
|
|
|
|
|
2017-02-14 18:07:48 +01:00
|
|
|
/**
|
|
|
|
* gdb_handle_vcont - Parses and handles a vCont packet.
|
|
|
|
* returns -ENOTSUP if a command is unsupported, -EINVAL or -ERANGE if there is
|
|
|
|
* a format error, 0 on success.
|
|
|
|
*/
|
2020-03-16 18:21:34 +01:00
|
|
|
static int gdb_handle_vcont(const char *p)
|
2017-02-14 18:07:48 +01:00
|
|
|
{
|
2019-01-07 16:23:46 +01:00
|
|
|
int res, signal = 0;
|
2017-02-14 18:07:48 +01:00
|
|
|
char cur_action;
|
|
|
|
char *newstates;
|
|
|
|
unsigned long tmp;
|
2019-01-07 16:23:46 +01:00
|
|
|
uint32_t pid, tid;
|
|
|
|
GDBProcess *process;
|
2017-02-14 18:07:48 +01:00
|
|
|
CPUState *cpu;
|
2019-03-26 13:53:26 +01:00
|
|
|
GDBThreadIdKind kind;
|
2023-03-03 03:57:52 +01:00
|
|
|
unsigned int max_cpus = gdb_get_max_cpus();
|
2017-02-14 18:07:48 +01:00
|
|
|
/* uninitialised CPUs stay 0 */
|
|
|
|
newstates = g_new0(char, max_cpus);
|
|
|
|
|
|
|
|
/* mark valid CPUs with 1 */
|
|
|
|
CPU_FOREACH(cpu) {
|
|
|
|
newstates[cpu->cpu_index] = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* res keeps track of what error we are returning, with -ENOTSUP meaning
|
|
|
|
* that the command is unknown or unsupported, thus returning an empty
|
|
|
|
* packet, while -EINVAL and -ERANGE cause an E22 packet, due to invalid,
|
|
|
|
* or incorrect parameters passed.
|
|
|
|
*/
|
|
|
|
res = 0;
|
|
|
|
while (*p) {
|
|
|
|
if (*p++ != ';') {
|
|
|
|
res = -ENOTSUP;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
cur_action = *p++;
|
|
|
|
if (cur_action == 'C' || cur_action == 'S') {
|
2017-07-20 18:31:30 +02:00
|
|
|
cur_action = qemu_tolower(cur_action);
|
2020-11-21 22:03:42 +01:00
|
|
|
res = qemu_strtoul(p, &p, 16, &tmp);
|
2017-02-14 18:07:48 +01:00
|
|
|
if (res) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
signal = gdb_signal_to_target(tmp);
|
|
|
|
} else if (cur_action != 'c' && cur_action != 's') {
|
|
|
|
/* unknown/invalid/unsupported command */
|
|
|
|
res = -ENOTSUP;
|
|
|
|
goto out;
|
|
|
|
}
|
2019-01-07 16:23:46 +01:00
|
|
|
|
2019-03-26 13:53:26 +01:00
|
|
|
if (*p == '\0' || *p == ';') {
|
|
|
|
/*
|
|
|
|
* No thread specifier, action is on "all threads". The
|
|
|
|
* specification is unclear regarding the process to act on. We
|
|
|
|
* choose all processes.
|
|
|
|
*/
|
|
|
|
kind = GDB_ALL_PROCESSES;
|
|
|
|
} else if (*p++ == ':') {
|
|
|
|
kind = read_thread_id(p, &p, &pid, &tid);
|
|
|
|
} else {
|
2019-01-07 16:23:46 +01:00
|
|
|
res = -ENOTSUP;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2019-03-26 13:53:26 +01:00
|
|
|
switch (kind) {
|
2019-01-07 16:23:46 +01:00
|
|
|
case GDB_READ_THREAD_ERR:
|
|
|
|
res = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
case GDB_ALL_PROCESSES:
|
2020-03-16 18:21:34 +01:00
|
|
|
cpu = gdb_first_attached_cpu();
|
2019-01-07 16:23:46 +01:00
|
|
|
while (cpu) {
|
|
|
|
if (newstates[cpu->cpu_index] == 1) {
|
|
|
|
newstates[cpu->cpu_index] = cur_action;
|
2017-02-14 18:07:48 +01:00
|
|
|
}
|
2019-01-07 16:23:46 +01:00
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
cpu = gdb_next_attached_cpu(cpu);
|
2017-02-14 18:07:48 +01:00
|
|
|
}
|
2019-01-07 16:23:46 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case GDB_ALL_THREADS:
|
2020-03-16 18:21:34 +01:00
|
|
|
process = gdb_get_process(pid);
|
2019-01-07 16:23:46 +01:00
|
|
|
|
|
|
|
if (!process->attached) {
|
|
|
|
res = -EINVAL;
|
2017-02-14 18:07:48 +01:00
|
|
|
goto out;
|
|
|
|
}
|
2017-07-12 12:52:16 +02:00
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
cpu = get_first_cpu_in_process(process);
|
2019-01-07 16:23:46 +01:00
|
|
|
while (cpu) {
|
|
|
|
if (newstates[cpu->cpu_index] == 1) {
|
|
|
|
newstates[cpu->cpu_index] = cur_action;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
cpu = gdb_next_cpu_in_process(cpu);
|
2019-01-07 16:23:46 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDB_ONE_THREAD:
|
2020-03-16 18:21:34 +01:00
|
|
|
cpu = gdb_get_cpu(pid, tid);
|
2017-02-14 18:07:48 +01:00
|
|
|
|
|
|
|
/* invalid CPU/thread specified */
|
2017-07-12 12:52:16 +02:00
|
|
|
if (!cpu) {
|
2017-02-14 18:07:48 +01:00
|
|
|
res = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2017-07-12 12:52:16 +02:00
|
|
|
|
2017-02-14 18:07:48 +01:00
|
|
|
/* only use if no previous match occourred */
|
|
|
|
if (newstates[cpu->cpu_index] == 1) {
|
|
|
|
newstates[cpu->cpu_index] = cur_action;
|
|
|
|
}
|
2019-01-07 16:23:46 +01:00
|
|
|
break;
|
2017-02-14 18:07:48 +01:00
|
|
|
}
|
|
|
|
}
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.signal = signal;
|
|
|
|
gdb_continue_partial(newstates);
|
2017-02-14 18:07:48 +01:00
|
|
|
|
|
|
|
out:
|
|
|
|
g_free(newstates);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2019-05-29 08:41:29 +02:00
|
|
|
static const char *cmd_next_param(const char *param, const char delimiter)
|
|
|
|
{
|
|
|
|
static const char all_delimiters[] = ",;:=";
|
|
|
|
char curr_delimiters[2] = {0};
|
|
|
|
const char *delimiters;
|
|
|
|
|
|
|
|
if (delimiter == '?') {
|
|
|
|
delimiters = all_delimiters;
|
|
|
|
} else if (delimiter == '0') {
|
|
|
|
return strchr(param, '\0');
|
|
|
|
} else if (delimiter == '.' && *param) {
|
|
|
|
return param + 1;
|
|
|
|
} else {
|
|
|
|
curr_delimiters[0] = delimiter;
|
|
|
|
delimiters = curr_delimiters;
|
|
|
|
}
|
|
|
|
|
|
|
|
param += strcspn(param, delimiters);
|
|
|
|
if (*param) {
|
|
|
|
param++;
|
|
|
|
}
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cmd_parse_params(const char *data, const char *schema,
|
2021-05-25 10:24:14 +02:00
|
|
|
GArray *params)
|
2019-05-29 08:41:29 +02:00
|
|
|
{
|
|
|
|
const char *curr_schema, *curr_data;
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
g_assert(schema);
|
|
|
|
g_assert(params->len == 0);
|
2019-05-29 08:41:29 +02:00
|
|
|
|
|
|
|
curr_schema = schema;
|
|
|
|
curr_data = data;
|
|
|
|
while (curr_schema[0] && curr_schema[1] && *curr_data) {
|
2021-05-25 10:24:14 +02:00
|
|
|
GdbCmdVariant this_param;
|
|
|
|
|
2019-05-29 08:41:29 +02:00
|
|
|
switch (curr_schema[0]) {
|
|
|
|
case 'l':
|
|
|
|
if (qemu_strtoul(curr_data, &curr_data, 16,
|
2021-05-25 10:24:14 +02:00
|
|
|
&this_param.val_ul)) {
|
2019-05-29 08:41:29 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
curr_data = cmd_next_param(curr_data, curr_schema[1]);
|
2021-05-25 10:24:14 +02:00
|
|
|
g_array_append_val(params, this_param);
|
2019-05-29 08:41:29 +02:00
|
|
|
break;
|
|
|
|
case 'L':
|
|
|
|
if (qemu_strtou64(curr_data, &curr_data, 16,
|
2021-05-25 10:24:14 +02:00
|
|
|
(uint64_t *)&this_param.val_ull)) {
|
2019-05-29 08:41:29 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
curr_data = cmd_next_param(curr_data, curr_schema[1]);
|
2021-05-25 10:24:14 +02:00
|
|
|
g_array_append_val(params, this_param);
|
2019-05-29 08:41:29 +02:00
|
|
|
break;
|
|
|
|
case 's':
|
2021-05-25 10:24:14 +02:00
|
|
|
this_param.data = curr_data;
|
2019-05-29 08:41:29 +02:00
|
|
|
curr_data = cmd_next_param(curr_data, curr_schema[1]);
|
2021-05-25 10:24:14 +02:00
|
|
|
g_array_append_val(params, this_param);
|
2019-05-29 08:41:29 +02:00
|
|
|
break;
|
|
|
|
case 'o':
|
2021-05-25 10:24:14 +02:00
|
|
|
this_param.opcode = *(uint8_t *)curr_data;
|
2019-05-29 08:41:29 +02:00
|
|
|
curr_data = cmd_next_param(curr_data, curr_schema[1]);
|
2021-05-25 10:24:14 +02:00
|
|
|
g_array_append_val(params, this_param);
|
2019-05-29 08:41:29 +02:00
|
|
|
break;
|
|
|
|
case 't':
|
2021-05-25 10:24:14 +02:00
|
|
|
this_param.thread_id.kind =
|
2019-05-29 08:41:29 +02:00
|
|
|
read_thread_id(curr_data, &curr_data,
|
2021-05-25 10:24:14 +02:00
|
|
|
&this_param.thread_id.pid,
|
|
|
|
&this_param.thread_id.tid);
|
2019-05-29 08:41:29 +02:00
|
|
|
curr_data = cmd_next_param(curr_data, curr_schema[1]);
|
2021-05-25 10:24:14 +02:00
|
|
|
g_array_append_val(params, this_param);
|
2019-05-29 08:41:29 +02:00
|
|
|
break;
|
|
|
|
case '?':
|
|
|
|
curr_data = cmd_next_param(curr_data, curr_schema[1]);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
curr_schema += 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
typedef void (*GdbCmdHandler)(GArray *params, void *user_ctx);
|
2019-05-29 08:41:29 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* cmd_startswith -> cmd is compared using startswith
|
|
|
|
*
|
2023-05-04 17:37:31 +02:00
|
|
|
* allow_stop_reply -> true iff the gdbstub can respond to this command with a
|
|
|
|
* "stop reply" packet. The list of commands that accept such response is
|
|
|
|
* defined at the GDB Remote Serial Protocol documentation. see:
|
|
|
|
* https://sourceware.org/gdb/onlinedocs/gdb/Stop-Reply-Packets.html#Stop-Reply-Packets.
|
2019-05-29 08:41:29 +02:00
|
|
|
*
|
|
|
|
* schema definitions:
|
|
|
|
* Each schema parameter entry consists of 2 chars,
|
|
|
|
* the first char represents the parameter type handling
|
|
|
|
* the second char represents the delimiter for the next parameter
|
|
|
|
*
|
|
|
|
* Currently supported schema types:
|
|
|
|
* 'l' -> unsigned long (stored in .val_ul)
|
|
|
|
* 'L' -> unsigned long long (stored in .val_ull)
|
|
|
|
* 's' -> string (stored in .data)
|
|
|
|
* 'o' -> single char (stored in .opcode)
|
|
|
|
* 't' -> thread id (stored in .thread_id)
|
|
|
|
* '?' -> skip according to delimiter
|
|
|
|
*
|
|
|
|
* Currently supported delimiters:
|
|
|
|
* '?' -> Stop at any delimiter (",;:=\0")
|
|
|
|
* '0' -> Stop at "\0"
|
|
|
|
* '.' -> Skip 1 char unless reached "\0"
|
|
|
|
* Any other value is treated as the delimiter value itself
|
|
|
|
*/
|
|
|
|
typedef struct GdbCmdParseEntry {
|
|
|
|
GdbCmdHandler handler;
|
|
|
|
const char *cmd;
|
|
|
|
bool cmd_startswith;
|
|
|
|
const char *schema;
|
2023-05-04 17:37:31 +02:00
|
|
|
bool allow_stop_reply;
|
2019-05-29 08:41:29 +02:00
|
|
|
} GdbCmdParseEntry;
|
|
|
|
|
|
|
|
static inline int startswith(const char *string, const char *pattern)
|
|
|
|
{
|
|
|
|
return !strncmp(string, pattern, strlen(pattern));
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
static int process_string_cmd(void *user_ctx, const char *data,
|
2019-05-29 08:41:29 +02:00
|
|
|
const GdbCmdParseEntry *cmds, int num_cmds)
|
|
|
|
{
|
2021-05-25 10:24:14 +02:00
|
|
|
int i;
|
|
|
|
g_autoptr(GArray) params = g_array_new(false, true, sizeof(GdbCmdVariant));
|
2019-05-29 08:41:29 +02:00
|
|
|
|
|
|
|
if (!cmds) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < num_cmds; i++) {
|
|
|
|
const GdbCmdParseEntry *cmd = &cmds[i];
|
|
|
|
g_assert(cmd->handler && cmd->cmd);
|
|
|
|
|
|
|
|
if ((cmd->cmd_startswith && !startswith(data, cmd->cmd)) ||
|
|
|
|
(!cmd->cmd_startswith && strcmp(cmd->cmd, data))) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cmd->schema) {
|
2021-05-25 10:24:14 +02:00
|
|
|
if (cmd_parse_params(&data[strlen(cmd->cmd)],
|
|
|
|
cmd->schema, params)) {
|
|
|
|
return -1;
|
2019-05-29 08:41:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-05-04 17:37:31 +02:00
|
|
|
gdbserver_state.allow_stop_reply = cmd->allow_stop_reply;
|
2021-05-25 10:24:14 +02:00
|
|
|
cmd->handler(params, user_ctx);
|
2019-05-29 08:41:29 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
static void run_cmd_parser(const char *data, const GdbCmdParseEntry *cmd)
|
2019-05-29 08:41:30 +02:00
|
|
|
{
|
|
|
|
if (!data) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_set_size(gdbserver_state.str_buf, 0);
|
2020-03-16 18:21:36 +01:00
|
|
|
g_byte_array_set_size(gdbserver_state.mem_buf, 0);
|
2020-03-16 18:21:35 +01:00
|
|
|
|
2019-05-29 08:41:30 +02:00
|
|
|
/* In case there was an error during the command parsing we must
|
|
|
|
* send a NULL packet to indicate the command is not supported */
|
2020-03-16 18:21:34 +01:00
|
|
|
if (process_string_cmd(NULL, data, cmd, 1)) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("");
|
2019-05-29 08:41:30 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_detach(GArray *params, void *user_ctx)
|
2019-05-29 08:41:30 +02:00
|
|
|
{
|
|
|
|
GDBProcess *process;
|
|
|
|
uint32_t pid = 1;
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
if (gdbserver_state.multiprocess) {
|
2021-05-25 10:24:14 +02:00
|
|
|
if (!params->len) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:30 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
pid = get_param(params, 0)->val_ul;
|
2019-05-29 08:41:30 +02:00
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
process = gdb_get_process(pid);
|
|
|
|
gdb_process_breakpoint_remove_all(process);
|
2019-05-29 08:41:30 +02:00
|
|
|
process->attached = false;
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
if (pid == gdb_get_cpu_pid(gdbserver_state.c_cpu)) {
|
|
|
|
gdbserver_state.c_cpu = gdb_first_attached_cpu();
|
2019-05-29 08:41:30 +02:00
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
if (pid == gdb_get_cpu_pid(gdbserver_state.g_cpu)) {
|
|
|
|
gdbserver_state.g_cpu = gdb_first_attached_cpu();
|
2019-05-29 08:41:30 +02:00
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
if (!gdbserver_state.c_cpu) {
|
2019-05-29 08:41:30 +02:00
|
|
|
/* No more process attached */
|
2023-03-03 03:57:57 +01:00
|
|
|
gdb_disable_syscalls();
|
2020-03-16 18:21:34 +01:00
|
|
|
gdb_continue();
|
2019-05-29 08:41:30 +02:00
|
|
|
}
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("OK");
|
2019-05-29 08:41:30 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_thread_alive(GArray *params, void *user_ctx)
|
2019-05-29 08:41:31 +02:00
|
|
|
{
|
|
|
|
CPUState *cpu;
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (!params->len) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:31 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (get_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:31 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
cpu = gdb_get_cpu(get_param(params, 0)->thread_id.pid,
|
|
|
|
get_param(params, 0)->thread_id.tid);
|
2019-05-29 08:41:31 +02:00
|
|
|
if (!cpu) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:31 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("OK");
|
2019-05-29 08:41:31 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_continue(GArray *params, void *user_ctx)
|
2019-05-29 08:41:32 +02:00
|
|
|
{
|
2021-05-25 10:24:14 +02:00
|
|
|
if (params->len) {
|
|
|
|
gdb_set_cpu_pc(get_param(params, 0)->val_ull);
|
2019-05-29 08:41:32 +02:00
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.signal = 0;
|
|
|
|
gdb_continue();
|
2019-05-29 08:41:32 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_cont_with_sig(GArray *params, void *user_ctx)
|
2019-05-29 08:41:33 +02:00
|
|
|
{
|
|
|
|
unsigned long signal = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: C sig;[addr] is currently unsupported and we simply
|
|
|
|
* omit the addr parameter
|
|
|
|
*/
|
2021-05-25 10:24:14 +02:00
|
|
|
if (params->len) {
|
|
|
|
signal = get_param(params, 0)->val_ul;
|
2019-05-29 08:41:33 +02:00
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.signal = gdb_signal_to_target(signal);
|
|
|
|
if (gdbserver_state.signal == -1) {
|
|
|
|
gdbserver_state.signal = 0;
|
2019-05-29 08:41:33 +02:00
|
|
|
}
|
2020-03-16 18:21:34 +01:00
|
|
|
gdb_continue();
|
2019-05-29 08:41:33 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_set_thread(GArray *params, void *user_ctx)
|
2019-05-29 08:41:34 +02:00
|
|
|
{
|
|
|
|
CPUState *cpu;
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (params->len != 2) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:34 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (get_param(params, 1)->thread_id.kind == GDB_READ_THREAD_ERR) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:34 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (get_param(params, 1)->thread_id.kind != GDB_ONE_THREAD) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("OK");
|
2019-05-29 08:41:34 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
cpu = gdb_get_cpu(get_param(params, 1)->thread_id.pid,
|
|
|
|
get_param(params, 1)->thread_id.tid);
|
2019-05-29 08:41:34 +02:00
|
|
|
if (!cpu) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:34 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: This command is deprecated and modern gdb's will be using the
|
|
|
|
* vCont command instead.
|
|
|
|
*/
|
2021-05-25 10:24:14 +02:00
|
|
|
switch (get_param(params, 0)->opcode) {
|
2019-05-29 08:41:34 +02:00
|
|
|
case 'c':
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.c_cpu = cpu;
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("OK");
|
2019-05-29 08:41:34 +02:00
|
|
|
break;
|
|
|
|
case 'g':
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.g_cpu = cpu;
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("OK");
|
2019-05-29 08:41:34 +02:00
|
|
|
break;
|
|
|
|
default:
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:34 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_insert_bp(GArray *params, void *user_ctx)
|
2019-05-29 08:41:35 +02:00
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (params->len != 3) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:35 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-09-29 13:42:24 +02:00
|
|
|
res = gdb_breakpoint_insert(gdbserver_state.c_cpu,
|
|
|
|
get_param(params, 0)->val_ul,
|
2021-05-25 10:24:14 +02:00
|
|
|
get_param(params, 1)->val_ull,
|
|
|
|
get_param(params, 2)->val_ull);
|
2019-05-29 08:41:35 +02:00
|
|
|
if (res >= 0) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("OK");
|
2019-05-29 08:41:35 +02:00
|
|
|
return;
|
|
|
|
} else if (res == -ENOSYS) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("");
|
2019-05-29 08:41:35 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:35 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_remove_bp(GArray *params, void *user_ctx)
|
2019-05-29 08:41:35 +02:00
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (params->len != 3) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:35 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-09-29 13:42:24 +02:00
|
|
|
res = gdb_breakpoint_remove(gdbserver_state.c_cpu,
|
|
|
|
get_param(params, 0)->val_ul,
|
2021-05-25 10:24:14 +02:00
|
|
|
get_param(params, 1)->val_ull,
|
|
|
|
get_param(params, 2)->val_ull);
|
2019-05-29 08:41:35 +02:00
|
|
|
if (res >= 0) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("OK");
|
2019-05-29 08:41:35 +02:00
|
|
|
return;
|
|
|
|
} else if (res == -ENOSYS) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("");
|
2019-05-29 08:41:35 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:35 +02:00
|
|
|
}
|
|
|
|
|
2019-07-05 15:23:07 +02:00
|
|
|
/*
|
|
|
|
* handle_set/get_reg
|
|
|
|
*
|
|
|
|
* Older gdb are really dumb, and don't use 'G/g' if 'P/p' is available.
|
|
|
|
* This works, but can be very slow. Anything new enough to understand
|
|
|
|
* XML also knows how to use this properly. However to use this we
|
|
|
|
* need to define a local XML file as well as be talking to a
|
|
|
|
* reasonably modern gdb. Responding with an empty packet will cause
|
|
|
|
* the remote gdb to fallback to older methods.
|
|
|
|
*/
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_set_reg(GArray *params, void *user_ctx)
|
2019-05-29 08:41:36 +02:00
|
|
|
{
|
|
|
|
int reg_size;
|
|
|
|
|
|
|
|
if (!gdb_has_xml) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("");
|
2019-05-29 08:41:36 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (params->len != 2) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:36 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
reg_size = strlen(get_param(params, 1)->data) / 2;
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_hextomem(gdbserver_state.mem_buf, get_param(params, 1)->data, reg_size);
|
2020-03-16 18:21:36 +01:00
|
|
|
gdb_write_register(gdbserver_state.g_cpu, gdbserver_state.mem_buf->data,
|
2021-05-25 10:24:14 +02:00
|
|
|
get_param(params, 0)->val_ull);
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("OK");
|
2019-05-29 08:41:36 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_get_reg(GArray *params, void *user_ctx)
|
2019-05-29 08:41:37 +02:00
|
|
|
{
|
|
|
|
int reg_size;
|
|
|
|
|
|
|
|
if (!gdb_has_xml) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("");
|
2019-05-29 08:41:37 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (!params->len) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E14");
|
2019-05-29 08:41:37 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:36 +01:00
|
|
|
reg_size = gdb_read_register(gdbserver_state.g_cpu,
|
2020-03-16 18:21:41 +01:00
|
|
|
gdbserver_state.mem_buf,
|
2021-05-25 10:24:14 +02:00
|
|
|
get_param(params, 0)->val_ull);
|
2019-05-29 08:41:37 +02:00
|
|
|
if (!reg_size) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E14");
|
2019-05-29 08:41:37 +02:00
|
|
|
return;
|
2020-03-16 18:21:36 +01:00
|
|
|
} else {
|
|
|
|
g_byte_array_set_size(gdbserver_state.mem_buf, reg_size);
|
2019-05-29 08:41:37 +02:00
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_memtohex(gdbserver_state.str_buf,
|
|
|
|
gdbserver_state.mem_buf->data, reg_size);
|
|
|
|
gdb_put_strbuf();
|
2019-05-29 08:41:37 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_write_mem(GArray *params, void *user_ctx)
|
2019-05-29 08:41:38 +02:00
|
|
|
{
|
2021-05-25 10:24:14 +02:00
|
|
|
if (params->len != 3) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:38 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
/* gdb_hextomem() reads 2*len bytes */
|
2021-05-25 10:24:14 +02:00
|
|
|
if (get_param(params, 1)->val_ull >
|
|
|
|
strlen(get_param(params, 2)->data) / 2) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:38 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_hextomem(gdbserver_state.mem_buf, get_param(params, 2)->data,
|
2023-03-03 03:57:51 +01:00
|
|
|
get_param(params, 1)->val_ull);
|
|
|
|
if (gdb_target_memory_rw_debug(gdbserver_state.g_cpu,
|
|
|
|
get_param(params, 0)->val_ull,
|
|
|
|
gdbserver_state.mem_buf->data,
|
|
|
|
gdbserver_state.mem_buf->len, true)) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E14");
|
2019-05-29 08:41:38 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("OK");
|
2019-05-29 08:41:38 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_read_mem(GArray *params, void *user_ctx)
|
2019-05-29 08:41:39 +02:00
|
|
|
{
|
2021-05-25 10:24:14 +02:00
|
|
|
if (params->len != 2) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:39 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
/* gdb_memtohex() doubles the required space */
|
2021-05-25 10:24:14 +02:00
|
|
|
if (get_param(params, 1)->val_ull > MAX_PACKET_LENGTH / 2) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:39 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
g_byte_array_set_size(gdbserver_state.mem_buf,
|
|
|
|
get_param(params, 1)->val_ull);
|
2020-03-16 18:21:36 +01:00
|
|
|
|
2023-03-03 03:57:51 +01:00
|
|
|
if (gdb_target_memory_rw_debug(gdbserver_state.g_cpu,
|
|
|
|
get_param(params, 0)->val_ull,
|
|
|
|
gdbserver_state.mem_buf->data,
|
|
|
|
gdbserver_state.mem_buf->len, false)) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E14");
|
2019-05-29 08:41:39 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data,
|
2020-03-16 18:21:36 +01:00
|
|
|
gdbserver_state.mem_buf->len);
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_strbuf();
|
2019-05-29 08:41:39 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_write_all_regs(GArray *params, void *user_ctx)
|
2019-05-29 08:41:40 +02:00
|
|
|
{
|
2023-03-03 03:57:55 +01:00
|
|
|
int reg_id;
|
|
|
|
size_t len;
|
2019-05-29 08:41:40 +02:00
|
|
|
uint8_t *registers;
|
|
|
|
int reg_size;
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (!params->len) {
|
2019-05-29 08:41:40 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
cpu_synchronize_state(gdbserver_state.g_cpu);
|
2021-05-25 10:24:14 +02:00
|
|
|
len = strlen(get_param(params, 0)->data) / 2;
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_hextomem(gdbserver_state.mem_buf, get_param(params, 0)->data, len);
|
2020-03-16 18:21:36 +01:00
|
|
|
registers = gdbserver_state.mem_buf->data;
|
2023-03-03 03:57:55 +01:00
|
|
|
for (reg_id = 0;
|
|
|
|
reg_id < gdbserver_state.g_cpu->gdb_num_g_regs && len > 0;
|
|
|
|
reg_id++) {
|
|
|
|
reg_size = gdb_write_register(gdbserver_state.g_cpu, registers, reg_id);
|
2019-05-29 08:41:40 +02:00
|
|
|
len -= reg_size;
|
|
|
|
registers += reg_size;
|
|
|
|
}
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("OK");
|
2019-05-29 08:41:40 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_read_all_regs(GArray *params, void *user_ctx)
|
2019-05-29 08:41:41 +02:00
|
|
|
{
|
2023-03-03 03:57:55 +01:00
|
|
|
int reg_id;
|
|
|
|
size_t len;
|
2019-05-29 08:41:41 +02:00
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
cpu_synchronize_state(gdbserver_state.g_cpu);
|
2020-03-16 18:21:41 +01:00
|
|
|
g_byte_array_set_size(gdbserver_state.mem_buf, 0);
|
2019-05-29 08:41:41 +02:00
|
|
|
len = 0;
|
2023-03-03 03:57:55 +01:00
|
|
|
for (reg_id = 0; reg_id < gdbserver_state.g_cpu->gdb_num_g_regs; reg_id++) {
|
2020-03-16 18:21:36 +01:00
|
|
|
len += gdb_read_register(gdbserver_state.g_cpu,
|
2020-03-16 18:21:41 +01:00
|
|
|
gdbserver_state.mem_buf,
|
2023-03-03 03:57:55 +01:00
|
|
|
reg_id);
|
2019-05-29 08:41:41 +02:00
|
|
|
}
|
2020-03-16 18:21:41 +01:00
|
|
|
g_assert(len == gdbserver_state.mem_buf->len);
|
2019-05-29 08:41:41 +02:00
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data, len);
|
|
|
|
gdb_put_strbuf();
|
2019-05-29 08:41:41 +02:00
|
|
|
}
|
|
|
|
|
2019-05-29 08:41:42 +02:00
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_step(GArray *params, void *user_ctx)
|
2019-05-29 08:41:43 +02:00
|
|
|
{
|
2021-05-25 10:24:14 +02:00
|
|
|
if (params->len) {
|
2023-03-03 03:57:54 +01:00
|
|
|
gdb_set_cpu_pc(get_param(params, 0)->val_ull);
|
2019-05-29 08:41:43 +02:00
|
|
|
}
|
|
|
|
|
2021-11-11 12:06:02 +01:00
|
|
|
cpu_single_step(gdbserver_state.c_cpu, gdbserver_state.sstep_flags);
|
2020-03-16 18:21:34 +01:00
|
|
|
gdb_continue();
|
2019-05-29 08:41:43 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_backward(GArray *params, void *user_ctx)
|
2020-10-03 19:13:43 +02:00
|
|
|
{
|
2023-03-03 03:57:53 +01:00
|
|
|
if (!gdb_can_reverse()) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2020-10-03 19:13:43 +02:00
|
|
|
}
|
2021-05-25 10:24:14 +02:00
|
|
|
if (params->len == 1) {
|
|
|
|
switch (get_param(params, 0)->opcode) {
|
2020-10-03 19:13:43 +02:00
|
|
|
case 's':
|
|
|
|
if (replay_reverse_step()) {
|
|
|
|
gdb_continue();
|
|
|
|
} else {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E14");
|
2020-10-03 19:13:43 +02:00
|
|
|
}
|
|
|
|
return;
|
2020-10-03 19:13:49 +02:00
|
|
|
case 'c':
|
|
|
|
if (replay_reverse_continue()) {
|
|
|
|
gdb_continue();
|
|
|
|
} else {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E14");
|
2020-10-03 19:13:49 +02:00
|
|
|
}
|
|
|
|
return;
|
2020-10-03 19:13:43 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Default invalid command */
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("");
|
2020-10-03 19:13:43 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_v_cont_query(GArray *params, void *user_ctx)
|
2019-05-29 08:41:44 +02:00
|
|
|
{
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("vCont;c;C;s;S");
|
2019-05-29 08:41:44 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_v_cont(GArray *params, void *user_ctx)
|
2019-05-29 08:41:44 +02:00
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (!params->len) {
|
2019-05-29 08:41:44 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
res = gdb_handle_vcont(get_param(params, 0)->data);
|
2019-05-29 08:41:44 +02:00
|
|
|
if ((res == -EINVAL) || (res == -ERANGE)) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:44 +02:00
|
|
|
} else if (res) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("");
|
2019-05-29 08:41:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_v_attach(GArray *params, void *user_ctx)
|
2019-05-29 08:41:44 +02:00
|
|
|
{
|
|
|
|
GDBProcess *process;
|
|
|
|
CPUState *cpu;
|
|
|
|
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_assign(gdbserver_state.str_buf, "E22");
|
2021-05-25 10:24:14 +02:00
|
|
|
if (!params->len) {
|
2019-05-29 08:41:44 +02:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
process = gdb_get_process(get_param(params, 0)->val_ul);
|
2019-05-29 08:41:44 +02:00
|
|
|
if (!process) {
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
cpu = get_first_cpu_in_process(process);
|
2019-05-29 08:41:44 +02:00
|
|
|
if (!cpu) {
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
process->attached = true;
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.g_cpu = cpu;
|
|
|
|
gdbserver_state.c_cpu = cpu;
|
2019-05-29 08:41:44 +02:00
|
|
|
|
2023-05-04 17:37:31 +02:00
|
|
|
if (gdbserver_state.allow_stop_reply) {
|
|
|
|
g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP);
|
|
|
|
gdb_append_thread_id(cpu, gdbserver_state.str_buf);
|
|
|
|
g_string_append_c(gdbserver_state.str_buf, ';');
|
|
|
|
gdbserver_state.allow_stop_reply = false;
|
2019-05-29 08:41:44 +02:00
|
|
|
cleanup:
|
2023-05-04 17:37:31 +02:00
|
|
|
gdb_put_strbuf();
|
|
|
|
}
|
2019-05-29 08:41:44 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_v_kill(GArray *params, void *user_ctx)
|
2019-05-29 08:41:44 +02:00
|
|
|
{
|
|
|
|
/* Kill the target */
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("OK");
|
2019-05-29 08:41:44 +02:00
|
|
|
error_report("QEMU: Terminated via GDBstub");
|
2021-01-08 23:42:45 +01:00
|
|
|
gdb_exit(0);
|
2019-05-29 08:41:44 +02:00
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
2021-05-20 19:42:59 +02:00
|
|
|
static const GdbCmdParseEntry gdb_v_commands_table[] = {
|
2019-05-29 08:41:44 +02:00
|
|
|
/* Order is important if has same prefix */
|
|
|
|
{
|
|
|
|
.handler = handle_v_cont_query,
|
|
|
|
.cmd = "Cont?",
|
|
|
|
.cmd_startswith = 1
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.handler = handle_v_cont,
|
|
|
|
.cmd = "Cont",
|
|
|
|
.cmd_startswith = 1,
|
2023-05-04 17:37:31 +02:00
|
|
|
.allow_stop_reply = true,
|
2019-05-29 08:41:44 +02:00
|
|
|
.schema = "s0"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.handler = handle_v_attach,
|
|
|
|
.cmd = "Attach;",
|
|
|
|
.cmd_startswith = 1,
|
2023-05-04 17:37:31 +02:00
|
|
|
.allow_stop_reply = true,
|
2019-05-29 08:41:44 +02:00
|
|
|
.schema = "l0"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.handler = handle_v_kill,
|
|
|
|
.cmd = "Kill;",
|
|
|
|
.cmd_startswith = 1
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_v_commands(GArray *params, void *user_ctx)
|
2019-05-29 08:41:44 +02:00
|
|
|
{
|
2021-05-25 10:24:14 +02:00
|
|
|
if (!params->len) {
|
2019-05-29 08:41:44 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (process_string_cmd(NULL, get_param(params, 0)->data,
|
2019-05-29 08:41:44 +02:00
|
|
|
gdb_v_commands_table,
|
|
|
|
ARRAY_SIZE(gdb_v_commands_table))) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("");
|
2019-05-29 08:41:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_query_qemu_sstepbits(GArray *params, void *user_ctx)
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
2021-11-11 12:06:02 +01:00
|
|
|
g_string_printf(gdbserver_state.str_buf, "ENABLE=%x", SSTEP_ENABLE);
|
|
|
|
|
|
|
|
if (gdbserver_state.supported_sstep_flags & SSTEP_NOIRQ) {
|
|
|
|
g_string_append_printf(gdbserver_state.str_buf, ",NOIRQ=%x",
|
|
|
|
SSTEP_NOIRQ);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gdbserver_state.supported_sstep_flags & SSTEP_NOTIMER) {
|
|
|
|
g_string_append_printf(gdbserver_state.str_buf, ",NOTIMER=%x",
|
|
|
|
SSTEP_NOTIMER);
|
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_strbuf();
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_set_qemu_sstep(GArray *params, void *user_ctx)
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
2021-11-11 12:06:02 +01:00
|
|
|
int new_sstep_flags;
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (!params->len) {
|
2019-05-29 08:41:45 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-11-11 12:06:02 +01:00
|
|
|
new_sstep_flags = get_param(params, 0)->val_ul;
|
|
|
|
|
|
|
|
if (new_sstep_flags & ~gdbserver_state.supported_sstep_flags) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2021-11-11 12:06:02 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
gdbserver_state.sstep_flags = new_sstep_flags;
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("OK");
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_query_qemu_sstep(GArray *params, void *user_ctx)
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
2021-11-11 12:06:02 +01:00
|
|
|
g_string_printf(gdbserver_state.str_buf, "0x%x",
|
|
|
|
gdbserver_state.sstep_flags);
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_strbuf();
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_query_curr_tid(GArray *params, void *user_ctx)
|
2003-06-27 19:34:32 +02:00
|
|
|
{
|
2013-06-27 19:19:39 +02:00
|
|
|
CPUState *cpu;
|
2019-05-29 08:41:45 +02:00
|
|
|
GDBProcess *process;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* "Current thread" remains vague in the spec, so always return
|
|
|
|
* the first thread of the current process (gdb returns the
|
|
|
|
* first thread).
|
|
|
|
*/
|
2020-03-16 18:21:34 +01:00
|
|
|
process = gdb_get_cpu_process(gdbserver_state.g_cpu);
|
|
|
|
cpu = get_first_cpu_in_process(process);
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_assign(gdbserver_state.str_buf, "QC");
|
|
|
|
gdb_append_thread_id(cpu, gdbserver_state.str_buf);
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_strbuf();
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_query_threads(GArray *params, void *user_ctx)
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
2020-03-16 18:21:34 +01:00
|
|
|
if (!gdbserver_state.query_cpu) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("l");
|
2019-05-29 08:41:45 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_assign(gdbserver_state.str_buf, "m");
|
|
|
|
gdb_append_thread_id(gdbserver_state.query_cpu, gdbserver_state.str_buf);
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_strbuf();
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.query_cpu = gdb_next_attached_cpu(gdbserver_state.query_cpu);
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_query_first_threads(GArray *params, void *user_ctx)
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.query_cpu = gdb_first_attached_cpu();
|
2021-05-25 10:24:14 +02:00
|
|
|
handle_query_threads(params, user_ctx);
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_query_thread_extra(GArray *params, void *user_ctx)
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
2020-03-16 18:21:35 +01:00
|
|
|
g_autoptr(GString) rs = g_string_new(NULL);
|
2019-05-29 08:41:45 +02:00
|
|
|
CPUState *cpu;
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (!params->len ||
|
|
|
|
get_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:45 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
cpu = gdb_get_cpu(get_param(params, 0)->thread_id.pid,
|
|
|
|
get_param(params, 0)->thread_id.tid);
|
2019-05-29 08:41:45 +02:00
|
|
|
if (!cpu) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
cpu_synchronize_state(cpu);
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
if (gdbserver_state.multiprocess && (gdbserver_state.process_num > 1)) {
|
2019-05-29 08:41:45 +02:00
|
|
|
/* Print the CPU model and name in multiprocess mode */
|
|
|
|
ObjectClass *oc = object_get_class(OBJECT(cpu));
|
|
|
|
const char *cpu_model = object_class_get_name(oc);
|
2020-07-14 18:02:00 +02:00
|
|
|
const char *cpu_name =
|
2020-04-03 21:11:44 +02:00
|
|
|
object_get_canonical_path_component(OBJECT(cpu));
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_printf(rs, "%s %s [%s]", cpu_model, cpu_name,
|
|
|
|
cpu->halted ? "halted " : "running");
|
2019-05-29 08:41:45 +02:00
|
|
|
} else {
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_printf(rs, "CPU#%d [%s]", cpu->cpu_index,
|
2019-05-29 08:41:45 +02:00
|
|
|
cpu->halted ? "halted " : "running");
|
|
|
|
}
|
2020-03-16 18:21:35 +01:00
|
|
|
trace_gdbstub_op_extra_info(rs->str);
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_memtohex(gdbserver_state.str_buf, (uint8_t *)rs->str, rs->len);
|
|
|
|
gdb_put_strbuf();
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_query_supported(GArray *params, void *user_ctx)
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
|
|
|
CPUClass *cc;
|
|
|
|
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_printf(gdbserver_state.str_buf, "PacketSize=%x", MAX_PACKET_LENGTH);
|
2019-05-29 08:41:45 +02:00
|
|
|
cc = CPU_GET_CLASS(first_cpu);
|
|
|
|
if (cc->gdb_core_xml_file) {
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_append(gdbserver_state.str_buf, ";qXfer:features:read+");
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:53 +01:00
|
|
|
if (gdb_can_reverse()) {
|
2020-10-03 19:13:49 +02:00
|
|
|
g_string_append(gdbserver_state.str_buf,
|
|
|
|
";ReverseStep+;ReverseContinue+");
|
2020-10-03 19:13:43 +02:00
|
|
|
}
|
|
|
|
|
2023-04-03 15:49:12 +02:00
|
|
|
#if defined(CONFIG_USER_ONLY) && defined(CONFIG_LINUX)
|
2021-01-08 23:42:42 +01:00
|
|
|
if (gdbserver_state.c_cpu->opaque) {
|
|
|
|
g_string_append(gdbserver_state.str_buf, ";qXfer:auxv:read+");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (params->len &&
|
|
|
|
strstr(get_param(params, 0)->data, "multiprocess+")) {
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.multiprocess = true;
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
|
gdbstub: Fix single-step issue by confirming 'vContSupported+' feature to gdb
Recently when debugging an arm32 system on qemu, I found sometimes the
single-step command (stepi) is not working. This can be reproduced by
below steps:
1) start qemu-system-arm -s -S .. and wait for gdb connection.
2) start gdb and connect to qemu. In my case, gdb gets a wrong value
(0x60) for PC, which is an another bug.
3) After connected, type 'stepi' and expect it will stop at next ins.
But, it has never stopped. This because:
1) We doesn't report ‘vContSupported’ feature to gdb explicitly and gdb
think we do not support it. In this case, gdb use a software breakpoint
to emulate single-step.
2) Since gdb gets a wrong initial value of PC, then gdb inserts a
breakpoint to wrong place (PC+4).
Not only for the arm target, Philippe has also encountered this on MIPS.
Probably gdb has different assumption for different architectures.
Since we do support ‘vContSupported’ query command, so let's tell gdb that
we support it.
Before this change, gdb send below 'Z0' packet to implement single-step:
gdb_handle_packet: Z0,4,4
After this change, gdb send "vCont;s.." which is expected:
gdb_handle_packet: vCont?
put_packet: vCont;c;C;s;S
gdb_handle_packet: vCont;s:p1.1;c:p1.-1
Signed-off-by: Changbin Du <changbin.du@gmail.com>
Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-Id: <20200221002559.6768-1-changbin.du@gmail.com>
[AJB: fix for static gdbstub]
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Reviewed-by: Luc Michel <luc.michel@greensocs.com>
Message-Id: <20200316172155.971-29-alex.bennee@linaro.org>
2020-03-16 18:21:55 +01:00
|
|
|
g_string_append(gdbserver_state.str_buf, ";vContSupported+;multiprocess+");
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_strbuf();
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_query_xfer_features(GArray *params, void *user_ctx)
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
2019-01-07 16:23:46 +01:00
|
|
|
GDBProcess *process;
|
2013-07-07 15:08:22 +02:00
|
|
|
CPUClass *cc;
|
2019-05-29 08:41:45 +02:00
|
|
|
unsigned long len, total_len, addr;
|
|
|
|
const char *xml;
|
2003-06-27 19:34:32 +02:00
|
|
|
const char *p;
|
2019-05-29 08:41:45 +02:00
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (params->len < 3) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E22");
|
2019-05-29 08:41:45 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
process = gdb_get_cpu_process(gdbserver_state.g_cpu);
|
|
|
|
cc = CPU_GET_CLASS(gdbserver_state.g_cpu);
|
2019-05-29 08:41:45 +02:00
|
|
|
if (!cc->gdb_core_xml_file) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("");
|
2019-05-29 08:41:45 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
gdb_has_xml = true;
|
2021-05-25 10:24:14 +02:00
|
|
|
p = get_param(params, 0)->data;
|
2020-03-16 18:21:34 +01:00
|
|
|
xml = get_feature_xml(p, &p, process);
|
2019-05-29 08:41:45 +02:00
|
|
|
if (!xml) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E00");
|
2019-05-29 08:41:45 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
addr = get_param(params, 1)->val_ul;
|
|
|
|
len = get_param(params, 2)->val_ul;
|
2019-05-29 08:41:45 +02:00
|
|
|
total_len = strlen(xml);
|
|
|
|
if (addr > total_len) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("E00");
|
2019-05-29 08:41:45 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (len > (MAX_PACKET_LENGTH - 5) / 2) {
|
|
|
|
len = (MAX_PACKET_LENGTH - 5) / 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (len < total_len - addr) {
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_assign(gdbserver_state.str_buf, "m");
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_memtox(gdbserver_state.str_buf, xml + addr, len);
|
2019-05-29 08:41:45 +02:00
|
|
|
} else {
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_assign(gdbserver_state.str_buf, "l");
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_memtox(gdbserver_state.str_buf, xml + addr, total_len - addr);
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet_binary(gdbserver_state.str_buf->str,
|
2020-03-16 18:21:35 +01:00
|
|
|
gdbserver_state.str_buf->len, true);
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_query_qemu_supported(GArray *params, void *user_ctx)
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_printf(gdbserver_state.str_buf, "sstepbits;sstep");
|
2019-05-29 08:41:48 +02:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2020-03-16 18:21:35 +01:00
|
|
|
g_string_append(gdbserver_state.str_buf, ";PhyMemMode");
|
2019-05-29 08:41:48 +02:00
|
|
|
#endif
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_strbuf();
|
2019-05-29 08:41:48 +02:00
|
|
|
}
|
|
|
|
|
2021-05-20 19:42:59 +02:00
|
|
|
static const GdbCmdParseEntry gdb_gen_query_set_common_table[] = {
|
2019-05-29 08:41:45 +02:00
|
|
|
/* Order is important if has same prefix */
|
|
|
|
{
|
|
|
|
.handler = handle_query_qemu_sstepbits,
|
|
|
|
.cmd = "qemu.sstepbits",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.handler = handle_query_qemu_sstep,
|
|
|
|
.cmd = "qemu.sstep",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.handler = handle_set_qemu_sstep,
|
|
|
|
.cmd = "qemu.sstep=",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "l0"
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2021-05-20 19:42:59 +02:00
|
|
|
static const GdbCmdParseEntry gdb_gen_query_table[] = {
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
|
|
|
.handler = handle_query_curr_tid,
|
|
|
|
.cmd = "C",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.handler = handle_query_threads,
|
|
|
|
.cmd = "sThreadInfo",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.handler = handle_query_first_threads,
|
|
|
|
.cmd = "fThreadInfo",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.handler = handle_query_thread_extra,
|
|
|
|
.cmd = "ThreadExtraInfo,",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "t0"
|
|
|
|
},
|
|
|
|
#ifdef CONFIG_USER_ONLY
|
|
|
|
{
|
2023-03-03 03:57:47 +01:00
|
|
|
.handler = gdb_handle_query_offsets,
|
2019-05-29 08:41:45 +02:00
|
|
|
.cmd = "Offsets",
|
|
|
|
},
|
|
|
|
#else
|
|
|
|
{
|
2023-03-03 03:57:46 +01:00
|
|
|
.handler = gdb_handle_query_rcmd,
|
2019-05-29 08:41:45 +02:00
|
|
|
.cmd = "Rcmd,",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "s0"
|
|
|
|
},
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
.handler = handle_query_supported,
|
|
|
|
.cmd = "Supported:",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "s0"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.handler = handle_query_supported,
|
|
|
|
.cmd = "Supported",
|
|
|
|
.schema = "s0"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.handler = handle_query_xfer_features,
|
|
|
|
.cmd = "Xfer:features:read:",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "s:l,l0"
|
|
|
|
},
|
2023-03-03 03:57:58 +01:00
|
|
|
#if defined(CONFIG_USER_ONLY) && defined(CONFIG_LINUX)
|
2021-01-08 23:42:42 +01:00
|
|
|
{
|
2023-03-03 03:57:47 +01:00
|
|
|
.handler = gdb_handle_query_xfer_auxv,
|
2021-01-08 23:42:42 +01:00
|
|
|
.cmd = "Xfer:auxv:read::",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "l,l0"
|
|
|
|
},
|
|
|
|
#endif
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
2023-03-03 03:57:50 +01:00
|
|
|
.handler = gdb_handle_query_attached,
|
2019-05-29 08:41:45 +02:00
|
|
|
.cmd = "Attached:",
|
|
|
|
.cmd_startswith = 1
|
|
|
|
},
|
|
|
|
{
|
2023-03-03 03:57:50 +01:00
|
|
|
.handler = gdb_handle_query_attached,
|
2019-05-29 08:41:45 +02:00
|
|
|
.cmd = "Attached",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.handler = handle_query_qemu_supported,
|
|
|
|
.cmd = "qemu.Supported",
|
|
|
|
},
|
2019-05-29 08:41:48 +02:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
{
|
2023-03-03 03:57:51 +01:00
|
|
|
.handler = gdb_handle_query_qemu_phy_mem_mode,
|
2019-05-29 08:41:48 +02:00
|
|
|
.cmd = "qemu.PhyMemMode",
|
|
|
|
},
|
|
|
|
#endif
|
2019-05-29 08:41:45 +02:00
|
|
|
};
|
|
|
|
|
2021-05-20 19:42:59 +02:00
|
|
|
static const GdbCmdParseEntry gdb_gen_set_table[] = {
|
2019-05-29 08:41:45 +02:00
|
|
|
/* Order is important if has same prefix */
|
|
|
|
{
|
|
|
|
.handler = handle_set_qemu_sstep,
|
|
|
|
.cmd = "qemu.sstep:",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "l0"
|
|
|
|
},
|
2019-05-29 08:41:48 +02:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
{
|
2023-03-03 03:57:51 +01:00
|
|
|
.handler = gdb_handle_set_qemu_phy_mem_mode,
|
2019-05-29 08:41:48 +02:00
|
|
|
.cmd = "qemu.PhyMemMode:",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "l0"
|
|
|
|
},
|
|
|
|
#endif
|
2019-05-29 08:41:45 +02:00
|
|
|
};
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_gen_query(GArray *params, void *user_ctx)
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
2021-05-25 10:24:14 +02:00
|
|
|
if (!params->len) {
|
2019-05-29 08:41:45 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (!process_string_cmd(NULL, get_param(params, 0)->data,
|
2019-05-29 08:41:45 +02:00
|
|
|
gdb_gen_query_set_common_table,
|
|
|
|
ARRAY_SIZE(gdb_gen_query_set_common_table))) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (process_string_cmd(NULL, get_param(params, 0)->data,
|
2019-05-29 08:41:45 +02:00
|
|
|
gdb_gen_query_table,
|
|
|
|
ARRAY_SIZE(gdb_gen_query_table))) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("");
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_gen_set(GArray *params, void *user_ctx)
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
2021-05-25 10:24:14 +02:00
|
|
|
if (!params->len) {
|
2019-05-29 08:41:45 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (!process_string_cmd(NULL, get_param(params, 0)->data,
|
2019-05-29 08:41:45 +02:00
|
|
|
gdb_gen_query_set_common_table,
|
|
|
|
ARRAY_SIZE(gdb_gen_query_set_common_table))) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
if (process_string_cmd(NULL, get_param(params, 0)->data,
|
2019-05-29 08:41:45 +02:00
|
|
|
gdb_gen_set_table,
|
|
|
|
ARRAY_SIZE(gdb_gen_set_table))) {
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("");
|
2019-05-29 08:41:45 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-25 10:24:14 +02:00
|
|
|
static void handle_target_halt(GArray *params, void *user_ctx)
|
2019-05-29 08:41:46 +02:00
|
|
|
{
|
2023-05-04 17:37:31 +02:00
|
|
|
if (gdbserver_state.allow_stop_reply) {
|
|
|
|
g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP);
|
|
|
|
gdb_append_thread_id(gdbserver_state.c_cpu, gdbserver_state.str_buf);
|
|
|
|
g_string_append_c(gdbserver_state.str_buf, ';');
|
|
|
|
gdb_put_strbuf();
|
|
|
|
gdbserver_state.allow_stop_reply = false;
|
|
|
|
}
|
2019-05-29 08:41:46 +02:00
|
|
|
/*
|
|
|
|
* Remove all the breakpoints when this query is issued,
|
|
|
|
* because gdb is doing an initial connect and the state
|
|
|
|
* should be cleaned up.
|
|
|
|
*/
|
2022-09-29 13:42:24 +02:00
|
|
|
gdb_breakpoint_remove_all(gdbserver_state.c_cpu);
|
2019-05-29 08:41:46 +02:00
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
static int gdb_handle_packet(const char *line_buf)
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
2019-05-29 08:41:30 +02:00
|
|
|
const GdbCmdParseEntry *cmd_parser = NULL;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2017-12-03 02:30:37 +01:00
|
|
|
trace_gdbstub_io_command(line_buf);
|
2017-07-12 12:52:13 +02:00
|
|
|
|
2019-05-29 08:41:47 +02:00
|
|
|
switch (line_buf[0]) {
|
2019-01-07 16:23:46 +01:00
|
|
|
case '!':
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("OK");
|
2019-01-07 16:23:46 +01:00
|
|
|
break;
|
2004-03-31 20:52:07 +02:00
|
|
|
case '?':
|
2019-05-29 08:41:46 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry target_halted_cmd_desc = {
|
|
|
|
.handler = handle_target_halt,
|
|
|
|
.cmd = "?",
|
2023-05-04 17:37:31 +02:00
|
|
|
.cmd_startswith = 1,
|
|
|
|
.allow_stop_reply = true,
|
2019-05-29 08:41:46 +02:00
|
|
|
};
|
|
|
|
cmd_parser = &target_halted_cmd_desc;
|
|
|
|
}
|
2004-03-31 20:52:07 +02:00
|
|
|
break;
|
|
|
|
case 'c':
|
2019-05-29 08:41:32 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry continue_cmd_desc = {
|
|
|
|
.handler = handle_continue,
|
|
|
|
.cmd = "c",
|
|
|
|
.cmd_startswith = 1,
|
2023-05-04 17:37:31 +02:00
|
|
|
.allow_stop_reply = true,
|
2019-05-29 08:41:32 +02:00
|
|
|
.schema = "L0"
|
|
|
|
};
|
|
|
|
cmd_parser = &continue_cmd_desc;
|
2004-03-31 20:52:07 +02:00
|
|
|
}
|
2019-05-29 08:41:32 +02:00
|
|
|
break;
|
2008-05-18 00:20:53 +02:00
|
|
|
case 'C':
|
2019-05-29 08:41:33 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry cont_with_sig_cmd_desc = {
|
|
|
|
.handler = handle_cont_with_sig,
|
|
|
|
.cmd = "C",
|
|
|
|
.cmd_startswith = 1,
|
2023-05-04 17:37:31 +02:00
|
|
|
.allow_stop_reply = true,
|
2019-05-29 08:41:33 +02:00
|
|
|
.schema = "l0"
|
|
|
|
};
|
|
|
|
cmd_parser = &cont_with_sig_cmd_desc;
|
|
|
|
}
|
|
|
|
break;
|
2009-06-27 09:53:51 +02:00
|
|
|
case 'v':
|
2019-05-29 08:41:44 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry v_cmd_desc = {
|
|
|
|
.handler = handle_v_commands,
|
|
|
|
.cmd = "v",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "s0"
|
|
|
|
};
|
|
|
|
cmd_parser = &v_cmd_desc;
|
2009-06-27 09:53:51 +02:00
|
|
|
}
|
2019-05-29 08:41:44 +02:00
|
|
|
break;
|
2008-05-17 20:58:29 +02:00
|
|
|
case 'k':
|
|
|
|
/* Kill the target */
|
2017-01-18 09:03:29 +01:00
|
|
|
error_report("QEMU: Terminated via GDBstub");
|
2021-01-08 23:42:45 +01:00
|
|
|
gdb_exit(0);
|
2008-05-17 20:58:29 +02:00
|
|
|
exit(0);
|
|
|
|
case 'D':
|
2019-05-29 08:41:30 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry detach_cmd_desc = {
|
|
|
|
.handler = handle_detach,
|
|
|
|
.cmd = "D",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "?.l0"
|
|
|
|
};
|
|
|
|
cmd_parser = &detach_cmd_desc;
|
2019-01-07 16:23:46 +01:00
|
|
|
}
|
2008-05-17 20:58:29 +02:00
|
|
|
break;
|
2004-03-31 20:52:07 +02:00
|
|
|
case 's':
|
2019-05-29 08:41:43 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry step_cmd_desc = {
|
|
|
|
.handler = handle_step,
|
|
|
|
.cmd = "s",
|
|
|
|
.cmd_startswith = 1,
|
2023-05-04 17:37:31 +02:00
|
|
|
.allow_stop_reply = true,
|
2019-05-29 08:41:43 +02:00
|
|
|
.schema = "L0"
|
|
|
|
};
|
|
|
|
cmd_parser = &step_cmd_desc;
|
2004-03-31 20:52:07 +02:00
|
|
|
}
|
2019-05-29 08:41:43 +02:00
|
|
|
break;
|
2020-10-03 19:13:43 +02:00
|
|
|
case 'b':
|
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry backward_cmd_desc = {
|
|
|
|
.handler = handle_backward,
|
|
|
|
.cmd = "b",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "o0"
|
|
|
|
};
|
|
|
|
cmd_parser = &backward_cmd_desc;
|
|
|
|
}
|
|
|
|
break;
|
2007-01-28 04:10:55 +01:00
|
|
|
case 'F':
|
|
|
|
{
|
2019-05-29 08:41:42 +02:00
|
|
|
static const GdbCmdParseEntry file_io_cmd_desc = {
|
2023-03-03 03:57:57 +01:00
|
|
|
.handler = gdb_handle_file_io,
|
2019-05-29 08:41:42 +02:00
|
|
|
.cmd = "F",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "L,L,o0"
|
|
|
|
};
|
|
|
|
cmd_parser = &file_io_cmd_desc;
|
2007-01-28 04:10:55 +01:00
|
|
|
}
|
|
|
|
break;
|
2004-03-31 20:52:07 +02:00
|
|
|
case 'g':
|
2019-05-29 08:41:41 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry read_all_regs_cmd_desc = {
|
|
|
|
.handler = handle_read_all_regs,
|
|
|
|
.cmd = "g",
|
|
|
|
.cmd_startswith = 1
|
|
|
|
};
|
|
|
|
cmd_parser = &read_all_regs_cmd_desc;
|
2008-10-11 19:55:29 +02:00
|
|
|
}
|
2004-03-31 20:52:07 +02:00
|
|
|
break;
|
|
|
|
case 'G':
|
2019-05-29 08:41:40 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry write_all_regs_cmd_desc = {
|
|
|
|
.handler = handle_write_all_regs,
|
|
|
|
.cmd = "G",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "s0"
|
|
|
|
};
|
|
|
|
cmd_parser = &write_all_regs_cmd_desc;
|
2008-10-11 19:55:29 +02:00
|
|
|
}
|
2004-03-31 20:52:07 +02:00
|
|
|
break;
|
|
|
|
case 'm':
|
2019-05-29 08:41:39 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry read_mem_cmd_desc = {
|
|
|
|
.handler = handle_read_mem,
|
|
|
|
.cmd = "m",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "L,L0"
|
|
|
|
};
|
|
|
|
cmd_parser = &read_mem_cmd_desc;
|
2005-12-05 20:55:19 +01:00
|
|
|
}
|
2004-03-31 20:52:07 +02:00
|
|
|
break;
|
|
|
|
case 'M':
|
2019-05-29 08:41:38 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry write_mem_cmd_desc = {
|
|
|
|
.handler = handle_write_mem,
|
|
|
|
.cmd = "M",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "L,L:s0"
|
|
|
|
};
|
|
|
|
cmd_parser = &write_mem_cmd_desc;
|
2011-09-08 12:48:16 +02:00
|
|
|
}
|
2004-03-31 20:52:07 +02:00
|
|
|
break;
|
2008-10-11 19:55:29 +02:00
|
|
|
case 'p':
|
2019-05-29 08:41:37 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry get_reg_cmd_desc = {
|
|
|
|
.handler = handle_get_reg,
|
|
|
|
.cmd = "p",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "L0"
|
|
|
|
};
|
|
|
|
cmd_parser = &get_reg_cmd_desc;
|
2008-10-11 19:55:29 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'P':
|
2019-05-29 08:41:36 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry set_reg_cmd_desc = {
|
|
|
|
.handler = handle_set_reg,
|
|
|
|
.cmd = "P",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "L?s0"
|
|
|
|
};
|
|
|
|
cmd_parser = &set_reg_cmd_desc;
|
|
|
|
}
|
2008-10-11 19:55:29 +02:00
|
|
|
break;
|
2004-03-31 20:52:07 +02:00
|
|
|
case 'Z':
|
2019-05-29 08:41:35 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry insert_bp_cmd_desc = {
|
|
|
|
.handler = handle_insert_bp,
|
|
|
|
.cmd = "Z",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "l?L?L0"
|
|
|
|
};
|
|
|
|
cmd_parser = &insert_bp_cmd_desc;
|
|
|
|
}
|
|
|
|
break;
|
2004-03-31 20:52:07 +02:00
|
|
|
case 'z':
|
2019-05-29 08:41:35 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry remove_bp_cmd_desc = {
|
|
|
|
.handler = handle_remove_bp,
|
|
|
|
.cmd = "z",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "l?L?L0"
|
|
|
|
};
|
|
|
|
cmd_parser = &remove_bp_cmd_desc;
|
|
|
|
}
|
2004-03-31 20:52:07 +02:00
|
|
|
break;
|
2008-11-18 21:30:24 +01:00
|
|
|
case 'H':
|
2019-05-29 08:41:34 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry set_thread_cmd_desc = {
|
|
|
|
.handler = handle_set_thread,
|
|
|
|
.cmd = "H",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "o.t0"
|
|
|
|
};
|
|
|
|
cmd_parser = &set_thread_cmd_desc;
|
2008-11-18 21:30:24 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'T':
|
2019-05-29 08:41:31 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry thread_alive_cmd_desc = {
|
|
|
|
.handler = handle_thread_alive,
|
|
|
|
.cmd = "T",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "t0"
|
|
|
|
};
|
|
|
|
cmd_parser = &thread_alive_cmd_desc;
|
2009-06-03 20:33:08 +02:00
|
|
|
}
|
2008-11-18 21:30:24 +01:00
|
|
|
break;
|
2006-06-17 20:30:42 +02:00
|
|
|
case 'q':
|
2019-05-29 08:41:45 +02:00
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry gen_query_cmd_desc = {
|
|
|
|
.handler = handle_gen_query,
|
|
|
|
.cmd = "q",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "s0"
|
|
|
|
};
|
|
|
|
cmd_parser = &gen_query_cmd_desc;
|
2008-10-11 19:55:29 +02:00
|
|
|
}
|
2019-05-29 08:41:45 +02:00
|
|
|
break;
|
|
|
|
case 'Q':
|
|
|
|
{
|
|
|
|
static const GdbCmdParseEntry gen_set_cmd_desc = {
|
|
|
|
.handler = handle_gen_set,
|
|
|
|
.cmd = "Q",
|
|
|
|
.cmd_startswith = 1,
|
|
|
|
.schema = "s0"
|
|
|
|
};
|
|
|
|
cmd_parser = &gen_set_cmd_desc;
|
2015-02-07 09:38:44 +01:00
|
|
|
}
|
2019-05-29 08:41:45 +02:00
|
|
|
break;
|
2004-03-31 20:52:07 +02:00
|
|
|
default:
|
|
|
|
/* put empty packet */
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_packet("");
|
2004-03-31 20:52:07 +02:00
|
|
|
break;
|
|
|
|
}
|
2019-05-29 08:41:30 +02:00
|
|
|
|
2019-08-05 21:09:01 +02:00
|
|
|
if (cmd_parser) {
|
2020-03-16 18:21:34 +01:00
|
|
|
run_cmd_parser(line_buf, cmd_parser);
|
2019-08-05 21:09:01 +02:00
|
|
|
}
|
2019-05-29 08:41:30 +02:00
|
|
|
|
2004-03-31 20:52:07 +02:00
|
|
|
return RS_IDLE;
|
|
|
|
}
|
|
|
|
|
2013-05-27 02:06:09 +02:00
|
|
|
void gdb_set_stop_cpu(CPUState *cpu)
|
2008-11-18 21:30:24 +01:00
|
|
|
{
|
2020-03-16 18:21:34 +01:00
|
|
|
GDBProcess *p = gdb_get_cpu_process(cpu);
|
2019-01-07 16:23:46 +01:00
|
|
|
|
|
|
|
if (!p->attached) {
|
|
|
|
/*
|
|
|
|
* Having a stop CPU corresponding to a process that is not attached
|
|
|
|
* confuses GDB. So we ignore the request.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-03-16 18:21:33 +01:00
|
|
|
gdbserver_state.c_cpu = cpu;
|
|
|
|
gdbserver_state.g_cpu = cpu;
|
2008-11-18 21:30:24 +01:00
|
|
|
}
|
|
|
|
|
2023-03-03 03:57:45 +01:00
|
|
|
void gdb_read_byte(uint8_t ch)
|
2004-03-31 20:52:07 +02:00
|
|
|
{
|
2007-12-16 04:02:09 +01:00
|
|
|
uint8_t reply;
|
2004-03-31 20:52:07 +02:00
|
|
|
|
2023-05-04 17:37:31 +02:00
|
|
|
gdbserver_state.allow_stop_reply = false;
|
2005-04-17 21:16:13 +02:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2020-03-16 18:21:53 +01:00
|
|
|
if (gdbserver_state.last_packet->len) {
|
2007-01-28 02:53:16 +01:00
|
|
|
/* Waiting for a response to the last packet. If we see the start
|
|
|
|
of a new command then abandon the previous response. */
|
|
|
|
if (ch == '-') {
|
2017-12-03 02:30:37 +01:00
|
|
|
trace_gdbstub_err_got_nack();
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_buffer(gdbserver_state.last_packet->data,
|
2020-03-16 18:21:53 +01:00
|
|
|
gdbserver_state.last_packet->len);
|
2017-07-12 12:52:13 +02:00
|
|
|
} else if (ch == '+') {
|
2017-12-03 02:30:37 +01:00
|
|
|
trace_gdbstub_io_got_ack();
|
2017-07-12 12:52:13 +02:00
|
|
|
} else {
|
2019-05-14 20:03:09 +02:00
|
|
|
trace_gdbstub_io_got_unexpected(ch);
|
2007-01-28 02:53:16 +01:00
|
|
|
}
|
2017-07-12 12:52:13 +02:00
|
|
|
|
2020-03-16 18:21:53 +01:00
|
|
|
if (ch == '+' || ch == '$') {
|
|
|
|
g_byte_array_set_size(gdbserver_state.last_packet, 0);
|
|
|
|
}
|
2007-01-28 02:53:16 +01:00
|
|
|
if (ch != '$')
|
|
|
|
return;
|
|
|
|
}
|
2011-07-29 20:36:43 +02:00
|
|
|
if (runstate_is_running()) {
|
2004-03-31 20:52:07 +02:00
|
|
|
/* when the CPU is running, we cannot do anything except stop
|
|
|
|
it when receiving a char */
|
2011-09-30 19:45:27 +02:00
|
|
|
vm_stop(RUN_STATE_PAUSED);
|
2007-09-16 23:08:06 +02:00
|
|
|
} else
|
2005-04-17 21:16:13 +02:00
|
|
|
#endif
|
2005-04-24 12:07:11 +02:00
|
|
|
{
|
2020-03-16 18:21:34 +01:00
|
|
|
switch(gdbserver_state.state) {
|
2004-03-31 20:52:07 +02:00
|
|
|
case RS_IDLE:
|
|
|
|
if (ch == '$') {
|
2017-05-01 18:22:10 +02:00
|
|
|
/* start of command packet */
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.line_buf_index = 0;
|
|
|
|
gdbserver_state.line_sum = 0;
|
|
|
|
gdbserver_state.state = RS_GETLINE;
|
2017-05-01 18:22:10 +02:00
|
|
|
} else {
|
2019-05-14 20:03:09 +02:00
|
|
|
trace_gdbstub_err_garbage(ch);
|
2003-07-29 22:50:33 +02:00
|
|
|
}
|
2003-06-27 19:34:32 +02:00
|
|
|
break;
|
2004-03-31 20:52:07 +02:00
|
|
|
case RS_GETLINE:
|
2017-05-01 18:22:10 +02:00
|
|
|
if (ch == '}') {
|
|
|
|
/* start escape sequence */
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.state = RS_GETLINE_ESC;
|
|
|
|
gdbserver_state.line_sum += ch;
|
2017-05-01 18:22:10 +02:00
|
|
|
} else if (ch == '*') {
|
|
|
|
/* start run length encoding sequence */
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.state = RS_GETLINE_RLE;
|
|
|
|
gdbserver_state.line_sum += ch;
|
2017-05-01 18:22:10 +02:00
|
|
|
} else if (ch == '#') {
|
|
|
|
/* end of command, start of checksum*/
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.state = RS_CHKSUM1;
|
|
|
|
} else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) {
|
2017-12-03 02:30:37 +01:00
|
|
|
trace_gdbstub_err_overrun();
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.state = RS_IDLE;
|
2017-05-01 18:22:10 +02:00
|
|
|
} else {
|
|
|
|
/* unescaped command character */
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch;
|
|
|
|
gdbserver_state.line_sum += ch;
|
2017-05-01 18:22:10 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case RS_GETLINE_ESC:
|
2004-03-31 20:52:07 +02:00
|
|
|
if (ch == '#') {
|
2017-05-01 18:22:10 +02:00
|
|
|
/* unexpected end of command in escape sequence */
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.state = RS_CHKSUM1;
|
|
|
|
} else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) {
|
2017-05-01 18:22:10 +02:00
|
|
|
/* command buffer overrun */
|
2017-12-03 02:30:37 +01:00
|
|
|
trace_gdbstub_err_overrun();
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.state = RS_IDLE;
|
2003-07-26 14:06:08 +02:00
|
|
|
} else {
|
2017-05-01 18:22:10 +02:00
|
|
|
/* parse escaped character and leave escape state */
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch ^ 0x20;
|
|
|
|
gdbserver_state.line_sum += ch;
|
|
|
|
gdbserver_state.state = RS_GETLINE;
|
2017-05-01 18:22:10 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case RS_GETLINE_RLE:
|
2019-05-14 20:03:08 +02:00
|
|
|
/*
|
|
|
|
* Run-length encoding is explained in "Debugging with GDB /
|
|
|
|
* Appendix E GDB Remote Serial Protocol / Overview".
|
|
|
|
*/
|
|
|
|
if (ch < ' ' || ch == '#' || ch == '$' || ch > 126) {
|
2017-05-01 18:22:10 +02:00
|
|
|
/* invalid RLE count encoding */
|
2019-05-14 20:03:09 +02:00
|
|
|
trace_gdbstub_err_invalid_repeat(ch);
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.state = RS_GETLINE;
|
2017-05-01 18:22:10 +02:00
|
|
|
} else {
|
|
|
|
/* decode repeat length */
|
2019-05-14 20:03:09 +02:00
|
|
|
int repeat = ch - ' ' + 3;
|
2020-03-16 18:21:34 +01:00
|
|
|
if (gdbserver_state.line_buf_index + repeat >= sizeof(gdbserver_state.line_buf) - 1) {
|
2017-05-01 18:22:10 +02:00
|
|
|
/* that many repeats would overrun the command buffer */
|
2017-12-03 02:30:37 +01:00
|
|
|
trace_gdbstub_err_overrun();
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.state = RS_IDLE;
|
|
|
|
} else if (gdbserver_state.line_buf_index < 1) {
|
2017-05-01 18:22:10 +02:00
|
|
|
/* got a repeat but we have nothing to repeat */
|
2017-12-03 02:30:37 +01:00
|
|
|
trace_gdbstub_err_invalid_rle();
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.state = RS_GETLINE;
|
2017-05-01 18:22:10 +02:00
|
|
|
} else {
|
|
|
|
/* repeat the last character */
|
2020-03-16 18:21:34 +01:00
|
|
|
memset(gdbserver_state.line_buf + gdbserver_state.line_buf_index,
|
|
|
|
gdbserver_state.line_buf[gdbserver_state.line_buf_index - 1], repeat);
|
|
|
|
gdbserver_state.line_buf_index += repeat;
|
|
|
|
gdbserver_state.line_sum += ch;
|
|
|
|
gdbserver_state.state = RS_GETLINE;
|
2017-05-01 18:22:10 +02:00
|
|
|
}
|
2003-07-26 14:06:08 +02:00
|
|
|
}
|
|
|
|
break;
|
2004-03-31 20:52:07 +02:00
|
|
|
case RS_CHKSUM1:
|
2017-05-01 18:22:10 +02:00
|
|
|
/* get high hex digit of checksum */
|
|
|
|
if (!isxdigit(ch)) {
|
2019-05-14 20:03:09 +02:00
|
|
|
trace_gdbstub_err_checksum_invalid(ch);
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.state = RS_GETLINE;
|
2017-05-01 18:22:10 +02:00
|
|
|
break;
|
|
|
|
}
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.line_buf[gdbserver_state.line_buf_index] = '\0';
|
|
|
|
gdbserver_state.line_csum = fromhex(ch) << 4;
|
|
|
|
gdbserver_state.state = RS_CHKSUM2;
|
2004-03-31 20:52:07 +02:00
|
|
|
break;
|
|
|
|
case RS_CHKSUM2:
|
2017-05-01 18:22:10 +02:00
|
|
|
/* get low hex digit of checksum */
|
|
|
|
if (!isxdigit(ch)) {
|
2019-05-14 20:03:09 +02:00
|
|
|
trace_gdbstub_err_checksum_invalid(ch);
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.state = RS_GETLINE;
|
2017-05-01 18:22:10 +02:00
|
|
|
break;
|
2004-03-31 20:52:07 +02:00
|
|
|
}
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.line_csum |= fromhex(ch);
|
2017-05-01 18:22:10 +02:00
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
if (gdbserver_state.line_csum != (gdbserver_state.line_sum & 0xff)) {
|
|
|
|
trace_gdbstub_err_checksum_incorrect(gdbserver_state.line_sum, gdbserver_state.line_csum);
|
2017-05-01 18:22:10 +02:00
|
|
|
/* send NAK reply */
|
2007-12-16 04:02:09 +01:00
|
|
|
reply = '-';
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_buffer(&reply, 1);
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.state = RS_IDLE;
|
2003-07-26 14:06:08 +02:00
|
|
|
} else {
|
2017-05-01 18:22:10 +02:00
|
|
|
/* send ACK reply */
|
2007-12-16 04:02:09 +01:00
|
|
|
reply = '+';
|
2023-03-03 03:57:45 +01:00
|
|
|
gdb_put_buffer(&reply, 1);
|
2020-03-16 18:21:34 +01:00
|
|
|
gdbserver_state.state = gdb_handle_packet(gdbserver_state.line_buf);
|
2003-07-26 14:06:08 +02:00
|
|
|
}
|
|
|
|
break;
|
2007-01-28 04:10:55 +01:00
|
|
|
default:
|
|
|
|
abort();
|
2004-03-31 20:52:07 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-07 16:23:45 +01:00
|
|
|
/*
|
|
|
|
* Create the process that will contain all the "orphan" CPUs (that are not
|
|
|
|
* part of a CPU cluster). Note that if this process contains no CPUs, it won't
|
|
|
|
* be attachable and thus will be invisible to the user.
|
|
|
|
*/
|
2023-03-03 03:57:45 +01:00
|
|
|
void gdb_create_default_process(GDBState *s)
|
2019-01-07 16:23:45 +01:00
|
|
|
{
|
|
|
|
GDBProcess *process;
|
|
|
|
int max_pid = 0;
|
|
|
|
|
2020-03-16 18:21:34 +01:00
|
|
|
if (gdbserver_state.process_num) {
|
2019-01-07 16:23:45 +01:00
|
|
|
max_pid = s->processes[s->process_num - 1].pid;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
|
|
|
|
process = &s->processes[s->process_num - 1];
|
|
|
|
|
|
|
|
/* We need an available PID slot for this process */
|
|
|
|
assert(max_pid < UINT32_MAX);
|
|
|
|
|
|
|
|
process->pid = max_pid + 1;
|
|
|
|
process->attached = false;
|
2019-01-07 16:23:46 +01:00
|
|
|
process->target_xml[0] = '\0';
|
2019-01-07 16:23:45 +01:00
|
|
|
}
|
|
|
|
|