2 * gdbstub user-mode helper routines.
4 * We know for user-mode we are using TCG so we can call stuff directly.
6 * Copyright (c) 2003-2005 Fabrice Bellard
7 * Copyright (c) 2022 Linaro Ltd
9 * SPDX-License-Identifier: LGPL-2.0+
12 #include "qemu/osdep.h"
13 #include "qemu/cutils.h"
14 #include "qemu/sockets.h"
15 #include "exec/hwaddr.h"
16 #include "exec/tb-flush.h"
17 #include "exec/gdbstub.h"
18 #include "gdbstub/syscalls.h"
19 #include "gdbstub/user.h"
20 #include "hw/core/cpu.h"
22 #include "internals.h"
24 /* User-mode specific state */
31 static GDBUserState gdbserver_user_state;
33 int gdb_get_char(void)
39 ret = recv(gdbserver_user_state.fd, &ch, 1, 0);
41 if (errno == ECONNRESET) {
42 gdbserver_user_state.fd = -1;
47 } else if (ret == 0) {
48 close(gdbserver_user_state.fd);
49 gdbserver_user_state.fd = -1;
58 bool gdb_got_immediate_ack(void)
64 /* no response, continue anyway */
69 /* received correctly, continue */
73 /* anything else, including '-' then try again */
77 void gdb_put_buffer(const uint8_t *buf, int len)
82 ret = send(gdbserver_user_state.fd, buf, len, 0);
94 /* Tell the remote gdb that the process has exited. */
95 void gdb_exit(int code)
99 if (!gdbserver_state.init) {
102 if (gdbserver_user_state.socket_path) {
103 unlink(gdbserver_user_state.socket_path);
105 if (gdbserver_user_state.fd < 0) {
109 trace_gdbstub_op_exiting((uint8_t)code);
111 if (gdbserver_state.allow_stop_reply) {
112 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
114 gdbserver_state.allow_stop_reply = false;
119 void gdb_qemu_exit(int code)
124 int gdb_handlesig(CPUState *cpu, int sig)
129 if (!gdbserver_state.init || gdbserver_user_state.fd < 0) {
133 /* disable single step if it was enabled */
134 cpu_single_step(cpu, 0);
138 gdb_set_stop_cpu(cpu);
139 if (gdbserver_state.allow_stop_reply) {
140 g_string_printf(gdbserver_state.str_buf,
141 "T%02xthread:", gdb_target_signal_to_gdb(sig));
142 gdb_append_thread_id(cpu, gdbserver_state.str_buf);
143 g_string_append_c(gdbserver_state.str_buf, ';');
145 gdbserver_state.allow_stop_reply = false;
149 * gdb_put_packet() might have detected that the peer terminated the
152 if (gdbserver_user_state.fd < 0) {
157 gdbserver_state.state = RS_IDLE;
158 gdbserver_user_state.running_state = 0;
159 while (gdbserver_user_state.running_state == 0) {
160 n = read(gdbserver_user_state.fd, buf, 256);
164 for (i = 0; i < n; i++) {
165 gdb_read_byte(buf[i]);
169 * XXX: Connection closed. Should probably wait for another
170 * connection before continuing.
173 close(gdbserver_user_state.fd);
175 gdbserver_user_state.fd = -1;
179 sig = gdbserver_state.signal;
180 gdbserver_state.signal = 0;
184 /* Tell the remote gdb that the process has exited due to SIG. */
185 void gdb_signalled(CPUArchState *env, int sig)
189 if (!gdbserver_state.init || gdbserver_user_state.fd < 0 ||
190 !gdbserver_state.allow_stop_reply) {
194 snprintf(buf, sizeof(buf), "X%02x", gdb_target_signal_to_gdb(sig));
196 gdbserver_state.allow_stop_reply = false;
199 static void gdb_accept_init(int fd)
201 gdb_init_gdbserver_state();
202 gdb_create_default_process(&gdbserver_state);
203 gdbserver_state.processes[0].attached = true;
204 gdbserver_state.c_cpu = gdb_first_attached_cpu();
205 gdbserver_state.g_cpu = gdbserver_state.c_cpu;
206 gdbserver_user_state.fd = fd;
209 static bool gdb_accept_socket(int gdb_fd)
214 fd = accept(gdb_fd, NULL, NULL);
215 if (fd < 0 && errno != EINTR) {
216 perror("accept socket");
218 } else if (fd >= 0) {
219 qemu_set_cloexec(fd);
228 static int gdbserver_open_socket(const char *path)
230 struct sockaddr_un sockaddr = {};
233 fd = socket(AF_UNIX, SOCK_STREAM, 0);
235 perror("create socket");
239 sockaddr.sun_family = AF_UNIX;
240 pstrcpy(sockaddr.sun_path, sizeof(sockaddr.sun_path) - 1, path);
241 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
243 perror("bind socket");
249 perror("listen socket");
257 static bool gdb_accept_tcp(int gdb_fd)
259 struct sockaddr_in sockaddr = {};
264 len = sizeof(sockaddr);
265 fd = accept(gdb_fd, (struct sockaddr *)&sockaddr, &len);
266 if (fd < 0 && errno != EINTR) {
269 } else if (fd >= 0) {
270 qemu_set_cloexec(fd);
275 /* set short latency */
276 if (socket_set_nodelay(fd)) {
277 perror("setsockopt");
286 static int gdbserver_open_port(int port)
288 struct sockaddr_in sockaddr;
291 fd = socket(PF_INET, SOCK_STREAM, 0);
296 qemu_set_cloexec(fd);
298 socket_set_fast_reuse(fd);
300 sockaddr.sin_family = AF_INET;
301 sockaddr.sin_port = htons(port);
302 sockaddr.sin_addr.s_addr = 0;
303 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
319 int gdbserver_start(const char *port_or_path)
321 int port = g_ascii_strtoull(port_or_path, NULL, 10);
325 gdb_fd = gdbserver_open_port(port);
327 gdb_fd = gdbserver_open_socket(port_or_path);
334 if (port > 0 && gdb_accept_tcp(gdb_fd)) {
336 } else if (gdb_accept_socket(gdb_fd)) {
337 gdbserver_user_state.socket_path = g_strdup(port_or_path);
346 /* Disable gdb stub for child processes. */
347 void gdbserver_fork(CPUState *cpu)
349 if (!gdbserver_state.init || gdbserver_user_state.fd < 0) {
352 close(gdbserver_user_state.fd);
353 gdbserver_user_state.fd = -1;
354 cpu_breakpoint_remove_all(cpu, BP_GDB);
355 /* no cpu_watchpoint_remove_all for user-mode */
359 * Execution state helpers
362 void gdb_handle_query_attached(GArray *params, void *user_ctx)
367 void gdb_continue(void)
369 gdbserver_user_state.running_state = 1;
370 trace_gdbstub_op_continue();
374 * Resume execution, for user-mode emulation it's equivalent to
377 int gdb_continue_partial(char *newstates)
382 * This is not exactly accurate, but it's an improvement compared to the
383 * previous situation, where only one CPU would be single-stepped.
386 if (newstates[cpu->cpu_index] == 's') {
387 trace_gdbstub_op_stepping(cpu->cpu_index);
388 cpu_single_step(cpu, gdbserver_state.sstep_flags);
391 gdbserver_user_state.running_state = 1;
396 * Memory access helpers
398 int gdb_target_memory_rw_debug(CPUState *cpu, hwaddr addr,
399 uint8_t *buf, int len, bool is_write)
403 cc = CPU_GET_CLASS(cpu);
404 if (cc->memory_rw_debug) {
405 return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
407 return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
414 unsigned int gdb_get_max_cpus(void)
417 unsigned int max_cpus = 1;
420 max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_index + 1 : max_cpus;
426 /* replay not supported for user-mode */
427 bool gdb_can_reverse(void)
433 * Break/Watch point helpers
436 bool gdb_supports_guest_debug(void)
438 /* user-mode == TCG == supported */
442 int gdb_breakpoint_insert(CPUState *cs, int type, vaddr addr, vaddr len)
448 case GDB_BREAKPOINT_SW:
449 case GDB_BREAKPOINT_HW:
451 err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
458 /* user-mode doesn't support watchpoints */
463 int gdb_breakpoint_remove(CPUState *cs, int type, vaddr addr, vaddr len)
469 case GDB_BREAKPOINT_SW:
470 case GDB_BREAKPOINT_HW:
472 err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
479 /* user-mode doesn't support watchpoints */
484 void gdb_breakpoint_remove_all(CPUState *cs)
486 cpu_breakpoint_remove_all(cs, BP_GDB);
490 * For user-mode syscall support we send the system call immediately
491 * and then return control to gdb for it to process the syscall request.
492 * Since the protocol requires that gdb hands control back to us
493 * using a "here are the results" F packet, we don't need to check
494 * gdb_handlesig's return value (which is the signal to deliver if
495 * execution was resumed via a continue packet).
497 void gdb_syscall_handling(const char *syscall_packet)
499 gdb_put_packet(syscall_packet);
500 gdb_handlesig(gdbserver_state.c_cpu, 0);