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