xref: /openbmc/qemu/gdbstub/user.c (revision 01c3ac68)
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 
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 
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 
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.  */
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 
190 void gdb_qemu_exit(int code)
191 {
192     exit(code);
193 }
194 
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.  */
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
625 void gdb_handle_query_attached(GArray *params, void *user_ctx)
626 {
627     gdb_put_packet("0");
628 }
629 
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  */
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  */
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 
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 */
690 bool gdb_can_reverse(void)
691 {
692     return false;
693 }
694 
695 /*
696  * Break/Watch point helpers
697  */
698 
699 bool gdb_supports_guest_debug(void)
700 {
701     /* user-mode == TCG == supported */
702     return true;
703 }
704 
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 
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 
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  */
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 
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 
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 
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 
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 = &param[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 
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