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);