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