#include "qemu/cutils.h"
#include "qemu/module.h"
#include "trace/trace-root.h"
+#include "exec/gdbstub.h"
#ifdef CONFIG_USER_ONLY
#include "qemu.h"
#else
#include "monitor/monitor.h"
#include "chardev/char.h"
#include "chardev/char-fe.h"
-#include "exec/gdbstub.h"
#include "hw/cpu/cluster.h"
#include "hw/boards.h"
#endif
{
#if defined(CONFIG_USER_ONLY)
TaskState *ts = (TaskState *) cpu->opaque;
- return ts->ts_tid;
+ return ts ? ts->ts_tid : -1;
#else
return cpu->cpu_index + 1;
#endif
gdb_syscall_complete_cb current_syscall_cb;
GString *str_buf;
GByteArray *mem_buf;
+ int sstep_flags;
+ int supported_sstep_flags;
} GDBState;
-/* By default use no IRQs and no timers while single stepping so as to
- * make single stepping like an ICE HW step.
- */
-static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
-
-/* Retrieves flags for single step mode. */
-static int get_sstep_flags(void)
-{
- /*
- * In replay mode all events written into the log should be replayed.
- * That is why NOIRQ flag is removed in this mode.
- */
- if (replay_mode != REPLAY_MODE_NONE) {
- return SSTEP_ENABLE;
- } else {
- return sstep_flags;
- }
-}
-
static GDBState gdbserver_state;
static void init_gdbserver_state(void)
gdbserver_state.str_buf = g_string_new(NULL);
gdbserver_state.mem_buf = g_byte_array_sized_new(MAX_PACKET_LENGTH);
gdbserver_state.last_packet = g_byte_array_sized_new(MAX_PACKET_LENGTH + 4);
+
+ /*
+ * In replay mode all events will come from the log and can't be
+ * suppressed otherwise we would break determinism. However as those
+ * events are tied to the number of executed instructions we won't see
+ * them occurring every time we single step.
+ */
+ if (replay_mode != REPLAY_MODE_NONE) {
+ gdbserver_state.supported_sstep_flags = SSTEP_ENABLE;
+ } else if (kvm_enabled()) {
+ gdbserver_state.supported_sstep_flags = kvm_get_supported_sstep_flags();
+ } else {
+ gdbserver_state.supported_sstep_flags =
+ SSTEP_ENABLE | SSTEP_NOIRQ | SSTEP_NOTIMER;
+ }
+
+ /*
+ * By default use no IRQs and no timers while single stepping so as to
+ * make single stepping like an ICE HW step.
+ */
+ gdbserver_state.sstep_flags = SSTEP_ENABLE | SSTEP_NOIRQ | SSTEP_NOTIMER;
+ gdbserver_state.sstep_flags &= gdbserver_state.supported_sstep_flags;
+
}
#ifndef CONFIG_USER_ONLY
return gdb_syscall_mode == GDB_SYS_ENABLED;
}
+static bool stub_can_reverse(void)
+{
+#ifdef CONFIG_USER_ONLY
+ return false;
+#else
+ return replay_mode == REPLAY_MODE_PLAY;
+#endif
+}
+
/* Resume execution. */
static inline void gdb_continue(void)
{
CPU_FOREACH(cpu) {
if (newstates[cpu->cpu_index] == 's') {
trace_gdbstub_op_stepping(cpu->cpu_index);
- cpu_single_step(cpu, sstep_flags);
+ cpu_single_step(cpu, gdbserver_state.sstep_flags);
}
}
gdbserver_state.running_state = 1;
break; /* nothing to do here */
case 's':
trace_gdbstub_op_stepping(cpu->cpu_index);
- cpu_single_step(cpu, get_sstep_flags());
+ cpu_single_step(cpu, gdbserver_state.sstep_flags);
cpu_resume(cpu);
flag = 1;
break;
gdb_set_cpu_pc((target_ulong)get_param(params, 0)->val_ull);
}
- cpu_single_step(gdbserver_state.c_cpu, get_sstep_flags());
+ cpu_single_step(gdbserver_state.c_cpu, gdbserver_state.sstep_flags);
gdb_continue();
}
static void handle_backward(GArray *params, void *user_ctx)
{
- if (replay_mode != REPLAY_MODE_PLAY) {
+ if (!stub_can_reverse()) {
put_packet("E22");
}
if (params->len == 1) {
static void handle_query_qemu_sstepbits(GArray *params, void *user_ctx)
{
- g_string_printf(gdbserver_state.str_buf, "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
- SSTEP_ENABLE, SSTEP_NOIRQ, SSTEP_NOTIMER);
+ 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);
+ }
+
put_strbuf();
}
static void handle_set_qemu_sstep(GArray *params, void *user_ctx)
{
+ int new_sstep_flags;
+
if (!params->len) {
return;
}
- sstep_flags = get_param(params, 0)->val_ul;
+ new_sstep_flags = get_param(params, 0)->val_ul;
+
+ if (new_sstep_flags & ~gdbserver_state.supported_sstep_flags) {
+ put_packet("E22");
+ return;
+ }
+
+ gdbserver_state.sstep_flags = new_sstep_flags;
put_packet("OK");
}
static void handle_query_qemu_sstep(GArray *params, void *user_ctx)
{
- g_string_printf(gdbserver_state.str_buf, "0x%x", sstep_flags);
+ g_string_printf(gdbserver_state.str_buf, "0x%x",
+ gdbserver_state.sstep_flags);
put_strbuf();
}
g_string_append(gdbserver_state.str_buf, ";qXfer:features:read+");
}
- if (replay_mode == REPLAY_MODE_PLAY) {
+ if (stub_can_reverse()) {
g_string_append(gdbserver_state.str_buf,
";ReverseStep+;ReverseContinue+");
}
tb_flush(cpu);
if (sig != 0) {
- snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
- put_packet(buf);
+ gdb_set_stop_cpu(cpu);
+ g_string_printf(gdbserver_state.str_buf,
+ "T%02xthread:", target_signal_to_gdb(sig));
+ gdb_append_thread_id(cpu, gdbserver_state.str_buf);
+ g_string_append_c(gdbserver_state.str_buf, ';');
+ put_strbuf();
}
/* put_packet() might have detected that the peer terminated the
connection. */
static int gdbserver_open_socket(const char *path)
{
- struct sockaddr_un sockaddr;
+ struct sockaddr_un sockaddr = {};
int fd, ret;
fd = socket(AF_UNIX, SOCK_STREAM, 0);
static bool gdb_accept_tcp(int gdb_fd)
{
- struct sockaddr_in sockaddr;
+ struct sockaddr_in sockaddr = {};
socklen_t len;
int fd;
return -1;
}
+ if (kvm_enabled() && !kvm_supports_guest_debug()) {
+ error_report("gdbstub: KVM doesn't support guest debugging");
+ return -1;
+ }
+
if (!device)
return -1;
if (strcmp(device, "none") != 0) {