xref: /openbmc/qemu/gdbstub/user.c (revision 6c3014858c4c0024dd0560f08a6eda0f92f658d6)
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