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;
118 int gdb_handlesig(CPUState *cpu, int sig)
123 if (!gdbserver_state.init || gdbserver_user_state.fd < 0) {
127 /* disable single step if it was enabled */
128 cpu_single_step(cpu, 0);
132 gdb_set_stop_cpu(cpu);
133 if (gdbserver_state.allow_stop_reply) {
134 g_string_printf(gdbserver_state.str_buf,
135 "T%02xthread:", gdb_target_signal_to_gdb(sig));
136 gdb_append_thread_id(cpu, gdbserver_state.str_buf);
137 g_string_append_c(gdbserver_state.str_buf, ';');
139 gdbserver_state.allow_stop_reply = false;
143 * gdb_put_packet() might have detected that the peer terminated the
146 if (gdbserver_user_state.fd < 0) {
151 gdbserver_state.state = RS_IDLE;
152 gdbserver_user_state.running_state = 0;
153 while (gdbserver_user_state.running_state == 0) {
154 n = read(gdbserver_user_state.fd, buf, 256);
158 for (i = 0; i < n; i++) {
159 gdb_read_byte(buf[i]);
163 * XXX: Connection closed. Should probably wait for another
164 * connection before continuing.
167 close(gdbserver_user_state.fd);
169 gdbserver_user_state.fd = -1;
173 sig = gdbserver_state.signal;
174 gdbserver_state.signal = 0;
178 /* Tell the remote gdb that the process has exited due to SIG. */
179 void gdb_signalled(CPUArchState *env, int sig)
183 if (!gdbserver_state.init || gdbserver_user_state.fd < 0 ||
184 !gdbserver_state.allow_stop_reply) {
188 snprintf(buf, sizeof(buf), "X%02x", gdb_target_signal_to_gdb(sig));
190 gdbserver_state.allow_stop_reply = false;
193 static void gdb_accept_init(int fd)
195 gdb_init_gdbserver_state();
196 gdb_create_default_process(&gdbserver_state);
197 gdbserver_state.processes[0].attached = true;
198 gdbserver_state.c_cpu = gdb_first_attached_cpu();
199 gdbserver_state.g_cpu = gdbserver_state.c_cpu;
200 gdbserver_user_state.fd = fd;
204 static bool gdb_accept_socket(int gdb_fd)
209 fd = accept(gdb_fd, NULL, NULL);
210 if (fd < 0 && errno != EINTR) {
211 perror("accept socket");
213 } else if (fd >= 0) {
214 qemu_set_cloexec(fd);
223 static int gdbserver_open_socket(const char *path)
225 struct sockaddr_un sockaddr = {};
228 fd = socket(AF_UNIX, SOCK_STREAM, 0);
230 perror("create socket");
234 sockaddr.sun_family = AF_UNIX;
235 pstrcpy(sockaddr.sun_path, sizeof(sockaddr.sun_path) - 1, path);
236 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
238 perror("bind socket");
244 perror("listen socket");
252 static bool gdb_accept_tcp(int gdb_fd)
254 struct sockaddr_in sockaddr = {};
259 len = sizeof(sockaddr);
260 fd = accept(gdb_fd, (struct sockaddr *)&sockaddr, &len);
261 if (fd < 0 && errno != EINTR) {
264 } else if (fd >= 0) {
265 qemu_set_cloexec(fd);
270 /* set short latency */
271 if (socket_set_nodelay(fd)) {
272 perror("setsockopt");
281 static int gdbserver_open_port(int port)
283 struct sockaddr_in sockaddr;
286 fd = socket(PF_INET, SOCK_STREAM, 0);
291 qemu_set_cloexec(fd);
293 socket_set_fast_reuse(fd);
295 sockaddr.sin_family = AF_INET;
296 sockaddr.sin_port = htons(port);
297 sockaddr.sin_addr.s_addr = 0;
298 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
314 int gdbserver_start(const char *port_or_path)
316 int port = g_ascii_strtoull(port_or_path, NULL, 10);
320 gdb_fd = gdbserver_open_port(port);
322 gdb_fd = gdbserver_open_socket(port_or_path);
329 if (port > 0 && gdb_accept_tcp(gdb_fd)) {
331 } else if (gdb_accept_socket(gdb_fd)) {
332 gdbserver_user_state.socket_path = g_strdup(port_or_path);
341 /* Disable gdb stub for child processes. */
342 void gdbserver_fork(CPUState *cpu)
344 if (!gdbserver_state.init || gdbserver_user_state.fd < 0) {
347 close(gdbserver_user_state.fd);
348 gdbserver_user_state.fd = -1;
349 cpu_breakpoint_remove_all(cpu, BP_GDB);
350 /* no cpu_watchpoint_remove_all for user-mode */
354 * Execution state helpers
357 void gdb_handle_query_attached(GArray *params, void *user_ctx)
362 void gdb_continue(void)
364 gdbserver_user_state.running_state = 1;
365 trace_gdbstub_op_continue();
369 * Resume execution, for user-mode emulation it's equivalent to
372 int gdb_continue_partial(char *newstates)
377 * This is not exactly accurate, but it's an improvement compared to the
378 * previous situation, where only one CPU would be single-stepped.
381 if (newstates[cpu->cpu_index] == 's') {
382 trace_gdbstub_op_stepping(cpu->cpu_index);
383 cpu_single_step(cpu, gdbserver_state.sstep_flags);
386 gdbserver_user_state.running_state = 1;
391 * Memory access helpers
393 int gdb_target_memory_rw_debug(CPUState *cpu, hwaddr addr,
394 uint8_t *buf, int len, bool is_write)
398 cc = CPU_GET_CLASS(cpu);
399 if (cc->memory_rw_debug) {
400 return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
402 return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
409 unsigned int gdb_get_max_cpus(void)
412 unsigned int max_cpus = 1;
415 max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_index + 1 : max_cpus;
421 /* replay not supported for user-mode */
422 bool gdb_can_reverse(void)
428 * Break/Watch point helpers
431 bool gdb_supports_guest_debug(void)
433 /* user-mode == TCG == supported */
437 int gdb_breakpoint_insert(CPUState *cs, int type, vaddr addr, vaddr len)
443 case GDB_BREAKPOINT_SW:
444 case GDB_BREAKPOINT_HW:
446 err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
453 /* user-mode doesn't support watchpoints */
458 int gdb_breakpoint_remove(CPUState *cs, int type, vaddr addr, vaddr len)
464 case GDB_BREAKPOINT_SW:
465 case GDB_BREAKPOINT_HW:
467 err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
474 /* user-mode doesn't support watchpoints */
479 void gdb_breakpoint_remove_all(CPUState *cs)
481 cpu_breakpoint_remove_all(cs, BP_GDB);
485 * For user-mode syscall support we send the system call immediately
486 * and then return control to gdb for it to process the syscall request.
487 * Since the protocol requires that gdb hands control back to us
488 * using a "here are the results" F packet, we don't need to check
489 * gdb_handlesig's return value (which is the signal to deliver if
490 * execution was resumed via a continue packet).
492 void gdb_syscall_handling(const char *syscall_packet)
494 gdb_put_packet(syscall_packet);
495 gdb_handlesig(gdbserver_state.c_cpu, 0);