1 /*
2 * gdbstub user-mode helper routines.
3 *
4 * We know for user-mode we are using TCG so we can call stuff directly.
5 *
6 * Copyright (c) 2003-2005 Fabrice Bellard
7 * Copyright (c) 2022 Linaro Ltd
8 *
9 * SPDX-License-Identifier: LGPL-2.0+
10 */
11
12 #include "qemu/osdep.h"
13 #include "qemu/bitops.h"
14 #include "qemu/cutils.h"
15 #include "qemu/sockets.h"
16 #include "exec/hwaddr.h"
17 #include "exec/tb-flush.h"
18 #include "exec/gdbstub.h"
19 #include "gdbstub/commands.h"
20 #include "gdbstub/syscalls.h"
21 #include "gdbstub/user.h"
22 #include "gdbstub/enums.h"
23 #include "hw/core/cpu.h"
24 #include "trace.h"
25 #include "internals.h"
26
27 #define GDB_NR_SYSCALLS 1024
28 typedef unsigned long GDBSyscallsMask[BITS_TO_LONGS(GDB_NR_SYSCALLS)];
29
30 /*
31 * Forked child talks to its parent in order to let GDB enforce the
32 * follow-fork-mode. This happens inside a start_exclusive() section, so that
33 * the other threads, which may be forking too, do not interfere. The
34 * implementation relies on GDB not sending $vCont until it has detached
35 * either from the parent (follow-fork-mode child) or from the child
36 * (follow-fork-mode parent).
37 *
38 * The parent and the child share the GDB socket; at any given time only one
39 * of them is allowed to use it, as is reflected in the respective fork_state.
40 * This is negotiated via the fork_sockets pair as a reaction to $Hg.
41 *
42 * Below is a short summary of the possible state transitions:
43 *
44 * ENABLED : Terminal state.
45 * DISABLED : Terminal state.
46 * ACTIVE : Parent initial state.
47 * INACTIVE : Child initial state.
48 * ACTIVE -> DEACTIVATING: On $Hg.
49 * ACTIVE -> ENABLING : On $D.
50 * ACTIVE -> DISABLING : On $D.
51 * ACTIVE -> DISABLED : On communication error.
52 * DEACTIVATING -> INACTIVE : On gdb_read_byte() return.
53 * DEACTIVATING -> DISABLED : On communication error.
54 * INACTIVE -> ACTIVE : On $Hg in the peer.
55 * INACTIVE -> ENABLE : On $D in the peer.
56 * INACTIVE -> DISABLE : On $D in the peer.
57 * INACTIVE -> DISABLED : On communication error.
58 * ENABLING -> ENABLED : On gdb_read_byte() return.
59 * ENABLING -> DISABLED : On communication error.
60 * DISABLING -> DISABLED : On gdb_read_byte() return.
61 */
62 enum GDBForkState {
63 /* Fully owning the GDB socket. */
64 GDB_FORK_ENABLED,
65 /* Working with the GDB socket; the peer is inactive. */
66 GDB_FORK_ACTIVE,
67 /* Handing off the GDB socket to the peer. */
68 GDB_FORK_DEACTIVATING,
69 /* The peer is working with the GDB socket. */
70 GDB_FORK_INACTIVE,
71 /* Asking the peer to close its GDB socket fd. */
72 GDB_FORK_ENABLING,
73 /* Asking the peer to take over, closing our GDB socket fd. */
74 GDB_FORK_DISABLING,
75 /* The peer has taken over, our GDB socket fd is closed. */
76 GDB_FORK_DISABLED,
77 };
78
79 enum GDBForkMessage {
80 GDB_FORK_ACTIVATE = 'a',
81 GDB_FORK_ENABLE = 'e',
82 GDB_FORK_DISABLE = 'd',
83 };
84
85 /* User-mode specific state */
86 typedef struct {
87 int fd;
88 char *socket_path;
89 int running_state;
90 /*
91 * Store syscalls mask without memory allocation in order to avoid
92 * implementing synchronization.
93 */
94 bool catch_all_syscalls;
95 GDBSyscallsMask catch_syscalls_mask;
96 bool fork_events;
97 enum GDBForkState fork_state;
98 int fork_sockets[2];
99 pid_t fork_peer_pid, fork_peer_tid;
100 uint8_t siginfo[MAX_SIGINFO_LENGTH];
101 unsigned long siginfo_len;
102 } GDBUserState;
103
104 static GDBUserState gdbserver_user_state;
105
gdb_get_char(void)106 int gdb_get_char(void)
107 {
108 uint8_t ch;
109 int ret;
110
111 for (;;) {
112 ret = recv(gdbserver_user_state.fd, &ch, 1, 0);
113 if (ret < 0) {
114 if (errno == ECONNRESET) {
115 gdbserver_user_state.fd = -1;
116 }
117 if (errno != EINTR) {
118 return -1;
119 }
120 } else if (ret == 0) {
121 close(gdbserver_user_state.fd);
122 gdbserver_user_state.fd = -1;
123 return -1;
124 } else {
125 break;
126 }
127 }
128 return ch;
129 }
130
gdb_got_immediate_ack(void)131 bool gdb_got_immediate_ack(void)
132 {
133 int i;
134
135 i = gdb_get_char();
136 if (i < 0) {
137 /* no response, continue anyway */
138 return true;
139 }
140
141 if (i == '+') {
142 /* received correctly, continue */
143 return true;
144 }
145
146 /* anything else, including '-' then try again */
147 return false;
148 }
149
gdb_put_buffer(const uint8_t * buf,int len)150 void gdb_put_buffer(const uint8_t *buf, int len)
151 {
152 int ret;
153
154 while (len > 0) {
155 ret = send(gdbserver_user_state.fd, buf, len, 0);
156 if (ret < 0) {
157 if (errno != EINTR) {
158 return;
159 }
160 } else {
161 buf += ret;
162 len -= ret;
163 }
164 }
165 }
166
167 /* Tell the remote gdb that the process has exited. */
gdb_exit(int code)168 void gdb_exit(int code)
169 {
170 char buf[4];
171
172 if (!gdbserver_state.init) {
173 return;
174 }
175 if (gdbserver_user_state.socket_path) {
176 unlink(gdbserver_user_state.socket_path);
177 }
178 if (gdbserver_user_state.fd < 0) {
179 return;
180 }
181
182 trace_gdbstub_op_exiting((uint8_t)code);
183
184 if (gdbserver_state.allow_stop_reply) {
185 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
186 gdb_put_packet(buf);
187 gdbserver_state.allow_stop_reply = false;
188 }
189
190 }
191
gdb_qemu_exit(int code)192 void gdb_qemu_exit(int code)
193 {
194 exit(code);
195 }
196
gdb_handlesig(CPUState * cpu,int sig,const char * reason,void * siginfo,int siginfo_len)197 int gdb_handlesig(CPUState *cpu, int sig, const char *reason, void *siginfo,
198 int siginfo_len)
199 {
200 char buf[256];
201 int n;
202
203 if (!gdbserver_state.init || gdbserver_user_state.fd < 0) {
204 return sig;
205 }
206
207 if (siginfo) {
208 /*
209 * Save target-specific siginfo.
210 *
211 * siginfo size, i.e. siginfo_len, is asserted at compile-time to fit in
212 * gdbserver_user_state.siginfo, usually in the source file calling
213 * gdb_handlesig. See, for instance, {linux,bsd}-user/signal.c.
214 */
215 memcpy(gdbserver_user_state.siginfo, siginfo, siginfo_len);
216 gdbserver_user_state.siginfo_len = siginfo_len;
217 }
218
219 /* disable single step if it was enabled */
220 cpu_single_step(cpu, 0);
221 tb_flush(cpu);
222
223 if (sig != 0) {
224 gdb_set_stop_cpu(cpu);
225 if (gdbserver_state.allow_stop_reply) {
226 g_string_printf(gdbserver_state.str_buf,
227 "T%02xthread:", gdb_target_signal_to_gdb(sig));
228 gdb_append_thread_id(cpu, gdbserver_state.str_buf);
229 g_string_append_c(gdbserver_state.str_buf, ';');
230 if (reason) {
231 g_string_append(gdbserver_state.str_buf, reason);
232 }
233 gdb_put_strbuf();
234 gdbserver_state.allow_stop_reply = false;
235 }
236 }
237 /*
238 * gdb_put_packet() might have detected that the peer terminated the
239 * connection.
240 */
241 if (gdbserver_user_state.fd < 0) {
242 return sig;
243 }
244
245 sig = 0;
246 gdbserver_state.state = RS_IDLE;
247 gdbserver_user_state.running_state = 0;
248 while (gdbserver_user_state.running_state == 0) {
249 n = read(gdbserver_user_state.fd, buf, 256);
250 if (n > 0) {
251 int i;
252
253 for (i = 0; i < n; i++) {
254 gdb_read_byte(buf[i]);
255 }
256 } else {
257 /*
258 * XXX: Connection closed. Should probably wait for another
259 * connection before continuing.
260 */
261 if (n == 0) {
262 close(gdbserver_user_state.fd);
263 }
264 gdbserver_user_state.fd = -1;
265 return sig;
266 }
267 }
268 sig = gdbserver_state.signal;
269 gdbserver_state.signal = 0;
270 return sig;
271 }
272
273 /* Tell the remote gdb that the process has exited due to SIG. */
gdb_signalled(CPUArchState * env,int sig)274 void gdb_signalled(CPUArchState *env, int sig)
275 {
276 char buf[4];
277
278 if (!gdbserver_state.init || gdbserver_user_state.fd < 0 ||
279 !gdbserver_state.allow_stop_reply) {
280 return;
281 }
282
283 snprintf(buf, sizeof(buf), "X%02x", gdb_target_signal_to_gdb(sig));
284 gdb_put_packet(buf);
285 gdbserver_state.allow_stop_reply = false;
286 }
287
gdb_accept_init(int fd)288 static void gdb_accept_init(int fd)
289 {
290 gdb_init_gdbserver_state();
291 gdb_create_default_process(&gdbserver_state);
292 gdbserver_state.processes[0].attached = true;
293 gdbserver_state.c_cpu = gdb_first_attached_cpu();
294 gdbserver_state.g_cpu = gdbserver_state.c_cpu;
295 gdbserver_user_state.fd = fd;
296 }
297
gdb_accept_socket(int gdb_fd)298 static bool gdb_accept_socket(int gdb_fd)
299 {
300 int fd;
301
302 for (;;) {
303 fd = accept(gdb_fd, NULL, NULL);
304 if (fd < 0 && errno != EINTR) {
305 perror("accept socket");
306 return false;
307 } else if (fd >= 0) {
308 qemu_set_cloexec(fd);
309 break;
310 }
311 }
312
313 gdb_accept_init(fd);
314 return true;
315 }
316
gdbserver_open_socket(const char * path)317 static int gdbserver_open_socket(const char *path)
318 {
319 struct sockaddr_un sockaddr = {};
320 int fd, ret;
321
322 fd = socket(AF_UNIX, SOCK_STREAM, 0);
323 if (fd < 0) {
324 perror("create socket");
325 return -1;
326 }
327
328 sockaddr.sun_family = AF_UNIX;
329 pstrcpy(sockaddr.sun_path, sizeof(sockaddr.sun_path) - 1, path);
330 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
331 if (ret < 0) {
332 perror("bind socket");
333 close(fd);
334 return -1;
335 }
336 ret = listen(fd, 1);
337 if (ret < 0) {
338 perror("listen socket");
339 close(fd);
340 return -1;
341 }
342
343 return fd;
344 }
345
gdb_accept_tcp(int gdb_fd)346 static bool gdb_accept_tcp(int gdb_fd)
347 {
348 struct sockaddr_in sockaddr = {};
349 socklen_t len;
350 int fd;
351
352 for (;;) {
353 len = sizeof(sockaddr);
354 fd = accept(gdb_fd, (struct sockaddr *)&sockaddr, &len);
355 if (fd < 0 && errno != EINTR) {
356 perror("accept");
357 return false;
358 } else if (fd >= 0) {
359 qemu_set_cloexec(fd);
360 break;
361 }
362 }
363
364 /* set short latency */
365 if (socket_set_nodelay(fd)) {
366 perror("setsockopt");
367 close(fd);
368 return false;
369 }
370
371 gdb_accept_init(fd);
372 return true;
373 }
374
gdbserver_open_port(int port)375 static int gdbserver_open_port(int port)
376 {
377 struct sockaddr_in sockaddr;
378 int fd, ret;
379
380 fd = socket(PF_INET, SOCK_STREAM, 0);
381 if (fd < 0) {
382 perror("socket");
383 return -1;
384 }
385 qemu_set_cloexec(fd);
386
387 socket_set_fast_reuse(fd);
388
389 sockaddr.sin_family = AF_INET;
390 sockaddr.sin_port = htons(port);
391 sockaddr.sin_addr.s_addr = 0;
392 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
393 if (ret < 0) {
394 perror("bind");
395 close(fd);
396 return -1;
397 }
398 ret = listen(fd, 1);
399 if (ret < 0) {
400 perror("listen");
401 close(fd);
402 return -1;
403 }
404
405 return fd;
406 }
407
gdbserver_start(const char * port_or_path)408 int gdbserver_start(const char *port_or_path)
409 {
410 int port = g_ascii_strtoull(port_or_path, NULL, 10);
411 int gdb_fd;
412
413 if (port > 0) {
414 gdb_fd = gdbserver_open_port(port);
415 } else {
416 gdb_fd = gdbserver_open_socket(port_or_path);
417 }
418
419 if (gdb_fd < 0) {
420 return -1;
421 }
422
423 if (port > 0 && gdb_accept_tcp(gdb_fd)) {
424 return 0;
425 } else if (gdb_accept_socket(gdb_fd)) {
426 gdbserver_user_state.socket_path = g_strdup(port_or_path);
427 return 0;
428 }
429
430 /* gone wrong */
431 close(gdb_fd);
432 return -1;
433 }
434
gdbserver_fork_start(void)435 void gdbserver_fork_start(void)
436 {
437 if (!gdbserver_state.init || gdbserver_user_state.fd < 0) {
438 return;
439 }
440 if (!gdbserver_user_state.fork_events ||
441 qemu_socketpair(AF_UNIX, SOCK_STREAM, 0,
442 gdbserver_user_state.fork_sockets) < 0) {
443 gdbserver_user_state.fork_state = GDB_FORK_DISABLED;
444 return;
445 }
446 gdbserver_user_state.fork_state = GDB_FORK_INACTIVE;
447 gdbserver_user_state.fork_peer_pid = getpid();
448 gdbserver_user_state.fork_peer_tid = qemu_get_thread_id();
449 }
450
disable_gdbstub(CPUState * thread_cpu)451 static void disable_gdbstub(CPUState *thread_cpu)
452 {
453 CPUState *cpu;
454
455 close(gdbserver_user_state.fd);
456 gdbserver_user_state.fd = -1;
457 CPU_FOREACH(cpu) {
458 cpu_breakpoint_remove_all(cpu, BP_GDB);
459 /* no cpu_watchpoint_remove_all for user-mode */
460 cpu_single_step(cpu, 0);
461 }
462 tb_flush(thread_cpu);
463 }
464
gdbserver_fork_end(CPUState * cpu,pid_t pid)465 void gdbserver_fork_end(CPUState *cpu, pid_t pid)
466 {
467 char b;
468 int fd;
469
470 if (!gdbserver_state.init || gdbserver_user_state.fd < 0) {
471 return;
472 }
473
474 if (pid == -1) {
475 if (gdbserver_user_state.fork_state != GDB_FORK_DISABLED) {
476 g_assert(gdbserver_user_state.fork_state == GDB_FORK_INACTIVE);
477 close(gdbserver_user_state.fork_sockets[0]);
478 close(gdbserver_user_state.fork_sockets[1]);
479 }
480 return;
481 }
482
483 if (gdbserver_user_state.fork_state == GDB_FORK_DISABLED) {
484 if (pid == 0) {
485 disable_gdbstub(cpu);
486 }
487 return;
488 }
489
490 if (pid == 0) {
491 close(gdbserver_user_state.fork_sockets[0]);
492 fd = gdbserver_user_state.fork_sockets[1];
493 g_assert(gdbserver_state.process_num == 1);
494 g_assert(gdbserver_state.processes[0].pid ==
495 gdbserver_user_state.fork_peer_pid);
496 g_assert(gdbserver_state.processes[0].attached);
497 gdbserver_state.processes[0].pid = getpid();
498 } else {
499 close(gdbserver_user_state.fork_sockets[1]);
500 fd = gdbserver_user_state.fork_sockets[0];
501 gdbserver_user_state.fork_state = GDB_FORK_ACTIVE;
502 gdbserver_user_state.fork_peer_pid = pid;
503 gdbserver_user_state.fork_peer_tid = pid;
504
505 if (!gdbserver_state.allow_stop_reply) {
506 goto fail;
507 }
508 g_string_printf(gdbserver_state.str_buf,
509 "T%02xfork:p%02x.%02x;thread:p%02x.%02x;",
510 gdb_target_signal_to_gdb(gdb_target_sigtrap()),
511 pid, pid, (int)getpid(), qemu_get_thread_id());
512 gdb_put_strbuf();
513 }
514
515 gdbserver_state.state = RS_IDLE;
516 gdbserver_state.allow_stop_reply = false;
517 gdbserver_user_state.running_state = 0;
518 for (;;) {
519 switch (gdbserver_user_state.fork_state) {
520 case GDB_FORK_ENABLED:
521 if (gdbserver_user_state.running_state) {
522 close(fd);
523 return;
524 }
525 QEMU_FALLTHROUGH;
526 case GDB_FORK_ACTIVE:
527 if (read(gdbserver_user_state.fd, &b, 1) != 1) {
528 goto fail;
529 }
530 gdb_read_byte(b);
531 break;
532 case GDB_FORK_DEACTIVATING:
533 b = GDB_FORK_ACTIVATE;
534 if (write(fd, &b, 1) != 1) {
535 goto fail;
536 }
537 gdbserver_user_state.fork_state = GDB_FORK_INACTIVE;
538 break;
539 case GDB_FORK_INACTIVE:
540 if (read(fd, &b, 1) != 1) {
541 goto fail;
542 }
543 switch (b) {
544 case GDB_FORK_ACTIVATE:
545 gdbserver_user_state.fork_state = GDB_FORK_ACTIVE;
546 break;
547 case GDB_FORK_ENABLE:
548 gdbserver_user_state.fork_state = GDB_FORK_ENABLED;
549 break;
550 case GDB_FORK_DISABLE:
551 gdbserver_user_state.fork_state = GDB_FORK_DISABLED;
552 break;
553 default:
554 g_assert_not_reached();
555 }
556 break;
557 case GDB_FORK_ENABLING:
558 b = GDB_FORK_DISABLE;
559 if (write(fd, &b, 1) != 1) {
560 goto fail;
561 }
562 gdbserver_user_state.fork_state = GDB_FORK_ENABLED;
563 break;
564 case GDB_FORK_DISABLING:
565 b = GDB_FORK_ENABLE;
566 if (write(fd, &b, 1) != 1) {
567 goto fail;
568 }
569 gdbserver_user_state.fork_state = GDB_FORK_DISABLED;
570 break;
571 case GDB_FORK_DISABLED:
572 close(fd);
573 disable_gdbstub(cpu);
574 return;
575 default:
576 g_assert_not_reached();
577 }
578 }
579
580 fail:
581 close(fd);
582 if (pid == 0) {
583 disable_gdbstub(cpu);
584 }
585 }
586
gdb_handle_query_supported_user(const char * gdb_supported)587 void gdb_handle_query_supported_user(const char *gdb_supported)
588 {
589 if (strstr(gdb_supported, "fork-events+")) {
590 gdbserver_user_state.fork_events = true;
591 }
592 g_string_append(gdbserver_state.str_buf, ";fork-events+");
593 }
594
gdb_handle_set_thread_user(uint32_t pid,uint32_t tid)595 bool gdb_handle_set_thread_user(uint32_t pid, uint32_t tid)
596 {
597 if (gdbserver_user_state.fork_state == GDB_FORK_ACTIVE &&
598 pid == gdbserver_user_state.fork_peer_pid &&
599 tid == gdbserver_user_state.fork_peer_tid) {
600 gdbserver_user_state.fork_state = GDB_FORK_DEACTIVATING;
601 gdb_put_packet("OK");
602 return true;
603 }
604 return false;
605 }
606
gdb_handle_detach_user(uint32_t pid)607 bool gdb_handle_detach_user(uint32_t pid)
608 {
609 bool enable;
610
611 if (gdbserver_user_state.fork_state == GDB_FORK_ACTIVE) {
612 enable = pid == gdbserver_user_state.fork_peer_pid;
613 if (enable || pid == getpid()) {
614 gdbserver_user_state.fork_state = enable ? GDB_FORK_ENABLING :
615 GDB_FORK_DISABLING;
616 gdb_put_packet("OK");
617 return true;
618 }
619 }
620 return false;
621 }
622
623 /*
624 * Execution state helpers
625 */
626
gdb_handle_query_attached(GArray * params,void * user_ctx)627 void gdb_handle_query_attached(GArray *params, void *user_ctx)
628 {
629 gdb_put_packet("0");
630 }
631
gdb_continue(void)632 void gdb_continue(void)
633 {
634 gdbserver_user_state.running_state = 1;
635 trace_gdbstub_op_continue();
636 }
637
638 /*
639 * Resume execution, for user-mode emulation it's equivalent to
640 * gdb_continue.
641 */
gdb_continue_partial(char * newstates)642 int gdb_continue_partial(char *newstates)
643 {
644 CPUState *cpu;
645 int res = 0;
646 /*
647 * This is not exactly accurate, but it's an improvement compared to the
648 * previous situation, where only one CPU would be single-stepped.
649 */
650 CPU_FOREACH(cpu) {
651 if (newstates[cpu->cpu_index] == 's') {
652 trace_gdbstub_op_stepping(cpu->cpu_index);
653 cpu_single_step(cpu, gdbserver_state.sstep_flags);
654 }
655 }
656 gdbserver_user_state.running_state = 1;
657 return res;
658 }
659
660 /*
661 * Memory access helpers
662 */
gdb_target_memory_rw_debug(CPUState * cpu,hwaddr addr,uint8_t * buf,int len,bool is_write)663 int gdb_target_memory_rw_debug(CPUState *cpu, hwaddr addr,
664 uint8_t *buf, int len, bool is_write)
665 {
666 CPUClass *cc;
667
668 cc = CPU_GET_CLASS(cpu);
669 if (cc->memory_rw_debug) {
670 return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
671 }
672 return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
673 }
674
675 /*
676 * cpu helpers
677 */
678
gdb_get_max_cpus(void)679 unsigned int gdb_get_max_cpus(void)
680 {
681 CPUState *cpu;
682 unsigned int max_cpus = 1;
683
684 CPU_FOREACH(cpu) {
685 max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_index + 1 : max_cpus;
686 }
687
688 return max_cpus;
689 }
690
691 /* replay not supported for user-mode */
gdb_can_reverse(void)692 bool gdb_can_reverse(void)
693 {
694 return false;
695 }
696
697 /*
698 * Break/Watch point helpers
699 */
700
gdb_supports_guest_debug(void)701 bool gdb_supports_guest_debug(void)
702 {
703 /* user-mode == TCG == supported */
704 return true;
705 }
706
gdb_breakpoint_insert(CPUState * cs,int type,vaddr addr,vaddr len)707 int gdb_breakpoint_insert(CPUState *cs, int type, vaddr addr, vaddr len)
708 {
709 CPUState *cpu;
710 int err = 0;
711
712 switch (type) {
713 case GDB_BREAKPOINT_SW:
714 case GDB_BREAKPOINT_HW:
715 CPU_FOREACH(cpu) {
716 err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
717 if (err) {
718 break;
719 }
720 }
721 return err;
722 default:
723 /* user-mode doesn't support watchpoints */
724 return -ENOSYS;
725 }
726 }
727
gdb_breakpoint_remove(CPUState * cs,int type,vaddr addr,vaddr len)728 int gdb_breakpoint_remove(CPUState *cs, int type, vaddr addr, vaddr len)
729 {
730 CPUState *cpu;
731 int err = 0;
732
733 switch (type) {
734 case GDB_BREAKPOINT_SW:
735 case GDB_BREAKPOINT_HW:
736 CPU_FOREACH(cpu) {
737 err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
738 if (err) {
739 break;
740 }
741 }
742 return err;
743 default:
744 /* user-mode doesn't support watchpoints */
745 return -ENOSYS;
746 }
747 }
748
gdb_breakpoint_remove_all(CPUState * cs)749 void gdb_breakpoint_remove_all(CPUState *cs)
750 {
751 cpu_breakpoint_remove_all(cs, BP_GDB);
752 }
753
754 /*
755 * For user-mode syscall support we send the system call immediately
756 * and then return control to gdb for it to process the syscall request.
757 * Since the protocol requires that gdb hands control back to us
758 * using a "here are the results" F packet, we don't need to check
759 * gdb_handlesig's return value (which is the signal to deliver if
760 * execution was resumed via a continue packet).
761 */
gdb_syscall_handling(const char * syscall_packet)762 void gdb_syscall_handling(const char *syscall_packet)
763 {
764 gdb_put_packet(syscall_packet);
765 gdb_handlesig(gdbserver_state.c_cpu, 0, NULL, NULL, 0);
766 }
767
should_catch_syscall(int num)768 static bool should_catch_syscall(int num)
769 {
770 if (gdbserver_user_state.catch_all_syscalls) {
771 return true;
772 }
773 if (num < 0 || num >= GDB_NR_SYSCALLS) {
774 return false;
775 }
776 return test_bit(num, gdbserver_user_state.catch_syscalls_mask);
777 }
778
gdb_syscall_entry(CPUState * cs,int num)779 void gdb_syscall_entry(CPUState *cs, int num)
780 {
781 if (should_catch_syscall(num)) {
782 g_autofree char *reason = g_strdup_printf("syscall_entry:%x;", num);
783 gdb_handlesig(cs, gdb_target_sigtrap(), reason, NULL, 0);
784 }
785 }
786
gdb_syscall_return(CPUState * cs,int num)787 void gdb_syscall_return(CPUState *cs, int num)
788 {
789 if (should_catch_syscall(num)) {
790 g_autofree char *reason = g_strdup_printf("syscall_return:%x;", num);
791 gdb_handlesig(cs, gdb_target_sigtrap(), reason, NULL, 0);
792 }
793 }
794
gdb_handle_set_catch_syscalls(GArray * params,void * user_ctx)795 void gdb_handle_set_catch_syscalls(GArray *params, void *user_ctx)
796 {
797 const char *param = gdb_get_cmd_param(params, 0)->data;
798 GDBSyscallsMask catch_syscalls_mask;
799 bool catch_all_syscalls;
800 unsigned int num;
801 const char *p;
802
803 /* "0" means not catching any syscalls. */
804 if (strcmp(param, "0") == 0) {
805 gdbserver_user_state.catch_all_syscalls = false;
806 memset(gdbserver_user_state.catch_syscalls_mask, 0,
807 sizeof(gdbserver_user_state.catch_syscalls_mask));
808 gdb_put_packet("OK");
809 return;
810 }
811
812 /* "1" means catching all syscalls. */
813 if (strcmp(param, "1") == 0) {
814 gdbserver_user_state.catch_all_syscalls = true;
815 gdb_put_packet("OK");
816 return;
817 }
818
819 /*
820 * "1;..." means catching only the specified syscalls.
821 * The syscall list must not be empty.
822 */
823 if (param[0] == '1' && param[1] == ';') {
824 catch_all_syscalls = false;
825 memset(catch_syscalls_mask, 0, sizeof(catch_syscalls_mask));
826 for (p = ¶m[2];; p++) {
827 if (qemu_strtoui(p, &p, 16, &num) || (*p && *p != ';')) {
828 goto err;
829 }
830 if (num >= GDB_NR_SYSCALLS) {
831 /*
832 * Fall back to reporting all syscalls. Reporting extra
833 * syscalls is inefficient, but the spec explicitly allows it.
834 * Keep parsing in case there is a syntax error ahead.
835 */
836 catch_all_syscalls = true;
837 } else {
838 set_bit(num, catch_syscalls_mask);
839 }
840 if (!*p) {
841 break;
842 }
843 }
844 gdbserver_user_state.catch_all_syscalls = catch_all_syscalls;
845 if (!catch_all_syscalls) {
846 memcpy(gdbserver_user_state.catch_syscalls_mask,
847 catch_syscalls_mask, sizeof(catch_syscalls_mask));
848 }
849 gdb_put_packet("OK");
850 return;
851 }
852
853 err:
854 gdb_put_packet("E00");
855 }
856
gdb_handle_query_xfer_siginfo(GArray * params,void * user_ctx)857 void gdb_handle_query_xfer_siginfo(GArray *params, void *user_ctx)
858 {
859 unsigned long offset, len;
860 uint8_t *siginfo_offset;
861
862 offset = gdb_get_cmd_param(params, 0)->val_ul;
863 len = gdb_get_cmd_param(params, 1)->val_ul;
864
865 if (offset + len > gdbserver_user_state.siginfo_len) {
866 /* Invalid offset and/or requested length. */
867 gdb_put_packet("E01");
868 return;
869 }
870
871 siginfo_offset = (uint8_t *)gdbserver_user_state.siginfo + offset;
872
873 /* Reply */
874 g_string_assign(gdbserver_state.str_buf, "l");
875 gdb_memtox(gdbserver_state.str_buf, (const char *)siginfo_offset, len);
876 gdb_put_packet_binary(gdbserver_state.str_buf->str,
877 gdbserver_state.str_buf->len, true);
878 }
879