1/* Main code for remote server for GDB. 2 Copyright (C) 1989-2023 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19#include "server.h" 20#include "gdbthread.h" 21#include "gdbsupport/agent.h" 22#include "notif.h" 23#include "tdesc.h" 24#include "gdbsupport/rsp-low.h" 25#include "gdbsupport/signals-state-save-restore.h" 26#include <ctype.h> 27#include <unistd.h> 28#if HAVE_SIGNAL_H 29#include <signal.h> 30#endif 31#include "gdbsupport/gdb_vecs.h" 32#include "gdbsupport/gdb_wait.h" 33#include "gdbsupport/btrace-common.h" 34#include "gdbsupport/filestuff.h" 35#include "tracepoint.h" 36#include "dll.h" 37#include "hostio.h" 38#include <vector> 39#include "gdbsupport/common-inferior.h" 40#include "gdbsupport/job-control.h" 41#include "gdbsupport/environ.h" 42#include "filenames.h" 43#include "gdbsupport/pathstuff.h" 44#ifdef USE_XML 45#include "xml-builtin.h" 46#endif 47 48#include "gdbsupport/selftest.h" 49#include "gdbsupport/scope-exit.h" 50#include "gdbsupport/gdb_select.h" 51#include "gdbsupport/scoped_restore.h" 52#include "gdbsupport/search.h" 53 54#define require_running_or_return(BUF) \ 55 if (!target_running ()) \ 56 { \ 57 write_enn (BUF); \ 58 return; \ 59 } 60 61#define require_running_or_break(BUF) \ 62 if (!target_running ()) \ 63 { \ 64 write_enn (BUF); \ 65 break; \ 66 } 67 68/* The environment to pass to the inferior when creating it. */ 69 70static gdb_environ our_environ; 71 72bool server_waiting; 73 74static bool extended_protocol; 75static bool response_needed; 76static bool exit_requested; 77 78/* --once: Exit after the first connection has closed. */ 79bool run_once; 80 81/* Whether to report TARGET_WAITKIND_NO_RESUMED events. */ 82static bool report_no_resumed; 83 84/* The event loop checks this to decide whether to continue accepting 85 events. */ 86static bool keep_processing_events = true; 87 88bool non_stop; 89 90static struct { 91 /* Set the PROGRAM_PATH. Here we adjust the path of the provided 92 binary if needed. */ 93 void set (const char *path) 94 { 95 m_path = path; 96 97 /* Make sure we're using the absolute path of the inferior when 98 creating it. */ 99 if (!contains_dir_separator (m_path.c_str ())) 100 { 101 int reg_file_errno; 102 103 /* Check if the file is in our CWD. If it is, then we prefix 104 its name with CURRENT_DIRECTORY. Otherwise, we leave the 105 name as-is because we'll try searching for it in $PATH. */ 106 if (is_regular_file (m_path.c_str (), ®_file_errno)) 107 m_path = gdb_abspath (m_path.c_str ()); 108 } 109 } 110 111 /* Return the PROGRAM_PATH. */ 112 const char *get () 113 { return m_path.empty () ? nullptr : m_path.c_str (); } 114 115private: 116 /* The program name, adjusted if needed. */ 117 std::string m_path; 118} program_path; 119static std::vector<char *> program_args; 120static std::string wrapper_argv; 121 122/* The PID of the originally created or attached inferior. Used to 123 send signals to the process when GDB sends us an asynchronous interrupt 124 (user hitting Control-C in the client), and to wait for the child to exit 125 when no longer debugging it. */ 126 127unsigned long signal_pid; 128 129/* Set if you want to disable optional thread related packets support 130 in gdbserver, for the sake of testing GDB against stubs that don't 131 support them. */ 132bool disable_packet_vCont; 133bool disable_packet_Tthread; 134bool disable_packet_qC; 135bool disable_packet_qfThreadInfo; 136bool disable_packet_T; 137 138static unsigned char *mem_buf; 139 140/* A sub-class of 'struct notif_event' for stop, holding information 141 relative to a single stop reply. We keep a queue of these to 142 push to GDB in non-stop mode. */ 143 144struct vstop_notif : public notif_event 145{ 146 /* Thread or process that got the event. */ 147 ptid_t ptid; 148 149 /* Event info. */ 150 struct target_waitstatus status; 151}; 152 153/* The current btrace configuration. This is gdbserver's mirror of GDB's 154 btrace configuration. */ 155static struct btrace_config current_btrace_conf; 156 157/* The client remote protocol state. */ 158 159static client_state g_client_state; 160 161client_state & 162get_client_state () 163{ 164 client_state &cs = g_client_state; 165 return cs; 166} 167 168 169/* Put a stop reply to the stop reply queue. */ 170 171static void 172queue_stop_reply (ptid_t ptid, const target_waitstatus &status) 173{ 174 struct vstop_notif *new_notif = new struct vstop_notif; 175 176 new_notif->ptid = ptid; 177 new_notif->status = status; 178 179 notif_event_enque (¬if_stop, new_notif); 180} 181 182static bool 183remove_all_on_match_ptid (struct notif_event *event, ptid_t filter_ptid) 184{ 185 struct vstop_notif *vstop_event = (struct vstop_notif *) event; 186 187 return vstop_event->ptid.matches (filter_ptid); 188} 189 190/* See server.h. */ 191 192void 193discard_queued_stop_replies (ptid_t ptid) 194{ 195 std::list<notif_event *>::iterator iter, next, end; 196 end = notif_stop.queue.end (); 197 for (iter = notif_stop.queue.begin (); iter != end; iter = next) 198 { 199 next = iter; 200 ++next; 201 202 if (iter == notif_stop.queue.begin ()) 203 { 204 /* The head of the list contains the notification that was 205 already sent to GDB. So we can't remove it, otherwise 206 when GDB sends the vStopped, it would ack the _next_ 207 notification, which hadn't been sent yet! */ 208 continue; 209 } 210 211 if (remove_all_on_match_ptid (*iter, ptid)) 212 { 213 delete *iter; 214 notif_stop.queue.erase (iter); 215 } 216 } 217} 218 219static void 220vstop_notif_reply (struct notif_event *event, char *own_buf) 221{ 222 struct vstop_notif *vstop = (struct vstop_notif *) event; 223 224 prepare_resume_reply (own_buf, vstop->ptid, vstop->status); 225} 226 227/* Helper for in_queued_stop_replies. */ 228 229static bool 230in_queued_stop_replies_ptid (struct notif_event *event, ptid_t filter_ptid) 231{ 232 struct vstop_notif *vstop_event = (struct vstop_notif *) event; 233 234 if (vstop_event->ptid.matches (filter_ptid)) 235 return true; 236 237 /* Don't resume fork children that GDB does not know about yet. */ 238 if ((vstop_event->status.kind () == TARGET_WAITKIND_FORKED 239 || vstop_event->status.kind () == TARGET_WAITKIND_VFORKED) 240 && vstop_event->status.child_ptid ().matches (filter_ptid)) 241 return true; 242 243 return false; 244} 245 246/* See server.h. */ 247 248int 249in_queued_stop_replies (ptid_t ptid) 250{ 251 for (notif_event *event : notif_stop.queue) 252 { 253 if (in_queued_stop_replies_ptid (event, ptid)) 254 return true; 255 } 256 257 return false; 258} 259 260struct notif_server notif_stop = 261{ 262 "vStopped", "Stop", {}, vstop_notif_reply, 263}; 264 265static int 266target_running (void) 267{ 268 return get_first_thread () != NULL; 269} 270 271/* See gdbsupport/common-inferior.h. */ 272 273const char * 274get_exec_wrapper () 275{ 276 return !wrapper_argv.empty () ? wrapper_argv.c_str () : NULL; 277} 278 279/* See gdbsupport/common-inferior.h. */ 280 281const char * 282get_exec_file (int err) 283{ 284 if (err && program_path.get () == NULL) 285 error (_("No executable file specified.")); 286 287 return program_path.get (); 288} 289 290/* See server.h. */ 291 292gdb_environ * 293get_environ () 294{ 295 return &our_environ; 296} 297 298static int 299attach_inferior (int pid) 300{ 301 client_state &cs = get_client_state (); 302 /* myattach should return -1 if attaching is unsupported, 303 0 if it succeeded, and call error() otherwise. */ 304 305 if (find_process_pid (pid) != nullptr) 306 error ("Already attached to process %d\n", pid); 307 308 if (myattach (pid) != 0) 309 return -1; 310 311 fprintf (stderr, "Attached; pid = %d\n", pid); 312 fflush (stderr); 313 314 /* FIXME - It may be that we should get the SIGNAL_PID from the 315 attach function, so that it can be the main thread instead of 316 whichever we were told to attach to. */ 317 signal_pid = pid; 318 319 if (!non_stop) 320 { 321 cs.last_ptid = mywait (ptid_t (pid), &cs.last_status, 0, 0); 322 323 /* GDB knows to ignore the first SIGSTOP after attaching to a running 324 process using the "attach" command, but this is different; it's 325 just using "target remote". Pretend it's just starting up. */ 326 if (cs.last_status.kind () == TARGET_WAITKIND_STOPPED 327 && cs.last_status.sig () == GDB_SIGNAL_STOP) 328 cs.last_status.set_stopped (GDB_SIGNAL_TRAP); 329 330 current_thread->last_resume_kind = resume_stop; 331 current_thread->last_status = cs.last_status; 332 } 333 334 return 0; 335} 336 337/* Decode a qXfer read request. Return 0 if everything looks OK, 338 or -1 otherwise. */ 339 340static int 341decode_xfer_read (char *buf, CORE_ADDR *ofs, unsigned int *len) 342{ 343 /* After the read marker and annex, qXfer looks like a 344 traditional 'm' packet. */ 345 decode_m_packet (buf, ofs, len); 346 347 return 0; 348} 349 350static int 351decode_xfer (char *buf, char **object, char **rw, char **annex, char **offset) 352{ 353 /* Extract and NUL-terminate the object. */ 354 *object = buf; 355 while (*buf && *buf != ':') 356 buf++; 357 if (*buf == '\0') 358 return -1; 359 *buf++ = 0; 360 361 /* Extract and NUL-terminate the read/write action. */ 362 *rw = buf; 363 while (*buf && *buf != ':') 364 buf++; 365 if (*buf == '\0') 366 return -1; 367 *buf++ = 0; 368 369 /* Extract and NUL-terminate the annex. */ 370 *annex = buf; 371 while (*buf && *buf != ':') 372 buf++; 373 if (*buf == '\0') 374 return -1; 375 *buf++ = 0; 376 377 *offset = buf; 378 return 0; 379} 380 381/* Write the response to a successful qXfer read. Returns the 382 length of the (binary) data stored in BUF, corresponding 383 to as much of DATA/LEN as we could fit. IS_MORE controls 384 the first character of the response. */ 385static int 386write_qxfer_response (char *buf, const gdb_byte *data, int len, int is_more) 387{ 388 int out_len; 389 390 if (is_more) 391 buf[0] = 'm'; 392 else 393 buf[0] = 'l'; 394 395 return remote_escape_output (data, len, 1, (unsigned char *) buf + 1, 396 &out_len, PBUFSIZ - 2) + 1; 397} 398 399/* Handle btrace enabling in BTS format. */ 400 401static void 402handle_btrace_enable_bts (struct thread_info *thread) 403{ 404 if (thread->btrace != NULL) 405 error (_("Btrace already enabled.")); 406 407 current_btrace_conf.format = BTRACE_FORMAT_BTS; 408 thread->btrace = target_enable_btrace (thread, ¤t_btrace_conf); 409} 410 411/* Handle btrace enabling in Intel Processor Trace format. */ 412 413static void 414handle_btrace_enable_pt (struct thread_info *thread) 415{ 416 if (thread->btrace != NULL) 417 error (_("Btrace already enabled.")); 418 419 current_btrace_conf.format = BTRACE_FORMAT_PT; 420 thread->btrace = target_enable_btrace (thread, ¤t_btrace_conf); 421} 422 423/* Handle btrace disabling. */ 424 425static void 426handle_btrace_disable (struct thread_info *thread) 427{ 428 429 if (thread->btrace == NULL) 430 error (_("Branch tracing not enabled.")); 431 432 if (target_disable_btrace (thread->btrace) != 0) 433 error (_("Could not disable branch tracing.")); 434 435 thread->btrace = NULL; 436} 437 438/* Handle the "Qbtrace" packet. */ 439 440static int 441handle_btrace_general_set (char *own_buf) 442{ 443 client_state &cs = get_client_state (); 444 struct thread_info *thread; 445 char *op; 446 447 if (!startswith (own_buf, "Qbtrace:")) 448 return 0; 449 450 op = own_buf + strlen ("Qbtrace:"); 451 452 if (cs.general_thread == null_ptid 453 || cs.general_thread == minus_one_ptid) 454 { 455 strcpy (own_buf, "E.Must select a single thread."); 456 return -1; 457 } 458 459 thread = find_thread_ptid (cs.general_thread); 460 if (thread == NULL) 461 { 462 strcpy (own_buf, "E.No such thread."); 463 return -1; 464 } 465 466 try 467 { 468 if (strcmp (op, "bts") == 0) 469 handle_btrace_enable_bts (thread); 470 else if (strcmp (op, "pt") == 0) 471 handle_btrace_enable_pt (thread); 472 else if (strcmp (op, "off") == 0) 473 handle_btrace_disable (thread); 474 else 475 error (_("Bad Qbtrace operation. Use bts, pt, or off.")); 476 477 write_ok (own_buf); 478 } 479 catch (const gdb_exception_error &exception) 480 { 481 sprintf (own_buf, "E.%s", exception.what ()); 482 } 483 484 return 1; 485} 486 487/* Handle the "Qbtrace-conf" packet. */ 488 489static int 490handle_btrace_conf_general_set (char *own_buf) 491{ 492 client_state &cs = get_client_state (); 493 struct thread_info *thread; 494 char *op; 495 496 if (!startswith (own_buf, "Qbtrace-conf:")) 497 return 0; 498 499 op = own_buf + strlen ("Qbtrace-conf:"); 500 501 if (cs.general_thread == null_ptid 502 || cs.general_thread == minus_one_ptid) 503 { 504 strcpy (own_buf, "E.Must select a single thread."); 505 return -1; 506 } 507 508 thread = find_thread_ptid (cs.general_thread); 509 if (thread == NULL) 510 { 511 strcpy (own_buf, "E.No such thread."); 512 return -1; 513 } 514 515 if (startswith (op, "bts:size=")) 516 { 517 unsigned long size; 518 char *endp = NULL; 519 520 errno = 0; 521 size = strtoul (op + strlen ("bts:size="), &endp, 16); 522 if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX) 523 { 524 strcpy (own_buf, "E.Bad size value."); 525 return -1; 526 } 527 528 current_btrace_conf.bts.size = (unsigned int) size; 529 } 530 else if (strncmp (op, "pt:size=", strlen ("pt:size=")) == 0) 531 { 532 unsigned long size; 533 char *endp = NULL; 534 535 errno = 0; 536 size = strtoul (op + strlen ("pt:size="), &endp, 16); 537 if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX) 538 { 539 strcpy (own_buf, "E.Bad size value."); 540 return -1; 541 } 542 543 current_btrace_conf.pt.size = (unsigned int) size; 544 } 545 else 546 { 547 strcpy (own_buf, "E.Bad Qbtrace configuration option."); 548 return -1; 549 } 550 551 write_ok (own_buf); 552 return 1; 553} 554 555/* Create the qMemTags packet reply given TAGS. 556 557 Returns true if parsing succeeded and false otherwise. */ 558 559static bool 560create_fetch_memtags_reply (char *reply, const gdb::byte_vector &tags) 561{ 562 /* It is an error to pass a zero-sized tag vector. */ 563 gdb_assert (tags.size () != 0); 564 565 std::string packet ("m"); 566 567 /* Write the tag data. */ 568 packet += bin2hex (tags.data (), tags.size ()); 569 570 /* Check if the reply is too big for the packet to handle. */ 571 if (PBUFSIZ < packet.size ()) 572 return false; 573 574 strcpy (reply, packet.c_str ()); 575 return true; 576} 577 578/* Parse the QMemTags request into ADDR, LEN and TAGS. 579 580 Returns true if parsing succeeded and false otherwise. */ 581 582static bool 583parse_store_memtags_request (char *request, CORE_ADDR *addr, size_t *len, 584 gdb::byte_vector &tags, int *type) 585{ 586 gdb_assert (startswith (request, "QMemTags:")); 587 588 const char *p = request + strlen ("QMemTags:"); 589 590 /* Read address and length. */ 591 unsigned int length = 0; 592 p = decode_m_packet_params (p, addr, &length, ':'); 593 *len = length; 594 595 /* Read the tag type. */ 596 ULONGEST tag_type = 0; 597 p = unpack_varlen_hex (p, &tag_type); 598 *type = (int) tag_type; 599 600 /* Make sure there is a colon after the type. */ 601 if (*p != ':') 602 return false; 603 604 /* Skip the colon. */ 605 p++; 606 607 /* Read the tag data. */ 608 tags = hex2bin (p); 609 610 return true; 611} 612 613/* Handle all of the extended 'Q' packets. */ 614 615static void 616handle_general_set (char *own_buf) 617{ 618 client_state &cs = get_client_state (); 619 if (startswith (own_buf, "QPassSignals:")) 620 { 621 int numsigs = (int) GDB_SIGNAL_LAST, i; 622 const char *p = own_buf + strlen ("QPassSignals:"); 623 CORE_ADDR cursig; 624 625 p = decode_address_to_semicolon (&cursig, p); 626 for (i = 0; i < numsigs; i++) 627 { 628 if (i == cursig) 629 { 630 cs.pass_signals[i] = 1; 631 if (*p == '\0') 632 /* Keep looping, to clear the remaining signals. */ 633 cursig = -1; 634 else 635 p = decode_address_to_semicolon (&cursig, p); 636 } 637 else 638 cs.pass_signals[i] = 0; 639 } 640 strcpy (own_buf, "OK"); 641 return; 642 } 643 644 if (startswith (own_buf, "QProgramSignals:")) 645 { 646 int numsigs = (int) GDB_SIGNAL_LAST, i; 647 const char *p = own_buf + strlen ("QProgramSignals:"); 648 CORE_ADDR cursig; 649 650 cs.program_signals_p = 1; 651 652 p = decode_address_to_semicolon (&cursig, p); 653 for (i = 0; i < numsigs; i++) 654 { 655 if (i == cursig) 656 { 657 cs.program_signals[i] = 1; 658 if (*p == '\0') 659 /* Keep looping, to clear the remaining signals. */ 660 cursig = -1; 661 else 662 p = decode_address_to_semicolon (&cursig, p); 663 } 664 else 665 cs.program_signals[i] = 0; 666 } 667 strcpy (own_buf, "OK"); 668 return; 669 } 670 671 if (startswith (own_buf, "QCatchSyscalls:")) 672 { 673 const char *p = own_buf + sizeof ("QCatchSyscalls:") - 1; 674 int enabled = -1; 675 CORE_ADDR sysno; 676 struct process_info *process; 677 678 if (!target_running () || !target_supports_catch_syscall ()) 679 { 680 write_enn (own_buf); 681 return; 682 } 683 684 if (strcmp (p, "0") == 0) 685 enabled = 0; 686 else if (p[0] == '1' && (p[1] == ';' || p[1] == '\0')) 687 enabled = 1; 688 else 689 { 690 fprintf (stderr, "Unknown catch-syscalls mode requested: %s\n", 691 own_buf); 692 write_enn (own_buf); 693 return; 694 } 695 696 process = current_process (); 697 process->syscalls_to_catch.clear (); 698 699 if (enabled) 700 { 701 p += 1; 702 if (*p == ';') 703 { 704 p += 1; 705 while (*p != '\0') 706 { 707 p = decode_address_to_semicolon (&sysno, p); 708 process->syscalls_to_catch.push_back (sysno); 709 } 710 } 711 else 712 process->syscalls_to_catch.push_back (ANY_SYSCALL); 713 } 714 715 write_ok (own_buf); 716 return; 717 } 718 719 if (strcmp (own_buf, "QEnvironmentReset") == 0) 720 { 721 our_environ = gdb_environ::from_host_environ (); 722 723 write_ok (own_buf); 724 return; 725 } 726 727 if (startswith (own_buf, "QEnvironmentHexEncoded:")) 728 { 729 const char *p = own_buf + sizeof ("QEnvironmentHexEncoded:") - 1; 730 /* The final form of the environment variable. FINAL_VAR will 731 hold the 'VAR=VALUE' format. */ 732 std::string final_var = hex2str (p); 733 std::string var_name, var_value; 734 735 remote_debug_printf ("[QEnvironmentHexEncoded received '%s']", p); 736 remote_debug_printf ("[Environment variable to be set: '%s']", 737 final_var.c_str ()); 738 739 size_t pos = final_var.find ('='); 740 if (pos == std::string::npos) 741 { 742 warning (_("Unexpected format for environment variable: '%s'"), 743 final_var.c_str ()); 744 write_enn (own_buf); 745 return; 746 } 747 748 var_name = final_var.substr (0, pos); 749 var_value = final_var.substr (pos + 1, std::string::npos); 750 751 our_environ.set (var_name.c_str (), var_value.c_str ()); 752 753 write_ok (own_buf); 754 return; 755 } 756 757 if (startswith (own_buf, "QEnvironmentUnset:")) 758 { 759 const char *p = own_buf + sizeof ("QEnvironmentUnset:") - 1; 760 std::string varname = hex2str (p); 761 762 remote_debug_printf ("[QEnvironmentUnset received '%s']", p); 763 remote_debug_printf ("[Environment variable to be unset: '%s']", 764 varname.c_str ()); 765 766 our_environ.unset (varname.c_str ()); 767 768 write_ok (own_buf); 769 return; 770 } 771 772 if (strcmp (own_buf, "QStartNoAckMode") == 0) 773 { 774 remote_debug_printf ("[noack mode enabled]"); 775 776 cs.noack_mode = 1; 777 write_ok (own_buf); 778 return; 779 } 780 781 if (startswith (own_buf, "QNonStop:")) 782 { 783 char *mode = own_buf + 9; 784 int req = -1; 785 const char *req_str; 786 787 if (strcmp (mode, "0") == 0) 788 req = 0; 789 else if (strcmp (mode, "1") == 0) 790 req = 1; 791 else 792 { 793 /* We don't know what this mode is, so complain to 794 GDB. */ 795 fprintf (stderr, "Unknown non-stop mode requested: %s\n", 796 own_buf); 797 write_enn (own_buf); 798 return; 799 } 800 801 req_str = req ? "non-stop" : "all-stop"; 802 if (the_target->start_non_stop (req == 1) != 0) 803 { 804 fprintf (stderr, "Setting %s mode failed\n", req_str); 805 write_enn (own_buf); 806 return; 807 } 808 809 non_stop = (req != 0); 810 811 remote_debug_printf ("[%s mode enabled]", req_str); 812 813 write_ok (own_buf); 814 return; 815 } 816 817 if (startswith (own_buf, "QDisableRandomization:")) 818 { 819 char *packet = own_buf + strlen ("QDisableRandomization:"); 820 ULONGEST setting; 821 822 unpack_varlen_hex (packet, &setting); 823 cs.disable_randomization = setting; 824 825 remote_debug_printf (cs.disable_randomization 826 ? "[address space randomization disabled]" 827 : "[address space randomization enabled]"); 828 829 write_ok (own_buf); 830 return; 831 } 832 833 if (target_supports_tracepoints () 834 && handle_tracepoint_general_set (own_buf)) 835 return; 836 837 if (startswith (own_buf, "QAgent:")) 838 { 839 char *mode = own_buf + strlen ("QAgent:"); 840 int req = 0; 841 842 if (strcmp (mode, "0") == 0) 843 req = 0; 844 else if (strcmp (mode, "1") == 0) 845 req = 1; 846 else 847 { 848 /* We don't know what this value is, so complain to GDB. */ 849 sprintf (own_buf, "E.Unknown QAgent value"); 850 return; 851 } 852 853 /* Update the flag. */ 854 use_agent = req; 855 remote_debug_printf ("[%s agent]", req ? "Enable" : "Disable"); 856 write_ok (own_buf); 857 return; 858 } 859 860 if (handle_btrace_general_set (own_buf)) 861 return; 862 863 if (handle_btrace_conf_general_set (own_buf)) 864 return; 865 866 if (startswith (own_buf, "QThreadEvents:")) 867 { 868 char *mode = own_buf + strlen ("QThreadEvents:"); 869 enum tribool req = TRIBOOL_UNKNOWN; 870 871 if (strcmp (mode, "0") == 0) 872 req = TRIBOOL_FALSE; 873 else if (strcmp (mode, "1") == 0) 874 req = TRIBOOL_TRUE; 875 else 876 { 877 /* We don't know what this mode is, so complain to GDB. */ 878 std::string err 879 = string_printf ("E.Unknown thread-events mode requested: %s\n", 880 mode); 881 strcpy (own_buf, err.c_str ()); 882 return; 883 } 884 885 cs.report_thread_events = (req == TRIBOOL_TRUE); 886 887 remote_debug_printf ("[thread events are now %s]\n", 888 cs.report_thread_events ? "enabled" : "disabled"); 889 890 write_ok (own_buf); 891 return; 892 } 893 894 if (startswith (own_buf, "QStartupWithShell:")) 895 { 896 const char *value = own_buf + strlen ("QStartupWithShell:"); 897 898 if (strcmp (value, "1") == 0) 899 startup_with_shell = true; 900 else if (strcmp (value, "0") == 0) 901 startup_with_shell = false; 902 else 903 { 904 /* Unknown value. */ 905 fprintf (stderr, "Unknown value to startup-with-shell: %s\n", 906 own_buf); 907 write_enn (own_buf); 908 return; 909 } 910 911 remote_debug_printf ("[Inferior will %s started with shell]", 912 startup_with_shell ? "be" : "not be"); 913 914 write_ok (own_buf); 915 return; 916 } 917 918 if (startswith (own_buf, "QSetWorkingDir:")) 919 { 920 const char *p = own_buf + strlen ("QSetWorkingDir:"); 921 922 if (*p != '\0') 923 { 924 std::string path = hex2str (p); 925 926 remote_debug_printf ("[Set the inferior's current directory to %s]", 927 path.c_str ()); 928 929 set_inferior_cwd (std::move (path)); 930 } 931 else 932 { 933 /* An empty argument means that we should clear out any 934 previously set cwd for the inferior. */ 935 set_inferior_cwd (""); 936 937 remote_debug_printf ("[Unset the inferior's current directory; will " 938 "use gdbserver's cwd]"); 939 } 940 write_ok (own_buf); 941 942 return; 943 } 944 945 946 /* Handle store memory tags packets. */ 947 if (startswith (own_buf, "QMemTags:") 948 && target_supports_memory_tagging ()) 949 { 950 gdb::byte_vector tags; 951 CORE_ADDR addr = 0; 952 size_t len = 0; 953 int type = 0; 954 955 require_running_or_return (own_buf); 956 957 bool ret = parse_store_memtags_request (own_buf, &addr, &len, tags, 958 &type); 959 960 if (ret) 961 ret = the_target->store_memtags (addr, len, tags, type); 962 963 if (!ret) 964 write_enn (own_buf); 965 else 966 write_ok (own_buf); 967 968 return; 969 } 970 971 /* Otherwise we didn't know what packet it was. Say we didn't 972 understand it. */ 973 own_buf[0] = 0; 974} 975 976static const char * 977get_features_xml (const char *annex) 978{ 979 const struct target_desc *desc = current_target_desc (); 980 981 /* `desc->xmltarget' defines what to return when looking for the 982 "target.xml" file. Its contents can either be verbatim XML code 983 (prefixed with a '@') or else the name of the actual XML file to 984 be used in place of "target.xml". 985 986 This variable is set up from the auto-generated 987 init_registers_... routine for the current target. */ 988 989 if (strcmp (annex, "target.xml") == 0) 990 { 991 const char *ret = tdesc_get_features_xml (desc); 992 993 if (*ret == '@') 994 return ret + 1; 995 else 996 annex = ret; 997 } 998 999#ifdef USE_XML 1000 { 1001 int i; 1002 1003 /* Look for the annex. */ 1004 for (i = 0; xml_builtin[i][0] != NULL; i++) 1005 if (strcmp (annex, xml_builtin[i][0]) == 0) 1006 break; 1007 1008 if (xml_builtin[i][0] != NULL) 1009 return xml_builtin[i][1]; 1010 } 1011#endif 1012 1013 return NULL; 1014} 1015 1016static void 1017monitor_show_help (void) 1018{ 1019 monitor_output ("The following monitor commands are supported:\n"); 1020 monitor_output (" set debug <0|1>\n"); 1021 monitor_output (" Enable general debugging messages\n"); 1022 monitor_output (" set debug-hw-points <0|1>\n"); 1023 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n"); 1024 monitor_output (" set remote-debug <0|1>\n"); 1025 monitor_output (" Enable remote protocol debugging messages\n"); 1026 monitor_output (" set event-loop-debug <0|1>\n"); 1027 monitor_output (" Enable event loop debugging messages\n"); 1028 monitor_output (" set debug-format option1[,option2,...]\n"); 1029 monitor_output (" Add additional information to debugging messages\n"); 1030 monitor_output (" Options: all, none"); 1031 monitor_output (", timestamp"); 1032 monitor_output ("\n"); 1033 monitor_output (" exit\n"); 1034 monitor_output (" Quit GDBserver\n"); 1035} 1036 1037/* Read trace frame or inferior memory. Returns the number of bytes 1038 actually read, zero when no further transfer is possible, and -1 on 1039 error. Return of a positive value smaller than LEN does not 1040 indicate there's no more to be read, only the end of the transfer. 1041 E.g., when GDB reads memory from a traceframe, a first request may 1042 be served from a memory block that does not cover the whole request 1043 length. A following request gets the rest served from either 1044 another block (of the same traceframe) or from the read-only 1045 regions. */ 1046 1047static int 1048gdb_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) 1049{ 1050 client_state &cs = get_client_state (); 1051 int res; 1052 1053 if (cs.current_traceframe >= 0) 1054 { 1055 ULONGEST nbytes; 1056 ULONGEST length = len; 1057 1058 if (traceframe_read_mem (cs.current_traceframe, 1059 memaddr, myaddr, len, &nbytes)) 1060 return -1; 1061 /* Data read from trace buffer, we're done. */ 1062 if (nbytes > 0) 1063 return nbytes; 1064 if (!in_readonly_region (memaddr, length)) 1065 return -1; 1066 /* Otherwise we have a valid readonly case, fall through. */ 1067 /* (assume no half-trace half-real blocks for now) */ 1068 } 1069 1070 if (set_desired_process ()) 1071 res = read_inferior_memory (memaddr, myaddr, len); 1072 else 1073 res = 1; 1074 1075 return res == 0 ? len : -1; 1076} 1077 1078/* Write trace frame or inferior memory. Actually, writing to trace 1079 frames is forbidden. */ 1080 1081static int 1082gdb_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len) 1083{ 1084 client_state &cs = get_client_state (); 1085 if (cs.current_traceframe >= 0) 1086 return EIO; 1087 else 1088 { 1089 int ret; 1090 1091 if (set_desired_process ()) 1092 ret = target_write_memory (memaddr, myaddr, len); 1093 else 1094 ret = EIO; 1095 return ret; 1096 } 1097} 1098 1099/* Handle qSearch:memory packets. */ 1100 1101static void 1102handle_search_memory (char *own_buf, int packet_len) 1103{ 1104 CORE_ADDR start_addr; 1105 CORE_ADDR search_space_len; 1106 gdb_byte *pattern; 1107 unsigned int pattern_len; 1108 int found; 1109 CORE_ADDR found_addr; 1110 int cmd_name_len = sizeof ("qSearch:memory:") - 1; 1111 1112 pattern = (gdb_byte *) malloc (packet_len); 1113 if (pattern == NULL) 1114 error ("Unable to allocate memory to perform the search"); 1115 1116 if (decode_search_memory_packet (own_buf + cmd_name_len, 1117 packet_len - cmd_name_len, 1118 &start_addr, &search_space_len, 1119 pattern, &pattern_len) < 0) 1120 { 1121 free (pattern); 1122 error ("Error in parsing qSearch:memory packet"); 1123 } 1124 1125 auto read_memory = [] (CORE_ADDR addr, gdb_byte *result, size_t len) 1126 { 1127 return gdb_read_memory (addr, result, len) == len; 1128 }; 1129 1130 found = simple_search_memory (read_memory, start_addr, search_space_len, 1131 pattern, pattern_len, &found_addr); 1132 1133 if (found > 0) 1134 sprintf (own_buf, "1,%lx", (long) found_addr); 1135 else if (found == 0) 1136 strcpy (own_buf, "0"); 1137 else 1138 strcpy (own_buf, "E00"); 1139 1140 free (pattern); 1141} 1142 1143/* Handle the "D" packet. */ 1144 1145static void 1146handle_detach (char *own_buf) 1147{ 1148 client_state &cs = get_client_state (); 1149 1150 process_info *process; 1151 1152 if (cs.multi_process) 1153 { 1154 /* skip 'D;' */ 1155 int pid = strtol (&own_buf[2], NULL, 16); 1156 1157 process = find_process_pid (pid); 1158 } 1159 else 1160 { 1161 process = (current_thread != nullptr 1162 ? get_thread_process (current_thread) 1163 : nullptr); 1164 } 1165 1166 if (process == NULL) 1167 { 1168 write_enn (own_buf); 1169 return; 1170 } 1171 1172 if ((tracing && disconnected_tracing) || any_persistent_commands (process)) 1173 { 1174 if (tracing && disconnected_tracing) 1175 fprintf (stderr, 1176 "Disconnected tracing in effect, " 1177 "leaving gdbserver attached to the process\n"); 1178 1179 if (any_persistent_commands (process)) 1180 fprintf (stderr, 1181 "Persistent commands are present, " 1182 "leaving gdbserver attached to the process\n"); 1183 1184 /* Make sure we're in non-stop/async mode, so we we can both 1185 wait for an async socket accept, and handle async target 1186 events simultaneously. There's also no point either in 1187 having the target stop all threads, when we're going to 1188 pass signals down without informing GDB. */ 1189 if (!non_stop) 1190 { 1191 threads_debug_printf ("Forcing non-stop mode"); 1192 1193 non_stop = true; 1194 the_target->start_non_stop (true); 1195 } 1196 1197 process->gdb_detached = 1; 1198 1199 /* Detaching implicitly resumes all threads. */ 1200 target_continue_no_signal (minus_one_ptid); 1201 1202 write_ok (own_buf); 1203 return; 1204 } 1205 1206 fprintf (stderr, "Detaching from process %d\n", process->pid); 1207 stop_tracing (); 1208 1209 /* We'll need this after PROCESS has been destroyed. */ 1210 int pid = process->pid; 1211 1212 /* If this process has an unreported fork child, that child is not known to 1213 GDB, so GDB won't take care of detaching it. We must do it here. 1214 1215 Here, we specifically don't want to use "safe iteration", as detaching 1216 another process might delete the next thread in the iteration, which is 1217 the one saved by the safe iterator. We will never delete the currently 1218 iterated on thread, so standard iteration should be safe. */ 1219 for (thread_info *thread : all_threads) 1220 { 1221 /* Only threads that are of the process we are detaching. */ 1222 if (thread->id.pid () != pid) 1223 continue; 1224 1225 /* Only threads that have a pending fork event. */ 1226 thread_info *child = target_thread_pending_child (thread); 1227 if (child == nullptr) 1228 continue; 1229 1230 process_info *fork_child_process = get_thread_process (child); 1231 gdb_assert (fork_child_process != nullptr); 1232 1233 int fork_child_pid = fork_child_process->pid; 1234 1235 if (detach_inferior (fork_child_process) != 0) 1236 warning (_("Failed to detach fork child %s, child of %s"), 1237 target_pid_to_str (ptid_t (fork_child_pid)).c_str (), 1238 target_pid_to_str (thread->id).c_str ()); 1239 } 1240 1241 if (detach_inferior (process) != 0) 1242 write_enn (own_buf); 1243 else 1244 { 1245 discard_queued_stop_replies (ptid_t (pid)); 1246 write_ok (own_buf); 1247 1248 if (extended_protocol || target_running ()) 1249 { 1250 /* There is still at least one inferior remaining or 1251 we are in extended mode, so don't terminate gdbserver, 1252 and instead treat this like a normal program exit. */ 1253 cs.last_status.set_exited (0); 1254 cs.last_ptid = ptid_t (pid); 1255 1256 switch_to_thread (nullptr); 1257 } 1258 else 1259 { 1260 putpkt (own_buf); 1261 remote_close (); 1262 1263 /* If we are attached, then we can exit. Otherwise, we 1264 need to hang around doing nothing, until the child is 1265 gone. */ 1266 join_inferior (pid); 1267 exit (0); 1268 } 1269 } 1270} 1271 1272/* Parse options to --debug-format= and "monitor set debug-format". 1273 ARG is the text after "--debug-format=" or "monitor set debug-format". 1274 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format". 1275 This triggers calls to monitor_output. 1276 The result is an empty string if all options were parsed ok, otherwise an 1277 error message which the caller must free. 1278 1279 N.B. These commands affect all debug format settings, they are not 1280 cumulative. If a format is not specified, it is turned off. 1281 However, we don't go to extra trouble with things like 1282 "monitor set debug-format all,none,timestamp". 1283 Instead we just parse them one at a time, in order. 1284 1285 The syntax for "monitor set debug" we support here is not identical 1286 to gdb's "set debug foo on|off" because we also use this function to 1287 parse "--debug-format=foo,bar". */ 1288 1289static std::string 1290parse_debug_format_options (const char *arg, int is_monitor) 1291{ 1292 /* First turn all debug format options off. */ 1293 debug_timestamp = 0; 1294 1295 /* First remove leading spaces, for "monitor set debug-format". */ 1296 while (isspace (*arg)) 1297 ++arg; 1298 1299 std::vector<gdb::unique_xmalloc_ptr<char>> options 1300 = delim_string_to_char_ptr_vec (arg, ','); 1301 1302 for (const gdb::unique_xmalloc_ptr<char> &option : options) 1303 { 1304 if (strcmp (option.get (), "all") == 0) 1305 { 1306 debug_timestamp = 1; 1307 if (is_monitor) 1308 monitor_output ("All extra debug format options enabled.\n"); 1309 } 1310 else if (strcmp (option.get (), "none") == 0) 1311 { 1312 debug_timestamp = 0; 1313 if (is_monitor) 1314 monitor_output ("All extra debug format options disabled.\n"); 1315 } 1316 else if (strcmp (option.get (), "timestamp") == 0) 1317 { 1318 debug_timestamp = 1; 1319 if (is_monitor) 1320 monitor_output ("Timestamps will be added to debug output.\n"); 1321 } 1322 else if (*option == '\0') 1323 { 1324 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */ 1325 continue; 1326 } 1327 else 1328 return string_printf ("Unknown debug-format argument: \"%s\"\n", 1329 option.get ()); 1330 } 1331 1332 return std::string (); 1333} 1334 1335/* Handle monitor commands not handled by target-specific handlers. */ 1336 1337static void 1338handle_monitor_command (char *mon, char *own_buf) 1339{ 1340 if (strcmp (mon, "set debug 1") == 0) 1341 { 1342 debug_threads = true; 1343 monitor_output ("Debug output enabled.\n"); 1344 } 1345 else if (strcmp (mon, "set debug 0") == 0) 1346 { 1347 debug_threads = false; 1348 monitor_output ("Debug output disabled.\n"); 1349 } 1350 else if (strcmp (mon, "set debug-hw-points 1") == 0) 1351 { 1352 show_debug_regs = 1; 1353 monitor_output ("H/W point debugging output enabled.\n"); 1354 } 1355 else if (strcmp (mon, "set debug-hw-points 0") == 0) 1356 { 1357 show_debug_regs = 0; 1358 monitor_output ("H/W point debugging output disabled.\n"); 1359 } 1360 else if (strcmp (mon, "set remote-debug 1") == 0) 1361 { 1362 remote_debug = true; 1363 monitor_output ("Protocol debug output enabled.\n"); 1364 } 1365 else if (strcmp (mon, "set remote-debug 0") == 0) 1366 { 1367 remote_debug = false; 1368 monitor_output ("Protocol debug output disabled.\n"); 1369 } 1370 else if (strcmp (mon, "set event-loop-debug 1") == 0) 1371 { 1372 debug_event_loop = debug_event_loop_kind::ALL; 1373 monitor_output ("Event loop debug output enabled.\n"); 1374 } 1375 else if (strcmp (mon, "set event-loop-debug 0") == 0) 1376 { 1377 debug_event_loop = debug_event_loop_kind::OFF; 1378 monitor_output ("Event loop debug output disabled.\n"); 1379 } 1380 else if (startswith (mon, "set debug-format ")) 1381 { 1382 std::string error_msg 1383 = parse_debug_format_options (mon + sizeof ("set debug-format ") - 1, 1384 1); 1385 1386 if (!error_msg.empty ()) 1387 { 1388 monitor_output (error_msg.c_str ()); 1389 monitor_show_help (); 1390 write_enn (own_buf); 1391 } 1392 } 1393 else if (strcmp (mon, "set debug-file") == 0) 1394 debug_set_output (nullptr); 1395 else if (startswith (mon, "set debug-file ")) 1396 debug_set_output (mon + sizeof ("set debug-file ") - 1); 1397 else if (strcmp (mon, "help") == 0) 1398 monitor_show_help (); 1399 else if (strcmp (mon, "exit") == 0) 1400 exit_requested = true; 1401 else 1402 { 1403 monitor_output ("Unknown monitor command.\n\n"); 1404 monitor_show_help (); 1405 write_enn (own_buf); 1406 } 1407} 1408 1409/* Associates a callback with each supported qXfer'able object. */ 1410 1411struct qxfer 1412{ 1413 /* The object this handler handles. */ 1414 const char *object; 1415 1416 /* Request that the target transfer up to LEN 8-bit bytes of the 1417 target's OBJECT. The OFFSET, for a seekable object, specifies 1418 the starting point. The ANNEX can be used to provide additional 1419 data-specific information to the target. 1420 1421 Return the number of bytes actually transfered, zero when no 1422 further transfer is possible, -1 on error, -2 when the transfer 1423 is not supported, and -3 on a verbose error message that should 1424 be preserved. Return of a positive value smaller than LEN does 1425 not indicate the end of the object, only the end of the transfer. 1426 1427 One, and only one, of readbuf or writebuf must be non-NULL. */ 1428 int (*xfer) (const char *annex, 1429 gdb_byte *readbuf, const gdb_byte *writebuf, 1430 ULONGEST offset, LONGEST len); 1431}; 1432 1433/* Handle qXfer:auxv:read. */ 1434 1435static int 1436handle_qxfer_auxv (const char *annex, 1437 gdb_byte *readbuf, const gdb_byte *writebuf, 1438 ULONGEST offset, LONGEST len) 1439{ 1440 if (!the_target->supports_read_auxv () || writebuf != NULL) 1441 return -2; 1442 1443 if (annex[0] != '\0' || current_thread == NULL) 1444 return -1; 1445 1446 return the_target->read_auxv (offset, readbuf, len); 1447} 1448 1449/* Handle qXfer:exec-file:read. */ 1450 1451static int 1452handle_qxfer_exec_file (const char *annex, 1453 gdb_byte *readbuf, const gdb_byte *writebuf, 1454 ULONGEST offset, LONGEST len) 1455{ 1456 ULONGEST pid; 1457 int total_len; 1458 1459 if (!the_target->supports_pid_to_exec_file () || writebuf != NULL) 1460 return -2; 1461 1462 if (annex[0] == '\0') 1463 { 1464 if (current_thread == NULL) 1465 return -1; 1466 1467 pid = pid_of (current_thread); 1468 } 1469 else 1470 { 1471 annex = unpack_varlen_hex (annex, &pid); 1472 if (annex[0] != '\0') 1473 return -1; 1474 } 1475 1476 if (pid <= 0) 1477 return -1; 1478 1479 const char *file = the_target->pid_to_exec_file (pid); 1480 if (file == NULL) 1481 return -1; 1482 1483 total_len = strlen (file); 1484 1485 if (offset > total_len) 1486 return -1; 1487 1488 if (offset + len > total_len) 1489 len = total_len - offset; 1490 1491 memcpy (readbuf, file + offset, len); 1492 return len; 1493} 1494 1495/* Handle qXfer:features:read. */ 1496 1497static int 1498handle_qxfer_features (const char *annex, 1499 gdb_byte *readbuf, const gdb_byte *writebuf, 1500 ULONGEST offset, LONGEST len) 1501{ 1502 const char *document; 1503 size_t total_len; 1504 1505 if (writebuf != NULL) 1506 return -2; 1507 1508 if (!target_running ()) 1509 return -1; 1510 1511 /* Grab the correct annex. */ 1512 document = get_features_xml (annex); 1513 if (document == NULL) 1514 return -1; 1515 1516 total_len = strlen (document); 1517 1518 if (offset > total_len) 1519 return -1; 1520 1521 if (offset + len > total_len) 1522 len = total_len - offset; 1523 1524 memcpy (readbuf, document + offset, len); 1525 return len; 1526} 1527 1528/* Handle qXfer:libraries:read. */ 1529 1530static int 1531handle_qxfer_libraries (const char *annex, 1532 gdb_byte *readbuf, const gdb_byte *writebuf, 1533 ULONGEST offset, LONGEST len) 1534{ 1535 if (writebuf != NULL) 1536 return -2; 1537 1538 if (annex[0] != '\0' || current_thread == NULL) 1539 return -1; 1540 1541 std::string document = "<library-list version=\"1.0\">\n"; 1542 1543 process_info *proc = current_process (); 1544 for (const dll_info &dll : proc->all_dlls) 1545 document += string_printf 1546 (" <library name=\"%s\"><segment address=\"0x%s\"/></library>\n", 1547 dll.name.c_str (), paddress (dll.base_addr)); 1548 1549 document += "</library-list>\n"; 1550 1551 if (offset > document.length ()) 1552 return -1; 1553 1554 if (offset + len > document.length ()) 1555 len = document.length () - offset; 1556 1557 memcpy (readbuf, &document[offset], len); 1558 1559 return len; 1560} 1561 1562/* Handle qXfer:libraries-svr4:read. */ 1563 1564static int 1565handle_qxfer_libraries_svr4 (const char *annex, 1566 gdb_byte *readbuf, const gdb_byte *writebuf, 1567 ULONGEST offset, LONGEST len) 1568{ 1569 if (writebuf != NULL) 1570 return -2; 1571 1572 if (current_thread == NULL 1573 || !the_target->supports_qxfer_libraries_svr4 ()) 1574 return -1; 1575 1576 return the_target->qxfer_libraries_svr4 (annex, readbuf, writebuf, 1577 offset, len); 1578} 1579 1580/* Handle qXfer:osadata:read. */ 1581 1582static int 1583handle_qxfer_osdata (const char *annex, 1584 gdb_byte *readbuf, const gdb_byte *writebuf, 1585 ULONGEST offset, LONGEST len) 1586{ 1587 if (!the_target->supports_qxfer_osdata () || writebuf != NULL) 1588 return -2; 1589 1590 return the_target->qxfer_osdata (annex, readbuf, NULL, offset, len); 1591} 1592 1593/* Handle qXfer:siginfo:read and qXfer:siginfo:write. */ 1594 1595static int 1596handle_qxfer_siginfo (const char *annex, 1597 gdb_byte *readbuf, const gdb_byte *writebuf, 1598 ULONGEST offset, LONGEST len) 1599{ 1600 if (!the_target->supports_qxfer_siginfo ()) 1601 return -2; 1602 1603 if (annex[0] != '\0' || current_thread == NULL) 1604 return -1; 1605 1606 return the_target->qxfer_siginfo (annex, readbuf, writebuf, offset, len); 1607} 1608 1609/* Handle qXfer:statictrace:read. */ 1610 1611static int 1612handle_qxfer_statictrace (const char *annex, 1613 gdb_byte *readbuf, const gdb_byte *writebuf, 1614 ULONGEST offset, LONGEST len) 1615{ 1616 client_state &cs = get_client_state (); 1617 ULONGEST nbytes; 1618 1619 if (writebuf != NULL) 1620 return -2; 1621 1622 if (annex[0] != '\0' || current_thread == NULL 1623 || cs.current_traceframe == -1) 1624 return -1; 1625 1626 if (traceframe_read_sdata (cs.current_traceframe, offset, 1627 readbuf, len, &nbytes)) 1628 return -1; 1629 return nbytes; 1630} 1631 1632/* Helper for handle_qxfer_threads_proper. 1633 Emit the XML to describe the thread of INF. */ 1634 1635static void 1636handle_qxfer_threads_worker (thread_info *thread, struct buffer *buffer) 1637{ 1638 ptid_t ptid = ptid_of (thread); 1639 char ptid_s[100]; 1640 int core = target_core_of_thread (ptid); 1641 char core_s[21]; 1642 const char *name = target_thread_name (ptid); 1643 int handle_len; 1644 gdb_byte *handle; 1645 bool handle_status = target_thread_handle (ptid, &handle, &handle_len); 1646 1647 /* If this is a fork or vfork child (has a fork parent), GDB does not yet 1648 know about this process, and must not know about it until it gets the 1649 corresponding (v)fork event. Exclude this thread from the list. */ 1650 if (target_thread_pending_parent (thread) != nullptr) 1651 return; 1652 1653 write_ptid (ptid_s, ptid); 1654 1655 buffer_xml_printf (buffer, "<thread id=\"%s\"", ptid_s); 1656 1657 if (core != -1) 1658 { 1659 sprintf (core_s, "%d", core); 1660 buffer_xml_printf (buffer, " core=\"%s\"", core_s); 1661 } 1662 1663 if (name != NULL) 1664 buffer_xml_printf (buffer, " name=\"%s\"", name); 1665 1666 if (handle_status) 1667 { 1668 char *handle_s = (char *) alloca (handle_len * 2 + 1); 1669 bin2hex (handle, handle_s, handle_len); 1670 buffer_xml_printf (buffer, " handle=\"%s\"", handle_s); 1671 } 1672 1673 buffer_xml_printf (buffer, "/>\n"); 1674} 1675 1676/* Helper for handle_qxfer_threads. Return true on success, false 1677 otherwise. */ 1678 1679static bool 1680handle_qxfer_threads_proper (struct buffer *buffer) 1681{ 1682 buffer_grow_str (buffer, "<threads>\n"); 1683 1684 /* The target may need to access memory and registers (e.g. via 1685 libthread_db) to fetch thread properties. Even if don't need to 1686 stop threads to access memory, we still will need to be able to 1687 access registers, and other ptrace accesses like 1688 PTRACE_GET_THREAD_AREA that require a paused thread. Pause all 1689 threads here, so that we pause each thread at most once for all 1690 accesses. */ 1691 if (non_stop) 1692 target_pause_all (true); 1693 1694 for_each_thread ([&] (thread_info *thread) 1695 { 1696 handle_qxfer_threads_worker (thread, buffer); 1697 }); 1698 1699 if (non_stop) 1700 target_unpause_all (true); 1701 1702 buffer_grow_str0 (buffer, "</threads>\n"); 1703 return true; 1704} 1705 1706/* Handle qXfer:threads:read. */ 1707 1708static int 1709handle_qxfer_threads (const char *annex, 1710 gdb_byte *readbuf, const gdb_byte *writebuf, 1711 ULONGEST offset, LONGEST len) 1712{ 1713 static char *result = 0; 1714 static unsigned int result_length = 0; 1715 1716 if (writebuf != NULL) 1717 return -2; 1718 1719 if (annex[0] != '\0') 1720 return -1; 1721 1722 if (offset == 0) 1723 { 1724 struct buffer buffer; 1725 /* When asked for data at offset 0, generate everything and store into 1726 'result'. Successive reads will be served off 'result'. */ 1727 if (result) 1728 free (result); 1729 1730 buffer_init (&buffer); 1731 1732 bool res = handle_qxfer_threads_proper (&buffer); 1733 1734 result = buffer_finish (&buffer); 1735 result_length = strlen (result); 1736 buffer_free (&buffer); 1737 1738 if (!res) 1739 return -1; 1740 } 1741 1742 if (offset >= result_length) 1743 { 1744 /* We're out of data. */ 1745 free (result); 1746 result = NULL; 1747 result_length = 0; 1748 return 0; 1749 } 1750 1751 if (len > result_length - offset) 1752 len = result_length - offset; 1753 1754 memcpy (readbuf, result + offset, len); 1755 1756 return len; 1757} 1758 1759/* Handle qXfer:traceframe-info:read. */ 1760 1761static int 1762handle_qxfer_traceframe_info (const char *annex, 1763 gdb_byte *readbuf, const gdb_byte *writebuf, 1764 ULONGEST offset, LONGEST len) 1765{ 1766 client_state &cs = get_client_state (); 1767 static char *result = 0; 1768 static unsigned int result_length = 0; 1769 1770 if (writebuf != NULL) 1771 return -2; 1772 1773 if (!target_running () || annex[0] != '\0' || cs.current_traceframe == -1) 1774 return -1; 1775 1776 if (offset == 0) 1777 { 1778 struct buffer buffer; 1779 1780 /* When asked for data at offset 0, generate everything and 1781 store into 'result'. Successive reads will be served off 1782 'result'. */ 1783 free (result); 1784 1785 buffer_init (&buffer); 1786 1787 traceframe_read_info (cs.current_traceframe, &buffer); 1788 1789 result = buffer_finish (&buffer); 1790 result_length = strlen (result); 1791 buffer_free (&buffer); 1792 } 1793 1794 if (offset >= result_length) 1795 { 1796 /* We're out of data. */ 1797 free (result); 1798 result = NULL; 1799 result_length = 0; 1800 return 0; 1801 } 1802 1803 if (len > result_length - offset) 1804 len = result_length - offset; 1805 1806 memcpy (readbuf, result + offset, len); 1807 return len; 1808} 1809 1810/* Handle qXfer:fdpic:read. */ 1811 1812static int 1813handle_qxfer_fdpic (const char *annex, gdb_byte *readbuf, 1814 const gdb_byte *writebuf, ULONGEST offset, LONGEST len) 1815{ 1816 if (!the_target->supports_read_loadmap ()) 1817 return -2; 1818 1819 if (current_thread == NULL) 1820 return -1; 1821 1822 return the_target->read_loadmap (annex, offset, readbuf, len); 1823} 1824 1825/* Handle qXfer:btrace:read. */ 1826 1827static int 1828handle_qxfer_btrace (const char *annex, 1829 gdb_byte *readbuf, const gdb_byte *writebuf, 1830 ULONGEST offset, LONGEST len) 1831{ 1832 client_state &cs = get_client_state (); 1833 static struct buffer cache; 1834 struct thread_info *thread; 1835 enum btrace_read_type type; 1836 int result; 1837 1838 if (writebuf != NULL) 1839 return -2; 1840 1841 if (cs.general_thread == null_ptid 1842 || cs.general_thread == minus_one_ptid) 1843 { 1844 strcpy (cs.own_buf, "E.Must select a single thread."); 1845 return -3; 1846 } 1847 1848 thread = find_thread_ptid (cs.general_thread); 1849 if (thread == NULL) 1850 { 1851 strcpy (cs.own_buf, "E.No such thread."); 1852 return -3; 1853 } 1854 1855 if (thread->btrace == NULL) 1856 { 1857 strcpy (cs.own_buf, "E.Btrace not enabled."); 1858 return -3; 1859 } 1860 1861 if (strcmp (annex, "all") == 0) 1862 type = BTRACE_READ_ALL; 1863 else if (strcmp (annex, "new") == 0) 1864 type = BTRACE_READ_NEW; 1865 else if (strcmp (annex, "delta") == 0) 1866 type = BTRACE_READ_DELTA; 1867 else 1868 { 1869 strcpy (cs.own_buf, "E.Bad annex."); 1870 return -3; 1871 } 1872 1873 if (offset == 0) 1874 { 1875 buffer_free (&cache); 1876 1877 try 1878 { 1879 result = target_read_btrace (thread->btrace, &cache, type); 1880 if (result != 0) 1881 memcpy (cs.own_buf, cache.buffer, cache.used_size); 1882 } 1883 catch (const gdb_exception_error &exception) 1884 { 1885 sprintf (cs.own_buf, "E.%s", exception.what ()); 1886 result = -1; 1887 } 1888 1889 if (result != 0) 1890 return -3; 1891 } 1892 else if (offset > cache.used_size) 1893 { 1894 buffer_free (&cache); 1895 return -3; 1896 } 1897 1898 if (len > cache.used_size - offset) 1899 len = cache.used_size - offset; 1900 1901 memcpy (readbuf, cache.buffer + offset, len); 1902 1903 return len; 1904} 1905 1906/* Handle qXfer:btrace-conf:read. */ 1907 1908static int 1909handle_qxfer_btrace_conf (const char *annex, 1910 gdb_byte *readbuf, const gdb_byte *writebuf, 1911 ULONGEST offset, LONGEST len) 1912{ 1913 client_state &cs = get_client_state (); 1914 static struct buffer cache; 1915 struct thread_info *thread; 1916 int result; 1917 1918 if (writebuf != NULL) 1919 return -2; 1920 1921 if (annex[0] != '\0') 1922 return -1; 1923 1924 if (cs.general_thread == null_ptid 1925 || cs.general_thread == minus_one_ptid) 1926 { 1927 strcpy (cs.own_buf, "E.Must select a single thread."); 1928 return -3; 1929 } 1930 1931 thread = find_thread_ptid (cs.general_thread); 1932 if (thread == NULL) 1933 { 1934 strcpy (cs.own_buf, "E.No such thread."); 1935 return -3; 1936 } 1937 1938 if (thread->btrace == NULL) 1939 { 1940 strcpy (cs.own_buf, "E.Btrace not enabled."); 1941 return -3; 1942 } 1943 1944 if (offset == 0) 1945 { 1946 buffer_free (&cache); 1947 1948 try 1949 { 1950 result = target_read_btrace_conf (thread->btrace, &cache); 1951 if (result != 0) 1952 memcpy (cs.own_buf, cache.buffer, cache.used_size); 1953 } 1954 catch (const gdb_exception_error &exception) 1955 { 1956 sprintf (cs.own_buf, "E.%s", exception.what ()); 1957 result = -1; 1958 } 1959 1960 if (result != 0) 1961 return -3; 1962 } 1963 else if (offset > cache.used_size) 1964 { 1965 buffer_free (&cache); 1966 return -3; 1967 } 1968 1969 if (len > cache.used_size - offset) 1970 len = cache.used_size - offset; 1971 1972 memcpy (readbuf, cache.buffer + offset, len); 1973 1974 return len; 1975} 1976 1977static const struct qxfer qxfer_packets[] = 1978 { 1979 { "auxv", handle_qxfer_auxv }, 1980 { "btrace", handle_qxfer_btrace }, 1981 { "btrace-conf", handle_qxfer_btrace_conf }, 1982 { "exec-file", handle_qxfer_exec_file}, 1983 { "fdpic", handle_qxfer_fdpic}, 1984 { "features", handle_qxfer_features }, 1985 { "libraries", handle_qxfer_libraries }, 1986 { "libraries-svr4", handle_qxfer_libraries_svr4 }, 1987 { "osdata", handle_qxfer_osdata }, 1988 { "siginfo", handle_qxfer_siginfo }, 1989 { "statictrace", handle_qxfer_statictrace }, 1990 { "threads", handle_qxfer_threads }, 1991 { "traceframe-info", handle_qxfer_traceframe_info }, 1992 }; 1993 1994static int 1995handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p) 1996{ 1997 int i; 1998 char *object; 1999 char *rw; 2000 char *annex; 2001 char *offset; 2002 2003 if (!startswith (own_buf, "qXfer:")) 2004 return 0; 2005 2006 /* Grab the object, r/w and annex. */ 2007 if (decode_xfer (own_buf + 6, &object, &rw, &annex, &offset) < 0) 2008 { 2009 write_enn (own_buf); 2010 return 1; 2011 } 2012 2013 for (i = 0; 2014 i < sizeof (qxfer_packets) / sizeof (qxfer_packets[0]); 2015 i++) 2016 { 2017 const struct qxfer *q = &qxfer_packets[i]; 2018 2019 if (strcmp (object, q->object) == 0) 2020 { 2021 if (strcmp (rw, "read") == 0) 2022 { 2023 unsigned char *data; 2024 int n; 2025 CORE_ADDR ofs; 2026 unsigned int len; 2027 2028 /* Grab the offset and length. */ 2029 if (decode_xfer_read (offset, &ofs, &len) < 0) 2030 { 2031 write_enn (own_buf); 2032 return 1; 2033 } 2034 2035 /* Read one extra byte, as an indicator of whether there is 2036 more. */ 2037 if (len > PBUFSIZ - 2) 2038 len = PBUFSIZ - 2; 2039 data = (unsigned char *) malloc (len + 1); 2040 if (data == NULL) 2041 { 2042 write_enn (own_buf); 2043 return 1; 2044 } 2045 n = (*q->xfer) (annex, data, NULL, ofs, len + 1); 2046 if (n == -2) 2047 { 2048 free (data); 2049 return 0; 2050 } 2051 else if (n == -3) 2052 { 2053 /* Preserve error message. */ 2054 } 2055 else if (n < 0) 2056 write_enn (own_buf); 2057 else if (n > len) 2058 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1); 2059 else 2060 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0); 2061 2062 free (data); 2063 return 1; 2064 } 2065 else if (strcmp (rw, "write") == 0) 2066 { 2067 int n; 2068 unsigned int len; 2069 CORE_ADDR ofs; 2070 unsigned char *data; 2071 2072 strcpy (own_buf, "E00"); 2073 data = (unsigned char *) malloc (packet_len - (offset - own_buf)); 2074 if (data == NULL) 2075 { 2076 write_enn (own_buf); 2077 return 1; 2078 } 2079 if (decode_xfer_write (offset, packet_len - (offset - own_buf), 2080 &ofs, &len, data) < 0) 2081 { 2082 free (data); 2083 write_enn (own_buf); 2084 return 1; 2085 } 2086 2087 n = (*q->xfer) (annex, NULL, data, ofs, len); 2088 if (n == -2) 2089 { 2090 free (data); 2091 return 0; 2092 } 2093 else if (n == -3) 2094 { 2095 /* Preserve error message. */ 2096 } 2097 else if (n < 0) 2098 write_enn (own_buf); 2099 else 2100 sprintf (own_buf, "%x", n); 2101 2102 free (data); 2103 return 1; 2104 } 2105 2106 return 0; 2107 } 2108 } 2109 2110 return 0; 2111} 2112 2113/* Compute 32 bit CRC from inferior memory. 2114 2115 On success, return 32 bit CRC. 2116 On failure, return (unsigned long long) -1. */ 2117 2118static unsigned long long 2119crc32 (CORE_ADDR base, int len, unsigned int crc) 2120{ 2121 while (len--) 2122 { 2123 unsigned char byte = 0; 2124 2125 /* Return failure if memory read fails. */ 2126 if (read_inferior_memory (base, &byte, 1) != 0) 2127 return (unsigned long long) -1; 2128 2129 crc = xcrc32 (&byte, 1, crc); 2130 base++; 2131 } 2132 return (unsigned long long) crc; 2133} 2134 2135/* Parse the qMemTags packet request into ADDR and LEN. */ 2136 2137static void 2138parse_fetch_memtags_request (char *request, CORE_ADDR *addr, size_t *len, 2139 int *type) 2140{ 2141 gdb_assert (startswith (request, "qMemTags:")); 2142 2143 const char *p = request + strlen ("qMemTags:"); 2144 2145 /* Read address and length. */ 2146 unsigned int length = 0; 2147 p = decode_m_packet_params (p, addr, &length, ':'); 2148 *len = length; 2149 2150 /* Read the tag type. */ 2151 ULONGEST tag_type = 0; 2152 p = unpack_varlen_hex (p, &tag_type); 2153 *type = (int) tag_type; 2154} 2155 2156/* Add supported btrace packets to BUF. */ 2157 2158static void 2159supported_btrace_packets (char *buf) 2160{ 2161 strcat (buf, ";Qbtrace:bts+"); 2162 strcat (buf, ";Qbtrace-conf:bts:size+"); 2163 strcat (buf, ";Qbtrace:pt+"); 2164 strcat (buf, ";Qbtrace-conf:pt:size+"); 2165 strcat (buf, ";Qbtrace:off+"); 2166 strcat (buf, ";qXfer:btrace:read+"); 2167 strcat (buf, ";qXfer:btrace-conf:read+"); 2168} 2169 2170/* Handle all of the extended 'q' packets. */ 2171 2172static void 2173handle_query (char *own_buf, int packet_len, int *new_packet_len_p) 2174{ 2175 client_state &cs = get_client_state (); 2176 static std::list<thread_info *>::const_iterator thread_iter; 2177 2178 /* Reply the current thread id. */ 2179 if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC) 2180 { 2181 ptid_t ptid; 2182 require_running_or_return (own_buf); 2183 2184 if (cs.general_thread != null_ptid && cs.general_thread != minus_one_ptid) 2185 ptid = cs.general_thread; 2186 else 2187 { 2188 thread_iter = all_threads.begin (); 2189 ptid = (*thread_iter)->id; 2190 } 2191 2192 sprintf (own_buf, "QC"); 2193 own_buf += 2; 2194 write_ptid (own_buf, ptid); 2195 return; 2196 } 2197 2198 if (strcmp ("qSymbol::", own_buf) == 0) 2199 { 2200 scoped_restore_current_thread restore_thread; 2201 2202 /* For qSymbol, GDB only changes the current thread if the 2203 previous current thread was of a different process. So if 2204 the previous thread is gone, we need to pick another one of 2205 the same process. This can happen e.g., if we followed an 2206 exec in a non-leader thread. */ 2207 if (current_thread == NULL) 2208 { 2209 thread_info *any_thread 2210 = find_any_thread_of_pid (cs.general_thread.pid ()); 2211 switch_to_thread (any_thread); 2212 2213 /* Just in case, if we didn't find a thread, then bail out 2214 instead of crashing. */ 2215 if (current_thread == NULL) 2216 { 2217 write_enn (own_buf); 2218 return; 2219 } 2220 } 2221 2222 /* GDB is suggesting new symbols have been loaded. This may 2223 mean a new shared library has been detected as loaded, so 2224 take the opportunity to check if breakpoints we think are 2225 inserted, still are. Note that it isn't guaranteed that 2226 we'll see this when a shared library is loaded, and nor will 2227 we see this for unloads (although breakpoints in unloaded 2228 libraries shouldn't trigger), as GDB may not find symbols for 2229 the library at all. We also re-validate breakpoints when we 2230 see a second GDB breakpoint for the same address, and or when 2231 we access breakpoint shadows. */ 2232 validate_breakpoints (); 2233 2234 if (target_supports_tracepoints ()) 2235 tracepoint_look_up_symbols (); 2236 2237 if (current_thread != NULL) 2238 the_target->look_up_symbols (); 2239 2240 strcpy (own_buf, "OK"); 2241 return; 2242 } 2243 2244 if (!disable_packet_qfThreadInfo) 2245 { 2246 if (strcmp ("qfThreadInfo", own_buf) == 0) 2247 { 2248 require_running_or_return (own_buf); 2249 thread_iter = all_threads.begin (); 2250 2251 *own_buf++ = 'm'; 2252 ptid_t ptid = (*thread_iter)->id; 2253 write_ptid (own_buf, ptid); 2254 thread_iter++; 2255 return; 2256 } 2257 2258 if (strcmp ("qsThreadInfo", own_buf) == 0) 2259 { 2260 require_running_or_return (own_buf); 2261 if (thread_iter != all_threads.end ()) 2262 { 2263 *own_buf++ = 'm'; 2264 ptid_t ptid = (*thread_iter)->id; 2265 write_ptid (own_buf, ptid); 2266 thread_iter++; 2267 return; 2268 } 2269 else 2270 { 2271 sprintf (own_buf, "l"); 2272 return; 2273 } 2274 } 2275 } 2276 2277 if (the_target->supports_read_offsets () 2278 && strcmp ("qOffsets", own_buf) == 0) 2279 { 2280 CORE_ADDR text, data; 2281 2282 require_running_or_return (own_buf); 2283 if (the_target->read_offsets (&text, &data)) 2284 sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX", 2285 (long)text, (long)data, (long)data); 2286 else 2287 write_enn (own_buf); 2288 2289 return; 2290 } 2291 2292 /* Protocol features query. */ 2293 if (startswith (own_buf, "qSupported") 2294 && (own_buf[10] == ':' || own_buf[10] == '\0')) 2295 { 2296 char *p = &own_buf[10]; 2297 int gdb_supports_qRelocInsn = 0; 2298 2299 /* Process each feature being provided by GDB. The first 2300 feature will follow a ':', and latter features will follow 2301 ';'. */ 2302 if (*p == ':') 2303 { 2304 std::vector<std::string> qsupported; 2305 std::vector<const char *> unknowns; 2306 2307 /* Two passes, to avoid nested strtok calls in 2308 target_process_qsupported. */ 2309 char *saveptr; 2310 for (p = strtok_r (p + 1, ";", &saveptr); 2311 p != NULL; 2312 p = strtok_r (NULL, ";", &saveptr)) 2313 qsupported.emplace_back (p); 2314 2315 for (const std::string &feature : qsupported) 2316 { 2317 if (feature == "multiprocess+") 2318 { 2319 /* GDB supports and wants multi-process support if 2320 possible. */ 2321 if (target_supports_multi_process ()) 2322 cs.multi_process = 1; 2323 } 2324 else if (feature == "qRelocInsn+") 2325 { 2326 /* GDB supports relocate instruction requests. */ 2327 gdb_supports_qRelocInsn = 1; 2328 } 2329 else if (feature == "swbreak+") 2330 { 2331 /* GDB wants us to report whether a trap is caused 2332 by a software breakpoint and for us to handle PC 2333 adjustment if necessary on this target. */ 2334 if (target_supports_stopped_by_sw_breakpoint ()) 2335 cs.swbreak_feature = 1; 2336 } 2337 else if (feature == "hwbreak+") 2338 { 2339 /* GDB wants us to report whether a trap is caused 2340 by a hardware breakpoint. */ 2341 if (target_supports_stopped_by_hw_breakpoint ()) 2342 cs.hwbreak_feature = 1; 2343 } 2344 else if (feature == "fork-events+") 2345 { 2346 /* GDB supports and wants fork events if possible. */ 2347 if (target_supports_fork_events ()) 2348 cs.report_fork_events = 1; 2349 } 2350 else if (feature == "vfork-events+") 2351 { 2352 /* GDB supports and wants vfork events if possible. */ 2353 if (target_supports_vfork_events ()) 2354 cs.report_vfork_events = 1; 2355 } 2356 else if (feature == "exec-events+") 2357 { 2358 /* GDB supports and wants exec events if possible. */ 2359 if (target_supports_exec_events ()) 2360 cs.report_exec_events = 1; 2361 } 2362 else if (feature == "vContSupported+") 2363 cs.vCont_supported = 1; 2364 else if (feature == "QThreadEvents+") 2365 ; 2366 else if (feature == "no-resumed+") 2367 { 2368 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED 2369 events. */ 2370 report_no_resumed = true; 2371 } 2372 else if (feature == "memory-tagging+") 2373 { 2374 /* GDB supports memory tagging features. */ 2375 if (target_supports_memory_tagging ()) 2376 cs.memory_tagging_feature = true; 2377 } 2378 else 2379 { 2380 /* Move the unknown features all together. */ 2381 unknowns.push_back (feature.c_str ()); 2382 } 2383 } 2384 2385 /* Give the target backend a chance to process the unknown 2386 features. */ 2387 target_process_qsupported (unknowns); 2388 } 2389 2390 sprintf (own_buf, 2391 "PacketSize=%x;QPassSignals+;QProgramSignals+;" 2392 "QStartupWithShell+;QEnvironmentHexEncoded+;" 2393 "QEnvironmentReset+;QEnvironmentUnset+;" 2394 "QSetWorkingDir+", 2395 PBUFSIZ - 1); 2396 2397 if (target_supports_catch_syscall ()) 2398 strcat (own_buf, ";QCatchSyscalls+"); 2399 2400 if (the_target->supports_qxfer_libraries_svr4 ()) 2401 strcat (own_buf, ";qXfer:libraries-svr4:read+" 2402 ";augmented-libraries-svr4-read+"); 2403 else 2404 { 2405 /* We do not have any hook to indicate whether the non-SVR4 target 2406 backend supports qXfer:libraries:read, so always report it. */ 2407 strcat (own_buf, ";qXfer:libraries:read+"); 2408 } 2409 2410 if (the_target->supports_read_auxv ()) 2411 strcat (own_buf, ";qXfer:auxv:read+"); 2412 2413 if (the_target->supports_qxfer_siginfo ()) 2414 strcat (own_buf, ";qXfer:siginfo:read+;qXfer:siginfo:write+"); 2415 2416 if (the_target->supports_read_loadmap ()) 2417 strcat (own_buf, ";qXfer:fdpic:read+"); 2418 2419 /* We always report qXfer:features:read, as targets may 2420 install XML files on a subsequent call to arch_setup. 2421 If we reported to GDB on startup that we don't support 2422 qXfer:feature:read at all, we will never be re-queried. */ 2423 strcat (own_buf, ";qXfer:features:read+"); 2424 2425 if (cs.transport_is_reliable) 2426 strcat (own_buf, ";QStartNoAckMode+"); 2427 2428 if (the_target->supports_qxfer_osdata ()) 2429 strcat (own_buf, ";qXfer:osdata:read+"); 2430 2431 if (target_supports_multi_process ()) 2432 strcat (own_buf, ";multiprocess+"); 2433 2434 if (target_supports_fork_events ()) 2435 strcat (own_buf, ";fork-events+"); 2436 2437 if (target_supports_vfork_events ()) 2438 strcat (own_buf, ";vfork-events+"); 2439 2440 if (target_supports_exec_events ()) 2441 strcat (own_buf, ";exec-events+"); 2442 2443 if (target_supports_non_stop ()) 2444 strcat (own_buf, ";QNonStop+"); 2445 2446 if (target_supports_disable_randomization ()) 2447 strcat (own_buf, ";QDisableRandomization+"); 2448 2449 strcat (own_buf, ";qXfer:threads:read+"); 2450 2451 if (target_supports_tracepoints ()) 2452 { 2453 strcat (own_buf, ";ConditionalTracepoints+"); 2454 strcat (own_buf, ";TraceStateVariables+"); 2455 strcat (own_buf, ";TracepointSource+"); 2456 strcat (own_buf, ";DisconnectedTracing+"); 2457 if (gdb_supports_qRelocInsn && target_supports_fast_tracepoints ()) 2458 strcat (own_buf, ";FastTracepoints+"); 2459 strcat (own_buf, ";StaticTracepoints+"); 2460 strcat (own_buf, ";InstallInTrace+"); 2461 strcat (own_buf, ";qXfer:statictrace:read+"); 2462 strcat (own_buf, ";qXfer:traceframe-info:read+"); 2463 strcat (own_buf, ";EnableDisableTracepoints+"); 2464 strcat (own_buf, ";QTBuffer:size+"); 2465 strcat (own_buf, ";tracenz+"); 2466 } 2467 2468 if (target_supports_hardware_single_step () 2469 || target_supports_software_single_step () ) 2470 { 2471 strcat (own_buf, ";ConditionalBreakpoints+"); 2472 } 2473 strcat (own_buf, ";BreakpointCommands+"); 2474 2475 if (target_supports_agent ()) 2476 strcat (own_buf, ";QAgent+"); 2477 2478 if (the_target->supports_btrace ()) 2479 supported_btrace_packets (own_buf); 2480 2481 if (target_supports_stopped_by_sw_breakpoint ()) 2482 strcat (own_buf, ";swbreak+"); 2483 2484 if (target_supports_stopped_by_hw_breakpoint ()) 2485 strcat (own_buf, ";hwbreak+"); 2486 2487 if (the_target->supports_pid_to_exec_file ()) 2488 strcat (own_buf, ";qXfer:exec-file:read+"); 2489 2490 strcat (own_buf, ";vContSupported+"); 2491 2492 strcat (own_buf, ";QThreadEvents+"); 2493 2494 strcat (own_buf, ";no-resumed+"); 2495 2496 if (target_supports_memory_tagging ()) 2497 strcat (own_buf, ";memory-tagging+"); 2498 2499 /* Reinitialize components as needed for the new connection. */ 2500 hostio_handle_new_gdb_connection (); 2501 target_handle_new_gdb_connection (); 2502 2503 return; 2504 } 2505 2506 /* Thread-local storage support. */ 2507 if (the_target->supports_get_tls_address () 2508 && startswith (own_buf, "qGetTLSAddr:")) 2509 { 2510 char *p = own_buf + 12; 2511 CORE_ADDR parts[2], address = 0; 2512 int i, err; 2513 ptid_t ptid = null_ptid; 2514 2515 require_running_or_return (own_buf); 2516 2517 for (i = 0; i < 3; i++) 2518 { 2519 char *p2; 2520 int len; 2521 2522 if (p == NULL) 2523 break; 2524 2525 p2 = strchr (p, ','); 2526 if (p2) 2527 { 2528 len = p2 - p; 2529 p2++; 2530 } 2531 else 2532 { 2533 len = strlen (p); 2534 p2 = NULL; 2535 } 2536 2537 if (i == 0) 2538 ptid = read_ptid (p, NULL); 2539 else 2540 decode_address (&parts[i - 1], p, len); 2541 p = p2; 2542 } 2543 2544 if (p != NULL || i < 3) 2545 err = 1; 2546 else 2547 { 2548 struct thread_info *thread = find_thread_ptid (ptid); 2549 2550 if (thread == NULL) 2551 err = 2; 2552 else 2553 err = the_target->get_tls_address (thread, parts[0], parts[1], 2554 &address); 2555 } 2556 2557 if (err == 0) 2558 { 2559 strcpy (own_buf, paddress(address)); 2560 return; 2561 } 2562 else if (err > 0) 2563 { 2564 write_enn (own_buf); 2565 return; 2566 } 2567 2568 /* Otherwise, pretend we do not understand this packet. */ 2569 } 2570 2571 /* Windows OS Thread Information Block address support. */ 2572 if (the_target->supports_get_tib_address () 2573 && startswith (own_buf, "qGetTIBAddr:")) 2574 { 2575 const char *annex; 2576 int n; 2577 CORE_ADDR tlb; 2578 ptid_t ptid = read_ptid (own_buf + 12, &annex); 2579 2580 n = the_target->get_tib_address (ptid, &tlb); 2581 if (n == 1) 2582 { 2583 strcpy (own_buf, paddress(tlb)); 2584 return; 2585 } 2586 else if (n == 0) 2587 { 2588 write_enn (own_buf); 2589 return; 2590 } 2591 return; 2592 } 2593 2594 /* Handle "monitor" commands. */ 2595 if (startswith (own_buf, "qRcmd,")) 2596 { 2597 char *mon = (char *) malloc (PBUFSIZ); 2598 int len = strlen (own_buf + 6); 2599 2600 if (mon == NULL) 2601 { 2602 write_enn (own_buf); 2603 return; 2604 } 2605 2606 if ((len % 2) != 0 2607 || hex2bin (own_buf + 6, (gdb_byte *) mon, len / 2) != len / 2) 2608 { 2609 write_enn (own_buf); 2610 free (mon); 2611 return; 2612 } 2613 mon[len / 2] = '\0'; 2614 2615 write_ok (own_buf); 2616 2617 if (the_target->handle_monitor_command (mon) == 0) 2618 /* Default processing. */ 2619 handle_monitor_command (mon, own_buf); 2620 2621 free (mon); 2622 return; 2623 } 2624 2625 if (startswith (own_buf, "qSearch:memory:")) 2626 { 2627 require_running_or_return (own_buf); 2628 handle_search_memory (own_buf, packet_len); 2629 return; 2630 } 2631 2632 if (strcmp (own_buf, "qAttached") == 0 2633 || startswith (own_buf, "qAttached:")) 2634 { 2635 struct process_info *process; 2636 2637 if (own_buf[sizeof ("qAttached") - 1]) 2638 { 2639 int pid = strtoul (own_buf + sizeof ("qAttached:") - 1, NULL, 16); 2640 process = find_process_pid (pid); 2641 } 2642 else 2643 { 2644 require_running_or_return (own_buf); 2645 process = current_process (); 2646 } 2647 2648 if (process == NULL) 2649 { 2650 write_enn (own_buf); 2651 return; 2652 } 2653 2654 strcpy (own_buf, process->attached ? "1" : "0"); 2655 return; 2656 } 2657 2658 if (startswith (own_buf, "qCRC:")) 2659 { 2660 /* CRC check (compare-section). */ 2661 const char *comma; 2662 ULONGEST base; 2663 int len; 2664 unsigned long long crc; 2665 2666 require_running_or_return (own_buf); 2667 comma = unpack_varlen_hex (own_buf + 5, &base); 2668 if (*comma++ != ',') 2669 { 2670 write_enn (own_buf); 2671 return; 2672 } 2673 len = strtoul (comma, NULL, 16); 2674 crc = crc32 (base, len, 0xffffffff); 2675 /* Check for memory failure. */ 2676 if (crc == (unsigned long long) -1) 2677 { 2678 write_enn (own_buf); 2679 return; 2680 } 2681 sprintf (own_buf, "C%lx", (unsigned long) crc); 2682 return; 2683 } 2684 2685 if (handle_qxfer (own_buf, packet_len, new_packet_len_p)) 2686 return; 2687 2688 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf)) 2689 return; 2690 2691 /* Handle fetch memory tags packets. */ 2692 if (startswith (own_buf, "qMemTags:") 2693 && target_supports_memory_tagging ()) 2694 { 2695 gdb::byte_vector tags; 2696 CORE_ADDR addr = 0; 2697 size_t len = 0; 2698 int type = 0; 2699 2700 require_running_or_return (own_buf); 2701 2702 parse_fetch_memtags_request (own_buf, &addr, &len, &type); 2703 2704 bool ret = the_target->fetch_memtags (addr, len, tags, type); 2705 2706 if (ret) 2707 ret = create_fetch_memtags_reply (own_buf, tags); 2708 2709 if (!ret) 2710 write_enn (own_buf); 2711 2712 *new_packet_len_p = strlen (own_buf); 2713 return; 2714 } 2715 2716 /* Otherwise we didn't know what packet it was. Say we didn't 2717 understand it. */ 2718 own_buf[0] = 0; 2719} 2720 2721static void gdb_wants_all_threads_stopped (void); 2722static void resume (struct thread_resume *actions, size_t n); 2723 2724/* The callback that is passed to visit_actioned_threads. */ 2725typedef int (visit_actioned_threads_callback_ftype) 2726 (const struct thread_resume *, struct thread_info *); 2727 2728/* Call CALLBACK for any thread to which ACTIONS applies to. Returns 2729 true if CALLBACK returns true. Returns false if no matching thread 2730 is found or CALLBACK results false. 2731 Note: This function is itself a callback for find_thread. */ 2732 2733static bool 2734visit_actioned_threads (thread_info *thread, 2735 const struct thread_resume *actions, 2736 size_t num_actions, 2737 visit_actioned_threads_callback_ftype *callback) 2738{ 2739 for (size_t i = 0; i < num_actions; i++) 2740 { 2741 const struct thread_resume *action = &actions[i]; 2742 2743 if (action->thread == minus_one_ptid 2744 || action->thread == thread->id 2745 || ((action->thread.pid () 2746 == thread->id.pid ()) 2747 && action->thread.lwp () == -1)) 2748 { 2749 if ((*callback) (action, thread)) 2750 return true; 2751 } 2752 } 2753 2754 return false; 2755} 2756 2757/* Callback for visit_actioned_threads. If the thread has a pending 2758 status to report, report it now. */ 2759 2760static int 2761handle_pending_status (const struct thread_resume *resumption, 2762 struct thread_info *thread) 2763{ 2764 client_state &cs = get_client_state (); 2765 if (thread->status_pending_p) 2766 { 2767 thread->status_pending_p = 0; 2768 2769 cs.last_status = thread->last_status; 2770 cs.last_ptid = thread->id; 2771 prepare_resume_reply (cs.own_buf, cs.last_ptid, cs.last_status); 2772 return 1; 2773 } 2774 return 0; 2775} 2776 2777/* Parse vCont packets. */ 2778static void 2779handle_v_cont (char *own_buf) 2780{ 2781 const char *p; 2782 int n = 0, i = 0; 2783 struct thread_resume *resume_info; 2784 struct thread_resume default_action { null_ptid }; 2785 2786 /* Count the number of semicolons in the packet. There should be one 2787 for every action. */ 2788 p = &own_buf[5]; 2789 while (p) 2790 { 2791 n++; 2792 p++; 2793 p = strchr (p, ';'); 2794 } 2795 2796 resume_info = (struct thread_resume *) malloc (n * sizeof (resume_info[0])); 2797 if (resume_info == NULL) 2798 goto err; 2799 2800 p = &own_buf[5]; 2801 while (*p) 2802 { 2803 p++; 2804 2805 memset (&resume_info[i], 0, sizeof resume_info[i]); 2806 2807 if (p[0] == 's' || p[0] == 'S') 2808 resume_info[i].kind = resume_step; 2809 else if (p[0] == 'r') 2810 resume_info[i].kind = resume_step; 2811 else if (p[0] == 'c' || p[0] == 'C') 2812 resume_info[i].kind = resume_continue; 2813 else if (p[0] == 't') 2814 resume_info[i].kind = resume_stop; 2815 else 2816 goto err; 2817 2818 if (p[0] == 'S' || p[0] == 'C') 2819 { 2820 char *q; 2821 int sig = strtol (p + 1, &q, 16); 2822 if (p == q) 2823 goto err; 2824 p = q; 2825 2826 if (!gdb_signal_to_host_p ((enum gdb_signal) sig)) 2827 goto err; 2828 resume_info[i].sig = gdb_signal_to_host ((enum gdb_signal) sig); 2829 } 2830 else if (p[0] == 'r') 2831 { 2832 ULONGEST addr; 2833 2834 p = unpack_varlen_hex (p + 1, &addr); 2835 resume_info[i].step_range_start = addr; 2836 2837 if (*p != ',') 2838 goto err; 2839 2840 p = unpack_varlen_hex (p + 1, &addr); 2841 resume_info[i].step_range_end = addr; 2842 } 2843 else 2844 { 2845 p = p + 1; 2846 } 2847 2848 if (p[0] == 0) 2849 { 2850 resume_info[i].thread = minus_one_ptid; 2851 default_action = resume_info[i]; 2852 2853 /* Note: we don't increment i here, we'll overwrite this entry 2854 the next time through. */ 2855 } 2856 else if (p[0] == ':') 2857 { 2858 const char *q; 2859 ptid_t ptid = read_ptid (p + 1, &q); 2860 2861 if (p == q) 2862 goto err; 2863 p = q; 2864 if (p[0] != ';' && p[0] != 0) 2865 goto err; 2866 2867 resume_info[i].thread = ptid; 2868 2869 i++; 2870 } 2871 } 2872 2873 if (i < n) 2874 resume_info[i] = default_action; 2875 2876 resume (resume_info, n); 2877 free (resume_info); 2878 return; 2879 2880err: 2881 write_enn (own_buf); 2882 free (resume_info); 2883 return; 2884} 2885 2886/* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */ 2887 2888static void 2889resume (struct thread_resume *actions, size_t num_actions) 2890{ 2891 client_state &cs = get_client_state (); 2892 if (!non_stop) 2893 { 2894 /* Check if among the threads that GDB wants actioned, there's 2895 one with a pending status to report. If so, skip actually 2896 resuming/stopping and report the pending event 2897 immediately. */ 2898 2899 thread_info *thread_with_status = find_thread ([&] (thread_info *thread) 2900 { 2901 return visit_actioned_threads (thread, actions, num_actions, 2902 handle_pending_status); 2903 }); 2904 2905 if (thread_with_status != NULL) 2906 return; 2907 2908 enable_async_io (); 2909 } 2910 2911 the_target->resume (actions, num_actions); 2912 2913 if (non_stop) 2914 write_ok (cs.own_buf); 2915 else 2916 { 2917 cs.last_ptid = mywait (minus_one_ptid, &cs.last_status, 0, 1); 2918 2919 if (cs.last_status.kind () == TARGET_WAITKIND_NO_RESUMED 2920 && !report_no_resumed) 2921 { 2922 /* The client does not support this stop reply. At least 2923 return error. */ 2924 sprintf (cs.own_buf, "E.No unwaited-for children left."); 2925 disable_async_io (); 2926 return; 2927 } 2928 2929 if (cs.last_status.kind () != TARGET_WAITKIND_EXITED 2930 && cs.last_status.kind () != TARGET_WAITKIND_SIGNALLED 2931 && cs.last_status.kind () != TARGET_WAITKIND_NO_RESUMED) 2932 current_thread->last_status = cs.last_status; 2933 2934 /* From the client's perspective, all-stop mode always stops all 2935 threads implicitly (and the target backend has already done 2936 so by now). Tag all threads as "want-stopped", so we don't 2937 resume them implicitly without the client telling us to. */ 2938 gdb_wants_all_threads_stopped (); 2939 prepare_resume_reply (cs.own_buf, cs.last_ptid, cs.last_status); 2940 disable_async_io (); 2941 2942 if (cs.last_status.kind () == TARGET_WAITKIND_EXITED 2943 || cs.last_status.kind () == TARGET_WAITKIND_SIGNALLED) 2944 target_mourn_inferior (cs.last_ptid); 2945 } 2946} 2947 2948/* Attach to a new program. */ 2949static void 2950handle_v_attach (char *own_buf) 2951{ 2952 client_state &cs = get_client_state (); 2953 int pid; 2954 2955 pid = strtol (own_buf + 8, NULL, 16); 2956 if (pid != 0 && attach_inferior (pid) == 0) 2957 { 2958 /* Don't report shared library events after attaching, even if 2959 some libraries are preloaded. GDB will always poll the 2960 library list. Avoids the "stopped by shared library event" 2961 notice on the GDB side. */ 2962 current_process ()->dlls_changed = false; 2963 2964 if (non_stop) 2965 { 2966 /* In non-stop, we don't send a resume reply. Stop events 2967 will follow up using the normal notification 2968 mechanism. */ 2969 write_ok (own_buf); 2970 } 2971 else 2972 prepare_resume_reply (own_buf, cs.last_ptid, cs.last_status); 2973 } 2974 else 2975 write_enn (own_buf); 2976} 2977 2978/* Run a new program. */ 2979static void 2980handle_v_run (char *own_buf) 2981{ 2982 client_state &cs = get_client_state (); 2983 char *p, *next_p; 2984 std::vector<char *> new_argv; 2985 char *new_program_name = NULL; 2986 int i; 2987 2988 for (i = 0, p = own_buf + strlen ("vRun;"); *p; p = next_p, ++i) 2989 { 2990 next_p = strchr (p, ';'); 2991 if (next_p == NULL) 2992 next_p = p + strlen (p); 2993 2994 if (i == 0 && p == next_p) 2995 { 2996 /* No program specified. */ 2997 new_program_name = NULL; 2998 } 2999 else if (p == next_p) 3000 { 3001 /* Empty argument. */ 3002 new_argv.push_back (xstrdup ("")); 3003 } 3004 else 3005 { 3006 size_t len = (next_p - p) / 2; 3007 /* ARG is the unquoted argument received via the RSP. */ 3008 char *arg = (char *) xmalloc (len + 1); 3009 /* FULL_ARGS will contain the quoted version of ARG. */ 3010 char *full_arg = (char *) xmalloc ((len + 1) * 2); 3011 /* These are pointers used to navigate the strings above. */ 3012 char *tmp_arg = arg; 3013 char *tmp_full_arg = full_arg; 3014 int need_quote = 0; 3015 3016 hex2bin (p, (gdb_byte *) arg, len); 3017 arg[len] = '\0'; 3018 3019 while (*tmp_arg != '\0') 3020 { 3021 switch (*tmp_arg) 3022 { 3023 case '\n': 3024 /* Quote \n. */ 3025 *tmp_full_arg = '\''; 3026 ++tmp_full_arg; 3027 need_quote = 1; 3028 break; 3029 3030 case '\'': 3031 /* Quote single quote. */ 3032 *tmp_full_arg = '\\'; 3033 ++tmp_full_arg; 3034 break; 3035 3036 default: 3037 break; 3038 } 3039 3040 *tmp_full_arg = *tmp_arg; 3041 ++tmp_full_arg; 3042 ++tmp_arg; 3043 } 3044 3045 if (need_quote) 3046 *tmp_full_arg++ = '\''; 3047 3048 /* Finish FULL_ARG and push it into the vector containing 3049 the argv. */ 3050 *tmp_full_arg = '\0'; 3051 if (i == 0) 3052 new_program_name = full_arg; 3053 else 3054 new_argv.push_back (full_arg); 3055 xfree (arg); 3056 } 3057 if (*next_p) 3058 next_p++; 3059 } 3060 3061 if (new_program_name == NULL) 3062 { 3063 /* GDB didn't specify a program to run. Use the program from the 3064 last run with the new argument list. */ 3065 if (program_path.get () == NULL) 3066 { 3067 write_enn (own_buf); 3068 free_vector_argv (new_argv); 3069 return; 3070 } 3071 } 3072 else 3073 program_path.set (new_program_name); 3074 3075 /* Free the old argv and install the new one. */ 3076 free_vector_argv (program_args); 3077 program_args = new_argv; 3078 3079 target_create_inferior (program_path.get (), program_args); 3080 3081 if (cs.last_status.kind () == TARGET_WAITKIND_STOPPED) 3082 { 3083 prepare_resume_reply (own_buf, cs.last_ptid, cs.last_status); 3084 3085 /* In non-stop, sending a resume reply doesn't set the general 3086 thread, but GDB assumes a vRun sets it (this is so GDB can 3087 query which is the main thread of the new inferior. */ 3088 if (non_stop) 3089 cs.general_thread = cs.last_ptid; 3090 } 3091 else 3092 write_enn (own_buf); 3093} 3094 3095/* Kill process. */ 3096static void 3097handle_v_kill (char *own_buf) 3098{ 3099 client_state &cs = get_client_state (); 3100 int pid; 3101 char *p = &own_buf[6]; 3102 if (cs.multi_process) 3103 pid = strtol (p, NULL, 16); 3104 else 3105 pid = signal_pid; 3106 3107 process_info *proc = find_process_pid (pid); 3108 3109 if (proc != nullptr && kill_inferior (proc) == 0) 3110 { 3111 cs.last_status.set_signalled (GDB_SIGNAL_KILL); 3112 cs.last_ptid = ptid_t (pid); 3113 discard_queued_stop_replies (cs.last_ptid); 3114 write_ok (own_buf); 3115 } 3116 else 3117 write_enn (own_buf); 3118} 3119 3120/* Handle all of the extended 'v' packets. */ 3121void 3122handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) 3123{ 3124 client_state &cs = get_client_state (); 3125 if (!disable_packet_vCont) 3126 { 3127 if (strcmp (own_buf, "vCtrlC") == 0) 3128 { 3129 the_target->request_interrupt (); 3130 write_ok (own_buf); 3131 return; 3132 } 3133 3134 if (startswith (own_buf, "vCont;")) 3135 { 3136 handle_v_cont (own_buf); 3137 return; 3138 } 3139 3140 if (startswith (own_buf, "vCont?")) 3141 { 3142 strcpy (own_buf, "vCont;c;C;t"); 3143 3144 if (target_supports_hardware_single_step () 3145 || target_supports_software_single_step () 3146 || !cs.vCont_supported) 3147 { 3148 /* If target supports single step either by hardware or by 3149 software, add actions s and S to the list of supported 3150 actions. On the other hand, if GDB doesn't request the 3151 supported vCont actions in qSupported packet, add s and 3152 S to the list too. */ 3153 own_buf = own_buf + strlen (own_buf); 3154 strcpy (own_buf, ";s;S"); 3155 } 3156 3157 if (target_supports_range_stepping ()) 3158 { 3159 own_buf = own_buf + strlen (own_buf); 3160 strcpy (own_buf, ";r"); 3161 } 3162 return; 3163 } 3164 } 3165 3166 if (startswith (own_buf, "vFile:") 3167 && handle_vFile (own_buf, packet_len, new_packet_len)) 3168 return; 3169 3170 if (startswith (own_buf, "vAttach;")) 3171 { 3172 if ((!extended_protocol || !cs.multi_process) && target_running ()) 3173 { 3174 fprintf (stderr, "Already debugging a process\n"); 3175 write_enn (own_buf); 3176 return; 3177 } 3178 handle_v_attach (own_buf); 3179 return; 3180 } 3181 3182 if (startswith (own_buf, "vRun;")) 3183 { 3184 if ((!extended_protocol || !cs.multi_process) && target_running ()) 3185 { 3186 fprintf (stderr, "Already debugging a process\n"); 3187 write_enn (own_buf); 3188 return; 3189 } 3190 handle_v_run (own_buf); 3191 return; 3192 } 3193 3194 if (startswith (own_buf, "vKill;")) 3195 { 3196 if (!target_running ()) 3197 { 3198 fprintf (stderr, "No process to kill\n"); 3199 write_enn (own_buf); 3200 return; 3201 } 3202 handle_v_kill (own_buf); 3203 return; 3204 } 3205 3206 if (handle_notif_ack (own_buf, packet_len)) 3207 return; 3208 3209 /* Otherwise we didn't know what packet it was. Say we didn't 3210 understand it. */ 3211 own_buf[0] = 0; 3212 return; 3213} 3214 3215/* Resume thread and wait for another event. In non-stop mode, 3216 don't really wait here, but return immediatelly to the event 3217 loop. */ 3218static void 3219myresume (char *own_buf, int step, int sig) 3220{ 3221 client_state &cs = get_client_state (); 3222 struct thread_resume resume_info[2]; 3223 int n = 0; 3224 int valid_cont_thread; 3225 3226 valid_cont_thread = (cs.cont_thread != null_ptid 3227 && cs.cont_thread != minus_one_ptid); 3228 3229 if (step || sig || valid_cont_thread) 3230 { 3231 resume_info[0].thread = current_ptid; 3232 if (step) 3233 resume_info[0].kind = resume_step; 3234 else 3235 resume_info[0].kind = resume_continue; 3236 resume_info[0].sig = sig; 3237 n++; 3238 } 3239 3240 if (!valid_cont_thread) 3241 { 3242 resume_info[n].thread = minus_one_ptid; 3243 resume_info[n].kind = resume_continue; 3244 resume_info[n].sig = 0; 3245 n++; 3246 } 3247 3248 resume (resume_info, n); 3249} 3250 3251/* Callback for for_each_thread. Make a new stop reply for each 3252 stopped thread. */ 3253 3254static void 3255queue_stop_reply_callback (thread_info *thread) 3256{ 3257 /* For now, assume targets that don't have this callback also don't 3258 manage the thread's last_status field. */ 3259 if (!the_target->supports_thread_stopped ()) 3260 { 3261 struct vstop_notif *new_notif = new struct vstop_notif; 3262 3263 new_notif->ptid = thread->id; 3264 new_notif->status = thread->last_status; 3265 /* Pass the last stop reply back to GDB, but don't notify 3266 yet. */ 3267 notif_event_enque (¬if_stop, new_notif); 3268 } 3269 else 3270 { 3271 if (target_thread_stopped (thread)) 3272 { 3273 threads_debug_printf 3274 ("Reporting thread %s as already stopped with %s", 3275 target_pid_to_str (thread->id).c_str (), 3276 thread->last_status.to_string ().c_str ()); 3277 3278 gdb_assert (thread->last_status.kind () != TARGET_WAITKIND_IGNORE); 3279 3280 /* Pass the last stop reply back to GDB, but don't notify 3281 yet. */ 3282 queue_stop_reply (thread->id, thread->last_status); 3283 } 3284 } 3285} 3286 3287/* Set this inferior threads's state as "want-stopped". We won't 3288 resume this thread until the client gives us another action for 3289 it. */ 3290 3291static void 3292gdb_wants_thread_stopped (thread_info *thread) 3293{ 3294 thread->last_resume_kind = resume_stop; 3295 3296 if (thread->last_status.kind () == TARGET_WAITKIND_IGNORE) 3297 { 3298 /* Most threads are stopped implicitly (all-stop); tag that with 3299 signal 0. */ 3300 thread->last_status.set_stopped (GDB_SIGNAL_0); 3301 } 3302} 3303 3304/* Set all threads' states as "want-stopped". */ 3305 3306static void 3307gdb_wants_all_threads_stopped (void) 3308{ 3309 for_each_thread (gdb_wants_thread_stopped); 3310} 3311 3312/* Callback for for_each_thread. If the thread is stopped with an 3313 interesting event, mark it as having a pending event. */ 3314 3315static void 3316set_pending_status_callback (thread_info *thread) 3317{ 3318 if (thread->last_status.kind () != TARGET_WAITKIND_STOPPED 3319 || (thread->last_status.sig () != GDB_SIGNAL_0 3320 /* A breakpoint, watchpoint or finished step from a previous 3321 GDB run isn't considered interesting for a new GDB run. 3322 If we left those pending, the new GDB could consider them 3323 random SIGTRAPs. This leaves out real async traps. We'd 3324 have to peek into the (target-specific) siginfo to 3325 distinguish those. */ 3326 && thread->last_status.sig () != GDB_SIGNAL_TRAP)) 3327 thread->status_pending_p = 1; 3328} 3329 3330/* Status handler for the '?' packet. */ 3331 3332static void 3333handle_status (char *own_buf) 3334{ 3335 client_state &cs = get_client_state (); 3336 3337 /* GDB is connected, don't forward events to the target anymore. */ 3338 for_each_process ([] (process_info *process) { 3339 process->gdb_detached = 0; 3340 }); 3341 3342 /* In non-stop mode, we must send a stop reply for each stopped 3343 thread. In all-stop mode, just send one for the first stopped 3344 thread we find. */ 3345 3346 if (non_stop) 3347 { 3348 for_each_thread (queue_stop_reply_callback); 3349 3350 /* The first is sent immediatly. OK is sent if there is no 3351 stopped thread, which is the same handling of the vStopped 3352 packet (by design). */ 3353 notif_write_event (¬if_stop, cs.own_buf); 3354 } 3355 else 3356 { 3357 thread_info *thread = NULL; 3358 3359 target_pause_all (false); 3360 target_stabilize_threads (); 3361 gdb_wants_all_threads_stopped (); 3362 3363 /* We can only report one status, but we might be coming out of 3364 non-stop -- if more than one thread is stopped with 3365 interesting events, leave events for the threads we're not 3366 reporting now pending. They'll be reported the next time the 3367 threads are resumed. Start by marking all interesting events 3368 as pending. */ 3369 for_each_thread (set_pending_status_callback); 3370 3371 /* Prefer the last thread that reported an event to GDB (even if 3372 that was a GDB_SIGNAL_TRAP). */ 3373 if (cs.last_status.kind () != TARGET_WAITKIND_IGNORE 3374 && cs.last_status.kind () != TARGET_WAITKIND_EXITED 3375 && cs.last_status.kind () != TARGET_WAITKIND_SIGNALLED) 3376 thread = find_thread_ptid (cs.last_ptid); 3377 3378 /* If the last event thread is not found for some reason, look 3379 for some other thread that might have an event to report. */ 3380 if (thread == NULL) 3381 thread = find_thread ([] (thread_info *thr_arg) 3382 { 3383 return thr_arg->status_pending_p; 3384 }); 3385 3386 /* If we're still out of luck, simply pick the first thread in 3387 the thread list. */ 3388 if (thread == NULL) 3389 thread = get_first_thread (); 3390 3391 if (thread != NULL) 3392 { 3393 struct thread_info *tp = (struct thread_info *) thread; 3394 3395 /* We're reporting this event, so it's no longer 3396 pending. */ 3397 tp->status_pending_p = 0; 3398 3399 /* GDB assumes the current thread is the thread we're 3400 reporting the status for. */ 3401 cs.general_thread = thread->id; 3402 set_desired_thread (); 3403 3404 gdb_assert (tp->last_status.kind () != TARGET_WAITKIND_IGNORE); 3405 prepare_resume_reply (own_buf, tp->id, tp->last_status); 3406 } 3407 else 3408 strcpy (own_buf, "W00"); 3409 } 3410} 3411 3412static void 3413gdbserver_version (void) 3414{ 3415 printf ("GNU gdbserver %s%s\n" 3416 "Copyright (C) 2023 Free Software Foundation, Inc.\n" 3417 "gdbserver is free software, covered by the " 3418 "GNU General Public License.\n" 3419 "This gdbserver was configured as \"%s\"\n", 3420 PKGVERSION, version, host_name); 3421} 3422 3423static void 3424gdbserver_usage (FILE *stream) 3425{ 3426 fprintf (stream, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n" 3427 "\tgdbserver [OPTIONS] --attach COMM PID\n" 3428 "\tgdbserver [OPTIONS] --multi COMM\n" 3429 "\n" 3430 "COMM may either be a tty device (for serial debugging),\n" 3431 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n" 3432 "stdin/stdout of gdbserver.\n" 3433 "PROG is the executable program. ARGS are arguments passed to inferior.\n" 3434 "PID is the process ID to attach to, when --attach is specified.\n" 3435 "\n" 3436 "Operating modes:\n" 3437 "\n" 3438 " --attach Attach to running process PID.\n" 3439 " --multi Start server without a specific program, and\n" 3440 " only quit when explicitly commanded.\n" 3441 " --once Exit after the first connection has closed.\n" 3442 " --help Print this message and then exit.\n" 3443 " --version Display version information and exit.\n" 3444 "\n" 3445 "Other options:\n" 3446 "\n" 3447 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n" 3448 " --disable-randomization\n" 3449 " Run PROG with address space randomization disabled.\n" 3450 " --no-disable-randomization\n" 3451 " Don't disable address space randomization when\n" 3452 " starting PROG.\n" 3453 " --startup-with-shell\n" 3454 " Start PROG using a shell. I.e., execs a shell that\n" 3455 " then execs PROG. (default)\n" 3456 " --no-startup-with-shell\n" 3457 " Exec PROG directly instead of using a shell.\n" 3458 " Disables argument globbing and variable substitution\n" 3459 " on UNIX-like systems.\n" 3460 "\n" 3461 "Debug options:\n" 3462 "\n" 3463 " --debug Enable general debugging output.\n" 3464 " --debug-format=OPT1[,OPT2,...]\n" 3465 " Specify extra content in debugging output.\n" 3466 " Options:\n" 3467 " all\n" 3468 " none\n" 3469 " timestamp\n" 3470 " --remote-debug Enable remote protocol debugging output.\n" 3471 " --event-loop-debug Enable event loop debugging output.\n" 3472 " --disable-packet=OPT1[,OPT2,...]\n" 3473 " Disable support for RSP packets or features.\n" 3474 " Options:\n" 3475 " vCont, T, Tthread, qC, qfThreadInfo and \n" 3476 " threads (disable all threading packets).\n" 3477 "\n" 3478 "For more information, consult the GDB manual (available as on-line \n" 3479 "info or a printed manual).\n"); 3480 if (REPORT_BUGS_TO[0] && stream == stdout) 3481 fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO); 3482} 3483 3484static void 3485gdbserver_show_disableable (FILE *stream) 3486{ 3487 fprintf (stream, "Disableable packets:\n" 3488 " vCont \tAll vCont packets\n" 3489 " qC \tQuerying the current thread\n" 3490 " qfThreadInfo\tThread listing\n" 3491 " Tthread \tPassing the thread specifier in the " 3492 "T stop reply packet\n" 3493 " threads \tAll of the above\n" 3494 " T \tAll 'T' packets\n"); 3495} 3496 3497/* Start up the event loop. This is the entry point to the event 3498 loop. */ 3499 3500static void 3501start_event_loop () 3502{ 3503 /* Loop until there is nothing to do. This is the entry point to 3504 the event loop engine. If nothing is ready at this time, wait 3505 for something to happen (via wait_for_event), then process it. 3506 Return when there are no longer event sources to wait for. */ 3507 3508 keep_processing_events = true; 3509 while (keep_processing_events) 3510 { 3511 /* Any events already waiting in the queue? */ 3512 int res = gdb_do_one_event (); 3513 3514 /* Was there an error? */ 3515 if (res == -1) 3516 break; 3517 } 3518 3519 /* We are done with the event loop. There are no more event sources 3520 to listen to. So we exit gdbserver. */ 3521} 3522 3523static void 3524kill_inferior_callback (process_info *process) 3525{ 3526 kill_inferior (process); 3527 discard_queued_stop_replies (ptid_t (process->pid)); 3528} 3529 3530/* Call this when exiting gdbserver with possible inferiors that need 3531 to be killed or detached from. */ 3532 3533static void 3534detach_or_kill_for_exit (void) 3535{ 3536 /* First print a list of the inferiors we will be killing/detaching. 3537 This is to assist the user, for example, in case the inferior unexpectedly 3538 dies after we exit: did we screw up or did the inferior exit on its own? 3539 Having this info will save some head-scratching. */ 3540 3541 if (have_started_inferiors_p ()) 3542 { 3543 fprintf (stderr, "Killing process(es):"); 3544 3545 for_each_process ([] (process_info *process) { 3546 if (!process->attached) 3547 fprintf (stderr, " %d", process->pid); 3548 }); 3549 3550 fprintf (stderr, "\n"); 3551 } 3552 if (have_attached_inferiors_p ()) 3553 { 3554 fprintf (stderr, "Detaching process(es):"); 3555 3556 for_each_process ([] (process_info *process) { 3557 if (process->attached) 3558 fprintf (stderr, " %d", process->pid); 3559 }); 3560 3561 fprintf (stderr, "\n"); 3562 } 3563 3564 /* Now we can kill or detach the inferiors. */ 3565 for_each_process ([] (process_info *process) { 3566 int pid = process->pid; 3567 3568 if (process->attached) 3569 detach_inferior (process); 3570 else 3571 kill_inferior (process); 3572 3573 discard_queued_stop_replies (ptid_t (pid)); 3574 }); 3575} 3576 3577/* Value that will be passed to exit(3) when gdbserver exits. */ 3578static int exit_code; 3579 3580/* Wrapper for detach_or_kill_for_exit that catches and prints 3581 errors. */ 3582 3583static void 3584detach_or_kill_for_exit_cleanup () 3585{ 3586 try 3587 { 3588 detach_or_kill_for_exit (); 3589 } 3590 catch (const gdb_exception &exception) 3591 { 3592 fflush (stdout); 3593 fprintf (stderr, "Detach or kill failed: %s\n", 3594 exception.what ()); 3595 exit_code = 1; 3596 } 3597} 3598 3599#if GDB_SELF_TEST 3600 3601namespace selftests { 3602 3603static void 3604test_memory_tagging_functions (void) 3605{ 3606 /* Setup testing. */ 3607 gdb::char_vector packet; 3608 gdb::byte_vector tags, bv; 3609 std::string expected; 3610 packet.resize (32000); 3611 CORE_ADDR addr; 3612 size_t len; 3613 int type; 3614 3615 /* Test parsing a qMemTags request. */ 3616 3617 /* Valid request, addr, len and type updated. */ 3618 addr = 0xff; 3619 len = 255; 3620 type = 255; 3621 strcpy (packet.data (), "qMemTags:0,0:0"); 3622 parse_fetch_memtags_request (packet.data (), &addr, &len, &type); 3623 SELF_CHECK (addr == 0 && len == 0 && type == 0); 3624 3625 /* Valid request, addr, len and type updated. */ 3626 addr = 0; 3627 len = 0; 3628 type = 0; 3629 strcpy (packet.data (), "qMemTags:deadbeef,ff:5"); 3630 parse_fetch_memtags_request (packet.data (), &addr, &len, &type); 3631 SELF_CHECK (addr == 0xdeadbeef && len == 255 && type == 5); 3632 3633 /* Test creating a qMemTags reply. */ 3634 3635 /* Non-empty tag data. */ 3636 bv.resize (0); 3637 3638 for (int i = 0; i < 5; i++) 3639 bv.push_back (i); 3640 3641 expected = "m0001020304"; 3642 SELF_CHECK (create_fetch_memtags_reply (packet.data (), bv) == true); 3643 SELF_CHECK (strcmp (packet.data (), expected.c_str ()) == 0); 3644 3645 /* Test parsing a QMemTags request. */ 3646 3647 /* Valid request and empty tag data: addr, len, type and tags updated. */ 3648 addr = 0xff; 3649 len = 255; 3650 type = 255; 3651 tags.resize (5); 3652 strcpy (packet.data (), "QMemTags:0,0:0:"); 3653 SELF_CHECK (parse_store_memtags_request (packet.data (), 3654 &addr, &len, tags, &type) == true); 3655 SELF_CHECK (addr == 0 && len == 0 && type == 0 && tags.size () == 0); 3656 3657 /* Valid request and non-empty tag data: addr, len, type 3658 and tags updated. */ 3659 addr = 0; 3660 len = 0; 3661 type = 0; 3662 tags.resize (0); 3663 strcpy (packet.data (), 3664 "QMemTags:deadbeef,ff:5:0001020304"); 3665 SELF_CHECK (parse_store_memtags_request (packet.data (), &addr, &len, tags, 3666 &type) == true); 3667 SELF_CHECK (addr == 0xdeadbeef && len == 255 && type == 5 3668 && tags.size () == 5); 3669} 3670 3671} // namespace selftests 3672#endif /* GDB_SELF_TEST */ 3673 3674/* Main function. This is called by the real "main" function, 3675 wrapped in a TRY_CATCH that handles any uncaught exceptions. */ 3676 3677static void ATTRIBUTE_NORETURN 3678captured_main (int argc, char *argv[]) 3679{ 3680 int bad_attach; 3681 int pid; 3682 char *arg_end; 3683 const char *port = NULL; 3684 char **next_arg = &argv[1]; 3685 volatile int multi_mode = 0; 3686 volatile int attach = 0; 3687 int was_running; 3688 bool selftest = false; 3689#if GDB_SELF_TEST 3690 std::vector<const char *> selftest_filters; 3691 3692 selftests::register_test ("remote_memory_tagging", 3693 selftests::test_memory_tagging_functions); 3694#endif 3695 3696 current_directory = getcwd (NULL, 0); 3697 client_state &cs = get_client_state (); 3698 3699 if (current_directory == NULL) 3700 { 3701 error (_("Could not find current working directory: %s"), 3702 safe_strerror (errno)); 3703 } 3704 3705 while (*next_arg != NULL && **next_arg == '-') 3706 { 3707 if (strcmp (*next_arg, "--version") == 0) 3708 { 3709 gdbserver_version (); 3710 exit (0); 3711 } 3712 else if (strcmp (*next_arg, "--help") == 0) 3713 { 3714 gdbserver_usage (stdout); 3715 exit (0); 3716 } 3717 else if (strcmp (*next_arg, "--attach") == 0) 3718 attach = 1; 3719 else if (strcmp (*next_arg, "--multi") == 0) 3720 multi_mode = 1; 3721 else if (strcmp (*next_arg, "--wrapper") == 0) 3722 { 3723 char **tmp; 3724 3725 next_arg++; 3726 3727 tmp = next_arg; 3728 while (*next_arg != NULL && strcmp (*next_arg, "--") != 0) 3729 { 3730 wrapper_argv += *next_arg; 3731 wrapper_argv += ' '; 3732 next_arg++; 3733 } 3734 3735 if (!wrapper_argv.empty ()) 3736 { 3737 /* Erase the last whitespace. */ 3738 wrapper_argv.erase (wrapper_argv.end () - 1); 3739 } 3740 3741 if (next_arg == tmp || *next_arg == NULL) 3742 { 3743 gdbserver_usage (stderr); 3744 exit (1); 3745 } 3746 3747 /* Consume the "--". */ 3748 *next_arg = NULL; 3749 } 3750 else if (strcmp (*next_arg, "--debug") == 0) 3751 debug_threads = true; 3752 else if (startswith (*next_arg, "--debug-format=")) 3753 { 3754 std::string error_msg 3755 = parse_debug_format_options ((*next_arg) 3756 + sizeof ("--debug-format=") - 1, 0); 3757 3758 if (!error_msg.empty ()) 3759 { 3760 fprintf (stderr, "%s", error_msg.c_str ()); 3761 exit (1); 3762 } 3763 } 3764 else if (strcmp (*next_arg, "--remote-debug") == 0) 3765 remote_debug = true; 3766 else if (strcmp (*next_arg, "--event-loop-debug") == 0) 3767 debug_event_loop = debug_event_loop_kind::ALL; 3768 else if (startswith (*next_arg, "--debug-file=")) 3769 debug_set_output ((*next_arg) + sizeof ("--debug-file=") -1); 3770 else if (strcmp (*next_arg, "--disable-packet") == 0) 3771 { 3772 gdbserver_show_disableable (stdout); 3773 exit (0); 3774 } 3775 else if (startswith (*next_arg, "--disable-packet=")) 3776 { 3777 char *packets = *next_arg += sizeof ("--disable-packet=") - 1; 3778 char *saveptr; 3779 for (char *tok = strtok_r (packets, ",", &saveptr); 3780 tok != NULL; 3781 tok = strtok_r (NULL, ",", &saveptr)) 3782 { 3783 if (strcmp ("vCont", tok) == 0) 3784 disable_packet_vCont = true; 3785 else if (strcmp ("Tthread", tok) == 0) 3786 disable_packet_Tthread = true; 3787 else if (strcmp ("qC", tok) == 0) 3788 disable_packet_qC = true; 3789 else if (strcmp ("qfThreadInfo", tok) == 0) 3790 disable_packet_qfThreadInfo = true; 3791 else if (strcmp ("T", tok) == 0) 3792 disable_packet_T = true; 3793 else if (strcmp ("threads", tok) == 0) 3794 { 3795 disable_packet_vCont = true; 3796 disable_packet_Tthread = true; 3797 disable_packet_qC = true; 3798 disable_packet_qfThreadInfo = true; 3799 } 3800 else 3801 { 3802 fprintf (stderr, "Don't know how to disable \"%s\".\n\n", 3803 tok); 3804 gdbserver_show_disableable (stderr); 3805 exit (1); 3806 } 3807 } 3808 } 3809 else if (strcmp (*next_arg, "-") == 0) 3810 { 3811 /* "-" specifies a stdio connection and is a form of port 3812 specification. */ 3813 port = STDIO_CONNECTION_NAME; 3814 next_arg++; 3815 break; 3816 } 3817 else if (strcmp (*next_arg, "--disable-randomization") == 0) 3818 cs.disable_randomization = 1; 3819 else if (strcmp (*next_arg, "--no-disable-randomization") == 0) 3820 cs.disable_randomization = 0; 3821 else if (strcmp (*next_arg, "--startup-with-shell") == 0) 3822 startup_with_shell = true; 3823 else if (strcmp (*next_arg, "--no-startup-with-shell") == 0) 3824 startup_with_shell = false; 3825 else if (strcmp (*next_arg, "--once") == 0) 3826 run_once = true; 3827 else if (strcmp (*next_arg, "--selftest") == 0) 3828 selftest = true; 3829 else if (startswith (*next_arg, "--selftest=")) 3830 { 3831 selftest = true; 3832 3833#if GDB_SELF_TEST 3834 const char *filter = *next_arg + strlen ("--selftest="); 3835 if (*filter == '\0') 3836 { 3837 fprintf (stderr, _("Error: selftest filter is empty.\n")); 3838 exit (1); 3839 } 3840 3841 selftest_filters.push_back (filter); 3842#endif 3843 } 3844 else 3845 { 3846 fprintf (stderr, "Unknown argument: %s\n", *next_arg); 3847 exit (1); 3848 } 3849 3850 next_arg++; 3851 continue; 3852 } 3853 3854 if (port == NULL) 3855 { 3856 port = *next_arg; 3857 next_arg++; 3858 } 3859 if ((port == NULL || (!attach && !multi_mode && *next_arg == NULL)) 3860 && !selftest) 3861 { 3862 gdbserver_usage (stderr); 3863 exit (1); 3864 } 3865 3866 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be 3867 opened by remote_prepare. */ 3868 notice_open_fds (); 3869 3870 save_original_signals_state (false); 3871 3872 /* We need to know whether the remote connection is stdio before 3873 starting the inferior. Inferiors created in this scenario have 3874 stdin,stdout redirected. So do this here before we call 3875 start_inferior. */ 3876 if (port != NULL) 3877 remote_prepare (port); 3878 3879 bad_attach = 0; 3880 pid = 0; 3881 3882 /* --attach used to come after PORT, so allow it there for 3883 compatibility. */ 3884 if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0) 3885 { 3886 attach = 1; 3887 next_arg++; 3888 } 3889 3890 if (attach 3891 && (*next_arg == NULL 3892 || (*next_arg)[0] == '\0' 3893 || (pid = strtoul (*next_arg, &arg_end, 0)) == 0 3894 || *arg_end != '\0' 3895 || next_arg[1] != NULL)) 3896 bad_attach = 1; 3897 3898 if (bad_attach) 3899 { 3900 gdbserver_usage (stderr); 3901 exit (1); 3902 } 3903 3904 /* Gather information about the environment. */ 3905 our_environ = gdb_environ::from_host_environ (); 3906 3907 initialize_async_io (); 3908 initialize_low (); 3909 have_job_control (); 3910 if (target_supports_tracepoints ()) 3911 initialize_tracepoint (); 3912 3913 mem_buf = (unsigned char *) xmalloc (PBUFSIZ); 3914 3915 if (selftest) 3916 { 3917#if GDB_SELF_TEST 3918 selftests::run_tests (selftest_filters); 3919#else 3920 printf (_("Selftests have been disabled for this build.\n")); 3921#endif 3922 throw_quit ("Quit"); 3923 } 3924 3925 if (pid == 0 && *next_arg != NULL) 3926 { 3927 int i, n; 3928 3929 n = argc - (next_arg - argv); 3930 program_path.set (next_arg[0]); 3931 for (i = 1; i < n; i++) 3932 program_args.push_back (xstrdup (next_arg[i])); 3933 3934 /* Wait till we are at first instruction in program. */ 3935 target_create_inferior (program_path.get (), program_args); 3936 3937 /* We are now (hopefully) stopped at the first instruction of 3938 the target process. This assumes that the target process was 3939 successfully created. */ 3940 } 3941 else if (pid != 0) 3942 { 3943 if (attach_inferior (pid) == -1) 3944 error ("Attaching not supported on this target"); 3945 3946 /* Otherwise succeeded. */ 3947 } 3948 else 3949 { 3950 cs.last_status.set_exited (0); 3951 cs.last_ptid = minus_one_ptid; 3952 } 3953 3954 SCOPE_EXIT { detach_or_kill_for_exit_cleanup (); }; 3955 3956 /* Don't report shared library events on the initial connection, 3957 even if some libraries are preloaded. Avoids the "stopped by 3958 shared library event" notice on gdb side. */ 3959 if (current_thread != nullptr) 3960 current_process ()->dlls_changed = false; 3961 3962 if (cs.last_status.kind () == TARGET_WAITKIND_EXITED 3963 || cs.last_status.kind () == TARGET_WAITKIND_SIGNALLED) 3964 was_running = 0; 3965 else 3966 was_running = 1; 3967 3968 if (!was_running && !multi_mode) 3969 error ("No program to debug"); 3970 3971 while (1) 3972 { 3973 cs.noack_mode = 0; 3974 cs.multi_process = 0; 3975 cs.report_fork_events = 0; 3976 cs.report_vfork_events = 0; 3977 cs.report_exec_events = 0; 3978 /* Be sure we're out of tfind mode. */ 3979 cs.current_traceframe = -1; 3980 cs.cont_thread = null_ptid; 3981 cs.swbreak_feature = 0; 3982 cs.hwbreak_feature = 0; 3983 cs.vCont_supported = 0; 3984 cs.memory_tagging_feature = false; 3985 3986 remote_open (port); 3987 3988 try 3989 { 3990 /* Wait for events. This will return when all event sources 3991 are removed from the event loop. */ 3992 start_event_loop (); 3993 3994 /* If an exit was requested (using the "monitor exit" 3995 command), terminate now. */ 3996 if (exit_requested) 3997 throw_quit ("Quit"); 3998 3999 /* The only other way to get here is for getpkt to fail: 4000 4001 - If --once was specified, we're done. 4002 4003 - If not in extended-remote mode, and we're no longer 4004 debugging anything, simply exit: GDB has disconnected 4005 after processing the last process exit. 4006 4007 - Otherwise, close the connection and reopen it at the 4008 top of the loop. */ 4009 if (run_once || (!extended_protocol && !target_running ())) 4010 throw_quit ("Quit"); 4011 4012 fprintf (stderr, 4013 "Remote side has terminated connection. " 4014 "GDBserver will reopen the connection.\n"); 4015 4016 /* Get rid of any pending statuses. An eventual reconnection 4017 (by the same GDB instance or another) will refresh all its 4018 state from scratch. */ 4019 discard_queued_stop_replies (minus_one_ptid); 4020 for_each_thread ([] (thread_info *thread) 4021 { 4022 thread->status_pending_p = 0; 4023 }); 4024 4025 if (tracing) 4026 { 4027 if (disconnected_tracing) 4028 { 4029 /* Try to enable non-stop/async mode, so we we can 4030 both wait for an async socket accept, and handle 4031 async target events simultaneously. There's also 4032 no point either in having the target always stop 4033 all threads, when we're going to pass signals 4034 down without informing GDB. */ 4035 if (!non_stop) 4036 { 4037 if (the_target->start_non_stop (true)) 4038 non_stop = 1; 4039 4040 /* Detaching implicitly resumes all threads; 4041 simply disconnecting does not. */ 4042 } 4043 } 4044 else 4045 { 4046 fprintf (stderr, 4047 "Disconnected tracing disabled; " 4048 "stopping trace run.\n"); 4049 stop_tracing (); 4050 } 4051 } 4052 } 4053 catch (const gdb_exception_error &exception) 4054 { 4055 fflush (stdout); 4056 fprintf (stderr, "gdbserver: %s\n", exception.what ()); 4057 4058 if (response_needed) 4059 { 4060 write_enn (cs.own_buf); 4061 putpkt (cs.own_buf); 4062 } 4063 4064 if (run_once) 4065 throw_quit ("Quit"); 4066 } 4067 } 4068} 4069 4070/* Main function. */ 4071 4072int 4073main (int argc, char *argv[]) 4074{ 4075 4076 try 4077 { 4078 captured_main (argc, argv); 4079 } 4080 catch (const gdb_exception &exception) 4081 { 4082 if (exception.reason == RETURN_ERROR) 4083 { 4084 fflush (stdout); 4085 fprintf (stderr, "%s\n", exception.what ()); 4086 fprintf (stderr, "Exiting\n"); 4087 exit_code = 1; 4088 } 4089 4090 exit (exit_code); 4091 } 4092 4093 gdb_assert_not_reached ("captured_main should never return"); 4094} 4095 4096/* Process options coming from Z packets for a breakpoint. PACKET is 4097 the packet buffer. *PACKET is updated to point to the first char 4098 after the last processed option. */ 4099 4100static void 4101process_point_options (struct gdb_breakpoint *bp, const char **packet) 4102{ 4103 const char *dataptr = *packet; 4104 int persist; 4105 4106 /* Check if data has the correct format. */ 4107 if (*dataptr != ';') 4108 return; 4109 4110 dataptr++; 4111 4112 while (*dataptr) 4113 { 4114 if (*dataptr == ';') 4115 ++dataptr; 4116 4117 if (*dataptr == 'X') 4118 { 4119 /* Conditional expression. */ 4120 threads_debug_printf ("Found breakpoint condition."); 4121 if (!add_breakpoint_condition (bp, &dataptr)) 4122 dataptr = strchrnul (dataptr, ';'); 4123 } 4124 else if (startswith (dataptr, "cmds:")) 4125 { 4126 dataptr += strlen ("cmds:"); 4127 threads_debug_printf ("Found breakpoint commands %s.", dataptr); 4128 persist = (*dataptr == '1'); 4129 dataptr += 2; 4130 if (add_breakpoint_commands (bp, &dataptr, persist)) 4131 dataptr = strchrnul (dataptr, ';'); 4132 } 4133 else 4134 { 4135 fprintf (stderr, "Unknown token %c, ignoring.\n", 4136 *dataptr); 4137 /* Skip tokens until we find one that we recognize. */ 4138 dataptr = strchrnul (dataptr, ';'); 4139 } 4140 } 4141 *packet = dataptr; 4142} 4143 4144/* Event loop callback that handles a serial event. The first byte in 4145 the serial buffer gets us here. We expect characters to arrive at 4146 a brisk pace, so we read the rest of the packet with a blocking 4147 getpkt call. */ 4148 4149static int 4150process_serial_event (void) 4151{ 4152 client_state &cs = get_client_state (); 4153 int signal; 4154 unsigned int len; 4155 CORE_ADDR mem_addr; 4156 unsigned char sig; 4157 int packet_len; 4158 int new_packet_len = -1; 4159 4160 disable_async_io (); 4161 4162 response_needed = false; 4163 packet_len = getpkt (cs.own_buf); 4164 if (packet_len <= 0) 4165 { 4166 remote_close (); 4167 /* Force an event loop break. */ 4168 return -1; 4169 } 4170 response_needed = true; 4171 4172 char ch = cs.own_buf[0]; 4173 switch (ch) 4174 { 4175 case 'q': 4176 handle_query (cs.own_buf, packet_len, &new_packet_len); 4177 break; 4178 case 'Q': 4179 handle_general_set (cs.own_buf); 4180 break; 4181 case 'D': 4182 handle_detach (cs.own_buf); 4183 break; 4184 case '!': 4185 extended_protocol = true; 4186 write_ok (cs.own_buf); 4187 break; 4188 case '?': 4189 handle_status (cs.own_buf); 4190 break; 4191 case 'H': 4192 if (cs.own_buf[1] == 'c' || cs.own_buf[1] == 'g' || cs.own_buf[1] == 's') 4193 { 4194 require_running_or_break (cs.own_buf); 4195 4196 ptid_t thread_id = read_ptid (&cs.own_buf[2], NULL); 4197 4198 if (thread_id == null_ptid || thread_id == minus_one_ptid) 4199 thread_id = null_ptid; 4200 else if (thread_id.is_pid ()) 4201 { 4202 /* The ptid represents a pid. */ 4203 thread_info *thread = find_any_thread_of_pid (thread_id.pid ()); 4204 4205 if (thread == NULL) 4206 { 4207 write_enn (cs.own_buf); 4208 break; 4209 } 4210 4211 thread_id = thread->id; 4212 } 4213 else 4214 { 4215 /* The ptid represents a lwp/tid. */ 4216 if (find_thread_ptid (thread_id) == NULL) 4217 { 4218 write_enn (cs.own_buf); 4219 break; 4220 } 4221 } 4222 4223 if (cs.own_buf[1] == 'g') 4224 { 4225 if (thread_id == null_ptid) 4226 { 4227 /* GDB is telling us to choose any thread. Check if 4228 the currently selected thread is still valid. If 4229 it is not, select the first available. */ 4230 thread_info *thread = find_thread_ptid (cs.general_thread); 4231 if (thread == NULL) 4232 thread = get_first_thread (); 4233 thread_id = thread->id; 4234 } 4235 4236 cs.general_thread = thread_id; 4237 set_desired_thread (); 4238 gdb_assert (current_thread != NULL); 4239 } 4240 else if (cs.own_buf[1] == 'c') 4241 cs.cont_thread = thread_id; 4242 4243 write_ok (cs.own_buf); 4244 } 4245 else 4246 { 4247 /* Silently ignore it so that gdb can extend the protocol 4248 without compatibility headaches. */ 4249 cs.own_buf[0] = '\0'; 4250 } 4251 break; 4252 case 'g': 4253 require_running_or_break (cs.own_buf); 4254 if (cs.current_traceframe >= 0) 4255 { 4256 struct regcache *regcache 4257 = new_register_cache (current_target_desc ()); 4258 4259 if (fetch_traceframe_registers (cs.current_traceframe, 4260 regcache, -1) == 0) 4261 registers_to_string (regcache, cs.own_buf); 4262 else 4263 write_enn (cs.own_buf); 4264 free_register_cache (regcache); 4265 } 4266 else 4267 { 4268 struct regcache *regcache; 4269 4270 if (!set_desired_thread ()) 4271 write_enn (cs.own_buf); 4272 else 4273 { 4274 regcache = get_thread_regcache (current_thread, 1); 4275 registers_to_string (regcache, cs.own_buf); 4276 } 4277 } 4278 break; 4279 case 'G': 4280 require_running_or_break (cs.own_buf); 4281 if (cs.current_traceframe >= 0) 4282 write_enn (cs.own_buf); 4283 else 4284 { 4285 struct regcache *regcache; 4286 4287 if (!set_desired_thread ()) 4288 write_enn (cs.own_buf); 4289 else 4290 { 4291 regcache = get_thread_regcache (current_thread, 1); 4292 registers_from_string (regcache, &cs.own_buf[1]); 4293 write_ok (cs.own_buf); 4294 } 4295 } 4296 break; 4297 case 'm': 4298 { 4299 require_running_or_break (cs.own_buf); 4300 decode_m_packet (&cs.own_buf[1], &mem_addr, &len); 4301 int res = gdb_read_memory (mem_addr, mem_buf, len); 4302 if (res < 0) 4303 write_enn (cs.own_buf); 4304 else 4305 bin2hex (mem_buf, cs.own_buf, res); 4306 } 4307 break; 4308 case 'M': 4309 require_running_or_break (cs.own_buf); 4310 decode_M_packet (&cs.own_buf[1], &mem_addr, &len, &mem_buf); 4311 if (gdb_write_memory (mem_addr, mem_buf, len) == 0) 4312 write_ok (cs.own_buf); 4313 else 4314 write_enn (cs.own_buf); 4315 break; 4316 case 'X': 4317 require_running_or_break (cs.own_buf); 4318 if (decode_X_packet (&cs.own_buf[1], packet_len - 1, 4319 &mem_addr, &len, &mem_buf) < 0 4320 || gdb_write_memory (mem_addr, mem_buf, len) != 0) 4321 write_enn (cs.own_buf); 4322 else 4323 write_ok (cs.own_buf); 4324 break; 4325 case 'C': 4326 require_running_or_break (cs.own_buf); 4327 hex2bin (cs.own_buf + 1, &sig, 1); 4328 if (gdb_signal_to_host_p ((enum gdb_signal) sig)) 4329 signal = gdb_signal_to_host ((enum gdb_signal) sig); 4330 else 4331 signal = 0; 4332 myresume (cs.own_buf, 0, signal); 4333 break; 4334 case 'S': 4335 require_running_or_break (cs.own_buf); 4336 hex2bin (cs.own_buf + 1, &sig, 1); 4337 if (gdb_signal_to_host_p ((enum gdb_signal) sig)) 4338 signal = gdb_signal_to_host ((enum gdb_signal) sig); 4339 else 4340 signal = 0; 4341 myresume (cs.own_buf, 1, signal); 4342 break; 4343 case 'c': 4344 require_running_or_break (cs.own_buf); 4345 signal = 0; 4346 myresume (cs.own_buf, 0, signal); 4347 break; 4348 case 's': 4349 require_running_or_break (cs.own_buf); 4350 signal = 0; 4351 myresume (cs.own_buf, 1, signal); 4352 break; 4353 case 'Z': /* insert_ ... */ 4354 /* Fallthrough. */ 4355 case 'z': /* remove_ ... */ 4356 { 4357 char *dataptr; 4358 ULONGEST addr; 4359 int kind; 4360 char type = cs.own_buf[1]; 4361 int res; 4362 const int insert = ch == 'Z'; 4363 const char *p = &cs.own_buf[3]; 4364 4365 p = unpack_varlen_hex (p, &addr); 4366 kind = strtol (p + 1, &dataptr, 16); 4367 4368 if (insert) 4369 { 4370 struct gdb_breakpoint *bp; 4371 4372 bp = set_gdb_breakpoint (type, addr, kind, &res); 4373 if (bp != NULL) 4374 { 4375 res = 0; 4376 4377 /* GDB may have sent us a list of *point parameters to 4378 be evaluated on the target's side. Read such list 4379 here. If we already have a list of parameters, GDB 4380 is telling us to drop that list and use this one 4381 instead. */ 4382 clear_breakpoint_conditions_and_commands (bp); 4383 const char *options = dataptr; 4384 process_point_options (bp, &options); 4385 } 4386 } 4387 else 4388 res = delete_gdb_breakpoint (type, addr, kind); 4389 4390 if (res == 0) 4391 write_ok (cs.own_buf); 4392 else if (res == 1) 4393 /* Unsupported. */ 4394 cs.own_buf[0] = '\0'; 4395 else 4396 write_enn (cs.own_buf); 4397 break; 4398 } 4399 case 'k': 4400 response_needed = false; 4401 if (!target_running ()) 4402 /* The packet we received doesn't make sense - but we can't 4403 reply to it, either. */ 4404 return 0; 4405 4406 fprintf (stderr, "Killing all inferiors\n"); 4407 4408 for_each_process (kill_inferior_callback); 4409 4410 /* When using the extended protocol, we wait with no program 4411 running. The traditional protocol will exit instead. */ 4412 if (extended_protocol) 4413 { 4414 cs.last_status.set_exited (GDB_SIGNAL_KILL); 4415 return 0; 4416 } 4417 else 4418 exit (0); 4419 4420 case 'T': 4421 { 4422 require_running_or_break (cs.own_buf); 4423 4424 ptid_t thread_id = read_ptid (&cs.own_buf[1], NULL); 4425 if (find_thread_ptid (thread_id) == NULL) 4426 { 4427 write_enn (cs.own_buf); 4428 break; 4429 } 4430 4431 if (mythread_alive (thread_id)) 4432 write_ok (cs.own_buf); 4433 else 4434 write_enn (cs.own_buf); 4435 } 4436 break; 4437 case 'R': 4438 response_needed = false; 4439 4440 /* Restarting the inferior is only supported in the extended 4441 protocol. */ 4442 if (extended_protocol) 4443 { 4444 if (target_running ()) 4445 for_each_process (kill_inferior_callback); 4446 4447 fprintf (stderr, "GDBserver restarting\n"); 4448 4449 /* Wait till we are at 1st instruction in prog. */ 4450 if (program_path.get () != NULL) 4451 { 4452 target_create_inferior (program_path.get (), program_args); 4453 4454 if (cs.last_status.kind () == TARGET_WAITKIND_STOPPED) 4455 { 4456 /* Stopped at the first instruction of the target 4457 process. */ 4458 cs.general_thread = cs.last_ptid; 4459 } 4460 else 4461 { 4462 /* Something went wrong. */ 4463 cs.general_thread = null_ptid; 4464 } 4465 } 4466 else 4467 { 4468 cs.last_status.set_exited (GDB_SIGNAL_KILL); 4469 } 4470 return 0; 4471 } 4472 else 4473 { 4474 /* It is a request we don't understand. Respond with an 4475 empty packet so that gdb knows that we don't support this 4476 request. */ 4477 cs.own_buf[0] = '\0'; 4478 break; 4479 } 4480 case 'v': 4481 /* Extended (long) request. */ 4482 handle_v_requests (cs.own_buf, packet_len, &new_packet_len); 4483 break; 4484 4485 default: 4486 /* It is a request we don't understand. Respond with an empty 4487 packet so that gdb knows that we don't support this 4488 request. */ 4489 cs.own_buf[0] = '\0'; 4490 break; 4491 } 4492 4493 if (new_packet_len != -1) 4494 putpkt_binary (cs.own_buf, new_packet_len); 4495 else 4496 putpkt (cs.own_buf); 4497 4498 response_needed = false; 4499 4500 if (exit_requested) 4501 return -1; 4502 4503 return 0; 4504} 4505 4506/* Event-loop callback for serial events. */ 4507 4508void 4509handle_serial_event (int err, gdb_client_data client_data) 4510{ 4511 threads_debug_printf ("handling possible serial event"); 4512 4513 /* Really handle it. */ 4514 if (process_serial_event () < 0) 4515 { 4516 keep_processing_events = false; 4517 return; 4518 } 4519 4520 /* Be sure to not change the selected thread behind GDB's back. 4521 Important in the non-stop mode asynchronous protocol. */ 4522 set_desired_thread (); 4523} 4524 4525/* Push a stop notification on the notification queue. */ 4526 4527static void 4528push_stop_notification (ptid_t ptid, const target_waitstatus &status) 4529{ 4530 struct vstop_notif *vstop_notif = new struct vstop_notif; 4531 4532 vstop_notif->status = status; 4533 vstop_notif->ptid = ptid; 4534 /* Push Stop notification. */ 4535 notif_push (¬if_stop, vstop_notif); 4536} 4537 4538/* Event-loop callback for target events. */ 4539 4540void 4541handle_target_event (int err, gdb_client_data client_data) 4542{ 4543 client_state &cs = get_client_state (); 4544 threads_debug_printf ("handling possible target event"); 4545 4546 cs.last_ptid = mywait (minus_one_ptid, &cs.last_status, 4547 TARGET_WNOHANG, 1); 4548 4549 if (cs.last_status.kind () == TARGET_WAITKIND_NO_RESUMED) 4550 { 4551 if (gdb_connected () && report_no_resumed) 4552 push_stop_notification (null_ptid, cs.last_status); 4553 } 4554 else if (cs.last_status.kind () != TARGET_WAITKIND_IGNORE) 4555 { 4556 int pid = cs.last_ptid.pid (); 4557 struct process_info *process = find_process_pid (pid); 4558 int forward_event = !gdb_connected () || process->gdb_detached; 4559 4560 if (cs.last_status.kind () == TARGET_WAITKIND_EXITED 4561 || cs.last_status.kind () == TARGET_WAITKIND_SIGNALLED) 4562 { 4563 mark_breakpoints_out (process); 4564 target_mourn_inferior (cs.last_ptid); 4565 } 4566 else if (cs.last_status.kind () == TARGET_WAITKIND_THREAD_EXITED) 4567 ; 4568 else 4569 { 4570 /* We're reporting this thread as stopped. Update its 4571 "want-stopped" state to what the client wants, until it 4572 gets a new resume action. */ 4573 current_thread->last_resume_kind = resume_stop; 4574 current_thread->last_status = cs.last_status; 4575 } 4576 4577 if (forward_event) 4578 { 4579 if (!target_running ()) 4580 { 4581 /* The last process exited. We're done. */ 4582 exit (0); 4583 } 4584 4585 if (cs.last_status.kind () == TARGET_WAITKIND_EXITED 4586 || cs.last_status.kind () == TARGET_WAITKIND_SIGNALLED 4587 || cs.last_status.kind () == TARGET_WAITKIND_THREAD_EXITED) 4588 ; 4589 else 4590 { 4591 /* A thread stopped with a signal, but gdb isn't 4592 connected to handle it. Pass it down to the 4593 inferior, as if it wasn't being traced. */ 4594 enum gdb_signal signal; 4595 4596 threads_debug_printf ("GDB not connected; forwarding event %d for" 4597 " [%s]", 4598 (int) cs.last_status.kind (), 4599 target_pid_to_str (cs.last_ptid).c_str ()); 4600 4601 if (cs.last_status.kind () == TARGET_WAITKIND_STOPPED) 4602 signal = cs.last_status.sig (); 4603 else 4604 signal = GDB_SIGNAL_0; 4605 target_continue (cs.last_ptid, signal); 4606 } 4607 } 4608 else 4609 push_stop_notification (cs.last_ptid, cs.last_status); 4610 } 4611 4612 /* Be sure to not change the selected thread behind GDB's back. 4613 Important in the non-stop mode asynchronous protocol. */ 4614 set_desired_thread (); 4615} 4616 4617/* See gdbsupport/event-loop.h. */ 4618 4619int 4620invoke_async_signal_handlers () 4621{ 4622 return 0; 4623} 4624 4625/* See gdbsupport/event-loop.h. */ 4626 4627int 4628check_async_event_handlers () 4629{ 4630 return 0; 4631} 4632 4633/* See gdbsupport/errors.h */ 4634 4635void 4636flush_streams () 4637{ 4638 fflush (stdout); 4639 fflush (stderr); 4640} 4641 4642/* See gdbsupport/gdb_select.h. */ 4643 4644int 4645gdb_select (int n, fd_set *readfds, fd_set *writefds, 4646 fd_set *exceptfds, struct timeval *timeout) 4647{ 4648 return select (n, readfds, writefds, exceptfds, timeout); 4649} 4650 4651#if GDB_SELF_TEST 4652namespace selftests 4653{ 4654 4655void 4656reset () 4657{} 4658 4659} // namespace selftests 4660#endif /* GDB_SELF_TEST */ 4661