remote.c revision 1.9
1/* Remote target communications for serial-line targets in custom GDB protocol 2 3 Copyright (C) 1988-2020 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20/* See the GDB User Guide for details of the GDB remote protocol. */ 21 22#include "defs.h" 23#include <ctype.h> 24#include <fcntl.h> 25#include "inferior.h" 26#include "infrun.h" 27#include "bfd.h" 28#include "symfile.h" 29#include "target.h" 30#include "process-stratum-target.h" 31#include "gdbcmd.h" 32#include "objfiles.h" 33#include "gdb-stabs.h" 34#include "gdbthread.h" 35#include "remote.h" 36#include "remote-notif.h" 37#include "regcache.h" 38#include "value.h" 39#include "observable.h" 40#include "solib.h" 41#include "cli/cli-decode.h" 42#include "cli/cli-setshow.h" 43#include "target-descriptions.h" 44#include "gdb_bfd.h" 45#include "gdbsupport/filestuff.h" 46#include "gdbsupport/rsp-low.h" 47#include "disasm.h" 48#include "location.h" 49 50#include "gdbsupport/gdb_sys_time.h" 51 52#include "gdbsupport/event-loop.h" 53#include "event-top.h" 54#include "inf-loop.h" 55 56#include <signal.h> 57#include "serial.h" 58 59#include "gdbcore.h" /* for exec_bfd */ 60 61#include "remote-fileio.h" 62#include "gdb/fileio.h" 63#include <sys/stat.h> 64#include "xml-support.h" 65 66#include "memory-map.h" 67 68#include "tracepoint.h" 69#include "ax.h" 70#include "ax-gdb.h" 71#include "gdbsupport/agent.h" 72#include "btrace.h" 73#include "record-btrace.h" 74#include <algorithm> 75#include "gdbsupport/scoped_restore.h" 76#include "gdbsupport/environ.h" 77#include "gdbsupport/byte-vector.h" 78#include <algorithm> 79#include <unordered_map> 80#include "async-event.h" 81 82/* The remote target. */ 83 84static const char remote_doc[] = N_("\ 85Use a remote computer via a serial line, using a gdb-specific protocol.\n\ 86Specify the serial device it is connected to\n\ 87(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."); 88 89#define OPAQUETHREADBYTES 8 90 91/* a 64 bit opaque identifier */ 92typedef unsigned char threadref[OPAQUETHREADBYTES]; 93 94struct gdb_ext_thread_info; 95struct threads_listing_context; 96typedef int (*rmt_thread_action) (threadref *ref, void *context); 97struct protocol_feature; 98struct packet_reg; 99 100struct stop_reply; 101typedef std::unique_ptr<stop_reply> stop_reply_up; 102 103/* Generic configuration support for packets the stub optionally 104 supports. Allows the user to specify the use of the packet as well 105 as allowing GDB to auto-detect support in the remote stub. */ 106 107enum packet_support 108 { 109 PACKET_SUPPORT_UNKNOWN = 0, 110 PACKET_ENABLE, 111 PACKET_DISABLE 112 }; 113 114/* Analyze a packet's return value and update the packet config 115 accordingly. */ 116 117enum packet_result 118{ 119 PACKET_ERROR, 120 PACKET_OK, 121 PACKET_UNKNOWN 122}; 123 124struct threads_listing_context; 125 126/* Stub vCont actions support. 127 128 Each field is a boolean flag indicating whether the stub reports 129 support for the corresponding action. */ 130 131struct vCont_action_support 132{ 133 /* vCont;t */ 134 bool t = false; 135 136 /* vCont;r */ 137 bool r = false; 138 139 /* vCont;s */ 140 bool s = false; 141 142 /* vCont;S */ 143 bool S = false; 144}; 145 146/* About this many threadids fit in a packet. */ 147 148#define MAXTHREADLISTRESULTS 32 149 150/* Data for the vFile:pread readahead cache. */ 151 152struct readahead_cache 153{ 154 /* Invalidate the readahead cache. */ 155 void invalidate (); 156 157 /* Invalidate the readahead cache if it is holding data for FD. */ 158 void invalidate_fd (int fd); 159 160 /* Serve pread from the readahead cache. Returns number of bytes 161 read, or 0 if the request can't be served from the cache. */ 162 int pread (int fd, gdb_byte *read_buf, size_t len, ULONGEST offset); 163 164 /* The file descriptor for the file that is being cached. -1 if the 165 cache is invalid. */ 166 int fd = -1; 167 168 /* The offset into the file that the cache buffer corresponds 169 to. */ 170 ULONGEST offset = 0; 171 172 /* The buffer holding the cache contents. */ 173 gdb_byte *buf = nullptr; 174 /* The buffer's size. We try to read as much as fits into a packet 175 at a time. */ 176 size_t bufsize = 0; 177 178 /* Cache hit and miss counters. */ 179 ULONGEST hit_count = 0; 180 ULONGEST miss_count = 0; 181}; 182 183/* Description of the remote protocol for a given architecture. */ 184 185struct packet_reg 186{ 187 long offset; /* Offset into G packet. */ 188 long regnum; /* GDB's internal register number. */ 189 LONGEST pnum; /* Remote protocol register number. */ 190 int in_g_packet; /* Always part of G packet. */ 191 /* long size in bytes; == register_size (target_gdbarch (), regnum); 192 at present. */ 193 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum); 194 at present. */ 195}; 196 197struct remote_arch_state 198{ 199 explicit remote_arch_state (struct gdbarch *gdbarch); 200 201 /* Description of the remote protocol registers. */ 202 long sizeof_g_packet; 203 204 /* Description of the remote protocol registers indexed by REGNUM 205 (making an array gdbarch_num_regs in size). */ 206 std::unique_ptr<packet_reg[]> regs; 207 208 /* This is the size (in chars) of the first response to the ``g'' 209 packet. It is used as a heuristic when determining the maximum 210 size of memory-read and memory-write packets. A target will 211 typically only reserve a buffer large enough to hold the ``g'' 212 packet. The size does not include packet overhead (headers and 213 trailers). */ 214 long actual_register_packet_size; 215 216 /* This is the maximum size (in chars) of a non read/write packet. 217 It is also used as a cap on the size of read/write packets. */ 218 long remote_packet_size; 219}; 220 221/* Description of the remote protocol state for the currently 222 connected target. This is per-target state, and independent of the 223 selected architecture. */ 224 225class remote_state 226{ 227public: 228 229 remote_state (); 230 ~remote_state (); 231 232 /* Get the remote arch state for GDBARCH. */ 233 struct remote_arch_state *get_remote_arch_state (struct gdbarch *gdbarch); 234 235public: /* data */ 236 237 /* A buffer to use for incoming packets, and its current size. The 238 buffer is grown dynamically for larger incoming packets. 239 Outgoing packets may also be constructed in this buffer. 240 The size of the buffer is always at least REMOTE_PACKET_SIZE; 241 REMOTE_PACKET_SIZE should be used to limit the length of outgoing 242 packets. */ 243 gdb::char_vector buf; 244 245 /* True if we're going through initial connection setup (finding out 246 about the remote side's threads, relocating symbols, etc.). */ 247 bool starting_up = false; 248 249 /* If we negotiated packet size explicitly (and thus can bypass 250 heuristics for the largest packet size that will not overflow 251 a buffer in the stub), this will be set to that packet size. 252 Otherwise zero, meaning to use the guessed size. */ 253 long explicit_packet_size = 0; 254 255 /* remote_wait is normally called when the target is running and 256 waits for a stop reply packet. But sometimes we need to call it 257 when the target is already stopped. We can send a "?" packet 258 and have remote_wait read the response. Or, if we already have 259 the response, we can stash it in BUF and tell remote_wait to 260 skip calling getpkt. This flag is set when BUF contains a 261 stop reply packet and the target is not waiting. */ 262 int cached_wait_status = 0; 263 264 /* True, if in no ack mode. That is, neither GDB nor the stub will 265 expect acks from each other. The connection is assumed to be 266 reliable. */ 267 bool noack_mode = false; 268 269 /* True if we're connected in extended remote mode. */ 270 bool extended = false; 271 272 /* True if we resumed the target and we're waiting for the target to 273 stop. In the mean time, we can't start another command/query. 274 The remote server wouldn't be ready to process it, so we'd 275 timeout waiting for a reply that would never come and eventually 276 we'd close the connection. This can happen in asynchronous mode 277 because we allow GDB commands while the target is running. */ 278 bool waiting_for_stop_reply = false; 279 280 /* The status of the stub support for the various vCont actions. */ 281 vCont_action_support supports_vCont; 282 /* Whether vCont support was probed already. This is a workaround 283 until packet_support is per-connection. */ 284 bool supports_vCont_probed; 285 286 /* True if the user has pressed Ctrl-C, but the target hasn't 287 responded to that. */ 288 bool ctrlc_pending_p = false; 289 290 /* True if we saw a Ctrl-C while reading or writing from/to the 291 remote descriptor. At that point it is not safe to send a remote 292 interrupt packet, so we instead remember we saw the Ctrl-C and 293 process it once we're done with sending/receiving the current 294 packet, which should be shortly. If however that takes too long, 295 and the user presses Ctrl-C again, we offer to disconnect. */ 296 bool got_ctrlc_during_io = false; 297 298 /* Descriptor for I/O to remote machine. Initialize it to NULL so that 299 remote_open knows that we don't have a file open when the program 300 starts. */ 301 struct serial *remote_desc = nullptr; 302 303 /* These are the threads which we last sent to the remote system. The 304 TID member will be -1 for all or -2 for not sent yet. */ 305 ptid_t general_thread = null_ptid; 306 ptid_t continue_thread = null_ptid; 307 308 /* This is the traceframe which we last selected on the remote system. 309 It will be -1 if no traceframe is selected. */ 310 int remote_traceframe_number = -1; 311 312 char *last_pass_packet = nullptr; 313 314 /* The last QProgramSignals packet sent to the target. We bypass 315 sending a new program signals list down to the target if the new 316 packet is exactly the same as the last we sent. IOW, we only let 317 the target know about program signals list changes. */ 318 char *last_program_signals_packet = nullptr; 319 320 gdb_signal last_sent_signal = GDB_SIGNAL_0; 321 322 bool last_sent_step = false; 323 324 /* The execution direction of the last resume we got. */ 325 exec_direction_kind last_resume_exec_dir = EXEC_FORWARD; 326 327 char *finished_object = nullptr; 328 char *finished_annex = nullptr; 329 ULONGEST finished_offset = 0; 330 331 /* Should we try the 'ThreadInfo' query packet? 332 333 This variable (NOT available to the user: auto-detect only!) 334 determines whether GDB will use the new, simpler "ThreadInfo" 335 query or the older, more complex syntax for thread queries. 336 This is an auto-detect variable (set to true at each connect, 337 and set to false when the target fails to recognize it). */ 338 bool use_threadinfo_query = false; 339 bool use_threadextra_query = false; 340 341 threadref echo_nextthread {}; 342 threadref nextthread {}; 343 threadref resultthreadlist[MAXTHREADLISTRESULTS] {}; 344 345 /* The state of remote notification. */ 346 struct remote_notif_state *notif_state = nullptr; 347 348 /* The branch trace configuration. */ 349 struct btrace_config btrace_config {}; 350 351 /* The argument to the last "vFile:setfs:" packet we sent, used 352 to avoid sending repeated unnecessary "vFile:setfs:" packets. 353 Initialized to -1 to indicate that no "vFile:setfs:" packet 354 has yet been sent. */ 355 int fs_pid = -1; 356 357 /* A readahead cache for vFile:pread. Often, reading a binary 358 involves a sequence of small reads. E.g., when parsing an ELF 359 file. A readahead cache helps mostly the case of remote 360 debugging on a connection with higher latency, due to the 361 request/reply nature of the RSP. We only cache data for a single 362 file descriptor at a time. */ 363 struct readahead_cache readahead_cache; 364 365 /* The list of already fetched and acknowledged stop events. This 366 queue is used for notification Stop, and other notifications 367 don't need queue for their events, because the notification 368 events of Stop can't be consumed immediately, so that events 369 should be queued first, and be consumed by remote_wait_{ns,as} 370 one per time. Other notifications can consume their events 371 immediately, so queue is not needed for them. */ 372 std::vector<stop_reply_up> stop_reply_queue; 373 374 /* Asynchronous signal handle registered as event loop source for 375 when we have pending events ready to be passed to the core. */ 376 struct async_event_handler *remote_async_inferior_event_token = nullptr; 377 378 /* FIXME: cagney/1999-09-23: Even though getpkt was called with 379 ``forever'' still use the normal timeout mechanism. This is 380 currently used by the ASYNC code to guarentee that target reads 381 during the initial connect always time-out. Once getpkt has been 382 modified to return a timeout indication and, in turn 383 remote_wait()/wait_for_inferior() have gained a timeout parameter 384 this can go away. */ 385 int wait_forever_enabled_p = 1; 386 387private: 388 /* Mapping of remote protocol data for each gdbarch. Usually there 389 is only one entry here, though we may see more with stubs that 390 support multi-process. */ 391 std::unordered_map<struct gdbarch *, remote_arch_state> 392 m_arch_states; 393}; 394 395static const target_info remote_target_info = { 396 "remote", 397 N_("Remote serial target in gdb-specific protocol"), 398 remote_doc 399}; 400 401class remote_target : public process_stratum_target 402{ 403public: 404 remote_target () = default; 405 ~remote_target () override; 406 407 const target_info &info () const override 408 { return remote_target_info; } 409 410 const char *connection_string () override; 411 412 thread_control_capabilities get_thread_control_capabilities () override 413 { return tc_schedlock; } 414 415 /* Open a remote connection. */ 416 static void open (const char *, int); 417 418 void close () override; 419 420 void detach (inferior *, int) override; 421 void disconnect (const char *, int) override; 422 423 void commit_resume () override; 424 void resume (ptid_t, int, enum gdb_signal) override; 425 ptid_t wait (ptid_t, struct target_waitstatus *, int) override; 426 427 void fetch_registers (struct regcache *, int) override; 428 void store_registers (struct regcache *, int) override; 429 void prepare_to_store (struct regcache *) override; 430 431 void files_info () override; 432 433 int insert_breakpoint (struct gdbarch *, struct bp_target_info *) override; 434 435 int remove_breakpoint (struct gdbarch *, struct bp_target_info *, 436 enum remove_bp_reason) override; 437 438 439 bool stopped_by_sw_breakpoint () override; 440 bool supports_stopped_by_sw_breakpoint () override; 441 442 bool stopped_by_hw_breakpoint () override; 443 444 bool supports_stopped_by_hw_breakpoint () override; 445 446 bool stopped_by_watchpoint () override; 447 448 bool stopped_data_address (CORE_ADDR *) override; 449 450 bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override; 451 452 int can_use_hw_breakpoint (enum bptype, int, int) override; 453 454 int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override; 455 456 int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override; 457 458 int region_ok_for_hw_watchpoint (CORE_ADDR, int) override; 459 460 int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, 461 struct expression *) override; 462 463 int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, 464 struct expression *) override; 465 466 void kill () override; 467 468 void load (const char *, int) override; 469 470 void mourn_inferior () override; 471 472 void pass_signals (gdb::array_view<const unsigned char>) override; 473 474 int set_syscall_catchpoint (int, bool, int, 475 gdb::array_view<const int>) override; 476 477 void program_signals (gdb::array_view<const unsigned char>) override; 478 479 bool thread_alive (ptid_t ptid) override; 480 481 const char *thread_name (struct thread_info *) override; 482 483 void update_thread_list () override; 484 485 std::string pid_to_str (ptid_t) override; 486 487 const char *extra_thread_info (struct thread_info *) override; 488 489 ptid_t get_ada_task_ptid (long lwp, long thread) override; 490 491 thread_info *thread_handle_to_thread_info (const gdb_byte *thread_handle, 492 int handle_len, 493 inferior *inf) override; 494 495 gdb::byte_vector thread_info_to_thread_handle (struct thread_info *tp) 496 override; 497 498 void stop (ptid_t) override; 499 500 void interrupt () override; 501 502 void pass_ctrlc () override; 503 504 enum target_xfer_status xfer_partial (enum target_object object, 505 const char *annex, 506 gdb_byte *readbuf, 507 const gdb_byte *writebuf, 508 ULONGEST offset, ULONGEST len, 509 ULONGEST *xfered_len) override; 510 511 ULONGEST get_memory_xfer_limit () override; 512 513 void rcmd (const char *command, struct ui_file *output) override; 514 515 char *pid_to_exec_file (int pid) override; 516 517 void log_command (const char *cmd) override 518 { 519 serial_log_command (this, cmd); 520 } 521 522 CORE_ADDR get_thread_local_address (ptid_t ptid, 523 CORE_ADDR load_module_addr, 524 CORE_ADDR offset) override; 525 526 bool can_execute_reverse () override; 527 528 std::vector<mem_region> memory_map () override; 529 530 void flash_erase (ULONGEST address, LONGEST length) override; 531 532 void flash_done () override; 533 534 const struct target_desc *read_description () override; 535 536 int search_memory (CORE_ADDR start_addr, ULONGEST search_space_len, 537 const gdb_byte *pattern, ULONGEST pattern_len, 538 CORE_ADDR *found_addrp) override; 539 540 bool can_async_p () override; 541 542 bool is_async_p () override; 543 544 void async (int) override; 545 546 int async_wait_fd () override; 547 548 void thread_events (int) override; 549 550 int can_do_single_step () override; 551 552 void terminal_inferior () override; 553 554 void terminal_ours () override; 555 556 bool supports_non_stop () override; 557 558 bool supports_multi_process () override; 559 560 bool supports_disable_randomization () override; 561 562 bool filesystem_is_local () override; 563 564 565 int fileio_open (struct inferior *inf, const char *filename, 566 int flags, int mode, int warn_if_slow, 567 int *target_errno) override; 568 569 int fileio_pwrite (int fd, const gdb_byte *write_buf, int len, 570 ULONGEST offset, int *target_errno) override; 571 572 int fileio_pread (int fd, gdb_byte *read_buf, int len, 573 ULONGEST offset, int *target_errno) override; 574 575 int fileio_fstat (int fd, struct stat *sb, int *target_errno) override; 576 577 int fileio_close (int fd, int *target_errno) override; 578 579 int fileio_unlink (struct inferior *inf, 580 const char *filename, 581 int *target_errno) override; 582 583 gdb::optional<std::string> 584 fileio_readlink (struct inferior *inf, 585 const char *filename, 586 int *target_errno) override; 587 588 bool supports_enable_disable_tracepoint () override; 589 590 bool supports_string_tracing () override; 591 592 bool supports_evaluation_of_breakpoint_conditions () override; 593 594 bool can_run_breakpoint_commands () override; 595 596 void trace_init () override; 597 598 void download_tracepoint (struct bp_location *location) override; 599 600 bool can_download_tracepoint () override; 601 602 void download_trace_state_variable (const trace_state_variable &tsv) override; 603 604 void enable_tracepoint (struct bp_location *location) override; 605 606 void disable_tracepoint (struct bp_location *location) override; 607 608 void trace_set_readonly_regions () override; 609 610 void trace_start () override; 611 612 int get_trace_status (struct trace_status *ts) override; 613 614 void get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp) 615 override; 616 617 void trace_stop () override; 618 619 int trace_find (enum trace_find_type type, int num, 620 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) override; 621 622 bool get_trace_state_variable_value (int tsv, LONGEST *val) override; 623 624 int save_trace_data (const char *filename) override; 625 626 int upload_tracepoints (struct uploaded_tp **utpp) override; 627 628 int upload_trace_state_variables (struct uploaded_tsv **utsvp) override; 629 630 LONGEST get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len) override; 631 632 int get_min_fast_tracepoint_insn_len () override; 633 634 void set_disconnected_tracing (int val) override; 635 636 void set_circular_trace_buffer (int val) override; 637 638 void set_trace_buffer_size (LONGEST val) override; 639 640 bool set_trace_notes (const char *user, const char *notes, 641 const char *stopnotes) override; 642 643 int core_of_thread (ptid_t ptid) override; 644 645 int verify_memory (const gdb_byte *data, 646 CORE_ADDR memaddr, ULONGEST size) override; 647 648 649 bool get_tib_address (ptid_t ptid, CORE_ADDR *addr) override; 650 651 void set_permissions () override; 652 653 bool static_tracepoint_marker_at (CORE_ADDR, 654 struct static_tracepoint_marker *marker) 655 override; 656 657 std::vector<static_tracepoint_marker> 658 static_tracepoint_markers_by_strid (const char *id) override; 659 660 traceframe_info_up traceframe_info () override; 661 662 bool use_agent (bool use) override; 663 bool can_use_agent () override; 664 665 struct btrace_target_info *enable_btrace (ptid_t ptid, 666 const struct btrace_config *conf) override; 667 668 void disable_btrace (struct btrace_target_info *tinfo) override; 669 670 void teardown_btrace (struct btrace_target_info *tinfo) override; 671 672 enum btrace_error read_btrace (struct btrace_data *data, 673 struct btrace_target_info *btinfo, 674 enum btrace_read_type type) override; 675 676 const struct btrace_config *btrace_conf (const struct btrace_target_info *) override; 677 bool augmented_libraries_svr4_read () override; 678 bool follow_fork (bool, bool) override; 679 void follow_exec (struct inferior *, const char *) override; 680 int insert_fork_catchpoint (int) override; 681 int remove_fork_catchpoint (int) override; 682 int insert_vfork_catchpoint (int) override; 683 int remove_vfork_catchpoint (int) override; 684 int insert_exec_catchpoint (int) override; 685 int remove_exec_catchpoint (int) override; 686 enum exec_direction_kind execution_direction () override; 687 688public: /* Remote specific methods. */ 689 690 void remote_download_command_source (int num, ULONGEST addr, 691 struct command_line *cmds); 692 693 void remote_file_put (const char *local_file, const char *remote_file, 694 int from_tty); 695 void remote_file_get (const char *remote_file, const char *local_file, 696 int from_tty); 697 void remote_file_delete (const char *remote_file, int from_tty); 698 699 int remote_hostio_pread (int fd, gdb_byte *read_buf, int len, 700 ULONGEST offset, int *remote_errno); 701 int remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len, 702 ULONGEST offset, int *remote_errno); 703 int remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len, 704 ULONGEST offset, int *remote_errno); 705 706 int remote_hostio_send_command (int command_bytes, int which_packet, 707 int *remote_errno, char **attachment, 708 int *attachment_len); 709 int remote_hostio_set_filesystem (struct inferior *inf, 710 int *remote_errno); 711 /* We should get rid of this and use fileio_open directly. */ 712 int remote_hostio_open (struct inferior *inf, const char *filename, 713 int flags, int mode, int warn_if_slow, 714 int *remote_errno); 715 int remote_hostio_close (int fd, int *remote_errno); 716 717 int remote_hostio_unlink (inferior *inf, const char *filename, 718 int *remote_errno); 719 720 struct remote_state *get_remote_state (); 721 722 long get_remote_packet_size (void); 723 long get_memory_packet_size (struct memory_packet_config *config); 724 725 long get_memory_write_packet_size (); 726 long get_memory_read_packet_size (); 727 728 char *append_pending_thread_resumptions (char *p, char *endp, 729 ptid_t ptid); 730 static void open_1 (const char *name, int from_tty, int extended_p); 731 void start_remote (int from_tty, int extended_p); 732 void remote_detach_1 (struct inferior *inf, int from_tty); 733 734 char *append_resumption (char *p, char *endp, 735 ptid_t ptid, int step, gdb_signal siggnal); 736 int remote_resume_with_vcont (ptid_t ptid, int step, 737 gdb_signal siggnal); 738 739 void add_current_inferior_and_thread (char *wait_status); 740 741 ptid_t wait_ns (ptid_t ptid, struct target_waitstatus *status, 742 int options); 743 ptid_t wait_as (ptid_t ptid, target_waitstatus *status, 744 int options); 745 746 ptid_t process_stop_reply (struct stop_reply *stop_reply, 747 target_waitstatus *status); 748 749 void remote_notice_new_inferior (ptid_t currthread, int executing); 750 751 void process_initial_stop_replies (int from_tty); 752 753 thread_info *remote_add_thread (ptid_t ptid, bool running, bool executing); 754 755 void btrace_sync_conf (const btrace_config *conf); 756 757 void remote_btrace_maybe_reopen (); 758 759 void remove_new_fork_children (threads_listing_context *context); 760 void kill_new_fork_children (int pid); 761 void discard_pending_stop_replies (struct inferior *inf); 762 int stop_reply_queue_length (); 763 764 void check_pending_events_prevent_wildcard_vcont 765 (int *may_global_wildcard_vcont); 766 767 void discard_pending_stop_replies_in_queue (); 768 struct stop_reply *remote_notif_remove_queued_reply (ptid_t ptid); 769 struct stop_reply *queued_stop_reply (ptid_t ptid); 770 int peek_stop_reply (ptid_t ptid); 771 void remote_parse_stop_reply (const char *buf, stop_reply *event); 772 773 void remote_stop_ns (ptid_t ptid); 774 void remote_interrupt_as (); 775 void remote_interrupt_ns (); 776 777 char *remote_get_noisy_reply (); 778 int remote_query_attached (int pid); 779 inferior *remote_add_inferior (bool fake_pid_p, int pid, int attached, 780 int try_open_exec); 781 782 ptid_t remote_current_thread (ptid_t oldpid); 783 ptid_t get_current_thread (char *wait_status); 784 785 void set_thread (ptid_t ptid, int gen); 786 void set_general_thread (ptid_t ptid); 787 void set_continue_thread (ptid_t ptid); 788 void set_general_process (); 789 790 char *write_ptid (char *buf, const char *endbuf, ptid_t ptid); 791 792 int remote_unpack_thread_info_response (char *pkt, threadref *expectedref, 793 gdb_ext_thread_info *info); 794 int remote_get_threadinfo (threadref *threadid, int fieldset, 795 gdb_ext_thread_info *info); 796 797 int parse_threadlist_response (char *pkt, int result_limit, 798 threadref *original_echo, 799 threadref *resultlist, 800 int *doneflag); 801 int remote_get_threadlist (int startflag, threadref *nextthread, 802 int result_limit, int *done, int *result_count, 803 threadref *threadlist); 804 805 int remote_threadlist_iterator (rmt_thread_action stepfunction, 806 void *context, int looplimit); 807 808 int remote_get_threads_with_ql (threads_listing_context *context); 809 int remote_get_threads_with_qxfer (threads_listing_context *context); 810 int remote_get_threads_with_qthreadinfo (threads_listing_context *context); 811 812 void extended_remote_restart (); 813 814 void get_offsets (); 815 816 void remote_check_symbols (); 817 818 void remote_supported_packet (const struct protocol_feature *feature, 819 enum packet_support support, 820 const char *argument); 821 822 void remote_query_supported (); 823 824 void remote_packet_size (const protocol_feature *feature, 825 packet_support support, const char *value); 826 827 void remote_serial_quit_handler (); 828 829 void remote_detach_pid (int pid); 830 831 void remote_vcont_probe (); 832 833 void remote_resume_with_hc (ptid_t ptid, int step, 834 gdb_signal siggnal); 835 836 void send_interrupt_sequence (); 837 void interrupt_query (); 838 839 void remote_notif_get_pending_events (notif_client *nc); 840 841 int fetch_register_using_p (struct regcache *regcache, 842 packet_reg *reg); 843 int send_g_packet (); 844 void process_g_packet (struct regcache *regcache); 845 void fetch_registers_using_g (struct regcache *regcache); 846 int store_register_using_P (const struct regcache *regcache, 847 packet_reg *reg); 848 void store_registers_using_G (const struct regcache *regcache); 849 850 void set_remote_traceframe (); 851 852 void check_binary_download (CORE_ADDR addr); 853 854 target_xfer_status remote_write_bytes_aux (const char *header, 855 CORE_ADDR memaddr, 856 const gdb_byte *myaddr, 857 ULONGEST len_units, 858 int unit_size, 859 ULONGEST *xfered_len_units, 860 char packet_format, 861 int use_length); 862 863 target_xfer_status remote_write_bytes (CORE_ADDR memaddr, 864 const gdb_byte *myaddr, ULONGEST len, 865 int unit_size, ULONGEST *xfered_len); 866 867 target_xfer_status remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr, 868 ULONGEST len_units, 869 int unit_size, ULONGEST *xfered_len_units); 870 871 target_xfer_status remote_xfer_live_readonly_partial (gdb_byte *readbuf, 872 ULONGEST memaddr, 873 ULONGEST len, 874 int unit_size, 875 ULONGEST *xfered_len); 876 877 target_xfer_status remote_read_bytes (CORE_ADDR memaddr, 878 gdb_byte *myaddr, ULONGEST len, 879 int unit_size, 880 ULONGEST *xfered_len); 881 882 packet_result remote_send_printf (const char *format, ...) 883 ATTRIBUTE_PRINTF (2, 3); 884 885 target_xfer_status remote_flash_write (ULONGEST address, 886 ULONGEST length, ULONGEST *xfered_len, 887 const gdb_byte *data); 888 889 int readchar (int timeout); 890 891 void remote_serial_write (const char *str, int len); 892 893 int putpkt (const char *buf); 894 int putpkt_binary (const char *buf, int cnt); 895 896 int putpkt (const gdb::char_vector &buf) 897 { 898 return putpkt (buf.data ()); 899 } 900 901 void skip_frame (); 902 long read_frame (gdb::char_vector *buf_p); 903 void getpkt (gdb::char_vector *buf, int forever); 904 int getpkt_or_notif_sane_1 (gdb::char_vector *buf, int forever, 905 int expecting_notif, int *is_notif); 906 int getpkt_sane (gdb::char_vector *buf, int forever); 907 int getpkt_or_notif_sane (gdb::char_vector *buf, int forever, 908 int *is_notif); 909 int remote_vkill (int pid); 910 void remote_kill_k (); 911 912 void extended_remote_disable_randomization (int val); 913 int extended_remote_run (const std::string &args); 914 915 void send_environment_packet (const char *action, 916 const char *packet, 917 const char *value); 918 919 void extended_remote_environment_support (); 920 void extended_remote_set_inferior_cwd (); 921 922 target_xfer_status remote_write_qxfer (const char *object_name, 923 const char *annex, 924 const gdb_byte *writebuf, 925 ULONGEST offset, LONGEST len, 926 ULONGEST *xfered_len, 927 struct packet_config *packet); 928 929 target_xfer_status remote_read_qxfer (const char *object_name, 930 const char *annex, 931 gdb_byte *readbuf, ULONGEST offset, 932 LONGEST len, 933 ULONGEST *xfered_len, 934 struct packet_config *packet); 935 936 void push_stop_reply (struct stop_reply *new_event); 937 938 bool vcont_r_supported (); 939 940 void packet_command (const char *args, int from_tty); 941 942private: /* data fields */ 943 944 /* The remote state. Don't reference this directly. Use the 945 get_remote_state method instead. */ 946 remote_state m_remote_state; 947}; 948 949static const target_info extended_remote_target_info = { 950 "extended-remote", 951 N_("Extended remote serial target in gdb-specific protocol"), 952 remote_doc 953}; 954 955/* Set up the extended remote target by extending the standard remote 956 target and adding to it. */ 957 958class extended_remote_target final : public remote_target 959{ 960public: 961 const target_info &info () const override 962 { return extended_remote_target_info; } 963 964 /* Open an extended-remote connection. */ 965 static void open (const char *, int); 966 967 bool can_create_inferior () override { return true; } 968 void create_inferior (const char *, const std::string &, 969 char **, int) override; 970 971 void detach (inferior *, int) override; 972 973 bool can_attach () override { return true; } 974 void attach (const char *, int) override; 975 976 void post_attach (int) override; 977 bool supports_disable_randomization () override; 978}; 979 980/* Per-program-space data key. */ 981static const struct program_space_key<char, gdb::xfree_deleter<char>> 982 remote_pspace_data; 983 984/* The variable registered as the control variable used by the 985 remote exec-file commands. While the remote exec-file setting is 986 per-program-space, the set/show machinery uses this as the 987 location of the remote exec-file value. */ 988static char *remote_exec_file_var; 989 990/* The size to align memory write packets, when practical. The protocol 991 does not guarantee any alignment, and gdb will generate short 992 writes and unaligned writes, but even as a best-effort attempt this 993 can improve bulk transfers. For instance, if a write is misaligned 994 relative to the target's data bus, the stub may need to make an extra 995 round trip fetching data from the target. This doesn't make a 996 huge difference, but it's easy to do, so we try to be helpful. 997 998 The alignment chosen is arbitrary; usually data bus width is 999 important here, not the possibly larger cache line size. */ 1000enum { REMOTE_ALIGN_WRITES = 16 }; 1001 1002/* Prototypes for local functions. */ 1003 1004static int hexnumlen (ULONGEST num); 1005 1006static int stubhex (int ch); 1007 1008static int hexnumstr (char *, ULONGEST); 1009 1010static int hexnumnstr (char *, ULONGEST, int); 1011 1012static CORE_ADDR remote_address_masked (CORE_ADDR); 1013 1014static void print_packet (const char *); 1015 1016static int stub_unpack_int (char *buff, int fieldlength); 1017 1018struct packet_config; 1019 1020static void show_packet_config_cmd (struct packet_config *config); 1021 1022static void show_remote_protocol_packet_cmd (struct ui_file *file, 1023 int from_tty, 1024 struct cmd_list_element *c, 1025 const char *value); 1026 1027static ptid_t read_ptid (const char *buf, const char **obuf); 1028 1029static void remote_async_inferior_event_handler (gdb_client_data); 1030 1031static bool remote_read_description_p (struct target_ops *target); 1032 1033static void remote_console_output (const char *msg); 1034 1035static void remote_btrace_reset (remote_state *rs); 1036 1037static void remote_unpush_and_throw (remote_target *target); 1038 1039/* For "remote". */ 1040 1041static struct cmd_list_element *remote_cmdlist; 1042 1043/* For "set remote" and "show remote". */ 1044 1045static struct cmd_list_element *remote_set_cmdlist; 1046static struct cmd_list_element *remote_show_cmdlist; 1047 1048/* Controls whether GDB is willing to use range stepping. */ 1049 1050static bool use_range_stepping = true; 1051 1052/* Private data that we'll store in (struct thread_info)->priv. */ 1053struct remote_thread_info : public private_thread_info 1054{ 1055 std::string extra; 1056 std::string name; 1057 int core = -1; 1058 1059 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a 1060 sequence of bytes. */ 1061 gdb::byte_vector thread_handle; 1062 1063 /* Whether the target stopped for a breakpoint/watchpoint. */ 1064 enum target_stop_reason stop_reason = TARGET_STOPPED_BY_NO_REASON; 1065 1066 /* This is set to the data address of the access causing the target 1067 to stop for a watchpoint. */ 1068 CORE_ADDR watch_data_address = 0; 1069 1070 /* Fields used by the vCont action coalescing implemented in 1071 remote_resume / remote_commit_resume. remote_resume stores each 1072 thread's last resume request in these fields, so that a later 1073 remote_commit_resume knows which is the proper action for this 1074 thread to include in the vCont packet. */ 1075 1076 /* True if the last target_resume call for this thread was a step 1077 request, false if a continue request. */ 1078 int last_resume_step = 0; 1079 1080 /* The signal specified in the last target_resume call for this 1081 thread. */ 1082 gdb_signal last_resume_sig = GDB_SIGNAL_0; 1083 1084 /* Whether this thread was already vCont-resumed on the remote 1085 side. */ 1086 int vcont_resumed = 0; 1087}; 1088 1089remote_state::remote_state () 1090 : buf (400) 1091{ 1092} 1093 1094remote_state::~remote_state () 1095{ 1096 xfree (this->last_pass_packet); 1097 xfree (this->last_program_signals_packet); 1098 xfree (this->finished_object); 1099 xfree (this->finished_annex); 1100} 1101 1102/* Utility: generate error from an incoming stub packet. */ 1103static void 1104trace_error (char *buf) 1105{ 1106 if (*buf++ != 'E') 1107 return; /* not an error msg */ 1108 switch (*buf) 1109 { 1110 case '1': /* malformed packet error */ 1111 if (*++buf == '0') /* general case: */ 1112 error (_("remote.c: error in outgoing packet.")); 1113 else 1114 error (_("remote.c: error in outgoing packet at field #%ld."), 1115 strtol (buf, NULL, 16)); 1116 default: 1117 error (_("Target returns error code '%s'."), buf); 1118 } 1119} 1120 1121/* Utility: wait for reply from stub, while accepting "O" packets. */ 1122 1123char * 1124remote_target::remote_get_noisy_reply () 1125{ 1126 struct remote_state *rs = get_remote_state (); 1127 1128 do /* Loop on reply from remote stub. */ 1129 { 1130 char *buf; 1131 1132 QUIT; /* Allow user to bail out with ^C. */ 1133 getpkt (&rs->buf, 0); 1134 buf = rs->buf.data (); 1135 if (buf[0] == 'E') 1136 trace_error (buf); 1137 else if (startswith (buf, "qRelocInsn:")) 1138 { 1139 ULONGEST ul; 1140 CORE_ADDR from, to, org_to; 1141 const char *p, *pp; 1142 int adjusted_size = 0; 1143 int relocated = 0; 1144 1145 p = buf + strlen ("qRelocInsn:"); 1146 pp = unpack_varlen_hex (p, &ul); 1147 if (*pp != ';') 1148 error (_("invalid qRelocInsn packet: %s"), buf); 1149 from = ul; 1150 1151 p = pp + 1; 1152 unpack_varlen_hex (p, &ul); 1153 to = ul; 1154 1155 org_to = to; 1156 1157 try 1158 { 1159 gdbarch_relocate_instruction (target_gdbarch (), &to, from); 1160 relocated = 1; 1161 } 1162 catch (const gdb_exception &ex) 1163 { 1164 if (ex.error == MEMORY_ERROR) 1165 { 1166 /* Propagate memory errors silently back to the 1167 target. The stub may have limited the range of 1168 addresses we can write to, for example. */ 1169 } 1170 else 1171 { 1172 /* Something unexpectedly bad happened. Be verbose 1173 so we can tell what, and propagate the error back 1174 to the stub, so it doesn't get stuck waiting for 1175 a response. */ 1176 exception_fprintf (gdb_stderr, ex, 1177 _("warning: relocating instruction: ")); 1178 } 1179 putpkt ("E01"); 1180 } 1181 1182 if (relocated) 1183 { 1184 adjusted_size = to - org_to; 1185 1186 xsnprintf (buf, rs->buf.size (), "qRelocInsn:%x", adjusted_size); 1187 putpkt (buf); 1188 } 1189 } 1190 else if (buf[0] == 'O' && buf[1] != 'K') 1191 remote_console_output (buf + 1); /* 'O' message from stub */ 1192 else 1193 return buf; /* Here's the actual reply. */ 1194 } 1195 while (1); 1196} 1197 1198struct remote_arch_state * 1199remote_state::get_remote_arch_state (struct gdbarch *gdbarch) 1200{ 1201 remote_arch_state *rsa; 1202 1203 auto it = this->m_arch_states.find (gdbarch); 1204 if (it == this->m_arch_states.end ()) 1205 { 1206 auto p = this->m_arch_states.emplace (std::piecewise_construct, 1207 std::forward_as_tuple (gdbarch), 1208 std::forward_as_tuple (gdbarch)); 1209 rsa = &p.first->second; 1210 1211 /* Make sure that the packet buffer is plenty big enough for 1212 this architecture. */ 1213 if (this->buf.size () < rsa->remote_packet_size) 1214 this->buf.resize (2 * rsa->remote_packet_size); 1215 } 1216 else 1217 rsa = &it->second; 1218 1219 return rsa; 1220} 1221 1222/* Fetch the global remote target state. */ 1223 1224remote_state * 1225remote_target::get_remote_state () 1226{ 1227 /* Make sure that the remote architecture state has been 1228 initialized, because doing so might reallocate rs->buf. Any 1229 function which calls getpkt also needs to be mindful of changes 1230 to rs->buf, but this call limits the number of places which run 1231 into trouble. */ 1232 m_remote_state.get_remote_arch_state (target_gdbarch ()); 1233 1234 return &m_remote_state; 1235} 1236 1237/* Fetch the remote exec-file from the current program space. */ 1238 1239static const char * 1240get_remote_exec_file (void) 1241{ 1242 char *remote_exec_file; 1243 1244 remote_exec_file = remote_pspace_data.get (current_program_space); 1245 if (remote_exec_file == NULL) 1246 return ""; 1247 1248 return remote_exec_file; 1249} 1250 1251/* Set the remote exec file for PSPACE. */ 1252 1253static void 1254set_pspace_remote_exec_file (struct program_space *pspace, 1255 const char *remote_exec_file) 1256{ 1257 char *old_file = remote_pspace_data.get (pspace); 1258 1259 xfree (old_file); 1260 remote_pspace_data.set (pspace, xstrdup (remote_exec_file)); 1261} 1262 1263/* The "set/show remote exec-file" set command hook. */ 1264 1265static void 1266set_remote_exec_file (const char *ignored, int from_tty, 1267 struct cmd_list_element *c) 1268{ 1269 gdb_assert (remote_exec_file_var != NULL); 1270 set_pspace_remote_exec_file (current_program_space, remote_exec_file_var); 1271} 1272 1273/* The "set/show remote exec-file" show command hook. */ 1274 1275static void 1276show_remote_exec_file (struct ui_file *file, int from_tty, 1277 struct cmd_list_element *cmd, const char *value) 1278{ 1279 fprintf_filtered (file, "%s\n", get_remote_exec_file ()); 1280} 1281 1282static int 1283map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs) 1284{ 1285 int regnum, num_remote_regs, offset; 1286 struct packet_reg **remote_regs; 1287 1288 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++) 1289 { 1290 struct packet_reg *r = ®s[regnum]; 1291 1292 if (register_size (gdbarch, regnum) == 0) 1293 /* Do not try to fetch zero-sized (placeholder) registers. */ 1294 r->pnum = -1; 1295 else 1296 r->pnum = gdbarch_remote_register_number (gdbarch, regnum); 1297 1298 r->regnum = regnum; 1299 } 1300 1301 /* Define the g/G packet format as the contents of each register 1302 with a remote protocol number, in order of ascending protocol 1303 number. */ 1304 1305 remote_regs = XALLOCAVEC (struct packet_reg *, gdbarch_num_regs (gdbarch)); 1306 for (num_remote_regs = 0, regnum = 0; 1307 regnum < gdbarch_num_regs (gdbarch); 1308 regnum++) 1309 if (regs[regnum].pnum != -1) 1310 remote_regs[num_remote_regs++] = ®s[regnum]; 1311 1312 std::sort (remote_regs, remote_regs + num_remote_regs, 1313 [] (const packet_reg *a, const packet_reg *b) 1314 { return a->pnum < b->pnum; }); 1315 1316 for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++) 1317 { 1318 remote_regs[regnum]->in_g_packet = 1; 1319 remote_regs[regnum]->offset = offset; 1320 offset += register_size (gdbarch, remote_regs[regnum]->regnum); 1321 } 1322 1323 return offset; 1324} 1325 1326/* Given the architecture described by GDBARCH, return the remote 1327 protocol register's number and the register's offset in the g/G 1328 packets of GDB register REGNUM, in PNUM and POFFSET respectively. 1329 If the target does not have a mapping for REGNUM, return false, 1330 otherwise, return true. */ 1331 1332int 1333remote_register_number_and_offset (struct gdbarch *gdbarch, int regnum, 1334 int *pnum, int *poffset) 1335{ 1336 gdb_assert (regnum < gdbarch_num_regs (gdbarch)); 1337 1338 std::vector<packet_reg> regs (gdbarch_num_regs (gdbarch)); 1339 1340 map_regcache_remote_table (gdbarch, regs.data ()); 1341 1342 *pnum = regs[regnum].pnum; 1343 *poffset = regs[regnum].offset; 1344 1345 return *pnum != -1; 1346} 1347 1348remote_arch_state::remote_arch_state (struct gdbarch *gdbarch) 1349{ 1350 /* Use the architecture to build a regnum<->pnum table, which will be 1351 1:1 unless a feature set specifies otherwise. */ 1352 this->regs.reset (new packet_reg [gdbarch_num_regs (gdbarch)] ()); 1353 1354 /* Record the maximum possible size of the g packet - it may turn out 1355 to be smaller. */ 1356 this->sizeof_g_packet 1357 = map_regcache_remote_table (gdbarch, this->regs.get ()); 1358 1359 /* Default maximum number of characters in a packet body. Many 1360 remote stubs have a hardwired buffer size of 400 bytes 1361 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used 1362 as the maximum packet-size to ensure that the packet and an extra 1363 NUL character can always fit in the buffer. This stops GDB 1364 trashing stubs that try to squeeze an extra NUL into what is 1365 already a full buffer (As of 1999-12-04 that was most stubs). */ 1366 this->remote_packet_size = 400 - 1; 1367 1368 /* This one is filled in when a ``g'' packet is received. */ 1369 this->actual_register_packet_size = 0; 1370 1371 /* Should rsa->sizeof_g_packet needs more space than the 1372 default, adjust the size accordingly. Remember that each byte is 1373 encoded as two characters. 32 is the overhead for the packet 1374 header / footer. NOTE: cagney/1999-10-26: I suspect that 8 1375 (``$NN:G...#NN'') is a better guess, the below has been padded a 1376 little. */ 1377 if (this->sizeof_g_packet > ((this->remote_packet_size - 32) / 2)) 1378 this->remote_packet_size = (this->sizeof_g_packet * 2 + 32); 1379} 1380 1381/* Get a pointer to the current remote target. If not connected to a 1382 remote target, return NULL. */ 1383 1384static remote_target * 1385get_current_remote_target () 1386{ 1387 target_ops *proc_target = current_inferior ()->process_target (); 1388 return dynamic_cast<remote_target *> (proc_target); 1389} 1390 1391/* Return the current allowed size of a remote packet. This is 1392 inferred from the current architecture, and should be used to 1393 limit the length of outgoing packets. */ 1394long 1395remote_target::get_remote_packet_size () 1396{ 1397 struct remote_state *rs = get_remote_state (); 1398 remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ()); 1399 1400 if (rs->explicit_packet_size) 1401 return rs->explicit_packet_size; 1402 1403 return rsa->remote_packet_size; 1404} 1405 1406static struct packet_reg * 1407packet_reg_from_regnum (struct gdbarch *gdbarch, struct remote_arch_state *rsa, 1408 long regnum) 1409{ 1410 if (regnum < 0 && regnum >= gdbarch_num_regs (gdbarch)) 1411 return NULL; 1412 else 1413 { 1414 struct packet_reg *r = &rsa->regs[regnum]; 1415 1416 gdb_assert (r->regnum == regnum); 1417 return r; 1418 } 1419} 1420 1421static struct packet_reg * 1422packet_reg_from_pnum (struct gdbarch *gdbarch, struct remote_arch_state *rsa, 1423 LONGEST pnum) 1424{ 1425 int i; 1426 1427 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 1428 { 1429 struct packet_reg *r = &rsa->regs[i]; 1430 1431 if (r->pnum == pnum) 1432 return r; 1433 } 1434 return NULL; 1435} 1436 1437/* Allow the user to specify what sequence to send to the remote 1438 when he requests a program interruption: Although ^C is usually 1439 what remote systems expect (this is the default, here), it is 1440 sometimes preferable to send a break. On other systems such 1441 as the Linux kernel, a break followed by g, which is Magic SysRq g 1442 is required in order to interrupt the execution. */ 1443const char interrupt_sequence_control_c[] = "Ctrl-C"; 1444const char interrupt_sequence_break[] = "BREAK"; 1445const char interrupt_sequence_break_g[] = "BREAK-g"; 1446static const char *const interrupt_sequence_modes[] = 1447 { 1448 interrupt_sequence_control_c, 1449 interrupt_sequence_break, 1450 interrupt_sequence_break_g, 1451 NULL 1452 }; 1453static const char *interrupt_sequence_mode = interrupt_sequence_control_c; 1454 1455static void 1456show_interrupt_sequence (struct ui_file *file, int from_tty, 1457 struct cmd_list_element *c, 1458 const char *value) 1459{ 1460 if (interrupt_sequence_mode == interrupt_sequence_control_c) 1461 fprintf_filtered (file, 1462 _("Send the ASCII ETX character (Ctrl-c) " 1463 "to the remote target to interrupt the " 1464 "execution of the program.\n")); 1465 else if (interrupt_sequence_mode == interrupt_sequence_break) 1466 fprintf_filtered (file, 1467 _("send a break signal to the remote target " 1468 "to interrupt the execution of the program.\n")); 1469 else if (interrupt_sequence_mode == interrupt_sequence_break_g) 1470 fprintf_filtered (file, 1471 _("Send a break signal and 'g' a.k.a. Magic SysRq g to " 1472 "the remote target to interrupt the execution " 1473 "of Linux kernel.\n")); 1474 else 1475 internal_error (__FILE__, __LINE__, 1476 _("Invalid value for interrupt_sequence_mode: %s."), 1477 interrupt_sequence_mode); 1478} 1479 1480/* This boolean variable specifies whether interrupt_sequence is sent 1481 to the remote target when gdb connects to it. 1482 This is mostly needed when you debug the Linux kernel: The Linux kernel 1483 expects BREAK g which is Magic SysRq g for connecting gdb. */ 1484static bool interrupt_on_connect = false; 1485 1486/* This variable is used to implement the "set/show remotebreak" commands. 1487 Since these commands are now deprecated in favor of "set/show remote 1488 interrupt-sequence", it no longer has any effect on the code. */ 1489static bool remote_break; 1490 1491static void 1492set_remotebreak (const char *args, int from_tty, struct cmd_list_element *c) 1493{ 1494 if (remote_break) 1495 interrupt_sequence_mode = interrupt_sequence_break; 1496 else 1497 interrupt_sequence_mode = interrupt_sequence_control_c; 1498} 1499 1500static void 1501show_remotebreak (struct ui_file *file, int from_tty, 1502 struct cmd_list_element *c, 1503 const char *value) 1504{ 1505} 1506 1507/* This variable sets the number of bits in an address that are to be 1508 sent in a memory ("M" or "m") packet. Normally, after stripping 1509 leading zeros, the entire address would be sent. This variable 1510 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The 1511 initial implementation of remote.c restricted the address sent in 1512 memory packets to ``host::sizeof long'' bytes - (typically 32 1513 bits). Consequently, for 64 bit targets, the upper 32 bits of an 1514 address was never sent. Since fixing this bug may cause a break in 1515 some remote targets this variable is principally provided to 1516 facilitate backward compatibility. */ 1517 1518static unsigned int remote_address_size; 1519 1520 1521/* User configurable variables for the number of characters in a 1522 memory read/write packet. MIN (rsa->remote_packet_size, 1523 rsa->sizeof_g_packet) is the default. Some targets need smaller 1524 values (fifo overruns, et.al.) and some users need larger values 1525 (speed up transfers). The variables ``preferred_*'' (the user 1526 request), ``current_*'' (what was actually set) and ``forced_*'' 1527 (Positive - a soft limit, negative - a hard limit). */ 1528 1529struct memory_packet_config 1530{ 1531 const char *name; 1532 long size; 1533 int fixed_p; 1534}; 1535 1536/* The default max memory-write-packet-size, when the setting is 1537 "fixed". The 16k is historical. (It came from older GDB's using 1538 alloca for buffers and the knowledge (folklore?) that some hosts 1539 don't cope very well with large alloca calls.) */ 1540#define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384 1541 1542/* The minimum remote packet size for memory transfers. Ensures we 1543 can write at least one byte. */ 1544#define MIN_MEMORY_PACKET_SIZE 20 1545 1546/* Get the memory packet size, assuming it is fixed. */ 1547 1548static long 1549get_fixed_memory_packet_size (struct memory_packet_config *config) 1550{ 1551 gdb_assert (config->fixed_p); 1552 1553 if (config->size <= 0) 1554 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED; 1555 else 1556 return config->size; 1557} 1558 1559/* Compute the current size of a read/write packet. Since this makes 1560 use of ``actual_register_packet_size'' the computation is dynamic. */ 1561 1562long 1563remote_target::get_memory_packet_size (struct memory_packet_config *config) 1564{ 1565 struct remote_state *rs = get_remote_state (); 1566 remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ()); 1567 1568 long what_they_get; 1569 if (config->fixed_p) 1570 what_they_get = get_fixed_memory_packet_size (config); 1571 else 1572 { 1573 what_they_get = get_remote_packet_size (); 1574 /* Limit the packet to the size specified by the user. */ 1575 if (config->size > 0 1576 && what_they_get > config->size) 1577 what_they_get = config->size; 1578 1579 /* Limit it to the size of the targets ``g'' response unless we have 1580 permission from the stub to use a larger packet size. */ 1581 if (rs->explicit_packet_size == 0 1582 && rsa->actual_register_packet_size > 0 1583 && what_they_get > rsa->actual_register_packet_size) 1584 what_they_get = rsa->actual_register_packet_size; 1585 } 1586 if (what_they_get < MIN_MEMORY_PACKET_SIZE) 1587 what_they_get = MIN_MEMORY_PACKET_SIZE; 1588 1589 /* Make sure there is room in the global buffer for this packet 1590 (including its trailing NUL byte). */ 1591 if (rs->buf.size () < what_they_get + 1) 1592 rs->buf.resize (2 * what_they_get); 1593 1594 return what_they_get; 1595} 1596 1597/* Update the size of a read/write packet. If they user wants 1598 something really big then do a sanity check. */ 1599 1600static void 1601set_memory_packet_size (const char *args, struct memory_packet_config *config) 1602{ 1603 int fixed_p = config->fixed_p; 1604 long size = config->size; 1605 1606 if (args == NULL) 1607 error (_("Argument required (integer, `fixed' or `limited').")); 1608 else if (strcmp (args, "hard") == 0 1609 || strcmp (args, "fixed") == 0) 1610 fixed_p = 1; 1611 else if (strcmp (args, "soft") == 0 1612 || strcmp (args, "limit") == 0) 1613 fixed_p = 0; 1614 else 1615 { 1616 char *end; 1617 1618 size = strtoul (args, &end, 0); 1619 if (args == end) 1620 error (_("Invalid %s (bad syntax)."), config->name); 1621 1622 /* Instead of explicitly capping the size of a packet to or 1623 disallowing it, the user is allowed to set the size to 1624 something arbitrarily large. */ 1625 } 1626 1627 /* Extra checks? */ 1628 if (fixed_p && !config->fixed_p) 1629 { 1630 /* So that the query shows the correct value. */ 1631 long query_size = (size <= 0 1632 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 1633 : size); 1634 1635 if (! query (_("The target may not be able to correctly handle a %s\n" 1636 "of %ld bytes. Change the packet size? "), 1637 config->name, query_size)) 1638 error (_("Packet size not changed.")); 1639 } 1640 /* Update the config. */ 1641 config->fixed_p = fixed_p; 1642 config->size = size; 1643} 1644 1645static void 1646show_memory_packet_size (struct memory_packet_config *config) 1647{ 1648 if (config->size == 0) 1649 printf_filtered (_("The %s is 0 (default). "), config->name); 1650 else 1651 printf_filtered (_("The %s is %ld. "), config->name, config->size); 1652 if (config->fixed_p) 1653 printf_filtered (_("Packets are fixed at %ld bytes.\n"), 1654 get_fixed_memory_packet_size (config)); 1655 else 1656 { 1657 remote_target *remote = get_current_remote_target (); 1658 1659 if (remote != NULL) 1660 printf_filtered (_("Packets are limited to %ld bytes.\n"), 1661 remote->get_memory_packet_size (config)); 1662 else 1663 puts_filtered ("The actual limit will be further reduced " 1664 "dependent on the target.\n"); 1665 } 1666} 1667 1668/* FIXME: needs to be per-remote-target. */ 1669static struct memory_packet_config memory_write_packet_config = 1670{ 1671 "memory-write-packet-size", 1672}; 1673 1674static void 1675set_memory_write_packet_size (const char *args, int from_tty) 1676{ 1677 set_memory_packet_size (args, &memory_write_packet_config); 1678} 1679 1680static void 1681show_memory_write_packet_size (const char *args, int from_tty) 1682{ 1683 show_memory_packet_size (&memory_write_packet_config); 1684} 1685 1686/* Show the number of hardware watchpoints that can be used. */ 1687 1688static void 1689show_hardware_watchpoint_limit (struct ui_file *file, int from_tty, 1690 struct cmd_list_element *c, 1691 const char *value) 1692{ 1693 fprintf_filtered (file, _("The maximum number of target hardware " 1694 "watchpoints is %s.\n"), value); 1695} 1696 1697/* Show the length limit (in bytes) for hardware watchpoints. */ 1698 1699static void 1700show_hardware_watchpoint_length_limit (struct ui_file *file, int from_tty, 1701 struct cmd_list_element *c, 1702 const char *value) 1703{ 1704 fprintf_filtered (file, _("The maximum length (in bytes) of a target " 1705 "hardware watchpoint is %s.\n"), value); 1706} 1707 1708/* Show the number of hardware breakpoints that can be used. */ 1709 1710static void 1711show_hardware_breakpoint_limit (struct ui_file *file, int from_tty, 1712 struct cmd_list_element *c, 1713 const char *value) 1714{ 1715 fprintf_filtered (file, _("The maximum number of target hardware " 1716 "breakpoints is %s.\n"), value); 1717} 1718 1719/* Controls the maximum number of characters to display in the debug output 1720 for each remote packet. The remaining characters are omitted. */ 1721 1722static int remote_packet_max_chars = 512; 1723 1724/* Show the maximum number of characters to display for each remote packet 1725 when remote debugging is enabled. */ 1726 1727static void 1728show_remote_packet_max_chars (struct ui_file *file, int from_tty, 1729 struct cmd_list_element *c, 1730 const char *value) 1731{ 1732 fprintf_filtered (file, _("Number of remote packet characters to " 1733 "display is %s.\n"), value); 1734} 1735 1736long 1737remote_target::get_memory_write_packet_size () 1738{ 1739 return get_memory_packet_size (&memory_write_packet_config); 1740} 1741 1742/* FIXME: needs to be per-remote-target. */ 1743static struct memory_packet_config memory_read_packet_config = 1744{ 1745 "memory-read-packet-size", 1746}; 1747 1748static void 1749set_memory_read_packet_size (const char *args, int from_tty) 1750{ 1751 set_memory_packet_size (args, &memory_read_packet_config); 1752} 1753 1754static void 1755show_memory_read_packet_size (const char *args, int from_tty) 1756{ 1757 show_memory_packet_size (&memory_read_packet_config); 1758} 1759 1760long 1761remote_target::get_memory_read_packet_size () 1762{ 1763 long size = get_memory_packet_size (&memory_read_packet_config); 1764 1765 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an 1766 extra buffer size argument before the memory read size can be 1767 increased beyond this. */ 1768 if (size > get_remote_packet_size ()) 1769 size = get_remote_packet_size (); 1770 return size; 1771} 1772 1773 1774 1775struct packet_config 1776 { 1777 const char *name; 1778 const char *title; 1779 1780 /* If auto, GDB auto-detects support for this packet or feature, 1781 either through qSupported, or by trying the packet and looking 1782 at the response. If true, GDB assumes the target supports this 1783 packet. If false, the packet is disabled. Configs that don't 1784 have an associated command always have this set to auto. */ 1785 enum auto_boolean detect; 1786 1787 /* Does the target support this packet? */ 1788 enum packet_support support; 1789 }; 1790 1791static enum packet_support packet_config_support (struct packet_config *config); 1792static enum packet_support packet_support (int packet); 1793 1794static void 1795show_packet_config_cmd (struct packet_config *config) 1796{ 1797 const char *support = "internal-error"; 1798 1799 switch (packet_config_support (config)) 1800 { 1801 case PACKET_ENABLE: 1802 support = "enabled"; 1803 break; 1804 case PACKET_DISABLE: 1805 support = "disabled"; 1806 break; 1807 case PACKET_SUPPORT_UNKNOWN: 1808 support = "unknown"; 1809 break; 1810 } 1811 switch (config->detect) 1812 { 1813 case AUTO_BOOLEAN_AUTO: 1814 printf_filtered (_("Support for the `%s' packet " 1815 "is auto-detected, currently %s.\n"), 1816 config->name, support); 1817 break; 1818 case AUTO_BOOLEAN_TRUE: 1819 case AUTO_BOOLEAN_FALSE: 1820 printf_filtered (_("Support for the `%s' packet is currently %s.\n"), 1821 config->name, support); 1822 break; 1823 } 1824} 1825 1826static void 1827add_packet_config_cmd (struct packet_config *config, const char *name, 1828 const char *title, int legacy) 1829{ 1830 char *set_doc; 1831 char *show_doc; 1832 char *cmd_name; 1833 1834 config->name = name; 1835 config->title = title; 1836 set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet.", 1837 name, title); 1838 show_doc = xstrprintf ("Show current use of remote " 1839 "protocol `%s' (%s) packet.", 1840 name, title); 1841 /* set/show TITLE-packet {auto,on,off} */ 1842 cmd_name = xstrprintf ("%s-packet", title); 1843 add_setshow_auto_boolean_cmd (cmd_name, class_obscure, 1844 &config->detect, set_doc, 1845 show_doc, NULL, /* help_doc */ 1846 NULL, 1847 show_remote_protocol_packet_cmd, 1848 &remote_set_cmdlist, &remote_show_cmdlist); 1849 /* The command code copies the documentation strings. */ 1850 xfree (set_doc); 1851 xfree (show_doc); 1852 /* set/show remote NAME-packet {auto,on,off} -- legacy. */ 1853 if (legacy) 1854 { 1855 char *legacy_name; 1856 1857 legacy_name = xstrprintf ("%s-packet", name); 1858 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0, 1859 &remote_set_cmdlist); 1860 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0, 1861 &remote_show_cmdlist); 1862 } 1863} 1864 1865static enum packet_result 1866packet_check_result (const char *buf) 1867{ 1868 if (buf[0] != '\0') 1869 { 1870 /* The stub recognized the packet request. Check that the 1871 operation succeeded. */ 1872 if (buf[0] == 'E' 1873 && isxdigit (buf[1]) && isxdigit (buf[2]) 1874 && buf[3] == '\0') 1875 /* "Enn" - definitely an error. */ 1876 return PACKET_ERROR; 1877 1878 /* Always treat "E." as an error. This will be used for 1879 more verbose error messages, such as E.memtypes. */ 1880 if (buf[0] == 'E' && buf[1] == '.') 1881 return PACKET_ERROR; 1882 1883 /* The packet may or may not be OK. Just assume it is. */ 1884 return PACKET_OK; 1885 } 1886 else 1887 /* The stub does not support the packet. */ 1888 return PACKET_UNKNOWN; 1889} 1890 1891static enum packet_result 1892packet_check_result (const gdb::char_vector &buf) 1893{ 1894 return packet_check_result (buf.data ()); 1895} 1896 1897static enum packet_result 1898packet_ok (const char *buf, struct packet_config *config) 1899{ 1900 enum packet_result result; 1901 1902 if (config->detect != AUTO_BOOLEAN_TRUE 1903 && config->support == PACKET_DISABLE) 1904 internal_error (__FILE__, __LINE__, 1905 _("packet_ok: attempt to use a disabled packet")); 1906 1907 result = packet_check_result (buf); 1908 switch (result) 1909 { 1910 case PACKET_OK: 1911 case PACKET_ERROR: 1912 /* The stub recognized the packet request. */ 1913 if (config->support == PACKET_SUPPORT_UNKNOWN) 1914 { 1915 if (remote_debug) 1916 fprintf_unfiltered (gdb_stdlog, 1917 "Packet %s (%s) is supported\n", 1918 config->name, config->title); 1919 config->support = PACKET_ENABLE; 1920 } 1921 break; 1922 case PACKET_UNKNOWN: 1923 /* The stub does not support the packet. */ 1924 if (config->detect == AUTO_BOOLEAN_AUTO 1925 && config->support == PACKET_ENABLE) 1926 { 1927 /* If the stub previously indicated that the packet was 1928 supported then there is a protocol error. */ 1929 error (_("Protocol error: %s (%s) conflicting enabled responses."), 1930 config->name, config->title); 1931 } 1932 else if (config->detect == AUTO_BOOLEAN_TRUE) 1933 { 1934 /* The user set it wrong. */ 1935 error (_("Enabled packet %s (%s) not recognized by stub"), 1936 config->name, config->title); 1937 } 1938 1939 if (remote_debug) 1940 fprintf_unfiltered (gdb_stdlog, 1941 "Packet %s (%s) is NOT supported\n", 1942 config->name, config->title); 1943 config->support = PACKET_DISABLE; 1944 break; 1945 } 1946 1947 return result; 1948} 1949 1950static enum packet_result 1951packet_ok (const gdb::char_vector &buf, struct packet_config *config) 1952{ 1953 return packet_ok (buf.data (), config); 1954} 1955 1956enum { 1957 PACKET_vCont = 0, 1958 PACKET_X, 1959 PACKET_qSymbol, 1960 PACKET_P, 1961 PACKET_p, 1962 PACKET_Z0, 1963 PACKET_Z1, 1964 PACKET_Z2, 1965 PACKET_Z3, 1966 PACKET_Z4, 1967 PACKET_vFile_setfs, 1968 PACKET_vFile_open, 1969 PACKET_vFile_pread, 1970 PACKET_vFile_pwrite, 1971 PACKET_vFile_close, 1972 PACKET_vFile_unlink, 1973 PACKET_vFile_readlink, 1974 PACKET_vFile_fstat, 1975 PACKET_qXfer_auxv, 1976 PACKET_qXfer_features, 1977 PACKET_qXfer_exec_file, 1978 PACKET_qXfer_libraries, 1979 PACKET_qXfer_libraries_svr4, 1980 PACKET_qXfer_memory_map, 1981 PACKET_qXfer_osdata, 1982 PACKET_qXfer_threads, 1983 PACKET_qXfer_statictrace_read, 1984 PACKET_qXfer_traceframe_info, 1985 PACKET_qXfer_uib, 1986 PACKET_qGetTIBAddr, 1987 PACKET_qGetTLSAddr, 1988 PACKET_qSupported, 1989 PACKET_qTStatus, 1990 PACKET_QPassSignals, 1991 PACKET_QCatchSyscalls, 1992 PACKET_QProgramSignals, 1993 PACKET_QSetWorkingDir, 1994 PACKET_QStartupWithShell, 1995 PACKET_QEnvironmentHexEncoded, 1996 PACKET_QEnvironmentReset, 1997 PACKET_QEnvironmentUnset, 1998 PACKET_qCRC, 1999 PACKET_qSearch_memory, 2000 PACKET_vAttach, 2001 PACKET_vRun, 2002 PACKET_QStartNoAckMode, 2003 PACKET_vKill, 2004 PACKET_qXfer_siginfo_read, 2005 PACKET_qXfer_siginfo_write, 2006 PACKET_qAttached, 2007 2008 /* Support for conditional tracepoints. */ 2009 PACKET_ConditionalTracepoints, 2010 2011 /* Support for target-side breakpoint conditions. */ 2012 PACKET_ConditionalBreakpoints, 2013 2014 /* Support for target-side breakpoint commands. */ 2015 PACKET_BreakpointCommands, 2016 2017 /* Support for fast tracepoints. */ 2018 PACKET_FastTracepoints, 2019 2020 /* Support for static tracepoints. */ 2021 PACKET_StaticTracepoints, 2022 2023 /* Support for installing tracepoints while a trace experiment is 2024 running. */ 2025 PACKET_InstallInTrace, 2026 2027 PACKET_bc, 2028 PACKET_bs, 2029 PACKET_TracepointSource, 2030 PACKET_QAllow, 2031 PACKET_qXfer_fdpic, 2032 PACKET_QDisableRandomization, 2033 PACKET_QAgent, 2034 PACKET_QTBuffer_size, 2035 PACKET_Qbtrace_off, 2036 PACKET_Qbtrace_bts, 2037 PACKET_Qbtrace_pt, 2038 PACKET_qXfer_btrace, 2039 2040 /* Support for the QNonStop packet. */ 2041 PACKET_QNonStop, 2042 2043 /* Support for the QThreadEvents packet. */ 2044 PACKET_QThreadEvents, 2045 2046 /* Support for multi-process extensions. */ 2047 PACKET_multiprocess_feature, 2048 2049 /* Support for enabling and disabling tracepoints while a trace 2050 experiment is running. */ 2051 PACKET_EnableDisableTracepoints_feature, 2052 2053 /* Support for collecting strings using the tracenz bytecode. */ 2054 PACKET_tracenz_feature, 2055 2056 /* Support for continuing to run a trace experiment while GDB is 2057 disconnected. */ 2058 PACKET_DisconnectedTracing_feature, 2059 2060 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */ 2061 PACKET_augmented_libraries_svr4_read_feature, 2062 2063 /* Support for the qXfer:btrace-conf:read packet. */ 2064 PACKET_qXfer_btrace_conf, 2065 2066 /* Support for the Qbtrace-conf:bts:size packet. */ 2067 PACKET_Qbtrace_conf_bts_size, 2068 2069 /* Support for swbreak+ feature. */ 2070 PACKET_swbreak_feature, 2071 2072 /* Support for hwbreak+ feature. */ 2073 PACKET_hwbreak_feature, 2074 2075 /* Support for fork events. */ 2076 PACKET_fork_event_feature, 2077 2078 /* Support for vfork events. */ 2079 PACKET_vfork_event_feature, 2080 2081 /* Support for the Qbtrace-conf:pt:size packet. */ 2082 PACKET_Qbtrace_conf_pt_size, 2083 2084 /* Support for exec events. */ 2085 PACKET_exec_event_feature, 2086 2087 /* Support for query supported vCont actions. */ 2088 PACKET_vContSupported, 2089 2090 /* Support remote CTRL-C. */ 2091 PACKET_vCtrlC, 2092 2093 /* Support TARGET_WAITKIND_NO_RESUMED. */ 2094 PACKET_no_resumed, 2095 2096 PACKET_MAX 2097}; 2098 2099/* FIXME: needs to be per-remote-target. Ignoring this for now, 2100 assuming all remote targets are the same server (thus all support 2101 the same packets). */ 2102static struct packet_config remote_protocol_packets[PACKET_MAX]; 2103 2104/* Returns the packet's corresponding "set remote foo-packet" command 2105 state. See struct packet_config for more details. */ 2106 2107static enum auto_boolean 2108packet_set_cmd_state (int packet) 2109{ 2110 return remote_protocol_packets[packet].detect; 2111} 2112 2113/* Returns whether a given packet or feature is supported. This takes 2114 into account the state of the corresponding "set remote foo-packet" 2115 command, which may be used to bypass auto-detection. */ 2116 2117static enum packet_support 2118packet_config_support (struct packet_config *config) 2119{ 2120 switch (config->detect) 2121 { 2122 case AUTO_BOOLEAN_TRUE: 2123 return PACKET_ENABLE; 2124 case AUTO_BOOLEAN_FALSE: 2125 return PACKET_DISABLE; 2126 case AUTO_BOOLEAN_AUTO: 2127 return config->support; 2128 default: 2129 gdb_assert_not_reached (_("bad switch")); 2130 } 2131} 2132 2133/* Same as packet_config_support, but takes the packet's enum value as 2134 argument. */ 2135 2136static enum packet_support 2137packet_support (int packet) 2138{ 2139 struct packet_config *config = &remote_protocol_packets[packet]; 2140 2141 return packet_config_support (config); 2142} 2143 2144static void 2145show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty, 2146 struct cmd_list_element *c, 2147 const char *value) 2148{ 2149 struct packet_config *packet; 2150 2151 for (packet = remote_protocol_packets; 2152 packet < &remote_protocol_packets[PACKET_MAX]; 2153 packet++) 2154 { 2155 if (&packet->detect == c->var) 2156 { 2157 show_packet_config_cmd (packet); 2158 return; 2159 } 2160 } 2161 internal_error (__FILE__, __LINE__, _("Could not find config for %s"), 2162 c->name); 2163} 2164 2165/* Should we try one of the 'Z' requests? */ 2166 2167enum Z_packet_type 2168{ 2169 Z_PACKET_SOFTWARE_BP, 2170 Z_PACKET_HARDWARE_BP, 2171 Z_PACKET_WRITE_WP, 2172 Z_PACKET_READ_WP, 2173 Z_PACKET_ACCESS_WP, 2174 NR_Z_PACKET_TYPES 2175}; 2176 2177/* For compatibility with older distributions. Provide a ``set remote 2178 Z-packet ...'' command that updates all the Z packet types. */ 2179 2180static enum auto_boolean remote_Z_packet_detect; 2181 2182static void 2183set_remote_protocol_Z_packet_cmd (const char *args, int from_tty, 2184 struct cmd_list_element *c) 2185{ 2186 int i; 2187 2188 for (i = 0; i < NR_Z_PACKET_TYPES; i++) 2189 remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect; 2190} 2191 2192static void 2193show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty, 2194 struct cmd_list_element *c, 2195 const char *value) 2196{ 2197 int i; 2198 2199 for (i = 0; i < NR_Z_PACKET_TYPES; i++) 2200 { 2201 show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]); 2202 } 2203} 2204 2205/* Returns true if the multi-process extensions are in effect. */ 2206 2207static int 2208remote_multi_process_p (struct remote_state *rs) 2209{ 2210 return packet_support (PACKET_multiprocess_feature) == PACKET_ENABLE; 2211} 2212 2213/* Returns true if fork events are supported. */ 2214 2215static int 2216remote_fork_event_p (struct remote_state *rs) 2217{ 2218 return packet_support (PACKET_fork_event_feature) == PACKET_ENABLE; 2219} 2220 2221/* Returns true if vfork events are supported. */ 2222 2223static int 2224remote_vfork_event_p (struct remote_state *rs) 2225{ 2226 return packet_support (PACKET_vfork_event_feature) == PACKET_ENABLE; 2227} 2228 2229/* Returns true if exec events are supported. */ 2230 2231static int 2232remote_exec_event_p (struct remote_state *rs) 2233{ 2234 return packet_support (PACKET_exec_event_feature) == PACKET_ENABLE; 2235} 2236 2237/* Insert fork catchpoint target routine. If fork events are enabled 2238 then return success, nothing more to do. */ 2239 2240int 2241remote_target::insert_fork_catchpoint (int pid) 2242{ 2243 struct remote_state *rs = get_remote_state (); 2244 2245 return !remote_fork_event_p (rs); 2246} 2247 2248/* Remove fork catchpoint target routine. Nothing to do, just 2249 return success. */ 2250 2251int 2252remote_target::remove_fork_catchpoint (int pid) 2253{ 2254 return 0; 2255} 2256 2257/* Insert vfork catchpoint target routine. If vfork events are enabled 2258 then return success, nothing more to do. */ 2259 2260int 2261remote_target::insert_vfork_catchpoint (int pid) 2262{ 2263 struct remote_state *rs = get_remote_state (); 2264 2265 return !remote_vfork_event_p (rs); 2266} 2267 2268/* Remove vfork catchpoint target routine. Nothing to do, just 2269 return success. */ 2270 2271int 2272remote_target::remove_vfork_catchpoint (int pid) 2273{ 2274 return 0; 2275} 2276 2277/* Insert exec catchpoint target routine. If exec events are 2278 enabled, just return success. */ 2279 2280int 2281remote_target::insert_exec_catchpoint (int pid) 2282{ 2283 struct remote_state *rs = get_remote_state (); 2284 2285 return !remote_exec_event_p (rs); 2286} 2287 2288/* Remove exec catchpoint target routine. Nothing to do, just 2289 return success. */ 2290 2291int 2292remote_target::remove_exec_catchpoint (int pid) 2293{ 2294 return 0; 2295} 2296 2297 2298 2299/* Take advantage of the fact that the TID field is not used, to tag 2300 special ptids with it set to != 0. */ 2301static const ptid_t magic_null_ptid (42000, -1, 1); 2302static const ptid_t not_sent_ptid (42000, -2, 1); 2303static const ptid_t any_thread_ptid (42000, 0, 1); 2304 2305/* Find out if the stub attached to PID (and hence GDB should offer to 2306 detach instead of killing it when bailing out). */ 2307 2308int 2309remote_target::remote_query_attached (int pid) 2310{ 2311 struct remote_state *rs = get_remote_state (); 2312 size_t size = get_remote_packet_size (); 2313 2314 if (packet_support (PACKET_qAttached) == PACKET_DISABLE) 2315 return 0; 2316 2317 if (remote_multi_process_p (rs)) 2318 xsnprintf (rs->buf.data (), size, "qAttached:%x", pid); 2319 else 2320 xsnprintf (rs->buf.data (), size, "qAttached"); 2321 2322 putpkt (rs->buf); 2323 getpkt (&rs->buf, 0); 2324 2325 switch (packet_ok (rs->buf, 2326 &remote_protocol_packets[PACKET_qAttached])) 2327 { 2328 case PACKET_OK: 2329 if (strcmp (rs->buf.data (), "1") == 0) 2330 return 1; 2331 break; 2332 case PACKET_ERROR: 2333 warning (_("Remote failure reply: %s"), rs->buf.data ()); 2334 break; 2335 case PACKET_UNKNOWN: 2336 break; 2337 } 2338 2339 return 0; 2340} 2341 2342/* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID 2343 has been invented by GDB, instead of reported by the target. Since 2344 we can be connected to a remote system before before knowing about 2345 any inferior, mark the target with execution when we find the first 2346 inferior. If ATTACHED is 1, then we had just attached to this 2347 inferior. If it is 0, then we just created this inferior. If it 2348 is -1, then try querying the remote stub to find out if it had 2349 attached to the inferior or not. If TRY_OPEN_EXEC is true then 2350 attempt to open this inferior's executable as the main executable 2351 if no main executable is open already. */ 2352 2353inferior * 2354remote_target::remote_add_inferior (bool fake_pid_p, int pid, int attached, 2355 int try_open_exec) 2356{ 2357 struct inferior *inf; 2358 2359 /* Check whether this process we're learning about is to be 2360 considered attached, or if is to be considered to have been 2361 spawned by the stub. */ 2362 if (attached == -1) 2363 attached = remote_query_attached (pid); 2364 2365 if (gdbarch_has_global_solist (target_gdbarch ())) 2366 { 2367 /* If the target shares code across all inferiors, then every 2368 attach adds a new inferior. */ 2369 inf = add_inferior (pid); 2370 2371 /* ... and every inferior is bound to the same program space. 2372 However, each inferior may still have its own address 2373 space. */ 2374 inf->aspace = maybe_new_address_space (); 2375 inf->pspace = current_program_space; 2376 } 2377 else 2378 { 2379 /* In the traditional debugging scenario, there's a 1-1 match 2380 between program/address spaces. We simply bind the inferior 2381 to the program space's address space. */ 2382 inf = current_inferior (); 2383 2384 /* However, if the current inferior is already bound to a 2385 process, find some other empty inferior. */ 2386 if (inf->pid != 0) 2387 { 2388 inf = nullptr; 2389 for (inferior *it : all_inferiors ()) 2390 if (it->pid == 0) 2391 { 2392 inf = it; 2393 break; 2394 } 2395 } 2396 if (inf == nullptr) 2397 { 2398 /* Since all inferiors were already bound to a process, add 2399 a new inferior. */ 2400 inf = add_inferior_with_spaces (); 2401 } 2402 switch_to_inferior_no_thread (inf); 2403 push_target (this); 2404 inferior_appeared (inf, pid); 2405 } 2406 2407 inf->attach_flag = attached; 2408 inf->fake_pid_p = fake_pid_p; 2409 2410 /* If no main executable is currently open then attempt to 2411 open the file that was executed to create this inferior. */ 2412 if (try_open_exec && get_exec_file (0) == NULL) 2413 exec_file_locate_attach (pid, 0, 1); 2414 2415 /* Check for exec file mismatch, and let the user solve it. */ 2416 validate_exec_file (1); 2417 2418 return inf; 2419} 2420 2421static remote_thread_info *get_remote_thread_info (thread_info *thread); 2422static remote_thread_info *get_remote_thread_info (remote_target *target, 2423 ptid_t ptid); 2424 2425/* Add thread PTID to GDB's thread list. Tag it as executing/running 2426 according to RUNNING. */ 2427 2428thread_info * 2429remote_target::remote_add_thread (ptid_t ptid, bool running, bool executing) 2430{ 2431 struct remote_state *rs = get_remote_state (); 2432 struct thread_info *thread; 2433 2434 /* GDB historically didn't pull threads in the initial connection 2435 setup. If the remote target doesn't even have a concept of 2436 threads (e.g., a bare-metal target), even if internally we 2437 consider that a single-threaded target, mentioning a new thread 2438 might be confusing to the user. Be silent then, preserving the 2439 age old behavior. */ 2440 if (rs->starting_up) 2441 thread = add_thread_silent (this, ptid); 2442 else 2443 thread = add_thread (this, ptid); 2444 2445 get_remote_thread_info (thread)->vcont_resumed = executing; 2446 set_executing (this, ptid, executing); 2447 set_running (this, ptid, running); 2448 2449 return thread; 2450} 2451 2452/* Come here when we learn about a thread id from the remote target. 2453 It may be the first time we hear about such thread, so take the 2454 opportunity to add it to GDB's thread list. In case this is the 2455 first time we're noticing its corresponding inferior, add it to 2456 GDB's inferior list as well. EXECUTING indicates whether the 2457 thread is (internally) executing or stopped. */ 2458 2459void 2460remote_target::remote_notice_new_inferior (ptid_t currthread, int executing) 2461{ 2462 /* In non-stop mode, we assume new found threads are (externally) 2463 running until proven otherwise with a stop reply. In all-stop, 2464 we can only get here if all threads are stopped. */ 2465 int running = target_is_non_stop_p () ? 1 : 0; 2466 2467 /* If this is a new thread, add it to GDB's thread list. 2468 If we leave it up to WFI to do this, bad things will happen. */ 2469 2470 thread_info *tp = find_thread_ptid (this, currthread); 2471 if (tp != NULL && tp->state == THREAD_EXITED) 2472 { 2473 /* We're seeing an event on a thread id we knew had exited. 2474 This has to be a new thread reusing the old id. Add it. */ 2475 remote_add_thread (currthread, running, executing); 2476 return; 2477 } 2478 2479 if (!in_thread_list (this, currthread)) 2480 { 2481 struct inferior *inf = NULL; 2482 int pid = currthread.pid (); 2483 2484 if (inferior_ptid.is_pid () 2485 && pid == inferior_ptid.pid ()) 2486 { 2487 /* inferior_ptid has no thread member yet. This can happen 2488 with the vAttach -> remote_wait,"TAAthread:" path if the 2489 stub doesn't support qC. This is the first stop reported 2490 after an attach, so this is the main thread. Update the 2491 ptid in the thread list. */ 2492 if (in_thread_list (this, ptid_t (pid))) 2493 thread_change_ptid (this, inferior_ptid, currthread); 2494 else 2495 { 2496 thread_info *thr 2497 = remote_add_thread (currthread, running, executing); 2498 switch_to_thread (thr); 2499 } 2500 return; 2501 } 2502 2503 if (magic_null_ptid == inferior_ptid) 2504 { 2505 /* inferior_ptid is not set yet. This can happen with the 2506 vRun -> remote_wait,"TAAthread:" path if the stub 2507 doesn't support qC. This is the first stop reported 2508 after an attach, so this is the main thread. Update the 2509 ptid in the thread list. */ 2510 thread_change_ptid (this, inferior_ptid, currthread); 2511 return; 2512 } 2513 2514 /* When connecting to a target remote, or to a target 2515 extended-remote which already was debugging an inferior, we 2516 may not know about it yet. Add it before adding its child 2517 thread, so notifications are emitted in a sensible order. */ 2518 if (find_inferior_pid (this, currthread.pid ()) == NULL) 2519 { 2520 struct remote_state *rs = get_remote_state (); 2521 bool fake_pid_p = !remote_multi_process_p (rs); 2522 2523 inf = remote_add_inferior (fake_pid_p, 2524 currthread.pid (), -1, 1); 2525 } 2526 2527 /* This is really a new thread. Add it. */ 2528 thread_info *new_thr 2529 = remote_add_thread (currthread, running, executing); 2530 2531 /* If we found a new inferior, let the common code do whatever 2532 it needs to with it (e.g., read shared libraries, insert 2533 breakpoints), unless we're just setting up an all-stop 2534 connection. */ 2535 if (inf != NULL) 2536 { 2537 struct remote_state *rs = get_remote_state (); 2538 2539 if (!rs->starting_up) 2540 notice_new_inferior (new_thr, executing, 0); 2541 } 2542 } 2543} 2544 2545/* Return THREAD's private thread data, creating it if necessary. */ 2546 2547static remote_thread_info * 2548get_remote_thread_info (thread_info *thread) 2549{ 2550 gdb_assert (thread != NULL); 2551 2552 if (thread->priv == NULL) 2553 thread->priv.reset (new remote_thread_info); 2554 2555 return static_cast<remote_thread_info *> (thread->priv.get ()); 2556} 2557 2558/* Return PTID's private thread data, creating it if necessary. */ 2559 2560static remote_thread_info * 2561get_remote_thread_info (remote_target *target, ptid_t ptid) 2562{ 2563 thread_info *thr = find_thread_ptid (target, ptid); 2564 return get_remote_thread_info (thr); 2565} 2566 2567/* Call this function as a result of 2568 1) A halt indication (T packet) containing a thread id 2569 2) A direct query of currthread 2570 3) Successful execution of set thread */ 2571 2572static void 2573record_currthread (struct remote_state *rs, ptid_t currthread) 2574{ 2575 rs->general_thread = currthread; 2576} 2577 2578/* If 'QPassSignals' is supported, tell the remote stub what signals 2579 it can simply pass through to the inferior without reporting. */ 2580 2581void 2582remote_target::pass_signals (gdb::array_view<const unsigned char> pass_signals) 2583{ 2584 if (packet_support (PACKET_QPassSignals) != PACKET_DISABLE) 2585 { 2586 char *pass_packet, *p; 2587 int count = 0; 2588 struct remote_state *rs = get_remote_state (); 2589 2590 gdb_assert (pass_signals.size () < 256); 2591 for (size_t i = 0; i < pass_signals.size (); i++) 2592 { 2593 if (pass_signals[i]) 2594 count++; 2595 } 2596 pass_packet = (char *) xmalloc (count * 3 + strlen ("QPassSignals:") + 1); 2597 strcpy (pass_packet, "QPassSignals:"); 2598 p = pass_packet + strlen (pass_packet); 2599 for (size_t i = 0; i < pass_signals.size (); i++) 2600 { 2601 if (pass_signals[i]) 2602 { 2603 if (i >= 16) 2604 *p++ = tohex (i >> 4); 2605 *p++ = tohex (i & 15); 2606 if (count) 2607 *p++ = ';'; 2608 else 2609 break; 2610 count--; 2611 } 2612 } 2613 *p = 0; 2614 if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet)) 2615 { 2616 putpkt (pass_packet); 2617 getpkt (&rs->buf, 0); 2618 packet_ok (rs->buf, &remote_protocol_packets[PACKET_QPassSignals]); 2619 xfree (rs->last_pass_packet); 2620 rs->last_pass_packet = pass_packet; 2621 } 2622 else 2623 xfree (pass_packet); 2624 } 2625} 2626 2627/* If 'QCatchSyscalls' is supported, tell the remote stub 2628 to report syscalls to GDB. */ 2629 2630int 2631remote_target::set_syscall_catchpoint (int pid, bool needed, int any_count, 2632 gdb::array_view<const int> syscall_counts) 2633{ 2634 const char *catch_packet; 2635 enum packet_result result; 2636 int n_sysno = 0; 2637 2638 if (packet_support (PACKET_QCatchSyscalls) == PACKET_DISABLE) 2639 { 2640 /* Not supported. */ 2641 return 1; 2642 } 2643 2644 if (needed && any_count == 0) 2645 { 2646 /* Count how many syscalls are to be caught. */ 2647 for (size_t i = 0; i < syscall_counts.size (); i++) 2648 { 2649 if (syscall_counts[i] != 0) 2650 n_sysno++; 2651 } 2652 } 2653 2654 if (remote_debug) 2655 { 2656 fprintf_unfiltered (gdb_stdlog, 2657 "remote_set_syscall_catchpoint " 2658 "pid %d needed %d any_count %d n_sysno %d\n", 2659 pid, needed, any_count, n_sysno); 2660 } 2661 2662 std::string built_packet; 2663 if (needed) 2664 { 2665 /* Prepare a packet with the sysno list, assuming max 8+1 2666 characters for a sysno. If the resulting packet size is too 2667 big, fallback on the non-selective packet. */ 2668 const int maxpktsz = strlen ("QCatchSyscalls:1") + n_sysno * 9 + 1; 2669 built_packet.reserve (maxpktsz); 2670 built_packet = "QCatchSyscalls:1"; 2671 if (any_count == 0) 2672 { 2673 /* Add in each syscall to be caught. */ 2674 for (size_t i = 0; i < syscall_counts.size (); i++) 2675 { 2676 if (syscall_counts[i] != 0) 2677 string_appendf (built_packet, ";%zx", i); 2678 } 2679 } 2680 if (built_packet.size () > get_remote_packet_size ()) 2681 { 2682 /* catch_packet too big. Fallback to less efficient 2683 non selective mode, with GDB doing the filtering. */ 2684 catch_packet = "QCatchSyscalls:1"; 2685 } 2686 else 2687 catch_packet = built_packet.c_str (); 2688 } 2689 else 2690 catch_packet = "QCatchSyscalls:0"; 2691 2692 struct remote_state *rs = get_remote_state (); 2693 2694 putpkt (catch_packet); 2695 getpkt (&rs->buf, 0); 2696 result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_QCatchSyscalls]); 2697 if (result == PACKET_OK) 2698 return 0; 2699 else 2700 return -1; 2701} 2702 2703/* If 'QProgramSignals' is supported, tell the remote stub what 2704 signals it should pass through to the inferior when detaching. */ 2705 2706void 2707remote_target::program_signals (gdb::array_view<const unsigned char> signals) 2708{ 2709 if (packet_support (PACKET_QProgramSignals) != PACKET_DISABLE) 2710 { 2711 char *packet, *p; 2712 int count = 0; 2713 struct remote_state *rs = get_remote_state (); 2714 2715 gdb_assert (signals.size () < 256); 2716 for (size_t i = 0; i < signals.size (); i++) 2717 { 2718 if (signals[i]) 2719 count++; 2720 } 2721 packet = (char *) xmalloc (count * 3 + strlen ("QProgramSignals:") + 1); 2722 strcpy (packet, "QProgramSignals:"); 2723 p = packet + strlen (packet); 2724 for (size_t i = 0; i < signals.size (); i++) 2725 { 2726 if (signal_pass_state (i)) 2727 { 2728 if (i >= 16) 2729 *p++ = tohex (i >> 4); 2730 *p++ = tohex (i & 15); 2731 if (count) 2732 *p++ = ';'; 2733 else 2734 break; 2735 count--; 2736 } 2737 } 2738 *p = 0; 2739 if (!rs->last_program_signals_packet 2740 || strcmp (rs->last_program_signals_packet, packet) != 0) 2741 { 2742 putpkt (packet); 2743 getpkt (&rs->buf, 0); 2744 packet_ok (rs->buf, &remote_protocol_packets[PACKET_QProgramSignals]); 2745 xfree (rs->last_program_signals_packet); 2746 rs->last_program_signals_packet = packet; 2747 } 2748 else 2749 xfree (packet); 2750 } 2751} 2752 2753/* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is 2754 MINUS_ONE_PTID, set the thread to -1, so the stub returns the 2755 thread. If GEN is set, set the general thread, if not, then set 2756 the step/continue thread. */ 2757void 2758remote_target::set_thread (ptid_t ptid, int gen) 2759{ 2760 struct remote_state *rs = get_remote_state (); 2761 ptid_t state = gen ? rs->general_thread : rs->continue_thread; 2762 char *buf = rs->buf.data (); 2763 char *endbuf = buf + get_remote_packet_size (); 2764 2765 if (state == ptid) 2766 return; 2767 2768 *buf++ = 'H'; 2769 *buf++ = gen ? 'g' : 'c'; 2770 if (ptid == magic_null_ptid) 2771 xsnprintf (buf, endbuf - buf, "0"); 2772 else if (ptid == any_thread_ptid) 2773 xsnprintf (buf, endbuf - buf, "0"); 2774 else if (ptid == minus_one_ptid) 2775 xsnprintf (buf, endbuf - buf, "-1"); 2776 else 2777 write_ptid (buf, endbuf, ptid); 2778 putpkt (rs->buf); 2779 getpkt (&rs->buf, 0); 2780 if (gen) 2781 rs->general_thread = ptid; 2782 else 2783 rs->continue_thread = ptid; 2784} 2785 2786void 2787remote_target::set_general_thread (ptid_t ptid) 2788{ 2789 set_thread (ptid, 1); 2790} 2791 2792void 2793remote_target::set_continue_thread (ptid_t ptid) 2794{ 2795 set_thread (ptid, 0); 2796} 2797 2798/* Change the remote current process. Which thread within the process 2799 ends up selected isn't important, as long as it is the same process 2800 as what INFERIOR_PTID points to. 2801 2802 This comes from that fact that there is no explicit notion of 2803 "selected process" in the protocol. The selected process for 2804 general operations is the process the selected general thread 2805 belongs to. */ 2806 2807void 2808remote_target::set_general_process () 2809{ 2810 struct remote_state *rs = get_remote_state (); 2811 2812 /* If the remote can't handle multiple processes, don't bother. */ 2813 if (!remote_multi_process_p (rs)) 2814 return; 2815 2816 /* We only need to change the remote current thread if it's pointing 2817 at some other process. */ 2818 if (rs->general_thread.pid () != inferior_ptid.pid ()) 2819 set_general_thread (inferior_ptid); 2820} 2821 2822 2823/* Return nonzero if this is the main thread that we made up ourselves 2824 to model non-threaded targets as single-threaded. */ 2825 2826static int 2827remote_thread_always_alive (ptid_t ptid) 2828{ 2829 if (ptid == magic_null_ptid) 2830 /* The main thread is always alive. */ 2831 return 1; 2832 2833 if (ptid.pid () != 0 && ptid.lwp () == 0) 2834 /* The main thread is always alive. This can happen after a 2835 vAttach, if the remote side doesn't support 2836 multi-threading. */ 2837 return 1; 2838 2839 return 0; 2840} 2841 2842/* Return nonzero if the thread PTID is still alive on the remote 2843 system. */ 2844 2845bool 2846remote_target::thread_alive (ptid_t ptid) 2847{ 2848 struct remote_state *rs = get_remote_state (); 2849 char *p, *endp; 2850 2851 /* Check if this is a thread that we made up ourselves to model 2852 non-threaded targets as single-threaded. */ 2853 if (remote_thread_always_alive (ptid)) 2854 return 1; 2855 2856 p = rs->buf.data (); 2857 endp = p + get_remote_packet_size (); 2858 2859 *p++ = 'T'; 2860 write_ptid (p, endp, ptid); 2861 2862 putpkt (rs->buf); 2863 getpkt (&rs->buf, 0); 2864 return (rs->buf[0] == 'O' && rs->buf[1] == 'K'); 2865} 2866 2867/* Return a pointer to a thread name if we know it and NULL otherwise. 2868 The thread_info object owns the memory for the name. */ 2869 2870const char * 2871remote_target::thread_name (struct thread_info *info) 2872{ 2873 if (info->priv != NULL) 2874 { 2875 const std::string &name = get_remote_thread_info (info)->name; 2876 return !name.empty () ? name.c_str () : NULL; 2877 } 2878 2879 return NULL; 2880} 2881 2882/* About these extended threadlist and threadinfo packets. They are 2883 variable length packets but, the fields within them are often fixed 2884 length. They are redundant enough to send over UDP as is the 2885 remote protocol in general. There is a matching unit test module 2886 in libstub. */ 2887 2888/* WARNING: This threadref data structure comes from the remote O.S., 2889 libstub protocol encoding, and remote.c. It is not particularly 2890 changable. */ 2891 2892/* Right now, the internal structure is int. We want it to be bigger. 2893 Plan to fix this. */ 2894 2895typedef int gdb_threadref; /* Internal GDB thread reference. */ 2896 2897/* gdb_ext_thread_info is an internal GDB data structure which is 2898 equivalent to the reply of the remote threadinfo packet. */ 2899 2900struct gdb_ext_thread_info 2901 { 2902 threadref threadid; /* External form of thread reference. */ 2903 int active; /* Has state interesting to GDB? 2904 regs, stack. */ 2905 char display[256]; /* Brief state display, name, 2906 blocked/suspended. */ 2907 char shortname[32]; /* To be used to name threads. */ 2908 char more_display[256]; /* Long info, statistics, queue depth, 2909 whatever. */ 2910 }; 2911 2912/* The volume of remote transfers can be limited by submitting 2913 a mask containing bits specifying the desired information. 2914 Use a union of these values as the 'selection' parameter to 2915 get_thread_info. FIXME: Make these TAG names more thread specific. */ 2916 2917#define TAG_THREADID 1 2918#define TAG_EXISTS 2 2919#define TAG_DISPLAY 4 2920#define TAG_THREADNAME 8 2921#define TAG_MOREDISPLAY 16 2922 2923#define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2) 2924 2925static char *unpack_nibble (char *buf, int *val); 2926 2927static char *unpack_byte (char *buf, int *value); 2928 2929static char *pack_int (char *buf, int value); 2930 2931static char *unpack_int (char *buf, int *value); 2932 2933static char *unpack_string (char *src, char *dest, int length); 2934 2935static char *pack_threadid (char *pkt, threadref *id); 2936 2937static char *unpack_threadid (char *inbuf, threadref *id); 2938 2939void int_to_threadref (threadref *id, int value); 2940 2941static int threadref_to_int (threadref *ref); 2942 2943static void copy_threadref (threadref *dest, threadref *src); 2944 2945static int threadmatch (threadref *dest, threadref *src); 2946 2947static char *pack_threadinfo_request (char *pkt, int mode, 2948 threadref *id); 2949 2950static char *pack_threadlist_request (char *pkt, int startflag, 2951 int threadcount, 2952 threadref *nextthread); 2953 2954static int remote_newthread_step (threadref *ref, void *context); 2955 2956 2957/* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the 2958 buffer we're allowed to write to. Returns 2959 BUF+CHARACTERS_WRITTEN. */ 2960 2961char * 2962remote_target::write_ptid (char *buf, const char *endbuf, ptid_t ptid) 2963{ 2964 int pid, tid; 2965 struct remote_state *rs = get_remote_state (); 2966 2967 if (remote_multi_process_p (rs)) 2968 { 2969 pid = ptid.pid (); 2970 if (pid < 0) 2971 buf += xsnprintf (buf, endbuf - buf, "p-%x.", -pid); 2972 else 2973 buf += xsnprintf (buf, endbuf - buf, "p%x.", pid); 2974 } 2975 tid = ptid.lwp (); 2976 if (tid < 0) 2977 buf += xsnprintf (buf, endbuf - buf, "-%x", -tid); 2978 else 2979 buf += xsnprintf (buf, endbuf - buf, "%x", tid); 2980 2981 return buf; 2982} 2983 2984/* Extract a PTID from BUF. If non-null, OBUF is set to one past the 2985 last parsed char. Returns null_ptid if no thread id is found, and 2986 throws an error if the thread id has an invalid format. */ 2987 2988static ptid_t 2989read_ptid (const char *buf, const char **obuf) 2990{ 2991 const char *p = buf; 2992 const char *pp; 2993 ULONGEST pid = 0, tid = 0; 2994 2995 if (*p == 'p') 2996 { 2997 /* Multi-process ptid. */ 2998 pp = unpack_varlen_hex (p + 1, &pid); 2999 if (*pp != '.') 3000 error (_("invalid remote ptid: %s"), p); 3001 3002 p = pp; 3003 pp = unpack_varlen_hex (p + 1, &tid); 3004 if (obuf) 3005 *obuf = pp; 3006 return ptid_t (pid, tid, 0); 3007 } 3008 3009 /* No multi-process. Just a tid. */ 3010 pp = unpack_varlen_hex (p, &tid); 3011 3012 /* Return null_ptid when no thread id is found. */ 3013 if (p == pp) 3014 { 3015 if (obuf) 3016 *obuf = pp; 3017 return null_ptid; 3018 } 3019 3020 /* Since the stub is not sending a process id, then default to 3021 what's in inferior_ptid, unless it's null at this point. If so, 3022 then since there's no way to know the pid of the reported 3023 threads, use the magic number. */ 3024 if (inferior_ptid == null_ptid) 3025 pid = magic_null_ptid.pid (); 3026 else 3027 pid = inferior_ptid.pid (); 3028 3029 if (obuf) 3030 *obuf = pp; 3031 return ptid_t (pid, tid, 0); 3032} 3033 3034static int 3035stubhex (int ch) 3036{ 3037 if (ch >= 'a' && ch <= 'f') 3038 return ch - 'a' + 10; 3039 if (ch >= '0' && ch <= '9') 3040 return ch - '0'; 3041 if (ch >= 'A' && ch <= 'F') 3042 return ch - 'A' + 10; 3043 return -1; 3044} 3045 3046static int 3047stub_unpack_int (char *buff, int fieldlength) 3048{ 3049 int nibble; 3050 int retval = 0; 3051 3052 while (fieldlength) 3053 { 3054 nibble = stubhex (*buff++); 3055 retval |= nibble; 3056 fieldlength--; 3057 if (fieldlength) 3058 retval = retval << 4; 3059 } 3060 return retval; 3061} 3062 3063static char * 3064unpack_nibble (char *buf, int *val) 3065{ 3066 *val = fromhex (*buf++); 3067 return buf; 3068} 3069 3070static char * 3071unpack_byte (char *buf, int *value) 3072{ 3073 *value = stub_unpack_int (buf, 2); 3074 return buf + 2; 3075} 3076 3077static char * 3078pack_int (char *buf, int value) 3079{ 3080 buf = pack_hex_byte (buf, (value >> 24) & 0xff); 3081 buf = pack_hex_byte (buf, (value >> 16) & 0xff); 3082 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff); 3083 buf = pack_hex_byte (buf, (value & 0xff)); 3084 return buf; 3085} 3086 3087static char * 3088unpack_int (char *buf, int *value) 3089{ 3090 *value = stub_unpack_int (buf, 8); 3091 return buf + 8; 3092} 3093 3094#if 0 /* Currently unused, uncomment when needed. */ 3095static char *pack_string (char *pkt, char *string); 3096 3097static char * 3098pack_string (char *pkt, char *string) 3099{ 3100 char ch; 3101 int len; 3102 3103 len = strlen (string); 3104 if (len > 200) 3105 len = 200; /* Bigger than most GDB packets, junk??? */ 3106 pkt = pack_hex_byte (pkt, len); 3107 while (len-- > 0) 3108 { 3109 ch = *string++; 3110 if ((ch == '\0') || (ch == '#')) 3111 ch = '*'; /* Protect encapsulation. */ 3112 *pkt++ = ch; 3113 } 3114 return pkt; 3115} 3116#endif /* 0 (unused) */ 3117 3118static char * 3119unpack_string (char *src, char *dest, int length) 3120{ 3121 while (length--) 3122 *dest++ = *src++; 3123 *dest = '\0'; 3124 return src; 3125} 3126 3127static char * 3128pack_threadid (char *pkt, threadref *id) 3129{ 3130 char *limit; 3131 unsigned char *altid; 3132 3133 altid = (unsigned char *) id; 3134 limit = pkt + BUF_THREAD_ID_SIZE; 3135 while (pkt < limit) 3136 pkt = pack_hex_byte (pkt, *altid++); 3137 return pkt; 3138} 3139 3140 3141static char * 3142unpack_threadid (char *inbuf, threadref *id) 3143{ 3144 char *altref; 3145 char *limit = inbuf + BUF_THREAD_ID_SIZE; 3146 int x, y; 3147 3148 altref = (char *) id; 3149 3150 while (inbuf < limit) 3151 { 3152 x = stubhex (*inbuf++); 3153 y = stubhex (*inbuf++); 3154 *altref++ = (x << 4) | y; 3155 } 3156 return inbuf; 3157} 3158 3159/* Externally, threadrefs are 64 bits but internally, they are still 3160 ints. This is due to a mismatch of specifications. We would like 3161 to use 64bit thread references internally. This is an adapter 3162 function. */ 3163 3164void 3165int_to_threadref (threadref *id, int value) 3166{ 3167 unsigned char *scan; 3168 3169 scan = (unsigned char *) id; 3170 { 3171 int i = 4; 3172 while (i--) 3173 *scan++ = 0; 3174 } 3175 *scan++ = (value >> 24) & 0xff; 3176 *scan++ = (value >> 16) & 0xff; 3177 *scan++ = (value >> 8) & 0xff; 3178 *scan++ = (value & 0xff); 3179} 3180 3181static int 3182threadref_to_int (threadref *ref) 3183{ 3184 int i, value = 0; 3185 unsigned char *scan; 3186 3187 scan = *ref; 3188 scan += 4; 3189 i = 4; 3190 while (i-- > 0) 3191 value = (value << 8) | ((*scan++) & 0xff); 3192 return value; 3193} 3194 3195static void 3196copy_threadref (threadref *dest, threadref *src) 3197{ 3198 int i; 3199 unsigned char *csrc, *cdest; 3200 3201 csrc = (unsigned char *) src; 3202 cdest = (unsigned char *) dest; 3203 i = 8; 3204 while (i--) 3205 *cdest++ = *csrc++; 3206} 3207 3208static int 3209threadmatch (threadref *dest, threadref *src) 3210{ 3211 /* Things are broken right now, so just assume we got a match. */ 3212#if 0 3213 unsigned char *srcp, *destp; 3214 int i, result; 3215 srcp = (char *) src; 3216 destp = (char *) dest; 3217 3218 result = 1; 3219 while (i-- > 0) 3220 result &= (*srcp++ == *destp++) ? 1 : 0; 3221 return result; 3222#endif 3223 return 1; 3224} 3225 3226/* 3227 threadid:1, # always request threadid 3228 context_exists:2, 3229 display:4, 3230 unique_name:8, 3231 more_display:16 3232 */ 3233 3234/* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */ 3235 3236static char * 3237pack_threadinfo_request (char *pkt, int mode, threadref *id) 3238{ 3239 *pkt++ = 'q'; /* Info Query */ 3240 *pkt++ = 'P'; /* process or thread info */ 3241 pkt = pack_int (pkt, mode); /* mode */ 3242 pkt = pack_threadid (pkt, id); /* threadid */ 3243 *pkt = '\0'; /* terminate */ 3244 return pkt; 3245} 3246 3247/* These values tag the fields in a thread info response packet. */ 3248/* Tagging the fields allows us to request specific fields and to 3249 add more fields as time goes by. */ 3250 3251#define TAG_THREADID 1 /* Echo the thread identifier. */ 3252#define TAG_EXISTS 2 /* Is this process defined enough to 3253 fetch registers and its stack? */ 3254#define TAG_DISPLAY 4 /* A short thing maybe to put on a window */ 3255#define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */ 3256#define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about 3257 the process. */ 3258 3259int 3260remote_target::remote_unpack_thread_info_response (char *pkt, 3261 threadref *expectedref, 3262 gdb_ext_thread_info *info) 3263{ 3264 struct remote_state *rs = get_remote_state (); 3265 int mask, length; 3266 int tag; 3267 threadref ref; 3268 char *limit = pkt + rs->buf.size (); /* Plausible parsing limit. */ 3269 int retval = 1; 3270 3271 /* info->threadid = 0; FIXME: implement zero_threadref. */ 3272 info->active = 0; 3273 info->display[0] = '\0'; 3274 info->shortname[0] = '\0'; 3275 info->more_display[0] = '\0'; 3276 3277 /* Assume the characters indicating the packet type have been 3278 stripped. */ 3279 pkt = unpack_int (pkt, &mask); /* arg mask */ 3280 pkt = unpack_threadid (pkt, &ref); 3281 3282 if (mask == 0) 3283 warning (_("Incomplete response to threadinfo request.")); 3284 if (!threadmatch (&ref, expectedref)) 3285 { /* This is an answer to a different request. */ 3286 warning (_("ERROR RMT Thread info mismatch.")); 3287 return 0; 3288 } 3289 copy_threadref (&info->threadid, &ref); 3290 3291 /* Loop on tagged fields , try to bail if something goes wrong. */ 3292 3293 /* Packets are terminated with nulls. */ 3294 while ((pkt < limit) && mask && *pkt) 3295 { 3296 pkt = unpack_int (pkt, &tag); /* tag */ 3297 pkt = unpack_byte (pkt, &length); /* length */ 3298 if (!(tag & mask)) /* Tags out of synch with mask. */ 3299 { 3300 warning (_("ERROR RMT: threadinfo tag mismatch.")); 3301 retval = 0; 3302 break; 3303 } 3304 if (tag == TAG_THREADID) 3305 { 3306 if (length != 16) 3307 { 3308 warning (_("ERROR RMT: length of threadid is not 16.")); 3309 retval = 0; 3310 break; 3311 } 3312 pkt = unpack_threadid (pkt, &ref); 3313 mask = mask & ~TAG_THREADID; 3314 continue; 3315 } 3316 if (tag == TAG_EXISTS) 3317 { 3318 info->active = stub_unpack_int (pkt, length); 3319 pkt += length; 3320 mask = mask & ~(TAG_EXISTS); 3321 if (length > 8) 3322 { 3323 warning (_("ERROR RMT: 'exists' length too long.")); 3324 retval = 0; 3325 break; 3326 } 3327 continue; 3328 } 3329 if (tag == TAG_THREADNAME) 3330 { 3331 pkt = unpack_string (pkt, &info->shortname[0], length); 3332 mask = mask & ~TAG_THREADNAME; 3333 continue; 3334 } 3335 if (tag == TAG_DISPLAY) 3336 { 3337 pkt = unpack_string (pkt, &info->display[0], length); 3338 mask = mask & ~TAG_DISPLAY; 3339 continue; 3340 } 3341 if (tag == TAG_MOREDISPLAY) 3342 { 3343 pkt = unpack_string (pkt, &info->more_display[0], length); 3344 mask = mask & ~TAG_MOREDISPLAY; 3345 continue; 3346 } 3347 warning (_("ERROR RMT: unknown thread info tag.")); 3348 break; /* Not a tag we know about. */ 3349 } 3350 return retval; 3351} 3352 3353int 3354remote_target::remote_get_threadinfo (threadref *threadid, 3355 int fieldset, 3356 gdb_ext_thread_info *info) 3357{ 3358 struct remote_state *rs = get_remote_state (); 3359 int result; 3360 3361 pack_threadinfo_request (rs->buf.data (), fieldset, threadid); 3362 putpkt (rs->buf); 3363 getpkt (&rs->buf, 0); 3364 3365 if (rs->buf[0] == '\0') 3366 return 0; 3367 3368 result = remote_unpack_thread_info_response (&rs->buf[2], 3369 threadid, info); 3370 return result; 3371} 3372 3373/* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */ 3374 3375static char * 3376pack_threadlist_request (char *pkt, int startflag, int threadcount, 3377 threadref *nextthread) 3378{ 3379 *pkt++ = 'q'; /* info query packet */ 3380 *pkt++ = 'L'; /* Process LIST or threadLIST request */ 3381 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */ 3382 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */ 3383 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */ 3384 *pkt = '\0'; 3385 return pkt; 3386} 3387 3388/* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */ 3389 3390int 3391remote_target::parse_threadlist_response (char *pkt, int result_limit, 3392 threadref *original_echo, 3393 threadref *resultlist, 3394 int *doneflag) 3395{ 3396 struct remote_state *rs = get_remote_state (); 3397 char *limit; 3398 int count, resultcount, done; 3399 3400 resultcount = 0; 3401 /* Assume the 'q' and 'M chars have been stripped. */ 3402 limit = pkt + (rs->buf.size () - BUF_THREAD_ID_SIZE); 3403 /* done parse past here */ 3404 pkt = unpack_byte (pkt, &count); /* count field */ 3405 pkt = unpack_nibble (pkt, &done); 3406 /* The first threadid is the argument threadid. */ 3407 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */ 3408 while ((count-- > 0) && (pkt < limit)) 3409 { 3410 pkt = unpack_threadid (pkt, resultlist++); 3411 if (resultcount++ >= result_limit) 3412 break; 3413 } 3414 if (doneflag) 3415 *doneflag = done; 3416 return resultcount; 3417} 3418 3419/* Fetch the next batch of threads from the remote. Returns -1 if the 3420 qL packet is not supported, 0 on error and 1 on success. */ 3421 3422int 3423remote_target::remote_get_threadlist (int startflag, threadref *nextthread, 3424 int result_limit, int *done, int *result_count, 3425 threadref *threadlist) 3426{ 3427 struct remote_state *rs = get_remote_state (); 3428 int result = 1; 3429 3430 /* Truncate result limit to be smaller than the packet size. */ 3431 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) 3432 >= get_remote_packet_size ()) 3433 result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2; 3434 3435 pack_threadlist_request (rs->buf.data (), startflag, result_limit, 3436 nextthread); 3437 putpkt (rs->buf); 3438 getpkt (&rs->buf, 0); 3439 if (rs->buf[0] == '\0') 3440 { 3441 /* Packet not supported. */ 3442 return -1; 3443 } 3444 3445 *result_count = 3446 parse_threadlist_response (&rs->buf[2], result_limit, 3447 &rs->echo_nextthread, threadlist, done); 3448 3449 if (!threadmatch (&rs->echo_nextthread, nextthread)) 3450 { 3451 /* FIXME: This is a good reason to drop the packet. */ 3452 /* Possibly, there is a duplicate response. */ 3453 /* Possibilities : 3454 retransmit immediatly - race conditions 3455 retransmit after timeout - yes 3456 exit 3457 wait for packet, then exit 3458 */ 3459 warning (_("HMM: threadlist did not echo arg thread, dropping it.")); 3460 return 0; /* I choose simply exiting. */ 3461 } 3462 if (*result_count <= 0) 3463 { 3464 if (*done != 1) 3465 { 3466 warning (_("RMT ERROR : failed to get remote thread list.")); 3467 result = 0; 3468 } 3469 return result; /* break; */ 3470 } 3471 if (*result_count > result_limit) 3472 { 3473 *result_count = 0; 3474 warning (_("RMT ERROR: threadlist response longer than requested.")); 3475 return 0; 3476 } 3477 return result; 3478} 3479 3480/* Fetch the list of remote threads, with the qL packet, and call 3481 STEPFUNCTION for each thread found. Stops iterating and returns 1 3482 if STEPFUNCTION returns true. Stops iterating and returns 0 if the 3483 STEPFUNCTION returns false. If the packet is not supported, 3484 returns -1. */ 3485 3486int 3487remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction, 3488 void *context, int looplimit) 3489{ 3490 struct remote_state *rs = get_remote_state (); 3491 int done, i, result_count; 3492 int startflag = 1; 3493 int result = 1; 3494 int loopcount = 0; 3495 3496 done = 0; 3497 while (!done) 3498 { 3499 if (loopcount++ > looplimit) 3500 { 3501 result = 0; 3502 warning (_("Remote fetch threadlist -infinite loop-.")); 3503 break; 3504 } 3505 result = remote_get_threadlist (startflag, &rs->nextthread, 3506 MAXTHREADLISTRESULTS, 3507 &done, &result_count, 3508 rs->resultthreadlist); 3509 if (result <= 0) 3510 break; 3511 /* Clear for later iterations. */ 3512 startflag = 0; 3513 /* Setup to resume next batch of thread references, set nextthread. */ 3514 if (result_count >= 1) 3515 copy_threadref (&rs->nextthread, 3516 &rs->resultthreadlist[result_count - 1]); 3517 i = 0; 3518 while (result_count--) 3519 { 3520 if (!(*stepfunction) (&rs->resultthreadlist[i++], context)) 3521 { 3522 result = 0; 3523 break; 3524 } 3525 } 3526 } 3527 return result; 3528} 3529 3530/* A thread found on the remote target. */ 3531 3532struct thread_item 3533{ 3534 explicit thread_item (ptid_t ptid_) 3535 : ptid (ptid_) 3536 {} 3537 3538 thread_item (thread_item &&other) = default; 3539 thread_item &operator= (thread_item &&other) = default; 3540 3541 DISABLE_COPY_AND_ASSIGN (thread_item); 3542 3543 /* The thread's PTID. */ 3544 ptid_t ptid; 3545 3546 /* The thread's extra info. */ 3547 std::string extra; 3548 3549 /* The thread's name. */ 3550 std::string name; 3551 3552 /* The core the thread was running on. -1 if not known. */ 3553 int core = -1; 3554 3555 /* The thread handle associated with the thread. */ 3556 gdb::byte_vector thread_handle; 3557}; 3558 3559/* Context passed around to the various methods listing remote 3560 threads. As new threads are found, they're added to the ITEMS 3561 vector. */ 3562 3563struct threads_listing_context 3564{ 3565 /* Return true if this object contains an entry for a thread with ptid 3566 PTID. */ 3567 3568 bool contains_thread (ptid_t ptid) const 3569 { 3570 auto match_ptid = [&] (const thread_item &item) 3571 { 3572 return item.ptid == ptid; 3573 }; 3574 3575 auto it = std::find_if (this->items.begin (), 3576 this->items.end (), 3577 match_ptid); 3578 3579 return it != this->items.end (); 3580 } 3581 3582 /* Remove the thread with ptid PTID. */ 3583 3584 void remove_thread (ptid_t ptid) 3585 { 3586 auto match_ptid = [&] (const thread_item &item) 3587 { 3588 return item.ptid == ptid; 3589 }; 3590 3591 auto it = std::remove_if (this->items.begin (), 3592 this->items.end (), 3593 match_ptid); 3594 3595 if (it != this->items.end ()) 3596 this->items.erase (it); 3597 } 3598 3599 /* The threads found on the remote target. */ 3600 std::vector<thread_item> items; 3601}; 3602 3603static int 3604remote_newthread_step (threadref *ref, void *data) 3605{ 3606 struct threads_listing_context *context 3607 = (struct threads_listing_context *) data; 3608 int pid = inferior_ptid.pid (); 3609 int lwp = threadref_to_int (ref); 3610 ptid_t ptid (pid, lwp); 3611 3612 context->items.emplace_back (ptid); 3613 3614 return 1; /* continue iterator */ 3615} 3616 3617#define CRAZY_MAX_THREADS 1000 3618 3619ptid_t 3620remote_target::remote_current_thread (ptid_t oldpid) 3621{ 3622 struct remote_state *rs = get_remote_state (); 3623 3624 putpkt ("qC"); 3625 getpkt (&rs->buf, 0); 3626 if (rs->buf[0] == 'Q' && rs->buf[1] == 'C') 3627 { 3628 const char *obuf; 3629 ptid_t result; 3630 3631 result = read_ptid (&rs->buf[2], &obuf); 3632 if (*obuf != '\0' && remote_debug) 3633 fprintf_unfiltered (gdb_stdlog, 3634 "warning: garbage in qC reply\n"); 3635 3636 return result; 3637 } 3638 else 3639 return oldpid; 3640} 3641 3642/* List remote threads using the deprecated qL packet. */ 3643 3644int 3645remote_target::remote_get_threads_with_ql (threads_listing_context *context) 3646{ 3647 if (remote_threadlist_iterator (remote_newthread_step, context, 3648 CRAZY_MAX_THREADS) >= 0) 3649 return 1; 3650 3651 return 0; 3652} 3653 3654#if defined(HAVE_LIBEXPAT) 3655 3656static void 3657start_thread (struct gdb_xml_parser *parser, 3658 const struct gdb_xml_element *element, 3659 void *user_data, 3660 std::vector<gdb_xml_value> &attributes) 3661{ 3662 struct threads_listing_context *data 3663 = (struct threads_listing_context *) user_data; 3664 struct gdb_xml_value *attr; 3665 3666 char *id = (char *) xml_find_attribute (attributes, "id")->value.get (); 3667 ptid_t ptid = read_ptid (id, NULL); 3668 3669 data->items.emplace_back (ptid); 3670 thread_item &item = data->items.back (); 3671 3672 attr = xml_find_attribute (attributes, "core"); 3673 if (attr != NULL) 3674 item.core = *(ULONGEST *) attr->value.get (); 3675 3676 attr = xml_find_attribute (attributes, "name"); 3677 if (attr != NULL) 3678 item.name = (const char *) attr->value.get (); 3679 3680 attr = xml_find_attribute (attributes, "handle"); 3681 if (attr != NULL) 3682 item.thread_handle = hex2bin ((const char *) attr->value.get ()); 3683} 3684 3685static void 3686end_thread (struct gdb_xml_parser *parser, 3687 const struct gdb_xml_element *element, 3688 void *user_data, const char *body_text) 3689{ 3690 struct threads_listing_context *data 3691 = (struct threads_listing_context *) user_data; 3692 3693 if (body_text != NULL && *body_text != '\0') 3694 data->items.back ().extra = body_text; 3695} 3696 3697const struct gdb_xml_attribute thread_attributes[] = { 3698 { "id", GDB_XML_AF_NONE, NULL, NULL }, 3699 { "core", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL }, 3700 { "name", GDB_XML_AF_OPTIONAL, NULL, NULL }, 3701 { "handle", GDB_XML_AF_OPTIONAL, NULL, NULL }, 3702 { NULL, GDB_XML_AF_NONE, NULL, NULL } 3703}; 3704 3705const struct gdb_xml_element thread_children[] = { 3706 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } 3707}; 3708 3709const struct gdb_xml_element threads_children[] = { 3710 { "thread", thread_attributes, thread_children, 3711 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL, 3712 start_thread, end_thread }, 3713 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } 3714}; 3715 3716const struct gdb_xml_element threads_elements[] = { 3717 { "threads", NULL, threads_children, 3718 GDB_XML_EF_NONE, NULL, NULL }, 3719 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } 3720}; 3721 3722#endif 3723 3724/* List remote threads using qXfer:threads:read. */ 3725 3726int 3727remote_target::remote_get_threads_with_qxfer (threads_listing_context *context) 3728{ 3729#if defined(HAVE_LIBEXPAT) 3730 if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE) 3731 { 3732 gdb::optional<gdb::char_vector> xml 3733 = target_read_stralloc (this, TARGET_OBJECT_THREADS, NULL); 3734 3735 if (xml && (*xml)[0] != '\0') 3736 { 3737 gdb_xml_parse_quick (_("threads"), "threads.dtd", 3738 threads_elements, xml->data (), context); 3739 } 3740 3741 return 1; 3742 } 3743#endif 3744 3745 return 0; 3746} 3747 3748/* List remote threads using qfThreadInfo/qsThreadInfo. */ 3749 3750int 3751remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context *context) 3752{ 3753 struct remote_state *rs = get_remote_state (); 3754 3755 if (rs->use_threadinfo_query) 3756 { 3757 const char *bufp; 3758 3759 putpkt ("qfThreadInfo"); 3760 getpkt (&rs->buf, 0); 3761 bufp = rs->buf.data (); 3762 if (bufp[0] != '\0') /* q packet recognized */ 3763 { 3764 while (*bufp++ == 'm') /* reply contains one or more TID */ 3765 { 3766 do 3767 { 3768 ptid_t ptid = read_ptid (bufp, &bufp); 3769 context->items.emplace_back (ptid); 3770 } 3771 while (*bufp++ == ','); /* comma-separated list */ 3772 putpkt ("qsThreadInfo"); 3773 getpkt (&rs->buf, 0); 3774 bufp = rs->buf.data (); 3775 } 3776 return 1; 3777 } 3778 else 3779 { 3780 /* Packet not recognized. */ 3781 rs->use_threadinfo_query = 0; 3782 } 3783 } 3784 3785 return 0; 3786} 3787 3788/* Return true if INF only has one non-exited thread. */ 3789 3790static bool 3791has_single_non_exited_thread (inferior *inf) 3792{ 3793 int count = 0; 3794 for (thread_info *tp ATTRIBUTE_UNUSED : inf->non_exited_threads ()) 3795 if (++count > 1) 3796 break; 3797 return count == 1; 3798} 3799 3800/* Implement the to_update_thread_list function for the remote 3801 targets. */ 3802 3803void 3804remote_target::update_thread_list () 3805{ 3806 struct threads_listing_context context; 3807 int got_list = 0; 3808 3809 /* We have a few different mechanisms to fetch the thread list. Try 3810 them all, starting with the most preferred one first, falling 3811 back to older methods. */ 3812 if (remote_get_threads_with_qxfer (&context) 3813 || remote_get_threads_with_qthreadinfo (&context) 3814 || remote_get_threads_with_ql (&context)) 3815 { 3816 got_list = 1; 3817 3818 if (context.items.empty () 3819 && remote_thread_always_alive (inferior_ptid)) 3820 { 3821 /* Some targets don't really support threads, but still 3822 reply an (empty) thread list in response to the thread 3823 listing packets, instead of replying "packet not 3824 supported". Exit early so we don't delete the main 3825 thread. */ 3826 return; 3827 } 3828 3829 /* CONTEXT now holds the current thread list on the remote 3830 target end. Delete GDB-side threads no longer found on the 3831 target. */ 3832 for (thread_info *tp : all_threads_safe ()) 3833 { 3834 if (tp->inf->process_target () != this) 3835 continue; 3836 3837 if (!context.contains_thread (tp->ptid)) 3838 { 3839 /* Do not remove the thread if it is the last thread in 3840 the inferior. This situation happens when we have a 3841 pending exit process status to process. Otherwise we 3842 may end up with a seemingly live inferior (i.e. pid 3843 != 0) that has no threads. */ 3844 if (has_single_non_exited_thread (tp->inf)) 3845 continue; 3846 3847 /* Not found. */ 3848 delete_thread (tp); 3849 } 3850 } 3851 3852 /* Remove any unreported fork child threads from CONTEXT so 3853 that we don't interfere with follow fork, which is where 3854 creation of such threads is handled. */ 3855 remove_new_fork_children (&context); 3856 3857 /* And now add threads we don't know about yet to our list. */ 3858 for (thread_item &item : context.items) 3859 { 3860 if (item.ptid != null_ptid) 3861 { 3862 /* In non-stop mode, we assume new found threads are 3863 executing until proven otherwise with a stop reply. 3864 In all-stop, we can only get here if all threads are 3865 stopped. */ 3866 int executing = target_is_non_stop_p () ? 1 : 0; 3867 3868 remote_notice_new_inferior (item.ptid, executing); 3869 3870 thread_info *tp = find_thread_ptid (this, item.ptid); 3871 remote_thread_info *info = get_remote_thread_info (tp); 3872 info->core = item.core; 3873 info->extra = std::move (item.extra); 3874 info->name = std::move (item.name); 3875 info->thread_handle = std::move (item.thread_handle); 3876 } 3877 } 3878 } 3879 3880 if (!got_list) 3881 { 3882 /* If no thread listing method is supported, then query whether 3883 each known thread is alive, one by one, with the T packet. 3884 If the target doesn't support threads at all, then this is a 3885 no-op. See remote_thread_alive. */ 3886 prune_threads (); 3887 } 3888} 3889 3890/* 3891 * Collect a descriptive string about the given thread. 3892 * The target may say anything it wants to about the thread 3893 * (typically info about its blocked / runnable state, name, etc.). 3894 * This string will appear in the info threads display. 3895 * 3896 * Optional: targets are not required to implement this function. 3897 */ 3898 3899const char * 3900remote_target::extra_thread_info (thread_info *tp) 3901{ 3902 struct remote_state *rs = get_remote_state (); 3903 int set; 3904 threadref id; 3905 struct gdb_ext_thread_info threadinfo; 3906 3907 if (rs->remote_desc == 0) /* paranoia */ 3908 internal_error (__FILE__, __LINE__, 3909 _("remote_threads_extra_info")); 3910 3911 if (tp->ptid == magic_null_ptid 3912 || (tp->ptid.pid () != 0 && tp->ptid.lwp () == 0)) 3913 /* This is the main thread which was added by GDB. The remote 3914 server doesn't know about it. */ 3915 return NULL; 3916 3917 std::string &extra = get_remote_thread_info (tp)->extra; 3918 3919 /* If already have cached info, use it. */ 3920 if (!extra.empty ()) 3921 return extra.c_str (); 3922 3923 if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE) 3924 { 3925 /* If we're using qXfer:threads:read, then the extra info is 3926 included in the XML. So if we didn't have anything cached, 3927 it's because there's really no extra info. */ 3928 return NULL; 3929 } 3930 3931 if (rs->use_threadextra_query) 3932 { 3933 char *b = rs->buf.data (); 3934 char *endb = b + get_remote_packet_size (); 3935 3936 xsnprintf (b, endb - b, "qThreadExtraInfo,"); 3937 b += strlen (b); 3938 write_ptid (b, endb, tp->ptid); 3939 3940 putpkt (rs->buf); 3941 getpkt (&rs->buf, 0); 3942 if (rs->buf[0] != 0) 3943 { 3944 extra.resize (strlen (rs->buf.data ()) / 2); 3945 hex2bin (rs->buf.data (), (gdb_byte *) &extra[0], extra.size ()); 3946 return extra.c_str (); 3947 } 3948 } 3949 3950 /* If the above query fails, fall back to the old method. */ 3951 rs->use_threadextra_query = 0; 3952 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME 3953 | TAG_MOREDISPLAY | TAG_DISPLAY; 3954 int_to_threadref (&id, tp->ptid.lwp ()); 3955 if (remote_get_threadinfo (&id, set, &threadinfo)) 3956 if (threadinfo.active) 3957 { 3958 if (*threadinfo.shortname) 3959 string_appendf (extra, " Name: %s", threadinfo.shortname); 3960 if (*threadinfo.display) 3961 { 3962 if (!extra.empty ()) 3963 extra += ','; 3964 string_appendf (extra, " State: %s", threadinfo.display); 3965 } 3966 if (*threadinfo.more_display) 3967 { 3968 if (!extra.empty ()) 3969 extra += ','; 3970 string_appendf (extra, " Priority: %s", threadinfo.more_display); 3971 } 3972 return extra.c_str (); 3973 } 3974 return NULL; 3975} 3976 3977 3978bool 3979remote_target::static_tracepoint_marker_at (CORE_ADDR addr, 3980 struct static_tracepoint_marker *marker) 3981{ 3982 struct remote_state *rs = get_remote_state (); 3983 char *p = rs->buf.data (); 3984 3985 xsnprintf (p, get_remote_packet_size (), "qTSTMat:"); 3986 p += strlen (p); 3987 p += hexnumstr (p, addr); 3988 putpkt (rs->buf); 3989 getpkt (&rs->buf, 0); 3990 p = rs->buf.data (); 3991 3992 if (*p == 'E') 3993 error (_("Remote failure reply: %s"), p); 3994 3995 if (*p++ == 'm') 3996 { 3997 parse_static_tracepoint_marker_definition (p, NULL, marker); 3998 return true; 3999 } 4000 4001 return false; 4002} 4003 4004std::vector<static_tracepoint_marker> 4005remote_target::static_tracepoint_markers_by_strid (const char *strid) 4006{ 4007 struct remote_state *rs = get_remote_state (); 4008 std::vector<static_tracepoint_marker> markers; 4009 const char *p; 4010 static_tracepoint_marker marker; 4011 4012 /* Ask for a first packet of static tracepoint marker 4013 definition. */ 4014 putpkt ("qTfSTM"); 4015 getpkt (&rs->buf, 0); 4016 p = rs->buf.data (); 4017 if (*p == 'E') 4018 error (_("Remote failure reply: %s"), p); 4019 4020 while (*p++ == 'm') 4021 { 4022 do 4023 { 4024 parse_static_tracepoint_marker_definition (p, &p, &marker); 4025 4026 if (strid == NULL || marker.str_id == strid) 4027 markers.push_back (std::move (marker)); 4028 } 4029 while (*p++ == ','); /* comma-separated list */ 4030 /* Ask for another packet of static tracepoint definition. */ 4031 putpkt ("qTsSTM"); 4032 getpkt (&rs->buf, 0); 4033 p = rs->buf.data (); 4034 } 4035 4036 return markers; 4037} 4038 4039 4040/* Implement the to_get_ada_task_ptid function for the remote targets. */ 4041 4042ptid_t 4043remote_target::get_ada_task_ptid (long lwp, long thread) 4044{ 4045 return ptid_t (inferior_ptid.pid (), lwp, 0); 4046} 4047 4048 4049/* Restart the remote side; this is an extended protocol operation. */ 4050 4051void 4052remote_target::extended_remote_restart () 4053{ 4054 struct remote_state *rs = get_remote_state (); 4055 4056 /* Send the restart command; for reasons I don't understand the 4057 remote side really expects a number after the "R". */ 4058 xsnprintf (rs->buf.data (), get_remote_packet_size (), "R%x", 0); 4059 putpkt (rs->buf); 4060 4061 remote_fileio_reset (); 4062} 4063 4064/* Clean up connection to a remote debugger. */ 4065 4066void 4067remote_target::close () 4068{ 4069 /* Make sure we leave stdin registered in the event loop. */ 4070 terminal_ours (); 4071 4072 trace_reset_local_state (); 4073 4074 delete this; 4075} 4076 4077remote_target::~remote_target () 4078{ 4079 struct remote_state *rs = get_remote_state (); 4080 4081 /* Check for NULL because we may get here with a partially 4082 constructed target/connection. */ 4083 if (rs->remote_desc == nullptr) 4084 return; 4085 4086 serial_close (rs->remote_desc); 4087 4088 /* We are destroying the remote target, so we should discard 4089 everything of this target. */ 4090 discard_pending_stop_replies_in_queue (); 4091 4092 if (rs->remote_async_inferior_event_token) 4093 delete_async_event_handler (&rs->remote_async_inferior_event_token); 4094 4095 delete rs->notif_state; 4096} 4097 4098/* Query the remote side for the text, data and bss offsets. */ 4099 4100void 4101remote_target::get_offsets () 4102{ 4103 struct remote_state *rs = get_remote_state (); 4104 char *buf; 4105 char *ptr; 4106 int lose, num_segments = 0, do_sections, do_segments; 4107 CORE_ADDR text_addr, data_addr, bss_addr, segments[2]; 4108 4109 if (symfile_objfile == NULL) 4110 return; 4111 4112 putpkt ("qOffsets"); 4113 getpkt (&rs->buf, 0); 4114 buf = rs->buf.data (); 4115 4116 if (buf[0] == '\000') 4117 return; /* Return silently. Stub doesn't support 4118 this command. */ 4119 if (buf[0] == 'E') 4120 { 4121 warning (_("Remote failure reply: %s"), buf); 4122 return; 4123 } 4124 4125 /* Pick up each field in turn. This used to be done with scanf, but 4126 scanf will make trouble if CORE_ADDR size doesn't match 4127 conversion directives correctly. The following code will work 4128 with any size of CORE_ADDR. */ 4129 text_addr = data_addr = bss_addr = 0; 4130 ptr = buf; 4131 lose = 0; 4132 4133 if (startswith (ptr, "Text=")) 4134 { 4135 ptr += 5; 4136 /* Don't use strtol, could lose on big values. */ 4137 while (*ptr && *ptr != ';') 4138 text_addr = (text_addr << 4) + fromhex (*ptr++); 4139 4140 if (startswith (ptr, ";Data=")) 4141 { 4142 ptr += 6; 4143 while (*ptr && *ptr != ';') 4144 data_addr = (data_addr << 4) + fromhex (*ptr++); 4145 } 4146 else 4147 lose = 1; 4148 4149 if (!lose && startswith (ptr, ";Bss=")) 4150 { 4151 ptr += 5; 4152 while (*ptr && *ptr != ';') 4153 bss_addr = (bss_addr << 4) + fromhex (*ptr++); 4154 4155 if (bss_addr != data_addr) 4156 warning (_("Target reported unsupported offsets: %s"), buf); 4157 } 4158 else 4159 lose = 1; 4160 } 4161 else if (startswith (ptr, "TextSeg=")) 4162 { 4163 ptr += 8; 4164 /* Don't use strtol, could lose on big values. */ 4165 while (*ptr && *ptr != ';') 4166 text_addr = (text_addr << 4) + fromhex (*ptr++); 4167 num_segments = 1; 4168 4169 if (startswith (ptr, ";DataSeg=")) 4170 { 4171 ptr += 9; 4172 while (*ptr && *ptr != ';') 4173 data_addr = (data_addr << 4) + fromhex (*ptr++); 4174 num_segments++; 4175 } 4176 } 4177 else 4178 lose = 1; 4179 4180 if (lose) 4181 error (_("Malformed response to offset query, %s"), buf); 4182 else if (*ptr != '\0') 4183 warning (_("Target reported unsupported offsets: %s"), buf); 4184 4185 section_offsets offs = symfile_objfile->section_offsets; 4186 4187 symfile_segment_data_up data 4188 = get_symfile_segment_data (symfile_objfile->obfd); 4189 do_segments = (data != NULL); 4190 do_sections = num_segments == 0; 4191 4192 if (num_segments > 0) 4193 { 4194 segments[0] = text_addr; 4195 segments[1] = data_addr; 4196 } 4197 /* If we have two segments, we can still try to relocate everything 4198 by assuming that the .text and .data offsets apply to the whole 4199 text and data segments. Convert the offsets given in the packet 4200 to base addresses for symfile_map_offsets_to_segments. */ 4201 else if (data != nullptr && data->segments.size () == 2) 4202 { 4203 segments[0] = data->segments[0].base + text_addr; 4204 segments[1] = data->segments[1].base + data_addr; 4205 num_segments = 2; 4206 } 4207 /* If the object file has only one segment, assume that it is text 4208 rather than data; main programs with no writable data are rare, 4209 but programs with no code are useless. Of course the code might 4210 have ended up in the data segment... to detect that we would need 4211 the permissions here. */ 4212 else if (data && data->segments.size () == 1) 4213 { 4214 segments[0] = data->segments[0].base + text_addr; 4215 num_segments = 1; 4216 } 4217 /* There's no way to relocate by segment. */ 4218 else 4219 do_segments = 0; 4220 4221 if (do_segments) 4222 { 4223 int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, 4224 data.get (), offs, 4225 num_segments, segments); 4226 4227 if (ret == 0 && !do_sections) 4228 error (_("Can not handle qOffsets TextSeg " 4229 "response with this symbol file")); 4230 4231 if (ret > 0) 4232 do_sections = 0; 4233 } 4234 4235 if (do_sections) 4236 { 4237 offs[SECT_OFF_TEXT (symfile_objfile)] = text_addr; 4238 4239 /* This is a temporary kludge to force data and bss to use the 4240 same offsets because that's what nlmconv does now. The real 4241 solution requires changes to the stub and remote.c that I 4242 don't have time to do right now. */ 4243 4244 offs[SECT_OFF_DATA (symfile_objfile)] = data_addr; 4245 offs[SECT_OFF_BSS (symfile_objfile)] = data_addr; 4246 } 4247 4248 objfile_relocate (symfile_objfile, offs); 4249} 4250 4251/* Send interrupt_sequence to remote target. */ 4252 4253void 4254remote_target::send_interrupt_sequence () 4255{ 4256 struct remote_state *rs = get_remote_state (); 4257 4258 if (interrupt_sequence_mode == interrupt_sequence_control_c) 4259 remote_serial_write ("\x03", 1); 4260 else if (interrupt_sequence_mode == interrupt_sequence_break) 4261 serial_send_break (rs->remote_desc); 4262 else if (interrupt_sequence_mode == interrupt_sequence_break_g) 4263 { 4264 serial_send_break (rs->remote_desc); 4265 remote_serial_write ("g", 1); 4266 } 4267 else 4268 internal_error (__FILE__, __LINE__, 4269 _("Invalid value for interrupt_sequence_mode: %s."), 4270 interrupt_sequence_mode); 4271} 4272 4273 4274/* If STOP_REPLY is a T stop reply, look for the "thread" register, 4275 and extract the PTID. Returns NULL_PTID if not found. */ 4276 4277static ptid_t 4278stop_reply_extract_thread (char *stop_reply) 4279{ 4280 if (stop_reply[0] == 'T' && strlen (stop_reply) > 3) 4281 { 4282 const char *p; 4283 4284 /* Txx r:val ; r:val (...) */ 4285 p = &stop_reply[3]; 4286 4287 /* Look for "register" named "thread". */ 4288 while (*p != '\0') 4289 { 4290 const char *p1; 4291 4292 p1 = strchr (p, ':'); 4293 if (p1 == NULL) 4294 return null_ptid; 4295 4296 if (strncmp (p, "thread", p1 - p) == 0) 4297 return read_ptid (++p1, &p); 4298 4299 p1 = strchr (p, ';'); 4300 if (p1 == NULL) 4301 return null_ptid; 4302 p1++; 4303 4304 p = p1; 4305 } 4306 } 4307 4308 return null_ptid; 4309} 4310 4311/* Determine the remote side's current thread. If we have a stop 4312 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a 4313 "thread" register we can extract the current thread from. If not, 4314 ask the remote which is the current thread with qC. The former 4315 method avoids a roundtrip. */ 4316 4317ptid_t 4318remote_target::get_current_thread (char *wait_status) 4319{ 4320 ptid_t ptid = null_ptid; 4321 4322 /* Note we don't use remote_parse_stop_reply as that makes use of 4323 the target architecture, which we haven't yet fully determined at 4324 this point. */ 4325 if (wait_status != NULL) 4326 ptid = stop_reply_extract_thread (wait_status); 4327 if (ptid == null_ptid) 4328 ptid = remote_current_thread (inferior_ptid); 4329 4330 return ptid; 4331} 4332 4333/* Query the remote target for which is the current thread/process, 4334 add it to our tables, and update INFERIOR_PTID. The caller is 4335 responsible for setting the state such that the remote end is ready 4336 to return the current thread. 4337 4338 This function is called after handling the '?' or 'vRun' packets, 4339 whose response is a stop reply from which we can also try 4340 extracting the thread. If the target doesn't support the explicit 4341 qC query, we infer the current thread from that stop reply, passed 4342 in in WAIT_STATUS, which may be NULL. */ 4343 4344void 4345remote_target::add_current_inferior_and_thread (char *wait_status) 4346{ 4347 struct remote_state *rs = get_remote_state (); 4348 bool fake_pid_p = false; 4349 4350 switch_to_no_thread (); 4351 4352 /* Now, if we have thread information, update the current thread's 4353 ptid. */ 4354 ptid_t curr_ptid = get_current_thread (wait_status); 4355 4356 if (curr_ptid != null_ptid) 4357 { 4358 if (!remote_multi_process_p (rs)) 4359 fake_pid_p = true; 4360 } 4361 else 4362 { 4363 /* Without this, some commands which require an active target 4364 (such as kill) won't work. This variable serves (at least) 4365 double duty as both the pid of the target process (if it has 4366 such), and as a flag indicating that a target is active. */ 4367 curr_ptid = magic_null_ptid; 4368 fake_pid_p = true; 4369 } 4370 4371 remote_add_inferior (fake_pid_p, curr_ptid.pid (), -1, 1); 4372 4373 /* Add the main thread and switch to it. Don't try reading 4374 registers yet, since we haven't fetched the target description 4375 yet. */ 4376 thread_info *tp = add_thread_silent (this, curr_ptid); 4377 switch_to_thread_no_regs (tp); 4378} 4379 4380/* Print info about a thread that was found already stopped on 4381 connection. */ 4382 4383static void 4384print_one_stopped_thread (struct thread_info *thread) 4385{ 4386 struct target_waitstatus *ws = &thread->suspend.waitstatus; 4387 4388 switch_to_thread (thread); 4389 thread->suspend.stop_pc = get_frame_pc (get_current_frame ()); 4390 set_current_sal_from_frame (get_current_frame ()); 4391 4392 thread->suspend.waitstatus_pending_p = 0; 4393 4394 if (ws->kind == TARGET_WAITKIND_STOPPED) 4395 { 4396 enum gdb_signal sig = ws->value.sig; 4397 4398 if (signal_print_state (sig)) 4399 gdb::observers::signal_received.notify (sig); 4400 } 4401 gdb::observers::normal_stop.notify (NULL, 1); 4402} 4403 4404/* Process all initial stop replies the remote side sent in response 4405 to the ? packet. These indicate threads that were already stopped 4406 on initial connection. We mark these threads as stopped and print 4407 their current frame before giving the user the prompt. */ 4408 4409void 4410remote_target::process_initial_stop_replies (int from_tty) 4411{ 4412 int pending_stop_replies = stop_reply_queue_length (); 4413 struct thread_info *selected = NULL; 4414 struct thread_info *lowest_stopped = NULL; 4415 struct thread_info *first = NULL; 4416 4417 /* Consume the initial pending events. */ 4418 while (pending_stop_replies-- > 0) 4419 { 4420 ptid_t waiton_ptid = minus_one_ptid; 4421 ptid_t event_ptid; 4422 struct target_waitstatus ws; 4423 int ignore_event = 0; 4424 4425 memset (&ws, 0, sizeof (ws)); 4426 event_ptid = target_wait (waiton_ptid, &ws, TARGET_WNOHANG); 4427 if (remote_debug) 4428 print_target_wait_results (waiton_ptid, event_ptid, &ws); 4429 4430 switch (ws.kind) 4431 { 4432 case TARGET_WAITKIND_IGNORE: 4433 case TARGET_WAITKIND_NO_RESUMED: 4434 case TARGET_WAITKIND_SIGNALLED: 4435 case TARGET_WAITKIND_EXITED: 4436 /* We shouldn't see these, but if we do, just ignore. */ 4437 if (remote_debug) 4438 fprintf_unfiltered (gdb_stdlog, "remote: event ignored\n"); 4439 ignore_event = 1; 4440 break; 4441 4442 case TARGET_WAITKIND_EXECD: 4443 xfree (ws.value.execd_pathname); 4444 break; 4445 default: 4446 break; 4447 } 4448 4449 if (ignore_event) 4450 continue; 4451 4452 thread_info *evthread = find_thread_ptid (this, event_ptid); 4453 4454 if (ws.kind == TARGET_WAITKIND_STOPPED) 4455 { 4456 enum gdb_signal sig = ws.value.sig; 4457 4458 /* Stubs traditionally report SIGTRAP as initial signal, 4459 instead of signal 0. Suppress it. */ 4460 if (sig == GDB_SIGNAL_TRAP) 4461 sig = GDB_SIGNAL_0; 4462 evthread->suspend.stop_signal = sig; 4463 ws.value.sig = sig; 4464 } 4465 4466 evthread->suspend.waitstatus = ws; 4467 4468 if (ws.kind != TARGET_WAITKIND_STOPPED 4469 || ws.value.sig != GDB_SIGNAL_0) 4470 evthread->suspend.waitstatus_pending_p = 1; 4471 4472 set_executing (this, event_ptid, false); 4473 set_running (this, event_ptid, false); 4474 get_remote_thread_info (evthread)->vcont_resumed = 0; 4475 } 4476 4477 /* "Notice" the new inferiors before anything related to 4478 registers/memory. */ 4479 for (inferior *inf : all_non_exited_inferiors (this)) 4480 { 4481 inf->needs_setup = 1; 4482 4483 if (non_stop) 4484 { 4485 thread_info *thread = any_live_thread_of_inferior (inf); 4486 notice_new_inferior (thread, thread->state == THREAD_RUNNING, 4487 from_tty); 4488 } 4489 } 4490 4491 /* If all-stop on top of non-stop, pause all threads. Note this 4492 records the threads' stop pc, so must be done after "noticing" 4493 the inferiors. */ 4494 if (!non_stop) 4495 { 4496 stop_all_threads (); 4497 4498 /* If all threads of an inferior were already stopped, we 4499 haven't setup the inferior yet. */ 4500 for (inferior *inf : all_non_exited_inferiors (this)) 4501 { 4502 if (inf->needs_setup) 4503 { 4504 thread_info *thread = any_live_thread_of_inferior (inf); 4505 switch_to_thread_no_regs (thread); 4506 setup_inferior (0); 4507 } 4508 } 4509 } 4510 4511 /* Now go over all threads that are stopped, and print their current 4512 frame. If all-stop, then if there's a signalled thread, pick 4513 that as current. */ 4514 for (thread_info *thread : all_non_exited_threads (this)) 4515 { 4516 if (first == NULL) 4517 first = thread; 4518 4519 if (!non_stop) 4520 thread->set_running (false); 4521 else if (thread->state != THREAD_STOPPED) 4522 continue; 4523 4524 if (selected == NULL 4525 && thread->suspend.waitstatus_pending_p) 4526 selected = thread; 4527 4528 if (lowest_stopped == NULL 4529 || thread->inf->num < lowest_stopped->inf->num 4530 || thread->per_inf_num < lowest_stopped->per_inf_num) 4531 lowest_stopped = thread; 4532 4533 if (non_stop) 4534 print_one_stopped_thread (thread); 4535 } 4536 4537 /* In all-stop, we only print the status of one thread, and leave 4538 others with their status pending. */ 4539 if (!non_stop) 4540 { 4541 thread_info *thread = selected; 4542 if (thread == NULL) 4543 thread = lowest_stopped; 4544 if (thread == NULL) 4545 thread = first; 4546 4547 print_one_stopped_thread (thread); 4548 } 4549 4550 /* For "info program". */ 4551 thread_info *thread = inferior_thread (); 4552 if (thread->state == THREAD_STOPPED) 4553 set_last_target_status (this, inferior_ptid, thread->suspend.waitstatus); 4554} 4555 4556/* Start the remote connection and sync state. */ 4557 4558void 4559remote_target::start_remote (int from_tty, int extended_p) 4560{ 4561 struct remote_state *rs = get_remote_state (); 4562 struct packet_config *noack_config; 4563 char *wait_status = NULL; 4564 4565 /* Signal other parts that we're going through the initial setup, 4566 and so things may not be stable yet. E.g., we don't try to 4567 install tracepoints until we've relocated symbols. Also, a 4568 Ctrl-C before we're connected and synced up can't interrupt the 4569 target. Instead, it offers to drop the (potentially wedged) 4570 connection. */ 4571 rs->starting_up = 1; 4572 4573 QUIT; 4574 4575 if (interrupt_on_connect) 4576 send_interrupt_sequence (); 4577 4578 /* Ack any packet which the remote side has already sent. */ 4579 remote_serial_write ("+", 1); 4580 4581 /* The first packet we send to the target is the optional "supported 4582 packets" request. If the target can answer this, it will tell us 4583 which later probes to skip. */ 4584 remote_query_supported (); 4585 4586 /* If the stub wants to get a QAllow, compose one and send it. */ 4587 if (packet_support (PACKET_QAllow) != PACKET_DISABLE) 4588 set_permissions (); 4589 4590 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any 4591 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB 4592 as a reply to known packet. For packet "vFile:setfs:" it is an 4593 invalid reply and GDB would return error in 4594 remote_hostio_set_filesystem, making remote files access impossible. 4595 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as 4596 other "vFile" packets get correctly detected even on gdbserver < 7.7. */ 4597 { 4598 const char v_mustreplyempty[] = "vMustReplyEmpty"; 4599 4600 putpkt (v_mustreplyempty); 4601 getpkt (&rs->buf, 0); 4602 if (strcmp (rs->buf.data (), "OK") == 0) 4603 remote_protocol_packets[PACKET_vFile_setfs].support = PACKET_DISABLE; 4604 else if (strcmp (rs->buf.data (), "") != 0) 4605 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty, 4606 rs->buf.data ()); 4607 } 4608 4609 /* Next, we possibly activate noack mode. 4610 4611 If the QStartNoAckMode packet configuration is set to AUTO, 4612 enable noack mode if the stub reported a wish for it with 4613 qSupported. 4614 4615 If set to TRUE, then enable noack mode even if the stub didn't 4616 report it in qSupported. If the stub doesn't reply OK, the 4617 session ends with an error. 4618 4619 If FALSE, then don't activate noack mode, regardless of what the 4620 stub claimed should be the default with qSupported. */ 4621 4622 noack_config = &remote_protocol_packets[PACKET_QStartNoAckMode]; 4623 if (packet_config_support (noack_config) != PACKET_DISABLE) 4624 { 4625 putpkt ("QStartNoAckMode"); 4626 getpkt (&rs->buf, 0); 4627 if (packet_ok (rs->buf, noack_config) == PACKET_OK) 4628 rs->noack_mode = 1; 4629 } 4630 4631 if (extended_p) 4632 { 4633 /* Tell the remote that we are using the extended protocol. */ 4634 putpkt ("!"); 4635 getpkt (&rs->buf, 0); 4636 } 4637 4638 /* Let the target know which signals it is allowed to pass down to 4639 the program. */ 4640 update_signals_program_target (); 4641 4642 /* Next, if the target can specify a description, read it. We do 4643 this before anything involving memory or registers. */ 4644 target_find_description (); 4645 4646 /* Next, now that we know something about the target, update the 4647 address spaces in the program spaces. */ 4648 update_address_spaces (); 4649 4650 /* On OSs where the list of libraries is global to all 4651 processes, we fetch them early. */ 4652 if (gdbarch_has_global_solist (target_gdbarch ())) 4653 solib_add (NULL, from_tty, auto_solib_add); 4654 4655 if (target_is_non_stop_p ()) 4656 { 4657 if (packet_support (PACKET_QNonStop) != PACKET_ENABLE) 4658 error (_("Non-stop mode requested, but remote " 4659 "does not support non-stop")); 4660 4661 putpkt ("QNonStop:1"); 4662 getpkt (&rs->buf, 0); 4663 4664 if (strcmp (rs->buf.data (), "OK") != 0) 4665 error (_("Remote refused setting non-stop mode with: %s"), 4666 rs->buf.data ()); 4667 4668 /* Find about threads and processes the stub is already 4669 controlling. We default to adding them in the running state. 4670 The '?' query below will then tell us about which threads are 4671 stopped. */ 4672 this->update_thread_list (); 4673 } 4674 else if (packet_support (PACKET_QNonStop) == PACKET_ENABLE) 4675 { 4676 /* Don't assume that the stub can operate in all-stop mode. 4677 Request it explicitly. */ 4678 putpkt ("QNonStop:0"); 4679 getpkt (&rs->buf, 0); 4680 4681 if (strcmp (rs->buf.data (), "OK") != 0) 4682 error (_("Remote refused setting all-stop mode with: %s"), 4683 rs->buf.data ()); 4684 } 4685 4686 /* Upload TSVs regardless of whether the target is running or not. The 4687 remote stub, such as GDBserver, may have some predefined or builtin 4688 TSVs, even if the target is not running. */ 4689 if (get_trace_status (current_trace_status ()) != -1) 4690 { 4691 struct uploaded_tsv *uploaded_tsvs = NULL; 4692 4693 upload_trace_state_variables (&uploaded_tsvs); 4694 merge_uploaded_trace_state_variables (&uploaded_tsvs); 4695 } 4696 4697 /* Check whether the target is running now. */ 4698 putpkt ("?"); 4699 getpkt (&rs->buf, 0); 4700 4701 if (!target_is_non_stop_p ()) 4702 { 4703 if (rs->buf[0] == 'W' || rs->buf[0] == 'X') 4704 { 4705 if (!extended_p) 4706 error (_("The target is not running (try extended-remote?)")); 4707 4708 /* We're connected, but not running. Drop out before we 4709 call start_remote. */ 4710 rs->starting_up = 0; 4711 return; 4712 } 4713 else 4714 { 4715 /* Save the reply for later. */ 4716 wait_status = (char *) alloca (strlen (rs->buf.data ()) + 1); 4717 strcpy (wait_status, rs->buf.data ()); 4718 } 4719 4720 /* Fetch thread list. */ 4721 target_update_thread_list (); 4722 4723 /* Let the stub know that we want it to return the thread. */ 4724 set_continue_thread (minus_one_ptid); 4725 4726 if (thread_count (this) == 0) 4727 { 4728 /* Target has no concept of threads at all. GDB treats 4729 non-threaded target as single-threaded; add a main 4730 thread. */ 4731 add_current_inferior_and_thread (wait_status); 4732 } 4733 else 4734 { 4735 /* We have thread information; select the thread the target 4736 says should be current. If we're reconnecting to a 4737 multi-threaded program, this will ideally be the thread 4738 that last reported an event before GDB disconnected. */ 4739 ptid_t curr_thread = get_current_thread (wait_status); 4740 if (curr_thread == null_ptid) 4741 { 4742 /* Odd... The target was able to list threads, but not 4743 tell us which thread was current (no "thread" 4744 register in T stop reply?). Just pick the first 4745 thread in the thread list then. */ 4746 4747 if (remote_debug) 4748 fprintf_unfiltered (gdb_stdlog, 4749 "warning: couldn't determine remote " 4750 "current thread; picking first in list.\n"); 4751 4752 for (thread_info *tp : all_non_exited_threads (this, 4753 minus_one_ptid)) 4754 { 4755 switch_to_thread (tp); 4756 break; 4757 } 4758 } 4759 else 4760 switch_to_thread (find_thread_ptid (this, curr_thread)); 4761 } 4762 4763 /* init_wait_for_inferior should be called before get_offsets in order 4764 to manage `inserted' flag in bp loc in a correct state. 4765 breakpoint_init_inferior, called from init_wait_for_inferior, set 4766 `inserted' flag to 0, while before breakpoint_re_set, called from 4767 start_remote, set `inserted' flag to 1. In the initialization of 4768 inferior, breakpoint_init_inferior should be called first, and then 4769 breakpoint_re_set can be called. If this order is broken, state of 4770 `inserted' flag is wrong, and cause some problems on breakpoint 4771 manipulation. */ 4772 init_wait_for_inferior (); 4773 4774 get_offsets (); /* Get text, data & bss offsets. */ 4775 4776 /* If we could not find a description using qXfer, and we know 4777 how to do it some other way, try again. This is not 4778 supported for non-stop; it could be, but it is tricky if 4779 there are no stopped threads when we connect. */ 4780 if (remote_read_description_p (this) 4781 && gdbarch_target_desc (target_gdbarch ()) == NULL) 4782 { 4783 target_clear_description (); 4784 target_find_description (); 4785 } 4786 4787 /* Use the previously fetched status. */ 4788 gdb_assert (wait_status != NULL); 4789 strcpy (rs->buf.data (), wait_status); 4790 rs->cached_wait_status = 1; 4791 4792 ::start_remote (from_tty); /* Initialize gdb process mechanisms. */ 4793 } 4794 else 4795 { 4796 /* Clear WFI global state. Do this before finding about new 4797 threads and inferiors, and setting the current inferior. 4798 Otherwise we would clear the proceed status of the current 4799 inferior when we want its stop_soon state to be preserved 4800 (see notice_new_inferior). */ 4801 init_wait_for_inferior (); 4802 4803 /* In non-stop, we will either get an "OK", meaning that there 4804 are no stopped threads at this time; or, a regular stop 4805 reply. In the latter case, there may be more than one thread 4806 stopped --- we pull them all out using the vStopped 4807 mechanism. */ 4808 if (strcmp (rs->buf.data (), "OK") != 0) 4809 { 4810 struct notif_client *notif = ¬if_client_stop; 4811 4812 /* remote_notif_get_pending_replies acks this one, and gets 4813 the rest out. */ 4814 rs->notif_state->pending_event[notif_client_stop.id] 4815 = remote_notif_parse (this, notif, rs->buf.data ()); 4816 remote_notif_get_pending_events (notif); 4817 } 4818 4819 if (thread_count (this) == 0) 4820 { 4821 if (!extended_p) 4822 error (_("The target is not running (try extended-remote?)")); 4823 4824 /* We're connected, but not running. Drop out before we 4825 call start_remote. */ 4826 rs->starting_up = 0; 4827 return; 4828 } 4829 4830 /* In non-stop mode, any cached wait status will be stored in 4831 the stop reply queue. */ 4832 gdb_assert (wait_status == NULL); 4833 4834 /* Report all signals during attach/startup. */ 4835 pass_signals ({}); 4836 4837 /* If there are already stopped threads, mark them stopped and 4838 report their stops before giving the prompt to the user. */ 4839 process_initial_stop_replies (from_tty); 4840 4841 if (target_can_async_p ()) 4842 target_async (1); 4843 } 4844 4845 /* If we connected to a live target, do some additional setup. */ 4846 if (target_has_execution) 4847 { 4848 if (symfile_objfile) /* No use without a symbol-file. */ 4849 remote_check_symbols (); 4850 } 4851 4852 /* Possibly the target has been engaged in a trace run started 4853 previously; find out where things are at. */ 4854 if (get_trace_status (current_trace_status ()) != -1) 4855 { 4856 struct uploaded_tp *uploaded_tps = NULL; 4857 4858 if (current_trace_status ()->running) 4859 printf_filtered (_("Trace is already running on the target.\n")); 4860 4861 upload_tracepoints (&uploaded_tps); 4862 4863 merge_uploaded_tracepoints (&uploaded_tps); 4864 } 4865 4866 /* Possibly the target has been engaged in a btrace record started 4867 previously; find out where things are at. */ 4868 remote_btrace_maybe_reopen (); 4869 4870 /* The thread and inferior lists are now synchronized with the 4871 target, our symbols have been relocated, and we're merged the 4872 target's tracepoints with ours. We're done with basic start 4873 up. */ 4874 rs->starting_up = 0; 4875 4876 /* Maybe breakpoints are global and need to be inserted now. */ 4877 if (breakpoints_should_be_inserted_now ()) 4878 insert_breakpoints (); 4879} 4880 4881const char * 4882remote_target::connection_string () 4883{ 4884 remote_state *rs = get_remote_state (); 4885 4886 if (rs->remote_desc->name != NULL) 4887 return rs->remote_desc->name; 4888 else 4889 return NULL; 4890} 4891 4892/* Open a connection to a remote debugger. 4893 NAME is the filename used for communication. */ 4894 4895void 4896remote_target::open (const char *name, int from_tty) 4897{ 4898 open_1 (name, from_tty, 0); 4899} 4900 4901/* Open a connection to a remote debugger using the extended 4902 remote gdb protocol. NAME is the filename used for communication. */ 4903 4904void 4905extended_remote_target::open (const char *name, int from_tty) 4906{ 4907 open_1 (name, from_tty, 1 /*extended_p */); 4908} 4909 4910/* Reset all packets back to "unknown support". Called when opening a 4911 new connection to a remote target. */ 4912 4913static void 4914reset_all_packet_configs_support (void) 4915{ 4916 int i; 4917 4918 for (i = 0; i < PACKET_MAX; i++) 4919 remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN; 4920} 4921 4922/* Initialize all packet configs. */ 4923 4924static void 4925init_all_packet_configs (void) 4926{ 4927 int i; 4928 4929 for (i = 0; i < PACKET_MAX; i++) 4930 { 4931 remote_protocol_packets[i].detect = AUTO_BOOLEAN_AUTO; 4932 remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN; 4933 } 4934} 4935 4936/* Symbol look-up. */ 4937 4938void 4939remote_target::remote_check_symbols () 4940{ 4941 char *tmp; 4942 int end; 4943 4944 /* The remote side has no concept of inferiors that aren't running 4945 yet, it only knows about running processes. If we're connected 4946 but our current inferior is not running, we should not invite the 4947 remote target to request symbol lookups related to its 4948 (unrelated) current process. */ 4949 if (!target_has_execution) 4950 return; 4951 4952 if (packet_support (PACKET_qSymbol) == PACKET_DISABLE) 4953 return; 4954 4955 /* Make sure the remote is pointing at the right process. Note 4956 there's no way to select "no process". */ 4957 set_general_process (); 4958 4959 /* Allocate a message buffer. We can't reuse the input buffer in RS, 4960 because we need both at the same time. */ 4961 gdb::char_vector msg (get_remote_packet_size ()); 4962 gdb::char_vector reply (get_remote_packet_size ()); 4963 4964 /* Invite target to request symbol lookups. */ 4965 4966 putpkt ("qSymbol::"); 4967 getpkt (&reply, 0); 4968 packet_ok (reply, &remote_protocol_packets[PACKET_qSymbol]); 4969 4970 while (startswith (reply.data (), "qSymbol:")) 4971 { 4972 struct bound_minimal_symbol sym; 4973 4974 tmp = &reply[8]; 4975 end = hex2bin (tmp, reinterpret_cast <gdb_byte *> (msg.data ()), 4976 strlen (tmp) / 2); 4977 msg[end] = '\0'; 4978 sym = lookup_minimal_symbol (msg.data (), NULL, NULL); 4979 if (sym.minsym == NULL) 4980 xsnprintf (msg.data (), get_remote_packet_size (), "qSymbol::%s", 4981 &reply[8]); 4982 else 4983 { 4984 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; 4985 CORE_ADDR sym_addr = BMSYMBOL_VALUE_ADDRESS (sym); 4986 4987 /* If this is a function address, return the start of code 4988 instead of any data function descriptor. */ 4989 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (), 4990 sym_addr, 4991 current_top_target ()); 4992 4993 xsnprintf (msg.data (), get_remote_packet_size (), "qSymbol:%s:%s", 4994 phex_nz (sym_addr, addr_size), &reply[8]); 4995 } 4996 4997 putpkt (msg.data ()); 4998 getpkt (&reply, 0); 4999 } 5000} 5001 5002static struct serial * 5003remote_serial_open (const char *name) 5004{ 5005 static int udp_warning = 0; 5006 5007 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead 5008 of in ser-tcp.c, because it is the remote protocol assuming that the 5009 serial connection is reliable and not the serial connection promising 5010 to be. */ 5011 if (!udp_warning && startswith (name, "udp:")) 5012 { 5013 warning (_("The remote protocol may be unreliable over UDP.\n" 5014 "Some events may be lost, rendering further debugging " 5015 "impossible.")); 5016 udp_warning = 1; 5017 } 5018 5019 return serial_open (name); 5020} 5021 5022/* Inform the target of our permission settings. The permission flags 5023 work without this, but if the target knows the settings, it can do 5024 a couple things. First, it can add its own check, to catch cases 5025 that somehow manage to get by the permissions checks in target 5026 methods. Second, if the target is wired to disallow particular 5027 settings (for instance, a system in the field that is not set up to 5028 be able to stop at a breakpoint), it can object to any unavailable 5029 permissions. */ 5030 5031void 5032remote_target::set_permissions () 5033{ 5034 struct remote_state *rs = get_remote_state (); 5035 5036 xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAllow:" 5037 "WriteReg:%x;WriteMem:%x;" 5038 "InsertBreak:%x;InsertTrace:%x;" 5039 "InsertFastTrace:%x;Stop:%x", 5040 may_write_registers, may_write_memory, 5041 may_insert_breakpoints, may_insert_tracepoints, 5042 may_insert_fast_tracepoints, may_stop); 5043 putpkt (rs->buf); 5044 getpkt (&rs->buf, 0); 5045 5046 /* If the target didn't like the packet, warn the user. Do not try 5047 to undo the user's settings, that would just be maddening. */ 5048 if (strcmp (rs->buf.data (), "OK") != 0) 5049 warning (_("Remote refused setting permissions with: %s"), 5050 rs->buf.data ()); 5051} 5052 5053/* This type describes each known response to the qSupported 5054 packet. */ 5055struct protocol_feature 5056{ 5057 /* The name of this protocol feature. */ 5058 const char *name; 5059 5060 /* The default for this protocol feature. */ 5061 enum packet_support default_support; 5062 5063 /* The function to call when this feature is reported, or after 5064 qSupported processing if the feature is not supported. 5065 The first argument points to this structure. The second 5066 argument indicates whether the packet requested support be 5067 enabled, disabled, or probed (or the default, if this function 5068 is being called at the end of processing and this feature was 5069 not reported). The third argument may be NULL; if not NULL, it 5070 is a NUL-terminated string taken from the packet following 5071 this feature's name and an equals sign. */ 5072 void (*func) (remote_target *remote, const struct protocol_feature *, 5073 enum packet_support, const char *); 5074 5075 /* The corresponding packet for this feature. Only used if 5076 FUNC is remote_supported_packet. */ 5077 int packet; 5078}; 5079 5080static void 5081remote_supported_packet (remote_target *remote, 5082 const struct protocol_feature *feature, 5083 enum packet_support support, 5084 const char *argument) 5085{ 5086 if (argument) 5087 { 5088 warning (_("Remote qSupported response supplied an unexpected value for" 5089 " \"%s\"."), feature->name); 5090 return; 5091 } 5092 5093 remote_protocol_packets[feature->packet].support = support; 5094} 5095 5096void 5097remote_target::remote_packet_size (const protocol_feature *feature, 5098 enum packet_support support, const char *value) 5099{ 5100 struct remote_state *rs = get_remote_state (); 5101 5102 int packet_size; 5103 char *value_end; 5104 5105 if (support != PACKET_ENABLE) 5106 return; 5107 5108 if (value == NULL || *value == '\0') 5109 { 5110 warning (_("Remote target reported \"%s\" without a size."), 5111 feature->name); 5112 return; 5113 } 5114 5115 errno = 0; 5116 packet_size = strtol (value, &value_end, 16); 5117 if (errno != 0 || *value_end != '\0' || packet_size < 0) 5118 { 5119 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."), 5120 feature->name, value); 5121 return; 5122 } 5123 5124 /* Record the new maximum packet size. */ 5125 rs->explicit_packet_size = packet_size; 5126} 5127 5128static void 5129remote_packet_size (remote_target *remote, const protocol_feature *feature, 5130 enum packet_support support, const char *value) 5131{ 5132 remote->remote_packet_size (feature, support, value); 5133} 5134 5135static const struct protocol_feature remote_protocol_features[] = { 5136 { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 }, 5137 { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet, 5138 PACKET_qXfer_auxv }, 5139 { "qXfer:exec-file:read", PACKET_DISABLE, remote_supported_packet, 5140 PACKET_qXfer_exec_file }, 5141 { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet, 5142 PACKET_qXfer_features }, 5143 { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet, 5144 PACKET_qXfer_libraries }, 5145 { "qXfer:libraries-svr4:read", PACKET_DISABLE, remote_supported_packet, 5146 PACKET_qXfer_libraries_svr4 }, 5147 { "augmented-libraries-svr4-read", PACKET_DISABLE, 5148 remote_supported_packet, PACKET_augmented_libraries_svr4_read_feature }, 5149 { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet, 5150 PACKET_qXfer_memory_map }, 5151 { "qXfer:osdata:read", PACKET_DISABLE, remote_supported_packet, 5152 PACKET_qXfer_osdata }, 5153 { "qXfer:threads:read", PACKET_DISABLE, remote_supported_packet, 5154 PACKET_qXfer_threads }, 5155 { "qXfer:traceframe-info:read", PACKET_DISABLE, remote_supported_packet, 5156 PACKET_qXfer_traceframe_info }, 5157 { "QPassSignals", PACKET_DISABLE, remote_supported_packet, 5158 PACKET_QPassSignals }, 5159 { "QCatchSyscalls", PACKET_DISABLE, remote_supported_packet, 5160 PACKET_QCatchSyscalls }, 5161 { "QProgramSignals", PACKET_DISABLE, remote_supported_packet, 5162 PACKET_QProgramSignals }, 5163 { "QSetWorkingDir", PACKET_DISABLE, remote_supported_packet, 5164 PACKET_QSetWorkingDir }, 5165 { "QStartupWithShell", PACKET_DISABLE, remote_supported_packet, 5166 PACKET_QStartupWithShell }, 5167 { "QEnvironmentHexEncoded", PACKET_DISABLE, remote_supported_packet, 5168 PACKET_QEnvironmentHexEncoded }, 5169 { "QEnvironmentReset", PACKET_DISABLE, remote_supported_packet, 5170 PACKET_QEnvironmentReset }, 5171 { "QEnvironmentUnset", PACKET_DISABLE, remote_supported_packet, 5172 PACKET_QEnvironmentUnset }, 5173 { "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet, 5174 PACKET_QStartNoAckMode }, 5175 { "multiprocess", PACKET_DISABLE, remote_supported_packet, 5176 PACKET_multiprocess_feature }, 5177 { "QNonStop", PACKET_DISABLE, remote_supported_packet, PACKET_QNonStop }, 5178 { "qXfer:siginfo:read", PACKET_DISABLE, remote_supported_packet, 5179 PACKET_qXfer_siginfo_read }, 5180 { "qXfer:siginfo:write", PACKET_DISABLE, remote_supported_packet, 5181 PACKET_qXfer_siginfo_write }, 5182 { "ConditionalTracepoints", PACKET_DISABLE, remote_supported_packet, 5183 PACKET_ConditionalTracepoints }, 5184 { "ConditionalBreakpoints", PACKET_DISABLE, remote_supported_packet, 5185 PACKET_ConditionalBreakpoints }, 5186 { "BreakpointCommands", PACKET_DISABLE, remote_supported_packet, 5187 PACKET_BreakpointCommands }, 5188 { "FastTracepoints", PACKET_DISABLE, remote_supported_packet, 5189 PACKET_FastTracepoints }, 5190 { "StaticTracepoints", PACKET_DISABLE, remote_supported_packet, 5191 PACKET_StaticTracepoints }, 5192 {"InstallInTrace", PACKET_DISABLE, remote_supported_packet, 5193 PACKET_InstallInTrace}, 5194 { "DisconnectedTracing", PACKET_DISABLE, remote_supported_packet, 5195 PACKET_DisconnectedTracing_feature }, 5196 { "ReverseContinue", PACKET_DISABLE, remote_supported_packet, 5197 PACKET_bc }, 5198 { "ReverseStep", PACKET_DISABLE, remote_supported_packet, 5199 PACKET_bs }, 5200 { "TracepointSource", PACKET_DISABLE, remote_supported_packet, 5201 PACKET_TracepointSource }, 5202 { "QAllow", PACKET_DISABLE, remote_supported_packet, 5203 PACKET_QAllow }, 5204 { "EnableDisableTracepoints", PACKET_DISABLE, remote_supported_packet, 5205 PACKET_EnableDisableTracepoints_feature }, 5206 { "qXfer:fdpic:read", PACKET_DISABLE, remote_supported_packet, 5207 PACKET_qXfer_fdpic }, 5208 { "qXfer:uib:read", PACKET_DISABLE, remote_supported_packet, 5209 PACKET_qXfer_uib }, 5210 { "QDisableRandomization", PACKET_DISABLE, remote_supported_packet, 5211 PACKET_QDisableRandomization }, 5212 { "QAgent", PACKET_DISABLE, remote_supported_packet, PACKET_QAgent}, 5213 { "QTBuffer:size", PACKET_DISABLE, 5214 remote_supported_packet, PACKET_QTBuffer_size}, 5215 { "tracenz", PACKET_DISABLE, remote_supported_packet, PACKET_tracenz_feature }, 5216 { "Qbtrace:off", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_off }, 5217 { "Qbtrace:bts", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_bts }, 5218 { "Qbtrace:pt", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_pt }, 5219 { "qXfer:btrace:read", PACKET_DISABLE, remote_supported_packet, 5220 PACKET_qXfer_btrace }, 5221 { "qXfer:btrace-conf:read", PACKET_DISABLE, remote_supported_packet, 5222 PACKET_qXfer_btrace_conf }, 5223 { "Qbtrace-conf:bts:size", PACKET_DISABLE, remote_supported_packet, 5224 PACKET_Qbtrace_conf_bts_size }, 5225 { "swbreak", PACKET_DISABLE, remote_supported_packet, PACKET_swbreak_feature }, 5226 { "hwbreak", PACKET_DISABLE, remote_supported_packet, PACKET_hwbreak_feature }, 5227 { "fork-events", PACKET_DISABLE, remote_supported_packet, 5228 PACKET_fork_event_feature }, 5229 { "vfork-events", PACKET_DISABLE, remote_supported_packet, 5230 PACKET_vfork_event_feature }, 5231 { "exec-events", PACKET_DISABLE, remote_supported_packet, 5232 PACKET_exec_event_feature }, 5233 { "Qbtrace-conf:pt:size", PACKET_DISABLE, remote_supported_packet, 5234 PACKET_Qbtrace_conf_pt_size }, 5235 { "vContSupported", PACKET_DISABLE, remote_supported_packet, PACKET_vContSupported }, 5236 { "QThreadEvents", PACKET_DISABLE, remote_supported_packet, PACKET_QThreadEvents }, 5237 { "no-resumed", PACKET_DISABLE, remote_supported_packet, PACKET_no_resumed }, 5238}; 5239 5240static char *remote_support_xml; 5241 5242/* Register string appended to "xmlRegisters=" in qSupported query. */ 5243 5244void 5245register_remote_support_xml (const char *xml) 5246{ 5247#if defined(HAVE_LIBEXPAT) 5248 if (remote_support_xml == NULL) 5249 remote_support_xml = concat ("xmlRegisters=", xml, (char *) NULL); 5250 else 5251 { 5252 char *copy = xstrdup (remote_support_xml + 13); 5253 char *saveptr; 5254 char *p = strtok_r (copy, ",", &saveptr); 5255 5256 do 5257 { 5258 if (strcmp (p, xml) == 0) 5259 { 5260 /* already there */ 5261 xfree (copy); 5262 return; 5263 } 5264 } 5265 while ((p = strtok_r (NULL, ",", &saveptr)) != NULL); 5266 xfree (copy); 5267 5268 remote_support_xml = reconcat (remote_support_xml, 5269 remote_support_xml, ",", xml, 5270 (char *) NULL); 5271 } 5272#endif 5273} 5274 5275static void 5276remote_query_supported_append (std::string *msg, const char *append) 5277{ 5278 if (!msg->empty ()) 5279 msg->append (";"); 5280 msg->append (append); 5281} 5282 5283void 5284remote_target::remote_query_supported () 5285{ 5286 struct remote_state *rs = get_remote_state (); 5287 char *next; 5288 int i; 5289 unsigned char seen [ARRAY_SIZE (remote_protocol_features)]; 5290 5291 /* The packet support flags are handled differently for this packet 5292 than for most others. We treat an error, a disabled packet, and 5293 an empty response identically: any features which must be reported 5294 to be used will be automatically disabled. An empty buffer 5295 accomplishes this, since that is also the representation for a list 5296 containing no features. */ 5297 5298 rs->buf[0] = 0; 5299 if (packet_support (PACKET_qSupported) != PACKET_DISABLE) 5300 { 5301 std::string q; 5302 5303 if (packet_set_cmd_state (PACKET_multiprocess_feature) != AUTO_BOOLEAN_FALSE) 5304 remote_query_supported_append (&q, "multiprocess+"); 5305 5306 if (packet_set_cmd_state (PACKET_swbreak_feature) != AUTO_BOOLEAN_FALSE) 5307 remote_query_supported_append (&q, "swbreak+"); 5308 if (packet_set_cmd_state (PACKET_hwbreak_feature) != AUTO_BOOLEAN_FALSE) 5309 remote_query_supported_append (&q, "hwbreak+"); 5310 5311 remote_query_supported_append (&q, "qRelocInsn+"); 5312 5313 if (packet_set_cmd_state (PACKET_fork_event_feature) 5314 != AUTO_BOOLEAN_FALSE) 5315 remote_query_supported_append (&q, "fork-events+"); 5316 if (packet_set_cmd_state (PACKET_vfork_event_feature) 5317 != AUTO_BOOLEAN_FALSE) 5318 remote_query_supported_append (&q, "vfork-events+"); 5319 if (packet_set_cmd_state (PACKET_exec_event_feature) 5320 != AUTO_BOOLEAN_FALSE) 5321 remote_query_supported_append (&q, "exec-events+"); 5322 5323 if (packet_set_cmd_state (PACKET_vContSupported) != AUTO_BOOLEAN_FALSE) 5324 remote_query_supported_append (&q, "vContSupported+"); 5325 5326 if (packet_set_cmd_state (PACKET_QThreadEvents) != AUTO_BOOLEAN_FALSE) 5327 remote_query_supported_append (&q, "QThreadEvents+"); 5328 5329 if (packet_set_cmd_state (PACKET_no_resumed) != AUTO_BOOLEAN_FALSE) 5330 remote_query_supported_append (&q, "no-resumed+"); 5331 5332 /* Keep this one last to work around a gdbserver <= 7.10 bug in 5333 the qSupported:xmlRegisters=i386 handling. */ 5334 if (remote_support_xml != NULL 5335 && packet_support (PACKET_qXfer_features) != PACKET_DISABLE) 5336 remote_query_supported_append (&q, remote_support_xml); 5337 5338 q = "qSupported:" + q; 5339 putpkt (q.c_str ()); 5340 5341 getpkt (&rs->buf, 0); 5342 5343 /* If an error occured, warn, but do not return - just reset the 5344 buffer to empty and go on to disable features. */ 5345 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported]) 5346 == PACKET_ERROR) 5347 { 5348 warning (_("Remote failure reply: %s"), rs->buf.data ()); 5349 rs->buf[0] = 0; 5350 } 5351 } 5352 5353 memset (seen, 0, sizeof (seen)); 5354 5355 next = rs->buf.data (); 5356 while (*next) 5357 { 5358 enum packet_support is_supported; 5359 char *p, *end, *name_end, *value; 5360 5361 /* First separate out this item from the rest of the packet. If 5362 there's another item after this, we overwrite the separator 5363 (terminated strings are much easier to work with). */ 5364 p = next; 5365 end = strchr (p, ';'); 5366 if (end == NULL) 5367 { 5368 end = p + strlen (p); 5369 next = end; 5370 } 5371 else 5372 { 5373 *end = '\0'; 5374 next = end + 1; 5375 5376 if (end == p) 5377 { 5378 warning (_("empty item in \"qSupported\" response")); 5379 continue; 5380 } 5381 } 5382 5383 name_end = strchr (p, '='); 5384 if (name_end) 5385 { 5386 /* This is a name=value entry. */ 5387 is_supported = PACKET_ENABLE; 5388 value = name_end + 1; 5389 *name_end = '\0'; 5390 } 5391 else 5392 { 5393 value = NULL; 5394 switch (end[-1]) 5395 { 5396 case '+': 5397 is_supported = PACKET_ENABLE; 5398 break; 5399 5400 case '-': 5401 is_supported = PACKET_DISABLE; 5402 break; 5403 5404 case '?': 5405 is_supported = PACKET_SUPPORT_UNKNOWN; 5406 break; 5407 5408 default: 5409 warning (_("unrecognized item \"%s\" " 5410 "in \"qSupported\" response"), p); 5411 continue; 5412 } 5413 end[-1] = '\0'; 5414 } 5415 5416 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++) 5417 if (strcmp (remote_protocol_features[i].name, p) == 0) 5418 { 5419 const struct protocol_feature *feature; 5420 5421 seen[i] = 1; 5422 feature = &remote_protocol_features[i]; 5423 feature->func (this, feature, is_supported, value); 5424 break; 5425 } 5426 } 5427 5428 /* If we increased the packet size, make sure to increase the global 5429 buffer size also. We delay this until after parsing the entire 5430 qSupported packet, because this is the same buffer we were 5431 parsing. */ 5432 if (rs->buf.size () < rs->explicit_packet_size) 5433 rs->buf.resize (rs->explicit_packet_size); 5434 5435 /* Handle the defaults for unmentioned features. */ 5436 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++) 5437 if (!seen[i]) 5438 { 5439 const struct protocol_feature *feature; 5440 5441 feature = &remote_protocol_features[i]; 5442 feature->func (this, feature, feature->default_support, NULL); 5443 } 5444} 5445 5446/* Serial QUIT handler for the remote serial descriptor. 5447 5448 Defers handling a Ctrl-C until we're done with the current 5449 command/response packet sequence, unless: 5450 5451 - We're setting up the connection. Don't send a remote interrupt 5452 request, as we're not fully synced yet. Quit immediately 5453 instead. 5454 5455 - The target has been resumed in the foreground 5456 (target_terminal::is_ours is false) with a synchronous resume 5457 packet, and we're blocked waiting for the stop reply, thus a 5458 Ctrl-C should be immediately sent to the target. 5459 5460 - We get a second Ctrl-C while still within the same serial read or 5461 write. In that case the serial is seemingly wedged --- offer to 5462 quit/disconnect. 5463 5464 - We see a second Ctrl-C without target response, after having 5465 previously interrupted the target. In that case the target/stub 5466 is probably wedged --- offer to quit/disconnect. 5467*/ 5468 5469void 5470remote_target::remote_serial_quit_handler () 5471{ 5472 struct remote_state *rs = get_remote_state (); 5473 5474 if (check_quit_flag ()) 5475 { 5476 /* If we're starting up, we're not fully synced yet. Quit 5477 immediately. */ 5478 if (rs->starting_up) 5479 quit (); 5480 else if (rs->got_ctrlc_during_io) 5481 { 5482 if (query (_("The target is not responding to GDB commands.\n" 5483 "Stop debugging it? "))) 5484 remote_unpush_and_throw (this); 5485 } 5486 /* If ^C has already been sent once, offer to disconnect. */ 5487 else if (!target_terminal::is_ours () && rs->ctrlc_pending_p) 5488 interrupt_query (); 5489 /* All-stop protocol, and blocked waiting for stop reply. Send 5490 an interrupt request. */ 5491 else if (!target_terminal::is_ours () && rs->waiting_for_stop_reply) 5492 target_interrupt (); 5493 else 5494 rs->got_ctrlc_during_io = 1; 5495 } 5496} 5497 5498/* The remote_target that is current while the quit handler is 5499 overridden with remote_serial_quit_handler. */ 5500static remote_target *curr_quit_handler_target; 5501 5502static void 5503remote_serial_quit_handler () 5504{ 5505 curr_quit_handler_target->remote_serial_quit_handler (); 5506} 5507 5508/* Remove the remote target from the target stack of each inferior 5509 that is using it. Upper targets depend on it so remove them 5510 first. */ 5511 5512static void 5513remote_unpush_target (remote_target *target) 5514{ 5515 /* We have to unpush the target from all inferiors, even those that 5516 aren't running. */ 5517 scoped_restore_current_inferior restore_current_inferior; 5518 5519 for (inferior *inf : all_inferiors (target)) 5520 { 5521 switch_to_inferior_no_thread (inf); 5522 pop_all_targets_at_and_above (process_stratum); 5523 generic_mourn_inferior (); 5524 } 5525} 5526 5527static void 5528remote_unpush_and_throw (remote_target *target) 5529{ 5530 remote_unpush_target (target); 5531 throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target.")); 5532} 5533 5534void 5535remote_target::open_1 (const char *name, int from_tty, int extended_p) 5536{ 5537 remote_target *curr_remote = get_current_remote_target (); 5538 5539 if (name == 0) 5540 error (_("To open a remote debug connection, you need to specify what\n" 5541 "serial device is attached to the remote system\n" 5542 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).")); 5543 5544 /* If we're connected to a running target, target_preopen will kill it. 5545 Ask this question first, before target_preopen has a chance to kill 5546 anything. */ 5547 if (curr_remote != NULL && !target_has_execution) 5548 { 5549 if (from_tty 5550 && !query (_("Already connected to a remote target. Disconnect? "))) 5551 error (_("Still connected.")); 5552 } 5553 5554 /* Here the possibly existing remote target gets unpushed. */ 5555 target_preopen (from_tty); 5556 5557 remote_fileio_reset (); 5558 reopen_exec_file (); 5559 reread_symbols (); 5560 5561 remote_target *remote 5562 = (extended_p ? new extended_remote_target () : new remote_target ()); 5563 target_ops_up target_holder (remote); 5564 5565 remote_state *rs = remote->get_remote_state (); 5566 5567 /* See FIXME above. */ 5568 if (!target_async_permitted) 5569 rs->wait_forever_enabled_p = 1; 5570 5571 rs->remote_desc = remote_serial_open (name); 5572 if (!rs->remote_desc) 5573 perror_with_name (name); 5574 5575 if (baud_rate != -1) 5576 { 5577 if (serial_setbaudrate (rs->remote_desc, baud_rate)) 5578 { 5579 /* The requested speed could not be set. Error out to 5580 top level after closing remote_desc. Take care to 5581 set remote_desc to NULL to avoid closing remote_desc 5582 more than once. */ 5583 serial_close (rs->remote_desc); 5584 rs->remote_desc = NULL; 5585 perror_with_name (name); 5586 } 5587 } 5588 5589 serial_setparity (rs->remote_desc, serial_parity); 5590 serial_raw (rs->remote_desc); 5591 5592 /* If there is something sitting in the buffer we might take it as a 5593 response to a command, which would be bad. */ 5594 serial_flush_input (rs->remote_desc); 5595 5596 if (from_tty) 5597 { 5598 puts_filtered ("Remote debugging using "); 5599 puts_filtered (name); 5600 puts_filtered ("\n"); 5601 } 5602 5603 /* Switch to using the remote target now. */ 5604 push_target (std::move (target_holder)); 5605 5606 /* Register extra event sources in the event loop. */ 5607 rs->remote_async_inferior_event_token 5608 = create_async_event_handler (remote_async_inferior_event_handler, remote); 5609 rs->notif_state = remote_notif_state_allocate (remote); 5610 5611 /* Reset the target state; these things will be queried either by 5612 remote_query_supported or as they are needed. */ 5613 reset_all_packet_configs_support (); 5614 rs->cached_wait_status = 0; 5615 rs->explicit_packet_size = 0; 5616 rs->noack_mode = 0; 5617 rs->extended = extended_p; 5618 rs->waiting_for_stop_reply = 0; 5619 rs->ctrlc_pending_p = 0; 5620 rs->got_ctrlc_during_io = 0; 5621 5622 rs->general_thread = not_sent_ptid; 5623 rs->continue_thread = not_sent_ptid; 5624 rs->remote_traceframe_number = -1; 5625 5626 rs->last_resume_exec_dir = EXEC_FORWARD; 5627 5628 /* Probe for ability to use "ThreadInfo" query, as required. */ 5629 rs->use_threadinfo_query = 1; 5630 rs->use_threadextra_query = 1; 5631 5632 rs->readahead_cache.invalidate (); 5633 5634 if (target_async_permitted) 5635 { 5636 /* FIXME: cagney/1999-09-23: During the initial connection it is 5637 assumed that the target is already ready and able to respond to 5638 requests. Unfortunately remote_start_remote() eventually calls 5639 wait_for_inferior() with no timeout. wait_forever_enabled_p gets 5640 around this. Eventually a mechanism that allows 5641 wait_for_inferior() to expect/get timeouts will be 5642 implemented. */ 5643 rs->wait_forever_enabled_p = 0; 5644 } 5645 5646 /* First delete any symbols previously loaded from shared libraries. */ 5647 no_shared_libraries (NULL, 0); 5648 5649 /* Start the remote connection. If error() or QUIT, discard this 5650 target (we'd otherwise be in an inconsistent state) and then 5651 propogate the error on up the exception chain. This ensures that 5652 the caller doesn't stumble along blindly assuming that the 5653 function succeeded. The CLI doesn't have this problem but other 5654 UI's, such as MI do. 5655 5656 FIXME: cagney/2002-05-19: Instead of re-throwing the exception, 5657 this function should return an error indication letting the 5658 caller restore the previous state. Unfortunately the command 5659 ``target remote'' is directly wired to this function making that 5660 impossible. On a positive note, the CLI side of this problem has 5661 been fixed - the function set_cmd_context() makes it possible for 5662 all the ``target ....'' commands to share a common callback 5663 function. See cli-dump.c. */ 5664 { 5665 5666 try 5667 { 5668 remote->start_remote (from_tty, extended_p); 5669 } 5670 catch (const gdb_exception &ex) 5671 { 5672 /* Pop the partially set up target - unless something else did 5673 already before throwing the exception. */ 5674 if (ex.error != TARGET_CLOSE_ERROR) 5675 remote_unpush_target (remote); 5676 throw; 5677 } 5678 } 5679 5680 remote_btrace_reset (rs); 5681 5682 if (target_async_permitted) 5683 rs->wait_forever_enabled_p = 1; 5684} 5685 5686/* Detach the specified process. */ 5687 5688void 5689remote_target::remote_detach_pid (int pid) 5690{ 5691 struct remote_state *rs = get_remote_state (); 5692 5693 /* This should not be necessary, but the handling for D;PID in 5694 GDBserver versions prior to 8.2 incorrectly assumes that the 5695 selected process points to the same process we're detaching, 5696 leading to misbehavior (and possibly GDBserver crashing) when it 5697 does not. Since it's easy and cheap, work around it by forcing 5698 GDBserver to select GDB's current process. */ 5699 set_general_process (); 5700 5701 if (remote_multi_process_p (rs)) 5702 xsnprintf (rs->buf.data (), get_remote_packet_size (), "D;%x", pid); 5703 else 5704 strcpy (rs->buf.data (), "D"); 5705 5706 putpkt (rs->buf); 5707 getpkt (&rs->buf, 0); 5708 5709 if (rs->buf[0] == 'O' && rs->buf[1] == 'K') 5710 ; 5711 else if (rs->buf[0] == '\0') 5712 error (_("Remote doesn't know how to detach")); 5713 else 5714 error (_("Can't detach process.")); 5715} 5716 5717/* This detaches a program to which we previously attached, using 5718 inferior_ptid to identify the process. After this is done, GDB 5719 can be used to debug some other program. We better not have left 5720 any breakpoints in the target program or it'll die when it hits 5721 one. */ 5722 5723void 5724remote_target::remote_detach_1 (inferior *inf, int from_tty) 5725{ 5726 int pid = inferior_ptid.pid (); 5727 struct remote_state *rs = get_remote_state (); 5728 int is_fork_parent; 5729 5730 if (!target_has_execution) 5731 error (_("No process to detach from.")); 5732 5733 target_announce_detach (from_tty); 5734 5735 /* Tell the remote target to detach. */ 5736 remote_detach_pid (pid); 5737 5738 /* Exit only if this is the only active inferior. */ 5739 if (from_tty && !rs->extended && number_of_live_inferiors (this) == 1) 5740 puts_filtered (_("Ending remote debugging.\n")); 5741 5742 thread_info *tp = find_thread_ptid (this, inferior_ptid); 5743 5744 /* Check to see if we are detaching a fork parent. Note that if we 5745 are detaching a fork child, tp == NULL. */ 5746 is_fork_parent = (tp != NULL 5747 && tp->pending_follow.kind == TARGET_WAITKIND_FORKED); 5748 5749 /* If doing detach-on-fork, we don't mourn, because that will delete 5750 breakpoints that should be available for the followed inferior. */ 5751 if (!is_fork_parent) 5752 { 5753 /* Save the pid as a string before mourning, since that will 5754 unpush the remote target, and we need the string after. */ 5755 std::string infpid = target_pid_to_str (ptid_t (pid)); 5756 5757 target_mourn_inferior (inferior_ptid); 5758 if (print_inferior_events) 5759 printf_unfiltered (_("[Inferior %d (%s) detached]\n"), 5760 inf->num, infpid.c_str ()); 5761 } 5762 else 5763 { 5764 switch_to_no_thread (); 5765 detach_inferior (current_inferior ()); 5766 } 5767} 5768 5769void 5770remote_target::detach (inferior *inf, int from_tty) 5771{ 5772 remote_detach_1 (inf, from_tty); 5773} 5774 5775void 5776extended_remote_target::detach (inferior *inf, int from_tty) 5777{ 5778 remote_detach_1 (inf, from_tty); 5779} 5780 5781/* Target follow-fork function for remote targets. On entry, and 5782 at return, the current inferior is the fork parent. 5783 5784 Note that although this is currently only used for extended-remote, 5785 it is named remote_follow_fork in anticipation of using it for the 5786 remote target as well. */ 5787 5788bool 5789remote_target::follow_fork (bool follow_child, bool detach_fork) 5790{ 5791 struct remote_state *rs = get_remote_state (); 5792 enum target_waitkind kind = inferior_thread ()->pending_follow.kind; 5793 5794 if ((kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs)) 5795 || (kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs))) 5796 { 5797 /* When following the parent and detaching the child, we detach 5798 the child here. For the case of following the child and 5799 detaching the parent, the detach is done in the target- 5800 independent follow fork code in infrun.c. We can't use 5801 target_detach when detaching an unfollowed child because 5802 the client side doesn't know anything about the child. */ 5803 if (detach_fork && !follow_child) 5804 { 5805 /* Detach the fork child. */ 5806 ptid_t child_ptid; 5807 pid_t child_pid; 5808 5809 child_ptid = inferior_thread ()->pending_follow.value.related_pid; 5810 child_pid = child_ptid.pid (); 5811 5812 remote_detach_pid (child_pid); 5813 } 5814 } 5815 5816 return false; 5817} 5818 5819/* Target follow-exec function for remote targets. Save EXECD_PATHNAME 5820 in the program space of the new inferior. On entry and at return the 5821 current inferior is the exec'ing inferior. INF is the new exec'd 5822 inferior, which may be the same as the exec'ing inferior unless 5823 follow-exec-mode is "new". */ 5824 5825void 5826remote_target::follow_exec (struct inferior *inf, const char *execd_pathname) 5827{ 5828 /* We know that this is a target file name, so if it has the "target:" 5829 prefix we strip it off before saving it in the program space. */ 5830 if (is_target_filename (execd_pathname)) 5831 execd_pathname += strlen (TARGET_SYSROOT_PREFIX); 5832 5833 set_pspace_remote_exec_file (inf->pspace, execd_pathname); 5834} 5835 5836/* Same as remote_detach, but don't send the "D" packet; just disconnect. */ 5837 5838void 5839remote_target::disconnect (const char *args, int from_tty) 5840{ 5841 if (args) 5842 error (_("Argument given to \"disconnect\" when remotely debugging.")); 5843 5844 /* Make sure we unpush even the extended remote targets. Calling 5845 target_mourn_inferior won't unpush, and 5846 remote_target::mourn_inferior won't unpush if there is more than 5847 one inferior left. */ 5848 remote_unpush_target (this); 5849 5850 if (from_tty) 5851 puts_filtered ("Ending remote debugging.\n"); 5852} 5853 5854/* Attach to the process specified by ARGS. If FROM_TTY is non-zero, 5855 be chatty about it. */ 5856 5857void 5858extended_remote_target::attach (const char *args, int from_tty) 5859{ 5860 struct remote_state *rs = get_remote_state (); 5861 int pid; 5862 char *wait_status = NULL; 5863 5864 pid = parse_pid_to_attach (args); 5865 5866 /* Remote PID can be freely equal to getpid, do not check it here the same 5867 way as in other targets. */ 5868 5869 if (packet_support (PACKET_vAttach) == PACKET_DISABLE) 5870 error (_("This target does not support attaching to a process")); 5871 5872 if (from_tty) 5873 { 5874 const char *exec_file = get_exec_file (0); 5875 5876 if (exec_file) 5877 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file, 5878 target_pid_to_str (ptid_t (pid)).c_str ()); 5879 else 5880 printf_unfiltered (_("Attaching to %s\n"), 5881 target_pid_to_str (ptid_t (pid)).c_str ()); 5882 } 5883 5884 xsnprintf (rs->buf.data (), get_remote_packet_size (), "vAttach;%x", pid); 5885 putpkt (rs->buf); 5886 getpkt (&rs->buf, 0); 5887 5888 switch (packet_ok (rs->buf, 5889 &remote_protocol_packets[PACKET_vAttach])) 5890 { 5891 case PACKET_OK: 5892 if (!target_is_non_stop_p ()) 5893 { 5894 /* Save the reply for later. */ 5895 wait_status = (char *) alloca (strlen (rs->buf.data ()) + 1); 5896 strcpy (wait_status, rs->buf.data ()); 5897 } 5898 else if (strcmp (rs->buf.data (), "OK") != 0) 5899 error (_("Attaching to %s failed with: %s"), 5900 target_pid_to_str (ptid_t (pid)).c_str (), 5901 rs->buf.data ()); 5902 break; 5903 case PACKET_UNKNOWN: 5904 error (_("This target does not support attaching to a process")); 5905 default: 5906 error (_("Attaching to %s failed"), 5907 target_pid_to_str (ptid_t (pid)).c_str ()); 5908 } 5909 5910 switch_to_inferior_no_thread (remote_add_inferior (false, pid, 1, 0)); 5911 5912 inferior_ptid = ptid_t (pid); 5913 5914 if (target_is_non_stop_p ()) 5915 { 5916 /* Get list of threads. */ 5917 update_thread_list (); 5918 5919 thread_info *thread = first_thread_of_inferior (current_inferior ()); 5920 if (thread != nullptr) 5921 switch_to_thread (thread); 5922 5923 /* Invalidate our notion of the remote current thread. */ 5924 record_currthread (rs, minus_one_ptid); 5925 } 5926 else 5927 { 5928 /* Now, if we have thread information, update the main thread's 5929 ptid. */ 5930 ptid_t curr_ptid = remote_current_thread (ptid_t (pid)); 5931 5932 /* Add the main thread to the thread list. */ 5933 thread_info *thr = add_thread_silent (this, curr_ptid); 5934 5935 switch_to_thread (thr); 5936 5937 /* Don't consider the thread stopped until we've processed the 5938 saved stop reply. */ 5939 set_executing (this, thr->ptid, true); 5940 } 5941 5942 /* Next, if the target can specify a description, read it. We do 5943 this before anything involving memory or registers. */ 5944 target_find_description (); 5945 5946 if (!target_is_non_stop_p ()) 5947 { 5948 /* Use the previously fetched status. */ 5949 gdb_assert (wait_status != NULL); 5950 5951 if (target_can_async_p ()) 5952 { 5953 struct notif_event *reply 5954 = remote_notif_parse (this, ¬if_client_stop, wait_status); 5955 5956 push_stop_reply ((struct stop_reply *) reply); 5957 5958 target_async (1); 5959 } 5960 else 5961 { 5962 gdb_assert (wait_status != NULL); 5963 strcpy (rs->buf.data (), wait_status); 5964 rs->cached_wait_status = 1; 5965 } 5966 } 5967 else 5968 gdb_assert (wait_status == NULL); 5969} 5970 5971/* Implementation of the to_post_attach method. */ 5972 5973void 5974extended_remote_target::post_attach (int pid) 5975{ 5976 /* Get text, data & bss offsets. */ 5977 get_offsets (); 5978 5979 /* In certain cases GDB might not have had the chance to start 5980 symbol lookup up until now. This could happen if the debugged 5981 binary is not using shared libraries, the vsyscall page is not 5982 present (on Linux) and the binary itself hadn't changed since the 5983 debugging process was started. */ 5984 if (symfile_objfile != NULL) 5985 remote_check_symbols(); 5986} 5987 5988 5989/* Check for the availability of vCont. This function should also check 5990 the response. */ 5991 5992void 5993remote_target::remote_vcont_probe () 5994{ 5995 remote_state *rs = get_remote_state (); 5996 char *buf; 5997 5998 strcpy (rs->buf.data (), "vCont?"); 5999 putpkt (rs->buf); 6000 getpkt (&rs->buf, 0); 6001 buf = rs->buf.data (); 6002 6003 /* Make sure that the features we assume are supported. */ 6004 if (startswith (buf, "vCont")) 6005 { 6006 char *p = &buf[5]; 6007 int support_c, support_C; 6008 6009 rs->supports_vCont.s = 0; 6010 rs->supports_vCont.S = 0; 6011 support_c = 0; 6012 support_C = 0; 6013 rs->supports_vCont.t = 0; 6014 rs->supports_vCont.r = 0; 6015 while (p && *p == ';') 6016 { 6017 p++; 6018 if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0)) 6019 rs->supports_vCont.s = 1; 6020 else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0)) 6021 rs->supports_vCont.S = 1; 6022 else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0)) 6023 support_c = 1; 6024 else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0)) 6025 support_C = 1; 6026 else if (*p == 't' && (*(p + 1) == ';' || *(p + 1) == 0)) 6027 rs->supports_vCont.t = 1; 6028 else if (*p == 'r' && (*(p + 1) == ';' || *(p + 1) == 0)) 6029 rs->supports_vCont.r = 1; 6030 6031 p = strchr (p, ';'); 6032 } 6033 6034 /* If c, and C are not all supported, we can't use vCont. Clearing 6035 BUF will make packet_ok disable the packet. */ 6036 if (!support_c || !support_C) 6037 buf[0] = 0; 6038 } 6039 6040 packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCont]); 6041 rs->supports_vCont_probed = true; 6042} 6043 6044/* Helper function for building "vCont" resumptions. Write a 6045 resumption to P. ENDP points to one-passed-the-end of the buffer 6046 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The 6047 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the 6048 resumed thread should be single-stepped and/or signalled. If PTID 6049 equals minus_one_ptid, then all threads are resumed; if PTID 6050 represents a process, then all threads of the process are resumed; 6051 the thread to be stepped and/or signalled is given in the global 6052 INFERIOR_PTID. */ 6053 6054char * 6055remote_target::append_resumption (char *p, char *endp, 6056 ptid_t ptid, int step, gdb_signal siggnal) 6057{ 6058 struct remote_state *rs = get_remote_state (); 6059 6060 if (step && siggnal != GDB_SIGNAL_0) 6061 p += xsnprintf (p, endp - p, ";S%02x", siggnal); 6062 else if (step 6063 /* GDB is willing to range step. */ 6064 && use_range_stepping 6065 /* Target supports range stepping. */ 6066 && rs->supports_vCont.r 6067 /* We don't currently support range stepping multiple 6068 threads with a wildcard (though the protocol allows it, 6069 so stubs shouldn't make an active effort to forbid 6070 it). */ 6071 && !(remote_multi_process_p (rs) && ptid.is_pid ())) 6072 { 6073 struct thread_info *tp; 6074 6075 if (ptid == minus_one_ptid) 6076 { 6077 /* If we don't know about the target thread's tid, then 6078 we're resuming magic_null_ptid (see caller). */ 6079 tp = find_thread_ptid (this, magic_null_ptid); 6080 } 6081 else 6082 tp = find_thread_ptid (this, ptid); 6083 gdb_assert (tp != NULL); 6084 6085 if (tp->control.may_range_step) 6086 { 6087 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; 6088 6089 p += xsnprintf (p, endp - p, ";r%s,%s", 6090 phex_nz (tp->control.step_range_start, 6091 addr_size), 6092 phex_nz (tp->control.step_range_end, 6093 addr_size)); 6094 } 6095 else 6096 p += xsnprintf (p, endp - p, ";s"); 6097 } 6098 else if (step) 6099 p += xsnprintf (p, endp - p, ";s"); 6100 else if (siggnal != GDB_SIGNAL_0) 6101 p += xsnprintf (p, endp - p, ";C%02x", siggnal); 6102 else 6103 p += xsnprintf (p, endp - p, ";c"); 6104 6105 if (remote_multi_process_p (rs) && ptid.is_pid ()) 6106 { 6107 ptid_t nptid; 6108 6109 /* All (-1) threads of process. */ 6110 nptid = ptid_t (ptid.pid (), -1, 0); 6111 6112 p += xsnprintf (p, endp - p, ":"); 6113 p = write_ptid (p, endp, nptid); 6114 } 6115 else if (ptid != minus_one_ptid) 6116 { 6117 p += xsnprintf (p, endp - p, ":"); 6118 p = write_ptid (p, endp, ptid); 6119 } 6120 6121 return p; 6122} 6123 6124/* Clear the thread's private info on resume. */ 6125 6126static void 6127resume_clear_thread_private_info (struct thread_info *thread) 6128{ 6129 if (thread->priv != NULL) 6130 { 6131 remote_thread_info *priv = get_remote_thread_info (thread); 6132 6133 priv->stop_reason = TARGET_STOPPED_BY_NO_REASON; 6134 priv->watch_data_address = 0; 6135 } 6136} 6137 6138/* Append a vCont continue-with-signal action for threads that have a 6139 non-zero stop signal. */ 6140 6141char * 6142remote_target::append_pending_thread_resumptions (char *p, char *endp, 6143 ptid_t ptid) 6144{ 6145 for (thread_info *thread : all_non_exited_threads (this, ptid)) 6146 if (inferior_ptid != thread->ptid 6147 && thread->suspend.stop_signal != GDB_SIGNAL_0) 6148 { 6149 p = append_resumption (p, endp, thread->ptid, 6150 0, thread->suspend.stop_signal); 6151 thread->suspend.stop_signal = GDB_SIGNAL_0; 6152 resume_clear_thread_private_info (thread); 6153 } 6154 6155 return p; 6156} 6157 6158/* Set the target running, using the packets that use Hc 6159 (c/s/C/S). */ 6160 6161void 6162remote_target::remote_resume_with_hc (ptid_t ptid, int step, 6163 gdb_signal siggnal) 6164{ 6165 struct remote_state *rs = get_remote_state (); 6166 char *buf; 6167 6168 rs->last_sent_signal = siggnal; 6169 rs->last_sent_step = step; 6170 6171 /* The c/s/C/S resume packets use Hc, so set the continue 6172 thread. */ 6173 if (ptid == minus_one_ptid) 6174 set_continue_thread (any_thread_ptid); 6175 else 6176 set_continue_thread (ptid); 6177 6178 for (thread_info *thread : all_non_exited_threads (this)) 6179 resume_clear_thread_private_info (thread); 6180 6181 buf = rs->buf.data (); 6182 if (::execution_direction == EXEC_REVERSE) 6183 { 6184 /* We don't pass signals to the target in reverse exec mode. */ 6185 if (info_verbose && siggnal != GDB_SIGNAL_0) 6186 warning (_(" - Can't pass signal %d to target in reverse: ignored."), 6187 siggnal); 6188 6189 if (step && packet_support (PACKET_bs) == PACKET_DISABLE) 6190 error (_("Remote reverse-step not supported.")); 6191 if (!step && packet_support (PACKET_bc) == PACKET_DISABLE) 6192 error (_("Remote reverse-continue not supported.")); 6193 6194 strcpy (buf, step ? "bs" : "bc"); 6195 } 6196 else if (siggnal != GDB_SIGNAL_0) 6197 { 6198 buf[0] = step ? 'S' : 'C'; 6199 buf[1] = tohex (((int) siggnal >> 4) & 0xf); 6200 buf[2] = tohex (((int) siggnal) & 0xf); 6201 buf[3] = '\0'; 6202 } 6203 else 6204 strcpy (buf, step ? "s" : "c"); 6205 6206 putpkt (buf); 6207} 6208 6209/* Resume the remote inferior by using a "vCont" packet. The thread 6210 to be resumed is PTID; STEP and SIGGNAL indicate whether the 6211 resumed thread should be single-stepped and/or signalled. If PTID 6212 equals minus_one_ptid, then all threads are resumed; the thread to 6213 be stepped and/or signalled is given in the global INFERIOR_PTID. 6214 This function returns non-zero iff it resumes the inferior. 6215 6216 This function issues a strict subset of all possible vCont commands 6217 at the moment. */ 6218 6219int 6220remote_target::remote_resume_with_vcont (ptid_t ptid, int step, 6221 enum gdb_signal siggnal) 6222{ 6223 struct remote_state *rs = get_remote_state (); 6224 char *p; 6225 char *endp; 6226 6227 /* No reverse execution actions defined for vCont. */ 6228 if (::execution_direction == EXEC_REVERSE) 6229 return 0; 6230 6231 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN) 6232 remote_vcont_probe (); 6233 6234 if (packet_support (PACKET_vCont) == PACKET_DISABLE) 6235 return 0; 6236 6237 p = rs->buf.data (); 6238 endp = p + get_remote_packet_size (); 6239 6240 /* If we could generate a wider range of packets, we'd have to worry 6241 about overflowing BUF. Should there be a generic 6242 "multi-part-packet" packet? */ 6243 6244 p += xsnprintf (p, endp - p, "vCont"); 6245 6246 if (ptid == magic_null_ptid) 6247 { 6248 /* MAGIC_NULL_PTID means that we don't have any active threads, 6249 so we don't have any TID numbers the inferior will 6250 understand. Make sure to only send forms that do not specify 6251 a TID. */ 6252 append_resumption (p, endp, minus_one_ptid, step, siggnal); 6253 } 6254 else if (ptid == minus_one_ptid || ptid.is_pid ()) 6255 { 6256 /* Resume all threads (of all processes, or of a single 6257 process), with preference for INFERIOR_PTID. This assumes 6258 inferior_ptid belongs to the set of all threads we are about 6259 to resume. */ 6260 if (step || siggnal != GDB_SIGNAL_0) 6261 { 6262 /* Step inferior_ptid, with or without signal. */ 6263 p = append_resumption (p, endp, inferior_ptid, step, siggnal); 6264 } 6265 6266 /* Also pass down any pending signaled resumption for other 6267 threads not the current. */ 6268 p = append_pending_thread_resumptions (p, endp, ptid); 6269 6270 /* And continue others without a signal. */ 6271 append_resumption (p, endp, ptid, /*step=*/ 0, GDB_SIGNAL_0); 6272 } 6273 else 6274 { 6275 /* Scheduler locking; resume only PTID. */ 6276 append_resumption (p, endp, ptid, step, siggnal); 6277 } 6278 6279 gdb_assert (strlen (rs->buf.data ()) < get_remote_packet_size ()); 6280 putpkt (rs->buf); 6281 6282 if (target_is_non_stop_p ()) 6283 { 6284 /* In non-stop, the stub replies to vCont with "OK". The stop 6285 reply will be reported asynchronously by means of a `%Stop' 6286 notification. */ 6287 getpkt (&rs->buf, 0); 6288 if (strcmp (rs->buf.data (), "OK") != 0) 6289 error (_("Unexpected vCont reply in non-stop mode: %s"), 6290 rs->buf.data ()); 6291 } 6292 6293 return 1; 6294} 6295 6296/* Tell the remote machine to resume. */ 6297 6298void 6299remote_target::resume (ptid_t ptid, int step, enum gdb_signal siggnal) 6300{ 6301 struct remote_state *rs = get_remote_state (); 6302 6303 /* When connected in non-stop mode, the core resumes threads 6304 individually. Resuming remote threads directly in target_resume 6305 would thus result in sending one packet per thread. Instead, to 6306 minimize roundtrip latency, here we just store the resume 6307 request; the actual remote resumption will be done in 6308 target_commit_resume / remote_commit_resume, where we'll be able 6309 to do vCont action coalescing. */ 6310 if (target_is_non_stop_p () && ::execution_direction != EXEC_REVERSE) 6311 { 6312 remote_thread_info *remote_thr; 6313 6314 if (minus_one_ptid == ptid || ptid.is_pid ()) 6315 remote_thr = get_remote_thread_info (this, inferior_ptid); 6316 else 6317 remote_thr = get_remote_thread_info (this, ptid); 6318 6319 remote_thr->last_resume_step = step; 6320 remote_thr->last_resume_sig = siggnal; 6321 return; 6322 } 6323 6324 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN 6325 (explained in remote-notif.c:handle_notification) so 6326 remote_notif_process is not called. We need find a place where 6327 it is safe to start a 'vNotif' sequence. It is good to do it 6328 before resuming inferior, because inferior was stopped and no RSP 6329 traffic at that moment. */ 6330 if (!target_is_non_stop_p ()) 6331 remote_notif_process (rs->notif_state, ¬if_client_stop); 6332 6333 rs->last_resume_exec_dir = ::execution_direction; 6334 6335 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */ 6336 if (!remote_resume_with_vcont (ptid, step, siggnal)) 6337 remote_resume_with_hc (ptid, step, siggnal); 6338 6339 /* We are about to start executing the inferior, let's register it 6340 with the event loop. NOTE: this is the one place where all the 6341 execution commands end up. We could alternatively do this in each 6342 of the execution commands in infcmd.c. */ 6343 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here 6344 into infcmd.c in order to allow inferior function calls to work 6345 NOT asynchronously. */ 6346 if (target_can_async_p ()) 6347 target_async (1); 6348 6349 /* We've just told the target to resume. The remote server will 6350 wait for the inferior to stop, and then send a stop reply. In 6351 the mean time, we can't start another command/query ourselves 6352 because the stub wouldn't be ready to process it. This applies 6353 only to the base all-stop protocol, however. In non-stop (which 6354 only supports vCont), the stub replies with an "OK", and is 6355 immediate able to process further serial input. */ 6356 if (!target_is_non_stop_p ()) 6357 rs->waiting_for_stop_reply = 1; 6358} 6359 6360static int is_pending_fork_parent_thread (struct thread_info *thread); 6361 6362/* Private per-inferior info for target remote processes. */ 6363 6364struct remote_inferior : public private_inferior 6365{ 6366 /* Whether we can send a wildcard vCont for this process. */ 6367 bool may_wildcard_vcont = true; 6368}; 6369 6370/* Get the remote private inferior data associated to INF. */ 6371 6372static remote_inferior * 6373get_remote_inferior (inferior *inf) 6374{ 6375 if (inf->priv == NULL) 6376 inf->priv.reset (new remote_inferior); 6377 6378 return static_cast<remote_inferior *> (inf->priv.get ()); 6379} 6380 6381/* Class used to track the construction of a vCont packet in the 6382 outgoing packet buffer. This is used to send multiple vCont 6383 packets if we have more actions than would fit a single packet. */ 6384 6385class vcont_builder 6386{ 6387public: 6388 explicit vcont_builder (remote_target *remote) 6389 : m_remote (remote) 6390 { 6391 restart (); 6392 } 6393 6394 void flush (); 6395 void push_action (ptid_t ptid, bool step, gdb_signal siggnal); 6396 6397private: 6398 void restart (); 6399 6400 /* The remote target. */ 6401 remote_target *m_remote; 6402 6403 /* Pointer to the first action. P points here if no action has been 6404 appended yet. */ 6405 char *m_first_action; 6406 6407 /* Where the next action will be appended. */ 6408 char *m_p; 6409 6410 /* The end of the buffer. Must never write past this. */ 6411 char *m_endp; 6412}; 6413 6414/* Prepare the outgoing buffer for a new vCont packet. */ 6415 6416void 6417vcont_builder::restart () 6418{ 6419 struct remote_state *rs = m_remote->get_remote_state (); 6420 6421 m_p = rs->buf.data (); 6422 m_endp = m_p + m_remote->get_remote_packet_size (); 6423 m_p += xsnprintf (m_p, m_endp - m_p, "vCont"); 6424 m_first_action = m_p; 6425} 6426 6427/* If the vCont packet being built has any action, send it to the 6428 remote end. */ 6429 6430void 6431vcont_builder::flush () 6432{ 6433 struct remote_state *rs; 6434 6435 if (m_p == m_first_action) 6436 return; 6437 6438 rs = m_remote->get_remote_state (); 6439 m_remote->putpkt (rs->buf); 6440 m_remote->getpkt (&rs->buf, 0); 6441 if (strcmp (rs->buf.data (), "OK") != 0) 6442 error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf.data ()); 6443} 6444 6445/* The largest action is range-stepping, with its two addresses. This 6446 is more than sufficient. If a new, bigger action is created, it'll 6447 quickly trigger a failed assertion in append_resumption (and we'll 6448 just bump this). */ 6449#define MAX_ACTION_SIZE 200 6450 6451/* Append a new vCont action in the outgoing packet being built. If 6452 the action doesn't fit the packet along with previous actions, push 6453 what we've got so far to the remote end and start over a new vCont 6454 packet (with the new action). */ 6455 6456void 6457vcont_builder::push_action (ptid_t ptid, bool step, gdb_signal siggnal) 6458{ 6459 char buf[MAX_ACTION_SIZE + 1]; 6460 6461 char *endp = m_remote->append_resumption (buf, buf + sizeof (buf), 6462 ptid, step, siggnal); 6463 6464 /* Check whether this new action would fit in the vCont packet along 6465 with previous actions. If not, send what we've got so far and 6466 start a new vCont packet. */ 6467 size_t rsize = endp - buf; 6468 if (rsize > m_endp - m_p) 6469 { 6470 flush (); 6471 restart (); 6472 6473 /* Should now fit. */ 6474 gdb_assert (rsize <= m_endp - m_p); 6475 } 6476 6477 memcpy (m_p, buf, rsize); 6478 m_p += rsize; 6479 *m_p = '\0'; 6480} 6481 6482/* to_commit_resume implementation. */ 6483 6484void 6485remote_target::commit_resume () 6486{ 6487 int any_process_wildcard; 6488 int may_global_wildcard_vcont; 6489 6490 /* If connected in all-stop mode, we'd send the remote resume 6491 request directly from remote_resume. Likewise if 6492 reverse-debugging, as there are no defined vCont actions for 6493 reverse execution. */ 6494 if (!target_is_non_stop_p () || ::execution_direction == EXEC_REVERSE) 6495 return; 6496 6497 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1") 6498 instead of resuming all threads of each process individually. 6499 However, if any thread of a process must remain halted, we can't 6500 send wildcard resumes and must send one action per thread. 6501 6502 Care must be taken to not resume threads/processes the server 6503 side already told us are stopped, but the core doesn't know about 6504 yet, because the events are still in the vStopped notification 6505 queue. For example: 6506 6507 #1 => vCont s:p1.1;c 6508 #2 <= OK 6509 #3 <= %Stopped T05 p1.1 6510 #4 => vStopped 6511 #5 <= T05 p1.2 6512 #6 => vStopped 6513 #7 <= OK 6514 #8 (infrun handles the stop for p1.1 and continues stepping) 6515 #9 => vCont s:p1.1;c 6516 6517 The last vCont above would resume thread p1.2 by mistake, because 6518 the server has no idea that the event for p1.2 had not been 6519 handled yet. 6520 6521 The server side must similarly ignore resume actions for the 6522 thread that has a pending %Stopped notification (and any other 6523 threads with events pending), until GDB acks the notification 6524 with vStopped. Otherwise, e.g., the following case is 6525 mishandled: 6526 6527 #1 => g (or any other packet) 6528 #2 <= [registers] 6529 #3 <= %Stopped T05 p1.2 6530 #4 => vCont s:p1.1;c 6531 #5 <= OK 6532 6533 Above, the server must not resume thread p1.2. GDB can't know 6534 that p1.2 stopped until it acks the %Stopped notification, and 6535 since from GDB's perspective all threads should be running, it 6536 sends a "c" action. 6537 6538 Finally, special care must also be given to handling fork/vfork 6539 events. A (v)fork event actually tells us that two processes 6540 stopped -- the parent and the child. Until we follow the fork, 6541 we must not resume the child. Therefore, if we have a pending 6542 fork follow, we must not send a global wildcard resume action 6543 (vCont;c). We can still send process-wide wildcards though. */ 6544 6545 /* Start by assuming a global wildcard (vCont;c) is possible. */ 6546 may_global_wildcard_vcont = 1; 6547 6548 /* And assume every process is individually wildcard-able too. */ 6549 for (inferior *inf : all_non_exited_inferiors (this)) 6550 { 6551 remote_inferior *priv = get_remote_inferior (inf); 6552 6553 priv->may_wildcard_vcont = true; 6554 } 6555 6556 /* Check for any pending events (not reported or processed yet) and 6557 disable process and global wildcard resumes appropriately. */ 6558 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont); 6559 6560 for (thread_info *tp : all_non_exited_threads (this)) 6561 { 6562 /* If a thread of a process is not meant to be resumed, then we 6563 can't wildcard that process. */ 6564 if (!tp->executing) 6565 { 6566 get_remote_inferior (tp->inf)->may_wildcard_vcont = false; 6567 6568 /* And if we can't wildcard a process, we can't wildcard 6569 everything either. */ 6570 may_global_wildcard_vcont = 0; 6571 continue; 6572 } 6573 6574 /* If a thread is the parent of an unfollowed fork, then we 6575 can't do a global wildcard, as that would resume the fork 6576 child. */ 6577 if (is_pending_fork_parent_thread (tp)) 6578 may_global_wildcard_vcont = 0; 6579 } 6580 6581 /* Now let's build the vCont packet(s). Actions must be appended 6582 from narrower to wider scopes (thread -> process -> global). If 6583 we end up with too many actions for a single packet vcont_builder 6584 flushes the current vCont packet to the remote side and starts a 6585 new one. */ 6586 struct vcont_builder vcont_builder (this); 6587 6588 /* Threads first. */ 6589 for (thread_info *tp : all_non_exited_threads (this)) 6590 { 6591 remote_thread_info *remote_thr = get_remote_thread_info (tp); 6592 6593 if (!tp->executing || remote_thr->vcont_resumed) 6594 continue; 6595 6596 gdb_assert (!thread_is_in_step_over_chain (tp)); 6597 6598 if (!remote_thr->last_resume_step 6599 && remote_thr->last_resume_sig == GDB_SIGNAL_0 6600 && get_remote_inferior (tp->inf)->may_wildcard_vcont) 6601 { 6602 /* We'll send a wildcard resume instead. */ 6603 remote_thr->vcont_resumed = 1; 6604 continue; 6605 } 6606 6607 vcont_builder.push_action (tp->ptid, 6608 remote_thr->last_resume_step, 6609 remote_thr->last_resume_sig); 6610 remote_thr->vcont_resumed = 1; 6611 } 6612 6613 /* Now check whether we can send any process-wide wildcard. This is 6614 to avoid sending a global wildcard in the case nothing is 6615 supposed to be resumed. */ 6616 any_process_wildcard = 0; 6617 6618 for (inferior *inf : all_non_exited_inferiors (this)) 6619 { 6620 if (get_remote_inferior (inf)->may_wildcard_vcont) 6621 { 6622 any_process_wildcard = 1; 6623 break; 6624 } 6625 } 6626 6627 if (any_process_wildcard) 6628 { 6629 /* If all processes are wildcard-able, then send a single "c" 6630 action, otherwise, send an "all (-1) threads of process" 6631 continue action for each running process, if any. */ 6632 if (may_global_wildcard_vcont) 6633 { 6634 vcont_builder.push_action (minus_one_ptid, 6635 false, GDB_SIGNAL_0); 6636 } 6637 else 6638 { 6639 for (inferior *inf : all_non_exited_inferiors (this)) 6640 { 6641 if (get_remote_inferior (inf)->may_wildcard_vcont) 6642 { 6643 vcont_builder.push_action (ptid_t (inf->pid), 6644 false, GDB_SIGNAL_0); 6645 } 6646 } 6647 } 6648 } 6649 6650 vcont_builder.flush (); 6651} 6652 6653 6654 6655/* Non-stop version of target_stop. Uses `vCont;t' to stop a remote 6656 thread, all threads of a remote process, or all threads of all 6657 processes. */ 6658 6659void 6660remote_target::remote_stop_ns (ptid_t ptid) 6661{ 6662 struct remote_state *rs = get_remote_state (); 6663 char *p = rs->buf.data (); 6664 char *endp = p + get_remote_packet_size (); 6665 6666 /* FIXME: This supports_vCont_probed check is a workaround until 6667 packet_support is per-connection. */ 6668 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN 6669 || !rs->supports_vCont_probed) 6670 remote_vcont_probe (); 6671 6672 if (!rs->supports_vCont.t) 6673 error (_("Remote server does not support stopping threads")); 6674 6675 if (ptid == minus_one_ptid 6676 || (!remote_multi_process_p (rs) && ptid.is_pid ())) 6677 p += xsnprintf (p, endp - p, "vCont;t"); 6678 else 6679 { 6680 ptid_t nptid; 6681 6682 p += xsnprintf (p, endp - p, "vCont;t:"); 6683 6684 if (ptid.is_pid ()) 6685 /* All (-1) threads of process. */ 6686 nptid = ptid_t (ptid.pid (), -1, 0); 6687 else 6688 { 6689 /* Small optimization: if we already have a stop reply for 6690 this thread, no use in telling the stub we want this 6691 stopped. */ 6692 if (peek_stop_reply (ptid)) 6693 return; 6694 6695 nptid = ptid; 6696 } 6697 6698 write_ptid (p, endp, nptid); 6699 } 6700 6701 /* In non-stop, we get an immediate OK reply. The stop reply will 6702 come in asynchronously by notification. */ 6703 putpkt (rs->buf); 6704 getpkt (&rs->buf, 0); 6705 if (strcmp (rs->buf.data (), "OK") != 0) 6706 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid).c_str (), 6707 rs->buf.data ()); 6708} 6709 6710/* All-stop version of target_interrupt. Sends a break or a ^C to 6711 interrupt the remote target. It is undefined which thread of which 6712 process reports the interrupt. */ 6713 6714void 6715remote_target::remote_interrupt_as () 6716{ 6717 struct remote_state *rs = get_remote_state (); 6718 6719 rs->ctrlc_pending_p = 1; 6720 6721 /* If the inferior is stopped already, but the core didn't know 6722 about it yet, just ignore the request. The cached wait status 6723 will be collected in remote_wait. */ 6724 if (rs->cached_wait_status) 6725 return; 6726 6727 /* Send interrupt_sequence to remote target. */ 6728 send_interrupt_sequence (); 6729} 6730 6731/* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt 6732 the remote target. It is undefined which thread of which process 6733 reports the interrupt. Throws an error if the packet is not 6734 supported by the server. */ 6735 6736void 6737remote_target::remote_interrupt_ns () 6738{ 6739 struct remote_state *rs = get_remote_state (); 6740 char *p = rs->buf.data (); 6741 char *endp = p + get_remote_packet_size (); 6742 6743 xsnprintf (p, endp - p, "vCtrlC"); 6744 6745 /* In non-stop, we get an immediate OK reply. The stop reply will 6746 come in asynchronously by notification. */ 6747 putpkt (rs->buf); 6748 getpkt (&rs->buf, 0); 6749 6750 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCtrlC])) 6751 { 6752 case PACKET_OK: 6753 break; 6754 case PACKET_UNKNOWN: 6755 error (_("No support for interrupting the remote target.")); 6756 case PACKET_ERROR: 6757 error (_("Interrupting target failed: %s"), rs->buf.data ()); 6758 } 6759} 6760 6761/* Implement the to_stop function for the remote targets. */ 6762 6763void 6764remote_target::stop (ptid_t ptid) 6765{ 6766 if (remote_debug) 6767 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n"); 6768 6769 if (target_is_non_stop_p ()) 6770 remote_stop_ns (ptid); 6771 else 6772 { 6773 /* We don't currently have a way to transparently pause the 6774 remote target in all-stop mode. Interrupt it instead. */ 6775 remote_interrupt_as (); 6776 } 6777} 6778 6779/* Implement the to_interrupt function for the remote targets. */ 6780 6781void 6782remote_target::interrupt () 6783{ 6784 if (remote_debug) 6785 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n"); 6786 6787 if (target_is_non_stop_p ()) 6788 remote_interrupt_ns (); 6789 else 6790 remote_interrupt_as (); 6791} 6792 6793/* Implement the to_pass_ctrlc function for the remote targets. */ 6794 6795void 6796remote_target::pass_ctrlc () 6797{ 6798 struct remote_state *rs = get_remote_state (); 6799 6800 if (remote_debug) 6801 fprintf_unfiltered (gdb_stdlog, "remote_pass_ctrlc called\n"); 6802 6803 /* If we're starting up, we're not fully synced yet. Quit 6804 immediately. */ 6805 if (rs->starting_up) 6806 quit (); 6807 /* If ^C has already been sent once, offer to disconnect. */ 6808 else if (rs->ctrlc_pending_p) 6809 interrupt_query (); 6810 else 6811 target_interrupt (); 6812} 6813 6814/* Ask the user what to do when an interrupt is received. */ 6815 6816void 6817remote_target::interrupt_query () 6818{ 6819 struct remote_state *rs = get_remote_state (); 6820 6821 if (rs->waiting_for_stop_reply && rs->ctrlc_pending_p) 6822 { 6823 if (query (_("The target is not responding to interrupt requests.\n" 6824 "Stop debugging it? "))) 6825 { 6826 remote_unpush_target (this); 6827 throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target.")); 6828 } 6829 } 6830 else 6831 { 6832 if (query (_("Interrupted while waiting for the program.\n" 6833 "Give up waiting? "))) 6834 quit (); 6835 } 6836} 6837 6838/* Enable/disable target terminal ownership. Most targets can use 6839 terminal groups to control terminal ownership. Remote targets are 6840 different in that explicit transfer of ownership to/from GDB/target 6841 is required. */ 6842 6843void 6844remote_target::terminal_inferior () 6845{ 6846 /* NOTE: At this point we could also register our selves as the 6847 recipient of all input. Any characters typed could then be 6848 passed on down to the target. */ 6849} 6850 6851void 6852remote_target::terminal_ours () 6853{ 6854} 6855 6856static void 6857remote_console_output (const char *msg) 6858{ 6859 const char *p; 6860 6861 for (p = msg; p[0] && p[1]; p += 2) 6862 { 6863 char tb[2]; 6864 char c = fromhex (p[0]) * 16 + fromhex (p[1]); 6865 6866 tb[0] = c; 6867 tb[1] = 0; 6868 gdb_stdtarg->puts (tb); 6869 } 6870 gdb_stdtarg->flush (); 6871} 6872 6873struct stop_reply : public notif_event 6874{ 6875 ~stop_reply (); 6876 6877 /* The identifier of the thread about this event */ 6878 ptid_t ptid; 6879 6880 /* The remote state this event is associated with. When the remote 6881 connection, represented by a remote_state object, is closed, 6882 all the associated stop_reply events should be released. */ 6883 struct remote_state *rs; 6884 6885 struct target_waitstatus ws; 6886 6887 /* The architecture associated with the expedited registers. */ 6888 gdbarch *arch; 6889 6890 /* Expedited registers. This makes remote debugging a bit more 6891 efficient for those targets that provide critical registers as 6892 part of their normal status mechanism (as another roundtrip to 6893 fetch them is avoided). */ 6894 std::vector<cached_reg_t> regcache; 6895 6896 enum target_stop_reason stop_reason; 6897 6898 CORE_ADDR watch_data_address; 6899 6900 int core; 6901}; 6902 6903/* Return the length of the stop reply queue. */ 6904 6905int 6906remote_target::stop_reply_queue_length () 6907{ 6908 remote_state *rs = get_remote_state (); 6909 return rs->stop_reply_queue.size (); 6910} 6911 6912static void 6913remote_notif_stop_parse (remote_target *remote, 6914 struct notif_client *self, const char *buf, 6915 struct notif_event *event) 6916{ 6917 remote->remote_parse_stop_reply (buf, (struct stop_reply *) event); 6918} 6919 6920static void 6921remote_notif_stop_ack (remote_target *remote, 6922 struct notif_client *self, const char *buf, 6923 struct notif_event *event) 6924{ 6925 struct stop_reply *stop_reply = (struct stop_reply *) event; 6926 6927 /* acknowledge */ 6928 putpkt (remote, self->ack_command); 6929 6930 if (stop_reply->ws.kind == TARGET_WAITKIND_IGNORE) 6931 { 6932 /* We got an unknown stop reply. */ 6933 error (_("Unknown stop reply")); 6934 } 6935 6936 remote->push_stop_reply (stop_reply); 6937} 6938 6939static int 6940remote_notif_stop_can_get_pending_events (remote_target *remote, 6941 struct notif_client *self) 6942{ 6943 /* We can't get pending events in remote_notif_process for 6944 notification stop, and we have to do this in remote_wait_ns 6945 instead. If we fetch all queued events from stub, remote stub 6946 may exit and we have no chance to process them back in 6947 remote_wait_ns. */ 6948 remote_state *rs = remote->get_remote_state (); 6949 mark_async_event_handler (rs->remote_async_inferior_event_token); 6950 return 0; 6951} 6952 6953stop_reply::~stop_reply () 6954{ 6955 for (cached_reg_t ® : regcache) 6956 xfree (reg.data); 6957} 6958 6959static notif_event_up 6960remote_notif_stop_alloc_reply () 6961{ 6962 return notif_event_up (new struct stop_reply ()); 6963} 6964 6965/* A client of notification Stop. */ 6966 6967struct notif_client notif_client_stop = 6968{ 6969 "Stop", 6970 "vStopped", 6971 remote_notif_stop_parse, 6972 remote_notif_stop_ack, 6973 remote_notif_stop_can_get_pending_events, 6974 remote_notif_stop_alloc_reply, 6975 REMOTE_NOTIF_STOP, 6976}; 6977 6978/* Determine if THREAD_PTID is a pending fork parent thread. ARG contains 6979 the pid of the process that owns the threads we want to check, or 6980 -1 if we want to check all threads. */ 6981 6982static int 6983is_pending_fork_parent (struct target_waitstatus *ws, int event_pid, 6984 ptid_t thread_ptid) 6985{ 6986 if (ws->kind == TARGET_WAITKIND_FORKED 6987 || ws->kind == TARGET_WAITKIND_VFORKED) 6988 { 6989 if (event_pid == -1 || event_pid == thread_ptid.pid ()) 6990 return 1; 6991 } 6992 6993 return 0; 6994} 6995 6996/* Return the thread's pending status used to determine whether the 6997 thread is a fork parent stopped at a fork event. */ 6998 6999static struct target_waitstatus * 7000thread_pending_fork_status (struct thread_info *thread) 7001{ 7002 if (thread->suspend.waitstatus_pending_p) 7003 return &thread->suspend.waitstatus; 7004 else 7005 return &thread->pending_follow; 7006} 7007 7008/* Determine if THREAD is a pending fork parent thread. */ 7009 7010static int 7011is_pending_fork_parent_thread (struct thread_info *thread) 7012{ 7013 struct target_waitstatus *ws = thread_pending_fork_status (thread); 7014 int pid = -1; 7015 7016 return is_pending_fork_parent (ws, pid, thread->ptid); 7017} 7018 7019/* If CONTEXT contains any fork child threads that have not been 7020 reported yet, remove them from the CONTEXT list. If such a 7021 thread exists it is because we are stopped at a fork catchpoint 7022 and have not yet called follow_fork, which will set up the 7023 host-side data structures for the new process. */ 7024 7025void 7026remote_target::remove_new_fork_children (threads_listing_context *context) 7027{ 7028 int pid = -1; 7029 struct notif_client *notif = ¬if_client_stop; 7030 7031 /* For any threads stopped at a fork event, remove the corresponding 7032 fork child threads from the CONTEXT list. */ 7033 for (thread_info *thread : all_non_exited_threads (this)) 7034 { 7035 struct target_waitstatus *ws = thread_pending_fork_status (thread); 7036 7037 if (is_pending_fork_parent (ws, pid, thread->ptid)) 7038 context->remove_thread (ws->value.related_pid); 7039 } 7040 7041 /* Check for any pending fork events (not reported or processed yet) 7042 in process PID and remove those fork child threads from the 7043 CONTEXT list as well. */ 7044 remote_notif_get_pending_events (notif); 7045 for (auto &event : get_remote_state ()->stop_reply_queue) 7046 if (event->ws.kind == TARGET_WAITKIND_FORKED 7047 || event->ws.kind == TARGET_WAITKIND_VFORKED 7048 || event->ws.kind == TARGET_WAITKIND_THREAD_EXITED) 7049 context->remove_thread (event->ws.value.related_pid); 7050} 7051 7052/* Check whether any event pending in the vStopped queue would prevent 7053 a global or process wildcard vCont action. Clear 7054 *may_global_wildcard if we can't do a global wildcard (vCont;c), 7055 and clear the event inferior's may_wildcard_vcont flag if we can't 7056 do a process-wide wildcard resume (vCont;c:pPID.-1). */ 7057 7058void 7059remote_target::check_pending_events_prevent_wildcard_vcont 7060 (int *may_global_wildcard) 7061{ 7062 struct notif_client *notif = ¬if_client_stop; 7063 7064 remote_notif_get_pending_events (notif); 7065 for (auto &event : get_remote_state ()->stop_reply_queue) 7066 { 7067 if (event->ws.kind == TARGET_WAITKIND_NO_RESUMED 7068 || event->ws.kind == TARGET_WAITKIND_NO_HISTORY) 7069 continue; 7070 7071 if (event->ws.kind == TARGET_WAITKIND_FORKED 7072 || event->ws.kind == TARGET_WAITKIND_VFORKED) 7073 *may_global_wildcard = 0; 7074 7075 struct inferior *inf = find_inferior_ptid (this, event->ptid); 7076 7077 /* This may be the first time we heard about this process. 7078 Regardless, we must not do a global wildcard resume, otherwise 7079 we'd resume this process too. */ 7080 *may_global_wildcard = 0; 7081 if (inf != NULL) 7082 get_remote_inferior (inf)->may_wildcard_vcont = false; 7083 } 7084} 7085 7086/* Discard all pending stop replies of inferior INF. */ 7087 7088void 7089remote_target::discard_pending_stop_replies (struct inferior *inf) 7090{ 7091 struct stop_reply *reply; 7092 struct remote_state *rs = get_remote_state (); 7093 struct remote_notif_state *rns = rs->notif_state; 7094 7095 /* This function can be notified when an inferior exists. When the 7096 target is not remote, the notification state is NULL. */ 7097 if (rs->remote_desc == NULL) 7098 return; 7099 7100 reply = (struct stop_reply *) rns->pending_event[notif_client_stop.id]; 7101 7102 /* Discard the in-flight notification. */ 7103 if (reply != NULL && reply->ptid.pid () == inf->pid) 7104 { 7105 delete reply; 7106 rns->pending_event[notif_client_stop.id] = NULL; 7107 } 7108 7109 /* Discard the stop replies we have already pulled with 7110 vStopped. */ 7111 auto iter = std::remove_if (rs->stop_reply_queue.begin (), 7112 rs->stop_reply_queue.end (), 7113 [=] (const stop_reply_up &event) 7114 { 7115 return event->ptid.pid () == inf->pid; 7116 }); 7117 rs->stop_reply_queue.erase (iter, rs->stop_reply_queue.end ()); 7118} 7119 7120/* Discard the stop replies for RS in stop_reply_queue. */ 7121 7122void 7123remote_target::discard_pending_stop_replies_in_queue () 7124{ 7125 remote_state *rs = get_remote_state (); 7126 7127 /* Discard the stop replies we have already pulled with 7128 vStopped. */ 7129 auto iter = std::remove_if (rs->stop_reply_queue.begin (), 7130 rs->stop_reply_queue.end (), 7131 [=] (const stop_reply_up &event) 7132 { 7133 return event->rs == rs; 7134 }); 7135 rs->stop_reply_queue.erase (iter, rs->stop_reply_queue.end ()); 7136} 7137 7138/* Remove the first reply in 'stop_reply_queue' which matches 7139 PTID. */ 7140 7141struct stop_reply * 7142remote_target::remote_notif_remove_queued_reply (ptid_t ptid) 7143{ 7144 remote_state *rs = get_remote_state (); 7145 7146 auto iter = std::find_if (rs->stop_reply_queue.begin (), 7147 rs->stop_reply_queue.end (), 7148 [=] (const stop_reply_up &event) 7149 { 7150 return event->ptid.matches (ptid); 7151 }); 7152 struct stop_reply *result; 7153 if (iter == rs->stop_reply_queue.end ()) 7154 result = nullptr; 7155 else 7156 { 7157 result = iter->release (); 7158 rs->stop_reply_queue.erase (iter); 7159 } 7160 7161 if (notif_debug) 7162 fprintf_unfiltered (gdb_stdlog, 7163 "notif: discard queued event: 'Stop' in %s\n", 7164 target_pid_to_str (ptid).c_str ()); 7165 7166 return result; 7167} 7168 7169/* Look for a queued stop reply belonging to PTID. If one is found, 7170 remove it from the queue, and return it. Returns NULL if none is 7171 found. If there are still queued events left to process, tell the 7172 event loop to get back to target_wait soon. */ 7173 7174struct stop_reply * 7175remote_target::queued_stop_reply (ptid_t ptid) 7176{ 7177 remote_state *rs = get_remote_state (); 7178 struct stop_reply *r = remote_notif_remove_queued_reply (ptid); 7179 7180 if (!rs->stop_reply_queue.empty ()) 7181 { 7182 /* There's still at least an event left. */ 7183 mark_async_event_handler (rs->remote_async_inferior_event_token); 7184 } 7185 7186 return r; 7187} 7188 7189/* Push a fully parsed stop reply in the stop reply queue. Since we 7190 know that we now have at least one queued event left to pass to the 7191 core side, tell the event loop to get back to target_wait soon. */ 7192 7193void 7194remote_target::push_stop_reply (struct stop_reply *new_event) 7195{ 7196 remote_state *rs = get_remote_state (); 7197 rs->stop_reply_queue.push_back (stop_reply_up (new_event)); 7198 7199 if (notif_debug) 7200 fprintf_unfiltered (gdb_stdlog, 7201 "notif: push 'Stop' %s to queue %d\n", 7202 target_pid_to_str (new_event->ptid).c_str (), 7203 int (rs->stop_reply_queue.size ())); 7204 7205 mark_async_event_handler (rs->remote_async_inferior_event_token); 7206} 7207 7208/* Returns true if we have a stop reply for PTID. */ 7209 7210int 7211remote_target::peek_stop_reply (ptid_t ptid) 7212{ 7213 remote_state *rs = get_remote_state (); 7214 for (auto &event : rs->stop_reply_queue) 7215 if (ptid == event->ptid 7216 && event->ws.kind == TARGET_WAITKIND_STOPPED) 7217 return 1; 7218 return 0; 7219} 7220 7221/* Helper for remote_parse_stop_reply. Return nonzero if the substring 7222 starting with P and ending with PEND matches PREFIX. */ 7223 7224static int 7225strprefix (const char *p, const char *pend, const char *prefix) 7226{ 7227 for ( ; p < pend; p++, prefix++) 7228 if (*p != *prefix) 7229 return 0; 7230 return *prefix == '\0'; 7231} 7232 7233/* Parse the stop reply in BUF. Either the function succeeds, and the 7234 result is stored in EVENT, or throws an error. */ 7235 7236void 7237remote_target::remote_parse_stop_reply (const char *buf, stop_reply *event) 7238{ 7239 remote_arch_state *rsa = NULL; 7240 ULONGEST addr; 7241 const char *p; 7242 int skipregs = 0; 7243 7244 event->ptid = null_ptid; 7245 event->rs = get_remote_state (); 7246 event->ws.kind = TARGET_WAITKIND_IGNORE; 7247 event->ws.value.integer = 0; 7248 event->stop_reason = TARGET_STOPPED_BY_NO_REASON; 7249 event->regcache.clear (); 7250 event->core = -1; 7251 7252 switch (buf[0]) 7253 { 7254 case 'T': /* Status with PC, SP, FP, ... */ 7255 /* Expedited reply, containing Signal, {regno, reg} repeat. */ 7256 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where 7257 ss = signal number 7258 n... = register number 7259 r... = register contents 7260 */ 7261 7262 p = &buf[3]; /* after Txx */ 7263 while (*p) 7264 { 7265 const char *p1; 7266 int fieldsize; 7267 7268 p1 = strchr (p, ':'); 7269 if (p1 == NULL) 7270 error (_("Malformed packet(a) (missing colon): %s\n\ 7271Packet: '%s'\n"), 7272 p, buf); 7273 if (p == p1) 7274 error (_("Malformed packet(a) (missing register number): %s\n\ 7275Packet: '%s'\n"), 7276 p, buf); 7277 7278 /* Some "registers" are actually extended stop information. 7279 Note if you're adding a new entry here: GDB 7.9 and 7280 earlier assume that all register "numbers" that start 7281 with an hex digit are real register numbers. Make sure 7282 the server only sends such a packet if it knows the 7283 client understands it. */ 7284 7285 if (strprefix (p, p1, "thread")) 7286 event->ptid = read_ptid (++p1, &p); 7287 else if (strprefix (p, p1, "syscall_entry")) 7288 { 7289 ULONGEST sysno; 7290 7291 event->ws.kind = TARGET_WAITKIND_SYSCALL_ENTRY; 7292 p = unpack_varlen_hex (++p1, &sysno); 7293 event->ws.value.syscall_number = (int) sysno; 7294 } 7295 else if (strprefix (p, p1, "syscall_return")) 7296 { 7297 ULONGEST sysno; 7298 7299 event->ws.kind = TARGET_WAITKIND_SYSCALL_RETURN; 7300 p = unpack_varlen_hex (++p1, &sysno); 7301 event->ws.value.syscall_number = (int) sysno; 7302 } 7303 else if (strprefix (p, p1, "watch") 7304 || strprefix (p, p1, "rwatch") 7305 || strprefix (p, p1, "awatch")) 7306 { 7307 event->stop_reason = TARGET_STOPPED_BY_WATCHPOINT; 7308 p = unpack_varlen_hex (++p1, &addr); 7309 event->watch_data_address = (CORE_ADDR) addr; 7310 } 7311 else if (strprefix (p, p1, "swbreak")) 7312 { 7313 event->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT; 7314 7315 /* Make sure the stub doesn't forget to indicate support 7316 with qSupported. */ 7317 if (packet_support (PACKET_swbreak_feature) != PACKET_ENABLE) 7318 error (_("Unexpected swbreak stop reason")); 7319 7320 /* The value part is documented as "must be empty", 7321 though we ignore it, in case we ever decide to make 7322 use of it in a backward compatible way. */ 7323 p = strchrnul (p1 + 1, ';'); 7324 } 7325 else if (strprefix (p, p1, "hwbreak")) 7326 { 7327 event->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT; 7328 7329 /* Make sure the stub doesn't forget to indicate support 7330 with qSupported. */ 7331 if (packet_support (PACKET_hwbreak_feature) != PACKET_ENABLE) 7332 error (_("Unexpected hwbreak stop reason")); 7333 7334 /* See above. */ 7335 p = strchrnul (p1 + 1, ';'); 7336 } 7337 else if (strprefix (p, p1, "library")) 7338 { 7339 event->ws.kind = TARGET_WAITKIND_LOADED; 7340 p = strchrnul (p1 + 1, ';'); 7341 } 7342 else if (strprefix (p, p1, "replaylog")) 7343 { 7344 event->ws.kind = TARGET_WAITKIND_NO_HISTORY; 7345 /* p1 will indicate "begin" or "end", but it makes 7346 no difference for now, so ignore it. */ 7347 p = strchrnul (p1 + 1, ';'); 7348 } 7349 else if (strprefix (p, p1, "core")) 7350 { 7351 ULONGEST c; 7352 7353 p = unpack_varlen_hex (++p1, &c); 7354 event->core = c; 7355 } 7356 else if (strprefix (p, p1, "fork")) 7357 { 7358 event->ws.value.related_pid = read_ptid (++p1, &p); 7359 event->ws.kind = TARGET_WAITKIND_FORKED; 7360 } 7361 else if (strprefix (p, p1, "vfork")) 7362 { 7363 event->ws.value.related_pid = read_ptid (++p1, &p); 7364 event->ws.kind = TARGET_WAITKIND_VFORKED; 7365 } 7366 else if (strprefix (p, p1, "vforkdone")) 7367 { 7368 event->ws.kind = TARGET_WAITKIND_VFORK_DONE; 7369 p = strchrnul (p1 + 1, ';'); 7370 } 7371 else if (strprefix (p, p1, "exec")) 7372 { 7373 ULONGEST ignored; 7374 int pathlen; 7375 7376 /* Determine the length of the execd pathname. */ 7377 p = unpack_varlen_hex (++p1, &ignored); 7378 pathlen = (p - p1) / 2; 7379 7380 /* Save the pathname for event reporting and for 7381 the next run command. */ 7382 gdb::unique_xmalloc_ptr<char[]> pathname 7383 ((char *) xmalloc (pathlen + 1)); 7384 hex2bin (p1, (gdb_byte *) pathname.get (), pathlen); 7385 pathname[pathlen] = '\0'; 7386 7387 /* This is freed during event handling. */ 7388 event->ws.value.execd_pathname = pathname.release (); 7389 event->ws.kind = TARGET_WAITKIND_EXECD; 7390 7391 /* Skip the registers included in this packet, since 7392 they may be for an architecture different from the 7393 one used by the original program. */ 7394 skipregs = 1; 7395 } 7396 else if (strprefix (p, p1, "create")) 7397 { 7398 event->ws.kind = TARGET_WAITKIND_THREAD_CREATED; 7399 p = strchrnul (p1 + 1, ';'); 7400 } 7401 else 7402 { 7403 ULONGEST pnum; 7404 const char *p_temp; 7405 7406 if (skipregs) 7407 { 7408 p = strchrnul (p1 + 1, ';'); 7409 p++; 7410 continue; 7411 } 7412 7413 /* Maybe a real ``P'' register number. */ 7414 p_temp = unpack_varlen_hex (p, &pnum); 7415 /* If the first invalid character is the colon, we got a 7416 register number. Otherwise, it's an unknown stop 7417 reason. */ 7418 if (p_temp == p1) 7419 { 7420 /* If we haven't parsed the event's thread yet, find 7421 it now, in order to find the architecture of the 7422 reported expedited registers. */ 7423 if (event->ptid == null_ptid) 7424 { 7425 /* If there is no thread-id information then leave 7426 the event->ptid as null_ptid. Later in 7427 process_stop_reply we will pick a suitable 7428 thread. */ 7429 const char *thr = strstr (p1 + 1, ";thread:"); 7430 if (thr != NULL) 7431 event->ptid = read_ptid (thr + strlen (";thread:"), 7432 NULL); 7433 } 7434 7435 if (rsa == NULL) 7436 { 7437 inferior *inf 7438 = (event->ptid == null_ptid 7439 ? NULL 7440 : find_inferior_ptid (this, event->ptid)); 7441 /* If this is the first time we learn anything 7442 about this process, skip the registers 7443 included in this packet, since we don't yet 7444 know which architecture to use to parse them. 7445 We'll determine the architecture later when 7446 we process the stop reply and retrieve the 7447 target description, via 7448 remote_notice_new_inferior -> 7449 post_create_inferior. */ 7450 if (inf == NULL) 7451 { 7452 p = strchrnul (p1 + 1, ';'); 7453 p++; 7454 continue; 7455 } 7456 7457 event->arch = inf->gdbarch; 7458 rsa = event->rs->get_remote_arch_state (event->arch); 7459 } 7460 7461 packet_reg *reg 7462 = packet_reg_from_pnum (event->arch, rsa, pnum); 7463 cached_reg_t cached_reg; 7464 7465 if (reg == NULL) 7466 error (_("Remote sent bad register number %s: %s\n\ 7467Packet: '%s'\n"), 7468 hex_string (pnum), p, buf); 7469 7470 cached_reg.num = reg->regnum; 7471 cached_reg.data = (gdb_byte *) 7472 xmalloc (register_size (event->arch, reg->regnum)); 7473 7474 p = p1 + 1; 7475 fieldsize = hex2bin (p, cached_reg.data, 7476 register_size (event->arch, reg->regnum)); 7477 p += 2 * fieldsize; 7478 if (fieldsize < register_size (event->arch, reg->regnum)) 7479 warning (_("Remote reply is too short: %s"), buf); 7480 7481 event->regcache.push_back (cached_reg); 7482 } 7483 else 7484 { 7485 /* Not a number. Silently skip unknown optional 7486 info. */ 7487 p = strchrnul (p1 + 1, ';'); 7488 } 7489 } 7490 7491 if (*p != ';') 7492 error (_("Remote register badly formatted: %s\nhere: %s"), 7493 buf, p); 7494 ++p; 7495 } 7496 7497 if (event->ws.kind != TARGET_WAITKIND_IGNORE) 7498 break; 7499 7500 /* fall through */ 7501 case 'S': /* Old style status, just signal only. */ 7502 { 7503 int sig; 7504 7505 event->ws.kind = TARGET_WAITKIND_STOPPED; 7506 sig = (fromhex (buf[1]) << 4) + fromhex (buf[2]); 7507 if (GDB_SIGNAL_FIRST <= sig && sig < GDB_SIGNAL_LAST) 7508 event->ws.value.sig = (enum gdb_signal) sig; 7509 else 7510 event->ws.value.sig = GDB_SIGNAL_UNKNOWN; 7511 } 7512 break; 7513 case 'w': /* Thread exited. */ 7514 { 7515 ULONGEST value; 7516 7517 event->ws.kind = TARGET_WAITKIND_THREAD_EXITED; 7518 p = unpack_varlen_hex (&buf[1], &value); 7519 event->ws.value.integer = value; 7520 if (*p != ';') 7521 error (_("stop reply packet badly formatted: %s"), buf); 7522 event->ptid = read_ptid (++p, NULL); 7523 break; 7524 } 7525 case 'W': /* Target exited. */ 7526 case 'X': 7527 { 7528 ULONGEST value; 7529 7530 /* GDB used to accept only 2 hex chars here. Stubs should 7531 only send more if they detect GDB supports multi-process 7532 support. */ 7533 p = unpack_varlen_hex (&buf[1], &value); 7534 7535 if (buf[0] == 'W') 7536 { 7537 /* The remote process exited. */ 7538 event->ws.kind = TARGET_WAITKIND_EXITED; 7539 event->ws.value.integer = value; 7540 } 7541 else 7542 { 7543 /* The remote process exited with a signal. */ 7544 event->ws.kind = TARGET_WAITKIND_SIGNALLED; 7545 if (GDB_SIGNAL_FIRST <= value && value < GDB_SIGNAL_LAST) 7546 event->ws.value.sig = (enum gdb_signal) value; 7547 else 7548 event->ws.value.sig = GDB_SIGNAL_UNKNOWN; 7549 } 7550 7551 /* If no process is specified, return null_ptid, and let the 7552 caller figure out the right process to use. */ 7553 int pid = 0; 7554 if (*p == '\0') 7555 ; 7556 else if (*p == ';') 7557 { 7558 p++; 7559 7560 if (*p == '\0') 7561 ; 7562 else if (startswith (p, "process:")) 7563 { 7564 ULONGEST upid; 7565 7566 p += sizeof ("process:") - 1; 7567 unpack_varlen_hex (p, &upid); 7568 pid = upid; 7569 } 7570 else 7571 error (_("unknown stop reply packet: %s"), buf); 7572 } 7573 else 7574 error (_("unknown stop reply packet: %s"), buf); 7575 event->ptid = ptid_t (pid); 7576 } 7577 break; 7578 case 'N': 7579 event->ws.kind = TARGET_WAITKIND_NO_RESUMED; 7580 event->ptid = minus_one_ptid; 7581 break; 7582 } 7583} 7584 7585/* When the stub wants to tell GDB about a new notification reply, it 7586 sends a notification (%Stop, for example). Those can come it at 7587 any time, hence, we have to make sure that any pending 7588 putpkt/getpkt sequence we're making is finished, before querying 7589 the stub for more events with the corresponding ack command 7590 (vStopped, for example). E.g., if we started a vStopped sequence 7591 immediately upon receiving the notification, something like this 7592 could happen: 7593 7594 1.1) --> Hg 1 7595 1.2) <-- OK 7596 1.3) --> g 7597 1.4) <-- %Stop 7598 1.5) --> vStopped 7599 1.6) <-- (registers reply to step #1.3) 7600 7601 Obviously, the reply in step #1.6 would be unexpected to a vStopped 7602 query. 7603 7604 To solve this, whenever we parse a %Stop notification successfully, 7605 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on 7606 doing whatever we were doing: 7607 7608 2.1) --> Hg 1 7609 2.2) <-- OK 7610 2.3) --> g 7611 2.4) <-- %Stop 7612 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN> 7613 2.5) <-- (registers reply to step #2.3) 7614 7615 Eventually after step #2.5, we return to the event loop, which 7616 notices there's an event on the 7617 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the 7618 associated callback --- the function below. At this point, we're 7619 always safe to start a vStopped sequence. : 7620 7621 2.6) --> vStopped 7622 2.7) <-- T05 thread:2 7623 2.8) --> vStopped 7624 2.9) --> OK 7625*/ 7626 7627void 7628remote_target::remote_notif_get_pending_events (notif_client *nc) 7629{ 7630 struct remote_state *rs = get_remote_state (); 7631 7632 if (rs->notif_state->pending_event[nc->id] != NULL) 7633 { 7634 if (notif_debug) 7635 fprintf_unfiltered (gdb_stdlog, 7636 "notif: process: '%s' ack pending event\n", 7637 nc->name); 7638 7639 /* acknowledge */ 7640 nc->ack (this, nc, rs->buf.data (), 7641 rs->notif_state->pending_event[nc->id]); 7642 rs->notif_state->pending_event[nc->id] = NULL; 7643 7644 while (1) 7645 { 7646 getpkt (&rs->buf, 0); 7647 if (strcmp (rs->buf.data (), "OK") == 0) 7648 break; 7649 else 7650 remote_notif_ack (this, nc, rs->buf.data ()); 7651 } 7652 } 7653 else 7654 { 7655 if (notif_debug) 7656 fprintf_unfiltered (gdb_stdlog, 7657 "notif: process: '%s' no pending reply\n", 7658 nc->name); 7659 } 7660} 7661 7662/* Wrapper around remote_target::remote_notif_get_pending_events to 7663 avoid having to export the whole remote_target class. */ 7664 7665void 7666remote_notif_get_pending_events (remote_target *remote, notif_client *nc) 7667{ 7668 remote->remote_notif_get_pending_events (nc); 7669} 7670 7671/* Called when it is decided that STOP_REPLY holds the info of the 7672 event that is to be returned to the core. This function always 7673 destroys STOP_REPLY. */ 7674 7675ptid_t 7676remote_target::process_stop_reply (struct stop_reply *stop_reply, 7677 struct target_waitstatus *status) 7678{ 7679 ptid_t ptid; 7680 7681 *status = stop_reply->ws; 7682 ptid = stop_reply->ptid; 7683 7684 /* If no thread/process was reported by the stub then use the first 7685 non-exited thread in the current target. */ 7686 if (ptid == null_ptid) 7687 { 7688 /* Some stop events apply to all threads in an inferior, while others 7689 only apply to a single thread. */ 7690 bool is_stop_for_all_threads 7691 = (status->kind == TARGET_WAITKIND_EXITED 7692 || status->kind == TARGET_WAITKIND_SIGNALLED); 7693 7694 for (thread_info *thr : all_non_exited_threads (this)) 7695 { 7696 if (ptid != null_ptid 7697 && (!is_stop_for_all_threads 7698 || ptid.pid () != thr->ptid.pid ())) 7699 { 7700 static bool warned = false; 7701 7702 if (!warned) 7703 { 7704 /* If you are seeing this warning then the remote target 7705 has stopped without specifying a thread-id, but the 7706 target does have multiple threads (or inferiors), and 7707 so GDB is having to guess which thread stopped. 7708 7709 Examples of what might cause this are the target 7710 sending and 'S' stop packet, or a 'T' stop packet and 7711 not including a thread-id. 7712 7713 Additionally, the target might send a 'W' or 'X 7714 packet without including a process-id, when the target 7715 has multiple running inferiors. */ 7716 if (is_stop_for_all_threads) 7717 warning (_("multi-inferior target stopped without " 7718 "sending a process-id, using first " 7719 "non-exited inferior")); 7720 else 7721 warning (_("multi-threaded target stopped without " 7722 "sending a thread-id, using first " 7723 "non-exited thread")); 7724 warned = true; 7725 } 7726 break; 7727 } 7728 7729 /* If this is a stop for all threads then don't use a particular 7730 threads ptid, instead create a new ptid where only the pid 7731 field is set. */ 7732 if (is_stop_for_all_threads) 7733 ptid = ptid_t (thr->ptid.pid ()); 7734 else 7735 ptid = thr->ptid; 7736 } 7737 gdb_assert (ptid != null_ptid); 7738 } 7739 7740 if (status->kind != TARGET_WAITKIND_EXITED 7741 && status->kind != TARGET_WAITKIND_SIGNALLED 7742 && status->kind != TARGET_WAITKIND_NO_RESUMED) 7743 { 7744 /* Expedited registers. */ 7745 if (!stop_reply->regcache.empty ()) 7746 { 7747 struct regcache *regcache 7748 = get_thread_arch_regcache (this, ptid, stop_reply->arch); 7749 7750 for (cached_reg_t ® : stop_reply->regcache) 7751 { 7752 regcache->raw_supply (reg.num, reg.data); 7753 xfree (reg.data); 7754 } 7755 7756 stop_reply->regcache.clear (); 7757 } 7758 7759 remote_notice_new_inferior (ptid, 0); 7760 remote_thread_info *remote_thr = get_remote_thread_info (this, ptid); 7761 remote_thr->core = stop_reply->core; 7762 remote_thr->stop_reason = stop_reply->stop_reason; 7763 remote_thr->watch_data_address = stop_reply->watch_data_address; 7764 remote_thr->vcont_resumed = 0; 7765 } 7766 7767 delete stop_reply; 7768 return ptid; 7769} 7770 7771/* The non-stop mode version of target_wait. */ 7772 7773ptid_t 7774remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status, int options) 7775{ 7776 struct remote_state *rs = get_remote_state (); 7777 struct stop_reply *stop_reply; 7778 int ret; 7779 int is_notif = 0; 7780 7781 /* If in non-stop mode, get out of getpkt even if a 7782 notification is received. */ 7783 7784 ret = getpkt_or_notif_sane (&rs->buf, 0 /* forever */, &is_notif); 7785 while (1) 7786 { 7787 if (ret != -1 && !is_notif) 7788 switch (rs->buf[0]) 7789 { 7790 case 'E': /* Error of some sort. */ 7791 /* We're out of sync with the target now. Did it continue 7792 or not? We can't tell which thread it was in non-stop, 7793 so just ignore this. */ 7794 warning (_("Remote failure reply: %s"), rs->buf.data ()); 7795 break; 7796 case 'O': /* Console output. */ 7797 remote_console_output (&rs->buf[1]); 7798 break; 7799 default: 7800 warning (_("Invalid remote reply: %s"), rs->buf.data ()); 7801 break; 7802 } 7803 7804 /* Acknowledge a pending stop reply that may have arrived in the 7805 mean time. */ 7806 if (rs->notif_state->pending_event[notif_client_stop.id] != NULL) 7807 remote_notif_get_pending_events (¬if_client_stop); 7808 7809 /* If indeed we noticed a stop reply, we're done. */ 7810 stop_reply = queued_stop_reply (ptid); 7811 if (stop_reply != NULL) 7812 return process_stop_reply (stop_reply, status); 7813 7814 /* Still no event. If we're just polling for an event, then 7815 return to the event loop. */ 7816 if (options & TARGET_WNOHANG) 7817 { 7818 status->kind = TARGET_WAITKIND_IGNORE; 7819 return minus_one_ptid; 7820 } 7821 7822 /* Otherwise do a blocking wait. */ 7823 ret = getpkt_or_notif_sane (&rs->buf, 1 /* forever */, &is_notif); 7824 } 7825} 7826 7827/* Return the first resumed thread. */ 7828 7829static ptid_t 7830first_remote_resumed_thread (remote_target *target) 7831{ 7832 for (thread_info *tp : all_non_exited_threads (target, minus_one_ptid)) 7833 if (tp->resumed) 7834 return tp->ptid; 7835 return null_ptid; 7836} 7837 7838/* Wait until the remote machine stops, then return, storing status in 7839 STATUS just as `wait' would. */ 7840 7841ptid_t 7842remote_target::wait_as (ptid_t ptid, target_waitstatus *status, int options) 7843{ 7844 struct remote_state *rs = get_remote_state (); 7845 ptid_t event_ptid = null_ptid; 7846 char *buf; 7847 struct stop_reply *stop_reply; 7848 7849 again: 7850 7851 status->kind = TARGET_WAITKIND_IGNORE; 7852 status->value.integer = 0; 7853 7854 stop_reply = queued_stop_reply (ptid); 7855 if (stop_reply != NULL) 7856 return process_stop_reply (stop_reply, status); 7857 7858 if (rs->cached_wait_status) 7859 /* Use the cached wait status, but only once. */ 7860 rs->cached_wait_status = 0; 7861 else 7862 { 7863 int ret; 7864 int is_notif; 7865 int forever = ((options & TARGET_WNOHANG) == 0 7866 && rs->wait_forever_enabled_p); 7867 7868 if (!rs->waiting_for_stop_reply) 7869 { 7870 status->kind = TARGET_WAITKIND_NO_RESUMED; 7871 return minus_one_ptid; 7872 } 7873 7874 /* FIXME: cagney/1999-09-27: If we're in async mode we should 7875 _never_ wait for ever -> test on target_is_async_p(). 7876 However, before we do that we need to ensure that the caller 7877 knows how to take the target into/out of async mode. */ 7878 ret = getpkt_or_notif_sane (&rs->buf, forever, &is_notif); 7879 7880 /* GDB gets a notification. Return to core as this event is 7881 not interesting. */ 7882 if (ret != -1 && is_notif) 7883 return minus_one_ptid; 7884 7885 if (ret == -1 && (options & TARGET_WNOHANG) != 0) 7886 return minus_one_ptid; 7887 } 7888 7889 buf = rs->buf.data (); 7890 7891 /* Assume that the target has acknowledged Ctrl-C unless we receive 7892 an 'F' or 'O' packet. */ 7893 if (buf[0] != 'F' && buf[0] != 'O') 7894 rs->ctrlc_pending_p = 0; 7895 7896 switch (buf[0]) 7897 { 7898 case 'E': /* Error of some sort. */ 7899 /* We're out of sync with the target now. Did it continue or 7900 not? Not is more likely, so report a stop. */ 7901 rs->waiting_for_stop_reply = 0; 7902 7903 warning (_("Remote failure reply: %s"), buf); 7904 status->kind = TARGET_WAITKIND_STOPPED; 7905 status->value.sig = GDB_SIGNAL_0; 7906 break; 7907 case 'F': /* File-I/O request. */ 7908 /* GDB may access the inferior memory while handling the File-I/O 7909 request, but we don't want GDB accessing memory while waiting 7910 for a stop reply. See the comments in putpkt_binary. Set 7911 waiting_for_stop_reply to 0 temporarily. */ 7912 rs->waiting_for_stop_reply = 0; 7913 remote_fileio_request (this, buf, rs->ctrlc_pending_p); 7914 rs->ctrlc_pending_p = 0; 7915 /* GDB handled the File-I/O request, and the target is running 7916 again. Keep waiting for events. */ 7917 rs->waiting_for_stop_reply = 1; 7918 break; 7919 case 'N': case 'T': case 'S': case 'X': case 'W': 7920 { 7921 /* There is a stop reply to handle. */ 7922 rs->waiting_for_stop_reply = 0; 7923 7924 stop_reply 7925 = (struct stop_reply *) remote_notif_parse (this, 7926 ¬if_client_stop, 7927 rs->buf.data ()); 7928 7929 event_ptid = process_stop_reply (stop_reply, status); 7930 break; 7931 } 7932 case 'O': /* Console output. */ 7933 remote_console_output (buf + 1); 7934 break; 7935 case '\0': 7936 if (rs->last_sent_signal != GDB_SIGNAL_0) 7937 { 7938 /* Zero length reply means that we tried 'S' or 'C' and the 7939 remote system doesn't support it. */ 7940 target_terminal::ours_for_output (); 7941 printf_filtered 7942 ("Can't send signals to this remote system. %s not sent.\n", 7943 gdb_signal_to_name (rs->last_sent_signal)); 7944 rs->last_sent_signal = GDB_SIGNAL_0; 7945 target_terminal::inferior (); 7946 7947 strcpy (buf, rs->last_sent_step ? "s" : "c"); 7948 putpkt (buf); 7949 break; 7950 } 7951 /* fallthrough */ 7952 default: 7953 warning (_("Invalid remote reply: %s"), buf); 7954 break; 7955 } 7956 7957 if (status->kind == TARGET_WAITKIND_NO_RESUMED) 7958 return minus_one_ptid; 7959 else if (status->kind == TARGET_WAITKIND_IGNORE) 7960 { 7961 /* Nothing interesting happened. If we're doing a non-blocking 7962 poll, we're done. Otherwise, go back to waiting. */ 7963 if (options & TARGET_WNOHANG) 7964 return minus_one_ptid; 7965 else 7966 goto again; 7967 } 7968 else if (status->kind != TARGET_WAITKIND_EXITED 7969 && status->kind != TARGET_WAITKIND_SIGNALLED) 7970 { 7971 if (event_ptid != null_ptid) 7972 record_currthread (rs, event_ptid); 7973 else 7974 event_ptid = first_remote_resumed_thread (this); 7975 } 7976 else 7977 { 7978 /* A process exit. Invalidate our notion of current thread. */ 7979 record_currthread (rs, minus_one_ptid); 7980 /* It's possible that the packet did not include a pid. */ 7981 if (event_ptid == null_ptid) 7982 event_ptid = first_remote_resumed_thread (this); 7983 /* EVENT_PTID could still be NULL_PTID. Double-check. */ 7984 if (event_ptid == null_ptid) 7985 event_ptid = magic_null_ptid; 7986 } 7987 7988 return event_ptid; 7989} 7990 7991/* Wait until the remote machine stops, then return, storing status in 7992 STATUS just as `wait' would. */ 7993 7994ptid_t 7995remote_target::wait (ptid_t ptid, struct target_waitstatus *status, int options) 7996{ 7997 ptid_t event_ptid; 7998 7999 if (target_is_non_stop_p ()) 8000 event_ptid = wait_ns (ptid, status, options); 8001 else 8002 event_ptid = wait_as (ptid, status, options); 8003 8004 if (target_is_async_p ()) 8005 { 8006 remote_state *rs = get_remote_state (); 8007 8008 /* If there are are events left in the queue tell the event loop 8009 to return here. */ 8010 if (!rs->stop_reply_queue.empty ()) 8011 mark_async_event_handler (rs->remote_async_inferior_event_token); 8012 } 8013 8014 return event_ptid; 8015} 8016 8017/* Fetch a single register using a 'p' packet. */ 8018 8019int 8020remote_target::fetch_register_using_p (struct regcache *regcache, 8021 packet_reg *reg) 8022{ 8023 struct gdbarch *gdbarch = regcache->arch (); 8024 struct remote_state *rs = get_remote_state (); 8025 char *buf, *p; 8026 gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum)); 8027 int i; 8028 8029 if (packet_support (PACKET_p) == PACKET_DISABLE) 8030 return 0; 8031 8032 if (reg->pnum == -1) 8033 return 0; 8034 8035 p = rs->buf.data (); 8036 *p++ = 'p'; 8037 p += hexnumstr (p, reg->pnum); 8038 *p++ = '\0'; 8039 putpkt (rs->buf); 8040 getpkt (&rs->buf, 0); 8041 8042 buf = rs->buf.data (); 8043 8044 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_p])) 8045 { 8046 case PACKET_OK: 8047 break; 8048 case PACKET_UNKNOWN: 8049 return 0; 8050 case PACKET_ERROR: 8051 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"), 8052 gdbarch_register_name (regcache->arch (), 8053 reg->regnum), 8054 buf); 8055 } 8056 8057 /* If this register is unfetchable, tell the regcache. */ 8058 if (buf[0] == 'x') 8059 { 8060 regcache->raw_supply (reg->regnum, NULL); 8061 return 1; 8062 } 8063 8064 /* Otherwise, parse and supply the value. */ 8065 p = buf; 8066 i = 0; 8067 while (p[0] != 0) 8068 { 8069 if (p[1] == 0) 8070 error (_("fetch_register_using_p: early buf termination")); 8071 8072 regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]); 8073 p += 2; 8074 } 8075 regcache->raw_supply (reg->regnum, regp); 8076 return 1; 8077} 8078 8079/* Fetch the registers included in the target's 'g' packet. */ 8080 8081int 8082remote_target::send_g_packet () 8083{ 8084 struct remote_state *rs = get_remote_state (); 8085 int buf_len; 8086 8087 xsnprintf (rs->buf.data (), get_remote_packet_size (), "g"); 8088 putpkt (rs->buf); 8089 getpkt (&rs->buf, 0); 8090 if (packet_check_result (rs->buf) == PACKET_ERROR) 8091 error (_("Could not read registers; remote failure reply '%s'"), 8092 rs->buf.data ()); 8093 8094 /* We can get out of synch in various cases. If the first character 8095 in the buffer is not a hex character, assume that has happened 8096 and try to fetch another packet to read. */ 8097 while ((rs->buf[0] < '0' || rs->buf[0] > '9') 8098 && (rs->buf[0] < 'A' || rs->buf[0] > 'F') 8099 && (rs->buf[0] < 'a' || rs->buf[0] > 'f') 8100 && rs->buf[0] != 'x') /* New: unavailable register value. */ 8101 { 8102 if (remote_debug) 8103 fprintf_unfiltered (gdb_stdlog, 8104 "Bad register packet; fetching a new packet\n"); 8105 getpkt (&rs->buf, 0); 8106 } 8107 8108 buf_len = strlen (rs->buf.data ()); 8109 8110 /* Sanity check the received packet. */ 8111 if (buf_len % 2 != 0) 8112 error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf.data ()); 8113 8114 return buf_len / 2; 8115} 8116 8117void 8118remote_target::process_g_packet (struct regcache *regcache) 8119{ 8120 struct gdbarch *gdbarch = regcache->arch (); 8121 struct remote_state *rs = get_remote_state (); 8122 remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch); 8123 int i, buf_len; 8124 char *p; 8125 char *regs; 8126 8127 buf_len = strlen (rs->buf.data ()); 8128 8129 /* Further sanity checks, with knowledge of the architecture. */ 8130 if (buf_len > 2 * rsa->sizeof_g_packet) 8131 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d " 8132 "bytes): %s"), 8133 rsa->sizeof_g_packet, buf_len / 2, 8134 rs->buf.data ()); 8135 8136 /* Save the size of the packet sent to us by the target. It is used 8137 as a heuristic when determining the max size of packets that the 8138 target can safely receive. */ 8139 if (rsa->actual_register_packet_size == 0) 8140 rsa->actual_register_packet_size = buf_len; 8141 8142 /* If this is smaller than we guessed the 'g' packet would be, 8143 update our records. A 'g' reply that doesn't include a register's 8144 value implies either that the register is not available, or that 8145 the 'p' packet must be used. */ 8146 if (buf_len < 2 * rsa->sizeof_g_packet) 8147 { 8148 long sizeof_g_packet = buf_len / 2; 8149 8150 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 8151 { 8152 long offset = rsa->regs[i].offset; 8153 long reg_size = register_size (gdbarch, i); 8154 8155 if (rsa->regs[i].pnum == -1) 8156 continue; 8157 8158 if (offset >= sizeof_g_packet) 8159 rsa->regs[i].in_g_packet = 0; 8160 else if (offset + reg_size > sizeof_g_packet) 8161 error (_("Truncated register %d in remote 'g' packet"), i); 8162 else 8163 rsa->regs[i].in_g_packet = 1; 8164 } 8165 8166 /* Looks valid enough, we can assume this is the correct length 8167 for a 'g' packet. It's important not to adjust 8168 rsa->sizeof_g_packet if we have truncated registers otherwise 8169 this "if" won't be run the next time the method is called 8170 with a packet of the same size and one of the internal errors 8171 below will trigger instead. */ 8172 rsa->sizeof_g_packet = sizeof_g_packet; 8173 } 8174 8175 regs = (char *) alloca (rsa->sizeof_g_packet); 8176 8177 /* Unimplemented registers read as all bits zero. */ 8178 memset (regs, 0, rsa->sizeof_g_packet); 8179 8180 /* Reply describes registers byte by byte, each byte encoded as two 8181 hex characters. Suck them all up, then supply them to the 8182 register cacheing/storage mechanism. */ 8183 8184 p = rs->buf.data (); 8185 for (i = 0; i < rsa->sizeof_g_packet; i++) 8186 { 8187 if (p[0] == 0 || p[1] == 0) 8188 /* This shouldn't happen - we adjusted sizeof_g_packet above. */ 8189 internal_error (__FILE__, __LINE__, 8190 _("unexpected end of 'g' packet reply")); 8191 8192 if (p[0] == 'x' && p[1] == 'x') 8193 regs[i] = 0; /* 'x' */ 8194 else 8195 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]); 8196 p += 2; 8197 } 8198 8199 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 8200 { 8201 struct packet_reg *r = &rsa->regs[i]; 8202 long reg_size = register_size (gdbarch, i); 8203 8204 if (r->in_g_packet) 8205 { 8206 if ((r->offset + reg_size) * 2 > strlen (rs->buf.data ())) 8207 /* This shouldn't happen - we adjusted in_g_packet above. */ 8208 internal_error (__FILE__, __LINE__, 8209 _("unexpected end of 'g' packet reply")); 8210 else if (rs->buf[r->offset * 2] == 'x') 8211 { 8212 gdb_assert (r->offset * 2 < strlen (rs->buf.data ())); 8213 /* The register isn't available, mark it as such (at 8214 the same time setting the value to zero). */ 8215 regcache->raw_supply (r->regnum, NULL); 8216 } 8217 else 8218 regcache->raw_supply (r->regnum, regs + r->offset); 8219 } 8220 } 8221} 8222 8223void 8224remote_target::fetch_registers_using_g (struct regcache *regcache) 8225{ 8226 send_g_packet (); 8227 process_g_packet (regcache); 8228} 8229 8230/* Make the remote selected traceframe match GDB's selected 8231 traceframe. */ 8232 8233void 8234remote_target::set_remote_traceframe () 8235{ 8236 int newnum; 8237 struct remote_state *rs = get_remote_state (); 8238 8239 if (rs->remote_traceframe_number == get_traceframe_number ()) 8240 return; 8241 8242 /* Avoid recursion, remote_trace_find calls us again. */ 8243 rs->remote_traceframe_number = get_traceframe_number (); 8244 8245 newnum = target_trace_find (tfind_number, 8246 get_traceframe_number (), 0, 0, NULL); 8247 8248 /* Should not happen. If it does, all bets are off. */ 8249 if (newnum != get_traceframe_number ()) 8250 warning (_("could not set remote traceframe")); 8251} 8252 8253void 8254remote_target::fetch_registers (struct regcache *regcache, int regnum) 8255{ 8256 struct gdbarch *gdbarch = regcache->arch (); 8257 struct remote_state *rs = get_remote_state (); 8258 remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch); 8259 int i; 8260 8261 set_remote_traceframe (); 8262 set_general_thread (regcache->ptid ()); 8263 8264 if (regnum >= 0) 8265 { 8266 packet_reg *reg = packet_reg_from_regnum (gdbarch, rsa, regnum); 8267 8268 gdb_assert (reg != NULL); 8269 8270 /* If this register might be in the 'g' packet, try that first - 8271 we are likely to read more than one register. If this is the 8272 first 'g' packet, we might be overly optimistic about its 8273 contents, so fall back to 'p'. */ 8274 if (reg->in_g_packet) 8275 { 8276 fetch_registers_using_g (regcache); 8277 if (reg->in_g_packet) 8278 return; 8279 } 8280 8281 if (fetch_register_using_p (regcache, reg)) 8282 return; 8283 8284 /* This register is not available. */ 8285 regcache->raw_supply (reg->regnum, NULL); 8286 8287 return; 8288 } 8289 8290 fetch_registers_using_g (regcache); 8291 8292 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 8293 if (!rsa->regs[i].in_g_packet) 8294 if (!fetch_register_using_p (regcache, &rsa->regs[i])) 8295 { 8296 /* This register is not available. */ 8297 regcache->raw_supply (i, NULL); 8298 } 8299} 8300 8301/* Prepare to store registers. Since we may send them all (using a 8302 'G' request), we have to read out the ones we don't want to change 8303 first. */ 8304 8305void 8306remote_target::prepare_to_store (struct regcache *regcache) 8307{ 8308 struct remote_state *rs = get_remote_state (); 8309 remote_arch_state *rsa = rs->get_remote_arch_state (regcache->arch ()); 8310 int i; 8311 8312 /* Make sure the entire registers array is valid. */ 8313 switch (packet_support (PACKET_P)) 8314 { 8315 case PACKET_DISABLE: 8316 case PACKET_SUPPORT_UNKNOWN: 8317 /* Make sure all the necessary registers are cached. */ 8318 for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++) 8319 if (rsa->regs[i].in_g_packet) 8320 regcache->raw_update (rsa->regs[i].regnum); 8321 break; 8322 case PACKET_ENABLE: 8323 break; 8324 } 8325} 8326 8327/* Helper: Attempt to store REGNUM using the P packet. Return fail IFF 8328 packet was not recognized. */ 8329 8330int 8331remote_target::store_register_using_P (const struct regcache *regcache, 8332 packet_reg *reg) 8333{ 8334 struct gdbarch *gdbarch = regcache->arch (); 8335 struct remote_state *rs = get_remote_state (); 8336 /* Try storing a single register. */ 8337 char *buf = rs->buf.data (); 8338 gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum)); 8339 char *p; 8340 8341 if (packet_support (PACKET_P) == PACKET_DISABLE) 8342 return 0; 8343 8344 if (reg->pnum == -1) 8345 return 0; 8346 8347 xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0)); 8348 p = buf + strlen (buf); 8349 regcache->raw_collect (reg->regnum, regp); 8350 bin2hex (regp, p, register_size (gdbarch, reg->regnum)); 8351 putpkt (rs->buf); 8352 getpkt (&rs->buf, 0); 8353 8354 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P])) 8355 { 8356 case PACKET_OK: 8357 return 1; 8358 case PACKET_ERROR: 8359 error (_("Could not write register \"%s\"; remote failure reply '%s'"), 8360 gdbarch_register_name (gdbarch, reg->regnum), rs->buf.data ()); 8361 case PACKET_UNKNOWN: 8362 return 0; 8363 default: 8364 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok")); 8365 } 8366} 8367 8368/* Store register REGNUM, or all registers if REGNUM == -1, from the 8369 contents of the register cache buffer. FIXME: ignores errors. */ 8370 8371void 8372remote_target::store_registers_using_G (const struct regcache *regcache) 8373{ 8374 struct remote_state *rs = get_remote_state (); 8375 remote_arch_state *rsa = rs->get_remote_arch_state (regcache->arch ()); 8376 gdb_byte *regs; 8377 char *p; 8378 8379 /* Extract all the registers in the regcache copying them into a 8380 local buffer. */ 8381 { 8382 int i; 8383 8384 regs = (gdb_byte *) alloca (rsa->sizeof_g_packet); 8385 memset (regs, 0, rsa->sizeof_g_packet); 8386 for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++) 8387 { 8388 struct packet_reg *r = &rsa->regs[i]; 8389 8390 if (r->in_g_packet) 8391 regcache->raw_collect (r->regnum, regs + r->offset); 8392 } 8393 } 8394 8395 /* Command describes registers byte by byte, 8396 each byte encoded as two hex characters. */ 8397 p = rs->buf.data (); 8398 *p++ = 'G'; 8399 bin2hex (regs, p, rsa->sizeof_g_packet); 8400 putpkt (rs->buf); 8401 getpkt (&rs->buf, 0); 8402 if (packet_check_result (rs->buf) == PACKET_ERROR) 8403 error (_("Could not write registers; remote failure reply '%s'"), 8404 rs->buf.data ()); 8405} 8406 8407/* Store register REGNUM, or all registers if REGNUM == -1, from the contents 8408 of the register cache buffer. FIXME: ignores errors. */ 8409 8410void 8411remote_target::store_registers (struct regcache *regcache, int regnum) 8412{ 8413 struct gdbarch *gdbarch = regcache->arch (); 8414 struct remote_state *rs = get_remote_state (); 8415 remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch); 8416 int i; 8417 8418 set_remote_traceframe (); 8419 set_general_thread (regcache->ptid ()); 8420 8421 if (regnum >= 0) 8422 { 8423 packet_reg *reg = packet_reg_from_regnum (gdbarch, rsa, regnum); 8424 8425 gdb_assert (reg != NULL); 8426 8427 /* Always prefer to store registers using the 'P' packet if 8428 possible; we often change only a small number of registers. 8429 Sometimes we change a larger number; we'd need help from a 8430 higher layer to know to use 'G'. */ 8431 if (store_register_using_P (regcache, reg)) 8432 return; 8433 8434 /* For now, don't complain if we have no way to write the 8435 register. GDB loses track of unavailable registers too 8436 easily. Some day, this may be an error. We don't have 8437 any way to read the register, either... */ 8438 if (!reg->in_g_packet) 8439 return; 8440 8441 store_registers_using_G (regcache); 8442 return; 8443 } 8444 8445 store_registers_using_G (regcache); 8446 8447 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 8448 if (!rsa->regs[i].in_g_packet) 8449 if (!store_register_using_P (regcache, &rsa->regs[i])) 8450 /* See above for why we do not issue an error here. */ 8451 continue; 8452} 8453 8454 8455/* Return the number of hex digits in num. */ 8456 8457static int 8458hexnumlen (ULONGEST num) 8459{ 8460 int i; 8461 8462 for (i = 0; num != 0; i++) 8463 num >>= 4; 8464 8465 return std::max (i, 1); 8466} 8467 8468/* Set BUF to the minimum number of hex digits representing NUM. */ 8469 8470static int 8471hexnumstr (char *buf, ULONGEST num) 8472{ 8473 int len = hexnumlen (num); 8474 8475 return hexnumnstr (buf, num, len); 8476} 8477 8478 8479/* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */ 8480 8481static int 8482hexnumnstr (char *buf, ULONGEST num, int width) 8483{ 8484 int i; 8485 8486 buf[width] = '\0'; 8487 8488 for (i = width - 1; i >= 0; i--) 8489 { 8490 buf[i] = "0123456789abcdef"[(num & 0xf)]; 8491 num >>= 4; 8492 } 8493 8494 return width; 8495} 8496 8497/* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */ 8498 8499static CORE_ADDR 8500remote_address_masked (CORE_ADDR addr) 8501{ 8502 unsigned int address_size = remote_address_size; 8503 8504 /* If "remoteaddresssize" was not set, default to target address size. */ 8505 if (!address_size) 8506 address_size = gdbarch_addr_bit (target_gdbarch ()); 8507 8508 if (address_size > 0 8509 && address_size < (sizeof (ULONGEST) * 8)) 8510 { 8511 /* Only create a mask when that mask can safely be constructed 8512 in a ULONGEST variable. */ 8513 ULONGEST mask = 1; 8514 8515 mask = (mask << address_size) - 1; 8516 addr &= mask; 8517 } 8518 return addr; 8519} 8520 8521/* Determine whether the remote target supports binary downloading. 8522 This is accomplished by sending a no-op memory write of zero length 8523 to the target at the specified address. It does not suffice to send 8524 the whole packet, since many stubs strip the eighth bit and 8525 subsequently compute a wrong checksum, which causes real havoc with 8526 remote_write_bytes. 8527 8528 NOTE: This can still lose if the serial line is not eight-bit 8529 clean. In cases like this, the user should clear "remote 8530 X-packet". */ 8531 8532void 8533remote_target::check_binary_download (CORE_ADDR addr) 8534{ 8535 struct remote_state *rs = get_remote_state (); 8536 8537 switch (packet_support (PACKET_X)) 8538 { 8539 case PACKET_DISABLE: 8540 break; 8541 case PACKET_ENABLE: 8542 break; 8543 case PACKET_SUPPORT_UNKNOWN: 8544 { 8545 char *p; 8546 8547 p = rs->buf.data (); 8548 *p++ = 'X'; 8549 p += hexnumstr (p, (ULONGEST) addr); 8550 *p++ = ','; 8551 p += hexnumstr (p, (ULONGEST) 0); 8552 *p++ = ':'; 8553 *p = '\0'; 8554 8555 putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ())); 8556 getpkt (&rs->buf, 0); 8557 8558 if (rs->buf[0] == '\0') 8559 { 8560 if (remote_debug) 8561 fprintf_unfiltered (gdb_stdlog, 8562 "binary downloading NOT " 8563 "supported by target\n"); 8564 remote_protocol_packets[PACKET_X].support = PACKET_DISABLE; 8565 } 8566 else 8567 { 8568 if (remote_debug) 8569 fprintf_unfiltered (gdb_stdlog, 8570 "binary downloading supported by target\n"); 8571 remote_protocol_packets[PACKET_X].support = PACKET_ENABLE; 8572 } 8573 break; 8574 } 8575 } 8576} 8577 8578/* Helper function to resize the payload in order to try to get a good 8579 alignment. We try to write an amount of data such that the next write will 8580 start on an address aligned on REMOTE_ALIGN_WRITES. */ 8581 8582static int 8583align_for_efficient_write (int todo, CORE_ADDR memaddr) 8584{ 8585 return ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr; 8586} 8587 8588/* Write memory data directly to the remote machine. 8589 This does not inform the data cache; the data cache uses this. 8590 HEADER is the starting part of the packet. 8591 MEMADDR is the address in the remote memory space. 8592 MYADDR is the address of the buffer in our space. 8593 LEN_UNITS is the number of addressable units to write. 8594 UNIT_SIZE is the length in bytes of an addressable unit. 8595 PACKET_FORMAT should be either 'X' or 'M', and indicates if we 8596 should send data as binary ('X'), or hex-encoded ('M'). 8597 8598 The function creates packet of the form 8599 <HEADER><ADDRESS>,<LENGTH>:<DATA> 8600 8601 where encoding of <DATA> is terminated by PACKET_FORMAT. 8602 8603 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma 8604 are omitted. 8605 8606 Return the transferred status, error or OK (an 8607 'enum target_xfer_status' value). Save the number of addressable units 8608 transferred in *XFERED_LEN_UNITS. Only transfer a single packet. 8609 8610 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an 8611 exchange between gdb and the stub could look like (?? in place of the 8612 checksum): 8613 8614 -> $m1000,4#?? 8615 <- aaaabbbbccccdddd 8616 8617 -> $M1000,3:eeeeffffeeee#?? 8618 <- OK 8619 8620 -> $m1000,4#?? 8621 <- eeeeffffeeeedddd */ 8622 8623target_xfer_status 8624remote_target::remote_write_bytes_aux (const char *header, CORE_ADDR memaddr, 8625 const gdb_byte *myaddr, 8626 ULONGEST len_units, 8627 int unit_size, 8628 ULONGEST *xfered_len_units, 8629 char packet_format, int use_length) 8630{ 8631 struct remote_state *rs = get_remote_state (); 8632 char *p; 8633 char *plen = NULL; 8634 int plenlen = 0; 8635 int todo_units; 8636 int units_written; 8637 int payload_capacity_bytes; 8638 int payload_length_bytes; 8639 8640 if (packet_format != 'X' && packet_format != 'M') 8641 internal_error (__FILE__, __LINE__, 8642 _("remote_write_bytes_aux: bad packet format")); 8643 8644 if (len_units == 0) 8645 return TARGET_XFER_EOF; 8646 8647 payload_capacity_bytes = get_memory_write_packet_size (); 8648 8649 /* The packet buffer will be large enough for the payload; 8650 get_memory_packet_size ensures this. */ 8651 rs->buf[0] = '\0'; 8652 8653 /* Compute the size of the actual payload by subtracting out the 8654 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */ 8655 8656 payload_capacity_bytes -= strlen ("$,:#NN"); 8657 if (!use_length) 8658 /* The comma won't be used. */ 8659 payload_capacity_bytes += 1; 8660 payload_capacity_bytes -= strlen (header); 8661 payload_capacity_bytes -= hexnumlen (memaddr); 8662 8663 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */ 8664 8665 strcat (rs->buf.data (), header); 8666 p = rs->buf.data () + strlen (header); 8667 8668 /* Compute a best guess of the number of bytes actually transfered. */ 8669 if (packet_format == 'X') 8670 { 8671 /* Best guess at number of bytes that will fit. */ 8672 todo_units = std::min (len_units, 8673 (ULONGEST) payload_capacity_bytes / unit_size); 8674 if (use_length) 8675 payload_capacity_bytes -= hexnumlen (todo_units); 8676 todo_units = std::min (todo_units, payload_capacity_bytes / unit_size); 8677 } 8678 else 8679 { 8680 /* Number of bytes that will fit. */ 8681 todo_units 8682 = std::min (len_units, 8683 (ULONGEST) (payload_capacity_bytes / unit_size) / 2); 8684 if (use_length) 8685 payload_capacity_bytes -= hexnumlen (todo_units); 8686 todo_units = std::min (todo_units, 8687 (payload_capacity_bytes / unit_size) / 2); 8688 } 8689 8690 if (todo_units <= 0) 8691 internal_error (__FILE__, __LINE__, 8692 _("minimum packet size too small to write data")); 8693 8694 /* If we already need another packet, then try to align the end 8695 of this packet to a useful boundary. */ 8696 if (todo_units > 2 * REMOTE_ALIGN_WRITES && todo_units < len_units) 8697 todo_units = align_for_efficient_write (todo_units, memaddr); 8698 8699 /* Append "<memaddr>". */ 8700 memaddr = remote_address_masked (memaddr); 8701 p += hexnumstr (p, (ULONGEST) memaddr); 8702 8703 if (use_length) 8704 { 8705 /* Append ",". */ 8706 *p++ = ','; 8707 8708 /* Append the length and retain its location and size. It may need to be 8709 adjusted once the packet body has been created. */ 8710 plen = p; 8711 plenlen = hexnumstr (p, (ULONGEST) todo_units); 8712 p += plenlen; 8713 } 8714 8715 /* Append ":". */ 8716 *p++ = ':'; 8717 *p = '\0'; 8718 8719 /* Append the packet body. */ 8720 if (packet_format == 'X') 8721 { 8722 /* Binary mode. Send target system values byte by byte, in 8723 increasing byte addresses. Only escape certain critical 8724 characters. */ 8725 payload_length_bytes = 8726 remote_escape_output (myaddr, todo_units, unit_size, (gdb_byte *) p, 8727 &units_written, payload_capacity_bytes); 8728 8729 /* If not all TODO units fit, then we'll need another packet. Make 8730 a second try to keep the end of the packet aligned. Don't do 8731 this if the packet is tiny. */ 8732 if (units_written < todo_units && units_written > 2 * REMOTE_ALIGN_WRITES) 8733 { 8734 int new_todo_units; 8735 8736 new_todo_units = align_for_efficient_write (units_written, memaddr); 8737 8738 if (new_todo_units != units_written) 8739 payload_length_bytes = 8740 remote_escape_output (myaddr, new_todo_units, unit_size, 8741 (gdb_byte *) p, &units_written, 8742 payload_capacity_bytes); 8743 } 8744 8745 p += payload_length_bytes; 8746 if (use_length && units_written < todo_units) 8747 { 8748 /* Escape chars have filled up the buffer prematurely, 8749 and we have actually sent fewer units than planned. 8750 Fix-up the length field of the packet. Use the same 8751 number of characters as before. */ 8752 plen += hexnumnstr (plen, (ULONGEST) units_written, 8753 plenlen); 8754 *plen = ':'; /* overwrite \0 from hexnumnstr() */ 8755 } 8756 } 8757 else 8758 { 8759 /* Normal mode: Send target system values byte by byte, in 8760 increasing byte addresses. Each byte is encoded as a two hex 8761 value. */ 8762 p += 2 * bin2hex (myaddr, p, todo_units * unit_size); 8763 units_written = todo_units; 8764 } 8765 8766 putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ())); 8767 getpkt (&rs->buf, 0); 8768 8769 if (rs->buf[0] == 'E') 8770 return TARGET_XFER_E_IO; 8771 8772 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to 8773 send fewer units than we'd planned. */ 8774 *xfered_len_units = (ULONGEST) units_written; 8775 return (*xfered_len_units != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF; 8776} 8777 8778/* Write memory data directly to the remote machine. 8779 This does not inform the data cache; the data cache uses this. 8780 MEMADDR is the address in the remote memory space. 8781 MYADDR is the address of the buffer in our space. 8782 LEN is the number of bytes. 8783 8784 Return the transferred status, error or OK (an 8785 'enum target_xfer_status' value). Save the number of bytes 8786 transferred in *XFERED_LEN. Only transfer a single packet. */ 8787 8788target_xfer_status 8789remote_target::remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, 8790 ULONGEST len, int unit_size, 8791 ULONGEST *xfered_len) 8792{ 8793 const char *packet_format = NULL; 8794 8795 /* Check whether the target supports binary download. */ 8796 check_binary_download (memaddr); 8797 8798 switch (packet_support (PACKET_X)) 8799 { 8800 case PACKET_ENABLE: 8801 packet_format = "X"; 8802 break; 8803 case PACKET_DISABLE: 8804 packet_format = "M"; 8805 break; 8806 case PACKET_SUPPORT_UNKNOWN: 8807 internal_error (__FILE__, __LINE__, 8808 _("remote_write_bytes: bad internal state")); 8809 default: 8810 internal_error (__FILE__, __LINE__, _("bad switch")); 8811 } 8812 8813 return remote_write_bytes_aux (packet_format, 8814 memaddr, myaddr, len, unit_size, xfered_len, 8815 packet_format[0], 1); 8816} 8817 8818/* Read memory data directly from the remote machine. 8819 This does not use the data cache; the data cache uses this. 8820 MEMADDR is the address in the remote memory space. 8821 MYADDR is the address of the buffer in our space. 8822 LEN_UNITS is the number of addressable memory units to read.. 8823 UNIT_SIZE is the length in bytes of an addressable unit. 8824 8825 Return the transferred status, error or OK (an 8826 'enum target_xfer_status' value). Save the number of bytes 8827 transferred in *XFERED_LEN_UNITS. 8828 8829 See the comment of remote_write_bytes_aux for an example of 8830 memory read/write exchange between gdb and the stub. */ 8831 8832target_xfer_status 8833remote_target::remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr, 8834 ULONGEST len_units, 8835 int unit_size, ULONGEST *xfered_len_units) 8836{ 8837 struct remote_state *rs = get_remote_state (); 8838 int buf_size_bytes; /* Max size of packet output buffer. */ 8839 char *p; 8840 int todo_units; 8841 int decoded_bytes; 8842 8843 buf_size_bytes = get_memory_read_packet_size (); 8844 /* The packet buffer will be large enough for the payload; 8845 get_memory_packet_size ensures this. */ 8846 8847 /* Number of units that will fit. */ 8848 todo_units = std::min (len_units, 8849 (ULONGEST) (buf_size_bytes / unit_size) / 2); 8850 8851 /* Construct "m"<memaddr>","<len>". */ 8852 memaddr = remote_address_masked (memaddr); 8853 p = rs->buf.data (); 8854 *p++ = 'm'; 8855 p += hexnumstr (p, (ULONGEST) memaddr); 8856 *p++ = ','; 8857 p += hexnumstr (p, (ULONGEST) todo_units); 8858 *p = '\0'; 8859 putpkt (rs->buf); 8860 getpkt (&rs->buf, 0); 8861 if (rs->buf[0] == 'E' 8862 && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2]) 8863 && rs->buf[3] == '\0') 8864 return TARGET_XFER_E_IO; 8865 /* Reply describes memory byte by byte, each byte encoded as two hex 8866 characters. */ 8867 p = rs->buf.data (); 8868 decoded_bytes = hex2bin (p, myaddr, todo_units * unit_size); 8869 /* Return what we have. Let higher layers handle partial reads. */ 8870 *xfered_len_units = (ULONGEST) (decoded_bytes / unit_size); 8871 return (*xfered_len_units != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF; 8872} 8873 8874/* Using the set of read-only target sections of remote, read live 8875 read-only memory. 8876 8877 For interface/parameters/return description see target.h, 8878 to_xfer_partial. */ 8879 8880target_xfer_status 8881remote_target::remote_xfer_live_readonly_partial (gdb_byte *readbuf, 8882 ULONGEST memaddr, 8883 ULONGEST len, 8884 int unit_size, 8885 ULONGEST *xfered_len) 8886{ 8887 struct target_section *secp; 8888 struct target_section_table *table; 8889 8890 secp = target_section_by_addr (this, memaddr); 8891 if (secp != NULL 8892 && (bfd_section_flags (secp->the_bfd_section) & SEC_READONLY)) 8893 { 8894 struct target_section *p; 8895 ULONGEST memend = memaddr + len; 8896 8897 table = target_get_section_table (this); 8898 8899 for (p = table->sections; p < table->sections_end; p++) 8900 { 8901 if (memaddr >= p->addr) 8902 { 8903 if (memend <= p->endaddr) 8904 { 8905 /* Entire transfer is within this section. */ 8906 return remote_read_bytes_1 (memaddr, readbuf, len, unit_size, 8907 xfered_len); 8908 } 8909 else if (memaddr >= p->endaddr) 8910 { 8911 /* This section ends before the transfer starts. */ 8912 continue; 8913 } 8914 else 8915 { 8916 /* This section overlaps the transfer. Just do half. */ 8917 len = p->endaddr - memaddr; 8918 return remote_read_bytes_1 (memaddr, readbuf, len, unit_size, 8919 xfered_len); 8920 } 8921 } 8922 } 8923 } 8924 8925 return TARGET_XFER_EOF; 8926} 8927 8928/* Similar to remote_read_bytes_1, but it reads from the remote stub 8929 first if the requested memory is unavailable in traceframe. 8930 Otherwise, fall back to remote_read_bytes_1. */ 8931 8932target_xfer_status 8933remote_target::remote_read_bytes (CORE_ADDR memaddr, 8934 gdb_byte *myaddr, ULONGEST len, int unit_size, 8935 ULONGEST *xfered_len) 8936{ 8937 if (len == 0) 8938 return TARGET_XFER_EOF; 8939 8940 if (get_traceframe_number () != -1) 8941 { 8942 std::vector<mem_range> available; 8943 8944 /* If we fail to get the set of available memory, then the 8945 target does not support querying traceframe info, and so we 8946 attempt reading from the traceframe anyway (assuming the 8947 target implements the old QTro packet then). */ 8948 if (traceframe_available_memory (&available, memaddr, len)) 8949 { 8950 if (available.empty () || available[0].start != memaddr) 8951 { 8952 enum target_xfer_status res; 8953 8954 /* Don't read into the traceframe's available 8955 memory. */ 8956 if (!available.empty ()) 8957 { 8958 LONGEST oldlen = len; 8959 8960 len = available[0].start - memaddr; 8961 gdb_assert (len <= oldlen); 8962 } 8963 8964 /* This goes through the topmost target again. */ 8965 res = remote_xfer_live_readonly_partial (myaddr, memaddr, 8966 len, unit_size, xfered_len); 8967 if (res == TARGET_XFER_OK) 8968 return TARGET_XFER_OK; 8969 else 8970 { 8971 /* No use trying further, we know some memory starting 8972 at MEMADDR isn't available. */ 8973 *xfered_len = len; 8974 return (*xfered_len != 0) ? 8975 TARGET_XFER_UNAVAILABLE : TARGET_XFER_EOF; 8976 } 8977 } 8978 8979 /* Don't try to read more than how much is available, in 8980 case the target implements the deprecated QTro packet to 8981 cater for older GDBs (the target's knowledge of read-only 8982 sections may be outdated by now). */ 8983 len = available[0].length; 8984 } 8985 } 8986 8987 return remote_read_bytes_1 (memaddr, myaddr, len, unit_size, xfered_len); 8988} 8989 8990 8991 8992/* Sends a packet with content determined by the printf format string 8993 FORMAT and the remaining arguments, then gets the reply. Returns 8994 whether the packet was a success, a failure, or unknown. */ 8995 8996packet_result 8997remote_target::remote_send_printf (const char *format, ...) 8998{ 8999 struct remote_state *rs = get_remote_state (); 9000 int max_size = get_remote_packet_size (); 9001 va_list ap; 9002 9003 va_start (ap, format); 9004 9005 rs->buf[0] = '\0'; 9006 int size = vsnprintf (rs->buf.data (), max_size, format, ap); 9007 9008 va_end (ap); 9009 9010 if (size >= max_size) 9011 internal_error (__FILE__, __LINE__, _("Too long remote packet.")); 9012 9013 if (putpkt (rs->buf) < 0) 9014 error (_("Communication problem with target.")); 9015 9016 rs->buf[0] = '\0'; 9017 getpkt (&rs->buf, 0); 9018 9019 return packet_check_result (rs->buf); 9020} 9021 9022/* Flash writing can take quite some time. We'll set 9023 effectively infinite timeout for flash operations. 9024 In future, we'll need to decide on a better approach. */ 9025static const int remote_flash_timeout = 1000; 9026 9027void 9028remote_target::flash_erase (ULONGEST address, LONGEST length) 9029{ 9030 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; 9031 enum packet_result ret; 9032 scoped_restore restore_timeout 9033 = make_scoped_restore (&remote_timeout, remote_flash_timeout); 9034 9035 ret = remote_send_printf ("vFlashErase:%s,%s", 9036 phex (address, addr_size), 9037 phex (length, 4)); 9038 switch (ret) 9039 { 9040 case PACKET_UNKNOWN: 9041 error (_("Remote target does not support flash erase")); 9042 case PACKET_ERROR: 9043 error (_("Error erasing flash with vFlashErase packet")); 9044 default: 9045 break; 9046 } 9047} 9048 9049target_xfer_status 9050remote_target::remote_flash_write (ULONGEST address, 9051 ULONGEST length, ULONGEST *xfered_len, 9052 const gdb_byte *data) 9053{ 9054 scoped_restore restore_timeout 9055 = make_scoped_restore (&remote_timeout, remote_flash_timeout); 9056 return remote_write_bytes_aux ("vFlashWrite:", address, data, length, 1, 9057 xfered_len,'X', 0); 9058} 9059 9060void 9061remote_target::flash_done () 9062{ 9063 int ret; 9064 9065 scoped_restore restore_timeout 9066 = make_scoped_restore (&remote_timeout, remote_flash_timeout); 9067 9068 ret = remote_send_printf ("vFlashDone"); 9069 9070 switch (ret) 9071 { 9072 case PACKET_UNKNOWN: 9073 error (_("Remote target does not support vFlashDone")); 9074 case PACKET_ERROR: 9075 error (_("Error finishing flash operation")); 9076 default: 9077 break; 9078 } 9079} 9080 9081void 9082remote_target::files_info () 9083{ 9084 puts_filtered ("Debugging a target over a serial line.\n"); 9085} 9086 9087/* Stuff for dealing with the packets which are part of this protocol. 9088 See comment at top of file for details. */ 9089 9090/* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR 9091 error to higher layers. Called when a serial error is detected. 9092 The exception message is STRING, followed by a colon and a blank, 9093 the system error message for errno at function entry and final dot 9094 for output compatibility with throw_perror_with_name. */ 9095 9096static void 9097unpush_and_perror (remote_target *target, const char *string) 9098{ 9099 int saved_errno = errno; 9100 9101 remote_unpush_target (target); 9102 throw_error (TARGET_CLOSE_ERROR, "%s: %s.", string, 9103 safe_strerror (saved_errno)); 9104} 9105 9106/* Read a single character from the remote end. The current quit 9107 handler is overridden to avoid quitting in the middle of packet 9108 sequence, as that would break communication with the remote server. 9109 See remote_serial_quit_handler for more detail. */ 9110 9111int 9112remote_target::readchar (int timeout) 9113{ 9114 int ch; 9115 struct remote_state *rs = get_remote_state (); 9116 9117 { 9118 scoped_restore restore_quit_target 9119 = make_scoped_restore (&curr_quit_handler_target, this); 9120 scoped_restore restore_quit 9121 = make_scoped_restore (&quit_handler, ::remote_serial_quit_handler); 9122 9123 rs->got_ctrlc_during_io = 0; 9124 9125 ch = serial_readchar (rs->remote_desc, timeout); 9126 9127 if (rs->got_ctrlc_during_io) 9128 set_quit_flag (); 9129 } 9130 9131 if (ch >= 0) 9132 return ch; 9133 9134 switch ((enum serial_rc) ch) 9135 { 9136 case SERIAL_EOF: 9137 remote_unpush_target (this); 9138 throw_error (TARGET_CLOSE_ERROR, _("Remote connection closed")); 9139 /* no return */ 9140 case SERIAL_ERROR: 9141 unpush_and_perror (this, _("Remote communication error. " 9142 "Target disconnected.")); 9143 /* no return */ 9144 case SERIAL_TIMEOUT: 9145 break; 9146 } 9147 return ch; 9148} 9149 9150/* Wrapper for serial_write that closes the target and throws if 9151 writing fails. The current quit handler is overridden to avoid 9152 quitting in the middle of packet sequence, as that would break 9153 communication with the remote server. See 9154 remote_serial_quit_handler for more detail. */ 9155 9156void 9157remote_target::remote_serial_write (const char *str, int len) 9158{ 9159 struct remote_state *rs = get_remote_state (); 9160 9161 scoped_restore restore_quit_target 9162 = make_scoped_restore (&curr_quit_handler_target, this); 9163 scoped_restore restore_quit 9164 = make_scoped_restore (&quit_handler, ::remote_serial_quit_handler); 9165 9166 rs->got_ctrlc_during_io = 0; 9167 9168 if (serial_write (rs->remote_desc, str, len)) 9169 { 9170 unpush_and_perror (this, _("Remote communication error. " 9171 "Target disconnected.")); 9172 } 9173 9174 if (rs->got_ctrlc_during_io) 9175 set_quit_flag (); 9176} 9177 9178/* Return a string representing an escaped version of BUF, of len N. 9179 E.g. \n is converted to \\n, \t to \\t, etc. */ 9180 9181static std::string 9182escape_buffer (const char *buf, int n) 9183{ 9184 string_file stb; 9185 9186 stb.putstrn (buf, n, '\\'); 9187 return std::move (stb.string ()); 9188} 9189 9190/* Display a null-terminated packet on stdout, for debugging, using C 9191 string notation. */ 9192 9193static void 9194print_packet (const char *buf) 9195{ 9196 puts_filtered ("\""); 9197 fputstr_filtered (buf, '"', gdb_stdout); 9198 puts_filtered ("\""); 9199} 9200 9201int 9202remote_target::putpkt (const char *buf) 9203{ 9204 return putpkt_binary (buf, strlen (buf)); 9205} 9206 9207/* Wrapper around remote_target::putpkt to avoid exporting 9208 remote_target. */ 9209 9210int 9211putpkt (remote_target *remote, const char *buf) 9212{ 9213 return remote->putpkt (buf); 9214} 9215 9216/* Send a packet to the remote machine, with error checking. The data 9217 of the packet is in BUF. The string in BUF can be at most 9218 get_remote_packet_size () - 5 to account for the $, # and checksum, 9219 and for a possible /0 if we are debugging (remote_debug) and want 9220 to print the sent packet as a string. */ 9221 9222int 9223remote_target::putpkt_binary (const char *buf, int cnt) 9224{ 9225 struct remote_state *rs = get_remote_state (); 9226 int i; 9227 unsigned char csum = 0; 9228 gdb::def_vector<char> data (cnt + 6); 9229 char *buf2 = data.data (); 9230 9231 int ch; 9232 int tcount = 0; 9233 char *p; 9234 9235 /* Catch cases like trying to read memory or listing threads while 9236 we're waiting for a stop reply. The remote server wouldn't be 9237 ready to handle this request, so we'd hang and timeout. We don't 9238 have to worry about this in synchronous mode, because in that 9239 case it's not possible to issue a command while the target is 9240 running. This is not a problem in non-stop mode, because in that 9241 case, the stub is always ready to process serial input. */ 9242 if (!target_is_non_stop_p () 9243 && target_is_async_p () 9244 && rs->waiting_for_stop_reply) 9245 { 9246 error (_("Cannot execute this command while the target is running.\n" 9247 "Use the \"interrupt\" command to stop the target\n" 9248 "and then try again.")); 9249 } 9250 9251 /* We're sending out a new packet. Make sure we don't look at a 9252 stale cached response. */ 9253 rs->cached_wait_status = 0; 9254 9255 /* Copy the packet into buffer BUF2, encapsulating it 9256 and giving it a checksum. */ 9257 9258 p = buf2; 9259 *p++ = '$'; 9260 9261 for (i = 0; i < cnt; i++) 9262 { 9263 csum += buf[i]; 9264 *p++ = buf[i]; 9265 } 9266 *p++ = '#'; 9267 *p++ = tohex ((csum >> 4) & 0xf); 9268 *p++ = tohex (csum & 0xf); 9269 9270 /* Send it over and over until we get a positive ack. */ 9271 9272 while (1) 9273 { 9274 int started_error_output = 0; 9275 9276 if (remote_debug) 9277 { 9278 *p = '\0'; 9279 9280 int len = (int) (p - buf2); 9281 int max_chars; 9282 9283 if (remote_packet_max_chars < 0) 9284 max_chars = len; 9285 else 9286 max_chars = remote_packet_max_chars; 9287 9288 std::string str 9289 = escape_buffer (buf2, std::min (len, max_chars)); 9290 9291 fprintf_unfiltered (gdb_stdlog, "Sending packet: %s", str.c_str ()); 9292 9293 if (len > max_chars) 9294 fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]", 9295 len - max_chars); 9296 9297 fprintf_unfiltered (gdb_stdlog, "..."); 9298 9299 gdb_flush (gdb_stdlog); 9300 } 9301 remote_serial_write (buf2, p - buf2); 9302 9303 /* If this is a no acks version of the remote protocol, send the 9304 packet and move on. */ 9305 if (rs->noack_mode) 9306 break; 9307 9308 /* Read until either a timeout occurs (-2) or '+' is read. 9309 Handle any notification that arrives in the mean time. */ 9310 while (1) 9311 { 9312 ch = readchar (remote_timeout); 9313 9314 if (remote_debug) 9315 { 9316 switch (ch) 9317 { 9318 case '+': 9319 case '-': 9320 case SERIAL_TIMEOUT: 9321 case '$': 9322 case '%': 9323 if (started_error_output) 9324 { 9325 putchar_unfiltered ('\n'); 9326 started_error_output = 0; 9327 } 9328 } 9329 } 9330 9331 switch (ch) 9332 { 9333 case '+': 9334 if (remote_debug) 9335 fprintf_unfiltered (gdb_stdlog, "Ack\n"); 9336 return 1; 9337 case '-': 9338 if (remote_debug) 9339 fprintf_unfiltered (gdb_stdlog, "Nak\n"); 9340 /* FALLTHROUGH */ 9341 case SERIAL_TIMEOUT: 9342 tcount++; 9343 if (tcount > 3) 9344 return 0; 9345 break; /* Retransmit buffer. */ 9346 case '$': 9347 { 9348 if (remote_debug) 9349 fprintf_unfiltered (gdb_stdlog, 9350 "Packet instead of Ack, ignoring it\n"); 9351 /* It's probably an old response sent because an ACK 9352 was lost. Gobble up the packet and ack it so it 9353 doesn't get retransmitted when we resend this 9354 packet. */ 9355 skip_frame (); 9356 remote_serial_write ("+", 1); 9357 continue; /* Now, go look for +. */ 9358 } 9359 9360 case '%': 9361 { 9362 int val; 9363 9364 /* If we got a notification, handle it, and go back to looking 9365 for an ack. */ 9366 /* We've found the start of a notification. Now 9367 collect the data. */ 9368 val = read_frame (&rs->buf); 9369 if (val >= 0) 9370 { 9371 if (remote_debug) 9372 { 9373 std::string str = escape_buffer (rs->buf.data (), val); 9374 9375 fprintf_unfiltered (gdb_stdlog, 9376 " Notification received: %s\n", 9377 str.c_str ()); 9378 } 9379 handle_notification (rs->notif_state, rs->buf.data ()); 9380 /* We're in sync now, rewait for the ack. */ 9381 tcount = 0; 9382 } 9383 else 9384 { 9385 if (remote_debug) 9386 { 9387 if (!started_error_output) 9388 { 9389 started_error_output = 1; 9390 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: "); 9391 } 9392 fputc_unfiltered (ch & 0177, gdb_stdlog); 9393 fprintf_unfiltered (gdb_stdlog, "%s", rs->buf.data ()); 9394 } 9395 } 9396 continue; 9397 } 9398 /* fall-through */ 9399 default: 9400 if (remote_debug) 9401 { 9402 if (!started_error_output) 9403 { 9404 started_error_output = 1; 9405 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: "); 9406 } 9407 fputc_unfiltered (ch & 0177, gdb_stdlog); 9408 } 9409 continue; 9410 } 9411 break; /* Here to retransmit. */ 9412 } 9413 9414#if 0 9415 /* This is wrong. If doing a long backtrace, the user should be 9416 able to get out next time we call QUIT, without anything as 9417 violent as interrupt_query. If we want to provide a way out of 9418 here without getting to the next QUIT, it should be based on 9419 hitting ^C twice as in remote_wait. */ 9420 if (quit_flag) 9421 { 9422 quit_flag = 0; 9423 interrupt_query (); 9424 } 9425#endif 9426 } 9427 9428 return 0; 9429} 9430 9431/* Come here after finding the start of a frame when we expected an 9432 ack. Do our best to discard the rest of this packet. */ 9433 9434void 9435remote_target::skip_frame () 9436{ 9437 int c; 9438 9439 while (1) 9440 { 9441 c = readchar (remote_timeout); 9442 switch (c) 9443 { 9444 case SERIAL_TIMEOUT: 9445 /* Nothing we can do. */ 9446 return; 9447 case '#': 9448 /* Discard the two bytes of checksum and stop. */ 9449 c = readchar (remote_timeout); 9450 if (c >= 0) 9451 c = readchar (remote_timeout); 9452 9453 return; 9454 case '*': /* Run length encoding. */ 9455 /* Discard the repeat count. */ 9456 c = readchar (remote_timeout); 9457 if (c < 0) 9458 return; 9459 break; 9460 default: 9461 /* A regular character. */ 9462 break; 9463 } 9464 } 9465} 9466 9467/* Come here after finding the start of the frame. Collect the rest 9468 into *BUF, verifying the checksum, length, and handling run-length 9469 compression. NUL terminate the buffer. If there is not enough room, 9470 expand *BUF. 9471 9472 Returns -1 on error, number of characters in buffer (ignoring the 9473 trailing NULL) on success. (could be extended to return one of the 9474 SERIAL status indications). */ 9475 9476long 9477remote_target::read_frame (gdb::char_vector *buf_p) 9478{ 9479 unsigned char csum; 9480 long bc; 9481 int c; 9482 char *buf = buf_p->data (); 9483 struct remote_state *rs = get_remote_state (); 9484 9485 csum = 0; 9486 bc = 0; 9487 9488 while (1) 9489 { 9490 c = readchar (remote_timeout); 9491 switch (c) 9492 { 9493 case SERIAL_TIMEOUT: 9494 if (remote_debug) 9495 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog); 9496 return -1; 9497 case '$': 9498 if (remote_debug) 9499 fputs_filtered ("Saw new packet start in middle of old one\n", 9500 gdb_stdlog); 9501 return -1; /* Start a new packet, count retries. */ 9502 case '#': 9503 { 9504 unsigned char pktcsum; 9505 int check_0 = 0; 9506 int check_1 = 0; 9507 9508 buf[bc] = '\0'; 9509 9510 check_0 = readchar (remote_timeout); 9511 if (check_0 >= 0) 9512 check_1 = readchar (remote_timeout); 9513 9514 if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT) 9515 { 9516 if (remote_debug) 9517 fputs_filtered ("Timeout in checksum, retrying\n", 9518 gdb_stdlog); 9519 return -1; 9520 } 9521 else if (check_0 < 0 || check_1 < 0) 9522 { 9523 if (remote_debug) 9524 fputs_filtered ("Communication error in checksum\n", 9525 gdb_stdlog); 9526 return -1; 9527 } 9528 9529 /* Don't recompute the checksum; with no ack packets we 9530 don't have any way to indicate a packet retransmission 9531 is necessary. */ 9532 if (rs->noack_mode) 9533 return bc; 9534 9535 pktcsum = (fromhex (check_0) << 4) | fromhex (check_1); 9536 if (csum == pktcsum) 9537 return bc; 9538 9539 if (remote_debug) 9540 { 9541 std::string str = escape_buffer (buf, bc); 9542 9543 fprintf_unfiltered (gdb_stdlog, 9544 "Bad checksum, sentsum=0x%x, " 9545 "csum=0x%x, buf=%s\n", 9546 pktcsum, csum, str.c_str ()); 9547 } 9548 /* Number of characters in buffer ignoring trailing 9549 NULL. */ 9550 return -1; 9551 } 9552 case '*': /* Run length encoding. */ 9553 { 9554 int repeat; 9555 9556 csum += c; 9557 c = readchar (remote_timeout); 9558 csum += c; 9559 repeat = c - ' ' + 3; /* Compute repeat count. */ 9560 9561 /* The character before ``*'' is repeated. */ 9562 9563 if (repeat > 0 && repeat <= 255 && bc > 0) 9564 { 9565 if (bc + repeat - 1 >= buf_p->size () - 1) 9566 { 9567 /* Make some more room in the buffer. */ 9568 buf_p->resize (buf_p->size () + repeat); 9569 buf = buf_p->data (); 9570 } 9571 9572 memset (&buf[bc], buf[bc - 1], repeat); 9573 bc += repeat; 9574 continue; 9575 } 9576 9577 buf[bc] = '\0'; 9578 printf_filtered (_("Invalid run length encoding: %s\n"), buf); 9579 return -1; 9580 } 9581 default: 9582 if (bc >= buf_p->size () - 1) 9583 { 9584 /* Make some more room in the buffer. */ 9585 buf_p->resize (buf_p->size () * 2); 9586 buf = buf_p->data (); 9587 } 9588 9589 buf[bc++] = c; 9590 csum += c; 9591 continue; 9592 } 9593 } 9594} 9595 9596/* Set this to the maximum number of seconds to wait instead of waiting forever 9597 in target_wait(). If this timer times out, then it generates an error and 9598 the command is aborted. This replaces most of the need for timeouts in the 9599 GDB test suite, and makes it possible to distinguish between a hung target 9600 and one with slow communications. */ 9601 9602static int watchdog = 0; 9603static void 9604show_watchdog (struct ui_file *file, int from_tty, 9605 struct cmd_list_element *c, const char *value) 9606{ 9607 fprintf_filtered (file, _("Watchdog timer is %s.\n"), value); 9608} 9609 9610/* Read a packet from the remote machine, with error checking, and 9611 store it in *BUF. Resize *BUF if necessary to hold the result. If 9612 FOREVER, wait forever rather than timing out; this is used (in 9613 synchronous mode) to wait for a target that is is executing user 9614 code to stop. */ 9615/* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we 9616 don't have to change all the calls to getpkt to deal with the 9617 return value, because at the moment I don't know what the right 9618 thing to do it for those. */ 9619 9620void 9621remote_target::getpkt (gdb::char_vector *buf, int forever) 9622{ 9623 getpkt_sane (buf, forever); 9624} 9625 9626 9627/* Read a packet from the remote machine, with error checking, and 9628 store it in *BUF. Resize *BUF if necessary to hold the result. If 9629 FOREVER, wait forever rather than timing out; this is used (in 9630 synchronous mode) to wait for a target that is is executing user 9631 code to stop. If FOREVER == 0, this function is allowed to time 9632 out gracefully and return an indication of this to the caller. 9633 Otherwise return the number of bytes read. If EXPECTING_NOTIF, 9634 consider receiving a notification enough reason to return to the 9635 caller. *IS_NOTIF is an output boolean that indicates whether *BUF 9636 holds a notification or not (a regular packet). */ 9637 9638int 9639remote_target::getpkt_or_notif_sane_1 (gdb::char_vector *buf, 9640 int forever, int expecting_notif, 9641 int *is_notif) 9642{ 9643 struct remote_state *rs = get_remote_state (); 9644 int c; 9645 int tries; 9646 int timeout; 9647 int val = -1; 9648 9649 /* We're reading a new response. Make sure we don't look at a 9650 previously cached response. */ 9651 rs->cached_wait_status = 0; 9652 9653 strcpy (buf->data (), "timeout"); 9654 9655 if (forever) 9656 timeout = watchdog > 0 ? watchdog : -1; 9657 else if (expecting_notif) 9658 timeout = 0; /* There should already be a char in the buffer. If 9659 not, bail out. */ 9660 else 9661 timeout = remote_timeout; 9662 9663#define MAX_TRIES 3 9664 9665 /* Process any number of notifications, and then return when 9666 we get a packet. */ 9667 for (;;) 9668 { 9669 /* If we get a timeout or bad checksum, retry up to MAX_TRIES 9670 times. */ 9671 for (tries = 1; tries <= MAX_TRIES; tries++) 9672 { 9673 /* This can loop forever if the remote side sends us 9674 characters continuously, but if it pauses, we'll get 9675 SERIAL_TIMEOUT from readchar because of timeout. Then 9676 we'll count that as a retry. 9677 9678 Note that even when forever is set, we will only wait 9679 forever prior to the start of a packet. After that, we 9680 expect characters to arrive at a brisk pace. They should 9681 show up within remote_timeout intervals. */ 9682 do 9683 c = readchar (timeout); 9684 while (c != SERIAL_TIMEOUT && c != '$' && c != '%'); 9685 9686 if (c == SERIAL_TIMEOUT) 9687 { 9688 if (expecting_notif) 9689 return -1; /* Don't complain, it's normal to not get 9690 anything in this case. */ 9691 9692 if (forever) /* Watchdog went off? Kill the target. */ 9693 { 9694 remote_unpush_target (this); 9695 throw_error (TARGET_CLOSE_ERROR, 9696 _("Watchdog timeout has expired. " 9697 "Target detached.")); 9698 } 9699 if (remote_debug) 9700 fputs_filtered ("Timed out.\n", gdb_stdlog); 9701 } 9702 else 9703 { 9704 /* We've found the start of a packet or notification. 9705 Now collect the data. */ 9706 val = read_frame (buf); 9707 if (val >= 0) 9708 break; 9709 } 9710 9711 remote_serial_write ("-", 1); 9712 } 9713 9714 if (tries > MAX_TRIES) 9715 { 9716 /* We have tried hard enough, and just can't receive the 9717 packet/notification. Give up. */ 9718 printf_unfiltered (_("Ignoring packet error, continuing...\n")); 9719 9720 /* Skip the ack char if we're in no-ack mode. */ 9721 if (!rs->noack_mode) 9722 remote_serial_write ("+", 1); 9723 return -1; 9724 } 9725 9726 /* If we got an ordinary packet, return that to our caller. */ 9727 if (c == '$') 9728 { 9729 if (remote_debug) 9730 { 9731 int max_chars; 9732 9733 if (remote_packet_max_chars < 0) 9734 max_chars = val; 9735 else 9736 max_chars = remote_packet_max_chars; 9737 9738 std::string str 9739 = escape_buffer (buf->data (), 9740 std::min (val, max_chars)); 9741 9742 fprintf_unfiltered (gdb_stdlog, "Packet received: %s", 9743 str.c_str ()); 9744 9745 if (val > max_chars) 9746 fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]", 9747 val - max_chars); 9748 9749 fprintf_unfiltered (gdb_stdlog, "\n"); 9750 } 9751 9752 /* Skip the ack char if we're in no-ack mode. */ 9753 if (!rs->noack_mode) 9754 remote_serial_write ("+", 1); 9755 if (is_notif != NULL) 9756 *is_notif = 0; 9757 return val; 9758 } 9759 9760 /* If we got a notification, handle it, and go back to looking 9761 for a packet. */ 9762 else 9763 { 9764 gdb_assert (c == '%'); 9765 9766 if (remote_debug) 9767 { 9768 std::string str = escape_buffer (buf->data (), val); 9769 9770 fprintf_unfiltered (gdb_stdlog, 9771 " Notification received: %s\n", 9772 str.c_str ()); 9773 } 9774 if (is_notif != NULL) 9775 *is_notif = 1; 9776 9777 handle_notification (rs->notif_state, buf->data ()); 9778 9779 /* Notifications require no acknowledgement. */ 9780 9781 if (expecting_notif) 9782 return val; 9783 } 9784 } 9785} 9786 9787int 9788remote_target::getpkt_sane (gdb::char_vector *buf, int forever) 9789{ 9790 return getpkt_or_notif_sane_1 (buf, forever, 0, NULL); 9791} 9792 9793int 9794remote_target::getpkt_or_notif_sane (gdb::char_vector *buf, int forever, 9795 int *is_notif) 9796{ 9797 return getpkt_or_notif_sane_1 (buf, forever, 1, is_notif); 9798} 9799 9800/* Kill any new fork children of process PID that haven't been 9801 processed by follow_fork. */ 9802 9803void 9804remote_target::kill_new_fork_children (int pid) 9805{ 9806 remote_state *rs = get_remote_state (); 9807 struct notif_client *notif = ¬if_client_stop; 9808 9809 /* Kill the fork child threads of any threads in process PID 9810 that are stopped at a fork event. */ 9811 for (thread_info *thread : all_non_exited_threads (this)) 9812 { 9813 struct target_waitstatus *ws = &thread->pending_follow; 9814 9815 if (is_pending_fork_parent (ws, pid, thread->ptid)) 9816 { 9817 int child_pid = ws->value.related_pid.pid (); 9818 int res; 9819 9820 res = remote_vkill (child_pid); 9821 if (res != 0) 9822 error (_("Can't kill fork child process %d"), child_pid); 9823 } 9824 } 9825 9826 /* Check for any pending fork events (not reported or processed yet) 9827 in process PID and kill those fork child threads as well. */ 9828 remote_notif_get_pending_events (notif); 9829 for (auto &event : rs->stop_reply_queue) 9830 if (is_pending_fork_parent (&event->ws, pid, event->ptid)) 9831 { 9832 int child_pid = event->ws.value.related_pid.pid (); 9833 int res; 9834 9835 res = remote_vkill (child_pid); 9836 if (res != 0) 9837 error (_("Can't kill fork child process %d"), child_pid); 9838 } 9839} 9840 9841 9842/* Target hook to kill the current inferior. */ 9843 9844void 9845remote_target::kill () 9846{ 9847 int res = -1; 9848 int pid = inferior_ptid.pid (); 9849 struct remote_state *rs = get_remote_state (); 9850 9851 if (packet_support (PACKET_vKill) != PACKET_DISABLE) 9852 { 9853 /* If we're stopped while forking and we haven't followed yet, 9854 kill the child task. We need to do this before killing the 9855 parent task because if this is a vfork then the parent will 9856 be sleeping. */ 9857 kill_new_fork_children (pid); 9858 9859 res = remote_vkill (pid); 9860 if (res == 0) 9861 { 9862 target_mourn_inferior (inferior_ptid); 9863 return; 9864 } 9865 } 9866 9867 /* If we are in 'target remote' mode and we are killing the only 9868 inferior, then we will tell gdbserver to exit and unpush the 9869 target. */ 9870 if (res == -1 && !remote_multi_process_p (rs) 9871 && number_of_live_inferiors (this) == 1) 9872 { 9873 remote_kill_k (); 9874 9875 /* We've killed the remote end, we get to mourn it. If we are 9876 not in extended mode, mourning the inferior also unpushes 9877 remote_ops from the target stack, which closes the remote 9878 connection. */ 9879 target_mourn_inferior (inferior_ptid); 9880 9881 return; 9882 } 9883 9884 error (_("Can't kill process")); 9885} 9886 9887/* Send a kill request to the target using the 'vKill' packet. */ 9888 9889int 9890remote_target::remote_vkill (int pid) 9891{ 9892 if (packet_support (PACKET_vKill) == PACKET_DISABLE) 9893 return -1; 9894 9895 remote_state *rs = get_remote_state (); 9896 9897 /* Tell the remote target to detach. */ 9898 xsnprintf (rs->buf.data (), get_remote_packet_size (), "vKill;%x", pid); 9899 putpkt (rs->buf); 9900 getpkt (&rs->buf, 0); 9901 9902 switch (packet_ok (rs->buf, 9903 &remote_protocol_packets[PACKET_vKill])) 9904 { 9905 case PACKET_OK: 9906 return 0; 9907 case PACKET_ERROR: 9908 return 1; 9909 case PACKET_UNKNOWN: 9910 return -1; 9911 default: 9912 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok")); 9913 } 9914} 9915 9916/* Send a kill request to the target using the 'k' packet. */ 9917 9918void 9919remote_target::remote_kill_k () 9920{ 9921 /* Catch errors so the user can quit from gdb even when we 9922 aren't on speaking terms with the remote system. */ 9923 try 9924 { 9925 putpkt ("k"); 9926 } 9927 catch (const gdb_exception_error &ex) 9928 { 9929 if (ex.error == TARGET_CLOSE_ERROR) 9930 { 9931 /* If we got an (EOF) error that caused the target 9932 to go away, then we're done, that's what we wanted. 9933 "k" is susceptible to cause a premature EOF, given 9934 that the remote server isn't actually required to 9935 reply to "k", and it can happen that it doesn't 9936 even get to reply ACK to the "k". */ 9937 return; 9938 } 9939 9940 /* Otherwise, something went wrong. We didn't actually kill 9941 the target. Just propagate the exception, and let the 9942 user or higher layers decide what to do. */ 9943 throw; 9944 } 9945} 9946 9947void 9948remote_target::mourn_inferior () 9949{ 9950 struct remote_state *rs = get_remote_state (); 9951 9952 /* We're no longer interested in notification events of an inferior 9953 that exited or was killed/detached. */ 9954 discard_pending_stop_replies (current_inferior ()); 9955 9956 /* In 'target remote' mode with one inferior, we close the connection. */ 9957 if (!rs->extended && number_of_live_inferiors (this) <= 1) 9958 { 9959 remote_unpush_target (this); 9960 return; 9961 } 9962 9963 /* In case we got here due to an error, but we're going to stay 9964 connected. */ 9965 rs->waiting_for_stop_reply = 0; 9966 9967 /* If the current general thread belonged to the process we just 9968 detached from or has exited, the remote side current general 9969 thread becomes undefined. Considering a case like this: 9970 9971 - We just got here due to a detach. 9972 - The process that we're detaching from happens to immediately 9973 report a global breakpoint being hit in non-stop mode, in the 9974 same thread we had selected before. 9975 - GDB attaches to this process again. 9976 - This event happens to be the next event we handle. 9977 9978 GDB would consider that the current general thread didn't need to 9979 be set on the stub side (with Hg), since for all it knew, 9980 GENERAL_THREAD hadn't changed. 9981 9982 Notice that although in all-stop mode, the remote server always 9983 sets the current thread to the thread reporting the stop event, 9984 that doesn't happen in non-stop mode; in non-stop, the stub *must 9985 not* change the current thread when reporting a breakpoint hit, 9986 due to the decoupling of event reporting and event handling. 9987 9988 To keep things simple, we always invalidate our notion of the 9989 current thread. */ 9990 record_currthread (rs, minus_one_ptid); 9991 9992 /* Call common code to mark the inferior as not running. */ 9993 generic_mourn_inferior (); 9994} 9995 9996bool 9997extended_remote_target::supports_disable_randomization () 9998{ 9999 return packet_support (PACKET_QDisableRandomization) == PACKET_ENABLE; 10000} 10001 10002void 10003remote_target::extended_remote_disable_randomization (int val) 10004{ 10005 struct remote_state *rs = get_remote_state (); 10006 char *reply; 10007 10008 xsnprintf (rs->buf.data (), get_remote_packet_size (), 10009 "QDisableRandomization:%x", val); 10010 putpkt (rs->buf); 10011 reply = remote_get_noisy_reply (); 10012 if (*reply == '\0') 10013 error (_("Target does not support QDisableRandomization.")); 10014 if (strcmp (reply, "OK") != 0) 10015 error (_("Bogus QDisableRandomization reply from target: %s"), reply); 10016} 10017 10018int 10019remote_target::extended_remote_run (const std::string &args) 10020{ 10021 struct remote_state *rs = get_remote_state (); 10022 int len; 10023 const char *remote_exec_file = get_remote_exec_file (); 10024 10025 /* If the user has disabled vRun support, or we have detected that 10026 support is not available, do not try it. */ 10027 if (packet_support (PACKET_vRun) == PACKET_DISABLE) 10028 return -1; 10029 10030 strcpy (rs->buf.data (), "vRun;"); 10031 len = strlen (rs->buf.data ()); 10032 10033 if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ()) 10034 error (_("Remote file name too long for run packet")); 10035 len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf.data () + len, 10036 strlen (remote_exec_file)); 10037 10038 if (!args.empty ()) 10039 { 10040 int i; 10041 10042 gdb_argv argv (args.c_str ()); 10043 for (i = 0; argv[i] != NULL; i++) 10044 { 10045 if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ()) 10046 error (_("Argument list too long for run packet")); 10047 rs->buf[len++] = ';'; 10048 len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf.data () + len, 10049 strlen (argv[i])); 10050 } 10051 } 10052 10053 rs->buf[len++] = '\0'; 10054 10055 putpkt (rs->buf); 10056 getpkt (&rs->buf, 0); 10057 10058 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun])) 10059 { 10060 case PACKET_OK: 10061 /* We have a wait response. All is well. */ 10062 return 0; 10063 case PACKET_UNKNOWN: 10064 return -1; 10065 case PACKET_ERROR: 10066 if (remote_exec_file[0] == '\0') 10067 error (_("Running the default executable on the remote target failed; " 10068 "try \"set remote exec-file\"?")); 10069 else 10070 error (_("Running \"%s\" on the remote target failed"), 10071 remote_exec_file); 10072 default: 10073 gdb_assert_not_reached (_("bad switch")); 10074 } 10075} 10076 10077/* Helper function to send set/unset environment packets. ACTION is 10078 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded" 10079 or "QEnvironmentUnsetVariable". VALUE is the variable to be 10080 sent. */ 10081 10082void 10083remote_target::send_environment_packet (const char *action, 10084 const char *packet, 10085 const char *value) 10086{ 10087 remote_state *rs = get_remote_state (); 10088 10089 /* Convert the environment variable to an hex string, which 10090 is the best format to be transmitted over the wire. */ 10091 std::string encoded_value = bin2hex ((const gdb_byte *) value, 10092 strlen (value)); 10093 10094 xsnprintf (rs->buf.data (), get_remote_packet_size (), 10095 "%s:%s", packet, encoded_value.c_str ()); 10096 10097 putpkt (rs->buf); 10098 getpkt (&rs->buf, 0); 10099 if (strcmp (rs->buf.data (), "OK") != 0) 10100 warning (_("Unable to %s environment variable '%s' on remote."), 10101 action, value); 10102} 10103 10104/* Helper function to handle the QEnvironment* packets. */ 10105 10106void 10107remote_target::extended_remote_environment_support () 10108{ 10109 remote_state *rs = get_remote_state (); 10110 10111 if (packet_support (PACKET_QEnvironmentReset) != PACKET_DISABLE) 10112 { 10113 putpkt ("QEnvironmentReset"); 10114 getpkt (&rs->buf, 0); 10115 if (strcmp (rs->buf.data (), "OK") != 0) 10116 warning (_("Unable to reset environment on remote.")); 10117 } 10118 10119 gdb_environ *e = ¤t_inferior ()->environment; 10120 10121 if (packet_support (PACKET_QEnvironmentHexEncoded) != PACKET_DISABLE) 10122 for (const std::string &el : e->user_set_env ()) 10123 send_environment_packet ("set", "QEnvironmentHexEncoded", 10124 el.c_str ()); 10125 10126 if (packet_support (PACKET_QEnvironmentUnset) != PACKET_DISABLE) 10127 for (const std::string &el : e->user_unset_env ()) 10128 send_environment_packet ("unset", "QEnvironmentUnset", el.c_str ()); 10129} 10130 10131/* Helper function to set the current working directory for the 10132 inferior in the remote target. */ 10133 10134void 10135remote_target::extended_remote_set_inferior_cwd () 10136{ 10137 if (packet_support (PACKET_QSetWorkingDir) != PACKET_DISABLE) 10138 { 10139 const char *inferior_cwd = get_inferior_cwd (); 10140 remote_state *rs = get_remote_state (); 10141 10142 if (inferior_cwd != NULL) 10143 { 10144 std::string hexpath = bin2hex ((const gdb_byte *) inferior_cwd, 10145 strlen (inferior_cwd)); 10146 10147 xsnprintf (rs->buf.data (), get_remote_packet_size (), 10148 "QSetWorkingDir:%s", hexpath.c_str ()); 10149 } 10150 else 10151 { 10152 /* An empty inferior_cwd means that the user wants us to 10153 reset the remote server's inferior's cwd. */ 10154 xsnprintf (rs->buf.data (), get_remote_packet_size (), 10155 "QSetWorkingDir:"); 10156 } 10157 10158 putpkt (rs->buf); 10159 getpkt (&rs->buf, 0); 10160 if (packet_ok (rs->buf, 10161 &remote_protocol_packets[PACKET_QSetWorkingDir]) 10162 != PACKET_OK) 10163 error (_("\ 10164Remote replied unexpectedly while setting the inferior's working\n\ 10165directory: %s"), 10166 rs->buf.data ()); 10167 10168 } 10169} 10170 10171/* In the extended protocol we want to be able to do things like 10172 "run" and have them basically work as expected. So we need 10173 a special create_inferior function. We support changing the 10174 executable file and the command line arguments, but not the 10175 environment. */ 10176 10177void 10178extended_remote_target::create_inferior (const char *exec_file, 10179 const std::string &args, 10180 char **env, int from_tty) 10181{ 10182 int run_worked; 10183 char *stop_reply; 10184 struct remote_state *rs = get_remote_state (); 10185 const char *remote_exec_file = get_remote_exec_file (); 10186 10187 /* If running asynchronously, register the target file descriptor 10188 with the event loop. */ 10189 if (target_can_async_p ()) 10190 target_async (1); 10191 10192 /* Disable address space randomization if requested (and supported). */ 10193 if (supports_disable_randomization ()) 10194 extended_remote_disable_randomization (disable_randomization); 10195 10196 /* If startup-with-shell is on, we inform gdbserver to start the 10197 remote inferior using a shell. */ 10198 if (packet_support (PACKET_QStartupWithShell) != PACKET_DISABLE) 10199 { 10200 xsnprintf (rs->buf.data (), get_remote_packet_size (), 10201 "QStartupWithShell:%d", startup_with_shell ? 1 : 0); 10202 putpkt (rs->buf); 10203 getpkt (&rs->buf, 0); 10204 if (strcmp (rs->buf.data (), "OK") != 0) 10205 error (_("\ 10206Remote replied unexpectedly while setting startup-with-shell: %s"), 10207 rs->buf.data ()); 10208 } 10209 10210 extended_remote_environment_support (); 10211 10212 extended_remote_set_inferior_cwd (); 10213 10214 /* Now restart the remote server. */ 10215 run_worked = extended_remote_run (args) != -1; 10216 if (!run_worked) 10217 { 10218 /* vRun was not supported. Fail if we need it to do what the 10219 user requested. */ 10220 if (remote_exec_file[0]) 10221 error (_("Remote target does not support \"set remote exec-file\"")); 10222 if (!args.empty ()) 10223 error (_("Remote target does not support \"set args\" or run ARGS")); 10224 10225 /* Fall back to "R". */ 10226 extended_remote_restart (); 10227 } 10228 10229 /* vRun's success return is a stop reply. */ 10230 stop_reply = run_worked ? rs->buf.data () : NULL; 10231 add_current_inferior_and_thread (stop_reply); 10232 10233 /* Get updated offsets, if the stub uses qOffsets. */ 10234 get_offsets (); 10235} 10236 10237 10238/* Given a location's target info BP_TGT and the packet buffer BUF, output 10239 the list of conditions (in agent expression bytecode format), if any, the 10240 target needs to evaluate. The output is placed into the packet buffer 10241 started from BUF and ended at BUF_END. */ 10242 10243static int 10244remote_add_target_side_condition (struct gdbarch *gdbarch, 10245 struct bp_target_info *bp_tgt, char *buf, 10246 char *buf_end) 10247{ 10248 if (bp_tgt->conditions.empty ()) 10249 return 0; 10250 10251 buf += strlen (buf); 10252 xsnprintf (buf, buf_end - buf, "%s", ";"); 10253 buf++; 10254 10255 /* Send conditions to the target. */ 10256 for (agent_expr *aexpr : bp_tgt->conditions) 10257 { 10258 xsnprintf (buf, buf_end - buf, "X%x,", aexpr->len); 10259 buf += strlen (buf); 10260 for (int i = 0; i < aexpr->len; ++i) 10261 buf = pack_hex_byte (buf, aexpr->buf[i]); 10262 *buf = '\0'; 10263 } 10264 return 0; 10265} 10266 10267static void 10268remote_add_target_side_commands (struct gdbarch *gdbarch, 10269 struct bp_target_info *bp_tgt, char *buf) 10270{ 10271 if (bp_tgt->tcommands.empty ()) 10272 return; 10273 10274 buf += strlen (buf); 10275 10276 sprintf (buf, ";cmds:%x,", bp_tgt->persist); 10277 buf += strlen (buf); 10278 10279 /* Concatenate all the agent expressions that are commands into the 10280 cmds parameter. */ 10281 for (agent_expr *aexpr : bp_tgt->tcommands) 10282 { 10283 sprintf (buf, "X%x,", aexpr->len); 10284 buf += strlen (buf); 10285 for (int i = 0; i < aexpr->len; ++i) 10286 buf = pack_hex_byte (buf, aexpr->buf[i]); 10287 *buf = '\0'; 10288 } 10289} 10290 10291/* Insert a breakpoint. On targets that have software breakpoint 10292 support, we ask the remote target to do the work; on targets 10293 which don't, we insert a traditional memory breakpoint. */ 10294 10295int 10296remote_target::insert_breakpoint (struct gdbarch *gdbarch, 10297 struct bp_target_info *bp_tgt) 10298{ 10299 /* Try the "Z" s/w breakpoint packet if it is not already disabled. 10300 If it succeeds, then set the support to PACKET_ENABLE. If it 10301 fails, and the user has explicitly requested the Z support then 10302 report an error, otherwise, mark it disabled and go on. */ 10303 10304 if (packet_support (PACKET_Z0) != PACKET_DISABLE) 10305 { 10306 CORE_ADDR addr = bp_tgt->reqstd_address; 10307 struct remote_state *rs; 10308 char *p, *endbuf; 10309 10310 /* Make sure the remote is pointing at the right process, if 10311 necessary. */ 10312 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10313 set_general_process (); 10314 10315 rs = get_remote_state (); 10316 p = rs->buf.data (); 10317 endbuf = p + get_remote_packet_size (); 10318 10319 *(p++) = 'Z'; 10320 *(p++) = '0'; 10321 *(p++) = ','; 10322 addr = (ULONGEST) remote_address_masked (addr); 10323 p += hexnumstr (p, addr); 10324 xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind); 10325 10326 if (supports_evaluation_of_breakpoint_conditions ()) 10327 remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf); 10328 10329 if (can_run_breakpoint_commands ()) 10330 remote_add_target_side_commands (gdbarch, bp_tgt, p); 10331 10332 putpkt (rs->buf); 10333 getpkt (&rs->buf, 0); 10334 10335 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0])) 10336 { 10337 case PACKET_ERROR: 10338 return -1; 10339 case PACKET_OK: 10340 return 0; 10341 case PACKET_UNKNOWN: 10342 break; 10343 } 10344 } 10345 10346 /* If this breakpoint has target-side commands but this stub doesn't 10347 support Z0 packets, throw error. */ 10348 if (!bp_tgt->tcommands.empty ()) 10349 throw_error (NOT_SUPPORTED_ERROR, _("\ 10350Target doesn't support breakpoints that have target side commands.")); 10351 10352 return memory_insert_breakpoint (this, gdbarch, bp_tgt); 10353} 10354 10355int 10356remote_target::remove_breakpoint (struct gdbarch *gdbarch, 10357 struct bp_target_info *bp_tgt, 10358 enum remove_bp_reason reason) 10359{ 10360 CORE_ADDR addr = bp_tgt->placed_address; 10361 struct remote_state *rs = get_remote_state (); 10362 10363 if (packet_support (PACKET_Z0) != PACKET_DISABLE) 10364 { 10365 char *p = rs->buf.data (); 10366 char *endbuf = p + get_remote_packet_size (); 10367 10368 /* Make sure the remote is pointing at the right process, if 10369 necessary. */ 10370 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10371 set_general_process (); 10372 10373 *(p++) = 'z'; 10374 *(p++) = '0'; 10375 *(p++) = ','; 10376 10377 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address); 10378 p += hexnumstr (p, addr); 10379 xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind); 10380 10381 putpkt (rs->buf); 10382 getpkt (&rs->buf, 0); 10383 10384 return (rs->buf[0] == 'E'); 10385 } 10386 10387 return memory_remove_breakpoint (this, gdbarch, bp_tgt, reason); 10388} 10389 10390static enum Z_packet_type 10391watchpoint_to_Z_packet (int type) 10392{ 10393 switch (type) 10394 { 10395 case hw_write: 10396 return Z_PACKET_WRITE_WP; 10397 break; 10398 case hw_read: 10399 return Z_PACKET_READ_WP; 10400 break; 10401 case hw_access: 10402 return Z_PACKET_ACCESS_WP; 10403 break; 10404 default: 10405 internal_error (__FILE__, __LINE__, 10406 _("hw_bp_to_z: bad watchpoint type %d"), type); 10407 } 10408} 10409 10410int 10411remote_target::insert_watchpoint (CORE_ADDR addr, int len, 10412 enum target_hw_bp_type type, struct expression *cond) 10413{ 10414 struct remote_state *rs = get_remote_state (); 10415 char *endbuf = rs->buf.data () + get_remote_packet_size (); 10416 char *p; 10417 enum Z_packet_type packet = watchpoint_to_Z_packet (type); 10418 10419 if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE) 10420 return 1; 10421 10422 /* Make sure the remote is pointing at the right process, if 10423 necessary. */ 10424 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10425 set_general_process (); 10426 10427 xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "Z%x,", packet); 10428 p = strchr (rs->buf.data (), '\0'); 10429 addr = remote_address_masked (addr); 10430 p += hexnumstr (p, (ULONGEST) addr); 10431 xsnprintf (p, endbuf - p, ",%x", len); 10432 10433 putpkt (rs->buf); 10434 getpkt (&rs->buf, 0); 10435 10436 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet])) 10437 { 10438 case PACKET_ERROR: 10439 return -1; 10440 case PACKET_UNKNOWN: 10441 return 1; 10442 case PACKET_OK: 10443 return 0; 10444 } 10445 internal_error (__FILE__, __LINE__, 10446 _("remote_insert_watchpoint: reached end of function")); 10447} 10448 10449bool 10450remote_target::watchpoint_addr_within_range (CORE_ADDR addr, 10451 CORE_ADDR start, int length) 10452{ 10453 CORE_ADDR diff = remote_address_masked (addr - start); 10454 10455 return diff < length; 10456} 10457 10458 10459int 10460remote_target::remove_watchpoint (CORE_ADDR addr, int len, 10461 enum target_hw_bp_type type, struct expression *cond) 10462{ 10463 struct remote_state *rs = get_remote_state (); 10464 char *endbuf = rs->buf.data () + get_remote_packet_size (); 10465 char *p; 10466 enum Z_packet_type packet = watchpoint_to_Z_packet (type); 10467 10468 if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE) 10469 return -1; 10470 10471 /* Make sure the remote is pointing at the right process, if 10472 necessary. */ 10473 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10474 set_general_process (); 10475 10476 xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "z%x,", packet); 10477 p = strchr (rs->buf.data (), '\0'); 10478 addr = remote_address_masked (addr); 10479 p += hexnumstr (p, (ULONGEST) addr); 10480 xsnprintf (p, endbuf - p, ",%x", len); 10481 putpkt (rs->buf); 10482 getpkt (&rs->buf, 0); 10483 10484 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet])) 10485 { 10486 case PACKET_ERROR: 10487 case PACKET_UNKNOWN: 10488 return -1; 10489 case PACKET_OK: 10490 return 0; 10491 } 10492 internal_error (__FILE__, __LINE__, 10493 _("remote_remove_watchpoint: reached end of function")); 10494} 10495 10496 10497static int remote_hw_watchpoint_limit = -1; 10498static int remote_hw_watchpoint_length_limit = -1; 10499static int remote_hw_breakpoint_limit = -1; 10500 10501int 10502remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) 10503{ 10504 if (remote_hw_watchpoint_length_limit == 0) 10505 return 0; 10506 else if (remote_hw_watchpoint_length_limit < 0) 10507 return 1; 10508 else if (len <= remote_hw_watchpoint_length_limit) 10509 return 1; 10510 else 10511 return 0; 10512} 10513 10514int 10515remote_target::can_use_hw_breakpoint (enum bptype type, int cnt, int ot) 10516{ 10517 if (type == bp_hardware_breakpoint) 10518 { 10519 if (remote_hw_breakpoint_limit == 0) 10520 return 0; 10521 else if (remote_hw_breakpoint_limit < 0) 10522 return 1; 10523 else if (cnt <= remote_hw_breakpoint_limit) 10524 return 1; 10525 } 10526 else 10527 { 10528 if (remote_hw_watchpoint_limit == 0) 10529 return 0; 10530 else if (remote_hw_watchpoint_limit < 0) 10531 return 1; 10532 else if (ot) 10533 return -1; 10534 else if (cnt <= remote_hw_watchpoint_limit) 10535 return 1; 10536 } 10537 return -1; 10538} 10539 10540/* The to_stopped_by_sw_breakpoint method of target remote. */ 10541 10542bool 10543remote_target::stopped_by_sw_breakpoint () 10544{ 10545 struct thread_info *thread = inferior_thread (); 10546 10547 return (thread->priv != NULL 10548 && (get_remote_thread_info (thread)->stop_reason 10549 == TARGET_STOPPED_BY_SW_BREAKPOINT)); 10550} 10551 10552/* The to_supports_stopped_by_sw_breakpoint method of target 10553 remote. */ 10554 10555bool 10556remote_target::supports_stopped_by_sw_breakpoint () 10557{ 10558 return (packet_support (PACKET_swbreak_feature) == PACKET_ENABLE); 10559} 10560 10561/* The to_stopped_by_hw_breakpoint method of target remote. */ 10562 10563bool 10564remote_target::stopped_by_hw_breakpoint () 10565{ 10566 struct thread_info *thread = inferior_thread (); 10567 10568 return (thread->priv != NULL 10569 && (get_remote_thread_info (thread)->stop_reason 10570 == TARGET_STOPPED_BY_HW_BREAKPOINT)); 10571} 10572 10573/* The to_supports_stopped_by_hw_breakpoint method of target 10574 remote. */ 10575 10576bool 10577remote_target::supports_stopped_by_hw_breakpoint () 10578{ 10579 return (packet_support (PACKET_hwbreak_feature) == PACKET_ENABLE); 10580} 10581 10582bool 10583remote_target::stopped_by_watchpoint () 10584{ 10585 struct thread_info *thread = inferior_thread (); 10586 10587 return (thread->priv != NULL 10588 && (get_remote_thread_info (thread)->stop_reason 10589 == TARGET_STOPPED_BY_WATCHPOINT)); 10590} 10591 10592bool 10593remote_target::stopped_data_address (CORE_ADDR *addr_p) 10594{ 10595 struct thread_info *thread = inferior_thread (); 10596 10597 if (thread->priv != NULL 10598 && (get_remote_thread_info (thread)->stop_reason 10599 == TARGET_STOPPED_BY_WATCHPOINT)) 10600 { 10601 *addr_p = get_remote_thread_info (thread)->watch_data_address; 10602 return true; 10603 } 10604 10605 return false; 10606} 10607 10608 10609int 10610remote_target::insert_hw_breakpoint (struct gdbarch *gdbarch, 10611 struct bp_target_info *bp_tgt) 10612{ 10613 CORE_ADDR addr = bp_tgt->reqstd_address; 10614 struct remote_state *rs; 10615 char *p, *endbuf; 10616 char *message; 10617 10618 if (packet_support (PACKET_Z1) == PACKET_DISABLE) 10619 return -1; 10620 10621 /* Make sure the remote is pointing at the right process, if 10622 necessary. */ 10623 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10624 set_general_process (); 10625 10626 rs = get_remote_state (); 10627 p = rs->buf.data (); 10628 endbuf = p + get_remote_packet_size (); 10629 10630 *(p++) = 'Z'; 10631 *(p++) = '1'; 10632 *(p++) = ','; 10633 10634 addr = remote_address_masked (addr); 10635 p += hexnumstr (p, (ULONGEST) addr); 10636 xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind); 10637 10638 if (supports_evaluation_of_breakpoint_conditions ()) 10639 remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf); 10640 10641 if (can_run_breakpoint_commands ()) 10642 remote_add_target_side_commands (gdbarch, bp_tgt, p); 10643 10644 putpkt (rs->buf); 10645 getpkt (&rs->buf, 0); 10646 10647 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1])) 10648 { 10649 case PACKET_ERROR: 10650 if (rs->buf[1] == '.') 10651 { 10652 message = strchr (&rs->buf[2], '.'); 10653 if (message) 10654 error (_("Remote failure reply: %s"), message + 1); 10655 } 10656 return -1; 10657 case PACKET_UNKNOWN: 10658 return -1; 10659 case PACKET_OK: 10660 return 0; 10661 } 10662 internal_error (__FILE__, __LINE__, 10663 _("remote_insert_hw_breakpoint: reached end of function")); 10664} 10665 10666 10667int 10668remote_target::remove_hw_breakpoint (struct gdbarch *gdbarch, 10669 struct bp_target_info *bp_tgt) 10670{ 10671 CORE_ADDR addr; 10672 struct remote_state *rs = get_remote_state (); 10673 char *p = rs->buf.data (); 10674 char *endbuf = p + get_remote_packet_size (); 10675 10676 if (packet_support (PACKET_Z1) == PACKET_DISABLE) 10677 return -1; 10678 10679 /* Make sure the remote is pointing at the right process, if 10680 necessary. */ 10681 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10682 set_general_process (); 10683 10684 *(p++) = 'z'; 10685 *(p++) = '1'; 10686 *(p++) = ','; 10687 10688 addr = remote_address_masked (bp_tgt->placed_address); 10689 p += hexnumstr (p, (ULONGEST) addr); 10690 xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind); 10691 10692 putpkt (rs->buf); 10693 getpkt (&rs->buf, 0); 10694 10695 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1])) 10696 { 10697 case PACKET_ERROR: 10698 case PACKET_UNKNOWN: 10699 return -1; 10700 case PACKET_OK: 10701 return 0; 10702 } 10703 internal_error (__FILE__, __LINE__, 10704 _("remote_remove_hw_breakpoint: reached end of function")); 10705} 10706 10707/* Verify memory using the "qCRC:" request. */ 10708 10709int 10710remote_target::verify_memory (const gdb_byte *data, CORE_ADDR lma, ULONGEST size) 10711{ 10712 struct remote_state *rs = get_remote_state (); 10713 unsigned long host_crc, target_crc; 10714 char *tmp; 10715 10716 /* It doesn't make sense to use qCRC if the remote target is 10717 connected but not running. */ 10718 if (target_has_execution && packet_support (PACKET_qCRC) != PACKET_DISABLE) 10719 { 10720 enum packet_result result; 10721 10722 /* Make sure the remote is pointing at the right process. */ 10723 set_general_process (); 10724 10725 /* FIXME: assumes lma can fit into long. */ 10726 xsnprintf (rs->buf.data (), get_remote_packet_size (), "qCRC:%lx,%lx", 10727 (long) lma, (long) size); 10728 putpkt (rs->buf); 10729 10730 /* Be clever; compute the host_crc before waiting for target 10731 reply. */ 10732 host_crc = xcrc32 (data, size, 0xffffffff); 10733 10734 getpkt (&rs->buf, 0); 10735 10736 result = packet_ok (rs->buf, 10737 &remote_protocol_packets[PACKET_qCRC]); 10738 if (result == PACKET_ERROR) 10739 return -1; 10740 else if (result == PACKET_OK) 10741 { 10742 for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++) 10743 target_crc = target_crc * 16 + fromhex (*tmp); 10744 10745 return (host_crc == target_crc); 10746 } 10747 } 10748 10749 return simple_verify_memory (this, data, lma, size); 10750} 10751 10752/* compare-sections command 10753 10754 With no arguments, compares each loadable section in the exec bfd 10755 with the same memory range on the target, and reports mismatches. 10756 Useful for verifying the image on the target against the exec file. */ 10757 10758static void 10759compare_sections_command (const char *args, int from_tty) 10760{ 10761 asection *s; 10762 const char *sectname; 10763 bfd_size_type size; 10764 bfd_vma lma; 10765 int matched = 0; 10766 int mismatched = 0; 10767 int res; 10768 int read_only = 0; 10769 10770 if (!exec_bfd) 10771 error (_("command cannot be used without an exec file")); 10772 10773 if (args != NULL && strcmp (args, "-r") == 0) 10774 { 10775 read_only = 1; 10776 args = NULL; 10777 } 10778 10779 for (s = exec_bfd->sections; s; s = s->next) 10780 { 10781 if (!(s->flags & SEC_LOAD)) 10782 continue; /* Skip non-loadable section. */ 10783 10784 if (read_only && (s->flags & SEC_READONLY) == 0) 10785 continue; /* Skip writeable sections */ 10786 10787 size = bfd_section_size (s); 10788 if (size == 0) 10789 continue; /* Skip zero-length section. */ 10790 10791 sectname = bfd_section_name (s); 10792 if (args && strcmp (args, sectname) != 0) 10793 continue; /* Not the section selected by user. */ 10794 10795 matched = 1; /* Do this section. */ 10796 lma = s->lma; 10797 10798 gdb::byte_vector sectdata (size); 10799 bfd_get_section_contents (exec_bfd, s, sectdata.data (), 0, size); 10800 10801 res = target_verify_memory (sectdata.data (), lma, size); 10802 10803 if (res == -1) 10804 error (_("target memory fault, section %s, range %s -- %s"), sectname, 10805 paddress (target_gdbarch (), lma), 10806 paddress (target_gdbarch (), lma + size)); 10807 10808 printf_filtered ("Section %s, range %s -- %s: ", sectname, 10809 paddress (target_gdbarch (), lma), 10810 paddress (target_gdbarch (), lma + size)); 10811 if (res) 10812 printf_filtered ("matched.\n"); 10813 else 10814 { 10815 printf_filtered ("MIS-MATCHED!\n"); 10816 mismatched++; 10817 } 10818 } 10819 if (mismatched > 0) 10820 warning (_("One or more sections of the target image does not match\n\ 10821the loaded file\n")); 10822 if (args && !matched) 10823 printf_filtered (_("No loaded section named '%s'.\n"), args); 10824} 10825 10826/* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET 10827 into remote target. The number of bytes written to the remote 10828 target is returned, or -1 for error. */ 10829 10830target_xfer_status 10831remote_target::remote_write_qxfer (const char *object_name, 10832 const char *annex, const gdb_byte *writebuf, 10833 ULONGEST offset, LONGEST len, 10834 ULONGEST *xfered_len, 10835 struct packet_config *packet) 10836{ 10837 int i, buf_len; 10838 ULONGEST n; 10839 struct remote_state *rs = get_remote_state (); 10840 int max_size = get_memory_write_packet_size (); 10841 10842 if (packet_config_support (packet) == PACKET_DISABLE) 10843 return TARGET_XFER_E_IO; 10844 10845 /* Insert header. */ 10846 i = snprintf (rs->buf.data (), max_size, 10847 "qXfer:%s:write:%s:%s:", 10848 object_name, annex ? annex : "", 10849 phex_nz (offset, sizeof offset)); 10850 max_size -= (i + 1); 10851 10852 /* Escape as much data as fits into rs->buf. */ 10853 buf_len = remote_escape_output 10854 (writebuf, len, 1, (gdb_byte *) rs->buf.data () + i, &max_size, max_size); 10855 10856 if (putpkt_binary (rs->buf.data (), i + buf_len) < 0 10857 || getpkt_sane (&rs->buf, 0) < 0 10858 || packet_ok (rs->buf, packet) != PACKET_OK) 10859 return TARGET_XFER_E_IO; 10860 10861 unpack_varlen_hex (rs->buf.data (), &n); 10862 10863 *xfered_len = n; 10864 return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF; 10865} 10866 10867/* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet. 10868 Data at OFFSET, of up to LEN bytes, is read into READBUF; the 10869 number of bytes read is returned, or 0 for EOF, or -1 for error. 10870 The number of bytes read may be less than LEN without indicating an 10871 EOF. PACKET is checked and updated to indicate whether the remote 10872 target supports this object. */ 10873 10874target_xfer_status 10875remote_target::remote_read_qxfer (const char *object_name, 10876 const char *annex, 10877 gdb_byte *readbuf, ULONGEST offset, 10878 LONGEST len, 10879 ULONGEST *xfered_len, 10880 struct packet_config *packet) 10881{ 10882 struct remote_state *rs = get_remote_state (); 10883 LONGEST i, n, packet_len; 10884 10885 if (packet_config_support (packet) == PACKET_DISABLE) 10886 return TARGET_XFER_E_IO; 10887 10888 /* Check whether we've cached an end-of-object packet that matches 10889 this request. */ 10890 if (rs->finished_object) 10891 { 10892 if (strcmp (object_name, rs->finished_object) == 0 10893 && strcmp (annex ? annex : "", rs->finished_annex) == 0 10894 && offset == rs->finished_offset) 10895 return TARGET_XFER_EOF; 10896 10897 10898 /* Otherwise, we're now reading something different. Discard 10899 the cache. */ 10900 xfree (rs->finished_object); 10901 xfree (rs->finished_annex); 10902 rs->finished_object = NULL; 10903 rs->finished_annex = NULL; 10904 } 10905 10906 /* Request only enough to fit in a single packet. The actual data 10907 may not, since we don't know how much of it will need to be escaped; 10908 the target is free to respond with slightly less data. We subtract 10909 five to account for the response type and the protocol frame. */ 10910 n = std::min<LONGEST> (get_remote_packet_size () - 5, len); 10911 snprintf (rs->buf.data (), get_remote_packet_size () - 4, 10912 "qXfer:%s:read:%s:%s,%s", 10913 object_name, annex ? annex : "", 10914 phex_nz (offset, sizeof offset), 10915 phex_nz (n, sizeof n)); 10916 i = putpkt (rs->buf); 10917 if (i < 0) 10918 return TARGET_XFER_E_IO; 10919 10920 rs->buf[0] = '\0'; 10921 packet_len = getpkt_sane (&rs->buf, 0); 10922 if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK) 10923 return TARGET_XFER_E_IO; 10924 10925 if (rs->buf[0] != 'l' && rs->buf[0] != 'm') 10926 error (_("Unknown remote qXfer reply: %s"), rs->buf.data ()); 10927 10928 /* 'm' means there is (or at least might be) more data after this 10929 batch. That does not make sense unless there's at least one byte 10930 of data in this reply. */ 10931 if (rs->buf[0] == 'm' && packet_len == 1) 10932 error (_("Remote qXfer reply contained no data.")); 10933 10934 /* Got some data. */ 10935 i = remote_unescape_input ((gdb_byte *) rs->buf.data () + 1, 10936 packet_len - 1, readbuf, n); 10937 10938 /* 'l' is an EOF marker, possibly including a final block of data, 10939 or possibly empty. If we have the final block of a non-empty 10940 object, record this fact to bypass a subsequent partial read. */ 10941 if (rs->buf[0] == 'l' && offset + i > 0) 10942 { 10943 rs->finished_object = xstrdup (object_name); 10944 rs->finished_annex = xstrdup (annex ? annex : ""); 10945 rs->finished_offset = offset + i; 10946 } 10947 10948 if (i == 0) 10949 return TARGET_XFER_EOF; 10950 else 10951 { 10952 *xfered_len = i; 10953 return TARGET_XFER_OK; 10954 } 10955} 10956 10957enum target_xfer_status 10958remote_target::xfer_partial (enum target_object object, 10959 const char *annex, gdb_byte *readbuf, 10960 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, 10961 ULONGEST *xfered_len) 10962{ 10963 struct remote_state *rs; 10964 int i; 10965 char *p2; 10966 char query_type; 10967 int unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ()); 10968 10969 set_remote_traceframe (); 10970 set_general_thread (inferior_ptid); 10971 10972 rs = get_remote_state (); 10973 10974 /* Handle memory using the standard memory routines. */ 10975 if (object == TARGET_OBJECT_MEMORY) 10976 { 10977 /* If the remote target is connected but not running, we should 10978 pass this request down to a lower stratum (e.g. the executable 10979 file). */ 10980 if (!target_has_execution) 10981 return TARGET_XFER_EOF; 10982 10983 if (writebuf != NULL) 10984 return remote_write_bytes (offset, writebuf, len, unit_size, 10985 xfered_len); 10986 else 10987 return remote_read_bytes (offset, readbuf, len, unit_size, 10988 xfered_len); 10989 } 10990 10991 /* Handle extra signal info using qxfer packets. */ 10992 if (object == TARGET_OBJECT_SIGNAL_INFO) 10993 { 10994 if (readbuf) 10995 return remote_read_qxfer ("siginfo", annex, readbuf, offset, len, 10996 xfered_len, &remote_protocol_packets 10997 [PACKET_qXfer_siginfo_read]); 10998 else 10999 return remote_write_qxfer ("siginfo", annex, 11000 writebuf, offset, len, xfered_len, 11001 &remote_protocol_packets 11002 [PACKET_qXfer_siginfo_write]); 11003 } 11004 11005 if (object == TARGET_OBJECT_STATIC_TRACE_DATA) 11006 { 11007 if (readbuf) 11008 return remote_read_qxfer ("statictrace", annex, 11009 readbuf, offset, len, xfered_len, 11010 &remote_protocol_packets 11011 [PACKET_qXfer_statictrace_read]); 11012 else 11013 return TARGET_XFER_E_IO; 11014 } 11015 11016 /* Only handle flash writes. */ 11017 if (writebuf != NULL) 11018 { 11019 switch (object) 11020 { 11021 case TARGET_OBJECT_FLASH: 11022 return remote_flash_write (offset, len, xfered_len, 11023 writebuf); 11024 11025 default: 11026 return TARGET_XFER_E_IO; 11027 } 11028 } 11029 11030 /* Map pre-existing objects onto letters. DO NOT do this for new 11031 objects!!! Instead specify new query packets. */ 11032 switch (object) 11033 { 11034 case TARGET_OBJECT_AVR: 11035 query_type = 'R'; 11036 break; 11037 11038 case TARGET_OBJECT_AUXV: 11039 gdb_assert (annex == NULL); 11040 return remote_read_qxfer ("auxv", annex, readbuf, offset, len, 11041 xfered_len, 11042 &remote_protocol_packets[PACKET_qXfer_auxv]); 11043 11044 case TARGET_OBJECT_AVAILABLE_FEATURES: 11045 return remote_read_qxfer 11046 ("features", annex, readbuf, offset, len, xfered_len, 11047 &remote_protocol_packets[PACKET_qXfer_features]); 11048 11049 case TARGET_OBJECT_LIBRARIES: 11050 return remote_read_qxfer 11051 ("libraries", annex, readbuf, offset, len, xfered_len, 11052 &remote_protocol_packets[PACKET_qXfer_libraries]); 11053 11054 case TARGET_OBJECT_LIBRARIES_SVR4: 11055 return remote_read_qxfer 11056 ("libraries-svr4", annex, readbuf, offset, len, xfered_len, 11057 &remote_protocol_packets[PACKET_qXfer_libraries_svr4]); 11058 11059 case TARGET_OBJECT_MEMORY_MAP: 11060 gdb_assert (annex == NULL); 11061 return remote_read_qxfer ("memory-map", annex, readbuf, offset, len, 11062 xfered_len, 11063 &remote_protocol_packets[PACKET_qXfer_memory_map]); 11064 11065 case TARGET_OBJECT_OSDATA: 11066 /* Should only get here if we're connected. */ 11067 gdb_assert (rs->remote_desc); 11068 return remote_read_qxfer 11069 ("osdata", annex, readbuf, offset, len, xfered_len, 11070 &remote_protocol_packets[PACKET_qXfer_osdata]); 11071 11072 case TARGET_OBJECT_THREADS: 11073 gdb_assert (annex == NULL); 11074 return remote_read_qxfer ("threads", annex, readbuf, offset, len, 11075 xfered_len, 11076 &remote_protocol_packets[PACKET_qXfer_threads]); 11077 11078 case TARGET_OBJECT_TRACEFRAME_INFO: 11079 gdb_assert (annex == NULL); 11080 return remote_read_qxfer 11081 ("traceframe-info", annex, readbuf, offset, len, xfered_len, 11082 &remote_protocol_packets[PACKET_qXfer_traceframe_info]); 11083 11084 case TARGET_OBJECT_FDPIC: 11085 return remote_read_qxfer ("fdpic", annex, readbuf, offset, len, 11086 xfered_len, 11087 &remote_protocol_packets[PACKET_qXfer_fdpic]); 11088 11089 case TARGET_OBJECT_OPENVMS_UIB: 11090 return remote_read_qxfer ("uib", annex, readbuf, offset, len, 11091 xfered_len, 11092 &remote_protocol_packets[PACKET_qXfer_uib]); 11093 11094 case TARGET_OBJECT_BTRACE: 11095 return remote_read_qxfer ("btrace", annex, readbuf, offset, len, 11096 xfered_len, 11097 &remote_protocol_packets[PACKET_qXfer_btrace]); 11098 11099 case TARGET_OBJECT_BTRACE_CONF: 11100 return remote_read_qxfer ("btrace-conf", annex, readbuf, offset, 11101 len, xfered_len, 11102 &remote_protocol_packets[PACKET_qXfer_btrace_conf]); 11103 11104 case TARGET_OBJECT_EXEC_FILE: 11105 return remote_read_qxfer ("exec-file", annex, readbuf, offset, 11106 len, xfered_len, 11107 &remote_protocol_packets[PACKET_qXfer_exec_file]); 11108 11109 default: 11110 return TARGET_XFER_E_IO; 11111 } 11112 11113 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not 11114 large enough let the caller deal with it. */ 11115 if (len < get_remote_packet_size ()) 11116 return TARGET_XFER_E_IO; 11117 len = get_remote_packet_size (); 11118 11119 /* Except for querying the minimum buffer size, target must be open. */ 11120 if (!rs->remote_desc) 11121 error (_("remote query is only available after target open")); 11122 11123 gdb_assert (annex != NULL); 11124 gdb_assert (readbuf != NULL); 11125 11126 p2 = rs->buf.data (); 11127 *p2++ = 'q'; 11128 *p2++ = query_type; 11129 11130 /* We used one buffer char for the remote protocol q command and 11131 another for the query type. As the remote protocol encapsulation 11132 uses 4 chars plus one extra in case we are debugging 11133 (remote_debug), we have PBUFZIZ - 7 left to pack the query 11134 string. */ 11135 i = 0; 11136 while (annex[i] && (i < (get_remote_packet_size () - 8))) 11137 { 11138 /* Bad caller may have sent forbidden characters. */ 11139 gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#'); 11140 *p2++ = annex[i]; 11141 i++; 11142 } 11143 *p2 = '\0'; 11144 gdb_assert (annex[i] == '\0'); 11145 11146 i = putpkt (rs->buf); 11147 if (i < 0) 11148 return TARGET_XFER_E_IO; 11149 11150 getpkt (&rs->buf, 0); 11151 strcpy ((char *) readbuf, rs->buf.data ()); 11152 11153 *xfered_len = strlen ((char *) readbuf); 11154 return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF; 11155} 11156 11157/* Implementation of to_get_memory_xfer_limit. */ 11158 11159ULONGEST 11160remote_target::get_memory_xfer_limit () 11161{ 11162 return get_memory_write_packet_size (); 11163} 11164 11165int 11166remote_target::search_memory (CORE_ADDR start_addr, ULONGEST search_space_len, 11167 const gdb_byte *pattern, ULONGEST pattern_len, 11168 CORE_ADDR *found_addrp) 11169{ 11170 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; 11171 struct remote_state *rs = get_remote_state (); 11172 int max_size = get_memory_write_packet_size (); 11173 struct packet_config *packet = 11174 &remote_protocol_packets[PACKET_qSearch_memory]; 11175 /* Number of packet bytes used to encode the pattern; 11176 this could be more than PATTERN_LEN due to escape characters. */ 11177 int escaped_pattern_len; 11178 /* Amount of pattern that was encodable in the packet. */ 11179 int used_pattern_len; 11180 int i; 11181 int found; 11182 ULONGEST found_addr; 11183 11184 /* Don't go to the target if we don't have to. This is done before 11185 checking packet_config_support to avoid the possibility that a 11186 success for this edge case means the facility works in 11187 general. */ 11188 if (pattern_len > search_space_len) 11189 return 0; 11190 if (pattern_len == 0) 11191 { 11192 *found_addrp = start_addr; 11193 return 1; 11194 } 11195 11196 /* If we already know the packet isn't supported, fall back to the simple 11197 way of searching memory. */ 11198 11199 if (packet_config_support (packet) == PACKET_DISABLE) 11200 { 11201 /* Target doesn't provided special support, fall back and use the 11202 standard support (copy memory and do the search here). */ 11203 return simple_search_memory (this, start_addr, search_space_len, 11204 pattern, pattern_len, found_addrp); 11205 } 11206 11207 /* Make sure the remote is pointing at the right process. */ 11208 set_general_process (); 11209 11210 /* Insert header. */ 11211 i = snprintf (rs->buf.data (), max_size, 11212 "qSearch:memory:%s;%s;", 11213 phex_nz (start_addr, addr_size), 11214 phex_nz (search_space_len, sizeof (search_space_len))); 11215 max_size -= (i + 1); 11216 11217 /* Escape as much data as fits into rs->buf. */ 11218 escaped_pattern_len = 11219 remote_escape_output (pattern, pattern_len, 1, 11220 (gdb_byte *) rs->buf.data () + i, 11221 &used_pattern_len, max_size); 11222 11223 /* Bail if the pattern is too large. */ 11224 if (used_pattern_len != pattern_len) 11225 error (_("Pattern is too large to transmit to remote target.")); 11226 11227 if (putpkt_binary (rs->buf.data (), i + escaped_pattern_len) < 0 11228 || getpkt_sane (&rs->buf, 0) < 0 11229 || packet_ok (rs->buf, packet) != PACKET_OK) 11230 { 11231 /* The request may not have worked because the command is not 11232 supported. If so, fall back to the simple way. */ 11233 if (packet_config_support (packet) == PACKET_DISABLE) 11234 { 11235 return simple_search_memory (this, start_addr, search_space_len, 11236 pattern, pattern_len, found_addrp); 11237 } 11238 return -1; 11239 } 11240 11241 if (rs->buf[0] == '0') 11242 found = 0; 11243 else if (rs->buf[0] == '1') 11244 { 11245 found = 1; 11246 if (rs->buf[1] != ',') 11247 error (_("Unknown qSearch:memory reply: %s"), rs->buf.data ()); 11248 unpack_varlen_hex (&rs->buf[2], &found_addr); 11249 *found_addrp = found_addr; 11250 } 11251 else 11252 error (_("Unknown qSearch:memory reply: %s"), rs->buf.data ()); 11253 11254 return found; 11255} 11256 11257void 11258remote_target::rcmd (const char *command, struct ui_file *outbuf) 11259{ 11260 struct remote_state *rs = get_remote_state (); 11261 char *p = rs->buf.data (); 11262 11263 if (!rs->remote_desc) 11264 error (_("remote rcmd is only available after target open")); 11265 11266 /* Send a NULL command across as an empty command. */ 11267 if (command == NULL) 11268 command = ""; 11269 11270 /* The query prefix. */ 11271 strcpy (rs->buf.data (), "qRcmd,"); 11272 p = strchr (rs->buf.data (), '\0'); 11273 11274 if ((strlen (rs->buf.data ()) + strlen (command) * 2 + 8/*misc*/) 11275 > get_remote_packet_size ()) 11276 error (_("\"monitor\" command ``%s'' is too long."), command); 11277 11278 /* Encode the actual command. */ 11279 bin2hex ((const gdb_byte *) command, p, strlen (command)); 11280 11281 if (putpkt (rs->buf) < 0) 11282 error (_("Communication problem with target.")); 11283 11284 /* get/display the response */ 11285 while (1) 11286 { 11287 char *buf; 11288 11289 /* XXX - see also remote_get_noisy_reply(). */ 11290 QUIT; /* Allow user to bail out with ^C. */ 11291 rs->buf[0] = '\0'; 11292 if (getpkt_sane (&rs->buf, 0) == -1) 11293 { 11294 /* Timeout. Continue to (try to) read responses. 11295 This is better than stopping with an error, assuming the stub 11296 is still executing the (long) monitor command. 11297 If needed, the user can interrupt gdb using C-c, obtaining 11298 an effect similar to stop on timeout. */ 11299 continue; 11300 } 11301 buf = rs->buf.data (); 11302 if (buf[0] == '\0') 11303 error (_("Target does not support this command.")); 11304 if (buf[0] == 'O' && buf[1] != 'K') 11305 { 11306 remote_console_output (buf + 1); /* 'O' message from stub. */ 11307 continue; 11308 } 11309 if (strcmp (buf, "OK") == 0) 11310 break; 11311 if (strlen (buf) == 3 && buf[0] == 'E' 11312 && isdigit (buf[1]) && isdigit (buf[2])) 11313 { 11314 error (_("Protocol error with Rcmd")); 11315 } 11316 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2) 11317 { 11318 char c = (fromhex (p[0]) << 4) + fromhex (p[1]); 11319 11320 fputc_unfiltered (c, outbuf); 11321 } 11322 break; 11323 } 11324} 11325 11326std::vector<mem_region> 11327remote_target::memory_map () 11328{ 11329 std::vector<mem_region> result; 11330 gdb::optional<gdb::char_vector> text 11331 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP, NULL); 11332 11333 if (text) 11334 result = parse_memory_map (text->data ()); 11335 11336 return result; 11337} 11338 11339static void 11340packet_command (const char *args, int from_tty) 11341{ 11342 remote_target *remote = get_current_remote_target (); 11343 11344 if (remote == nullptr) 11345 error (_("command can only be used with remote target")); 11346 11347 remote->packet_command (args, from_tty); 11348} 11349 11350void 11351remote_target::packet_command (const char *args, int from_tty) 11352{ 11353 if (!args) 11354 error (_("remote-packet command requires packet text as argument")); 11355 11356 puts_filtered ("sending: "); 11357 print_packet (args); 11358 puts_filtered ("\n"); 11359 putpkt (args); 11360 11361 remote_state *rs = get_remote_state (); 11362 11363 getpkt (&rs->buf, 0); 11364 puts_filtered ("received: "); 11365 print_packet (rs->buf.data ()); 11366 puts_filtered ("\n"); 11367} 11368 11369#if 0 11370/* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */ 11371 11372static void display_thread_info (struct gdb_ext_thread_info *info); 11373 11374static void threadset_test_cmd (char *cmd, int tty); 11375 11376static void threadalive_test (char *cmd, int tty); 11377 11378static void threadlist_test_cmd (char *cmd, int tty); 11379 11380int get_and_display_threadinfo (threadref *ref); 11381 11382static void threadinfo_test_cmd (char *cmd, int tty); 11383 11384static int thread_display_step (threadref *ref, void *context); 11385 11386static void threadlist_update_test_cmd (char *cmd, int tty); 11387 11388static void init_remote_threadtests (void); 11389 11390#define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */ 11391 11392static void 11393threadset_test_cmd (const char *cmd, int tty) 11394{ 11395 int sample_thread = SAMPLE_THREAD; 11396 11397 printf_filtered (_("Remote threadset test\n")); 11398 set_general_thread (sample_thread); 11399} 11400 11401 11402static void 11403threadalive_test (const char *cmd, int tty) 11404{ 11405 int sample_thread = SAMPLE_THREAD; 11406 int pid = inferior_ptid.pid (); 11407 ptid_t ptid = ptid_t (pid, sample_thread, 0); 11408 11409 if (remote_thread_alive (ptid)) 11410 printf_filtered ("PASS: Thread alive test\n"); 11411 else 11412 printf_filtered ("FAIL: Thread alive test\n"); 11413} 11414 11415void output_threadid (char *title, threadref *ref); 11416 11417void 11418output_threadid (char *title, threadref *ref) 11419{ 11420 char hexid[20]; 11421 11422 pack_threadid (&hexid[0], ref); /* Convert thread id into hex. */ 11423 hexid[16] = 0; 11424 printf_filtered ("%s %s\n", title, (&hexid[0])); 11425} 11426 11427static void 11428threadlist_test_cmd (const char *cmd, int tty) 11429{ 11430 int startflag = 1; 11431 threadref nextthread; 11432 int done, result_count; 11433 threadref threadlist[3]; 11434 11435 printf_filtered ("Remote Threadlist test\n"); 11436 if (!remote_get_threadlist (startflag, &nextthread, 3, &done, 11437 &result_count, &threadlist[0])) 11438 printf_filtered ("FAIL: threadlist test\n"); 11439 else 11440 { 11441 threadref *scan = threadlist; 11442 threadref *limit = scan + result_count; 11443 11444 while (scan < limit) 11445 output_threadid (" thread ", scan++); 11446 } 11447} 11448 11449void 11450display_thread_info (struct gdb_ext_thread_info *info) 11451{ 11452 output_threadid ("Threadid: ", &info->threadid); 11453 printf_filtered ("Name: %s\n ", info->shortname); 11454 printf_filtered ("State: %s\n", info->display); 11455 printf_filtered ("other: %s\n\n", info->more_display); 11456} 11457 11458int 11459get_and_display_threadinfo (threadref *ref) 11460{ 11461 int result; 11462 int set; 11463 struct gdb_ext_thread_info threadinfo; 11464 11465 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME 11466 | TAG_MOREDISPLAY | TAG_DISPLAY; 11467 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo))) 11468 display_thread_info (&threadinfo); 11469 return result; 11470} 11471 11472static void 11473threadinfo_test_cmd (const char *cmd, int tty) 11474{ 11475 int athread = SAMPLE_THREAD; 11476 threadref thread; 11477 int set; 11478 11479 int_to_threadref (&thread, athread); 11480 printf_filtered ("Remote Threadinfo test\n"); 11481 if (!get_and_display_threadinfo (&thread)) 11482 printf_filtered ("FAIL cannot get thread info\n"); 11483} 11484 11485static int 11486thread_display_step (threadref *ref, void *context) 11487{ 11488 /* output_threadid(" threadstep ",ref); *//* simple test */ 11489 return get_and_display_threadinfo (ref); 11490} 11491 11492static void 11493threadlist_update_test_cmd (const char *cmd, int tty) 11494{ 11495 printf_filtered ("Remote Threadlist update test\n"); 11496 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS); 11497} 11498 11499static void 11500init_remote_threadtests (void) 11501{ 11502 add_com ("tlist", class_obscure, threadlist_test_cmd, 11503 _("Fetch and print the remote list of " 11504 "thread identifiers, one pkt only.")); 11505 add_com ("tinfo", class_obscure, threadinfo_test_cmd, 11506 _("Fetch and display info about one thread.")); 11507 add_com ("tset", class_obscure, threadset_test_cmd, 11508 _("Test setting to a different thread.")); 11509 add_com ("tupd", class_obscure, threadlist_update_test_cmd, 11510 _("Iterate through updating all remote thread info.")); 11511 add_com ("talive", class_obscure, threadalive_test, 11512 _("Remote thread alive test.")); 11513} 11514 11515#endif /* 0 */ 11516 11517/* Convert a thread ID to a string. */ 11518 11519std::string 11520remote_target::pid_to_str (ptid_t ptid) 11521{ 11522 struct remote_state *rs = get_remote_state (); 11523 11524 if (ptid == null_ptid) 11525 return normal_pid_to_str (ptid); 11526 else if (ptid.is_pid ()) 11527 { 11528 /* Printing an inferior target id. */ 11529 11530 /* When multi-process extensions are off, there's no way in the 11531 remote protocol to know the remote process id, if there's any 11532 at all. There's one exception --- when we're connected with 11533 target extended-remote, and we manually attached to a process 11534 with "attach PID". We don't record anywhere a flag that 11535 allows us to distinguish that case from the case of 11536 connecting with extended-remote and the stub already being 11537 attached to a process, and reporting yes to qAttached, hence 11538 no smart special casing here. */ 11539 if (!remote_multi_process_p (rs)) 11540 return "Remote target"; 11541 11542 return normal_pid_to_str (ptid); 11543 } 11544 else 11545 { 11546 if (magic_null_ptid == ptid) 11547 return "Thread <main>"; 11548 else if (remote_multi_process_p (rs)) 11549 if (ptid.lwp () == 0) 11550 return normal_pid_to_str (ptid); 11551 else 11552 return string_printf ("Thread %d.%ld", 11553 ptid.pid (), ptid.lwp ()); 11554 else 11555 return string_printf ("Thread %ld", ptid.lwp ()); 11556 } 11557} 11558 11559/* Get the address of the thread local variable in OBJFILE which is 11560 stored at OFFSET within the thread local storage for thread PTID. */ 11561 11562CORE_ADDR 11563remote_target::get_thread_local_address (ptid_t ptid, CORE_ADDR lm, 11564 CORE_ADDR offset) 11565{ 11566 if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE) 11567 { 11568 struct remote_state *rs = get_remote_state (); 11569 char *p = rs->buf.data (); 11570 char *endp = p + get_remote_packet_size (); 11571 enum packet_result result; 11572 11573 strcpy (p, "qGetTLSAddr:"); 11574 p += strlen (p); 11575 p = write_ptid (p, endp, ptid); 11576 *p++ = ','; 11577 p += hexnumstr (p, offset); 11578 *p++ = ','; 11579 p += hexnumstr (p, lm); 11580 *p++ = '\0'; 11581 11582 putpkt (rs->buf); 11583 getpkt (&rs->buf, 0); 11584 result = packet_ok (rs->buf, 11585 &remote_protocol_packets[PACKET_qGetTLSAddr]); 11586 if (result == PACKET_OK) 11587 { 11588 ULONGEST addr; 11589 11590 unpack_varlen_hex (rs->buf.data (), &addr); 11591 return addr; 11592 } 11593 else if (result == PACKET_UNKNOWN) 11594 throw_error (TLS_GENERIC_ERROR, 11595 _("Remote target doesn't support qGetTLSAddr packet")); 11596 else 11597 throw_error (TLS_GENERIC_ERROR, 11598 _("Remote target failed to process qGetTLSAddr request")); 11599 } 11600 else 11601 throw_error (TLS_GENERIC_ERROR, 11602 _("TLS not supported or disabled on this target")); 11603 /* Not reached. */ 11604 return 0; 11605} 11606 11607/* Provide thread local base, i.e. Thread Information Block address. 11608 Returns 1 if ptid is found and thread_local_base is non zero. */ 11609 11610bool 11611remote_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr) 11612{ 11613 if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE) 11614 { 11615 struct remote_state *rs = get_remote_state (); 11616 char *p = rs->buf.data (); 11617 char *endp = p + get_remote_packet_size (); 11618 enum packet_result result; 11619 11620 strcpy (p, "qGetTIBAddr:"); 11621 p += strlen (p); 11622 p = write_ptid (p, endp, ptid); 11623 *p++ = '\0'; 11624 11625 putpkt (rs->buf); 11626 getpkt (&rs->buf, 0); 11627 result = packet_ok (rs->buf, 11628 &remote_protocol_packets[PACKET_qGetTIBAddr]); 11629 if (result == PACKET_OK) 11630 { 11631 ULONGEST val; 11632 unpack_varlen_hex (rs->buf.data (), &val); 11633 if (addr) 11634 *addr = (CORE_ADDR) val; 11635 return true; 11636 } 11637 else if (result == PACKET_UNKNOWN) 11638 error (_("Remote target doesn't support qGetTIBAddr packet")); 11639 else 11640 error (_("Remote target failed to process qGetTIBAddr request")); 11641 } 11642 else 11643 error (_("qGetTIBAddr not supported or disabled on this target")); 11644 /* Not reached. */ 11645 return false; 11646} 11647 11648/* Support for inferring a target description based on the current 11649 architecture and the size of a 'g' packet. While the 'g' packet 11650 can have any size (since optional registers can be left off the 11651 end), some sizes are easily recognizable given knowledge of the 11652 approximate architecture. */ 11653 11654struct remote_g_packet_guess 11655{ 11656 remote_g_packet_guess (int bytes_, const struct target_desc *tdesc_) 11657 : bytes (bytes_), 11658 tdesc (tdesc_) 11659 { 11660 } 11661 11662 int bytes; 11663 const struct target_desc *tdesc; 11664}; 11665 11666struct remote_g_packet_data : public allocate_on_obstack 11667{ 11668 std::vector<remote_g_packet_guess> guesses; 11669}; 11670 11671static struct gdbarch_data *remote_g_packet_data_handle; 11672 11673static void * 11674remote_g_packet_data_init (struct obstack *obstack) 11675{ 11676 return new (obstack) remote_g_packet_data; 11677} 11678 11679void 11680register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes, 11681 const struct target_desc *tdesc) 11682{ 11683 struct remote_g_packet_data *data 11684 = ((struct remote_g_packet_data *) 11685 gdbarch_data (gdbarch, remote_g_packet_data_handle)); 11686 11687 gdb_assert (tdesc != NULL); 11688 11689 for (const remote_g_packet_guess &guess : data->guesses) 11690 if (guess.bytes == bytes) 11691 internal_error (__FILE__, __LINE__, 11692 _("Duplicate g packet description added for size %d"), 11693 bytes); 11694 11695 data->guesses.emplace_back (bytes, tdesc); 11696} 11697 11698/* Return true if remote_read_description would do anything on this target 11699 and architecture, false otherwise. */ 11700 11701static bool 11702remote_read_description_p (struct target_ops *target) 11703{ 11704 struct remote_g_packet_data *data 11705 = ((struct remote_g_packet_data *) 11706 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle)); 11707 11708 return !data->guesses.empty (); 11709} 11710 11711const struct target_desc * 11712remote_target::read_description () 11713{ 11714 struct remote_g_packet_data *data 11715 = ((struct remote_g_packet_data *) 11716 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle)); 11717 11718 /* Do not try this during initial connection, when we do not know 11719 whether there is a running but stopped thread. */ 11720 if (!target_has_execution || inferior_ptid == null_ptid) 11721 return beneath ()->read_description (); 11722 11723 if (!data->guesses.empty ()) 11724 { 11725 int bytes = send_g_packet (); 11726 11727 for (const remote_g_packet_guess &guess : data->guesses) 11728 if (guess.bytes == bytes) 11729 return guess.tdesc; 11730 11731 /* We discard the g packet. A minor optimization would be to 11732 hold on to it, and fill the register cache once we have selected 11733 an architecture, but it's too tricky to do safely. */ 11734 } 11735 11736 return beneath ()->read_description (); 11737} 11738 11739/* Remote file transfer support. This is host-initiated I/O, not 11740 target-initiated; for target-initiated, see remote-fileio.c. */ 11741 11742/* If *LEFT is at least the length of STRING, copy STRING to 11743 *BUFFER, update *BUFFER to point to the new end of the buffer, and 11744 decrease *LEFT. Otherwise raise an error. */ 11745 11746static void 11747remote_buffer_add_string (char **buffer, int *left, const char *string) 11748{ 11749 int len = strlen (string); 11750 11751 if (len > *left) 11752 error (_("Packet too long for target.")); 11753 11754 memcpy (*buffer, string, len); 11755 *buffer += len; 11756 *left -= len; 11757 11758 /* NUL-terminate the buffer as a convenience, if there is 11759 room. */ 11760 if (*left) 11761 **buffer = '\0'; 11762} 11763 11764/* If *LEFT is large enough, hex encode LEN bytes from BYTES into 11765 *BUFFER, update *BUFFER to point to the new end of the buffer, and 11766 decrease *LEFT. Otherwise raise an error. */ 11767 11768static void 11769remote_buffer_add_bytes (char **buffer, int *left, const gdb_byte *bytes, 11770 int len) 11771{ 11772 if (2 * len > *left) 11773 error (_("Packet too long for target.")); 11774 11775 bin2hex (bytes, *buffer, len); 11776 *buffer += 2 * len; 11777 *left -= 2 * len; 11778 11779 /* NUL-terminate the buffer as a convenience, if there is 11780 room. */ 11781 if (*left) 11782 **buffer = '\0'; 11783} 11784 11785/* If *LEFT is large enough, convert VALUE to hex and add it to 11786 *BUFFER, update *BUFFER to point to the new end of the buffer, and 11787 decrease *LEFT. Otherwise raise an error. */ 11788 11789static void 11790remote_buffer_add_int (char **buffer, int *left, ULONGEST value) 11791{ 11792 int len = hexnumlen (value); 11793 11794 if (len > *left) 11795 error (_("Packet too long for target.")); 11796 11797 hexnumstr (*buffer, value); 11798 *buffer += len; 11799 *left -= len; 11800 11801 /* NUL-terminate the buffer as a convenience, if there is 11802 room. */ 11803 if (*left) 11804 **buffer = '\0'; 11805} 11806 11807/* Parse an I/O result packet from BUFFER. Set RETCODE to the return 11808 value, *REMOTE_ERRNO to the remote error number or zero if none 11809 was included, and *ATTACHMENT to point to the start of the annex 11810 if any. The length of the packet isn't needed here; there may 11811 be NUL bytes in BUFFER, but they will be after *ATTACHMENT. 11812 11813 Return 0 if the packet could be parsed, -1 if it could not. If 11814 -1 is returned, the other variables may not be initialized. */ 11815 11816static int 11817remote_hostio_parse_result (char *buffer, int *retcode, 11818 int *remote_errno, char **attachment) 11819{ 11820 char *p, *p2; 11821 11822 *remote_errno = 0; 11823 *attachment = NULL; 11824 11825 if (buffer[0] != 'F') 11826 return -1; 11827 11828 errno = 0; 11829 *retcode = strtol (&buffer[1], &p, 16); 11830 if (errno != 0 || p == &buffer[1]) 11831 return -1; 11832 11833 /* Check for ",errno". */ 11834 if (*p == ',') 11835 { 11836 errno = 0; 11837 *remote_errno = strtol (p + 1, &p2, 16); 11838 if (errno != 0 || p + 1 == p2) 11839 return -1; 11840 p = p2; 11841 } 11842 11843 /* Check for ";attachment". If there is no attachment, the 11844 packet should end here. */ 11845 if (*p == ';') 11846 { 11847 *attachment = p + 1; 11848 return 0; 11849 } 11850 else if (*p == '\0') 11851 return 0; 11852 else 11853 return -1; 11854} 11855 11856/* Send a prepared I/O packet to the target and read its response. 11857 The prepared packet is in the global RS->BUF before this function 11858 is called, and the answer is there when we return. 11859 11860 COMMAND_BYTES is the length of the request to send, which may include 11861 binary data. WHICH_PACKET is the packet configuration to check 11862 before attempting a packet. If an error occurs, *REMOTE_ERRNO 11863 is set to the error number and -1 is returned. Otherwise the value 11864 returned by the function is returned. 11865 11866 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an 11867 attachment is expected; an error will be reported if there's a 11868 mismatch. If one is found, *ATTACHMENT will be set to point into 11869 the packet buffer and *ATTACHMENT_LEN will be set to the 11870 attachment's length. */ 11871 11872int 11873remote_target::remote_hostio_send_command (int command_bytes, int which_packet, 11874 int *remote_errno, char **attachment, 11875 int *attachment_len) 11876{ 11877 struct remote_state *rs = get_remote_state (); 11878 int ret, bytes_read; 11879 char *attachment_tmp; 11880 11881 if (packet_support (which_packet) == PACKET_DISABLE) 11882 { 11883 *remote_errno = FILEIO_ENOSYS; 11884 return -1; 11885 } 11886 11887 putpkt_binary (rs->buf.data (), command_bytes); 11888 bytes_read = getpkt_sane (&rs->buf, 0); 11889 11890 /* If it timed out, something is wrong. Don't try to parse the 11891 buffer. */ 11892 if (bytes_read < 0) 11893 { 11894 *remote_errno = FILEIO_EINVAL; 11895 return -1; 11896 } 11897 11898 switch (packet_ok (rs->buf, &remote_protocol_packets[which_packet])) 11899 { 11900 case PACKET_ERROR: 11901 *remote_errno = FILEIO_EINVAL; 11902 return -1; 11903 case PACKET_UNKNOWN: 11904 *remote_errno = FILEIO_ENOSYS; 11905 return -1; 11906 case PACKET_OK: 11907 break; 11908 } 11909 11910 if (remote_hostio_parse_result (rs->buf.data (), &ret, remote_errno, 11911 &attachment_tmp)) 11912 { 11913 *remote_errno = FILEIO_EINVAL; 11914 return -1; 11915 } 11916 11917 /* Make sure we saw an attachment if and only if we expected one. */ 11918 if ((attachment_tmp == NULL && attachment != NULL) 11919 || (attachment_tmp != NULL && attachment == NULL)) 11920 { 11921 *remote_errno = FILEIO_EINVAL; 11922 return -1; 11923 } 11924 11925 /* If an attachment was found, it must point into the packet buffer; 11926 work out how many bytes there were. */ 11927 if (attachment_tmp != NULL) 11928 { 11929 *attachment = attachment_tmp; 11930 *attachment_len = bytes_read - (*attachment - rs->buf.data ()); 11931 } 11932 11933 return ret; 11934} 11935 11936/* See declaration.h. */ 11937 11938void 11939readahead_cache::invalidate () 11940{ 11941 this->fd = -1; 11942} 11943 11944/* See declaration.h. */ 11945 11946void 11947readahead_cache::invalidate_fd (int fd) 11948{ 11949 if (this->fd == fd) 11950 this->fd = -1; 11951} 11952 11953/* Set the filesystem remote_hostio functions that take FILENAME 11954 arguments will use. Return 0 on success, or -1 if an error 11955 occurs (and set *REMOTE_ERRNO). */ 11956 11957int 11958remote_target::remote_hostio_set_filesystem (struct inferior *inf, 11959 int *remote_errno) 11960{ 11961 struct remote_state *rs = get_remote_state (); 11962 int required_pid = (inf == NULL || inf->fake_pid_p) ? 0 : inf->pid; 11963 char *p = rs->buf.data (); 11964 int left = get_remote_packet_size () - 1; 11965 char arg[9]; 11966 int ret; 11967 11968 if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE) 11969 return 0; 11970 11971 if (rs->fs_pid != -1 && required_pid == rs->fs_pid) 11972 return 0; 11973 11974 remote_buffer_add_string (&p, &left, "vFile:setfs:"); 11975 11976 xsnprintf (arg, sizeof (arg), "%x", required_pid); 11977 remote_buffer_add_string (&p, &left, arg); 11978 11979 ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_setfs, 11980 remote_errno, NULL, NULL); 11981 11982 if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE) 11983 return 0; 11984 11985 if (ret == 0) 11986 rs->fs_pid = required_pid; 11987 11988 return ret; 11989} 11990 11991/* Implementation of to_fileio_open. */ 11992 11993int 11994remote_target::remote_hostio_open (inferior *inf, const char *filename, 11995 int flags, int mode, int warn_if_slow, 11996 int *remote_errno) 11997{ 11998 struct remote_state *rs = get_remote_state (); 11999 char *p = rs->buf.data (); 12000 int left = get_remote_packet_size () - 1; 12001 12002 if (warn_if_slow) 12003 { 12004 static int warning_issued = 0; 12005 12006 printf_unfiltered (_("Reading %s from remote target...\n"), 12007 filename); 12008 12009 if (!warning_issued) 12010 { 12011 warning (_("File transfers from remote targets can be slow." 12012 " Use \"set sysroot\" to access files locally" 12013 " instead.")); 12014 warning_issued = 1; 12015 } 12016 } 12017 12018 if (remote_hostio_set_filesystem (inf, remote_errno) != 0) 12019 return -1; 12020 12021 remote_buffer_add_string (&p, &left, "vFile:open:"); 12022 12023 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, 12024 strlen (filename)); 12025 remote_buffer_add_string (&p, &left, ","); 12026 12027 remote_buffer_add_int (&p, &left, flags); 12028 remote_buffer_add_string (&p, &left, ","); 12029 12030 remote_buffer_add_int (&p, &left, mode); 12031 12032 return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_open, 12033 remote_errno, NULL, NULL); 12034} 12035 12036int 12037remote_target::fileio_open (struct inferior *inf, const char *filename, 12038 int flags, int mode, int warn_if_slow, 12039 int *remote_errno) 12040{ 12041 return remote_hostio_open (inf, filename, flags, mode, warn_if_slow, 12042 remote_errno); 12043} 12044 12045/* Implementation of to_fileio_pwrite. */ 12046 12047int 12048remote_target::remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len, 12049 ULONGEST offset, int *remote_errno) 12050{ 12051 struct remote_state *rs = get_remote_state (); 12052 char *p = rs->buf.data (); 12053 int left = get_remote_packet_size (); 12054 int out_len; 12055 12056 rs->readahead_cache.invalidate_fd (fd); 12057 12058 remote_buffer_add_string (&p, &left, "vFile:pwrite:"); 12059 12060 remote_buffer_add_int (&p, &left, fd); 12061 remote_buffer_add_string (&p, &left, ","); 12062 12063 remote_buffer_add_int (&p, &left, offset); 12064 remote_buffer_add_string (&p, &left, ","); 12065 12066 p += remote_escape_output (write_buf, len, 1, (gdb_byte *) p, &out_len, 12067 (get_remote_packet_size () 12068 - (p - rs->buf.data ()))); 12069 12070 return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pwrite, 12071 remote_errno, NULL, NULL); 12072} 12073 12074int 12075remote_target::fileio_pwrite (int fd, const gdb_byte *write_buf, int len, 12076 ULONGEST offset, int *remote_errno) 12077{ 12078 return remote_hostio_pwrite (fd, write_buf, len, offset, remote_errno); 12079} 12080 12081/* Helper for the implementation of to_fileio_pread. Read the file 12082 from the remote side with vFile:pread. */ 12083 12084int 12085remote_target::remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len, 12086 ULONGEST offset, int *remote_errno) 12087{ 12088 struct remote_state *rs = get_remote_state (); 12089 char *p = rs->buf.data (); 12090 char *attachment; 12091 int left = get_remote_packet_size (); 12092 int ret, attachment_len; 12093 int read_len; 12094 12095 remote_buffer_add_string (&p, &left, "vFile:pread:"); 12096 12097 remote_buffer_add_int (&p, &left, fd); 12098 remote_buffer_add_string (&p, &left, ","); 12099 12100 remote_buffer_add_int (&p, &left, len); 12101 remote_buffer_add_string (&p, &left, ","); 12102 12103 remote_buffer_add_int (&p, &left, offset); 12104 12105 ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pread, 12106 remote_errno, &attachment, 12107 &attachment_len); 12108 12109 if (ret < 0) 12110 return ret; 12111 12112 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len, 12113 read_buf, len); 12114 if (read_len != ret) 12115 error (_("Read returned %d, but %d bytes."), ret, (int) read_len); 12116 12117 return ret; 12118} 12119 12120/* See declaration.h. */ 12121 12122int 12123readahead_cache::pread (int fd, gdb_byte *read_buf, size_t len, 12124 ULONGEST offset) 12125{ 12126 if (this->fd == fd 12127 && this->offset <= offset 12128 && offset < this->offset + this->bufsize) 12129 { 12130 ULONGEST max = this->offset + this->bufsize; 12131 12132 if (offset + len > max) 12133 len = max - offset; 12134 12135 memcpy (read_buf, this->buf + offset - this->offset, len); 12136 return len; 12137 } 12138 12139 return 0; 12140} 12141 12142/* Implementation of to_fileio_pread. */ 12143 12144int 12145remote_target::remote_hostio_pread (int fd, gdb_byte *read_buf, int len, 12146 ULONGEST offset, int *remote_errno) 12147{ 12148 int ret; 12149 struct remote_state *rs = get_remote_state (); 12150 readahead_cache *cache = &rs->readahead_cache; 12151 12152 ret = cache->pread (fd, read_buf, len, offset); 12153 if (ret > 0) 12154 { 12155 cache->hit_count++; 12156 12157 if (remote_debug) 12158 fprintf_unfiltered (gdb_stdlog, "readahead cache hit %s\n", 12159 pulongest (cache->hit_count)); 12160 return ret; 12161 } 12162 12163 cache->miss_count++; 12164 if (remote_debug) 12165 fprintf_unfiltered (gdb_stdlog, "readahead cache miss %s\n", 12166 pulongest (cache->miss_count)); 12167 12168 cache->fd = fd; 12169 cache->offset = offset; 12170 cache->bufsize = get_remote_packet_size (); 12171 cache->buf = (gdb_byte *) xrealloc (cache->buf, cache->bufsize); 12172 12173 ret = remote_hostio_pread_vFile (cache->fd, cache->buf, cache->bufsize, 12174 cache->offset, remote_errno); 12175 if (ret <= 0) 12176 { 12177 cache->invalidate_fd (fd); 12178 return ret; 12179 } 12180 12181 cache->bufsize = ret; 12182 return cache->pread (fd, read_buf, len, offset); 12183} 12184 12185int 12186remote_target::fileio_pread (int fd, gdb_byte *read_buf, int len, 12187 ULONGEST offset, int *remote_errno) 12188{ 12189 return remote_hostio_pread (fd, read_buf, len, offset, remote_errno); 12190} 12191 12192/* Implementation of to_fileio_close. */ 12193 12194int 12195remote_target::remote_hostio_close (int fd, int *remote_errno) 12196{ 12197 struct remote_state *rs = get_remote_state (); 12198 char *p = rs->buf.data (); 12199 int left = get_remote_packet_size () - 1; 12200 12201 rs->readahead_cache.invalidate_fd (fd); 12202 12203 remote_buffer_add_string (&p, &left, "vFile:close:"); 12204 12205 remote_buffer_add_int (&p, &left, fd); 12206 12207 return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_close, 12208 remote_errno, NULL, NULL); 12209} 12210 12211int 12212remote_target::fileio_close (int fd, int *remote_errno) 12213{ 12214 return remote_hostio_close (fd, remote_errno); 12215} 12216 12217/* Implementation of to_fileio_unlink. */ 12218 12219int 12220remote_target::remote_hostio_unlink (inferior *inf, const char *filename, 12221 int *remote_errno) 12222{ 12223 struct remote_state *rs = get_remote_state (); 12224 char *p = rs->buf.data (); 12225 int left = get_remote_packet_size () - 1; 12226 12227 if (remote_hostio_set_filesystem (inf, remote_errno) != 0) 12228 return -1; 12229 12230 remote_buffer_add_string (&p, &left, "vFile:unlink:"); 12231 12232 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, 12233 strlen (filename)); 12234 12235 return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_unlink, 12236 remote_errno, NULL, NULL); 12237} 12238 12239int 12240remote_target::fileio_unlink (struct inferior *inf, const char *filename, 12241 int *remote_errno) 12242{ 12243 return remote_hostio_unlink (inf, filename, remote_errno); 12244} 12245 12246/* Implementation of to_fileio_readlink. */ 12247 12248gdb::optional<std::string> 12249remote_target::fileio_readlink (struct inferior *inf, const char *filename, 12250 int *remote_errno) 12251{ 12252 struct remote_state *rs = get_remote_state (); 12253 char *p = rs->buf.data (); 12254 char *attachment; 12255 int left = get_remote_packet_size (); 12256 int len, attachment_len; 12257 int read_len; 12258 12259 if (remote_hostio_set_filesystem (inf, remote_errno) != 0) 12260 return {}; 12261 12262 remote_buffer_add_string (&p, &left, "vFile:readlink:"); 12263 12264 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, 12265 strlen (filename)); 12266 12267 len = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_readlink, 12268 remote_errno, &attachment, 12269 &attachment_len); 12270 12271 if (len < 0) 12272 return {}; 12273 12274 std::string ret (len, '\0'); 12275 12276 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len, 12277 (gdb_byte *) &ret[0], len); 12278 if (read_len != len) 12279 error (_("Readlink returned %d, but %d bytes."), len, read_len); 12280 12281 return ret; 12282} 12283 12284/* Implementation of to_fileio_fstat. */ 12285 12286int 12287remote_target::fileio_fstat (int fd, struct stat *st, int *remote_errno) 12288{ 12289 struct remote_state *rs = get_remote_state (); 12290 char *p = rs->buf.data (); 12291 int left = get_remote_packet_size (); 12292 int attachment_len, ret; 12293 char *attachment; 12294 struct fio_stat fst; 12295 int read_len; 12296 12297 remote_buffer_add_string (&p, &left, "vFile:fstat:"); 12298 12299 remote_buffer_add_int (&p, &left, fd); 12300 12301 ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_fstat, 12302 remote_errno, &attachment, 12303 &attachment_len); 12304 if (ret < 0) 12305 { 12306 if (*remote_errno != FILEIO_ENOSYS) 12307 return ret; 12308 12309 /* Strictly we should return -1, ENOSYS here, but when 12310 "set sysroot remote:" was implemented in August 2008 12311 BFD's need for a stat function was sidestepped with 12312 this hack. This was not remedied until March 2015 12313 so we retain the previous behavior to avoid breaking 12314 compatibility. 12315 12316 Note that the memset is a March 2015 addition; older 12317 GDBs set st_size *and nothing else* so the structure 12318 would have garbage in all other fields. This might 12319 break something but retaining the previous behavior 12320 here would be just too wrong. */ 12321 12322 memset (st, 0, sizeof (struct stat)); 12323 st->st_size = INT_MAX; 12324 return 0; 12325 } 12326 12327 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len, 12328 (gdb_byte *) &fst, sizeof (fst)); 12329 12330 if (read_len != ret) 12331 error (_("vFile:fstat returned %d, but %d bytes."), ret, read_len); 12332 12333 if (read_len != sizeof (fst)) 12334 error (_("vFile:fstat returned %d bytes, but expecting %d."), 12335 read_len, (int) sizeof (fst)); 12336 12337 remote_fileio_to_host_stat (&fst, st); 12338 12339 return 0; 12340} 12341 12342/* Implementation of to_filesystem_is_local. */ 12343 12344bool 12345remote_target::filesystem_is_local () 12346{ 12347 /* Valgrind GDB presents itself as a remote target but works 12348 on the local filesystem: it does not implement remote get 12349 and users are not expected to set a sysroot. To handle 12350 this case we treat the remote filesystem as local if the 12351 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub 12352 does not support vFile:open. */ 12353 if (strcmp (gdb_sysroot, TARGET_SYSROOT_PREFIX) == 0) 12354 { 12355 enum packet_support ps = packet_support (PACKET_vFile_open); 12356 12357 if (ps == PACKET_SUPPORT_UNKNOWN) 12358 { 12359 int fd, remote_errno; 12360 12361 /* Try opening a file to probe support. The supplied 12362 filename is irrelevant, we only care about whether 12363 the stub recognizes the packet or not. */ 12364 fd = remote_hostio_open (NULL, "just probing", 12365 FILEIO_O_RDONLY, 0700, 0, 12366 &remote_errno); 12367 12368 if (fd >= 0) 12369 remote_hostio_close (fd, &remote_errno); 12370 12371 ps = packet_support (PACKET_vFile_open); 12372 } 12373 12374 if (ps == PACKET_DISABLE) 12375 { 12376 static int warning_issued = 0; 12377 12378 if (!warning_issued) 12379 { 12380 warning (_("remote target does not support file" 12381 " transfer, attempting to access files" 12382 " from local filesystem.")); 12383 warning_issued = 1; 12384 } 12385 12386 return true; 12387 } 12388 } 12389 12390 return false; 12391} 12392 12393static int 12394remote_fileio_errno_to_host (int errnum) 12395{ 12396 switch (errnum) 12397 { 12398 case FILEIO_EPERM: 12399 return EPERM; 12400 case FILEIO_ENOENT: 12401 return ENOENT; 12402 case FILEIO_EINTR: 12403 return EINTR; 12404 case FILEIO_EIO: 12405 return EIO; 12406 case FILEIO_EBADF: 12407 return EBADF; 12408 case FILEIO_EACCES: 12409 return EACCES; 12410 case FILEIO_EFAULT: 12411 return EFAULT; 12412 case FILEIO_EBUSY: 12413 return EBUSY; 12414 case FILEIO_EEXIST: 12415 return EEXIST; 12416 case FILEIO_ENODEV: 12417 return ENODEV; 12418 case FILEIO_ENOTDIR: 12419 return ENOTDIR; 12420 case FILEIO_EISDIR: 12421 return EISDIR; 12422 case FILEIO_EINVAL: 12423 return EINVAL; 12424 case FILEIO_ENFILE: 12425 return ENFILE; 12426 case FILEIO_EMFILE: 12427 return EMFILE; 12428 case FILEIO_EFBIG: 12429 return EFBIG; 12430 case FILEIO_ENOSPC: 12431 return ENOSPC; 12432 case FILEIO_ESPIPE: 12433 return ESPIPE; 12434 case FILEIO_EROFS: 12435 return EROFS; 12436 case FILEIO_ENOSYS: 12437 return ENOSYS; 12438 case FILEIO_ENAMETOOLONG: 12439 return ENAMETOOLONG; 12440 } 12441 return -1; 12442} 12443 12444static char * 12445remote_hostio_error (int errnum) 12446{ 12447 int host_error = remote_fileio_errno_to_host (errnum); 12448 12449 if (host_error == -1) 12450 error (_("Unknown remote I/O error %d"), errnum); 12451 else 12452 error (_("Remote I/O error: %s"), safe_strerror (host_error)); 12453} 12454 12455/* A RAII wrapper around a remote file descriptor. */ 12456 12457class scoped_remote_fd 12458{ 12459public: 12460 scoped_remote_fd (remote_target *remote, int fd) 12461 : m_remote (remote), m_fd (fd) 12462 { 12463 } 12464 12465 ~scoped_remote_fd () 12466 { 12467 if (m_fd != -1) 12468 { 12469 try 12470 { 12471 int remote_errno; 12472 m_remote->remote_hostio_close (m_fd, &remote_errno); 12473 } 12474 catch (...) 12475 { 12476 /* Swallow exception before it escapes the dtor. If 12477 something goes wrong, likely the connection is gone, 12478 and there's nothing else that can be done. */ 12479 } 12480 } 12481 } 12482 12483 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd); 12484 12485 /* Release ownership of the file descriptor, and return it. */ 12486 ATTRIBUTE_UNUSED_RESULT int release () noexcept 12487 { 12488 int fd = m_fd; 12489 m_fd = -1; 12490 return fd; 12491 } 12492 12493 /* Return the owned file descriptor. */ 12494 int get () const noexcept 12495 { 12496 return m_fd; 12497 } 12498 12499private: 12500 /* The remote target. */ 12501 remote_target *m_remote; 12502 12503 /* The owned remote I/O file descriptor. */ 12504 int m_fd; 12505}; 12506 12507void 12508remote_file_put (const char *local_file, const char *remote_file, int from_tty) 12509{ 12510 remote_target *remote = get_current_remote_target (); 12511 12512 if (remote == nullptr) 12513 error (_("command can only be used with remote target")); 12514 12515 remote->remote_file_put (local_file, remote_file, from_tty); 12516} 12517 12518void 12519remote_target::remote_file_put (const char *local_file, const char *remote_file, 12520 int from_tty) 12521{ 12522 int retcode, remote_errno, bytes, io_size; 12523 int bytes_in_buffer; 12524 int saw_eof; 12525 ULONGEST offset; 12526 12527 gdb_file_up file = gdb_fopen_cloexec (local_file, "rb"); 12528 if (file == NULL) 12529 perror_with_name (local_file); 12530 12531 scoped_remote_fd fd 12532 (this, remote_hostio_open (NULL, 12533 remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT 12534 | FILEIO_O_TRUNC), 12535 0700, 0, &remote_errno)); 12536 if (fd.get () == -1) 12537 remote_hostio_error (remote_errno); 12538 12539 /* Send up to this many bytes at once. They won't all fit in the 12540 remote packet limit, so we'll transfer slightly fewer. */ 12541 io_size = get_remote_packet_size (); 12542 gdb::byte_vector buffer (io_size); 12543 12544 bytes_in_buffer = 0; 12545 saw_eof = 0; 12546 offset = 0; 12547 while (bytes_in_buffer || !saw_eof) 12548 { 12549 if (!saw_eof) 12550 { 12551 bytes = fread (buffer.data () + bytes_in_buffer, 1, 12552 io_size - bytes_in_buffer, 12553 file.get ()); 12554 if (bytes == 0) 12555 { 12556 if (ferror (file.get ())) 12557 error (_("Error reading %s."), local_file); 12558 else 12559 { 12560 /* EOF. Unless there is something still in the 12561 buffer from the last iteration, we are done. */ 12562 saw_eof = 1; 12563 if (bytes_in_buffer == 0) 12564 break; 12565 } 12566 } 12567 } 12568 else 12569 bytes = 0; 12570 12571 bytes += bytes_in_buffer; 12572 bytes_in_buffer = 0; 12573 12574 retcode = remote_hostio_pwrite (fd.get (), buffer.data (), bytes, 12575 offset, &remote_errno); 12576 12577 if (retcode < 0) 12578 remote_hostio_error (remote_errno); 12579 else if (retcode == 0) 12580 error (_("Remote write of %d bytes returned 0!"), bytes); 12581 else if (retcode < bytes) 12582 { 12583 /* Short write. Save the rest of the read data for the next 12584 write. */ 12585 bytes_in_buffer = bytes - retcode; 12586 memmove (buffer.data (), buffer.data () + retcode, bytes_in_buffer); 12587 } 12588 12589 offset += retcode; 12590 } 12591 12592 if (remote_hostio_close (fd.release (), &remote_errno)) 12593 remote_hostio_error (remote_errno); 12594 12595 if (from_tty) 12596 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file); 12597} 12598 12599void 12600remote_file_get (const char *remote_file, const char *local_file, int from_tty) 12601{ 12602 remote_target *remote = get_current_remote_target (); 12603 12604 if (remote == nullptr) 12605 error (_("command can only be used with remote target")); 12606 12607 remote->remote_file_get (remote_file, local_file, from_tty); 12608} 12609 12610void 12611remote_target::remote_file_get (const char *remote_file, const char *local_file, 12612 int from_tty) 12613{ 12614 int remote_errno, bytes, io_size; 12615 ULONGEST offset; 12616 12617 scoped_remote_fd fd 12618 (this, remote_hostio_open (NULL, 12619 remote_file, FILEIO_O_RDONLY, 0, 0, 12620 &remote_errno)); 12621 if (fd.get () == -1) 12622 remote_hostio_error (remote_errno); 12623 12624 gdb_file_up file = gdb_fopen_cloexec (local_file, "wb"); 12625 if (file == NULL) 12626 perror_with_name (local_file); 12627 12628 /* Send up to this many bytes at once. They won't all fit in the 12629 remote packet limit, so we'll transfer slightly fewer. */ 12630 io_size = get_remote_packet_size (); 12631 gdb::byte_vector buffer (io_size); 12632 12633 offset = 0; 12634 while (1) 12635 { 12636 bytes = remote_hostio_pread (fd.get (), buffer.data (), io_size, offset, 12637 &remote_errno); 12638 if (bytes == 0) 12639 /* Success, but no bytes, means end-of-file. */ 12640 break; 12641 if (bytes == -1) 12642 remote_hostio_error (remote_errno); 12643 12644 offset += bytes; 12645 12646 bytes = fwrite (buffer.data (), 1, bytes, file.get ()); 12647 if (bytes == 0) 12648 perror_with_name (local_file); 12649 } 12650 12651 if (remote_hostio_close (fd.release (), &remote_errno)) 12652 remote_hostio_error (remote_errno); 12653 12654 if (from_tty) 12655 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file); 12656} 12657 12658void 12659remote_file_delete (const char *remote_file, int from_tty) 12660{ 12661 remote_target *remote = get_current_remote_target (); 12662 12663 if (remote == nullptr) 12664 error (_("command can only be used with remote target")); 12665 12666 remote->remote_file_delete (remote_file, from_tty); 12667} 12668 12669void 12670remote_target::remote_file_delete (const char *remote_file, int from_tty) 12671{ 12672 int retcode, remote_errno; 12673 12674 retcode = remote_hostio_unlink (NULL, remote_file, &remote_errno); 12675 if (retcode == -1) 12676 remote_hostio_error (remote_errno); 12677 12678 if (from_tty) 12679 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file); 12680} 12681 12682static void 12683remote_put_command (const char *args, int from_tty) 12684{ 12685 if (args == NULL) 12686 error_no_arg (_("file to put")); 12687 12688 gdb_argv argv (args); 12689 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL) 12690 error (_("Invalid parameters to remote put")); 12691 12692 remote_file_put (argv[0], argv[1], from_tty); 12693} 12694 12695static void 12696remote_get_command (const char *args, int from_tty) 12697{ 12698 if (args == NULL) 12699 error_no_arg (_("file to get")); 12700 12701 gdb_argv argv (args); 12702 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL) 12703 error (_("Invalid parameters to remote get")); 12704 12705 remote_file_get (argv[0], argv[1], from_tty); 12706} 12707 12708static void 12709remote_delete_command (const char *args, int from_tty) 12710{ 12711 if (args == NULL) 12712 error_no_arg (_("file to delete")); 12713 12714 gdb_argv argv (args); 12715 if (argv[0] == NULL || argv[1] != NULL) 12716 error (_("Invalid parameters to remote delete")); 12717 12718 remote_file_delete (argv[0], from_tty); 12719} 12720 12721bool 12722remote_target::can_execute_reverse () 12723{ 12724 if (packet_support (PACKET_bs) == PACKET_ENABLE 12725 || packet_support (PACKET_bc) == PACKET_ENABLE) 12726 return true; 12727 else 12728 return false; 12729} 12730 12731bool 12732remote_target::supports_non_stop () 12733{ 12734 return true; 12735} 12736 12737bool 12738remote_target::supports_disable_randomization () 12739{ 12740 /* Only supported in extended mode. */ 12741 return false; 12742} 12743 12744bool 12745remote_target::supports_multi_process () 12746{ 12747 struct remote_state *rs = get_remote_state (); 12748 12749 return remote_multi_process_p (rs); 12750} 12751 12752static int 12753remote_supports_cond_tracepoints () 12754{ 12755 return packet_support (PACKET_ConditionalTracepoints) == PACKET_ENABLE; 12756} 12757 12758bool 12759remote_target::supports_evaluation_of_breakpoint_conditions () 12760{ 12761 return packet_support (PACKET_ConditionalBreakpoints) == PACKET_ENABLE; 12762} 12763 12764static int 12765remote_supports_fast_tracepoints () 12766{ 12767 return packet_support (PACKET_FastTracepoints) == PACKET_ENABLE; 12768} 12769 12770static int 12771remote_supports_static_tracepoints () 12772{ 12773 return packet_support (PACKET_StaticTracepoints) == PACKET_ENABLE; 12774} 12775 12776static int 12777remote_supports_install_in_trace () 12778{ 12779 return packet_support (PACKET_InstallInTrace) == PACKET_ENABLE; 12780} 12781 12782bool 12783remote_target::supports_enable_disable_tracepoint () 12784{ 12785 return (packet_support (PACKET_EnableDisableTracepoints_feature) 12786 == PACKET_ENABLE); 12787} 12788 12789bool 12790remote_target::supports_string_tracing () 12791{ 12792 return packet_support (PACKET_tracenz_feature) == PACKET_ENABLE; 12793} 12794 12795bool 12796remote_target::can_run_breakpoint_commands () 12797{ 12798 return packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE; 12799} 12800 12801void 12802remote_target::trace_init () 12803{ 12804 struct remote_state *rs = get_remote_state (); 12805 12806 putpkt ("QTinit"); 12807 remote_get_noisy_reply (); 12808 if (strcmp (rs->buf.data (), "OK") != 0) 12809 error (_("Target does not support this command.")); 12810} 12811 12812/* Recursive routine to walk through command list including loops, and 12813 download packets for each command. */ 12814 12815void 12816remote_target::remote_download_command_source (int num, ULONGEST addr, 12817 struct command_line *cmds) 12818{ 12819 struct remote_state *rs = get_remote_state (); 12820 struct command_line *cmd; 12821 12822 for (cmd = cmds; cmd; cmd = cmd->next) 12823 { 12824 QUIT; /* Allow user to bail out with ^C. */ 12825 strcpy (rs->buf.data (), "QTDPsrc:"); 12826 encode_source_string (num, addr, "cmd", cmd->line, 12827 rs->buf.data () + strlen (rs->buf.data ()), 12828 rs->buf.size () - strlen (rs->buf.data ())); 12829 putpkt (rs->buf); 12830 remote_get_noisy_reply (); 12831 if (strcmp (rs->buf.data (), "OK")) 12832 warning (_("Target does not support source download.")); 12833 12834 if (cmd->control_type == while_control 12835 || cmd->control_type == while_stepping_control) 12836 { 12837 remote_download_command_source (num, addr, cmd->body_list_0.get ()); 12838 12839 QUIT; /* Allow user to bail out with ^C. */ 12840 strcpy (rs->buf.data (), "QTDPsrc:"); 12841 encode_source_string (num, addr, "cmd", "end", 12842 rs->buf.data () + strlen (rs->buf.data ()), 12843 rs->buf.size () - strlen (rs->buf.data ())); 12844 putpkt (rs->buf); 12845 remote_get_noisy_reply (); 12846 if (strcmp (rs->buf.data (), "OK")) 12847 warning (_("Target does not support source download.")); 12848 } 12849 } 12850} 12851 12852void 12853remote_target::download_tracepoint (struct bp_location *loc) 12854{ 12855 CORE_ADDR tpaddr; 12856 char addrbuf[40]; 12857 std::vector<std::string> tdp_actions; 12858 std::vector<std::string> stepping_actions; 12859 char *pkt; 12860 struct breakpoint *b = loc->owner; 12861 struct tracepoint *t = (struct tracepoint *) b; 12862 struct remote_state *rs = get_remote_state (); 12863 int ret; 12864 const char *err_msg = _("Tracepoint packet too large for target."); 12865 size_t size_left; 12866 12867 /* We use a buffer other than rs->buf because we'll build strings 12868 across multiple statements, and other statements in between could 12869 modify rs->buf. */ 12870 gdb::char_vector buf (get_remote_packet_size ()); 12871 12872 encode_actions_rsp (loc, &tdp_actions, &stepping_actions); 12873 12874 tpaddr = loc->address; 12875 strcpy (addrbuf, phex (tpaddr, sizeof (CORE_ADDR))); 12876 ret = snprintf (buf.data (), buf.size (), "QTDP:%x:%s:%c:%lx:%x", 12877 b->number, addrbuf, /* address */ 12878 (b->enable_state == bp_enabled ? 'E' : 'D'), 12879 t->step_count, t->pass_count); 12880 12881 if (ret < 0 || ret >= buf.size ()) 12882 error ("%s", err_msg); 12883 12884 /* Fast tracepoints are mostly handled by the target, but we can 12885 tell the target how big of an instruction block should be moved 12886 around. */ 12887 if (b->type == bp_fast_tracepoint) 12888 { 12889 /* Only test for support at download time; we may not know 12890 target capabilities at definition time. */ 12891 if (remote_supports_fast_tracepoints ()) 12892 { 12893 if (gdbarch_fast_tracepoint_valid_at (loc->gdbarch, tpaddr, 12894 NULL)) 12895 { 12896 size_left = buf.size () - strlen (buf.data ()); 12897 ret = snprintf (buf.data () + strlen (buf.data ()), 12898 size_left, ":F%x", 12899 gdb_insn_length (loc->gdbarch, tpaddr)); 12900 12901 if (ret < 0 || ret >= size_left) 12902 error ("%s", err_msg); 12903 } 12904 else 12905 /* If it passed validation at definition but fails now, 12906 something is very wrong. */ 12907 internal_error (__FILE__, __LINE__, 12908 _("Fast tracepoint not " 12909 "valid during download")); 12910 } 12911 else 12912 /* Fast tracepoints are functionally identical to regular 12913 tracepoints, so don't take lack of support as a reason to 12914 give up on the trace run. */ 12915 warning (_("Target does not support fast tracepoints, " 12916 "downloading %d as regular tracepoint"), b->number); 12917 } 12918 else if (b->type == bp_static_tracepoint) 12919 { 12920 /* Only test for support at download time; we may not know 12921 target capabilities at definition time. */ 12922 if (remote_supports_static_tracepoints ()) 12923 { 12924 struct static_tracepoint_marker marker; 12925 12926 if (target_static_tracepoint_marker_at (tpaddr, &marker)) 12927 { 12928 size_left = buf.size () - strlen (buf.data ()); 12929 ret = snprintf (buf.data () + strlen (buf.data ()), 12930 size_left, ":S"); 12931 12932 if (ret < 0 || ret >= size_left) 12933 error ("%s", err_msg); 12934 } 12935 else 12936 error (_("Static tracepoint not valid during download")); 12937 } 12938 else 12939 /* Fast tracepoints are functionally identical to regular 12940 tracepoints, so don't take lack of support as a reason 12941 to give up on the trace run. */ 12942 error (_("Target does not support static tracepoints")); 12943 } 12944 /* If the tracepoint has a conditional, make it into an agent 12945 expression and append to the definition. */ 12946 if (loc->cond) 12947 { 12948 /* Only test support at download time, we may not know target 12949 capabilities at definition time. */ 12950 if (remote_supports_cond_tracepoints ()) 12951 { 12952 agent_expr_up aexpr = gen_eval_for_expr (tpaddr, 12953 loc->cond.get ()); 12954 12955 size_left = buf.size () - strlen (buf.data ()); 12956 12957 ret = snprintf (buf.data () + strlen (buf.data ()), 12958 size_left, ":X%x,", aexpr->len); 12959 12960 if (ret < 0 || ret >= size_left) 12961 error ("%s", err_msg); 12962 12963 size_left = buf.size () - strlen (buf.data ()); 12964 12965 /* Two bytes to encode each aexpr byte, plus the terminating 12966 null byte. */ 12967 if (aexpr->len * 2 + 1 > size_left) 12968 error ("%s", err_msg); 12969 12970 pkt = buf.data () + strlen (buf.data ()); 12971 12972 for (int ndx = 0; ndx < aexpr->len; ++ndx) 12973 pkt = pack_hex_byte (pkt, aexpr->buf[ndx]); 12974 *pkt = '\0'; 12975 } 12976 else 12977 warning (_("Target does not support conditional tracepoints, " 12978 "ignoring tp %d cond"), b->number); 12979 } 12980 12981 if (b->commands || *default_collect) 12982 { 12983 size_left = buf.size () - strlen (buf.data ()); 12984 12985 ret = snprintf (buf.data () + strlen (buf.data ()), 12986 size_left, "-"); 12987 12988 if (ret < 0 || ret >= size_left) 12989 error ("%s", err_msg); 12990 } 12991 12992 putpkt (buf.data ()); 12993 remote_get_noisy_reply (); 12994 if (strcmp (rs->buf.data (), "OK")) 12995 error (_("Target does not support tracepoints.")); 12996 12997 /* do_single_steps (t); */ 12998 for (auto action_it = tdp_actions.begin (); 12999 action_it != tdp_actions.end (); action_it++) 13000 { 13001 QUIT; /* Allow user to bail out with ^C. */ 13002 13003 bool has_more = ((action_it + 1) != tdp_actions.end () 13004 || !stepping_actions.empty ()); 13005 13006 ret = snprintf (buf.data (), buf.size (), "QTDP:-%x:%s:%s%c", 13007 b->number, addrbuf, /* address */ 13008 action_it->c_str (), 13009 has_more ? '-' : 0); 13010 13011 if (ret < 0 || ret >= buf.size ()) 13012 error ("%s", err_msg); 13013 13014 putpkt (buf.data ()); 13015 remote_get_noisy_reply (); 13016 if (strcmp (rs->buf.data (), "OK")) 13017 error (_("Error on target while setting tracepoints.")); 13018 } 13019 13020 for (auto action_it = stepping_actions.begin (); 13021 action_it != stepping_actions.end (); action_it++) 13022 { 13023 QUIT; /* Allow user to bail out with ^C. */ 13024 13025 bool is_first = action_it == stepping_actions.begin (); 13026 bool has_more = (action_it + 1) != stepping_actions.end (); 13027 13028 ret = snprintf (buf.data (), buf.size (), "QTDP:-%x:%s:%s%s%s", 13029 b->number, addrbuf, /* address */ 13030 is_first ? "S" : "", 13031 action_it->c_str (), 13032 has_more ? "-" : ""); 13033 13034 if (ret < 0 || ret >= buf.size ()) 13035 error ("%s", err_msg); 13036 13037 putpkt (buf.data ()); 13038 remote_get_noisy_reply (); 13039 if (strcmp (rs->buf.data (), "OK")) 13040 error (_("Error on target while setting tracepoints.")); 13041 } 13042 13043 if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE) 13044 { 13045 if (b->location != NULL) 13046 { 13047 ret = snprintf (buf.data (), buf.size (), "QTDPsrc:"); 13048 13049 if (ret < 0 || ret >= buf.size ()) 13050 error ("%s", err_msg); 13051 13052 encode_source_string (b->number, loc->address, "at", 13053 event_location_to_string (b->location.get ()), 13054 buf.data () + strlen (buf.data ()), 13055 buf.size () - strlen (buf.data ())); 13056 putpkt (buf.data ()); 13057 remote_get_noisy_reply (); 13058 if (strcmp (rs->buf.data (), "OK")) 13059 warning (_("Target does not support source download.")); 13060 } 13061 if (b->cond_string) 13062 { 13063 ret = snprintf (buf.data (), buf.size (), "QTDPsrc:"); 13064 13065 if (ret < 0 || ret >= buf.size ()) 13066 error ("%s", err_msg); 13067 13068 encode_source_string (b->number, loc->address, 13069 "cond", b->cond_string, 13070 buf.data () + strlen (buf.data ()), 13071 buf.size () - strlen (buf.data ())); 13072 putpkt (buf.data ()); 13073 remote_get_noisy_reply (); 13074 if (strcmp (rs->buf.data (), "OK")) 13075 warning (_("Target does not support source download.")); 13076 } 13077 remote_download_command_source (b->number, loc->address, 13078 breakpoint_commands (b)); 13079 } 13080} 13081 13082bool 13083remote_target::can_download_tracepoint () 13084{ 13085 struct remote_state *rs = get_remote_state (); 13086 struct trace_status *ts; 13087 int status; 13088 13089 /* Don't try to install tracepoints until we've relocated our 13090 symbols, and fetched and merged the target's tracepoint list with 13091 ours. */ 13092 if (rs->starting_up) 13093 return false; 13094 13095 ts = current_trace_status (); 13096 status = get_trace_status (ts); 13097 13098 if (status == -1 || !ts->running_known || !ts->running) 13099 return false; 13100 13101 /* If we are in a tracing experiment, but remote stub doesn't support 13102 installing tracepoint in trace, we have to return. */ 13103 if (!remote_supports_install_in_trace ()) 13104 return false; 13105 13106 return true; 13107} 13108 13109 13110void 13111remote_target::download_trace_state_variable (const trace_state_variable &tsv) 13112{ 13113 struct remote_state *rs = get_remote_state (); 13114 char *p; 13115 13116 xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:", 13117 tsv.number, phex ((ULONGEST) tsv.initial_value, 8), 13118 tsv.builtin); 13119 p = rs->buf.data () + strlen (rs->buf.data ()); 13120 if ((p - rs->buf.data ()) + tsv.name.length () * 2 13121 >= get_remote_packet_size ()) 13122 error (_("Trace state variable name too long for tsv definition packet")); 13123 p += 2 * bin2hex ((gdb_byte *) (tsv.name.data ()), p, tsv.name.length ()); 13124 *p++ = '\0'; 13125 putpkt (rs->buf); 13126 remote_get_noisy_reply (); 13127 if (rs->buf[0] == '\0') 13128 error (_("Target does not support this command.")); 13129 if (strcmp (rs->buf.data (), "OK") != 0) 13130 error (_("Error on target while downloading trace state variable.")); 13131} 13132 13133void 13134remote_target::enable_tracepoint (struct bp_location *location) 13135{ 13136 struct remote_state *rs = get_remote_state (); 13137 13138 xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTEnable:%x:%s", 13139 location->owner->number, 13140 phex (location->address, sizeof (CORE_ADDR))); 13141 putpkt (rs->buf); 13142 remote_get_noisy_reply (); 13143 if (rs->buf[0] == '\0') 13144 error (_("Target does not support enabling tracepoints while a trace run is ongoing.")); 13145 if (strcmp (rs->buf.data (), "OK") != 0) 13146 error (_("Error on target while enabling tracepoint.")); 13147} 13148 13149void 13150remote_target::disable_tracepoint (struct bp_location *location) 13151{ 13152 struct remote_state *rs = get_remote_state (); 13153 13154 xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDisable:%x:%s", 13155 location->owner->number, 13156 phex (location->address, sizeof (CORE_ADDR))); 13157 putpkt (rs->buf); 13158 remote_get_noisy_reply (); 13159 if (rs->buf[0] == '\0') 13160 error (_("Target does not support disabling tracepoints while a trace run is ongoing.")); 13161 if (strcmp (rs->buf.data (), "OK") != 0) 13162 error (_("Error on target while disabling tracepoint.")); 13163} 13164 13165void 13166remote_target::trace_set_readonly_regions () 13167{ 13168 asection *s; 13169 bfd_size_type size; 13170 bfd_vma vma; 13171 int anysecs = 0; 13172 int offset = 0; 13173 13174 if (!exec_bfd) 13175 return; /* No information to give. */ 13176 13177 struct remote_state *rs = get_remote_state (); 13178 13179 strcpy (rs->buf.data (), "QTro"); 13180 offset = strlen (rs->buf.data ()); 13181 for (s = exec_bfd->sections; s; s = s->next) 13182 { 13183 char tmp1[40], tmp2[40]; 13184 int sec_length; 13185 13186 if ((s->flags & SEC_LOAD) == 0 || 13187 /* (s->flags & SEC_CODE) == 0 || */ 13188 (s->flags & SEC_READONLY) == 0) 13189 continue; 13190 13191 anysecs = 1; 13192 vma = bfd_section_vma (s); 13193 size = bfd_section_size (s); 13194 sprintf_vma (tmp1, vma); 13195 sprintf_vma (tmp2, vma + size); 13196 sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2); 13197 if (offset + sec_length + 1 > rs->buf.size ()) 13198 { 13199 if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE) 13200 warning (_("\ 13201Too many sections for read-only sections definition packet.")); 13202 break; 13203 } 13204 xsnprintf (rs->buf.data () + offset, rs->buf.size () - offset, ":%s,%s", 13205 tmp1, tmp2); 13206 offset += sec_length; 13207 } 13208 if (anysecs) 13209 { 13210 putpkt (rs->buf); 13211 getpkt (&rs->buf, 0); 13212 } 13213} 13214 13215void 13216remote_target::trace_start () 13217{ 13218 struct remote_state *rs = get_remote_state (); 13219 13220 putpkt ("QTStart"); 13221 remote_get_noisy_reply (); 13222 if (rs->buf[0] == '\0') 13223 error (_("Target does not support this command.")); 13224 if (strcmp (rs->buf.data (), "OK") != 0) 13225 error (_("Bogus reply from target: %s"), rs->buf.data ()); 13226} 13227 13228int 13229remote_target::get_trace_status (struct trace_status *ts) 13230{ 13231 /* Initialize it just to avoid a GCC false warning. */ 13232 char *p = NULL; 13233 enum packet_result result; 13234 struct remote_state *rs = get_remote_state (); 13235 13236 if (packet_support (PACKET_qTStatus) == PACKET_DISABLE) 13237 return -1; 13238 13239 /* FIXME we need to get register block size some other way. */ 13240 trace_regblock_size 13241 = rs->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet; 13242 13243 putpkt ("qTStatus"); 13244 13245 try 13246 { 13247 p = remote_get_noisy_reply (); 13248 } 13249 catch (const gdb_exception_error &ex) 13250 { 13251 if (ex.error != TARGET_CLOSE_ERROR) 13252 { 13253 exception_fprintf (gdb_stderr, ex, "qTStatus: "); 13254 return -1; 13255 } 13256 throw; 13257 } 13258 13259 result = packet_ok (p, &remote_protocol_packets[PACKET_qTStatus]); 13260 13261 /* If the remote target doesn't do tracing, flag it. */ 13262 if (result == PACKET_UNKNOWN) 13263 return -1; 13264 13265 /* We're working with a live target. */ 13266 ts->filename = NULL; 13267 13268 if (*p++ != 'T') 13269 error (_("Bogus trace status reply from target: %s"), rs->buf.data ()); 13270 13271 /* Function 'parse_trace_status' sets default value of each field of 13272 'ts' at first, so we don't have to do it here. */ 13273 parse_trace_status (p, ts); 13274 13275 return ts->running; 13276} 13277 13278void 13279remote_target::get_tracepoint_status (struct breakpoint *bp, 13280 struct uploaded_tp *utp) 13281{ 13282 struct remote_state *rs = get_remote_state (); 13283 char *reply; 13284 struct bp_location *loc; 13285 struct tracepoint *tp = (struct tracepoint *) bp; 13286 size_t size = get_remote_packet_size (); 13287 13288 if (tp) 13289 { 13290 tp->hit_count = 0; 13291 tp->traceframe_usage = 0; 13292 for (loc = tp->loc; loc; loc = loc->next) 13293 { 13294 /* If the tracepoint was never downloaded, don't go asking for 13295 any status. */ 13296 if (tp->number_on_target == 0) 13297 continue; 13298 xsnprintf (rs->buf.data (), size, "qTP:%x:%s", tp->number_on_target, 13299 phex_nz (loc->address, 0)); 13300 putpkt (rs->buf); 13301 reply = remote_get_noisy_reply (); 13302 if (reply && *reply) 13303 { 13304 if (*reply == 'V') 13305 parse_tracepoint_status (reply + 1, bp, utp); 13306 } 13307 } 13308 } 13309 else if (utp) 13310 { 13311 utp->hit_count = 0; 13312 utp->traceframe_usage = 0; 13313 xsnprintf (rs->buf.data (), size, "qTP:%x:%s", utp->number, 13314 phex_nz (utp->addr, 0)); 13315 putpkt (rs->buf); 13316 reply = remote_get_noisy_reply (); 13317 if (reply && *reply) 13318 { 13319 if (*reply == 'V') 13320 parse_tracepoint_status (reply + 1, bp, utp); 13321 } 13322 } 13323} 13324 13325void 13326remote_target::trace_stop () 13327{ 13328 struct remote_state *rs = get_remote_state (); 13329 13330 putpkt ("QTStop"); 13331 remote_get_noisy_reply (); 13332 if (rs->buf[0] == '\0') 13333 error (_("Target does not support this command.")); 13334 if (strcmp (rs->buf.data (), "OK") != 0) 13335 error (_("Bogus reply from target: %s"), rs->buf.data ()); 13336} 13337 13338int 13339remote_target::trace_find (enum trace_find_type type, int num, 13340 CORE_ADDR addr1, CORE_ADDR addr2, 13341 int *tpp) 13342{ 13343 struct remote_state *rs = get_remote_state (); 13344 char *endbuf = rs->buf.data () + get_remote_packet_size (); 13345 char *p, *reply; 13346 int target_frameno = -1, target_tracept = -1; 13347 13348 /* Lookups other than by absolute frame number depend on the current 13349 trace selected, so make sure it is correct on the remote end 13350 first. */ 13351 if (type != tfind_number) 13352 set_remote_traceframe (); 13353 13354 p = rs->buf.data (); 13355 strcpy (p, "QTFrame:"); 13356 p = strchr (p, '\0'); 13357 switch (type) 13358 { 13359 case tfind_number: 13360 xsnprintf (p, endbuf - p, "%x", num); 13361 break; 13362 case tfind_pc: 13363 xsnprintf (p, endbuf - p, "pc:%s", phex_nz (addr1, 0)); 13364 break; 13365 case tfind_tp: 13366 xsnprintf (p, endbuf - p, "tdp:%x", num); 13367 break; 13368 case tfind_range: 13369 xsnprintf (p, endbuf - p, "range:%s:%s", phex_nz (addr1, 0), 13370 phex_nz (addr2, 0)); 13371 break; 13372 case tfind_outside: 13373 xsnprintf (p, endbuf - p, "outside:%s:%s", phex_nz (addr1, 0), 13374 phex_nz (addr2, 0)); 13375 break; 13376 default: 13377 error (_("Unknown trace find type %d"), type); 13378 } 13379 13380 putpkt (rs->buf); 13381 reply = remote_get_noisy_reply (); 13382 if (*reply == '\0') 13383 error (_("Target does not support this command.")); 13384 13385 while (reply && *reply) 13386 switch (*reply) 13387 { 13388 case 'F': 13389 p = ++reply; 13390 target_frameno = (int) strtol (p, &reply, 16); 13391 if (reply == p) 13392 error (_("Unable to parse trace frame number")); 13393 /* Don't update our remote traceframe number cache on failure 13394 to select a remote traceframe. */ 13395 if (target_frameno == -1) 13396 return -1; 13397 break; 13398 case 'T': 13399 p = ++reply; 13400 target_tracept = (int) strtol (p, &reply, 16); 13401 if (reply == p) 13402 error (_("Unable to parse tracepoint number")); 13403 break; 13404 case 'O': /* "OK"? */ 13405 if (reply[1] == 'K' && reply[2] == '\0') 13406 reply += 2; 13407 else 13408 error (_("Bogus reply from target: %s"), reply); 13409 break; 13410 default: 13411 error (_("Bogus reply from target: %s"), reply); 13412 } 13413 if (tpp) 13414 *tpp = target_tracept; 13415 13416 rs->remote_traceframe_number = target_frameno; 13417 return target_frameno; 13418} 13419 13420bool 13421remote_target::get_trace_state_variable_value (int tsvnum, LONGEST *val) 13422{ 13423 struct remote_state *rs = get_remote_state (); 13424 char *reply; 13425 ULONGEST uval; 13426 13427 set_remote_traceframe (); 13428 13429 xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTV:%x", tsvnum); 13430 putpkt (rs->buf); 13431 reply = remote_get_noisy_reply (); 13432 if (reply && *reply) 13433 { 13434 if (*reply == 'V') 13435 { 13436 unpack_varlen_hex (reply + 1, &uval); 13437 *val = (LONGEST) uval; 13438 return true; 13439 } 13440 } 13441 return false; 13442} 13443 13444int 13445remote_target::save_trace_data (const char *filename) 13446{ 13447 struct remote_state *rs = get_remote_state (); 13448 char *p, *reply; 13449 13450 p = rs->buf.data (); 13451 strcpy (p, "QTSave:"); 13452 p += strlen (p); 13453 if ((p - rs->buf.data ()) + strlen (filename) * 2 13454 >= get_remote_packet_size ()) 13455 error (_("Remote file name too long for trace save packet")); 13456 p += 2 * bin2hex ((gdb_byte *) filename, p, strlen (filename)); 13457 *p++ = '\0'; 13458 putpkt (rs->buf); 13459 reply = remote_get_noisy_reply (); 13460 if (*reply == '\0') 13461 error (_("Target does not support this command.")); 13462 if (strcmp (reply, "OK") != 0) 13463 error (_("Bogus reply from target: %s"), reply); 13464 return 0; 13465} 13466 13467/* This is basically a memory transfer, but needs to be its own packet 13468 because we don't know how the target actually organizes its trace 13469 memory, plus we want to be able to ask for as much as possible, but 13470 not be unhappy if we don't get as much as we ask for. */ 13471 13472LONGEST 13473remote_target::get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len) 13474{ 13475 struct remote_state *rs = get_remote_state (); 13476 char *reply; 13477 char *p; 13478 int rslt; 13479 13480 p = rs->buf.data (); 13481 strcpy (p, "qTBuffer:"); 13482 p += strlen (p); 13483 p += hexnumstr (p, offset); 13484 *p++ = ','; 13485 p += hexnumstr (p, len); 13486 *p++ = '\0'; 13487 13488 putpkt (rs->buf); 13489 reply = remote_get_noisy_reply (); 13490 if (reply && *reply) 13491 { 13492 /* 'l' by itself means we're at the end of the buffer and 13493 there is nothing more to get. */ 13494 if (*reply == 'l') 13495 return 0; 13496 13497 /* Convert the reply into binary. Limit the number of bytes to 13498 convert according to our passed-in buffer size, rather than 13499 what was returned in the packet; if the target is 13500 unexpectedly generous and gives us a bigger reply than we 13501 asked for, we don't want to crash. */ 13502 rslt = hex2bin (reply, buf, len); 13503 return rslt; 13504 } 13505 13506 /* Something went wrong, flag as an error. */ 13507 return -1; 13508} 13509 13510void 13511remote_target::set_disconnected_tracing (int val) 13512{ 13513 struct remote_state *rs = get_remote_state (); 13514 13515 if (packet_support (PACKET_DisconnectedTracing_feature) == PACKET_ENABLE) 13516 { 13517 char *reply; 13518 13519 xsnprintf (rs->buf.data (), get_remote_packet_size (), 13520 "QTDisconnected:%x", val); 13521 putpkt (rs->buf); 13522 reply = remote_get_noisy_reply (); 13523 if (*reply == '\0') 13524 error (_("Target does not support this command.")); 13525 if (strcmp (reply, "OK") != 0) 13526 error (_("Bogus reply from target: %s"), reply); 13527 } 13528 else if (val) 13529 warning (_("Target does not support disconnected tracing.")); 13530} 13531 13532int 13533remote_target::core_of_thread (ptid_t ptid) 13534{ 13535 thread_info *info = find_thread_ptid (this, ptid); 13536 13537 if (info != NULL && info->priv != NULL) 13538 return get_remote_thread_info (info)->core; 13539 13540 return -1; 13541} 13542 13543void 13544remote_target::set_circular_trace_buffer (int val) 13545{ 13546 struct remote_state *rs = get_remote_state (); 13547 char *reply; 13548 13549 xsnprintf (rs->buf.data (), get_remote_packet_size (), 13550 "QTBuffer:circular:%x", val); 13551 putpkt (rs->buf); 13552 reply = remote_get_noisy_reply (); 13553 if (*reply == '\0') 13554 error (_("Target does not support this command.")); 13555 if (strcmp (reply, "OK") != 0) 13556 error (_("Bogus reply from target: %s"), reply); 13557} 13558 13559traceframe_info_up 13560remote_target::traceframe_info () 13561{ 13562 gdb::optional<gdb::char_vector> text 13563 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO, 13564 NULL); 13565 if (text) 13566 return parse_traceframe_info (text->data ()); 13567 13568 return NULL; 13569} 13570 13571/* Handle the qTMinFTPILen packet. Returns the minimum length of 13572 instruction on which a fast tracepoint may be placed. Returns -1 13573 if the packet is not supported, and 0 if the minimum instruction 13574 length is unknown. */ 13575 13576int 13577remote_target::get_min_fast_tracepoint_insn_len () 13578{ 13579 struct remote_state *rs = get_remote_state (); 13580 char *reply; 13581 13582 /* If we're not debugging a process yet, the IPA can't be 13583 loaded. */ 13584 if (!target_has_execution) 13585 return 0; 13586 13587 /* Make sure the remote is pointing at the right process. */ 13588 set_general_process (); 13589 13590 xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTMinFTPILen"); 13591 putpkt (rs->buf); 13592 reply = remote_get_noisy_reply (); 13593 if (*reply == '\0') 13594 return -1; 13595 else 13596 { 13597 ULONGEST min_insn_len; 13598 13599 unpack_varlen_hex (reply, &min_insn_len); 13600 13601 return (int) min_insn_len; 13602 } 13603} 13604 13605void 13606remote_target::set_trace_buffer_size (LONGEST val) 13607{ 13608 if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE) 13609 { 13610 struct remote_state *rs = get_remote_state (); 13611 char *buf = rs->buf.data (); 13612 char *endbuf = buf + get_remote_packet_size (); 13613 enum packet_result result; 13614 13615 gdb_assert (val >= 0 || val == -1); 13616 buf += xsnprintf (buf, endbuf - buf, "QTBuffer:size:"); 13617 /* Send -1 as literal "-1" to avoid host size dependency. */ 13618 if (val < 0) 13619 { 13620 *buf++ = '-'; 13621 buf += hexnumstr (buf, (ULONGEST) -val); 13622 } 13623 else 13624 buf += hexnumstr (buf, (ULONGEST) val); 13625 13626 putpkt (rs->buf); 13627 remote_get_noisy_reply (); 13628 result = packet_ok (rs->buf, 13629 &remote_protocol_packets[PACKET_QTBuffer_size]); 13630 13631 if (result != PACKET_OK) 13632 warning (_("Bogus reply from target: %s"), rs->buf.data ()); 13633 } 13634} 13635 13636bool 13637remote_target::set_trace_notes (const char *user, const char *notes, 13638 const char *stop_notes) 13639{ 13640 struct remote_state *rs = get_remote_state (); 13641 char *reply; 13642 char *buf = rs->buf.data (); 13643 char *endbuf = buf + get_remote_packet_size (); 13644 int nbytes; 13645 13646 buf += xsnprintf (buf, endbuf - buf, "QTNotes:"); 13647 if (user) 13648 { 13649 buf += xsnprintf (buf, endbuf - buf, "user:"); 13650 nbytes = bin2hex ((gdb_byte *) user, buf, strlen (user)); 13651 buf += 2 * nbytes; 13652 *buf++ = ';'; 13653 } 13654 if (notes) 13655 { 13656 buf += xsnprintf (buf, endbuf - buf, "notes:"); 13657 nbytes = bin2hex ((gdb_byte *) notes, buf, strlen (notes)); 13658 buf += 2 * nbytes; 13659 *buf++ = ';'; 13660 } 13661 if (stop_notes) 13662 { 13663 buf += xsnprintf (buf, endbuf - buf, "tstop:"); 13664 nbytes = bin2hex ((gdb_byte *) stop_notes, buf, strlen (stop_notes)); 13665 buf += 2 * nbytes; 13666 *buf++ = ';'; 13667 } 13668 /* Ensure the buffer is terminated. */ 13669 *buf = '\0'; 13670 13671 putpkt (rs->buf); 13672 reply = remote_get_noisy_reply (); 13673 if (*reply == '\0') 13674 return false; 13675 13676 if (strcmp (reply, "OK") != 0) 13677 error (_("Bogus reply from target: %s"), reply); 13678 13679 return true; 13680} 13681 13682bool 13683remote_target::use_agent (bool use) 13684{ 13685 if (packet_support (PACKET_QAgent) != PACKET_DISABLE) 13686 { 13687 struct remote_state *rs = get_remote_state (); 13688 13689 /* If the stub supports QAgent. */ 13690 xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAgent:%d", use); 13691 putpkt (rs->buf); 13692 getpkt (&rs->buf, 0); 13693 13694 if (strcmp (rs->buf.data (), "OK") == 0) 13695 { 13696 ::use_agent = use; 13697 return true; 13698 } 13699 } 13700 13701 return false; 13702} 13703 13704bool 13705remote_target::can_use_agent () 13706{ 13707 return (packet_support (PACKET_QAgent) != PACKET_DISABLE); 13708} 13709 13710struct btrace_target_info 13711{ 13712 /* The ptid of the traced thread. */ 13713 ptid_t ptid; 13714 13715 /* The obtained branch trace configuration. */ 13716 struct btrace_config conf; 13717}; 13718 13719/* Reset our idea of our target's btrace configuration. */ 13720 13721static void 13722remote_btrace_reset (remote_state *rs) 13723{ 13724 memset (&rs->btrace_config, 0, sizeof (rs->btrace_config)); 13725} 13726 13727/* Synchronize the configuration with the target. */ 13728 13729void 13730remote_target::btrace_sync_conf (const btrace_config *conf) 13731{ 13732 struct packet_config *packet; 13733 struct remote_state *rs; 13734 char *buf, *pos, *endbuf; 13735 13736 rs = get_remote_state (); 13737 buf = rs->buf.data (); 13738 endbuf = buf + get_remote_packet_size (); 13739 13740 packet = &remote_protocol_packets[PACKET_Qbtrace_conf_bts_size]; 13741 if (packet_config_support (packet) == PACKET_ENABLE 13742 && conf->bts.size != rs->btrace_config.bts.size) 13743 { 13744 pos = buf; 13745 pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name, 13746 conf->bts.size); 13747 13748 putpkt (buf); 13749 getpkt (&rs->buf, 0); 13750 13751 if (packet_ok (buf, packet) == PACKET_ERROR) 13752 { 13753 if (buf[0] == 'E' && buf[1] == '.') 13754 error (_("Failed to configure the BTS buffer size: %s"), buf + 2); 13755 else 13756 error (_("Failed to configure the BTS buffer size.")); 13757 } 13758 13759 rs->btrace_config.bts.size = conf->bts.size; 13760 } 13761 13762 packet = &remote_protocol_packets[PACKET_Qbtrace_conf_pt_size]; 13763 if (packet_config_support (packet) == PACKET_ENABLE 13764 && conf->pt.size != rs->btrace_config.pt.size) 13765 { 13766 pos = buf; 13767 pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name, 13768 conf->pt.size); 13769 13770 putpkt (buf); 13771 getpkt (&rs->buf, 0); 13772 13773 if (packet_ok (buf, packet) == PACKET_ERROR) 13774 { 13775 if (buf[0] == 'E' && buf[1] == '.') 13776 error (_("Failed to configure the trace buffer size: %s"), buf + 2); 13777 else 13778 error (_("Failed to configure the trace buffer size.")); 13779 } 13780 13781 rs->btrace_config.pt.size = conf->pt.size; 13782 } 13783} 13784 13785/* Read the current thread's btrace configuration from the target and 13786 store it into CONF. */ 13787 13788static void 13789btrace_read_config (struct btrace_config *conf) 13790{ 13791 gdb::optional<gdb::char_vector> xml 13792 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF, ""); 13793 if (xml) 13794 parse_xml_btrace_conf (conf, xml->data ()); 13795} 13796 13797/* Maybe reopen target btrace. */ 13798 13799void 13800remote_target::remote_btrace_maybe_reopen () 13801{ 13802 struct remote_state *rs = get_remote_state (); 13803 int btrace_target_pushed = 0; 13804#if !defined (HAVE_LIBIPT) 13805 int warned = 0; 13806#endif 13807 13808 /* Don't bother walking the entirety of the remote thread list when 13809 we know the feature isn't supported by the remote. */ 13810 if (packet_support (PACKET_qXfer_btrace_conf) != PACKET_ENABLE) 13811 return; 13812 13813 scoped_restore_current_thread restore_thread; 13814 13815 for (thread_info *tp : all_non_exited_threads (this)) 13816 { 13817 set_general_thread (tp->ptid); 13818 13819 memset (&rs->btrace_config, 0x00, sizeof (struct btrace_config)); 13820 btrace_read_config (&rs->btrace_config); 13821 13822 if (rs->btrace_config.format == BTRACE_FORMAT_NONE) 13823 continue; 13824 13825#if !defined (HAVE_LIBIPT) 13826 if (rs->btrace_config.format == BTRACE_FORMAT_PT) 13827 { 13828 if (!warned) 13829 { 13830 warned = 1; 13831 warning (_("Target is recording using Intel Processor Trace " 13832 "but support was disabled at compile time.")); 13833 } 13834 13835 continue; 13836 } 13837#endif /* !defined (HAVE_LIBIPT) */ 13838 13839 /* Push target, once, but before anything else happens. This way our 13840 changes to the threads will be cleaned up by unpushing the target 13841 in case btrace_read_config () throws. */ 13842 if (!btrace_target_pushed) 13843 { 13844 btrace_target_pushed = 1; 13845 record_btrace_push_target (); 13846 printf_filtered (_("Target is recording using %s.\n"), 13847 btrace_format_string (rs->btrace_config.format)); 13848 } 13849 13850 tp->btrace.target = XCNEW (struct btrace_target_info); 13851 tp->btrace.target->ptid = tp->ptid; 13852 tp->btrace.target->conf = rs->btrace_config; 13853 } 13854} 13855 13856/* Enable branch tracing. */ 13857 13858struct btrace_target_info * 13859remote_target::enable_btrace (ptid_t ptid, const struct btrace_config *conf) 13860{ 13861 struct btrace_target_info *tinfo = NULL; 13862 struct packet_config *packet = NULL; 13863 struct remote_state *rs = get_remote_state (); 13864 char *buf = rs->buf.data (); 13865 char *endbuf = buf + get_remote_packet_size (); 13866 13867 switch (conf->format) 13868 { 13869 case BTRACE_FORMAT_BTS: 13870 packet = &remote_protocol_packets[PACKET_Qbtrace_bts]; 13871 break; 13872 13873 case BTRACE_FORMAT_PT: 13874 packet = &remote_protocol_packets[PACKET_Qbtrace_pt]; 13875 break; 13876 } 13877 13878 if (packet == NULL || packet_config_support (packet) != PACKET_ENABLE) 13879 error (_("Target does not support branch tracing.")); 13880 13881 btrace_sync_conf (conf); 13882 13883 set_general_thread (ptid); 13884 13885 buf += xsnprintf (buf, endbuf - buf, "%s", packet->name); 13886 putpkt (rs->buf); 13887 getpkt (&rs->buf, 0); 13888 13889 if (packet_ok (rs->buf, packet) == PACKET_ERROR) 13890 { 13891 if (rs->buf[0] == 'E' && rs->buf[1] == '.') 13892 error (_("Could not enable branch tracing for %s: %s"), 13893 target_pid_to_str (ptid).c_str (), &rs->buf[2]); 13894 else 13895 error (_("Could not enable branch tracing for %s."), 13896 target_pid_to_str (ptid).c_str ()); 13897 } 13898 13899 tinfo = XCNEW (struct btrace_target_info); 13900 tinfo->ptid = ptid; 13901 13902 /* If we fail to read the configuration, we lose some information, but the 13903 tracing itself is not impacted. */ 13904 try 13905 { 13906 btrace_read_config (&tinfo->conf); 13907 } 13908 catch (const gdb_exception_error &err) 13909 { 13910 if (err.message != NULL) 13911 warning ("%s", err.what ()); 13912 } 13913 13914 return tinfo; 13915} 13916 13917/* Disable branch tracing. */ 13918 13919void 13920remote_target::disable_btrace (struct btrace_target_info *tinfo) 13921{ 13922 struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_off]; 13923 struct remote_state *rs = get_remote_state (); 13924 char *buf = rs->buf.data (); 13925 char *endbuf = buf + get_remote_packet_size (); 13926 13927 if (packet_config_support (packet) != PACKET_ENABLE) 13928 error (_("Target does not support branch tracing.")); 13929 13930 set_general_thread (tinfo->ptid); 13931 13932 buf += xsnprintf (buf, endbuf - buf, "%s", packet->name); 13933 putpkt (rs->buf); 13934 getpkt (&rs->buf, 0); 13935 13936 if (packet_ok (rs->buf, packet) == PACKET_ERROR) 13937 { 13938 if (rs->buf[0] == 'E' && rs->buf[1] == '.') 13939 error (_("Could not disable branch tracing for %s: %s"), 13940 target_pid_to_str (tinfo->ptid).c_str (), &rs->buf[2]); 13941 else 13942 error (_("Could not disable branch tracing for %s."), 13943 target_pid_to_str (tinfo->ptid).c_str ()); 13944 } 13945 13946 xfree (tinfo); 13947} 13948 13949/* Teardown branch tracing. */ 13950 13951void 13952remote_target::teardown_btrace (struct btrace_target_info *tinfo) 13953{ 13954 /* We must not talk to the target during teardown. */ 13955 xfree (tinfo); 13956} 13957 13958/* Read the branch trace. */ 13959 13960enum btrace_error 13961remote_target::read_btrace (struct btrace_data *btrace, 13962 struct btrace_target_info *tinfo, 13963 enum btrace_read_type type) 13964{ 13965 struct packet_config *packet = &remote_protocol_packets[PACKET_qXfer_btrace]; 13966 const char *annex; 13967 13968 if (packet_config_support (packet) != PACKET_ENABLE) 13969 error (_("Target does not support branch tracing.")); 13970 13971#if !defined(HAVE_LIBEXPAT) 13972 error (_("Cannot process branch tracing result. XML parsing not supported.")); 13973#endif 13974 13975 switch (type) 13976 { 13977 case BTRACE_READ_ALL: 13978 annex = "all"; 13979 break; 13980 case BTRACE_READ_NEW: 13981 annex = "new"; 13982 break; 13983 case BTRACE_READ_DELTA: 13984 annex = "delta"; 13985 break; 13986 default: 13987 internal_error (__FILE__, __LINE__, 13988 _("Bad branch tracing read type: %u."), 13989 (unsigned int) type); 13990 } 13991 13992 gdb::optional<gdb::char_vector> xml 13993 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE, annex); 13994 if (!xml) 13995 return BTRACE_ERR_UNKNOWN; 13996 13997 parse_xml_btrace (btrace, xml->data ()); 13998 13999 return BTRACE_ERR_NONE; 14000} 14001 14002const struct btrace_config * 14003remote_target::btrace_conf (const struct btrace_target_info *tinfo) 14004{ 14005 return &tinfo->conf; 14006} 14007 14008bool 14009remote_target::augmented_libraries_svr4_read () 14010{ 14011 return (packet_support (PACKET_augmented_libraries_svr4_read_feature) 14012 == PACKET_ENABLE); 14013} 14014 14015/* Implementation of to_load. */ 14016 14017void 14018remote_target::load (const char *name, int from_tty) 14019{ 14020 generic_load (name, from_tty); 14021} 14022 14023/* Accepts an integer PID; returns a string representing a file that 14024 can be opened on the remote side to get the symbols for the child 14025 process. Returns NULL if the operation is not supported. */ 14026 14027char * 14028remote_target::pid_to_exec_file (int pid) 14029{ 14030 static gdb::optional<gdb::char_vector> filename; 14031 char *annex = NULL; 14032 14033 if (packet_support (PACKET_qXfer_exec_file) != PACKET_ENABLE) 14034 return NULL; 14035 14036 inferior *inf = find_inferior_pid (this, pid); 14037 if (inf == NULL) 14038 internal_error (__FILE__, __LINE__, 14039 _("not currently attached to process %d"), pid); 14040 14041 if (!inf->fake_pid_p) 14042 { 14043 const int annex_size = 9; 14044 14045 annex = (char *) alloca (annex_size); 14046 xsnprintf (annex, annex_size, "%x", pid); 14047 } 14048 14049 filename = target_read_stralloc (current_top_target (), 14050 TARGET_OBJECT_EXEC_FILE, annex); 14051 14052 return filename ? filename->data () : nullptr; 14053} 14054 14055/* Implement the to_can_do_single_step target_ops method. */ 14056 14057int 14058remote_target::can_do_single_step () 14059{ 14060 /* We can only tell whether target supports single step or not by 14061 supported s and S vCont actions if the stub supports vContSupported 14062 feature. If the stub doesn't support vContSupported feature, 14063 we have conservatively to think target doesn't supports single 14064 step. */ 14065 if (packet_support (PACKET_vContSupported) == PACKET_ENABLE) 14066 { 14067 struct remote_state *rs = get_remote_state (); 14068 14069 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN) 14070 remote_vcont_probe (); 14071 14072 return rs->supports_vCont.s && rs->supports_vCont.S; 14073 } 14074 else 14075 return 0; 14076} 14077 14078/* Implementation of the to_execution_direction method for the remote 14079 target. */ 14080 14081enum exec_direction_kind 14082remote_target::execution_direction () 14083{ 14084 struct remote_state *rs = get_remote_state (); 14085 14086 return rs->last_resume_exec_dir; 14087} 14088 14089/* Return pointer to the thread_info struct which corresponds to 14090 THREAD_HANDLE (having length HANDLE_LEN). */ 14091 14092thread_info * 14093remote_target::thread_handle_to_thread_info (const gdb_byte *thread_handle, 14094 int handle_len, 14095 inferior *inf) 14096{ 14097 for (thread_info *tp : all_non_exited_threads (this)) 14098 { 14099 remote_thread_info *priv = get_remote_thread_info (tp); 14100 14101 if (tp->inf == inf && priv != NULL) 14102 { 14103 if (handle_len != priv->thread_handle.size ()) 14104 error (_("Thread handle size mismatch: %d vs %zu (from remote)"), 14105 handle_len, priv->thread_handle.size ()); 14106 if (memcmp (thread_handle, priv->thread_handle.data (), 14107 handle_len) == 0) 14108 return tp; 14109 } 14110 } 14111 14112 return NULL; 14113} 14114 14115gdb::byte_vector 14116remote_target::thread_info_to_thread_handle (struct thread_info *tp) 14117{ 14118 remote_thread_info *priv = get_remote_thread_info (tp); 14119 return priv->thread_handle; 14120} 14121 14122bool 14123remote_target::can_async_p () 14124{ 14125 struct remote_state *rs = get_remote_state (); 14126 14127 /* We don't go async if the user has explicitly prevented it with the 14128 "maint set target-async" command. */ 14129 if (!target_async_permitted) 14130 return false; 14131 14132 /* We're async whenever the serial device is. */ 14133 return serial_can_async_p (rs->remote_desc); 14134} 14135 14136bool 14137remote_target::is_async_p () 14138{ 14139 struct remote_state *rs = get_remote_state (); 14140 14141 if (!target_async_permitted) 14142 /* We only enable async when the user specifically asks for it. */ 14143 return false; 14144 14145 /* We're async whenever the serial device is. */ 14146 return serial_is_async_p (rs->remote_desc); 14147} 14148 14149/* Pass the SERIAL event on and up to the client. One day this code 14150 will be able to delay notifying the client of an event until the 14151 point where an entire packet has been received. */ 14152 14153static serial_event_ftype remote_async_serial_handler; 14154 14155static void 14156remote_async_serial_handler (struct serial *scb, void *context) 14157{ 14158 /* Don't propogate error information up to the client. Instead let 14159 the client find out about the error by querying the target. */ 14160 inferior_event_handler (INF_REG_EVENT); 14161} 14162 14163static void 14164remote_async_inferior_event_handler (gdb_client_data data) 14165{ 14166 inferior_event_handler (INF_REG_EVENT); 14167 14168 remote_target *remote = (remote_target *) data; 14169 remote_state *rs = remote->get_remote_state (); 14170 14171 /* inferior_event_handler may have consumed an event pending on the 14172 infrun side without calling target_wait on the REMOTE target, or 14173 may have pulled an event out of a different target. Keep trying 14174 for this remote target as long it still has either pending events 14175 or unacknowledged notifications. */ 14176 14177 if (rs->notif_state->pending_event[notif_client_stop.id] != NULL 14178 || !rs->stop_reply_queue.empty ()) 14179 mark_async_event_handler (rs->remote_async_inferior_event_token); 14180} 14181 14182int 14183remote_target::async_wait_fd () 14184{ 14185 struct remote_state *rs = get_remote_state (); 14186 return rs->remote_desc->fd; 14187} 14188 14189void 14190remote_target::async (int enable) 14191{ 14192 struct remote_state *rs = get_remote_state (); 14193 14194 if (enable) 14195 { 14196 serial_async (rs->remote_desc, remote_async_serial_handler, rs); 14197 14198 /* If there are pending events in the stop reply queue tell the 14199 event loop to process them. */ 14200 if (!rs->stop_reply_queue.empty ()) 14201 mark_async_event_handler (rs->remote_async_inferior_event_token); 14202 /* For simplicity, below we clear the pending events token 14203 without remembering whether it is marked, so here we always 14204 mark it. If there's actually no pending notification to 14205 process, this ends up being a no-op (other than a spurious 14206 event-loop wakeup). */ 14207 if (target_is_non_stop_p ()) 14208 mark_async_event_handler (rs->notif_state->get_pending_events_token); 14209 } 14210 else 14211 { 14212 serial_async (rs->remote_desc, NULL, NULL); 14213 /* If the core is disabling async, it doesn't want to be 14214 disturbed with target events. Clear all async event sources 14215 too. */ 14216 clear_async_event_handler (rs->remote_async_inferior_event_token); 14217 if (target_is_non_stop_p ()) 14218 clear_async_event_handler (rs->notif_state->get_pending_events_token); 14219 } 14220} 14221 14222/* Implementation of the to_thread_events method. */ 14223 14224void 14225remote_target::thread_events (int enable) 14226{ 14227 struct remote_state *rs = get_remote_state (); 14228 size_t size = get_remote_packet_size (); 14229 14230 if (packet_support (PACKET_QThreadEvents) == PACKET_DISABLE) 14231 return; 14232 14233 xsnprintf (rs->buf.data (), size, "QThreadEvents:%x", enable ? 1 : 0); 14234 putpkt (rs->buf); 14235 getpkt (&rs->buf, 0); 14236 14237 switch (packet_ok (rs->buf, 14238 &remote_protocol_packets[PACKET_QThreadEvents])) 14239 { 14240 case PACKET_OK: 14241 if (strcmp (rs->buf.data (), "OK") != 0) 14242 error (_("Remote refused setting thread events: %s"), rs->buf.data ()); 14243 break; 14244 case PACKET_ERROR: 14245 warning (_("Remote failure reply: %s"), rs->buf.data ()); 14246 break; 14247 case PACKET_UNKNOWN: 14248 break; 14249 } 14250} 14251 14252static void 14253show_remote_cmd (const char *args, int from_tty) 14254{ 14255 /* We can't just use cmd_show_list here, because we want to skip 14256 the redundant "show remote Z-packet" and the legacy aliases. */ 14257 struct cmd_list_element *list = remote_show_cmdlist; 14258 struct ui_out *uiout = current_uiout; 14259 14260 ui_out_emit_tuple tuple_emitter (uiout, "showlist"); 14261 for (; list != NULL; list = list->next) 14262 if (strcmp (list->name, "Z-packet") == 0) 14263 continue; 14264 else if (list->type == not_set_cmd) 14265 /* Alias commands are exactly like the original, except they 14266 don't have the normal type. */ 14267 continue; 14268 else 14269 { 14270 ui_out_emit_tuple option_emitter (uiout, "option"); 14271 14272 uiout->field_string ("name", list->name); 14273 uiout->text (": "); 14274 if (list->type == show_cmd) 14275 do_show_command (NULL, from_tty, list); 14276 else 14277 cmd_func (list, NULL, from_tty); 14278 } 14279} 14280 14281 14282/* Function to be called whenever a new objfile (shlib) is detected. */ 14283static void 14284remote_new_objfile (struct objfile *objfile) 14285{ 14286 remote_target *remote = get_current_remote_target (); 14287 14288 if (remote != NULL) /* Have a remote connection. */ 14289 remote->remote_check_symbols (); 14290} 14291 14292/* Pull all the tracepoints defined on the target and create local 14293 data structures representing them. We don't want to create real 14294 tracepoints yet, we don't want to mess up the user's existing 14295 collection. */ 14296 14297int 14298remote_target::upload_tracepoints (struct uploaded_tp **utpp) 14299{ 14300 struct remote_state *rs = get_remote_state (); 14301 char *p; 14302 14303 /* Ask for a first packet of tracepoint definition. */ 14304 putpkt ("qTfP"); 14305 getpkt (&rs->buf, 0); 14306 p = rs->buf.data (); 14307 while (*p && *p != 'l') 14308 { 14309 parse_tracepoint_definition (p, utpp); 14310 /* Ask for another packet of tracepoint definition. */ 14311 putpkt ("qTsP"); 14312 getpkt (&rs->buf, 0); 14313 p = rs->buf.data (); 14314 } 14315 return 0; 14316} 14317 14318int 14319remote_target::upload_trace_state_variables (struct uploaded_tsv **utsvp) 14320{ 14321 struct remote_state *rs = get_remote_state (); 14322 char *p; 14323 14324 /* Ask for a first packet of variable definition. */ 14325 putpkt ("qTfV"); 14326 getpkt (&rs->buf, 0); 14327 p = rs->buf.data (); 14328 while (*p && *p != 'l') 14329 { 14330 parse_tsv_definition (p, utsvp); 14331 /* Ask for another packet of variable definition. */ 14332 putpkt ("qTsV"); 14333 getpkt (&rs->buf, 0); 14334 p = rs->buf.data (); 14335 } 14336 return 0; 14337} 14338 14339/* The "set/show range-stepping" show hook. */ 14340 14341static void 14342show_range_stepping (struct ui_file *file, int from_tty, 14343 struct cmd_list_element *c, 14344 const char *value) 14345{ 14346 fprintf_filtered (file, 14347 _("Debugger's willingness to use range stepping " 14348 "is %s.\n"), value); 14349} 14350 14351/* Return true if the vCont;r action is supported by the remote 14352 stub. */ 14353 14354bool 14355remote_target::vcont_r_supported () 14356{ 14357 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN) 14358 remote_vcont_probe (); 14359 14360 return (packet_support (PACKET_vCont) == PACKET_ENABLE 14361 && get_remote_state ()->supports_vCont.r); 14362} 14363 14364/* The "set/show range-stepping" set hook. */ 14365 14366static void 14367set_range_stepping (const char *ignore_args, int from_tty, 14368 struct cmd_list_element *c) 14369{ 14370 /* When enabling, check whether range stepping is actually supported 14371 by the target, and warn if not. */ 14372 if (use_range_stepping) 14373 { 14374 remote_target *remote = get_current_remote_target (); 14375 if (remote == NULL 14376 || !remote->vcont_r_supported ()) 14377 warning (_("Range stepping is not supported by the current target")); 14378 } 14379} 14380 14381void _initialize_remote (); 14382void 14383_initialize_remote () 14384{ 14385 struct cmd_list_element *cmd; 14386 const char *cmd_name; 14387 14388 /* architecture specific data */ 14389 remote_g_packet_data_handle = 14390 gdbarch_data_register_pre_init (remote_g_packet_data_init); 14391 14392 add_target (remote_target_info, remote_target::open); 14393 add_target (extended_remote_target_info, extended_remote_target::open); 14394 14395 /* Hook into new objfile notification. */ 14396 gdb::observers::new_objfile.attach (remote_new_objfile); 14397 14398#if 0 14399 init_remote_threadtests (); 14400#endif 14401 14402 /* set/show remote ... */ 14403 14404 add_basic_prefix_cmd ("remote", class_maintenance, _("\ 14405Remote protocol specific variables.\n\ 14406Configure various remote-protocol specific variables such as\n\ 14407the packets being used."), 14408 &remote_set_cmdlist, "set remote ", 14409 0 /* allow-unknown */, &setlist); 14410 add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\ 14411Remote protocol specific variables.\n\ 14412Configure various remote-protocol specific variables such as\n\ 14413the packets being used."), 14414 &remote_show_cmdlist, "show remote ", 14415 0 /* allow-unknown */, &showlist); 14416 14417 add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\ 14418Compare section data on target to the exec file.\n\ 14419Argument is a single section name (default: all loaded sections).\n\ 14420To compare only read-only loaded sections, specify the -r option."), 14421 &cmdlist); 14422 14423 add_cmd ("packet", class_maintenance, packet_command, _("\ 14424Send an arbitrary packet to a remote target.\n\ 14425 maintenance packet TEXT\n\ 14426If GDB is talking to an inferior via the GDB serial protocol, then\n\ 14427this command sends the string TEXT to the inferior, and displays the\n\ 14428response packet. GDB supplies the initial `$' character, and the\n\ 14429terminating `#' character and checksum."), 14430 &maintenancelist); 14431 14432 add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\ 14433Set whether to send break if interrupted."), _("\ 14434Show whether to send break if interrupted."), _("\ 14435If set, a break, instead of a cntrl-c, is sent to the remote target."), 14436 set_remotebreak, show_remotebreak, 14437 &setlist, &showlist); 14438 cmd_name = "remotebreak"; 14439 cmd = lookup_cmd (&cmd_name, setlist, "", NULL, -1, 1); 14440 deprecate_cmd (cmd, "set remote interrupt-sequence"); 14441 cmd_name = "remotebreak"; /* needed because lookup_cmd updates the pointer */ 14442 cmd = lookup_cmd (&cmd_name, showlist, "", NULL, -1, 1); 14443 deprecate_cmd (cmd, "show remote interrupt-sequence"); 14444 14445 add_setshow_enum_cmd ("interrupt-sequence", class_support, 14446 interrupt_sequence_modes, &interrupt_sequence_mode, 14447 _("\ 14448Set interrupt sequence to remote target."), _("\ 14449Show interrupt sequence to remote target."), _("\ 14450Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."), 14451 NULL, show_interrupt_sequence, 14452 &remote_set_cmdlist, 14453 &remote_show_cmdlist); 14454 14455 add_setshow_boolean_cmd ("interrupt-on-connect", class_support, 14456 &interrupt_on_connect, _("\ 14457Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\ 14458Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\ 14459If set, interrupt sequence is sent to remote target."), 14460 NULL, NULL, 14461 &remote_set_cmdlist, &remote_show_cmdlist); 14462 14463 /* Install commands for configuring memory read/write packets. */ 14464 14465 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\ 14466Set the maximum number of bytes per memory write packet (deprecated)."), 14467 &setlist); 14468 add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\ 14469Show the maximum number of bytes per memory write packet (deprecated)."), 14470 &showlist); 14471 add_cmd ("memory-write-packet-size", no_class, 14472 set_memory_write_packet_size, _("\ 14473Set the maximum number of bytes per memory-write packet.\n\ 14474Specify the number of bytes in a packet or 0 (zero) for the\n\ 14475default packet size. The actual limit is further reduced\n\ 14476dependent on the target. Specify ``fixed'' to disable the\n\ 14477further restriction and ``limit'' to enable that restriction."), 14478 &remote_set_cmdlist); 14479 add_cmd ("memory-read-packet-size", no_class, 14480 set_memory_read_packet_size, _("\ 14481Set the maximum number of bytes per memory-read packet.\n\ 14482Specify the number of bytes in a packet or 0 (zero) for the\n\ 14483default packet size. The actual limit is further reduced\n\ 14484dependent on the target. Specify ``fixed'' to disable the\n\ 14485further restriction and ``limit'' to enable that restriction."), 14486 &remote_set_cmdlist); 14487 add_cmd ("memory-write-packet-size", no_class, 14488 show_memory_write_packet_size, 14489 _("Show the maximum number of bytes per memory-write packet."), 14490 &remote_show_cmdlist); 14491 add_cmd ("memory-read-packet-size", no_class, 14492 show_memory_read_packet_size, 14493 _("Show the maximum number of bytes per memory-read packet."), 14494 &remote_show_cmdlist); 14495 14496 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class, 14497 &remote_hw_watchpoint_limit, _("\ 14498Set the maximum number of target hardware watchpoints."), _("\ 14499Show the maximum number of target hardware watchpoints."), _("\ 14500Specify \"unlimited\" for unlimited hardware watchpoints."), 14501 NULL, show_hardware_watchpoint_limit, 14502 &remote_set_cmdlist, 14503 &remote_show_cmdlist); 14504 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit", 14505 no_class, 14506 &remote_hw_watchpoint_length_limit, _("\ 14507Set the maximum length (in bytes) of a target hardware watchpoint."), _("\ 14508Show the maximum length (in bytes) of a target hardware watchpoint."), _("\ 14509Specify \"unlimited\" to allow watchpoints of unlimited size."), 14510 NULL, show_hardware_watchpoint_length_limit, 14511 &remote_set_cmdlist, &remote_show_cmdlist); 14512 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class, 14513 &remote_hw_breakpoint_limit, _("\ 14514Set the maximum number of target hardware breakpoints."), _("\ 14515Show the maximum number of target hardware breakpoints."), _("\ 14516Specify \"unlimited\" for unlimited hardware breakpoints."), 14517 NULL, show_hardware_breakpoint_limit, 14518 &remote_set_cmdlist, &remote_show_cmdlist); 14519 14520 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure, 14521 &remote_address_size, _("\ 14522Set the maximum size of the address (in bits) in a memory packet."), _("\ 14523Show the maximum size of the address (in bits) in a memory packet."), NULL, 14524 NULL, 14525 NULL, /* FIXME: i18n: */ 14526 &setlist, &showlist); 14527 14528 init_all_packet_configs (); 14529 14530 add_packet_config_cmd (&remote_protocol_packets[PACKET_X], 14531 "X", "binary-download", 1); 14532 14533 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont], 14534 "vCont", "verbose-resume", 0); 14535 14536 add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals], 14537 "QPassSignals", "pass-signals", 0); 14538 14539 add_packet_config_cmd (&remote_protocol_packets[PACKET_QCatchSyscalls], 14540 "QCatchSyscalls", "catch-syscalls", 0); 14541 14542 add_packet_config_cmd (&remote_protocol_packets[PACKET_QProgramSignals], 14543 "QProgramSignals", "program-signals", 0); 14544 14545 add_packet_config_cmd (&remote_protocol_packets[PACKET_QSetWorkingDir], 14546 "QSetWorkingDir", "set-working-dir", 0); 14547 14548 add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartupWithShell], 14549 "QStartupWithShell", "startup-with-shell", 0); 14550 14551 add_packet_config_cmd (&remote_protocol_packets 14552 [PACKET_QEnvironmentHexEncoded], 14553 "QEnvironmentHexEncoded", "environment-hex-encoded", 14554 0); 14555 14556 add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentReset], 14557 "QEnvironmentReset", "environment-reset", 14558 0); 14559 14560 add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentUnset], 14561 "QEnvironmentUnset", "environment-unset", 14562 0); 14563 14564 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol], 14565 "qSymbol", "symbol-lookup", 0); 14566 14567 add_packet_config_cmd (&remote_protocol_packets[PACKET_P], 14568 "P", "set-register", 1); 14569 14570 add_packet_config_cmd (&remote_protocol_packets[PACKET_p], 14571 "p", "fetch-register", 1); 14572 14573 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0], 14574 "Z0", "software-breakpoint", 0); 14575 14576 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1], 14577 "Z1", "hardware-breakpoint", 0); 14578 14579 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2], 14580 "Z2", "write-watchpoint", 0); 14581 14582 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3], 14583 "Z3", "read-watchpoint", 0); 14584 14585 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4], 14586 "Z4", "access-watchpoint", 0); 14587 14588 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv], 14589 "qXfer:auxv:read", "read-aux-vector", 0); 14590 14591 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_exec_file], 14592 "qXfer:exec-file:read", "pid-to-exec-file", 0); 14593 14594 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features], 14595 "qXfer:features:read", "target-features", 0); 14596 14597 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries], 14598 "qXfer:libraries:read", "library-info", 0); 14599 14600 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries_svr4], 14601 "qXfer:libraries-svr4:read", "library-info-svr4", 0); 14602 14603 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map], 14604 "qXfer:memory-map:read", "memory-map", 0); 14605 14606 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata], 14607 "qXfer:osdata:read", "osdata", 0); 14608 14609 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_threads], 14610 "qXfer:threads:read", "threads", 0); 14611 14612 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_read], 14613 "qXfer:siginfo:read", "read-siginfo-object", 0); 14614 14615 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write], 14616 "qXfer:siginfo:write", "write-siginfo-object", 0); 14617 14618 add_packet_config_cmd 14619 (&remote_protocol_packets[PACKET_qXfer_traceframe_info], 14620 "qXfer:traceframe-info:read", "traceframe-info", 0); 14621 14622 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_uib], 14623 "qXfer:uib:read", "unwind-info-block", 0); 14624 14625 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr], 14626 "qGetTLSAddr", "get-thread-local-storage-address", 14627 0); 14628 14629 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTIBAddr], 14630 "qGetTIBAddr", "get-thread-information-block-address", 14631 0); 14632 14633 add_packet_config_cmd (&remote_protocol_packets[PACKET_bc], 14634 "bc", "reverse-continue", 0); 14635 14636 add_packet_config_cmd (&remote_protocol_packets[PACKET_bs], 14637 "bs", "reverse-step", 0); 14638 14639 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported], 14640 "qSupported", "supported-packets", 0); 14641 14642 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSearch_memory], 14643 "qSearch:memory", "search-memory", 0); 14644 14645 add_packet_config_cmd (&remote_protocol_packets[PACKET_qTStatus], 14646 "qTStatus", "trace-status", 0); 14647 14648 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_setfs], 14649 "vFile:setfs", "hostio-setfs", 0); 14650 14651 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_open], 14652 "vFile:open", "hostio-open", 0); 14653 14654 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pread], 14655 "vFile:pread", "hostio-pread", 0); 14656 14657 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pwrite], 14658 "vFile:pwrite", "hostio-pwrite", 0); 14659 14660 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_close], 14661 "vFile:close", "hostio-close", 0); 14662 14663 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink], 14664 "vFile:unlink", "hostio-unlink", 0); 14665 14666 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_readlink], 14667 "vFile:readlink", "hostio-readlink", 0); 14668 14669 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_fstat], 14670 "vFile:fstat", "hostio-fstat", 0); 14671 14672 add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach], 14673 "vAttach", "attach", 0); 14674 14675 add_packet_config_cmd (&remote_protocol_packets[PACKET_vRun], 14676 "vRun", "run", 0); 14677 14678 add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartNoAckMode], 14679 "QStartNoAckMode", "noack", 0); 14680 14681 add_packet_config_cmd (&remote_protocol_packets[PACKET_vKill], 14682 "vKill", "kill", 0); 14683 14684 add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached], 14685 "qAttached", "query-attached", 0); 14686 14687 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints], 14688 "ConditionalTracepoints", 14689 "conditional-tracepoints", 0); 14690 14691 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalBreakpoints], 14692 "ConditionalBreakpoints", 14693 "conditional-breakpoints", 0); 14694 14695 add_packet_config_cmd (&remote_protocol_packets[PACKET_BreakpointCommands], 14696 "BreakpointCommands", 14697 "breakpoint-commands", 0); 14698 14699 add_packet_config_cmd (&remote_protocol_packets[PACKET_FastTracepoints], 14700 "FastTracepoints", "fast-tracepoints", 0); 14701 14702 add_packet_config_cmd (&remote_protocol_packets[PACKET_TracepointSource], 14703 "TracepointSource", "TracepointSource", 0); 14704 14705 add_packet_config_cmd (&remote_protocol_packets[PACKET_QAllow], 14706 "QAllow", "allow", 0); 14707 14708 add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints], 14709 "StaticTracepoints", "static-tracepoints", 0); 14710 14711 add_packet_config_cmd (&remote_protocol_packets[PACKET_InstallInTrace], 14712 "InstallInTrace", "install-in-trace", 0); 14713 14714 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read], 14715 "qXfer:statictrace:read", "read-sdata-object", 0); 14716 14717 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_fdpic], 14718 "qXfer:fdpic:read", "read-fdpic-loadmap", 0); 14719 14720 add_packet_config_cmd (&remote_protocol_packets[PACKET_QDisableRandomization], 14721 "QDisableRandomization", "disable-randomization", 0); 14722 14723 add_packet_config_cmd (&remote_protocol_packets[PACKET_QAgent], 14724 "QAgent", "agent", 0); 14725 14726 add_packet_config_cmd (&remote_protocol_packets[PACKET_QTBuffer_size], 14727 "QTBuffer:size", "trace-buffer-size", 0); 14728 14729 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_off], 14730 "Qbtrace:off", "disable-btrace", 0); 14731 14732 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_bts], 14733 "Qbtrace:bts", "enable-btrace-bts", 0); 14734 14735 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_pt], 14736 "Qbtrace:pt", "enable-btrace-pt", 0); 14737 14738 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace], 14739 "qXfer:btrace", "read-btrace", 0); 14740 14741 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace_conf], 14742 "qXfer:btrace-conf", "read-btrace-conf", 0); 14743 14744 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_bts_size], 14745 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0); 14746 14747 add_packet_config_cmd (&remote_protocol_packets[PACKET_multiprocess_feature], 14748 "multiprocess-feature", "multiprocess-feature", 0); 14749 14750 add_packet_config_cmd (&remote_protocol_packets[PACKET_swbreak_feature], 14751 "swbreak-feature", "swbreak-feature", 0); 14752 14753 add_packet_config_cmd (&remote_protocol_packets[PACKET_hwbreak_feature], 14754 "hwbreak-feature", "hwbreak-feature", 0); 14755 14756 add_packet_config_cmd (&remote_protocol_packets[PACKET_fork_event_feature], 14757 "fork-event-feature", "fork-event-feature", 0); 14758 14759 add_packet_config_cmd (&remote_protocol_packets[PACKET_vfork_event_feature], 14760 "vfork-event-feature", "vfork-event-feature", 0); 14761 14762 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_pt_size], 14763 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0); 14764 14765 add_packet_config_cmd (&remote_protocol_packets[PACKET_vContSupported], 14766 "vContSupported", "verbose-resume-supported", 0); 14767 14768 add_packet_config_cmd (&remote_protocol_packets[PACKET_exec_event_feature], 14769 "exec-event-feature", "exec-event-feature", 0); 14770 14771 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCtrlC], 14772 "vCtrlC", "ctrl-c", 0); 14773 14774 add_packet_config_cmd (&remote_protocol_packets[PACKET_QThreadEvents], 14775 "QThreadEvents", "thread-events", 0); 14776 14777 add_packet_config_cmd (&remote_protocol_packets[PACKET_no_resumed], 14778 "N stop reply", "no-resumed-stop-reply", 0); 14779 14780 /* Assert that we've registered "set remote foo-packet" commands 14781 for all packet configs. */ 14782 { 14783 int i; 14784 14785 for (i = 0; i < PACKET_MAX; i++) 14786 { 14787 /* Ideally all configs would have a command associated. Some 14788 still don't though. */ 14789 int excepted; 14790 14791 switch (i) 14792 { 14793 case PACKET_QNonStop: 14794 case PACKET_EnableDisableTracepoints_feature: 14795 case PACKET_tracenz_feature: 14796 case PACKET_DisconnectedTracing_feature: 14797 case PACKET_augmented_libraries_svr4_read_feature: 14798 case PACKET_qCRC: 14799 /* Additions to this list need to be well justified: 14800 pre-existing packets are OK; new packets are not. */ 14801 excepted = 1; 14802 break; 14803 default: 14804 excepted = 0; 14805 break; 14806 } 14807 14808 /* This catches both forgetting to add a config command, and 14809 forgetting to remove a packet from the exception list. */ 14810 gdb_assert (excepted == (remote_protocol_packets[i].name == NULL)); 14811 } 14812 } 14813 14814 /* Keep the old ``set remote Z-packet ...'' working. Each individual 14815 Z sub-packet has its own set and show commands, but users may 14816 have sets to this variable in their .gdbinit files (or in their 14817 documentation). */ 14818 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure, 14819 &remote_Z_packet_detect, _("\ 14820Set use of remote protocol `Z' packets."), _("\ 14821Show use of remote protocol `Z' packets."), _("\ 14822When set, GDB will attempt to use the remote breakpoint and watchpoint\n\ 14823packets."), 14824 set_remote_protocol_Z_packet_cmd, 14825 show_remote_protocol_Z_packet_cmd, 14826 /* FIXME: i18n: Use of remote protocol 14827 `Z' packets is %s. */ 14828 &remote_set_cmdlist, &remote_show_cmdlist); 14829 14830 add_basic_prefix_cmd ("remote", class_files, _("\ 14831Manipulate files on the remote system.\n\ 14832Transfer files to and from the remote target system."), 14833 &remote_cmdlist, "remote ", 14834 0 /* allow-unknown */, &cmdlist); 14835 14836 add_cmd ("put", class_files, remote_put_command, 14837 _("Copy a local file to the remote system."), 14838 &remote_cmdlist); 14839 14840 add_cmd ("get", class_files, remote_get_command, 14841 _("Copy a remote file to the local system."), 14842 &remote_cmdlist); 14843 14844 add_cmd ("delete", class_files, remote_delete_command, 14845 _("Delete a remote file."), 14846 &remote_cmdlist); 14847 14848 add_setshow_string_noescape_cmd ("exec-file", class_files, 14849 &remote_exec_file_var, _("\ 14850Set the remote pathname for \"run\"."), _("\ 14851Show the remote pathname for \"run\"."), NULL, 14852 set_remote_exec_file, 14853 show_remote_exec_file, 14854 &remote_set_cmdlist, 14855 &remote_show_cmdlist); 14856 14857 add_setshow_boolean_cmd ("range-stepping", class_run, 14858 &use_range_stepping, _("\ 14859Enable or disable range stepping."), _("\ 14860Show whether target-assisted range stepping is enabled."), _("\ 14861If on, and the target supports it, when stepping a source line, GDB\n\ 14862tells the target to step the corresponding range of addresses itself instead\n\ 14863of issuing multiple single-steps. This speeds up source level\n\ 14864stepping. If off, GDB always issues single-steps, even if range\n\ 14865stepping is supported by the target. The default is on."), 14866 set_range_stepping, 14867 show_range_stepping, 14868 &setlist, 14869 &showlist); 14870 14871 add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\ 14872Set watchdog timer."), _("\ 14873Show watchdog timer."), _("\ 14874When non-zero, this timeout is used instead of waiting forever for a target\n\ 14875to finish a low-level step or continue operation. If the specified amount\n\ 14876of time passes without a response from the target, an error occurs."), 14877 NULL, 14878 show_watchdog, 14879 &setlist, &showlist); 14880 14881 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class, 14882 &remote_packet_max_chars, _("\ 14883Set the maximum number of characters to display for each remote packet."), _("\ 14884Show the maximum number of characters to display for each remote packet."), _("\ 14885Specify \"unlimited\" to display all the characters."), 14886 NULL, show_remote_packet_max_chars, 14887 &setdebuglist, &showdebuglist); 14888 14889 /* Eventually initialize fileio. See fileio.c */ 14890 initialize_remote_fileio (&remote_set_cmdlist, &remote_show_cmdlist); 14891} 14892