2 * gdb server stub - softmmu specific bits
4 * Debug integration depends on support from the individual
5 * accelerators so most of this involves calling the ops helpers.
7 * Copyright (c) 2003-2005 Fabrice Bellard
8 * Copyright (c) 2022 Linaro Ltd
10 * SPDX-License-Identifier: LGPL-2.0+
13 #include "qemu/osdep.h"
14 #include "qapi/error.h"
15 #include "qemu/error-report.h"
16 #include "qemu/cutils.h"
17 #include "exec/gdbstub.h"
18 #include "gdbstub/syscalls.h"
19 #include "exec/hwaddr.h"
20 #include "exec/tb-flush.h"
21 #include "sysemu/cpus.h"
22 #include "sysemu/runstate.h"
23 #include "sysemu/replay.h"
24 #include "hw/core/cpu.h"
25 #include "hw/cpu/cluster.h"
26 #include "hw/boards.h"
27 #include "chardev/char.h"
28 #include "chardev/char-fe.h"
29 #include "monitor/monitor.h"
31 #include "internals.h"
33 /* System emulation specific state */
39 GDBSystemState gdbserver_system_state
;
41 static void reset_gdbserver_state(void)
43 g_free(gdbserver_state
.processes
);
44 gdbserver_state
.processes
= NULL
;
45 gdbserver_state
.process_num
= 0;
46 gdbserver_state
.allow_stop_reply
= false;
50 * Return the GDB index for a given vCPU state.
52 * In system mode GDB numbers CPUs from 1 as 0 is reserved as an "any
55 int gdb_get_cpu_index(CPUState
*cpu
)
57 return cpu
->cpu_index
+ 1;
61 * We check the status of the last message in the chardev receive code
63 bool gdb_got_immediate_ack(void)
69 * GDB Connection management. For system emulation we do all of this
70 * via our existing Chardev infrastructure which allows us to support
71 * network and unix sockets.
74 void gdb_put_buffer(const uint8_t *buf
, int len
)
77 * XXX this blocks entire thread. Rewrite to use
78 * qemu_chr_fe_write and background I/O callbacks
80 qemu_chr_fe_write_all(&gdbserver_system_state
.chr
, buf
, len
);
83 static void gdb_chr_event(void *opaque
, QEMUChrEvent event
)
86 GDBState
*s
= (GDBState
*) opaque
;
89 case CHR_EVENT_OPENED
:
90 /* Start with first process attached, others detached */
91 for (i
= 0; i
< s
->process_num
; i
++) {
92 s
->processes
[i
].attached
= !i
;
95 s
->c_cpu
= gdb_first_attached_cpu();
98 vm_stop(RUN_STATE_PAUSED
);
99 replay_gdb_attached();
108 * In softmmu mode we stop the VM and wait to send the syscall packet
109 * until notification that the CPU has stopped. This must be done
110 * because if the packet is sent now the reply from the syscall
111 * request could be received while the CPU is still in the running
112 * state, which can cause packets to be dropped and state transition
113 * 'T' packets to be sent while the syscall is still being processed.
115 void gdb_syscall_handling(const char *syscall_packet
)
117 vm_stop(RUN_STATE_DEBUG
);
118 qemu_cpu_kick(gdbserver_state
.c_cpu
);
121 static void gdb_vm_state_change(void *opaque
, bool running
, RunState state
)
123 CPUState
*cpu
= gdbserver_state
.c_cpu
;
124 g_autoptr(GString
) buf
= g_string_new(NULL
);
125 g_autoptr(GString
) tid
= g_string_new(NULL
);
129 if (running
|| gdbserver_state
.state
== RS_INACTIVE
) {
133 /* Is there a GDB syscall waiting to be sent? */
134 if (gdb_handled_syscall()) {
139 /* No process attached */
143 if (!gdbserver_state
.allow_stop_reply
) {
147 gdb_append_thread_id(cpu
, tid
);
150 case RUN_STATE_DEBUG
:
151 if (cpu
->watchpoint_hit
) {
152 switch (cpu
->watchpoint_hit
->flags
& BP_MEM_ACCESS
) {
163 trace_gdbstub_hit_watchpoint(type
,
164 gdb_get_cpu_index(cpu
),
165 cpu
->watchpoint_hit
->vaddr
);
166 g_string_printf(buf
, "T%02xthread:%s;%swatch:%" VADDR_PRIx
";",
167 GDB_SIGNAL_TRAP
, tid
->str
, type
,
168 cpu
->watchpoint_hit
->vaddr
);
169 cpu
->watchpoint_hit
= NULL
;
172 trace_gdbstub_hit_break();
175 ret
= GDB_SIGNAL_TRAP
;
177 case RUN_STATE_PAUSED
:
178 trace_gdbstub_hit_paused();
179 ret
= GDB_SIGNAL_INT
;
181 case RUN_STATE_SHUTDOWN
:
182 trace_gdbstub_hit_shutdown();
183 ret
= GDB_SIGNAL_QUIT
;
185 case RUN_STATE_IO_ERROR
:
186 trace_gdbstub_hit_io_error();
189 case RUN_STATE_WATCHDOG
:
190 trace_gdbstub_hit_watchdog();
191 ret
= GDB_SIGNAL_ALRM
;
193 case RUN_STATE_INTERNAL_ERROR
:
194 trace_gdbstub_hit_internal_error();
195 ret
= GDB_SIGNAL_ABRT
;
197 case RUN_STATE_SAVE_VM
:
198 case RUN_STATE_RESTORE_VM
:
200 case RUN_STATE_FINISH_MIGRATE
:
201 ret
= GDB_SIGNAL_XCPU
;
204 trace_gdbstub_hit_unknown(state
);
205 ret
= GDB_SIGNAL_UNKNOWN
;
208 gdb_set_stop_cpu(cpu
);
209 g_string_printf(buf
, "T%02xthread:%s;", ret
, tid
->str
);
212 gdb_put_packet(buf
->str
);
213 gdbserver_state
.allow_stop_reply
= false;
215 /* disable single step if it was enabled */
216 cpu_single_step(cpu
, 0);
220 static void gdb_sigterm_handler(int signal
)
222 if (runstate_is_running()) {
223 vm_stop(RUN_STATE_PAUSED
);
228 static int gdb_monitor_write(Chardev
*chr
, const uint8_t *buf
, int len
)
230 g_autoptr(GString
) hex_buf
= g_string_new("O");
231 gdb_memtohex(hex_buf
, buf
, len
);
232 gdb_put_packet(hex_buf
->str
);
236 static void gdb_monitor_open(Chardev
*chr
, ChardevBackend
*backend
,
237 bool *be_opened
, Error
**errp
)
242 static void char_gdb_class_init(ObjectClass
*oc
, void *data
)
244 ChardevClass
*cc
= CHARDEV_CLASS(oc
);
247 cc
->open
= gdb_monitor_open
;
248 cc
->chr_write
= gdb_monitor_write
;
251 #define TYPE_CHARDEV_GDB "chardev-gdb"
253 static const TypeInfo char_gdb_type_info
= {
254 .name
= TYPE_CHARDEV_GDB
,
255 .parent
= TYPE_CHARDEV
,
256 .class_init
= char_gdb_class_init
,
259 static int gdb_chr_can_receive(void *opaque
)
262 * We can handle an arbitrarily large amount of data.
263 * Pick the maximum packet size, which is as good as anything.
265 return MAX_PACKET_LENGTH
;
268 static void gdb_chr_receive(void *opaque
, const uint8_t *buf
, int size
)
272 for (i
= 0; i
< size
; i
++) {
273 gdb_read_byte(buf
[i
]);
277 static int find_cpu_clusters(Object
*child
, void *opaque
)
279 if (object_dynamic_cast(child
, TYPE_CPU_CLUSTER
)) {
280 GDBState
*s
= (GDBState
*) opaque
;
281 CPUClusterState
*cluster
= CPU_CLUSTER(child
);
284 s
->processes
= g_renew(GDBProcess
, s
->processes
, ++s
->process_num
);
286 process
= &s
->processes
[s
->process_num
- 1];
289 * GDB process IDs -1 and 0 are reserved. To avoid subtle errors at
290 * runtime, we enforce here that the machine does not use a cluster ID
291 * that would lead to PID 0.
293 assert(cluster
->cluster_id
!= UINT32_MAX
);
294 process
->pid
= cluster
->cluster_id
+ 1;
295 process
->attached
= false;
296 process
->target_xml
[0] = '\0';
301 return object_child_foreach(child
, find_cpu_clusters
, opaque
);
304 static int pid_order(const void *a
, const void *b
)
306 GDBProcess
*pa
= (GDBProcess
*) a
;
307 GDBProcess
*pb
= (GDBProcess
*) b
;
309 if (pa
->pid
< pb
->pid
) {
311 } else if (pa
->pid
> pb
->pid
) {
318 static void create_processes(GDBState
*s
)
320 object_child_foreach(object_get_root(), find_cpu_clusters
, s
);
322 if (gdbserver_state
.processes
) {
324 qsort(gdbserver_state
.processes
,
325 gdbserver_state
.process_num
,
326 sizeof(gdbserver_state
.processes
[0]),
330 gdb_create_default_process(s
);
333 int gdbserver_start(const char *device
)
337 g_autoptr(GString
) cs
= g_string_new(device
);
340 error_report("gdbstub: meaningless to attach gdb to a "
341 "machine without any CPU.");
345 if (!gdb_supports_guest_debug()) {
346 error_report("gdbstub: current accelerator doesn't "
347 "support guest debugging");
355 trace_gdbstub_op_start(cs
->str
);
357 if (g_strcmp0(cs
->str
, "none") != 0) {
358 if (g_str_has_prefix(cs
->str
, "tcp:")) {
359 /* enforce required TCP attributes */
360 g_string_append_printf(cs
, ",wait=off,nodelay=on,server=on");
363 else if (strcmp(device
, "stdio") == 0) {
364 struct sigaction act
;
366 memset(&act
, 0, sizeof(act
));
367 act
.sa_handler
= gdb_sigterm_handler
;
368 sigaction(SIGINT
, &act
, NULL
);
372 * FIXME: it's a bit weird to allow using a mux chardev here
373 * and implicitly setup a monitor. We may want to break this.
375 chr
= qemu_chr_new_noreplay("gdb", cs
->str
, true, NULL
);
381 if (!gdbserver_state
.init
) {
382 gdb_init_gdbserver_state();
384 qemu_add_vm_change_state_handler(gdb_vm_state_change
, NULL
);
386 /* Initialize a monitor terminal for gdb */
387 mon_chr
= qemu_chardev_new(NULL
, TYPE_CHARDEV_GDB
,
388 NULL
, NULL
, &error_abort
);
389 monitor_init_hmp(mon_chr
, false, &error_abort
);
391 qemu_chr_fe_deinit(&gdbserver_system_state
.chr
, true);
392 mon_chr
= gdbserver_system_state
.mon_chr
;
393 reset_gdbserver_state();
396 create_processes(&gdbserver_state
);
399 qemu_chr_fe_init(&gdbserver_system_state
.chr
, chr
, &error_abort
);
400 qemu_chr_fe_set_handlers(&gdbserver_system_state
.chr
,
402 gdb_chr_receive
, gdb_chr_event
,
403 NULL
, &gdbserver_state
, NULL
, true);
405 gdbserver_state
.state
= chr
? RS_IDLE
: RS_INACTIVE
;
406 gdbserver_system_state
.mon_chr
= mon_chr
;
412 static void register_types(void)
414 type_register_static(&char_gdb_type_info
);
417 type_init(register_types
);
419 /* Tell the remote gdb that the process has exited. */
420 void gdb_exit(int code
)
424 if (!gdbserver_state
.init
) {
428 trace_gdbstub_op_exiting((uint8_t)code
);
430 if (gdbserver_state
.allow_stop_reply
) {
431 snprintf(buf
, sizeof(buf
), "W%02x", (uint8_t)code
);
433 gdbserver_state
.allow_stop_reply
= false;
436 qemu_chr_fe_deinit(&gdbserver_system_state
.chr
, true);
442 static int phy_memory_mode
;
444 int gdb_target_memory_rw_debug(CPUState
*cpu
, hwaddr addr
,
445 uint8_t *buf
, int len
, bool is_write
)
449 if (phy_memory_mode
) {
451 cpu_physical_memory_write(addr
, buf
, len
);
453 cpu_physical_memory_read(addr
, buf
, len
);
458 cc
= CPU_GET_CLASS(cpu
);
459 if (cc
->memory_rw_debug
) {
460 return cc
->memory_rw_debug(cpu
, addr
, buf
, len
, is_write
);
463 return cpu_memory_rw_debug(cpu
, addr
, buf
, len
, is_write
);
470 unsigned int gdb_get_max_cpus(void)
472 MachineState
*ms
= MACHINE(qdev_get_machine());
473 return ms
->smp
.max_cpus
;
476 bool gdb_can_reverse(void)
478 return replay_mode
== REPLAY_MODE_PLAY
;
482 * Softmmu specific command helpers
485 void gdb_handle_query_qemu_phy_mem_mode(GArray
*params
,
488 g_string_printf(gdbserver_state
.str_buf
, "%d", phy_memory_mode
);
492 void gdb_handle_set_qemu_phy_mem_mode(GArray
*params
, void *user_ctx
)
495 gdb_put_packet("E22");
499 if (!get_param(params
, 0)->val_ul
) {
504 gdb_put_packet("OK");
507 void gdb_handle_query_rcmd(GArray
*params
, void *user_ctx
)
509 const guint8 zero
= 0;
513 gdb_put_packet("E22");
517 len
= strlen(get_param(params
, 0)->data
);
519 gdb_put_packet("E01");
523 g_assert(gdbserver_state
.mem_buf
->len
== 0);
525 gdb_hextomem(gdbserver_state
.mem_buf
, get_param(params
, 0)->data
, len
);
526 g_byte_array_append(gdbserver_state
.mem_buf
, &zero
, 1);
527 qemu_chr_be_write(gdbserver_system_state
.mon_chr
,
528 gdbserver_state
.mem_buf
->data
,
529 gdbserver_state
.mem_buf
->len
);
530 gdb_put_packet("OK");
534 * Execution state helpers
537 void gdb_handle_query_attached(GArray
*params
, void *user_ctx
)
542 void gdb_continue(void)
544 if (!runstate_needs_reset()) {
545 trace_gdbstub_op_continue();
551 * Resume execution, per CPU actions.
553 int gdb_continue_partial(char *newstates
)
559 if (!runstate_needs_reset()) {
560 bool step_requested
= false;
562 if (newstates
[cpu
->cpu_index
] == 's') {
563 step_requested
= true;
568 if (vm_prepare_start(step_requested
)) {
573 switch (newstates
[cpu
->cpu_index
]) {
576 break; /* nothing to do here */
578 trace_gdbstub_op_stepping(cpu
->cpu_index
);
579 cpu_single_step(cpu
, gdbserver_state
.sstep_flags
);
584 trace_gdbstub_op_continue_cpu(cpu
->cpu_index
);
595 qemu_clock_enable(QEMU_CLOCK_VIRTUAL
, true);
601 * Signal Handling - in system mode we only need SIGINT and SIGTRAP; other
602 * signals are not yet supported.
610 int gdb_signal_to_target(int sig
)
614 return TARGET_SIGINT
;
616 return TARGET_SIGTRAP
;
623 * Break/Watch point helpers
626 bool gdb_supports_guest_debug(void)
628 const AccelOpsClass
*ops
= cpus_get_accel();
629 if (ops
->supports_guest_debug
) {
630 return ops
->supports_guest_debug();
635 int gdb_breakpoint_insert(CPUState
*cs
, int type
, vaddr addr
, vaddr len
)
637 const AccelOpsClass
*ops
= cpus_get_accel();
638 if (ops
->insert_breakpoint
) {
639 return ops
->insert_breakpoint(cs
, type
, addr
, len
);
644 int gdb_breakpoint_remove(CPUState
*cs
, int type
, vaddr addr
, vaddr len
)
646 const AccelOpsClass
*ops
= cpus_get_accel();
647 if (ops
->remove_breakpoint
) {
648 return ops
->remove_breakpoint(cs
, type
, addr
, len
);
653 void gdb_breakpoint_remove_all(CPUState
*cs
)
655 const AccelOpsClass
*ops
= cpus_get_accel();
656 if (ops
->remove_all_breakpoints
) {
657 ops
->remove_all_breakpoints(cs
);