gdbstub/user.c

   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 }