remote.c revision 1.8
1/* Remote target communications for serial-line targets in custom GDB protocol 2 3 Copyright (C) 1988-2019 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 "common/filestuff.h" 46#include "common/rsp-low.h" 47#include "disasm.h" 48#include "location.h" 49 50#include "common/gdb_sys_time.h" 51 52#include "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 "common/agent.h" 72#include "btrace.h" 73#include "record-btrace.h" 74#include <algorithm> 75#include "common/scoped_restore.h" 76#include "common/environ.h" 77#include "common/byte-vector.h" 78#include <unordered_map> 79 80/* The remote target. */ 81 82static const char remote_doc[] = N_("\ 83Use a remote computer via a serial line, using a gdb-specific protocol.\n\ 84Specify the serial device it is connected to\n\ 85(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."); 86 87#define OPAQUETHREADBYTES 8 88 89/* a 64 bit opaque identifier */ 90typedef unsigned char threadref[OPAQUETHREADBYTES]; 91 92struct gdb_ext_thread_info; 93struct threads_listing_context; 94typedef int (*rmt_thread_action) (threadref *ref, void *context); 95struct protocol_feature; 96struct packet_reg; 97 98struct stop_reply; 99static void stop_reply_xfree (struct stop_reply *); 100 101struct stop_reply_deleter 102{ 103 void operator() (stop_reply *r) const 104 { 105 stop_reply_xfree (r); 106 } 107}; 108 109typedef std::unique_ptr<stop_reply, stop_reply_deleter> stop_reply_up; 110 111/* Generic configuration support for packets the stub optionally 112 supports. Allows the user to specify the use of the packet as well 113 as allowing GDB to auto-detect support in the remote stub. */ 114 115enum packet_support 116 { 117 PACKET_SUPPORT_UNKNOWN = 0, 118 PACKET_ENABLE, 119 PACKET_DISABLE 120 }; 121 122/* Analyze a packet's return value and update the packet config 123 accordingly. */ 124 125enum packet_result 126{ 127 PACKET_ERROR, 128 PACKET_OK, 129 PACKET_UNKNOWN 130}; 131 132struct threads_listing_context; 133 134/* Stub vCont actions support. 135 136 Each field is a boolean flag indicating whether the stub reports 137 support for the corresponding action. */ 138 139struct vCont_action_support 140{ 141 /* vCont;t */ 142 bool t = false; 143 144 /* vCont;r */ 145 bool r = false; 146 147 /* vCont;s */ 148 bool s = false; 149 150 /* vCont;S */ 151 bool S = false; 152}; 153 154/* About this many threadisds fit in a packet. */ 155 156#define MAXTHREADLISTRESULTS 32 157 158/* Data for the vFile:pread readahead cache. */ 159 160struct readahead_cache 161{ 162 /* Invalidate the readahead cache. */ 163 void invalidate (); 164 165 /* Invalidate the readahead cache if it is holding data for FD. */ 166 void invalidate_fd (int fd); 167 168 /* Serve pread from the readahead cache. Returns number of bytes 169 read, or 0 if the request can't be served from the cache. */ 170 int pread (int fd, gdb_byte *read_buf, size_t len, ULONGEST offset); 171 172 /* The file descriptor for the file that is being cached. -1 if the 173 cache is invalid. */ 174 int fd = -1; 175 176 /* The offset into the file that the cache buffer corresponds 177 to. */ 178 ULONGEST offset = 0; 179 180 /* The buffer holding the cache contents. */ 181 gdb_byte *buf = nullptr; 182 /* The buffer's size. We try to read as much as fits into a packet 183 at a time. */ 184 size_t bufsize = 0; 185 186 /* Cache hit and miss counters. */ 187 ULONGEST hit_count = 0; 188 ULONGEST miss_count = 0; 189}; 190 191/* Description of the remote protocol for a given architecture. */ 192 193struct packet_reg 194{ 195 long offset; /* Offset into G packet. */ 196 long regnum; /* GDB's internal register number. */ 197 LONGEST pnum; /* Remote protocol register number. */ 198 int in_g_packet; /* Always part of G packet. */ 199 /* long size in bytes; == register_size (target_gdbarch (), regnum); 200 at present. */ 201 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum); 202 at present. */ 203}; 204 205struct remote_arch_state 206{ 207 explicit remote_arch_state (struct gdbarch *gdbarch); 208 209 /* Description of the remote protocol registers. */ 210 long sizeof_g_packet; 211 212 /* Description of the remote protocol registers indexed by REGNUM 213 (making an array gdbarch_num_regs in size). */ 214 std::unique_ptr<packet_reg[]> regs; 215 216 /* This is the size (in chars) of the first response to the ``g'' 217 packet. It is used as a heuristic when determining the maximum 218 size of memory-read and memory-write packets. A target will 219 typically only reserve a buffer large enough to hold the ``g'' 220 packet. The size does not include packet overhead (headers and 221 trailers). */ 222 long actual_register_packet_size; 223 224 /* This is the maximum size (in chars) of a non read/write packet. 225 It is also used as a cap on the size of read/write packets. */ 226 long remote_packet_size; 227}; 228 229/* Description of the remote protocol state for the currently 230 connected target. This is per-target state, and independent of the 231 selected architecture. */ 232 233class remote_state 234{ 235public: 236 237 remote_state (); 238 ~remote_state (); 239 240 /* Get the remote arch state for GDBARCH. */ 241 struct remote_arch_state *get_remote_arch_state (struct gdbarch *gdbarch); 242 243public: /* data */ 244 245 /* A buffer to use for incoming packets, and its current size. The 246 buffer is grown dynamically for larger incoming packets. 247 Outgoing packets may also be constructed in this buffer. 248 The size of the buffer is always at least REMOTE_PACKET_SIZE; 249 REMOTE_PACKET_SIZE should be used to limit the length of outgoing 250 packets. */ 251 gdb::char_vector buf; 252 253 /* True if we're going through initial connection setup (finding out 254 about the remote side's threads, relocating symbols, etc.). */ 255 bool starting_up = false; 256 257 /* If we negotiated packet size explicitly (and thus can bypass 258 heuristics for the largest packet size that will not overflow 259 a buffer in the stub), this will be set to that packet size. 260 Otherwise zero, meaning to use the guessed size. */ 261 long explicit_packet_size = 0; 262 263 /* remote_wait is normally called when the target is running and 264 waits for a stop reply packet. But sometimes we need to call it 265 when the target is already stopped. We can send a "?" packet 266 and have remote_wait read the response. Or, if we already have 267 the response, we can stash it in BUF and tell remote_wait to 268 skip calling getpkt. This flag is set when BUF contains a 269 stop reply packet and the target is not waiting. */ 270 int cached_wait_status = 0; 271 272 /* True, if in no ack mode. That is, neither GDB nor the stub will 273 expect acks from each other. The connection is assumed to be 274 reliable. */ 275 bool noack_mode = false; 276 277 /* True if we're connected in extended remote mode. */ 278 bool extended = false; 279 280 /* True if we resumed the target and we're waiting for the target to 281 stop. In the mean time, we can't start another command/query. 282 The remote server wouldn't be ready to process it, so we'd 283 timeout waiting for a reply that would never come and eventually 284 we'd close the connection. This can happen in asynchronous mode 285 because we allow GDB commands while the target is running. */ 286 bool waiting_for_stop_reply = false; 287 288 /* The status of the stub support for the various vCont actions. */ 289 vCont_action_support supports_vCont; 290 291 /* True if the user has pressed Ctrl-C, but the target hasn't 292 responded to that. */ 293 bool ctrlc_pending_p = false; 294 295 /* True if we saw a Ctrl-C while reading or writing from/to the 296 remote descriptor. At that point it is not safe to send a remote 297 interrupt packet, so we instead remember we saw the Ctrl-C and 298 process it once we're done with sending/receiving the current 299 packet, which should be shortly. If however that takes too long, 300 and the user presses Ctrl-C again, we offer to disconnect. */ 301 bool got_ctrlc_during_io = false; 302 303 /* Descriptor for I/O to remote machine. Initialize it to NULL so that 304 remote_open knows that we don't have a file open when the program 305 starts. */ 306 struct serial *remote_desc = nullptr; 307 308 /* These are the threads which we last sent to the remote system. The 309 TID member will be -1 for all or -2 for not sent yet. */ 310 ptid_t general_thread = null_ptid; 311 ptid_t continue_thread = null_ptid; 312 313 /* This is the traceframe which we last selected on the remote system. 314 It will be -1 if no traceframe is selected. */ 315 int remote_traceframe_number = -1; 316 317 char *last_pass_packet = nullptr; 318 319 /* The last QProgramSignals packet sent to the target. We bypass 320 sending a new program signals list down to the target if the new 321 packet is exactly the same as the last we sent. IOW, we only let 322 the target know about program signals list changes. */ 323 char *last_program_signals_packet = nullptr; 324 325 gdb_signal last_sent_signal = GDB_SIGNAL_0; 326 327 bool last_sent_step = false; 328 329 /* The execution direction of the last resume we got. */ 330 exec_direction_kind last_resume_exec_dir = EXEC_FORWARD; 331 332 char *finished_object = nullptr; 333 char *finished_annex = nullptr; 334 ULONGEST finished_offset = 0; 335 336 /* Should we try the 'ThreadInfo' query packet? 337 338 This variable (NOT available to the user: auto-detect only!) 339 determines whether GDB will use the new, simpler "ThreadInfo" 340 query or the older, more complex syntax for thread queries. 341 This is an auto-detect variable (set to true at each connect, 342 and set to false when the target fails to recognize it). */ 343 bool use_threadinfo_query = false; 344 bool use_threadextra_query = false; 345 346 threadref echo_nextthread {}; 347 threadref nextthread {}; 348 threadref resultthreadlist[MAXTHREADLISTRESULTS] {}; 349 350 /* The state of remote notification. */ 351 struct remote_notif_state *notif_state = nullptr; 352 353 /* The branch trace configuration. */ 354 struct btrace_config btrace_config {}; 355 356 /* The argument to the last "vFile:setfs:" packet we sent, used 357 to avoid sending repeated unnecessary "vFile:setfs:" packets. 358 Initialized to -1 to indicate that no "vFile:setfs:" packet 359 has yet been sent. */ 360 int fs_pid = -1; 361 362 /* A readahead cache for vFile:pread. Often, reading a binary 363 involves a sequence of small reads. E.g., when parsing an ELF 364 file. A readahead cache helps mostly the case of remote 365 debugging on a connection with higher latency, due to the 366 request/reply nature of the RSP. We only cache data for a single 367 file descriptor at a time. */ 368 struct readahead_cache readahead_cache; 369 370 /* The list of already fetched and acknowledged stop events. This 371 queue is used for notification Stop, and other notifications 372 don't need queue for their events, because the notification 373 events of Stop can't be consumed immediately, so that events 374 should be queued first, and be consumed by remote_wait_{ns,as} 375 one per time. Other notifications can consume their events 376 immediately, so queue is not needed for them. */ 377 std::vector<stop_reply_up> stop_reply_queue; 378 379 /* Asynchronous signal handle registered as event loop source for 380 when we have pending events ready to be passed to the core. */ 381 struct async_event_handler *remote_async_inferior_event_token = nullptr; 382 383 /* FIXME: cagney/1999-09-23: Even though getpkt was called with 384 ``forever'' still use the normal timeout mechanism. This is 385 currently used by the ASYNC code to guarentee that target reads 386 during the initial connect always time-out. Once getpkt has been 387 modified to return a timeout indication and, in turn 388 remote_wait()/wait_for_inferior() have gained a timeout parameter 389 this can go away. */ 390 int wait_forever_enabled_p = 1; 391 392private: 393 /* Mapping of remote protocol data for each gdbarch. Usually there 394 is only one entry here, though we may see more with stubs that 395 support multi-process. */ 396 std::unordered_map<struct gdbarch *, remote_arch_state> 397 m_arch_states; 398}; 399 400static const target_info remote_target_info = { 401 "remote", 402 N_("Remote serial target in gdb-specific protocol"), 403 remote_doc 404}; 405 406class remote_target : public process_stratum_target 407{ 408public: 409 remote_target () = default; 410 ~remote_target () override; 411 412 const target_info &info () const override 413 { return remote_target_info; } 414 415 thread_control_capabilities get_thread_control_capabilities () override 416 { return tc_schedlock; } 417 418 /* Open a remote connection. */ 419 static void open (const char *, int); 420 421 void close () override; 422 423 void detach (inferior *, int) override; 424 void disconnect (const char *, int) override; 425 426 void commit_resume () override; 427 void resume (ptid_t, int, enum gdb_signal) override; 428 ptid_t wait (ptid_t, struct target_waitstatus *, int) override; 429 430 void fetch_registers (struct regcache *, int) override; 431 void store_registers (struct regcache *, int) override; 432 void prepare_to_store (struct regcache *) override; 433 434 void files_info () override; 435 436 int insert_breakpoint (struct gdbarch *, struct bp_target_info *) override; 437 438 int remove_breakpoint (struct gdbarch *, struct bp_target_info *, 439 enum remove_bp_reason) override; 440 441 442 bool stopped_by_sw_breakpoint () override; 443 bool supports_stopped_by_sw_breakpoint () override; 444 445 bool stopped_by_hw_breakpoint () override; 446 447 bool supports_stopped_by_hw_breakpoint () override; 448 449 bool stopped_by_watchpoint () override; 450 451 bool stopped_data_address (CORE_ADDR *) override; 452 453 bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override; 454 455 int can_use_hw_breakpoint (enum bptype, int, int) override; 456 457 int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override; 458 459 int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override; 460 461 int region_ok_for_hw_watchpoint (CORE_ADDR, int) override; 462 463 int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, 464 struct expression *) override; 465 466 int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, 467 struct expression *) override; 468 469 void kill () override; 470 471 void load (const char *, int) override; 472 473 void mourn_inferior () override; 474 475 void pass_signals (gdb::array_view<const unsigned char>) override; 476 477 int set_syscall_catchpoint (int, bool, int, 478 gdb::array_view<const int>) override; 479 480 void program_signals (gdb::array_view<const unsigned char>) override; 481 482 bool thread_alive (ptid_t ptid) override; 483 484 const char *thread_name (struct thread_info *) override; 485 486 void update_thread_list () override; 487 488 const char *pid_to_str (ptid_t) override; 489 490 const char *extra_thread_info (struct thread_info *) override; 491 492 ptid_t get_ada_task_ptid (long lwp, long thread) override; 493 494 thread_info *thread_handle_to_thread_info (const gdb_byte *thread_handle, 495 int handle_len, 496 inferior *inf) 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 void thread_events (int) override; 547 548 int can_do_single_step () override; 549 550 void terminal_inferior () override; 551 552 void terminal_ours () override; 553 554 bool supports_non_stop () override; 555 556 bool supports_multi_process () override; 557 558 bool supports_disable_randomization () override; 559 560 bool filesystem_is_local () override; 561 562 563 int fileio_open (struct inferior *inf, const char *filename, 564 int flags, int mode, int warn_if_slow, 565 int *target_errno) override; 566 567 int fileio_pwrite (int fd, const gdb_byte *write_buf, int len, 568 ULONGEST offset, int *target_errno) override; 569 570 int fileio_pread (int fd, gdb_byte *read_buf, int len, 571 ULONGEST offset, int *target_errno) override; 572 573 int fileio_fstat (int fd, struct stat *sb, int *target_errno) override; 574 575 int fileio_close (int fd, int *target_errno) override; 576 577 int fileio_unlink (struct inferior *inf, 578 const char *filename, 579 int *target_errno) override; 580 581 gdb::optional<std::string> 582 fileio_readlink (struct inferior *inf, 583 const char *filename, 584 int *target_errno) override; 585 586 bool supports_enable_disable_tracepoint () override; 587 588 bool supports_string_tracing () override; 589 590 bool supports_evaluation_of_breakpoint_conditions () override; 591 592 bool can_run_breakpoint_commands () override; 593 594 void trace_init () override; 595 596 void download_tracepoint (struct bp_location *location) override; 597 598 bool can_download_tracepoint () override; 599 600 void download_trace_state_variable (const trace_state_variable &tsv) override; 601 602 void enable_tracepoint (struct bp_location *location) override; 603 604 void disable_tracepoint (struct bp_location *location) override; 605 606 void trace_set_readonly_regions () override; 607 608 void trace_start () override; 609 610 int get_trace_status (struct trace_status *ts) override; 611 612 void get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp) 613 override; 614 615 void trace_stop () override; 616 617 int trace_find (enum trace_find_type type, int num, 618 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) override; 619 620 bool get_trace_state_variable_value (int tsv, LONGEST *val) override; 621 622 int save_trace_data (const char *filename) override; 623 624 int upload_tracepoints (struct uploaded_tp **utpp) override; 625 626 int upload_trace_state_variables (struct uploaded_tsv **utsvp) override; 627 628 LONGEST get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len) override; 629 630 int get_min_fast_tracepoint_insn_len () override; 631 632 void set_disconnected_tracing (int val) override; 633 634 void set_circular_trace_buffer (int val) override; 635 636 void set_trace_buffer_size (LONGEST val) override; 637 638 bool set_trace_notes (const char *user, const char *notes, 639 const char *stopnotes) override; 640 641 int core_of_thread (ptid_t ptid) override; 642 643 int verify_memory (const gdb_byte *data, 644 CORE_ADDR memaddr, ULONGEST size) override; 645 646 647 bool get_tib_address (ptid_t ptid, CORE_ADDR *addr) override; 648 649 void set_permissions () override; 650 651 bool static_tracepoint_marker_at (CORE_ADDR, 652 struct static_tracepoint_marker *marker) 653 override; 654 655 std::vector<static_tracepoint_marker> 656 static_tracepoint_markers_by_strid (const char *id) override; 657 658 traceframe_info_up traceframe_info () override; 659 660 bool use_agent (bool use) override; 661 bool can_use_agent () override; 662 663 struct btrace_target_info *enable_btrace (ptid_t ptid, 664 const struct btrace_config *conf) override; 665 666 void disable_btrace (struct btrace_target_info *tinfo) override; 667 668 void teardown_btrace (struct btrace_target_info *tinfo) override; 669 670 enum btrace_error read_btrace (struct btrace_data *data, 671 struct btrace_target_info *btinfo, 672 enum btrace_read_type type) override; 673 674 const struct btrace_config *btrace_conf (const struct btrace_target_info *) override; 675 bool augmented_libraries_svr4_read () override; 676 int follow_fork (int, int) override; 677 void follow_exec (struct inferior *, char *) override; 678 int insert_fork_catchpoint (int) override; 679 int remove_fork_catchpoint (int) override; 680 int insert_vfork_catchpoint (int) override; 681 int remove_vfork_catchpoint (int) override; 682 int insert_exec_catchpoint (int) override; 683 int remove_exec_catchpoint (int) override; 684 enum exec_direction_kind execution_direction () override; 685 686public: /* Remote specific methods. */ 687 688 void remote_download_command_source (int num, ULONGEST addr, 689 struct command_line *cmds); 690 691 void remote_file_put (const char *local_file, const char *remote_file, 692 int from_tty); 693 void remote_file_get (const char *remote_file, const char *local_file, 694 int from_tty); 695 void remote_file_delete (const char *remote_file, int from_tty); 696 697 int remote_hostio_pread (int fd, gdb_byte *read_buf, int len, 698 ULONGEST offset, int *remote_errno); 699 int remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len, 700 ULONGEST offset, int *remote_errno); 701 int remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len, 702 ULONGEST offset, int *remote_errno); 703 704 int remote_hostio_send_command (int command_bytes, int which_packet, 705 int *remote_errno, char **attachment, 706 int *attachment_len); 707 int remote_hostio_set_filesystem (struct inferior *inf, 708 int *remote_errno); 709 /* We should get rid of this and use fileio_open directly. */ 710 int remote_hostio_open (struct inferior *inf, const char *filename, 711 int flags, int mode, int warn_if_slow, 712 int *remote_errno); 713 int remote_hostio_close (int fd, int *remote_errno); 714 715 int remote_hostio_unlink (inferior *inf, const char *filename, 716 int *remote_errno); 717 718 struct remote_state *get_remote_state (); 719 720 long get_remote_packet_size (void); 721 long get_memory_packet_size (struct memory_packet_config *config); 722 723 long get_memory_write_packet_size (); 724 long get_memory_read_packet_size (); 725 726 char *append_pending_thread_resumptions (char *p, char *endp, 727 ptid_t ptid); 728 static void open_1 (const char *name, int from_tty, int extended_p); 729 void start_remote (int from_tty, int extended_p); 730 void remote_detach_1 (struct inferior *inf, int from_tty); 731 732 char *append_resumption (char *p, char *endp, 733 ptid_t ptid, int step, gdb_signal siggnal); 734 int remote_resume_with_vcont (ptid_t ptid, int step, 735 gdb_signal siggnal); 736 737 void add_current_inferior_and_thread (char *wait_status); 738 739 ptid_t wait_ns (ptid_t ptid, struct target_waitstatus *status, 740 int options); 741 ptid_t wait_as (ptid_t ptid, target_waitstatus *status, 742 int options); 743 744 ptid_t process_stop_reply (struct stop_reply *stop_reply, 745 target_waitstatus *status); 746 747 void remote_notice_new_inferior (ptid_t currthread, int executing); 748 749 void process_initial_stop_replies (int from_tty); 750 751 thread_info *remote_add_thread (ptid_t ptid, bool running, bool executing); 752 753 void btrace_sync_conf (const btrace_config *conf); 754 755 void remote_btrace_maybe_reopen (); 756 757 void remove_new_fork_children (threads_listing_context *context); 758 void kill_new_fork_children (int pid); 759 void discard_pending_stop_replies (struct inferior *inf); 760 int stop_reply_queue_length (); 761 762 void check_pending_events_prevent_wildcard_vcont 763 (int *may_global_wildcard_vcont); 764 765 void discard_pending_stop_replies_in_queue (); 766 struct stop_reply *remote_notif_remove_queued_reply (ptid_t ptid); 767 struct stop_reply *queued_stop_reply (ptid_t ptid); 768 int peek_stop_reply (ptid_t ptid); 769 void remote_parse_stop_reply (const char *buf, stop_reply *event); 770 771 void remote_stop_ns (ptid_t ptid); 772 void remote_interrupt_as (); 773 void remote_interrupt_ns (); 774 775 char *remote_get_noisy_reply (); 776 int remote_query_attached (int pid); 777 inferior *remote_add_inferior (int fake_pid_p, int pid, int attached, 778 int try_open_exec); 779 780 ptid_t remote_current_thread (ptid_t oldpid); 781 ptid_t get_current_thread (char *wait_status); 782 783 void set_thread (ptid_t ptid, int gen); 784 void set_general_thread (ptid_t ptid); 785 void set_continue_thread (ptid_t ptid); 786 void set_general_process (); 787 788 char *write_ptid (char *buf, const char *endbuf, ptid_t ptid); 789 790 int remote_unpack_thread_info_response (char *pkt, threadref *expectedref, 791 gdb_ext_thread_info *info); 792 int remote_get_threadinfo (threadref *threadid, int fieldset, 793 gdb_ext_thread_info *info); 794 795 int parse_threadlist_response (char *pkt, int result_limit, 796 threadref *original_echo, 797 threadref *resultlist, 798 int *doneflag); 799 int remote_get_threadlist (int startflag, threadref *nextthread, 800 int result_limit, int *done, int *result_count, 801 threadref *threadlist); 802 803 int remote_threadlist_iterator (rmt_thread_action stepfunction, 804 void *context, int looplimit); 805 806 int remote_get_threads_with_ql (threads_listing_context *context); 807 int remote_get_threads_with_qxfer (threads_listing_context *context); 808 int remote_get_threads_with_qthreadinfo (threads_listing_context *context); 809 810 void extended_remote_restart (); 811 812 void get_offsets (); 813 814 void remote_check_symbols (); 815 816 void remote_supported_packet (const struct protocol_feature *feature, 817 enum packet_support support, 818 const char *argument); 819 820 void remote_query_supported (); 821 822 void remote_packet_size (const protocol_feature *feature, 823 packet_support support, const char *value); 824 825 void remote_serial_quit_handler (); 826 827 void remote_detach_pid (int pid); 828 829 void remote_vcont_probe (); 830 831 void remote_resume_with_hc (ptid_t ptid, int step, 832 gdb_signal siggnal); 833 834 void send_interrupt_sequence (); 835 void interrupt_query (); 836 837 void remote_notif_get_pending_events (notif_client *nc); 838 839 int fetch_register_using_p (struct regcache *regcache, 840 packet_reg *reg); 841 int send_g_packet (); 842 void process_g_packet (struct regcache *regcache); 843 void fetch_registers_using_g (struct regcache *regcache); 844 int store_register_using_P (const struct regcache *regcache, 845 packet_reg *reg); 846 void store_registers_using_G (const struct regcache *regcache); 847 848 void set_remote_traceframe (); 849 850 void check_binary_download (CORE_ADDR addr); 851 852 target_xfer_status remote_write_bytes_aux (const char *header, 853 CORE_ADDR memaddr, 854 const gdb_byte *myaddr, 855 ULONGEST len_units, 856 int unit_size, 857 ULONGEST *xfered_len_units, 858 char packet_format, 859 int use_length); 860 861 target_xfer_status remote_write_bytes (CORE_ADDR memaddr, 862 const gdb_byte *myaddr, ULONGEST len, 863 int unit_size, ULONGEST *xfered_len); 864 865 target_xfer_status remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr, 866 ULONGEST len_units, 867 int unit_size, ULONGEST *xfered_len_units); 868 869 target_xfer_status remote_xfer_live_readonly_partial (gdb_byte *readbuf, 870 ULONGEST memaddr, 871 ULONGEST len, 872 int unit_size, 873 ULONGEST *xfered_len); 874 875 target_xfer_status remote_read_bytes (CORE_ADDR memaddr, 876 gdb_byte *myaddr, ULONGEST len, 877 int unit_size, 878 ULONGEST *xfered_len); 879 880 packet_result remote_send_printf (const char *format, ...) 881 ATTRIBUTE_PRINTF (2, 3); 882 883 target_xfer_status remote_flash_write (ULONGEST address, 884 ULONGEST length, ULONGEST *xfered_len, 885 const gdb_byte *data); 886 887 int readchar (int timeout); 888 889 void remote_serial_write (const char *str, int len); 890 891 int putpkt (const char *buf); 892 int putpkt_binary (const char *buf, int cnt); 893 894 int putpkt (const gdb::char_vector &buf) 895 { 896 return putpkt (buf.data ()); 897 } 898 899 void skip_frame (); 900 long read_frame (gdb::char_vector *buf_p); 901 void getpkt (gdb::char_vector *buf, int forever); 902 int getpkt_or_notif_sane_1 (gdb::char_vector *buf, int forever, 903 int expecting_notif, int *is_notif); 904 int getpkt_sane (gdb::char_vector *buf, int forever); 905 int getpkt_or_notif_sane (gdb::char_vector *buf, int forever, 906 int *is_notif); 907 int remote_vkill (int pid); 908 void remote_kill_k (); 909 910 void extended_remote_disable_randomization (int val); 911 int extended_remote_run (const std::string &args); 912 913 void send_environment_packet (const char *action, 914 const char *packet, 915 const char *value); 916 917 void extended_remote_environment_support (); 918 void extended_remote_set_inferior_cwd (); 919 920 target_xfer_status remote_write_qxfer (const char *object_name, 921 const char *annex, 922 const gdb_byte *writebuf, 923 ULONGEST offset, LONGEST len, 924 ULONGEST *xfered_len, 925 struct packet_config *packet); 926 927 target_xfer_status remote_read_qxfer (const char *object_name, 928 const char *annex, 929 gdb_byte *readbuf, ULONGEST offset, 930 LONGEST len, 931 ULONGEST *xfered_len, 932 struct packet_config *packet); 933 934 void push_stop_reply (struct stop_reply *new_event); 935 936 bool vcont_r_supported (); 937 938 void packet_command (const char *args, int from_tty); 939 940private: /* data fields */ 941 942 /* The remote state. Don't reference this directly. Use the 943 get_remote_state method instead. */ 944 remote_state m_remote_state; 945}; 946 947static const target_info extended_remote_target_info = { 948 "extended-remote", 949 N_("Extended remote serial target in gdb-specific protocol"), 950 remote_doc 951}; 952 953/* Set up the extended remote target by extending the standard remote 954 target and adding to it. */ 955 956class extended_remote_target final : public remote_target 957{ 958public: 959 const target_info &info () const override 960 { return extended_remote_target_info; } 961 962 /* Open an extended-remote connection. */ 963 static void open (const char *, int); 964 965 bool can_create_inferior () override { return true; } 966 void create_inferior (const char *, const std::string &, 967 char **, int) override; 968 969 void detach (inferior *, int) override; 970 971 bool can_attach () override { return true; } 972 void attach (const char *, int) override; 973 974 void post_attach (int) override; 975 bool supports_disable_randomization () override; 976}; 977 978/* Per-program-space data key. */ 979static const struct program_space_data *remote_pspace_data; 980 981/* The variable registered as the control variable used by the 982 remote exec-file commands. While the remote exec-file setting is 983 per-program-space, the set/show machinery uses this as the 984 location of the remote exec-file value. */ 985static char *remote_exec_file_var; 986 987/* The size to align memory write packets, when practical. The protocol 988 does not guarantee any alignment, and gdb will generate short 989 writes and unaligned writes, but even as a best-effort attempt this 990 can improve bulk transfers. For instance, if a write is misaligned 991 relative to the target's data bus, the stub may need to make an extra 992 round trip fetching data from the target. This doesn't make a 993 huge difference, but it's easy to do, so we try to be helpful. 994 995 The alignment chosen is arbitrary; usually data bus width is 996 important here, not the possibly larger cache line size. */ 997enum { REMOTE_ALIGN_WRITES = 16 }; 998 999/* Prototypes for local functions. */ 1000 1001static int hexnumlen (ULONGEST num); 1002 1003static int stubhex (int ch); 1004 1005static int hexnumstr (char *, ULONGEST); 1006 1007static int hexnumnstr (char *, ULONGEST, int); 1008 1009static CORE_ADDR remote_address_masked (CORE_ADDR); 1010 1011static void print_packet (const char *); 1012 1013static int stub_unpack_int (char *buff, int fieldlength); 1014 1015struct packet_config; 1016 1017static void show_packet_config_cmd (struct packet_config *config); 1018 1019static void show_remote_protocol_packet_cmd (struct ui_file *file, 1020 int from_tty, 1021 struct cmd_list_element *c, 1022 const char *value); 1023 1024static ptid_t read_ptid (const char *buf, const char **obuf); 1025 1026static void remote_async_inferior_event_handler (gdb_client_data); 1027 1028static bool remote_read_description_p (struct target_ops *target); 1029 1030static void remote_console_output (const char *msg); 1031 1032static void remote_btrace_reset (remote_state *rs); 1033 1034static void remote_unpush_and_throw (void); 1035 1036/* For "remote". */ 1037 1038static struct cmd_list_element *remote_cmdlist; 1039 1040/* For "set remote" and "show remote". */ 1041 1042static struct cmd_list_element *remote_set_cmdlist; 1043static struct cmd_list_element *remote_show_cmdlist; 1044 1045/* Controls whether GDB is willing to use range stepping. */ 1046 1047static int use_range_stepping = 1; 1048 1049/* The max number of chars in debug output. The rest of chars are 1050 omitted. */ 1051 1052#define REMOTE_DEBUG_MAX_CHAR 512 1053 1054/* Private data that we'll store in (struct thread_info)->priv. */ 1055struct remote_thread_info : public private_thread_info 1056{ 1057 std::string extra; 1058 std::string name; 1059 int core = -1; 1060 1061 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a 1062 sequence of bytes. */ 1063 gdb::byte_vector thread_handle; 1064 1065 /* Whether the target stopped for a breakpoint/watchpoint. */ 1066 enum target_stop_reason stop_reason = TARGET_STOPPED_BY_NO_REASON; 1067 1068 /* This is set to the data address of the access causing the target 1069 to stop for a watchpoint. */ 1070 CORE_ADDR watch_data_address = 0; 1071 1072 /* Fields used by the vCont action coalescing implemented in 1073 remote_resume / remote_commit_resume. remote_resume stores each 1074 thread's last resume request in these fields, so that a later 1075 remote_commit_resume knows which is the proper action for this 1076 thread to include in the vCont packet. */ 1077 1078 /* True if the last target_resume call for this thread was a step 1079 request, false if a continue request. */ 1080 int last_resume_step = 0; 1081 1082 /* The signal specified in the last target_resume call for this 1083 thread. */ 1084 gdb_signal last_resume_sig = GDB_SIGNAL_0; 1085 1086 /* Whether this thread was already vCont-resumed on the remote 1087 side. */ 1088 int vcont_resumed = 0; 1089}; 1090 1091remote_state::remote_state () 1092 : buf (400) 1093{ 1094} 1095 1096remote_state::~remote_state () 1097{ 1098 xfree (this->last_pass_packet); 1099 xfree (this->last_program_signals_packet); 1100 xfree (this->finished_object); 1101 xfree (this->finished_annex); 1102} 1103 1104/* Utility: generate error from an incoming stub packet. */ 1105static void 1106trace_error (char *buf) 1107{ 1108 if (*buf++ != 'E') 1109 return; /* not an error msg */ 1110 switch (*buf) 1111 { 1112 case '1': /* malformed packet error */ 1113 if (*++buf == '0') /* general case: */ 1114 error (_("remote.c: error in outgoing packet.")); 1115 else 1116 error (_("remote.c: error in outgoing packet at field #%ld."), 1117 strtol (buf, NULL, 16)); 1118 default: 1119 error (_("Target returns error code '%s'."), buf); 1120 } 1121} 1122 1123/* Utility: wait for reply from stub, while accepting "O" packets. */ 1124 1125char * 1126remote_target::remote_get_noisy_reply () 1127{ 1128 struct remote_state *rs = get_remote_state (); 1129 1130 do /* Loop on reply from remote stub. */ 1131 { 1132 char *buf; 1133 1134 QUIT; /* Allow user to bail out with ^C. */ 1135 getpkt (&rs->buf, 0); 1136 buf = rs->buf.data (); 1137 if (buf[0] == 'E') 1138 trace_error (buf); 1139 else if (startswith (buf, "qRelocInsn:")) 1140 { 1141 ULONGEST ul; 1142 CORE_ADDR from, to, org_to; 1143 const char *p, *pp; 1144 int adjusted_size = 0; 1145 int relocated = 0; 1146 1147 p = buf + strlen ("qRelocInsn:"); 1148 pp = unpack_varlen_hex (p, &ul); 1149 if (*pp != ';') 1150 error (_("invalid qRelocInsn packet: %s"), buf); 1151 from = ul; 1152 1153 p = pp + 1; 1154 unpack_varlen_hex (p, &ul); 1155 to = ul; 1156 1157 org_to = to; 1158 1159 TRY 1160 { 1161 gdbarch_relocate_instruction (target_gdbarch (), &to, from); 1162 relocated = 1; 1163 } 1164 CATCH (ex, RETURN_MASK_ALL) 1165 { 1166 if (ex.error == MEMORY_ERROR) 1167 { 1168 /* Propagate memory errors silently back to the 1169 target. The stub may have limited the range of 1170 addresses we can write to, for example. */ 1171 } 1172 else 1173 { 1174 /* Something unexpectedly bad happened. Be verbose 1175 so we can tell what, and propagate the error back 1176 to the stub, so it doesn't get stuck waiting for 1177 a response. */ 1178 exception_fprintf (gdb_stderr, ex, 1179 _("warning: relocating instruction: ")); 1180 } 1181 putpkt ("E01"); 1182 } 1183 END_CATCH 1184 1185 if (relocated) 1186 { 1187 adjusted_size = to - org_to; 1188 1189 xsnprintf (buf, rs->buf.size (), "qRelocInsn:%x", adjusted_size); 1190 putpkt (buf); 1191 } 1192 } 1193 else if (buf[0] == 'O' && buf[1] != 'K') 1194 remote_console_output (buf + 1); /* 'O' message from stub */ 1195 else 1196 return buf; /* Here's the actual reply. */ 1197 } 1198 while (1); 1199} 1200 1201struct remote_arch_state * 1202remote_state::get_remote_arch_state (struct gdbarch *gdbarch) 1203{ 1204 remote_arch_state *rsa; 1205 1206 auto it = this->m_arch_states.find (gdbarch); 1207 if (it == this->m_arch_states.end ()) 1208 { 1209 auto p = this->m_arch_states.emplace (std::piecewise_construct, 1210 std::forward_as_tuple (gdbarch), 1211 std::forward_as_tuple (gdbarch)); 1212 rsa = &p.first->second; 1213 1214 /* Make sure that the packet buffer is plenty big enough for 1215 this architecture. */ 1216 if (this->buf.size () < rsa->remote_packet_size) 1217 this->buf.resize (2 * rsa->remote_packet_size); 1218 } 1219 else 1220 rsa = &it->second; 1221 1222 return rsa; 1223} 1224 1225/* Fetch the global remote target state. */ 1226 1227remote_state * 1228remote_target::get_remote_state () 1229{ 1230 /* Make sure that the remote architecture state has been 1231 initialized, because doing so might reallocate rs->buf. Any 1232 function which calls getpkt also needs to be mindful of changes 1233 to rs->buf, but this call limits the number of places which run 1234 into trouble. */ 1235 m_remote_state.get_remote_arch_state (target_gdbarch ()); 1236 1237 return &m_remote_state; 1238} 1239 1240/* Cleanup routine for the remote module's pspace data. */ 1241 1242static void 1243remote_pspace_data_cleanup (struct program_space *pspace, void *arg) 1244{ 1245 char *remote_exec_file = (char *) arg; 1246 1247 xfree (remote_exec_file); 1248} 1249 1250/* Fetch the remote exec-file from the current program space. */ 1251 1252static const char * 1253get_remote_exec_file (void) 1254{ 1255 char *remote_exec_file; 1256 1257 remote_exec_file 1258 = (char *) program_space_data (current_program_space, 1259 remote_pspace_data); 1260 if (remote_exec_file == NULL) 1261 return ""; 1262 1263 return remote_exec_file; 1264} 1265 1266/* Set the remote exec file for PSPACE. */ 1267 1268static void 1269set_pspace_remote_exec_file (struct program_space *pspace, 1270 char *remote_exec_file) 1271{ 1272 char *old_file = (char *) program_space_data (pspace, remote_pspace_data); 1273 1274 xfree (old_file); 1275 set_program_space_data (pspace, remote_pspace_data, 1276 xstrdup (remote_exec_file)); 1277} 1278 1279/* The "set/show remote exec-file" set command hook. */ 1280 1281static void 1282set_remote_exec_file (const char *ignored, int from_tty, 1283 struct cmd_list_element *c) 1284{ 1285 gdb_assert (remote_exec_file_var != NULL); 1286 set_pspace_remote_exec_file (current_program_space, remote_exec_file_var); 1287} 1288 1289/* The "set/show remote exec-file" show command hook. */ 1290 1291static void 1292show_remote_exec_file (struct ui_file *file, int from_tty, 1293 struct cmd_list_element *cmd, const char *value) 1294{ 1295 fprintf_filtered (file, "%s\n", remote_exec_file_var); 1296} 1297 1298static int 1299compare_pnums (const void *lhs_, const void *rhs_) 1300{ 1301 const struct packet_reg * const *lhs 1302 = (const struct packet_reg * const *) lhs_; 1303 const struct packet_reg * const *rhs 1304 = (const struct packet_reg * const *) rhs_; 1305 1306 if ((*lhs)->pnum < (*rhs)->pnum) 1307 return -1; 1308 else if ((*lhs)->pnum == (*rhs)->pnum) 1309 return 0; 1310 else 1311 return 1; 1312} 1313 1314static int 1315map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs) 1316{ 1317 int regnum, num_remote_regs, offset; 1318 struct packet_reg **remote_regs; 1319 1320 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++) 1321 { 1322 struct packet_reg *r = ®s[regnum]; 1323 1324 if (register_size (gdbarch, regnum) == 0) 1325 /* Do not try to fetch zero-sized (placeholder) registers. */ 1326 r->pnum = -1; 1327 else 1328 r->pnum = gdbarch_remote_register_number (gdbarch, regnum); 1329 1330 r->regnum = regnum; 1331 } 1332 1333 /* Define the g/G packet format as the contents of each register 1334 with a remote protocol number, in order of ascending protocol 1335 number. */ 1336 1337 remote_regs = XALLOCAVEC (struct packet_reg *, gdbarch_num_regs (gdbarch)); 1338 for (num_remote_regs = 0, regnum = 0; 1339 regnum < gdbarch_num_regs (gdbarch); 1340 regnum++) 1341 if (regs[regnum].pnum != -1) 1342 remote_regs[num_remote_regs++] = ®s[regnum]; 1343 1344 qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *), 1345 compare_pnums); 1346 1347 for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++) 1348 { 1349 remote_regs[regnum]->in_g_packet = 1; 1350 remote_regs[regnum]->offset = offset; 1351 offset += register_size (gdbarch, remote_regs[regnum]->regnum); 1352 } 1353 1354 return offset; 1355} 1356 1357/* Given the architecture described by GDBARCH, return the remote 1358 protocol register's number and the register's offset in the g/G 1359 packets of GDB register REGNUM, in PNUM and POFFSET respectively. 1360 If the target does not have a mapping for REGNUM, return false, 1361 otherwise, return true. */ 1362 1363int 1364remote_register_number_and_offset (struct gdbarch *gdbarch, int regnum, 1365 int *pnum, int *poffset) 1366{ 1367 gdb_assert (regnum < gdbarch_num_regs (gdbarch)); 1368 1369 std::vector<packet_reg> regs (gdbarch_num_regs (gdbarch)); 1370 1371 map_regcache_remote_table (gdbarch, regs.data ()); 1372 1373 *pnum = regs[regnum].pnum; 1374 *poffset = regs[regnum].offset; 1375 1376 return *pnum != -1; 1377} 1378 1379remote_arch_state::remote_arch_state (struct gdbarch *gdbarch) 1380{ 1381 /* Use the architecture to build a regnum<->pnum table, which will be 1382 1:1 unless a feature set specifies otherwise. */ 1383 this->regs.reset (new packet_reg [gdbarch_num_regs (gdbarch)] ()); 1384 1385 /* Record the maximum possible size of the g packet - it may turn out 1386 to be smaller. */ 1387 this->sizeof_g_packet 1388 = map_regcache_remote_table (gdbarch, this->regs.get ()); 1389 1390 /* Default maximum number of characters in a packet body. Many 1391 remote stubs have a hardwired buffer size of 400 bytes 1392 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used 1393 as the maximum packet-size to ensure that the packet and an extra 1394 NUL character can always fit in the buffer. This stops GDB 1395 trashing stubs that try to squeeze an extra NUL into what is 1396 already a full buffer (As of 1999-12-04 that was most stubs). */ 1397 this->remote_packet_size = 400 - 1; 1398 1399 /* This one is filled in when a ``g'' packet is received. */ 1400 this->actual_register_packet_size = 0; 1401 1402 /* Should rsa->sizeof_g_packet needs more space than the 1403 default, adjust the size accordingly. Remember that each byte is 1404 encoded as two characters. 32 is the overhead for the packet 1405 header / footer. NOTE: cagney/1999-10-26: I suspect that 8 1406 (``$NN:G...#NN'') is a better guess, the below has been padded a 1407 little. */ 1408 if (this->sizeof_g_packet > ((this->remote_packet_size - 32) / 2)) 1409 this->remote_packet_size = (this->sizeof_g_packet * 2 + 32); 1410} 1411 1412/* Get a pointer to the current remote target. If not connected to a 1413 remote target, return NULL. */ 1414 1415static remote_target * 1416get_current_remote_target () 1417{ 1418 target_ops *proc_target = find_target_at (process_stratum); 1419 return dynamic_cast<remote_target *> (proc_target); 1420} 1421 1422/* Return the current allowed size of a remote packet. This is 1423 inferred from the current architecture, and should be used to 1424 limit the length of outgoing packets. */ 1425long 1426remote_target::get_remote_packet_size () 1427{ 1428 struct remote_state *rs = get_remote_state (); 1429 remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ()); 1430 1431 if (rs->explicit_packet_size) 1432 return rs->explicit_packet_size; 1433 1434 return rsa->remote_packet_size; 1435} 1436 1437static struct packet_reg * 1438packet_reg_from_regnum (struct gdbarch *gdbarch, struct remote_arch_state *rsa, 1439 long regnum) 1440{ 1441 if (regnum < 0 && regnum >= gdbarch_num_regs (gdbarch)) 1442 return NULL; 1443 else 1444 { 1445 struct packet_reg *r = &rsa->regs[regnum]; 1446 1447 gdb_assert (r->regnum == regnum); 1448 return r; 1449 } 1450} 1451 1452static struct packet_reg * 1453packet_reg_from_pnum (struct gdbarch *gdbarch, struct remote_arch_state *rsa, 1454 LONGEST pnum) 1455{ 1456 int i; 1457 1458 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 1459 { 1460 struct packet_reg *r = &rsa->regs[i]; 1461 1462 if (r->pnum == pnum) 1463 return r; 1464 } 1465 return NULL; 1466} 1467 1468/* Allow the user to specify what sequence to send to the remote 1469 when he requests a program interruption: Although ^C is usually 1470 what remote systems expect (this is the default, here), it is 1471 sometimes preferable to send a break. On other systems such 1472 as the Linux kernel, a break followed by g, which is Magic SysRq g 1473 is required in order to interrupt the execution. */ 1474const char interrupt_sequence_control_c[] = "Ctrl-C"; 1475const char interrupt_sequence_break[] = "BREAK"; 1476const char interrupt_sequence_break_g[] = "BREAK-g"; 1477static const char *const interrupt_sequence_modes[] = 1478 { 1479 interrupt_sequence_control_c, 1480 interrupt_sequence_break, 1481 interrupt_sequence_break_g, 1482 NULL 1483 }; 1484static const char *interrupt_sequence_mode = interrupt_sequence_control_c; 1485 1486static void 1487show_interrupt_sequence (struct ui_file *file, int from_tty, 1488 struct cmd_list_element *c, 1489 const char *value) 1490{ 1491 if (interrupt_sequence_mode == interrupt_sequence_control_c) 1492 fprintf_filtered (file, 1493 _("Send the ASCII ETX character (Ctrl-c) " 1494 "to the remote target to interrupt the " 1495 "execution of the program.\n")); 1496 else if (interrupt_sequence_mode == interrupt_sequence_break) 1497 fprintf_filtered (file, 1498 _("send a break signal to the remote target " 1499 "to interrupt the execution of the program.\n")); 1500 else if (interrupt_sequence_mode == interrupt_sequence_break_g) 1501 fprintf_filtered (file, 1502 _("Send a break signal and 'g' a.k.a. Magic SysRq g to " 1503 "the remote target to interrupt the execution " 1504 "of Linux kernel.\n")); 1505 else 1506 internal_error (__FILE__, __LINE__, 1507 _("Invalid value for interrupt_sequence_mode: %s."), 1508 interrupt_sequence_mode); 1509} 1510 1511/* This boolean variable specifies whether interrupt_sequence is sent 1512 to the remote target when gdb connects to it. 1513 This is mostly needed when you debug the Linux kernel: The Linux kernel 1514 expects BREAK g which is Magic SysRq g for connecting gdb. */ 1515static int interrupt_on_connect = 0; 1516 1517/* This variable is used to implement the "set/show remotebreak" commands. 1518 Since these commands are now deprecated in favor of "set/show remote 1519 interrupt-sequence", it no longer has any effect on the code. */ 1520static int remote_break; 1521 1522static void 1523set_remotebreak (const char *args, int from_tty, struct cmd_list_element *c) 1524{ 1525 if (remote_break) 1526 interrupt_sequence_mode = interrupt_sequence_break; 1527 else 1528 interrupt_sequence_mode = interrupt_sequence_control_c; 1529} 1530 1531static void 1532show_remotebreak (struct ui_file *file, int from_tty, 1533 struct cmd_list_element *c, 1534 const char *value) 1535{ 1536} 1537 1538/* This variable sets the number of bits in an address that are to be 1539 sent in a memory ("M" or "m") packet. Normally, after stripping 1540 leading zeros, the entire address would be sent. This variable 1541 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The 1542 initial implementation of remote.c restricted the address sent in 1543 memory packets to ``host::sizeof long'' bytes - (typically 32 1544 bits). Consequently, for 64 bit targets, the upper 32 bits of an 1545 address was never sent. Since fixing this bug may cause a break in 1546 some remote targets this variable is principly provided to 1547 facilitate backward compatibility. */ 1548 1549static unsigned int remote_address_size; 1550 1551 1552/* User configurable variables for the number of characters in a 1553 memory read/write packet. MIN (rsa->remote_packet_size, 1554 rsa->sizeof_g_packet) is the default. Some targets need smaller 1555 values (fifo overruns, et.al.) and some users need larger values 1556 (speed up transfers). The variables ``preferred_*'' (the user 1557 request), ``current_*'' (what was actually set) and ``forced_*'' 1558 (Positive - a soft limit, negative - a hard limit). */ 1559 1560struct memory_packet_config 1561{ 1562 const char *name; 1563 long size; 1564 int fixed_p; 1565}; 1566 1567/* The default max memory-write-packet-size, when the setting is 1568 "fixed". The 16k is historical. (It came from older GDB's using 1569 alloca for buffers and the knowledge (folklore?) that some hosts 1570 don't cope very well with large alloca calls.) */ 1571#define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384 1572 1573/* The minimum remote packet size for memory transfers. Ensures we 1574 can write at least one byte. */ 1575#define MIN_MEMORY_PACKET_SIZE 20 1576 1577/* Get the memory packet size, assuming it is fixed. */ 1578 1579static long 1580get_fixed_memory_packet_size (struct memory_packet_config *config) 1581{ 1582 gdb_assert (config->fixed_p); 1583 1584 if (config->size <= 0) 1585 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED; 1586 else 1587 return config->size; 1588} 1589 1590/* Compute the current size of a read/write packet. Since this makes 1591 use of ``actual_register_packet_size'' the computation is dynamic. */ 1592 1593long 1594remote_target::get_memory_packet_size (struct memory_packet_config *config) 1595{ 1596 struct remote_state *rs = get_remote_state (); 1597 remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ()); 1598 1599 long what_they_get; 1600 if (config->fixed_p) 1601 what_they_get = get_fixed_memory_packet_size (config); 1602 else 1603 { 1604 what_they_get = get_remote_packet_size (); 1605 /* Limit the packet to the size specified by the user. */ 1606 if (config->size > 0 1607 && what_they_get > config->size) 1608 what_they_get = config->size; 1609 1610 /* Limit it to the size of the targets ``g'' response unless we have 1611 permission from the stub to use a larger packet size. */ 1612 if (rs->explicit_packet_size == 0 1613 && rsa->actual_register_packet_size > 0 1614 && what_they_get > rsa->actual_register_packet_size) 1615 what_they_get = rsa->actual_register_packet_size; 1616 } 1617 if (what_they_get < MIN_MEMORY_PACKET_SIZE) 1618 what_they_get = MIN_MEMORY_PACKET_SIZE; 1619 1620 /* Make sure there is room in the global buffer for this packet 1621 (including its trailing NUL byte). */ 1622 if (rs->buf.size () < what_they_get + 1) 1623 rs->buf.resize (2 * what_they_get); 1624 1625 return what_they_get; 1626} 1627 1628/* Update the size of a read/write packet. If they user wants 1629 something really big then do a sanity check. */ 1630 1631static void 1632set_memory_packet_size (const char *args, struct memory_packet_config *config) 1633{ 1634 int fixed_p = config->fixed_p; 1635 long size = config->size; 1636 1637 if (args == NULL) 1638 error (_("Argument required (integer, `fixed' or `limited').")); 1639 else if (strcmp (args, "hard") == 0 1640 || strcmp (args, "fixed") == 0) 1641 fixed_p = 1; 1642 else if (strcmp (args, "soft") == 0 1643 || strcmp (args, "limit") == 0) 1644 fixed_p = 0; 1645 else 1646 { 1647 char *end; 1648 1649 size = strtoul (args, &end, 0); 1650 if (args == end) 1651 error (_("Invalid %s (bad syntax)."), config->name); 1652 1653 /* Instead of explicitly capping the size of a packet to or 1654 disallowing it, the user is allowed to set the size to 1655 something arbitrarily large. */ 1656 } 1657 1658 /* Extra checks? */ 1659 if (fixed_p && !config->fixed_p) 1660 { 1661 /* So that the query shows the correct value. */ 1662 long query_size = (size <= 0 1663 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 1664 : size); 1665 1666 if (! query (_("The target may not be able to correctly handle a %s\n" 1667 "of %ld bytes. Change the packet size? "), 1668 config->name, query_size)) 1669 error (_("Packet size not changed.")); 1670 } 1671 /* Update the config. */ 1672 config->fixed_p = fixed_p; 1673 config->size = size; 1674} 1675 1676static void 1677show_memory_packet_size (struct memory_packet_config *config) 1678{ 1679 if (config->size == 0) 1680 printf_filtered (_("The %s is 0 (default). "), config->name); 1681 else 1682 printf_filtered (_("The %s is %ld. "), config->name, config->size); 1683 if (config->fixed_p) 1684 printf_filtered (_("Packets are fixed at %ld bytes.\n"), 1685 get_fixed_memory_packet_size (config)); 1686 else 1687 { 1688 remote_target *remote = get_current_remote_target (); 1689 1690 if (remote != NULL) 1691 printf_filtered (_("Packets are limited to %ld bytes.\n"), 1692 remote->get_memory_packet_size (config)); 1693 else 1694 puts_filtered ("The actual limit will be further reduced " 1695 "dependent on the target.\n"); 1696 } 1697} 1698 1699static struct memory_packet_config memory_write_packet_config = 1700{ 1701 "memory-write-packet-size", 1702}; 1703 1704static void 1705set_memory_write_packet_size (const char *args, int from_tty) 1706{ 1707 set_memory_packet_size (args, &memory_write_packet_config); 1708} 1709 1710static void 1711show_memory_write_packet_size (const char *args, int from_tty) 1712{ 1713 show_memory_packet_size (&memory_write_packet_config); 1714} 1715 1716/* Show the number of hardware watchpoints that can be used. */ 1717 1718static void 1719show_hardware_watchpoint_limit (struct ui_file *file, int from_tty, 1720 struct cmd_list_element *c, 1721 const char *value) 1722{ 1723 fprintf_filtered (file, _("The maximum number of target hardware " 1724 "watchpoints is %s.\n"), value); 1725} 1726 1727/* Show the length limit (in bytes) for hardware watchpoints. */ 1728 1729static void 1730show_hardware_watchpoint_length_limit (struct ui_file *file, int from_tty, 1731 struct cmd_list_element *c, 1732 const char *value) 1733{ 1734 fprintf_filtered (file, _("The maximum length (in bytes) of a target " 1735 "hardware watchpoint is %s.\n"), value); 1736} 1737 1738/* Show the number of hardware breakpoints that can be used. */ 1739 1740static void 1741show_hardware_breakpoint_limit (struct ui_file *file, int from_tty, 1742 struct cmd_list_element *c, 1743 const char *value) 1744{ 1745 fprintf_filtered (file, _("The maximum number of target hardware " 1746 "breakpoints is %s.\n"), value); 1747} 1748 1749long 1750remote_target::get_memory_write_packet_size () 1751{ 1752 return get_memory_packet_size (&memory_write_packet_config); 1753} 1754 1755static struct memory_packet_config memory_read_packet_config = 1756{ 1757 "memory-read-packet-size", 1758}; 1759 1760static void 1761set_memory_read_packet_size (const char *args, int from_tty) 1762{ 1763 set_memory_packet_size (args, &memory_read_packet_config); 1764} 1765 1766static void 1767show_memory_read_packet_size (const char *args, int from_tty) 1768{ 1769 show_memory_packet_size (&memory_read_packet_config); 1770} 1771 1772long 1773remote_target::get_memory_read_packet_size () 1774{ 1775 long size = get_memory_packet_size (&memory_read_packet_config); 1776 1777 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an 1778 extra buffer size argument before the memory read size can be 1779 increased beyond this. */ 1780 if (size > get_remote_packet_size ()) 1781 size = get_remote_packet_size (); 1782 return size; 1783} 1784 1785 1786 1787struct packet_config 1788 { 1789 const char *name; 1790 const char *title; 1791 1792 /* If auto, GDB auto-detects support for this packet or feature, 1793 either through qSupported, or by trying the packet and looking 1794 at the response. If true, GDB assumes the target supports this 1795 packet. If false, the packet is disabled. Configs that don't 1796 have an associated command always have this set to auto. */ 1797 enum auto_boolean detect; 1798 1799 /* Does the target support this packet? */ 1800 enum packet_support support; 1801 }; 1802 1803static enum packet_support packet_config_support (struct packet_config *config); 1804static enum packet_support packet_support (int packet); 1805 1806static void 1807show_packet_config_cmd (struct packet_config *config) 1808{ 1809 const char *support = "internal-error"; 1810 1811 switch (packet_config_support (config)) 1812 { 1813 case PACKET_ENABLE: 1814 support = "enabled"; 1815 break; 1816 case PACKET_DISABLE: 1817 support = "disabled"; 1818 break; 1819 case PACKET_SUPPORT_UNKNOWN: 1820 support = "unknown"; 1821 break; 1822 } 1823 switch (config->detect) 1824 { 1825 case AUTO_BOOLEAN_AUTO: 1826 printf_filtered (_("Support for the `%s' packet " 1827 "is auto-detected, currently %s.\n"), 1828 config->name, support); 1829 break; 1830 case AUTO_BOOLEAN_TRUE: 1831 case AUTO_BOOLEAN_FALSE: 1832 printf_filtered (_("Support for the `%s' packet is currently %s.\n"), 1833 config->name, support); 1834 break; 1835 } 1836} 1837 1838static void 1839add_packet_config_cmd (struct packet_config *config, const char *name, 1840 const char *title, int legacy) 1841{ 1842 char *set_doc; 1843 char *show_doc; 1844 char *cmd_name; 1845 1846 config->name = name; 1847 config->title = title; 1848 set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet", 1849 name, title); 1850 show_doc = xstrprintf ("Show current use of remote " 1851 "protocol `%s' (%s) packet", 1852 name, title); 1853 /* set/show TITLE-packet {auto,on,off} */ 1854 cmd_name = xstrprintf ("%s-packet", title); 1855 add_setshow_auto_boolean_cmd (cmd_name, class_obscure, 1856 &config->detect, set_doc, 1857 show_doc, NULL, /* help_doc */ 1858 NULL, 1859 show_remote_protocol_packet_cmd, 1860 &remote_set_cmdlist, &remote_show_cmdlist); 1861 /* The command code copies the documentation strings. */ 1862 xfree (set_doc); 1863 xfree (show_doc); 1864 /* set/show remote NAME-packet {auto,on,off} -- legacy. */ 1865 if (legacy) 1866 { 1867 char *legacy_name; 1868 1869 legacy_name = xstrprintf ("%s-packet", name); 1870 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0, 1871 &remote_set_cmdlist); 1872 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0, 1873 &remote_show_cmdlist); 1874 } 1875} 1876 1877static enum packet_result 1878packet_check_result (const char *buf) 1879{ 1880 if (buf[0] != '\0') 1881 { 1882 /* The stub recognized the packet request. Check that the 1883 operation succeeded. */ 1884 if (buf[0] == 'E' 1885 && isxdigit (buf[1]) && isxdigit (buf[2]) 1886 && buf[3] == '\0') 1887 /* "Enn" - definitly an error. */ 1888 return PACKET_ERROR; 1889 1890 /* Always treat "E." as an error. This will be used for 1891 more verbose error messages, such as E.memtypes. */ 1892 if (buf[0] == 'E' && buf[1] == '.') 1893 return PACKET_ERROR; 1894 1895 /* The packet may or may not be OK. Just assume it is. */ 1896 return PACKET_OK; 1897 } 1898 else 1899 /* The stub does not support the packet. */ 1900 return PACKET_UNKNOWN; 1901} 1902 1903static enum packet_result 1904packet_check_result (const gdb::char_vector &buf) 1905{ 1906 return packet_check_result (buf.data ()); 1907} 1908 1909static enum packet_result 1910packet_ok (const char *buf, struct packet_config *config) 1911{ 1912 enum packet_result result; 1913 1914 if (config->detect != AUTO_BOOLEAN_TRUE 1915 && config->support == PACKET_DISABLE) 1916 internal_error (__FILE__, __LINE__, 1917 _("packet_ok: attempt to use a disabled packet")); 1918 1919 result = packet_check_result (buf); 1920 switch (result) 1921 { 1922 case PACKET_OK: 1923 case PACKET_ERROR: 1924 /* The stub recognized the packet request. */ 1925 if (config->support == PACKET_SUPPORT_UNKNOWN) 1926 { 1927 if (remote_debug) 1928 fprintf_unfiltered (gdb_stdlog, 1929 "Packet %s (%s) is supported\n", 1930 config->name, config->title); 1931 config->support = PACKET_ENABLE; 1932 } 1933 break; 1934 case PACKET_UNKNOWN: 1935 /* The stub does not support the packet. */ 1936 if (config->detect == AUTO_BOOLEAN_AUTO 1937 && config->support == PACKET_ENABLE) 1938 { 1939 /* If the stub previously indicated that the packet was 1940 supported then there is a protocol error. */ 1941 error (_("Protocol error: %s (%s) conflicting enabled responses."), 1942 config->name, config->title); 1943 } 1944 else if (config->detect == AUTO_BOOLEAN_TRUE) 1945 { 1946 /* The user set it wrong. */ 1947 error (_("Enabled packet %s (%s) not recognized by stub"), 1948 config->name, config->title); 1949 } 1950 1951 if (remote_debug) 1952 fprintf_unfiltered (gdb_stdlog, 1953 "Packet %s (%s) is NOT supported\n", 1954 config->name, config->title); 1955 config->support = PACKET_DISABLE; 1956 break; 1957 } 1958 1959 return result; 1960} 1961 1962static enum packet_result 1963packet_ok (const gdb::char_vector &buf, struct packet_config *config) 1964{ 1965 return packet_ok (buf.data (), config); 1966} 1967 1968enum { 1969 PACKET_vCont = 0, 1970 PACKET_X, 1971 PACKET_qSymbol, 1972 PACKET_P, 1973 PACKET_p, 1974 PACKET_Z0, 1975 PACKET_Z1, 1976 PACKET_Z2, 1977 PACKET_Z3, 1978 PACKET_Z4, 1979 PACKET_vFile_setfs, 1980 PACKET_vFile_open, 1981 PACKET_vFile_pread, 1982 PACKET_vFile_pwrite, 1983 PACKET_vFile_close, 1984 PACKET_vFile_unlink, 1985 PACKET_vFile_readlink, 1986 PACKET_vFile_fstat, 1987 PACKET_qXfer_auxv, 1988 PACKET_qXfer_features, 1989 PACKET_qXfer_exec_file, 1990 PACKET_qXfer_libraries, 1991 PACKET_qXfer_libraries_svr4, 1992 PACKET_qXfer_memory_map, 1993 PACKET_qXfer_spu_read, 1994 PACKET_qXfer_spu_write, 1995 PACKET_qXfer_osdata, 1996 PACKET_qXfer_threads, 1997 PACKET_qXfer_statictrace_read, 1998 PACKET_qXfer_traceframe_info, 1999 PACKET_qXfer_uib, 2000 PACKET_qGetTIBAddr, 2001 PACKET_qGetTLSAddr, 2002 PACKET_qSupported, 2003 PACKET_qTStatus, 2004 PACKET_QPassSignals, 2005 PACKET_QCatchSyscalls, 2006 PACKET_QProgramSignals, 2007 PACKET_QSetWorkingDir, 2008 PACKET_QStartupWithShell, 2009 PACKET_QEnvironmentHexEncoded, 2010 PACKET_QEnvironmentReset, 2011 PACKET_QEnvironmentUnset, 2012 PACKET_qCRC, 2013 PACKET_qSearch_memory, 2014 PACKET_vAttach, 2015 PACKET_vRun, 2016 PACKET_QStartNoAckMode, 2017 PACKET_vKill, 2018 PACKET_qXfer_siginfo_read, 2019 PACKET_qXfer_siginfo_write, 2020 PACKET_qAttached, 2021 2022 /* Support for conditional tracepoints. */ 2023 PACKET_ConditionalTracepoints, 2024 2025 /* Support for target-side breakpoint conditions. */ 2026 PACKET_ConditionalBreakpoints, 2027 2028 /* Support for target-side breakpoint commands. */ 2029 PACKET_BreakpointCommands, 2030 2031 /* Support for fast tracepoints. */ 2032 PACKET_FastTracepoints, 2033 2034 /* Support for static tracepoints. */ 2035 PACKET_StaticTracepoints, 2036 2037 /* Support for installing tracepoints while a trace experiment is 2038 running. */ 2039 PACKET_InstallInTrace, 2040 2041 PACKET_bc, 2042 PACKET_bs, 2043 PACKET_TracepointSource, 2044 PACKET_QAllow, 2045 PACKET_qXfer_fdpic, 2046 PACKET_QDisableRandomization, 2047 PACKET_QAgent, 2048 PACKET_QTBuffer_size, 2049 PACKET_Qbtrace_off, 2050 PACKET_Qbtrace_bts, 2051 PACKET_Qbtrace_pt, 2052 PACKET_qXfer_btrace, 2053 2054 /* Support for the QNonStop packet. */ 2055 PACKET_QNonStop, 2056 2057 /* Support for the QThreadEvents packet. */ 2058 PACKET_QThreadEvents, 2059 2060 /* Support for multi-process extensions. */ 2061 PACKET_multiprocess_feature, 2062 2063 /* Support for enabling and disabling tracepoints while a trace 2064 experiment is running. */ 2065 PACKET_EnableDisableTracepoints_feature, 2066 2067 /* Support for collecting strings using the tracenz bytecode. */ 2068 PACKET_tracenz_feature, 2069 2070 /* Support for continuing to run a trace experiment while GDB is 2071 disconnected. */ 2072 PACKET_DisconnectedTracing_feature, 2073 2074 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */ 2075 PACKET_augmented_libraries_svr4_read_feature, 2076 2077 /* Support for the qXfer:btrace-conf:read packet. */ 2078 PACKET_qXfer_btrace_conf, 2079 2080 /* Support for the Qbtrace-conf:bts:size packet. */ 2081 PACKET_Qbtrace_conf_bts_size, 2082 2083 /* Support for swbreak+ feature. */ 2084 PACKET_swbreak_feature, 2085 2086 /* Support for hwbreak+ feature. */ 2087 PACKET_hwbreak_feature, 2088 2089 /* Support for fork events. */ 2090 PACKET_fork_event_feature, 2091 2092 /* Support for vfork events. */ 2093 PACKET_vfork_event_feature, 2094 2095 /* Support for the Qbtrace-conf:pt:size packet. */ 2096 PACKET_Qbtrace_conf_pt_size, 2097 2098 /* Support for exec events. */ 2099 PACKET_exec_event_feature, 2100 2101 /* Support for query supported vCont actions. */ 2102 PACKET_vContSupported, 2103 2104 /* Support remote CTRL-C. */ 2105 PACKET_vCtrlC, 2106 2107 /* Support TARGET_WAITKIND_NO_RESUMED. */ 2108 PACKET_no_resumed, 2109 2110 PACKET_MAX 2111}; 2112 2113static struct packet_config remote_protocol_packets[PACKET_MAX]; 2114 2115/* Returns the packet's corresponding "set remote foo-packet" command 2116 state. See struct packet_config for more details. */ 2117 2118static enum auto_boolean 2119packet_set_cmd_state (int packet) 2120{ 2121 return remote_protocol_packets[packet].detect; 2122} 2123 2124/* Returns whether a given packet or feature is supported. This takes 2125 into account the state of the corresponding "set remote foo-packet" 2126 command, which may be used to bypass auto-detection. */ 2127 2128static enum packet_support 2129packet_config_support (struct packet_config *config) 2130{ 2131 switch (config->detect) 2132 { 2133 case AUTO_BOOLEAN_TRUE: 2134 return PACKET_ENABLE; 2135 case AUTO_BOOLEAN_FALSE: 2136 return PACKET_DISABLE; 2137 case AUTO_BOOLEAN_AUTO: 2138 return config->support; 2139 default: 2140 gdb_assert_not_reached (_("bad switch")); 2141 } 2142} 2143 2144/* Same as packet_config_support, but takes the packet's enum value as 2145 argument. */ 2146 2147static enum packet_support 2148packet_support (int packet) 2149{ 2150 struct packet_config *config = &remote_protocol_packets[packet]; 2151 2152 return packet_config_support (config); 2153} 2154 2155static void 2156show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty, 2157 struct cmd_list_element *c, 2158 const char *value) 2159{ 2160 struct packet_config *packet; 2161 2162 for (packet = remote_protocol_packets; 2163 packet < &remote_protocol_packets[PACKET_MAX]; 2164 packet++) 2165 { 2166 if (&packet->detect == c->var) 2167 { 2168 show_packet_config_cmd (packet); 2169 return; 2170 } 2171 } 2172 internal_error (__FILE__, __LINE__, _("Could not find config for %s"), 2173 c->name); 2174} 2175 2176/* Should we try one of the 'Z' requests? */ 2177 2178enum Z_packet_type 2179{ 2180 Z_PACKET_SOFTWARE_BP, 2181 Z_PACKET_HARDWARE_BP, 2182 Z_PACKET_WRITE_WP, 2183 Z_PACKET_READ_WP, 2184 Z_PACKET_ACCESS_WP, 2185 NR_Z_PACKET_TYPES 2186}; 2187 2188/* For compatibility with older distributions. Provide a ``set remote 2189 Z-packet ...'' command that updates all the Z packet types. */ 2190 2191static enum auto_boolean remote_Z_packet_detect; 2192 2193static void 2194set_remote_protocol_Z_packet_cmd (const char *args, int from_tty, 2195 struct cmd_list_element *c) 2196{ 2197 int i; 2198 2199 for (i = 0; i < NR_Z_PACKET_TYPES; i++) 2200 remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect; 2201} 2202 2203static void 2204show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty, 2205 struct cmd_list_element *c, 2206 const char *value) 2207{ 2208 int i; 2209 2210 for (i = 0; i < NR_Z_PACKET_TYPES; i++) 2211 { 2212 show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]); 2213 } 2214} 2215 2216/* Returns true if the multi-process extensions are in effect. */ 2217 2218static int 2219remote_multi_process_p (struct remote_state *rs) 2220{ 2221 return packet_support (PACKET_multiprocess_feature) == PACKET_ENABLE; 2222} 2223 2224/* Returns true if fork events are supported. */ 2225 2226static int 2227remote_fork_event_p (struct remote_state *rs) 2228{ 2229 return packet_support (PACKET_fork_event_feature) == PACKET_ENABLE; 2230} 2231 2232/* Returns true if vfork events are supported. */ 2233 2234static int 2235remote_vfork_event_p (struct remote_state *rs) 2236{ 2237 return packet_support (PACKET_vfork_event_feature) == PACKET_ENABLE; 2238} 2239 2240/* Returns true if exec events are supported. */ 2241 2242static int 2243remote_exec_event_p (struct remote_state *rs) 2244{ 2245 return packet_support (PACKET_exec_event_feature) == PACKET_ENABLE; 2246} 2247 2248/* Insert fork catchpoint target routine. If fork events are enabled 2249 then return success, nothing more to do. */ 2250 2251int 2252remote_target::insert_fork_catchpoint (int pid) 2253{ 2254 struct remote_state *rs = get_remote_state (); 2255 2256 return !remote_fork_event_p (rs); 2257} 2258 2259/* Remove fork catchpoint target routine. Nothing to do, just 2260 return success. */ 2261 2262int 2263remote_target::remove_fork_catchpoint (int pid) 2264{ 2265 return 0; 2266} 2267 2268/* Insert vfork catchpoint target routine. If vfork events are enabled 2269 then return success, nothing more to do. */ 2270 2271int 2272remote_target::insert_vfork_catchpoint (int pid) 2273{ 2274 struct remote_state *rs = get_remote_state (); 2275 2276 return !remote_vfork_event_p (rs); 2277} 2278 2279/* Remove vfork catchpoint target routine. Nothing to do, just 2280 return success. */ 2281 2282int 2283remote_target::remove_vfork_catchpoint (int pid) 2284{ 2285 return 0; 2286} 2287 2288/* Insert exec catchpoint target routine. If exec events are 2289 enabled, just return success. */ 2290 2291int 2292remote_target::insert_exec_catchpoint (int pid) 2293{ 2294 struct remote_state *rs = get_remote_state (); 2295 2296 return !remote_exec_event_p (rs); 2297} 2298 2299/* Remove exec catchpoint target routine. Nothing to do, just 2300 return success. */ 2301 2302int 2303remote_target::remove_exec_catchpoint (int pid) 2304{ 2305 return 0; 2306} 2307 2308 2309 2310static ptid_t magic_null_ptid; 2311static ptid_t not_sent_ptid; 2312static ptid_t any_thread_ptid; 2313 2314/* Find out if the stub attached to PID (and hence GDB should offer to 2315 detach instead of killing it when bailing out). */ 2316 2317int 2318remote_target::remote_query_attached (int pid) 2319{ 2320 struct remote_state *rs = get_remote_state (); 2321 size_t size = get_remote_packet_size (); 2322 2323 if (packet_support (PACKET_qAttached) == PACKET_DISABLE) 2324 return 0; 2325 2326 if (remote_multi_process_p (rs)) 2327 xsnprintf (rs->buf.data (), size, "qAttached:%x", pid); 2328 else 2329 xsnprintf (rs->buf.data (), size, "qAttached"); 2330 2331 putpkt (rs->buf); 2332 getpkt (&rs->buf, 0); 2333 2334 switch (packet_ok (rs->buf, 2335 &remote_protocol_packets[PACKET_qAttached])) 2336 { 2337 case PACKET_OK: 2338 if (strcmp (rs->buf.data (), "1") == 0) 2339 return 1; 2340 break; 2341 case PACKET_ERROR: 2342 warning (_("Remote failure reply: %s"), rs->buf.data ()); 2343 break; 2344 case PACKET_UNKNOWN: 2345 break; 2346 } 2347 2348 return 0; 2349} 2350 2351/* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID 2352 has been invented by GDB, instead of reported by the target. Since 2353 we can be connected to a remote system before before knowing about 2354 any inferior, mark the target with execution when we find the first 2355 inferior. If ATTACHED is 1, then we had just attached to this 2356 inferior. If it is 0, then we just created this inferior. If it 2357 is -1, then try querying the remote stub to find out if it had 2358 attached to the inferior or not. If TRY_OPEN_EXEC is true then 2359 attempt to open this inferior's executable as the main executable 2360 if no main executable is open already. */ 2361 2362inferior * 2363remote_target::remote_add_inferior (int fake_pid_p, int pid, int attached, 2364 int try_open_exec) 2365{ 2366 struct inferior *inf; 2367 2368 /* Check whether this process we're learning about is to be 2369 considered attached, or if is to be considered to have been 2370 spawned by the stub. */ 2371 if (attached == -1) 2372 attached = remote_query_attached (pid); 2373 2374 if (gdbarch_has_global_solist (target_gdbarch ())) 2375 { 2376 /* If the target shares code across all inferiors, then every 2377 attach adds a new inferior. */ 2378 inf = add_inferior (pid); 2379 2380 /* ... and every inferior is bound to the same program space. 2381 However, each inferior may still have its own address 2382 space. */ 2383 inf->aspace = maybe_new_address_space (); 2384 inf->pspace = current_program_space; 2385 } 2386 else 2387 { 2388 /* In the traditional debugging scenario, there's a 1-1 match 2389 between program/address spaces. We simply bind the inferior 2390 to the program space's address space. */ 2391 inf = current_inferior (); 2392 inferior_appeared (inf, pid); 2393 } 2394 2395 inf->attach_flag = attached; 2396 inf->fake_pid_p = fake_pid_p; 2397 2398 /* If no main executable is currently open then attempt to 2399 open the file that was executed to create this inferior. */ 2400 if (try_open_exec && get_exec_file (0) == NULL) 2401 exec_file_locate_attach (pid, 0, 1); 2402 2403 return inf; 2404} 2405 2406static remote_thread_info *get_remote_thread_info (thread_info *thread); 2407static remote_thread_info *get_remote_thread_info (ptid_t ptid); 2408 2409/* Add thread PTID to GDB's thread list. Tag it as executing/running 2410 according to RUNNING. */ 2411 2412thread_info * 2413remote_target::remote_add_thread (ptid_t ptid, bool running, bool executing) 2414{ 2415 struct remote_state *rs = get_remote_state (); 2416 struct thread_info *thread; 2417 2418 /* GDB historically didn't pull threads in the initial connection 2419 setup. If the remote target doesn't even have a concept of 2420 threads (e.g., a bare-metal target), even if internally we 2421 consider that a single-threaded target, mentioning a new thread 2422 might be confusing to the user. Be silent then, preserving the 2423 age old behavior. */ 2424 if (rs->starting_up) 2425 thread = add_thread_silent (ptid); 2426 else 2427 thread = add_thread (ptid); 2428 2429 get_remote_thread_info (thread)->vcont_resumed = executing; 2430 set_executing (ptid, executing); 2431 set_running (ptid, running); 2432 2433 return thread; 2434} 2435 2436/* Come here when we learn about a thread id from the remote target. 2437 It may be the first time we hear about such thread, so take the 2438 opportunity to add it to GDB's thread list. In case this is the 2439 first time we're noticing its corresponding inferior, add it to 2440 GDB's inferior list as well. EXECUTING indicates whether the 2441 thread is (internally) executing or stopped. */ 2442 2443void 2444remote_target::remote_notice_new_inferior (ptid_t currthread, int executing) 2445{ 2446 /* In non-stop mode, we assume new found threads are (externally) 2447 running until proven otherwise with a stop reply. In all-stop, 2448 we can only get here if all threads are stopped. */ 2449 int running = target_is_non_stop_p () ? 1 : 0; 2450 2451 /* If this is a new thread, add it to GDB's thread list. 2452 If we leave it up to WFI to do this, bad things will happen. */ 2453 2454 thread_info *tp = find_thread_ptid (currthread); 2455 if (tp != NULL && tp->state == THREAD_EXITED) 2456 { 2457 /* We're seeing an event on a thread id we knew had exited. 2458 This has to be a new thread reusing the old id. Add it. */ 2459 remote_add_thread (currthread, running, executing); 2460 return; 2461 } 2462 2463 if (!in_thread_list (currthread)) 2464 { 2465 struct inferior *inf = NULL; 2466 int pid = currthread.pid (); 2467 2468 if (inferior_ptid.is_pid () 2469 && pid == inferior_ptid.pid ()) 2470 { 2471 /* inferior_ptid has no thread member yet. This can happen 2472 with the vAttach -> remote_wait,"TAAthread:" path if the 2473 stub doesn't support qC. This is the first stop reported 2474 after an attach, so this is the main thread. Update the 2475 ptid in the thread list. */ 2476 if (in_thread_list (ptid_t (pid))) 2477 thread_change_ptid (inferior_ptid, currthread); 2478 else 2479 { 2480 remote_add_thread (currthread, running, executing); 2481 inferior_ptid = currthread; 2482 } 2483 return; 2484 } 2485 2486 if (magic_null_ptid == inferior_ptid) 2487 { 2488 /* inferior_ptid is not set yet. This can happen with the 2489 vRun -> remote_wait,"TAAthread:" path if the stub 2490 doesn't support qC. This is the first stop reported 2491 after an attach, so this is the main thread. Update the 2492 ptid in the thread list. */ 2493 thread_change_ptid (inferior_ptid, currthread); 2494 return; 2495 } 2496 2497 /* When connecting to a target remote, or to a target 2498 extended-remote which already was debugging an inferior, we 2499 may not know about it yet. Add it before adding its child 2500 thread, so notifications are emitted in a sensible order. */ 2501 if (find_inferior_pid (currthread.pid ()) == NULL) 2502 { 2503 struct remote_state *rs = get_remote_state (); 2504 int fake_pid_p = !remote_multi_process_p (rs); 2505 2506 inf = remote_add_inferior (fake_pid_p, 2507 currthread.pid (), -1, 1); 2508 } 2509 2510 /* This is really a new thread. Add it. */ 2511 thread_info *new_thr 2512 = remote_add_thread (currthread, running, executing); 2513 2514 /* If we found a new inferior, let the common code do whatever 2515 it needs to with it (e.g., read shared libraries, insert 2516 breakpoints), unless we're just setting up an all-stop 2517 connection. */ 2518 if (inf != NULL) 2519 { 2520 struct remote_state *rs = get_remote_state (); 2521 2522 if (!rs->starting_up) 2523 notice_new_inferior (new_thr, executing, 0); 2524 } 2525 } 2526} 2527 2528/* Return THREAD's private thread data, creating it if necessary. */ 2529 2530static remote_thread_info * 2531get_remote_thread_info (thread_info *thread) 2532{ 2533 gdb_assert (thread != NULL); 2534 2535 if (thread->priv == NULL) 2536 thread->priv.reset (new remote_thread_info); 2537 2538 return static_cast<remote_thread_info *> (thread->priv.get ()); 2539} 2540 2541static remote_thread_info * 2542get_remote_thread_info (ptid_t ptid) 2543{ 2544 thread_info *thr = find_thread_ptid (ptid); 2545 return get_remote_thread_info (thr); 2546} 2547 2548/* Call this function as a result of 2549 1) A halt indication (T packet) containing a thread id 2550 2) A direct query of currthread 2551 3) Successful execution of set thread */ 2552 2553static void 2554record_currthread (struct remote_state *rs, ptid_t currthread) 2555{ 2556 rs->general_thread = currthread; 2557} 2558 2559/* If 'QPassSignals' is supported, tell the remote stub what signals 2560 it can simply pass through to the inferior without reporting. */ 2561 2562void 2563remote_target::pass_signals (gdb::array_view<const unsigned char> pass_signals) 2564{ 2565 if (packet_support (PACKET_QPassSignals) != PACKET_DISABLE) 2566 { 2567 char *pass_packet, *p; 2568 int count = 0; 2569 struct remote_state *rs = get_remote_state (); 2570 2571 gdb_assert (pass_signals.size () < 256); 2572 for (size_t i = 0; i < pass_signals.size (); i++) 2573 { 2574 if (pass_signals[i]) 2575 count++; 2576 } 2577 pass_packet = (char *) xmalloc (count * 3 + strlen ("QPassSignals:") + 1); 2578 strcpy (pass_packet, "QPassSignals:"); 2579 p = pass_packet + strlen (pass_packet); 2580 for (size_t i = 0; i < pass_signals.size (); i++) 2581 { 2582 if (pass_signals[i]) 2583 { 2584 if (i >= 16) 2585 *p++ = tohex (i >> 4); 2586 *p++ = tohex (i & 15); 2587 if (count) 2588 *p++ = ';'; 2589 else 2590 break; 2591 count--; 2592 } 2593 } 2594 *p = 0; 2595 if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet)) 2596 { 2597 putpkt (pass_packet); 2598 getpkt (&rs->buf, 0); 2599 packet_ok (rs->buf, &remote_protocol_packets[PACKET_QPassSignals]); 2600 if (rs->last_pass_packet) 2601 xfree (rs->last_pass_packet); 2602 rs->last_pass_packet = pass_packet; 2603 } 2604 else 2605 xfree (pass_packet); 2606 } 2607} 2608 2609/* If 'QCatchSyscalls' is supported, tell the remote stub 2610 to report syscalls to GDB. */ 2611 2612int 2613remote_target::set_syscall_catchpoint (int pid, bool needed, int any_count, 2614 gdb::array_view<const int> syscall_counts) 2615{ 2616 const char *catch_packet; 2617 enum packet_result result; 2618 int n_sysno = 0; 2619 2620 if (packet_support (PACKET_QCatchSyscalls) == PACKET_DISABLE) 2621 { 2622 /* Not supported. */ 2623 return 1; 2624 } 2625 2626 if (needed && any_count == 0) 2627 { 2628 /* Count how many syscalls are to be caught. */ 2629 for (size_t i = 0; i < syscall_counts.size (); i++) 2630 { 2631 if (syscall_counts[i] != 0) 2632 n_sysno++; 2633 } 2634 } 2635 2636 if (remote_debug) 2637 { 2638 fprintf_unfiltered (gdb_stdlog, 2639 "remote_set_syscall_catchpoint " 2640 "pid %d needed %d any_count %d n_sysno %d\n", 2641 pid, needed, any_count, n_sysno); 2642 } 2643 2644 std::string built_packet; 2645 if (needed) 2646 { 2647 /* Prepare a packet with the sysno list, assuming max 8+1 2648 characters for a sysno. If the resulting packet size is too 2649 big, fallback on the non-selective packet. */ 2650 const int maxpktsz = strlen ("QCatchSyscalls:1") + n_sysno * 9 + 1; 2651 built_packet.reserve (maxpktsz); 2652 built_packet = "QCatchSyscalls:1"; 2653 if (any_count == 0) 2654 { 2655 /* Add in each syscall to be caught. */ 2656 for (size_t i = 0; i < syscall_counts.size (); i++) 2657 { 2658 if (syscall_counts[i] != 0) 2659 string_appendf (built_packet, ";%zx", i); 2660 } 2661 } 2662 if (built_packet.size () > get_remote_packet_size ()) 2663 { 2664 /* catch_packet too big. Fallback to less efficient 2665 non selective mode, with GDB doing the filtering. */ 2666 catch_packet = "QCatchSyscalls:1"; 2667 } 2668 else 2669 catch_packet = built_packet.c_str (); 2670 } 2671 else 2672 catch_packet = "QCatchSyscalls:0"; 2673 2674 struct remote_state *rs = get_remote_state (); 2675 2676 putpkt (catch_packet); 2677 getpkt (&rs->buf, 0); 2678 result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_QCatchSyscalls]); 2679 if (result == PACKET_OK) 2680 return 0; 2681 else 2682 return -1; 2683} 2684 2685/* If 'QProgramSignals' is supported, tell the remote stub what 2686 signals it should pass through to the inferior when detaching. */ 2687 2688void 2689remote_target::program_signals (gdb::array_view<const unsigned char> signals) 2690{ 2691 if (packet_support (PACKET_QProgramSignals) != PACKET_DISABLE) 2692 { 2693 char *packet, *p; 2694 int count = 0; 2695 struct remote_state *rs = get_remote_state (); 2696 2697 gdb_assert (signals.size () < 256); 2698 for (size_t i = 0; i < signals.size (); i++) 2699 { 2700 if (signals[i]) 2701 count++; 2702 } 2703 packet = (char *) xmalloc (count * 3 + strlen ("QProgramSignals:") + 1); 2704 strcpy (packet, "QProgramSignals:"); 2705 p = packet + strlen (packet); 2706 for (size_t i = 0; i < signals.size (); i++) 2707 { 2708 if (signal_pass_state (i)) 2709 { 2710 if (i >= 16) 2711 *p++ = tohex (i >> 4); 2712 *p++ = tohex (i & 15); 2713 if (count) 2714 *p++ = ';'; 2715 else 2716 break; 2717 count--; 2718 } 2719 } 2720 *p = 0; 2721 if (!rs->last_program_signals_packet 2722 || strcmp (rs->last_program_signals_packet, packet) != 0) 2723 { 2724 putpkt (packet); 2725 getpkt (&rs->buf, 0); 2726 packet_ok (rs->buf, &remote_protocol_packets[PACKET_QProgramSignals]); 2727 xfree (rs->last_program_signals_packet); 2728 rs->last_program_signals_packet = packet; 2729 } 2730 else 2731 xfree (packet); 2732 } 2733} 2734 2735/* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is 2736 MINUS_ONE_PTID, set the thread to -1, so the stub returns the 2737 thread. If GEN is set, set the general thread, if not, then set 2738 the step/continue thread. */ 2739void 2740remote_target::set_thread (ptid_t ptid, int gen) 2741{ 2742 struct remote_state *rs = get_remote_state (); 2743 ptid_t state = gen ? rs->general_thread : rs->continue_thread; 2744 char *buf = rs->buf.data (); 2745 char *endbuf = buf + get_remote_packet_size (); 2746 2747 if (state == ptid) 2748 return; 2749 2750 *buf++ = 'H'; 2751 *buf++ = gen ? 'g' : 'c'; 2752 if (ptid == magic_null_ptid) 2753 xsnprintf (buf, endbuf - buf, "0"); 2754 else if (ptid == any_thread_ptid) 2755 xsnprintf (buf, endbuf - buf, "0"); 2756 else if (ptid == minus_one_ptid) 2757 xsnprintf (buf, endbuf - buf, "-1"); 2758 else 2759 write_ptid (buf, endbuf, ptid); 2760 putpkt (rs->buf); 2761 getpkt (&rs->buf, 0); 2762 if (gen) 2763 rs->general_thread = ptid; 2764 else 2765 rs->continue_thread = ptid; 2766} 2767 2768void 2769remote_target::set_general_thread (ptid_t ptid) 2770{ 2771 set_thread (ptid, 1); 2772} 2773 2774void 2775remote_target::set_continue_thread (ptid_t ptid) 2776{ 2777 set_thread (ptid, 0); 2778} 2779 2780/* Change the remote current process. Which thread within the process 2781 ends up selected isn't important, as long as it is the same process 2782 as what INFERIOR_PTID points to. 2783 2784 This comes from that fact that there is no explicit notion of 2785 "selected process" in the protocol. The selected process for 2786 general operations is the process the selected general thread 2787 belongs to. */ 2788 2789void 2790remote_target::set_general_process () 2791{ 2792 struct remote_state *rs = get_remote_state (); 2793 2794 /* If the remote can't handle multiple processes, don't bother. */ 2795 if (!remote_multi_process_p (rs)) 2796 return; 2797 2798 /* We only need to change the remote current thread if it's pointing 2799 at some other process. */ 2800 if (rs->general_thread.pid () != inferior_ptid.pid ()) 2801 set_general_thread (inferior_ptid); 2802} 2803 2804 2805/* Return nonzero if this is the main thread that we made up ourselves 2806 to model non-threaded targets as single-threaded. */ 2807 2808static int 2809remote_thread_always_alive (ptid_t ptid) 2810{ 2811 if (ptid == magic_null_ptid) 2812 /* The main thread is always alive. */ 2813 return 1; 2814 2815 if (ptid.pid () != 0 && ptid.lwp () == 0) 2816 /* The main thread is always alive. This can happen after a 2817 vAttach, if the remote side doesn't support 2818 multi-threading. */ 2819 return 1; 2820 2821 return 0; 2822} 2823 2824/* Return nonzero if the thread PTID is still alive on the remote 2825 system. */ 2826 2827bool 2828remote_target::thread_alive (ptid_t ptid) 2829{ 2830 struct remote_state *rs = get_remote_state (); 2831 char *p, *endp; 2832 2833 /* Check if this is a thread that we made up ourselves to model 2834 non-threaded targets as single-threaded. */ 2835 if (remote_thread_always_alive (ptid)) 2836 return 1; 2837 2838 p = rs->buf.data (); 2839 endp = p + get_remote_packet_size (); 2840 2841 *p++ = 'T'; 2842 write_ptid (p, endp, ptid); 2843 2844 putpkt (rs->buf); 2845 getpkt (&rs->buf, 0); 2846 return (rs->buf[0] == 'O' && rs->buf[1] == 'K'); 2847} 2848 2849/* Return a pointer to a thread name if we know it and NULL otherwise. 2850 The thread_info object owns the memory for the name. */ 2851 2852const char * 2853remote_target::thread_name (struct thread_info *info) 2854{ 2855 if (info->priv != NULL) 2856 { 2857 const std::string &name = get_remote_thread_info (info)->name; 2858 return !name.empty () ? name.c_str () : NULL; 2859 } 2860 2861 return NULL; 2862} 2863 2864/* About these extended threadlist and threadinfo packets. They are 2865 variable length packets but, the fields within them are often fixed 2866 length. They are redundent enough to send over UDP as is the 2867 remote protocol in general. There is a matching unit test module 2868 in libstub. */ 2869 2870/* WARNING: This threadref data structure comes from the remote O.S., 2871 libstub protocol encoding, and remote.c. It is not particularly 2872 changable. */ 2873 2874/* Right now, the internal structure is int. We want it to be bigger. 2875 Plan to fix this. */ 2876 2877typedef int gdb_threadref; /* Internal GDB thread reference. */ 2878 2879/* gdb_ext_thread_info is an internal GDB data structure which is 2880 equivalent to the reply of the remote threadinfo packet. */ 2881 2882struct gdb_ext_thread_info 2883 { 2884 threadref threadid; /* External form of thread reference. */ 2885 int active; /* Has state interesting to GDB? 2886 regs, stack. */ 2887 char display[256]; /* Brief state display, name, 2888 blocked/suspended. */ 2889 char shortname[32]; /* To be used to name threads. */ 2890 char more_display[256]; /* Long info, statistics, queue depth, 2891 whatever. */ 2892 }; 2893 2894/* The volume of remote transfers can be limited by submitting 2895 a mask containing bits specifying the desired information. 2896 Use a union of these values as the 'selection' parameter to 2897 get_thread_info. FIXME: Make these TAG names more thread specific. */ 2898 2899#define TAG_THREADID 1 2900#define TAG_EXISTS 2 2901#define TAG_DISPLAY 4 2902#define TAG_THREADNAME 8 2903#define TAG_MOREDISPLAY 16 2904 2905#define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2) 2906 2907static char *unpack_nibble (char *buf, int *val); 2908 2909static char *unpack_byte (char *buf, int *value); 2910 2911static char *pack_int (char *buf, int value); 2912 2913static char *unpack_int (char *buf, int *value); 2914 2915static char *unpack_string (char *src, char *dest, int length); 2916 2917static char *pack_threadid (char *pkt, threadref *id); 2918 2919static char *unpack_threadid (char *inbuf, threadref *id); 2920 2921void int_to_threadref (threadref *id, int value); 2922 2923static int threadref_to_int (threadref *ref); 2924 2925static void copy_threadref (threadref *dest, threadref *src); 2926 2927static int threadmatch (threadref *dest, threadref *src); 2928 2929static char *pack_threadinfo_request (char *pkt, int mode, 2930 threadref *id); 2931 2932static char *pack_threadlist_request (char *pkt, int startflag, 2933 int threadcount, 2934 threadref *nextthread); 2935 2936static int remote_newthread_step (threadref *ref, void *context); 2937 2938 2939/* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the 2940 buffer we're allowed to write to. Returns 2941 BUF+CHARACTERS_WRITTEN. */ 2942 2943char * 2944remote_target::write_ptid (char *buf, const char *endbuf, ptid_t ptid) 2945{ 2946 int pid, tid; 2947 struct remote_state *rs = get_remote_state (); 2948 2949 if (remote_multi_process_p (rs)) 2950 { 2951 pid = ptid.pid (); 2952 if (pid < 0) 2953 buf += xsnprintf (buf, endbuf - buf, "p-%x.", -pid); 2954 else 2955 buf += xsnprintf (buf, endbuf - buf, "p%x.", pid); 2956 } 2957 tid = ptid.lwp (); 2958 if (tid < 0) 2959 buf += xsnprintf (buf, endbuf - buf, "-%x", -tid); 2960 else 2961 buf += xsnprintf (buf, endbuf - buf, "%x", tid); 2962 2963 return buf; 2964} 2965 2966/* Extract a PTID from BUF. If non-null, OBUF is set to one past the 2967 last parsed char. Returns null_ptid if no thread id is found, and 2968 throws an error if the thread id has an invalid format. */ 2969 2970static ptid_t 2971read_ptid (const char *buf, const char **obuf) 2972{ 2973 const char *p = buf; 2974 const char *pp; 2975 ULONGEST pid = 0, tid = 0; 2976 2977 if (*p == 'p') 2978 { 2979 /* Multi-process ptid. */ 2980 pp = unpack_varlen_hex (p + 1, &pid); 2981 if (*pp != '.') 2982 error (_("invalid remote ptid: %s"), p); 2983 2984 p = pp; 2985 pp = unpack_varlen_hex (p + 1, &tid); 2986 if (obuf) 2987 *obuf = pp; 2988 return ptid_t (pid, tid, 0); 2989 } 2990 2991 /* No multi-process. Just a tid. */ 2992 pp = unpack_varlen_hex (p, &tid); 2993 2994 /* Return null_ptid when no thread id is found. */ 2995 if (p == pp) 2996 { 2997 if (obuf) 2998 *obuf = pp; 2999 return null_ptid; 3000 } 3001 3002 /* Since the stub is not sending a process id, then default to 3003 what's in inferior_ptid, unless it's null at this point. If so, 3004 then since there's no way to know the pid of the reported 3005 threads, use the magic number. */ 3006 if (inferior_ptid == null_ptid) 3007 pid = magic_null_ptid.pid (); 3008 else 3009 pid = inferior_ptid.pid (); 3010 3011 if (obuf) 3012 *obuf = pp; 3013 return ptid_t (pid, tid, 0); 3014} 3015 3016static int 3017stubhex (int ch) 3018{ 3019 if (ch >= 'a' && ch <= 'f') 3020 return ch - 'a' + 10; 3021 if (ch >= '0' && ch <= '9') 3022 return ch - '0'; 3023 if (ch >= 'A' && ch <= 'F') 3024 return ch - 'A' + 10; 3025 return -1; 3026} 3027 3028static int 3029stub_unpack_int (char *buff, int fieldlength) 3030{ 3031 int nibble; 3032 int retval = 0; 3033 3034 while (fieldlength) 3035 { 3036 nibble = stubhex (*buff++); 3037 retval |= nibble; 3038 fieldlength--; 3039 if (fieldlength) 3040 retval = retval << 4; 3041 } 3042 return retval; 3043} 3044 3045static char * 3046unpack_nibble (char *buf, int *val) 3047{ 3048 *val = fromhex (*buf++); 3049 return buf; 3050} 3051 3052static char * 3053unpack_byte (char *buf, int *value) 3054{ 3055 *value = stub_unpack_int (buf, 2); 3056 return buf + 2; 3057} 3058 3059static char * 3060pack_int (char *buf, int value) 3061{ 3062 buf = pack_hex_byte (buf, (value >> 24) & 0xff); 3063 buf = pack_hex_byte (buf, (value >> 16) & 0xff); 3064 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff); 3065 buf = pack_hex_byte (buf, (value & 0xff)); 3066 return buf; 3067} 3068 3069static char * 3070unpack_int (char *buf, int *value) 3071{ 3072 *value = stub_unpack_int (buf, 8); 3073 return buf + 8; 3074} 3075 3076#if 0 /* Currently unused, uncomment when needed. */ 3077static char *pack_string (char *pkt, char *string); 3078 3079static char * 3080pack_string (char *pkt, char *string) 3081{ 3082 char ch; 3083 int len; 3084 3085 len = strlen (string); 3086 if (len > 200) 3087 len = 200; /* Bigger than most GDB packets, junk??? */ 3088 pkt = pack_hex_byte (pkt, len); 3089 while (len-- > 0) 3090 { 3091 ch = *string++; 3092 if ((ch == '\0') || (ch == '#')) 3093 ch = '*'; /* Protect encapsulation. */ 3094 *pkt++ = ch; 3095 } 3096 return pkt; 3097} 3098#endif /* 0 (unused) */ 3099 3100static char * 3101unpack_string (char *src, char *dest, int length) 3102{ 3103 while (length--) 3104 *dest++ = *src++; 3105 *dest = '\0'; 3106 return src; 3107} 3108 3109static char * 3110pack_threadid (char *pkt, threadref *id) 3111{ 3112 char *limit; 3113 unsigned char *altid; 3114 3115 altid = (unsigned char *) id; 3116 limit = pkt + BUF_THREAD_ID_SIZE; 3117 while (pkt < limit) 3118 pkt = pack_hex_byte (pkt, *altid++); 3119 return pkt; 3120} 3121 3122 3123static char * 3124unpack_threadid (char *inbuf, threadref *id) 3125{ 3126 char *altref; 3127 char *limit = inbuf + BUF_THREAD_ID_SIZE; 3128 int x, y; 3129 3130 altref = (char *) id; 3131 3132 while (inbuf < limit) 3133 { 3134 x = stubhex (*inbuf++); 3135 y = stubhex (*inbuf++); 3136 *altref++ = (x << 4) | y; 3137 } 3138 return inbuf; 3139} 3140 3141/* Externally, threadrefs are 64 bits but internally, they are still 3142 ints. This is due to a mismatch of specifications. We would like 3143 to use 64bit thread references internally. This is an adapter 3144 function. */ 3145 3146void 3147int_to_threadref (threadref *id, int value) 3148{ 3149 unsigned char *scan; 3150 3151 scan = (unsigned char *) id; 3152 { 3153 int i = 4; 3154 while (i--) 3155 *scan++ = 0; 3156 } 3157 *scan++ = (value >> 24) & 0xff; 3158 *scan++ = (value >> 16) & 0xff; 3159 *scan++ = (value >> 8) & 0xff; 3160 *scan++ = (value & 0xff); 3161} 3162 3163static int 3164threadref_to_int (threadref *ref) 3165{ 3166 int i, value = 0; 3167 unsigned char *scan; 3168 3169 scan = *ref; 3170 scan += 4; 3171 i = 4; 3172 while (i-- > 0) 3173 value = (value << 8) | ((*scan++) & 0xff); 3174 return value; 3175} 3176 3177static void 3178copy_threadref (threadref *dest, threadref *src) 3179{ 3180 int i; 3181 unsigned char *csrc, *cdest; 3182 3183 csrc = (unsigned char *) src; 3184 cdest = (unsigned char *) dest; 3185 i = 8; 3186 while (i--) 3187 *cdest++ = *csrc++; 3188} 3189 3190static int 3191threadmatch (threadref *dest, threadref *src) 3192{ 3193 /* Things are broken right now, so just assume we got a match. */ 3194#if 0 3195 unsigned char *srcp, *destp; 3196 int i, result; 3197 srcp = (char *) src; 3198 destp = (char *) dest; 3199 3200 result = 1; 3201 while (i-- > 0) 3202 result &= (*srcp++ == *destp++) ? 1 : 0; 3203 return result; 3204#endif 3205 return 1; 3206} 3207 3208/* 3209 threadid:1, # always request threadid 3210 context_exists:2, 3211 display:4, 3212 unique_name:8, 3213 more_display:16 3214 */ 3215 3216/* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */ 3217 3218static char * 3219pack_threadinfo_request (char *pkt, int mode, threadref *id) 3220{ 3221 *pkt++ = 'q'; /* Info Query */ 3222 *pkt++ = 'P'; /* process or thread info */ 3223 pkt = pack_int (pkt, mode); /* mode */ 3224 pkt = pack_threadid (pkt, id); /* threadid */ 3225 *pkt = '\0'; /* terminate */ 3226 return pkt; 3227} 3228 3229/* These values tag the fields in a thread info response packet. */ 3230/* Tagging the fields allows us to request specific fields and to 3231 add more fields as time goes by. */ 3232 3233#define TAG_THREADID 1 /* Echo the thread identifier. */ 3234#define TAG_EXISTS 2 /* Is this process defined enough to 3235 fetch registers and its stack? */ 3236#define TAG_DISPLAY 4 /* A short thing maybe to put on a window */ 3237#define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */ 3238#define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about 3239 the process. */ 3240 3241int 3242remote_target::remote_unpack_thread_info_response (char *pkt, 3243 threadref *expectedref, 3244 gdb_ext_thread_info *info) 3245{ 3246 struct remote_state *rs = get_remote_state (); 3247 int mask, length; 3248 int tag; 3249 threadref ref; 3250 char *limit = pkt + rs->buf.size (); /* Plausible parsing limit. */ 3251 int retval = 1; 3252 3253 /* info->threadid = 0; FIXME: implement zero_threadref. */ 3254 info->active = 0; 3255 info->display[0] = '\0'; 3256 info->shortname[0] = '\0'; 3257 info->more_display[0] = '\0'; 3258 3259 /* Assume the characters indicating the packet type have been 3260 stripped. */ 3261 pkt = unpack_int (pkt, &mask); /* arg mask */ 3262 pkt = unpack_threadid (pkt, &ref); 3263 3264 if (mask == 0) 3265 warning (_("Incomplete response to threadinfo request.")); 3266 if (!threadmatch (&ref, expectedref)) 3267 { /* This is an answer to a different request. */ 3268 warning (_("ERROR RMT Thread info mismatch.")); 3269 return 0; 3270 } 3271 copy_threadref (&info->threadid, &ref); 3272 3273 /* Loop on tagged fields , try to bail if somthing goes wrong. */ 3274 3275 /* Packets are terminated with nulls. */ 3276 while ((pkt < limit) && mask && *pkt) 3277 { 3278 pkt = unpack_int (pkt, &tag); /* tag */ 3279 pkt = unpack_byte (pkt, &length); /* length */ 3280 if (!(tag & mask)) /* Tags out of synch with mask. */ 3281 { 3282 warning (_("ERROR RMT: threadinfo tag mismatch.")); 3283 retval = 0; 3284 break; 3285 } 3286 if (tag == TAG_THREADID) 3287 { 3288 if (length != 16) 3289 { 3290 warning (_("ERROR RMT: length of threadid is not 16.")); 3291 retval = 0; 3292 break; 3293 } 3294 pkt = unpack_threadid (pkt, &ref); 3295 mask = mask & ~TAG_THREADID; 3296 continue; 3297 } 3298 if (tag == TAG_EXISTS) 3299 { 3300 info->active = stub_unpack_int (pkt, length); 3301 pkt += length; 3302 mask = mask & ~(TAG_EXISTS); 3303 if (length > 8) 3304 { 3305 warning (_("ERROR RMT: 'exists' length too long.")); 3306 retval = 0; 3307 break; 3308 } 3309 continue; 3310 } 3311 if (tag == TAG_THREADNAME) 3312 { 3313 pkt = unpack_string (pkt, &info->shortname[0], length); 3314 mask = mask & ~TAG_THREADNAME; 3315 continue; 3316 } 3317 if (tag == TAG_DISPLAY) 3318 { 3319 pkt = unpack_string (pkt, &info->display[0], length); 3320 mask = mask & ~TAG_DISPLAY; 3321 continue; 3322 } 3323 if (tag == TAG_MOREDISPLAY) 3324 { 3325 pkt = unpack_string (pkt, &info->more_display[0], length); 3326 mask = mask & ~TAG_MOREDISPLAY; 3327 continue; 3328 } 3329 warning (_("ERROR RMT: unknown thread info tag.")); 3330 break; /* Not a tag we know about. */ 3331 } 3332 return retval; 3333} 3334 3335int 3336remote_target::remote_get_threadinfo (threadref *threadid, 3337 int fieldset, 3338 gdb_ext_thread_info *info) 3339{ 3340 struct remote_state *rs = get_remote_state (); 3341 int result; 3342 3343 pack_threadinfo_request (rs->buf.data (), fieldset, threadid); 3344 putpkt (rs->buf); 3345 getpkt (&rs->buf, 0); 3346 3347 if (rs->buf[0] == '\0') 3348 return 0; 3349 3350 result = remote_unpack_thread_info_response (&rs->buf[2], 3351 threadid, info); 3352 return result; 3353} 3354 3355/* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */ 3356 3357static char * 3358pack_threadlist_request (char *pkt, int startflag, int threadcount, 3359 threadref *nextthread) 3360{ 3361 *pkt++ = 'q'; /* info query packet */ 3362 *pkt++ = 'L'; /* Process LIST or threadLIST request */ 3363 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */ 3364 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */ 3365 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */ 3366 *pkt = '\0'; 3367 return pkt; 3368} 3369 3370/* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */ 3371 3372int 3373remote_target::parse_threadlist_response (char *pkt, int result_limit, 3374 threadref *original_echo, 3375 threadref *resultlist, 3376 int *doneflag) 3377{ 3378 struct remote_state *rs = get_remote_state (); 3379 char *limit; 3380 int count, resultcount, done; 3381 3382 resultcount = 0; 3383 /* Assume the 'q' and 'M chars have been stripped. */ 3384 limit = pkt + (rs->buf.size () - BUF_THREAD_ID_SIZE); 3385 /* done parse past here */ 3386 pkt = unpack_byte (pkt, &count); /* count field */ 3387 pkt = unpack_nibble (pkt, &done); 3388 /* The first threadid is the argument threadid. */ 3389 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */ 3390 while ((count-- > 0) && (pkt < limit)) 3391 { 3392 pkt = unpack_threadid (pkt, resultlist++); 3393 if (resultcount++ >= result_limit) 3394 break; 3395 } 3396 if (doneflag) 3397 *doneflag = done; 3398 return resultcount; 3399} 3400 3401/* Fetch the next batch of threads from the remote. Returns -1 if the 3402 qL packet is not supported, 0 on error and 1 on success. */ 3403 3404int 3405remote_target::remote_get_threadlist (int startflag, threadref *nextthread, 3406 int result_limit, int *done, int *result_count, 3407 threadref *threadlist) 3408{ 3409 struct remote_state *rs = get_remote_state (); 3410 int result = 1; 3411 3412 /* Trancate result limit to be smaller than the packet size. */ 3413 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) 3414 >= get_remote_packet_size ()) 3415 result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2; 3416 3417 pack_threadlist_request (rs->buf.data (), startflag, result_limit, 3418 nextthread); 3419 putpkt (rs->buf); 3420 getpkt (&rs->buf, 0); 3421 if (rs->buf[0] == '\0') 3422 { 3423 /* Packet not supported. */ 3424 return -1; 3425 } 3426 3427 *result_count = 3428 parse_threadlist_response (&rs->buf[2], result_limit, 3429 &rs->echo_nextthread, threadlist, done); 3430 3431 if (!threadmatch (&rs->echo_nextthread, nextthread)) 3432 { 3433 /* FIXME: This is a good reason to drop the packet. */ 3434 /* Possably, there is a duplicate response. */ 3435 /* Possabilities : 3436 retransmit immediatly - race conditions 3437 retransmit after timeout - yes 3438 exit 3439 wait for packet, then exit 3440 */ 3441 warning (_("HMM: threadlist did not echo arg thread, dropping it.")); 3442 return 0; /* I choose simply exiting. */ 3443 } 3444 if (*result_count <= 0) 3445 { 3446 if (*done != 1) 3447 { 3448 warning (_("RMT ERROR : failed to get remote thread list.")); 3449 result = 0; 3450 } 3451 return result; /* break; */ 3452 } 3453 if (*result_count > result_limit) 3454 { 3455 *result_count = 0; 3456 warning (_("RMT ERROR: threadlist response longer than requested.")); 3457 return 0; 3458 } 3459 return result; 3460} 3461 3462/* Fetch the list of remote threads, with the qL packet, and call 3463 STEPFUNCTION for each thread found. Stops iterating and returns 1 3464 if STEPFUNCTION returns true. Stops iterating and returns 0 if the 3465 STEPFUNCTION returns false. If the packet is not supported, 3466 returns -1. */ 3467 3468int 3469remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction, 3470 void *context, int looplimit) 3471{ 3472 struct remote_state *rs = get_remote_state (); 3473 int done, i, result_count; 3474 int startflag = 1; 3475 int result = 1; 3476 int loopcount = 0; 3477 3478 done = 0; 3479 while (!done) 3480 { 3481 if (loopcount++ > looplimit) 3482 { 3483 result = 0; 3484 warning (_("Remote fetch threadlist -infinite loop-.")); 3485 break; 3486 } 3487 result = remote_get_threadlist (startflag, &rs->nextthread, 3488 MAXTHREADLISTRESULTS, 3489 &done, &result_count, 3490 rs->resultthreadlist); 3491 if (result <= 0) 3492 break; 3493 /* Clear for later iterations. */ 3494 startflag = 0; 3495 /* Setup to resume next batch of thread references, set nextthread. */ 3496 if (result_count >= 1) 3497 copy_threadref (&rs->nextthread, 3498 &rs->resultthreadlist[result_count - 1]); 3499 i = 0; 3500 while (result_count--) 3501 { 3502 if (!(*stepfunction) (&rs->resultthreadlist[i++], context)) 3503 { 3504 result = 0; 3505 break; 3506 } 3507 } 3508 } 3509 return result; 3510} 3511 3512/* A thread found on the remote target. */ 3513 3514struct thread_item 3515{ 3516 explicit thread_item (ptid_t ptid_) 3517 : ptid (ptid_) 3518 {} 3519 3520 thread_item (thread_item &&other) = default; 3521 thread_item &operator= (thread_item &&other) = default; 3522 3523 DISABLE_COPY_AND_ASSIGN (thread_item); 3524 3525 /* The thread's PTID. */ 3526 ptid_t ptid; 3527 3528 /* The thread's extra info. */ 3529 std::string extra; 3530 3531 /* The thread's name. */ 3532 std::string name; 3533 3534 /* The core the thread was running on. -1 if not known. */ 3535 int core = -1; 3536 3537 /* The thread handle associated with the thread. */ 3538 gdb::byte_vector thread_handle; 3539}; 3540 3541/* Context passed around to the various methods listing remote 3542 threads. As new threads are found, they're added to the ITEMS 3543 vector. */ 3544 3545struct threads_listing_context 3546{ 3547 /* Return true if this object contains an entry for a thread with ptid 3548 PTID. */ 3549 3550 bool contains_thread (ptid_t ptid) const 3551 { 3552 auto match_ptid = [&] (const thread_item &item) 3553 { 3554 return item.ptid == ptid; 3555 }; 3556 3557 auto it = std::find_if (this->items.begin (), 3558 this->items.end (), 3559 match_ptid); 3560 3561 return it != this->items.end (); 3562 } 3563 3564 /* Remove the thread with ptid PTID. */ 3565 3566 void remove_thread (ptid_t ptid) 3567 { 3568 auto match_ptid = [&] (const thread_item &item) 3569 { 3570 return item.ptid == ptid; 3571 }; 3572 3573 auto it = std::remove_if (this->items.begin (), 3574 this->items.end (), 3575 match_ptid); 3576 3577 if (it != this->items.end ()) 3578 this->items.erase (it); 3579 } 3580 3581 /* The threads found on the remote target. */ 3582 std::vector<thread_item> items; 3583}; 3584 3585static int 3586remote_newthread_step (threadref *ref, void *data) 3587{ 3588 struct threads_listing_context *context 3589 = (struct threads_listing_context *) data; 3590 int pid = inferior_ptid.pid (); 3591 int lwp = threadref_to_int (ref); 3592 ptid_t ptid (pid, lwp); 3593 3594 context->items.emplace_back (ptid); 3595 3596 return 1; /* continue iterator */ 3597} 3598 3599#define CRAZY_MAX_THREADS 1000 3600 3601ptid_t 3602remote_target::remote_current_thread (ptid_t oldpid) 3603{ 3604 struct remote_state *rs = get_remote_state (); 3605 3606 putpkt ("qC"); 3607 getpkt (&rs->buf, 0); 3608 if (rs->buf[0] == 'Q' && rs->buf[1] == 'C') 3609 { 3610 const char *obuf; 3611 ptid_t result; 3612 3613 result = read_ptid (&rs->buf[2], &obuf); 3614 if (*obuf != '\0' && remote_debug) 3615 fprintf_unfiltered (gdb_stdlog, 3616 "warning: garbage in qC reply\n"); 3617 3618 return result; 3619 } 3620 else 3621 return oldpid; 3622} 3623 3624/* List remote threads using the deprecated qL packet. */ 3625 3626int 3627remote_target::remote_get_threads_with_ql (threads_listing_context *context) 3628{ 3629 if (remote_threadlist_iterator (remote_newthread_step, context, 3630 CRAZY_MAX_THREADS) >= 0) 3631 return 1; 3632 3633 return 0; 3634} 3635 3636#if defined(HAVE_LIBEXPAT) 3637 3638static void 3639start_thread (struct gdb_xml_parser *parser, 3640 const struct gdb_xml_element *element, 3641 void *user_data, 3642 std::vector<gdb_xml_value> &attributes) 3643{ 3644 struct threads_listing_context *data 3645 = (struct threads_listing_context *) user_data; 3646 struct gdb_xml_value *attr; 3647 3648 char *id = (char *) xml_find_attribute (attributes, "id")->value.get (); 3649 ptid_t ptid = read_ptid (id, NULL); 3650 3651 data->items.emplace_back (ptid); 3652 thread_item &item = data->items.back (); 3653 3654 attr = xml_find_attribute (attributes, "core"); 3655 if (attr != NULL) 3656 item.core = *(ULONGEST *) attr->value.get (); 3657 3658 attr = xml_find_attribute (attributes, "name"); 3659 if (attr != NULL) 3660 item.name = (const char *) attr->value.get (); 3661 3662 attr = xml_find_attribute (attributes, "handle"); 3663 if (attr != NULL) 3664 item.thread_handle = hex2bin ((const char *) attr->value.get ()); 3665} 3666 3667static void 3668end_thread (struct gdb_xml_parser *parser, 3669 const struct gdb_xml_element *element, 3670 void *user_data, const char *body_text) 3671{ 3672 struct threads_listing_context *data 3673 = (struct threads_listing_context *) user_data; 3674 3675 if (body_text != NULL && *body_text != '\0') 3676 data->items.back ().extra = body_text; 3677} 3678 3679const struct gdb_xml_attribute thread_attributes[] = { 3680 { "id", GDB_XML_AF_NONE, NULL, NULL }, 3681 { "core", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL }, 3682 { "name", GDB_XML_AF_OPTIONAL, NULL, NULL }, 3683 { "handle", GDB_XML_AF_OPTIONAL, NULL, NULL }, 3684 { NULL, GDB_XML_AF_NONE, NULL, NULL } 3685}; 3686 3687const struct gdb_xml_element thread_children[] = { 3688 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } 3689}; 3690 3691const struct gdb_xml_element threads_children[] = { 3692 { "thread", thread_attributes, thread_children, 3693 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL, 3694 start_thread, end_thread }, 3695 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } 3696}; 3697 3698const struct gdb_xml_element threads_elements[] = { 3699 { "threads", NULL, threads_children, 3700 GDB_XML_EF_NONE, NULL, NULL }, 3701 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } 3702}; 3703 3704#endif 3705 3706/* List remote threads using qXfer:threads:read. */ 3707 3708int 3709remote_target::remote_get_threads_with_qxfer (threads_listing_context *context) 3710{ 3711#if defined(HAVE_LIBEXPAT) 3712 if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE) 3713 { 3714 gdb::optional<gdb::char_vector> xml 3715 = target_read_stralloc (this, TARGET_OBJECT_THREADS, NULL); 3716 3717 if (xml && (*xml)[0] != '\0') 3718 { 3719 gdb_xml_parse_quick (_("threads"), "threads.dtd", 3720 threads_elements, xml->data (), context); 3721 } 3722 3723 return 1; 3724 } 3725#endif 3726 3727 return 0; 3728} 3729 3730/* List remote threads using qfThreadInfo/qsThreadInfo. */ 3731 3732int 3733remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context *context) 3734{ 3735 struct remote_state *rs = get_remote_state (); 3736 3737 if (rs->use_threadinfo_query) 3738 { 3739 const char *bufp; 3740 3741 putpkt ("qfThreadInfo"); 3742 getpkt (&rs->buf, 0); 3743 bufp = rs->buf.data (); 3744 if (bufp[0] != '\0') /* q packet recognized */ 3745 { 3746 while (*bufp++ == 'm') /* reply contains one or more TID */ 3747 { 3748 do 3749 { 3750 ptid_t ptid = read_ptid (bufp, &bufp); 3751 context->items.emplace_back (ptid); 3752 } 3753 while (*bufp++ == ','); /* comma-separated list */ 3754 putpkt ("qsThreadInfo"); 3755 getpkt (&rs->buf, 0); 3756 bufp = rs->buf.data (); 3757 } 3758 return 1; 3759 } 3760 else 3761 { 3762 /* Packet not recognized. */ 3763 rs->use_threadinfo_query = 0; 3764 } 3765 } 3766 3767 return 0; 3768} 3769 3770/* Implement the to_update_thread_list function for the remote 3771 targets. */ 3772 3773void 3774remote_target::update_thread_list () 3775{ 3776 struct threads_listing_context context; 3777 int got_list = 0; 3778 3779 /* We have a few different mechanisms to fetch the thread list. Try 3780 them all, starting with the most preferred one first, falling 3781 back to older methods. */ 3782 if (remote_get_threads_with_qxfer (&context) 3783 || remote_get_threads_with_qthreadinfo (&context) 3784 || remote_get_threads_with_ql (&context)) 3785 { 3786 got_list = 1; 3787 3788 if (context.items.empty () 3789 && remote_thread_always_alive (inferior_ptid)) 3790 { 3791 /* Some targets don't really support threads, but still 3792 reply an (empty) thread list in response to the thread 3793 listing packets, instead of replying "packet not 3794 supported". Exit early so we don't delete the main 3795 thread. */ 3796 return; 3797 } 3798 3799 /* CONTEXT now holds the current thread list on the remote 3800 target end. Delete GDB-side threads no longer found on the 3801 target. */ 3802 for (thread_info *tp : all_threads_safe ()) 3803 { 3804 if (!context.contains_thread (tp->ptid)) 3805 { 3806 /* Not found. */ 3807 delete_thread (tp); 3808 } 3809 } 3810 3811 /* Remove any unreported fork child threads from CONTEXT so 3812 that we don't interfere with follow fork, which is where 3813 creation of such threads is handled. */ 3814 remove_new_fork_children (&context); 3815 3816 /* And now add threads we don't know about yet to our list. */ 3817 for (thread_item &item : context.items) 3818 { 3819 if (item.ptid != null_ptid) 3820 { 3821 /* In non-stop mode, we assume new found threads are 3822 executing until proven otherwise with a stop reply. 3823 In all-stop, we can only get here if all threads are 3824 stopped. */ 3825 int executing = target_is_non_stop_p () ? 1 : 0; 3826 3827 remote_notice_new_inferior (item.ptid, executing); 3828 3829 thread_info *tp = find_thread_ptid (item.ptid); 3830 remote_thread_info *info = get_remote_thread_info (tp); 3831 info->core = item.core; 3832 info->extra = std::move (item.extra); 3833 info->name = std::move (item.name); 3834 info->thread_handle = std::move (item.thread_handle); 3835 } 3836 } 3837 } 3838 3839 if (!got_list) 3840 { 3841 /* If no thread listing method is supported, then query whether 3842 each known thread is alive, one by one, with the T packet. 3843 If the target doesn't support threads at all, then this is a 3844 no-op. See remote_thread_alive. */ 3845 prune_threads (); 3846 } 3847} 3848 3849/* 3850 * Collect a descriptive string about the given thread. 3851 * The target may say anything it wants to about the thread 3852 * (typically info about its blocked / runnable state, name, etc.). 3853 * This string will appear in the info threads display. 3854 * 3855 * Optional: targets are not required to implement this function. 3856 */ 3857 3858const char * 3859remote_target::extra_thread_info (thread_info *tp) 3860{ 3861 struct remote_state *rs = get_remote_state (); 3862 int set; 3863 threadref id; 3864 struct gdb_ext_thread_info threadinfo; 3865 3866 if (rs->remote_desc == 0) /* paranoia */ 3867 internal_error (__FILE__, __LINE__, 3868 _("remote_threads_extra_info")); 3869 3870 if (tp->ptid == magic_null_ptid 3871 || (tp->ptid.pid () != 0 && tp->ptid.lwp () == 0)) 3872 /* This is the main thread which was added by GDB. The remote 3873 server doesn't know about it. */ 3874 return NULL; 3875 3876 std::string &extra = get_remote_thread_info (tp)->extra; 3877 3878 /* If already have cached info, use it. */ 3879 if (!extra.empty ()) 3880 return extra.c_str (); 3881 3882 if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE) 3883 { 3884 /* If we're using qXfer:threads:read, then the extra info is 3885 included in the XML. So if we didn't have anything cached, 3886 it's because there's really no extra info. */ 3887 return NULL; 3888 } 3889 3890 if (rs->use_threadextra_query) 3891 { 3892 char *b = rs->buf.data (); 3893 char *endb = b + get_remote_packet_size (); 3894 3895 xsnprintf (b, endb - b, "qThreadExtraInfo,"); 3896 b += strlen (b); 3897 write_ptid (b, endb, tp->ptid); 3898 3899 putpkt (rs->buf); 3900 getpkt (&rs->buf, 0); 3901 if (rs->buf[0] != 0) 3902 { 3903 extra.resize (strlen (rs->buf.data ()) / 2); 3904 hex2bin (rs->buf.data (), (gdb_byte *) &extra[0], extra.size ()); 3905 return extra.c_str (); 3906 } 3907 } 3908 3909 /* If the above query fails, fall back to the old method. */ 3910 rs->use_threadextra_query = 0; 3911 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME 3912 | TAG_MOREDISPLAY | TAG_DISPLAY; 3913 int_to_threadref (&id, tp->ptid.lwp ()); 3914 if (remote_get_threadinfo (&id, set, &threadinfo)) 3915 if (threadinfo.active) 3916 { 3917 if (*threadinfo.shortname) 3918 string_appendf (extra, " Name: %s", threadinfo.shortname); 3919 if (*threadinfo.display) 3920 { 3921 if (!extra.empty ()) 3922 extra += ','; 3923 string_appendf (extra, " State: %s", threadinfo.display); 3924 } 3925 if (*threadinfo.more_display) 3926 { 3927 if (!extra.empty ()) 3928 extra += ','; 3929 string_appendf (extra, " Priority: %s", threadinfo.more_display); 3930 } 3931 return extra.c_str (); 3932 } 3933 return NULL; 3934} 3935 3936 3937bool 3938remote_target::static_tracepoint_marker_at (CORE_ADDR addr, 3939 struct static_tracepoint_marker *marker) 3940{ 3941 struct remote_state *rs = get_remote_state (); 3942 char *p = rs->buf.data (); 3943 3944 xsnprintf (p, get_remote_packet_size (), "qTSTMat:"); 3945 p += strlen (p); 3946 p += hexnumstr (p, addr); 3947 putpkt (rs->buf); 3948 getpkt (&rs->buf, 0); 3949 p = rs->buf.data (); 3950 3951 if (*p == 'E') 3952 error (_("Remote failure reply: %s"), p); 3953 3954 if (*p++ == 'm') 3955 { 3956 parse_static_tracepoint_marker_definition (p, NULL, marker); 3957 return true; 3958 } 3959 3960 return false; 3961} 3962 3963std::vector<static_tracepoint_marker> 3964remote_target::static_tracepoint_markers_by_strid (const char *strid) 3965{ 3966 struct remote_state *rs = get_remote_state (); 3967 std::vector<static_tracepoint_marker> markers; 3968 const char *p; 3969 static_tracepoint_marker marker; 3970 3971 /* Ask for a first packet of static tracepoint marker 3972 definition. */ 3973 putpkt ("qTfSTM"); 3974 getpkt (&rs->buf, 0); 3975 p = rs->buf.data (); 3976 if (*p == 'E') 3977 error (_("Remote failure reply: %s"), p); 3978 3979 while (*p++ == 'm') 3980 { 3981 do 3982 { 3983 parse_static_tracepoint_marker_definition (p, &p, &marker); 3984 3985 if (strid == NULL || marker.str_id == strid) 3986 markers.push_back (std::move (marker)); 3987 } 3988 while (*p++ == ','); /* comma-separated list */ 3989 /* Ask for another packet of static tracepoint definition. */ 3990 putpkt ("qTsSTM"); 3991 getpkt (&rs->buf, 0); 3992 p = rs->buf.data (); 3993 } 3994 3995 return markers; 3996} 3997 3998 3999/* Implement the to_get_ada_task_ptid function for the remote targets. */ 4000 4001ptid_t 4002remote_target::get_ada_task_ptid (long lwp, long thread) 4003{ 4004 return ptid_t (inferior_ptid.pid (), lwp, 0); 4005} 4006 4007 4008/* Restart the remote side; this is an extended protocol operation. */ 4009 4010void 4011remote_target::extended_remote_restart () 4012{ 4013 struct remote_state *rs = get_remote_state (); 4014 4015 /* Send the restart command; for reasons I don't understand the 4016 remote side really expects a number after the "R". */ 4017 xsnprintf (rs->buf.data (), get_remote_packet_size (), "R%x", 0); 4018 putpkt (rs->buf); 4019 4020 remote_fileio_reset (); 4021} 4022 4023/* Clean up connection to a remote debugger. */ 4024 4025void 4026remote_target::close () 4027{ 4028 /* Make sure we leave stdin registered in the event loop. */ 4029 terminal_ours (); 4030 4031 /* We don't have a connection to the remote stub anymore. Get rid 4032 of all the inferiors and their threads we were controlling. 4033 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame 4034 will be unable to find the thread corresponding to (pid, 0, 0). */ 4035 inferior_ptid = null_ptid; 4036 discard_all_inferiors (); 4037 4038 trace_reset_local_state (); 4039 4040 delete this; 4041} 4042 4043remote_target::~remote_target () 4044{ 4045 struct remote_state *rs = get_remote_state (); 4046 4047 /* Check for NULL because we may get here with a partially 4048 constructed target/connection. */ 4049 if (rs->remote_desc == nullptr) 4050 return; 4051 4052 serial_close (rs->remote_desc); 4053 4054 /* We are destroying the remote target, so we should discard 4055 everything of this target. */ 4056 discard_pending_stop_replies_in_queue (); 4057 4058 if (rs->remote_async_inferior_event_token) 4059 delete_async_event_handler (&rs->remote_async_inferior_event_token); 4060 4061 remote_notif_state_xfree (rs->notif_state); 4062} 4063 4064/* Query the remote side for the text, data and bss offsets. */ 4065 4066void 4067remote_target::get_offsets () 4068{ 4069 struct remote_state *rs = get_remote_state (); 4070 char *buf; 4071 char *ptr; 4072 int lose, num_segments = 0, do_sections, do_segments; 4073 CORE_ADDR text_addr, data_addr, bss_addr, segments[2]; 4074 struct section_offsets *offs; 4075 struct symfile_segment_data *data; 4076 4077 if (symfile_objfile == NULL) 4078 return; 4079 4080 putpkt ("qOffsets"); 4081 getpkt (&rs->buf, 0); 4082 buf = rs->buf.data (); 4083 4084 if (buf[0] == '\000') 4085 return; /* Return silently. Stub doesn't support 4086 this command. */ 4087 if (buf[0] == 'E') 4088 { 4089 warning (_("Remote failure reply: %s"), buf); 4090 return; 4091 } 4092 4093 /* Pick up each field in turn. This used to be done with scanf, but 4094 scanf will make trouble if CORE_ADDR size doesn't match 4095 conversion directives correctly. The following code will work 4096 with any size of CORE_ADDR. */ 4097 text_addr = data_addr = bss_addr = 0; 4098 ptr = buf; 4099 lose = 0; 4100 4101 if (startswith (ptr, "Text=")) 4102 { 4103 ptr += 5; 4104 /* Don't use strtol, could lose on big values. */ 4105 while (*ptr && *ptr != ';') 4106 text_addr = (text_addr << 4) + fromhex (*ptr++); 4107 4108 if (startswith (ptr, ";Data=")) 4109 { 4110 ptr += 6; 4111 while (*ptr && *ptr != ';') 4112 data_addr = (data_addr << 4) + fromhex (*ptr++); 4113 } 4114 else 4115 lose = 1; 4116 4117 if (!lose && startswith (ptr, ";Bss=")) 4118 { 4119 ptr += 5; 4120 while (*ptr && *ptr != ';') 4121 bss_addr = (bss_addr << 4) + fromhex (*ptr++); 4122 4123 if (bss_addr != data_addr) 4124 warning (_("Target reported unsupported offsets: %s"), buf); 4125 } 4126 else 4127 lose = 1; 4128 } 4129 else if (startswith (ptr, "TextSeg=")) 4130 { 4131 ptr += 8; 4132 /* Don't use strtol, could lose on big values. */ 4133 while (*ptr && *ptr != ';') 4134 text_addr = (text_addr << 4) + fromhex (*ptr++); 4135 num_segments = 1; 4136 4137 if (startswith (ptr, ";DataSeg=")) 4138 { 4139 ptr += 9; 4140 while (*ptr && *ptr != ';') 4141 data_addr = (data_addr << 4) + fromhex (*ptr++); 4142 num_segments++; 4143 } 4144 } 4145 else 4146 lose = 1; 4147 4148 if (lose) 4149 error (_("Malformed response to offset query, %s"), buf); 4150 else if (*ptr != '\0') 4151 warning (_("Target reported unsupported offsets: %s"), buf); 4152 4153 offs = ((struct section_offsets *) 4154 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections))); 4155 memcpy (offs, symfile_objfile->section_offsets, 4156 SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)); 4157 4158 data = get_symfile_segment_data (symfile_objfile->obfd); 4159 do_segments = (data != NULL); 4160 do_sections = num_segments == 0; 4161 4162 if (num_segments > 0) 4163 { 4164 segments[0] = text_addr; 4165 segments[1] = data_addr; 4166 } 4167 /* If we have two segments, we can still try to relocate everything 4168 by assuming that the .text and .data offsets apply to the whole 4169 text and data segments. Convert the offsets given in the packet 4170 to base addresses for symfile_map_offsets_to_segments. */ 4171 else if (data && data->num_segments == 2) 4172 { 4173 segments[0] = data->segment_bases[0] + text_addr; 4174 segments[1] = data->segment_bases[1] + data_addr; 4175 num_segments = 2; 4176 } 4177 /* If the object file has only one segment, assume that it is text 4178 rather than data; main programs with no writable data are rare, 4179 but programs with no code are useless. Of course the code might 4180 have ended up in the data segment... to detect that we would need 4181 the permissions here. */ 4182 else if (data && data->num_segments == 1) 4183 { 4184 segments[0] = data->segment_bases[0] + text_addr; 4185 num_segments = 1; 4186 } 4187 /* There's no way to relocate by segment. */ 4188 else 4189 do_segments = 0; 4190 4191 if (do_segments) 4192 { 4193 int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data, 4194 offs, num_segments, segments); 4195 4196 if (ret == 0 && !do_sections) 4197 error (_("Can not handle qOffsets TextSeg " 4198 "response with this symbol file")); 4199 4200 if (ret > 0) 4201 do_sections = 0; 4202 } 4203 4204 if (data) 4205 free_symfile_segment_data (data); 4206 4207 if (do_sections) 4208 { 4209 offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr; 4210 4211 /* This is a temporary kludge to force data and bss to use the 4212 same offsets because that's what nlmconv does now. The real 4213 solution requires changes to the stub and remote.c that I 4214 don't have time to do right now. */ 4215 4216 offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr; 4217 offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr; 4218 } 4219 4220 objfile_relocate (symfile_objfile, offs); 4221} 4222 4223/* Send interrupt_sequence to remote target. */ 4224 4225void 4226remote_target::send_interrupt_sequence () 4227{ 4228 struct remote_state *rs = get_remote_state (); 4229 4230 if (interrupt_sequence_mode == interrupt_sequence_control_c) 4231 remote_serial_write ("\x03", 1); 4232 else if (interrupt_sequence_mode == interrupt_sequence_break) 4233 serial_send_break (rs->remote_desc); 4234 else if (interrupt_sequence_mode == interrupt_sequence_break_g) 4235 { 4236 serial_send_break (rs->remote_desc); 4237 remote_serial_write ("g", 1); 4238 } 4239 else 4240 internal_error (__FILE__, __LINE__, 4241 _("Invalid value for interrupt_sequence_mode: %s."), 4242 interrupt_sequence_mode); 4243} 4244 4245 4246/* If STOP_REPLY is a T stop reply, look for the "thread" register, 4247 and extract the PTID. Returns NULL_PTID if not found. */ 4248 4249static ptid_t 4250stop_reply_extract_thread (char *stop_reply) 4251{ 4252 if (stop_reply[0] == 'T' && strlen (stop_reply) > 3) 4253 { 4254 const char *p; 4255 4256 /* Txx r:val ; r:val (...) */ 4257 p = &stop_reply[3]; 4258 4259 /* Look for "register" named "thread". */ 4260 while (*p != '\0') 4261 { 4262 const char *p1; 4263 4264 p1 = strchr (p, ':'); 4265 if (p1 == NULL) 4266 return null_ptid; 4267 4268 if (strncmp (p, "thread", p1 - p) == 0) 4269 return read_ptid (++p1, &p); 4270 4271 p1 = strchr (p, ';'); 4272 if (p1 == NULL) 4273 return null_ptid; 4274 p1++; 4275 4276 p = p1; 4277 } 4278 } 4279 4280 return null_ptid; 4281} 4282 4283/* Determine the remote side's current thread. If we have a stop 4284 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a 4285 "thread" register we can extract the current thread from. If not, 4286 ask the remote which is the current thread with qC. The former 4287 method avoids a roundtrip. */ 4288 4289ptid_t 4290remote_target::get_current_thread (char *wait_status) 4291{ 4292 ptid_t ptid = null_ptid; 4293 4294 /* Note we don't use remote_parse_stop_reply as that makes use of 4295 the target architecture, which we haven't yet fully determined at 4296 this point. */ 4297 if (wait_status != NULL) 4298 ptid = stop_reply_extract_thread (wait_status); 4299 if (ptid == null_ptid) 4300 ptid = remote_current_thread (inferior_ptid); 4301 4302 return ptid; 4303} 4304 4305/* Query the remote target for which is the current thread/process, 4306 add it to our tables, and update INFERIOR_PTID. The caller is 4307 responsible for setting the state such that the remote end is ready 4308 to return the current thread. 4309 4310 This function is called after handling the '?' or 'vRun' packets, 4311 whose response is a stop reply from which we can also try 4312 extracting the thread. If the target doesn't support the explicit 4313 qC query, we infer the current thread from that stop reply, passed 4314 in in WAIT_STATUS, which may be NULL. */ 4315 4316void 4317remote_target::add_current_inferior_and_thread (char *wait_status) 4318{ 4319 struct remote_state *rs = get_remote_state (); 4320 int fake_pid_p = 0; 4321 4322 inferior_ptid = null_ptid; 4323 4324 /* Now, if we have thread information, update inferior_ptid. */ 4325 ptid_t curr_ptid = get_current_thread (wait_status); 4326 4327 if (curr_ptid != null_ptid) 4328 { 4329 if (!remote_multi_process_p (rs)) 4330 fake_pid_p = 1; 4331 } 4332 else 4333 { 4334 /* Without this, some commands which require an active target 4335 (such as kill) won't work. This variable serves (at least) 4336 double duty as both the pid of the target process (if it has 4337 such), and as a flag indicating that a target is active. */ 4338 curr_ptid = magic_null_ptid; 4339 fake_pid_p = 1; 4340 } 4341 4342 remote_add_inferior (fake_pid_p, curr_ptid.pid (), -1, 1); 4343 4344 /* Add the main thread and switch to it. Don't try reading 4345 registers yet, since we haven't fetched the target description 4346 yet. */ 4347 thread_info *tp = add_thread_silent (curr_ptid); 4348 switch_to_thread_no_regs (tp); 4349} 4350 4351/* Print info about a thread that was found already stopped on 4352 connection. */ 4353 4354static void 4355print_one_stopped_thread (struct thread_info *thread) 4356{ 4357 struct target_waitstatus *ws = &thread->suspend.waitstatus; 4358 4359 switch_to_thread (thread); 4360 thread->suspend.stop_pc = get_frame_pc (get_current_frame ()); 4361 set_current_sal_from_frame (get_current_frame ()); 4362 4363 thread->suspend.waitstatus_pending_p = 0; 4364 4365 if (ws->kind == TARGET_WAITKIND_STOPPED) 4366 { 4367 enum gdb_signal sig = ws->value.sig; 4368 4369 if (signal_print_state (sig)) 4370 gdb::observers::signal_received.notify (sig); 4371 } 4372 gdb::observers::normal_stop.notify (NULL, 1); 4373} 4374 4375/* Process all initial stop replies the remote side sent in response 4376 to the ? packet. These indicate threads that were already stopped 4377 on initial connection. We mark these threads as stopped and print 4378 their current frame before giving the user the prompt. */ 4379 4380void 4381remote_target::process_initial_stop_replies (int from_tty) 4382{ 4383 int pending_stop_replies = stop_reply_queue_length (); 4384 struct thread_info *selected = NULL; 4385 struct thread_info *lowest_stopped = NULL; 4386 struct thread_info *first = NULL; 4387 4388 /* Consume the initial pending events. */ 4389 while (pending_stop_replies-- > 0) 4390 { 4391 ptid_t waiton_ptid = minus_one_ptid; 4392 ptid_t event_ptid; 4393 struct target_waitstatus ws; 4394 int ignore_event = 0; 4395 4396 memset (&ws, 0, sizeof (ws)); 4397 event_ptid = target_wait (waiton_ptid, &ws, TARGET_WNOHANG); 4398 if (remote_debug) 4399 print_target_wait_results (waiton_ptid, event_ptid, &ws); 4400 4401 switch (ws.kind) 4402 { 4403 case TARGET_WAITKIND_IGNORE: 4404 case TARGET_WAITKIND_NO_RESUMED: 4405 case TARGET_WAITKIND_SIGNALLED: 4406 case TARGET_WAITKIND_EXITED: 4407 /* We shouldn't see these, but if we do, just ignore. */ 4408 if (remote_debug) 4409 fprintf_unfiltered (gdb_stdlog, "remote: event ignored\n"); 4410 ignore_event = 1; 4411 break; 4412 4413 case TARGET_WAITKIND_EXECD: 4414 xfree (ws.value.execd_pathname); 4415 break; 4416 default: 4417 break; 4418 } 4419 4420 if (ignore_event) 4421 continue; 4422 4423 struct thread_info *evthread = find_thread_ptid (event_ptid); 4424 4425 if (ws.kind == TARGET_WAITKIND_STOPPED) 4426 { 4427 enum gdb_signal sig = ws.value.sig; 4428 4429 /* Stubs traditionally report SIGTRAP as initial signal, 4430 instead of signal 0. Suppress it. */ 4431 if (sig == GDB_SIGNAL_TRAP) 4432 sig = GDB_SIGNAL_0; 4433 evthread->suspend.stop_signal = sig; 4434 ws.value.sig = sig; 4435 } 4436 4437 evthread->suspend.waitstatus = ws; 4438 4439 if (ws.kind != TARGET_WAITKIND_STOPPED 4440 || ws.value.sig != GDB_SIGNAL_0) 4441 evthread->suspend.waitstatus_pending_p = 1; 4442 4443 set_executing (event_ptid, 0); 4444 set_running (event_ptid, 0); 4445 get_remote_thread_info (evthread)->vcont_resumed = 0; 4446 } 4447 4448 /* "Notice" the new inferiors before anything related to 4449 registers/memory. */ 4450 for (inferior *inf : all_non_exited_inferiors ()) 4451 { 4452 inf->needs_setup = 1; 4453 4454 if (non_stop) 4455 { 4456 thread_info *thread = any_live_thread_of_inferior (inf); 4457 notice_new_inferior (thread, thread->state == THREAD_RUNNING, 4458 from_tty); 4459 } 4460 } 4461 4462 /* If all-stop on top of non-stop, pause all threads. Note this 4463 records the threads' stop pc, so must be done after "noticing" 4464 the inferiors. */ 4465 if (!non_stop) 4466 { 4467 stop_all_threads (); 4468 4469 /* If all threads of an inferior were already stopped, we 4470 haven't setup the inferior yet. */ 4471 for (inferior *inf : all_non_exited_inferiors ()) 4472 { 4473 if (inf->needs_setup) 4474 { 4475 thread_info *thread = any_live_thread_of_inferior (inf); 4476 switch_to_thread_no_regs (thread); 4477 setup_inferior (0); 4478 } 4479 } 4480 } 4481 4482 /* Now go over all threads that are stopped, and print their current 4483 frame. If all-stop, then if there's a signalled thread, pick 4484 that as current. */ 4485 for (thread_info *thread : all_non_exited_threads ()) 4486 { 4487 if (first == NULL) 4488 first = thread; 4489 4490 if (!non_stop) 4491 thread->set_running (false); 4492 else if (thread->state != THREAD_STOPPED) 4493 continue; 4494 4495 if (selected == NULL 4496 && thread->suspend.waitstatus_pending_p) 4497 selected = thread; 4498 4499 if (lowest_stopped == NULL 4500 || thread->inf->num < lowest_stopped->inf->num 4501 || thread->per_inf_num < lowest_stopped->per_inf_num) 4502 lowest_stopped = thread; 4503 4504 if (non_stop) 4505 print_one_stopped_thread (thread); 4506 } 4507 4508 /* In all-stop, we only print the status of one thread, and leave 4509 others with their status pending. */ 4510 if (!non_stop) 4511 { 4512 thread_info *thread = selected; 4513 if (thread == NULL) 4514 thread = lowest_stopped; 4515 if (thread == NULL) 4516 thread = first; 4517 4518 print_one_stopped_thread (thread); 4519 } 4520 4521 /* For "info program". */ 4522 thread_info *thread = inferior_thread (); 4523 if (thread->state == THREAD_STOPPED) 4524 set_last_target_status (inferior_ptid, thread->suspend.waitstatus); 4525} 4526 4527/* Start the remote connection and sync state. */ 4528 4529void 4530remote_target::start_remote (int from_tty, int extended_p) 4531{ 4532 struct remote_state *rs = get_remote_state (); 4533 struct packet_config *noack_config; 4534 char *wait_status = NULL; 4535 4536 /* Signal other parts that we're going through the initial setup, 4537 and so things may not be stable yet. E.g., we don't try to 4538 install tracepoints until we've relocated symbols. Also, a 4539 Ctrl-C before we're connected and synced up can't interrupt the 4540 target. Instead, it offers to drop the (potentially wedged) 4541 connection. */ 4542 rs->starting_up = 1; 4543 4544 QUIT; 4545 4546 if (interrupt_on_connect) 4547 send_interrupt_sequence (); 4548 4549 /* Ack any packet which the remote side has already sent. */ 4550 remote_serial_write ("+", 1); 4551 4552 /* The first packet we send to the target is the optional "supported 4553 packets" request. If the target can answer this, it will tell us 4554 which later probes to skip. */ 4555 remote_query_supported (); 4556 4557 /* If the stub wants to get a QAllow, compose one and send it. */ 4558 if (packet_support (PACKET_QAllow) != PACKET_DISABLE) 4559 set_permissions (); 4560 4561 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any 4562 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB 4563 as a reply to known packet. For packet "vFile:setfs:" it is an 4564 invalid reply and GDB would return error in 4565 remote_hostio_set_filesystem, making remote files access impossible. 4566 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as 4567 other "vFile" packets get correctly detected even on gdbserver < 7.7. */ 4568 { 4569 const char v_mustreplyempty[] = "vMustReplyEmpty"; 4570 4571 putpkt (v_mustreplyempty); 4572 getpkt (&rs->buf, 0); 4573 if (strcmp (rs->buf.data (), "OK") == 0) 4574 remote_protocol_packets[PACKET_vFile_setfs].support = PACKET_DISABLE; 4575 else if (strcmp (rs->buf.data (), "") != 0) 4576 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty, 4577 rs->buf.data ()); 4578 } 4579 4580 /* Next, we possibly activate noack mode. 4581 4582 If the QStartNoAckMode packet configuration is set to AUTO, 4583 enable noack mode if the stub reported a wish for it with 4584 qSupported. 4585 4586 If set to TRUE, then enable noack mode even if the stub didn't 4587 report it in qSupported. If the stub doesn't reply OK, the 4588 session ends with an error. 4589 4590 If FALSE, then don't activate noack mode, regardless of what the 4591 stub claimed should be the default with qSupported. */ 4592 4593 noack_config = &remote_protocol_packets[PACKET_QStartNoAckMode]; 4594 if (packet_config_support (noack_config) != PACKET_DISABLE) 4595 { 4596 putpkt ("QStartNoAckMode"); 4597 getpkt (&rs->buf, 0); 4598 if (packet_ok (rs->buf, noack_config) == PACKET_OK) 4599 rs->noack_mode = 1; 4600 } 4601 4602 if (extended_p) 4603 { 4604 /* Tell the remote that we are using the extended protocol. */ 4605 putpkt ("!"); 4606 getpkt (&rs->buf, 0); 4607 } 4608 4609 /* Let the target know which signals it is allowed to pass down to 4610 the program. */ 4611 update_signals_program_target (); 4612 4613 /* Next, if the target can specify a description, read it. We do 4614 this before anything involving memory or registers. */ 4615 target_find_description (); 4616 4617 /* Next, now that we know something about the target, update the 4618 address spaces in the program spaces. */ 4619 update_address_spaces (); 4620 4621 /* On OSs where the list of libraries is global to all 4622 processes, we fetch them early. */ 4623 if (gdbarch_has_global_solist (target_gdbarch ())) 4624 solib_add (NULL, from_tty, auto_solib_add); 4625 4626 if (target_is_non_stop_p ()) 4627 { 4628 if (packet_support (PACKET_QNonStop) != PACKET_ENABLE) 4629 error (_("Non-stop mode requested, but remote " 4630 "does not support non-stop")); 4631 4632 putpkt ("QNonStop:1"); 4633 getpkt (&rs->buf, 0); 4634 4635 if (strcmp (rs->buf.data (), "OK") != 0) 4636 error (_("Remote refused setting non-stop mode with: %s"), 4637 rs->buf.data ()); 4638 4639 /* Find about threads and processes the stub is already 4640 controlling. We default to adding them in the running state. 4641 The '?' query below will then tell us about which threads are 4642 stopped. */ 4643 this->update_thread_list (); 4644 } 4645 else if (packet_support (PACKET_QNonStop) == PACKET_ENABLE) 4646 { 4647 /* Don't assume that the stub can operate in all-stop mode. 4648 Request it explicitly. */ 4649 putpkt ("QNonStop:0"); 4650 getpkt (&rs->buf, 0); 4651 4652 if (strcmp (rs->buf.data (), "OK") != 0) 4653 error (_("Remote refused setting all-stop mode with: %s"), 4654 rs->buf.data ()); 4655 } 4656 4657 /* Upload TSVs regardless of whether the target is running or not. The 4658 remote stub, such as GDBserver, may have some predefined or builtin 4659 TSVs, even if the target is not running. */ 4660 if (get_trace_status (current_trace_status ()) != -1) 4661 { 4662 struct uploaded_tsv *uploaded_tsvs = NULL; 4663 4664 upload_trace_state_variables (&uploaded_tsvs); 4665 merge_uploaded_trace_state_variables (&uploaded_tsvs); 4666 } 4667 4668 /* Check whether the target is running now. */ 4669 putpkt ("?"); 4670 getpkt (&rs->buf, 0); 4671 4672 if (!target_is_non_stop_p ()) 4673 { 4674 if (rs->buf[0] == 'W' || rs->buf[0] == 'X') 4675 { 4676 if (!extended_p) 4677 error (_("The target is not running (try extended-remote?)")); 4678 4679 /* We're connected, but not running. Drop out before we 4680 call start_remote. */ 4681 rs->starting_up = 0; 4682 return; 4683 } 4684 else 4685 { 4686 /* Save the reply for later. */ 4687 wait_status = (char *) alloca (strlen (rs->buf.data ()) + 1); 4688 strcpy (wait_status, rs->buf.data ()); 4689 } 4690 4691 /* Fetch thread list. */ 4692 target_update_thread_list (); 4693 4694 /* Let the stub know that we want it to return the thread. */ 4695 set_continue_thread (minus_one_ptid); 4696 4697 if (thread_count () == 0) 4698 { 4699 /* Target has no concept of threads at all. GDB treats 4700 non-threaded target as single-threaded; add a main 4701 thread. */ 4702 add_current_inferior_and_thread (wait_status); 4703 } 4704 else 4705 { 4706 /* We have thread information; select the thread the target 4707 says should be current. If we're reconnecting to a 4708 multi-threaded program, this will ideally be the thread 4709 that last reported an event before GDB disconnected. */ 4710 inferior_ptid = get_current_thread (wait_status); 4711 if (inferior_ptid == null_ptid) 4712 { 4713 /* Odd... The target was able to list threads, but not 4714 tell us which thread was current (no "thread" 4715 register in T stop reply?). Just pick the first 4716 thread in the thread list then. */ 4717 4718 if (remote_debug) 4719 fprintf_unfiltered (gdb_stdlog, 4720 "warning: couldn't determine remote " 4721 "current thread; picking first in list.\n"); 4722 4723 inferior_ptid = inferior_list->thread_list->ptid; 4724 } 4725 } 4726 4727 /* init_wait_for_inferior should be called before get_offsets in order 4728 to manage `inserted' flag in bp loc in a correct state. 4729 breakpoint_init_inferior, called from init_wait_for_inferior, set 4730 `inserted' flag to 0, while before breakpoint_re_set, called from 4731 start_remote, set `inserted' flag to 1. In the initialization of 4732 inferior, breakpoint_init_inferior should be called first, and then 4733 breakpoint_re_set can be called. If this order is broken, state of 4734 `inserted' flag is wrong, and cause some problems on breakpoint 4735 manipulation. */ 4736 init_wait_for_inferior (); 4737 4738 get_offsets (); /* Get text, data & bss offsets. */ 4739 4740 /* If we could not find a description using qXfer, and we know 4741 how to do it some other way, try again. This is not 4742 supported for non-stop; it could be, but it is tricky if 4743 there are no stopped threads when we connect. */ 4744 if (remote_read_description_p (this) 4745 && gdbarch_target_desc (target_gdbarch ()) == NULL) 4746 { 4747 target_clear_description (); 4748 target_find_description (); 4749 } 4750 4751 /* Use the previously fetched status. */ 4752 gdb_assert (wait_status != NULL); 4753 strcpy (rs->buf.data (), wait_status); 4754 rs->cached_wait_status = 1; 4755 4756 ::start_remote (from_tty); /* Initialize gdb process mechanisms. */ 4757 } 4758 else 4759 { 4760 /* Clear WFI global state. Do this before finding about new 4761 threads and inferiors, and setting the current inferior. 4762 Otherwise we would clear the proceed status of the current 4763 inferior when we want its stop_soon state to be preserved 4764 (see notice_new_inferior). */ 4765 init_wait_for_inferior (); 4766 4767 /* In non-stop, we will either get an "OK", meaning that there 4768 are no stopped threads at this time; or, a regular stop 4769 reply. In the latter case, there may be more than one thread 4770 stopped --- we pull them all out using the vStopped 4771 mechanism. */ 4772 if (strcmp (rs->buf.data (), "OK") != 0) 4773 { 4774 struct notif_client *notif = ¬if_client_stop; 4775 4776 /* remote_notif_get_pending_replies acks this one, and gets 4777 the rest out. */ 4778 rs->notif_state->pending_event[notif_client_stop.id] 4779 = remote_notif_parse (this, notif, rs->buf.data ()); 4780 remote_notif_get_pending_events (notif); 4781 } 4782 4783 if (thread_count () == 0) 4784 { 4785 if (!extended_p) 4786 error (_("The target is not running (try extended-remote?)")); 4787 4788 /* We're connected, but not running. Drop out before we 4789 call start_remote. */ 4790 rs->starting_up = 0; 4791 return; 4792 } 4793 4794 /* In non-stop mode, any cached wait status will be stored in 4795 the stop reply queue. */ 4796 gdb_assert (wait_status == NULL); 4797 4798 /* Report all signals during attach/startup. */ 4799 pass_signals ({}); 4800 4801 /* If there are already stopped threads, mark them stopped and 4802 report their stops before giving the prompt to the user. */ 4803 process_initial_stop_replies (from_tty); 4804 4805 if (target_can_async_p ()) 4806 target_async (1); 4807 } 4808 4809 /* If we connected to a live target, do some additional setup. */ 4810 if (target_has_execution) 4811 { 4812 if (symfile_objfile) /* No use without a symbol-file. */ 4813 remote_check_symbols (); 4814 } 4815 4816 /* Possibly the target has been engaged in a trace run started 4817 previously; find out where things are at. */ 4818 if (get_trace_status (current_trace_status ()) != -1) 4819 { 4820 struct uploaded_tp *uploaded_tps = NULL; 4821 4822 if (current_trace_status ()->running) 4823 printf_filtered (_("Trace is already running on the target.\n")); 4824 4825 upload_tracepoints (&uploaded_tps); 4826 4827 merge_uploaded_tracepoints (&uploaded_tps); 4828 } 4829 4830 /* Possibly the target has been engaged in a btrace record started 4831 previously; find out where things are at. */ 4832 remote_btrace_maybe_reopen (); 4833 4834 /* The thread and inferior lists are now synchronized with the 4835 target, our symbols have been relocated, and we're merged the 4836 target's tracepoints with ours. We're done with basic start 4837 up. */ 4838 rs->starting_up = 0; 4839 4840 /* Maybe breakpoints are global and need to be inserted now. */ 4841 if (breakpoints_should_be_inserted_now ()) 4842 insert_breakpoints (); 4843} 4844 4845/* Open a connection to a remote debugger. 4846 NAME is the filename used for communication. */ 4847 4848void 4849remote_target::open (const char *name, int from_tty) 4850{ 4851 open_1 (name, from_tty, 0); 4852} 4853 4854/* Open a connection to a remote debugger using the extended 4855 remote gdb protocol. NAME is the filename used for communication. */ 4856 4857void 4858extended_remote_target::open (const char *name, int from_tty) 4859{ 4860 open_1 (name, from_tty, 1 /*extended_p */); 4861} 4862 4863/* Reset all packets back to "unknown support". Called when opening a 4864 new connection to a remote target. */ 4865 4866static void 4867reset_all_packet_configs_support (void) 4868{ 4869 int i; 4870 4871 for (i = 0; i < PACKET_MAX; i++) 4872 remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN; 4873} 4874 4875/* Initialize all packet configs. */ 4876 4877static void 4878init_all_packet_configs (void) 4879{ 4880 int i; 4881 4882 for (i = 0; i < PACKET_MAX; i++) 4883 { 4884 remote_protocol_packets[i].detect = AUTO_BOOLEAN_AUTO; 4885 remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN; 4886 } 4887} 4888 4889/* Symbol look-up. */ 4890 4891void 4892remote_target::remote_check_symbols () 4893{ 4894 char *tmp; 4895 int end; 4896 4897 /* The remote side has no concept of inferiors that aren't running 4898 yet, it only knows about running processes. If we're connected 4899 but our current inferior is not running, we should not invite the 4900 remote target to request symbol lookups related to its 4901 (unrelated) current process. */ 4902 if (!target_has_execution) 4903 return; 4904 4905 if (packet_support (PACKET_qSymbol) == PACKET_DISABLE) 4906 return; 4907 4908 /* Make sure the remote is pointing at the right process. Note 4909 there's no way to select "no process". */ 4910 set_general_process (); 4911 4912 /* Allocate a message buffer. We can't reuse the input buffer in RS, 4913 because we need both at the same time. */ 4914 gdb::char_vector msg (get_remote_packet_size ()); 4915 gdb::char_vector reply (get_remote_packet_size ()); 4916 4917 /* Invite target to request symbol lookups. */ 4918 4919 putpkt ("qSymbol::"); 4920 getpkt (&reply, 0); 4921 packet_ok (reply, &remote_protocol_packets[PACKET_qSymbol]); 4922 4923 while (startswith (reply.data (), "qSymbol:")) 4924 { 4925 struct bound_minimal_symbol sym; 4926 4927 tmp = &reply[8]; 4928 end = hex2bin (tmp, reinterpret_cast <gdb_byte *> (msg.data ()), 4929 strlen (tmp) / 2); 4930 msg[end] = '\0'; 4931 sym = lookup_minimal_symbol (msg.data (), NULL, NULL); 4932 if (sym.minsym == NULL) 4933 xsnprintf (msg.data (), get_remote_packet_size (), "qSymbol::%s", 4934 &reply[8]); 4935 else 4936 { 4937 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; 4938 CORE_ADDR sym_addr = BMSYMBOL_VALUE_ADDRESS (sym); 4939 4940 /* If this is a function address, return the start of code 4941 instead of any data function descriptor. */ 4942 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (), 4943 sym_addr, 4944 current_top_target ()); 4945 4946 xsnprintf (msg.data (), get_remote_packet_size (), "qSymbol:%s:%s", 4947 phex_nz (sym_addr, addr_size), &reply[8]); 4948 } 4949 4950 putpkt (msg.data ()); 4951 getpkt (&reply, 0); 4952 } 4953} 4954 4955static struct serial * 4956remote_serial_open (const char *name) 4957{ 4958 static int udp_warning = 0; 4959 4960 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead 4961 of in ser-tcp.c, because it is the remote protocol assuming that the 4962 serial connection is reliable and not the serial connection promising 4963 to be. */ 4964 if (!udp_warning && startswith (name, "udp:")) 4965 { 4966 warning (_("The remote protocol may be unreliable over UDP.\n" 4967 "Some events may be lost, rendering further debugging " 4968 "impossible.")); 4969 udp_warning = 1; 4970 } 4971 4972 return serial_open (name); 4973} 4974 4975/* Inform the target of our permission settings. The permission flags 4976 work without this, but if the target knows the settings, it can do 4977 a couple things. First, it can add its own check, to catch cases 4978 that somehow manage to get by the permissions checks in target 4979 methods. Second, if the target is wired to disallow particular 4980 settings (for instance, a system in the field that is not set up to 4981 be able to stop at a breakpoint), it can object to any unavailable 4982 permissions. */ 4983 4984void 4985remote_target::set_permissions () 4986{ 4987 struct remote_state *rs = get_remote_state (); 4988 4989 xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAllow:" 4990 "WriteReg:%x;WriteMem:%x;" 4991 "InsertBreak:%x;InsertTrace:%x;" 4992 "InsertFastTrace:%x;Stop:%x", 4993 may_write_registers, may_write_memory, 4994 may_insert_breakpoints, may_insert_tracepoints, 4995 may_insert_fast_tracepoints, may_stop); 4996 putpkt (rs->buf); 4997 getpkt (&rs->buf, 0); 4998 4999 /* If the target didn't like the packet, warn the user. Do not try 5000 to undo the user's settings, that would just be maddening. */ 5001 if (strcmp (rs->buf.data (), "OK") != 0) 5002 warning (_("Remote refused setting permissions with: %s"), 5003 rs->buf.data ()); 5004} 5005 5006/* This type describes each known response to the qSupported 5007 packet. */ 5008struct protocol_feature 5009{ 5010 /* The name of this protocol feature. */ 5011 const char *name; 5012 5013 /* The default for this protocol feature. */ 5014 enum packet_support default_support; 5015 5016 /* The function to call when this feature is reported, or after 5017 qSupported processing if the feature is not supported. 5018 The first argument points to this structure. The second 5019 argument indicates whether the packet requested support be 5020 enabled, disabled, or probed (or the default, if this function 5021 is being called at the end of processing and this feature was 5022 not reported). The third argument may be NULL; if not NULL, it 5023 is a NUL-terminated string taken from the packet following 5024 this feature's name and an equals sign. */ 5025 void (*func) (remote_target *remote, const struct protocol_feature *, 5026 enum packet_support, const char *); 5027 5028 /* The corresponding packet for this feature. Only used if 5029 FUNC is remote_supported_packet. */ 5030 int packet; 5031}; 5032 5033static void 5034remote_supported_packet (remote_target *remote, 5035 const struct protocol_feature *feature, 5036 enum packet_support support, 5037 const char *argument) 5038{ 5039 if (argument) 5040 { 5041 warning (_("Remote qSupported response supplied an unexpected value for" 5042 " \"%s\"."), feature->name); 5043 return; 5044 } 5045 5046 remote_protocol_packets[feature->packet].support = support; 5047} 5048 5049void 5050remote_target::remote_packet_size (const protocol_feature *feature, 5051 enum packet_support support, const char *value) 5052{ 5053 struct remote_state *rs = get_remote_state (); 5054 5055 int packet_size; 5056 char *value_end; 5057 5058 if (support != PACKET_ENABLE) 5059 return; 5060 5061 if (value == NULL || *value == '\0') 5062 { 5063 warning (_("Remote target reported \"%s\" without a size."), 5064 feature->name); 5065 return; 5066 } 5067 5068 errno = 0; 5069 packet_size = strtol (value, &value_end, 16); 5070 if (errno != 0 || *value_end != '\0' || packet_size < 0) 5071 { 5072 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."), 5073 feature->name, value); 5074 return; 5075 } 5076 5077 /* Record the new maximum packet size. */ 5078 rs->explicit_packet_size = packet_size; 5079} 5080 5081void 5082remote_packet_size (remote_target *remote, const protocol_feature *feature, 5083 enum packet_support support, const char *value) 5084{ 5085 remote->remote_packet_size (feature, support, value); 5086} 5087 5088static const struct protocol_feature remote_protocol_features[] = { 5089 { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 }, 5090 { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet, 5091 PACKET_qXfer_auxv }, 5092 { "qXfer:exec-file:read", PACKET_DISABLE, remote_supported_packet, 5093 PACKET_qXfer_exec_file }, 5094 { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet, 5095 PACKET_qXfer_features }, 5096 { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet, 5097 PACKET_qXfer_libraries }, 5098 { "qXfer:libraries-svr4:read", PACKET_DISABLE, remote_supported_packet, 5099 PACKET_qXfer_libraries_svr4 }, 5100 { "augmented-libraries-svr4-read", PACKET_DISABLE, 5101 remote_supported_packet, PACKET_augmented_libraries_svr4_read_feature }, 5102 { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet, 5103 PACKET_qXfer_memory_map }, 5104 { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet, 5105 PACKET_qXfer_spu_read }, 5106 { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet, 5107 PACKET_qXfer_spu_write }, 5108 { "qXfer:osdata:read", PACKET_DISABLE, remote_supported_packet, 5109 PACKET_qXfer_osdata }, 5110 { "qXfer:threads:read", PACKET_DISABLE, remote_supported_packet, 5111 PACKET_qXfer_threads }, 5112 { "qXfer:traceframe-info:read", PACKET_DISABLE, remote_supported_packet, 5113 PACKET_qXfer_traceframe_info }, 5114 { "QPassSignals", PACKET_DISABLE, remote_supported_packet, 5115 PACKET_QPassSignals }, 5116 { "QCatchSyscalls", PACKET_DISABLE, remote_supported_packet, 5117 PACKET_QCatchSyscalls }, 5118 { "QProgramSignals", PACKET_DISABLE, remote_supported_packet, 5119 PACKET_QProgramSignals }, 5120 { "QSetWorkingDir", PACKET_DISABLE, remote_supported_packet, 5121 PACKET_QSetWorkingDir }, 5122 { "QStartupWithShell", PACKET_DISABLE, remote_supported_packet, 5123 PACKET_QStartupWithShell }, 5124 { "QEnvironmentHexEncoded", PACKET_DISABLE, remote_supported_packet, 5125 PACKET_QEnvironmentHexEncoded }, 5126 { "QEnvironmentReset", PACKET_DISABLE, remote_supported_packet, 5127 PACKET_QEnvironmentReset }, 5128 { "QEnvironmentUnset", PACKET_DISABLE, remote_supported_packet, 5129 PACKET_QEnvironmentUnset }, 5130 { "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet, 5131 PACKET_QStartNoAckMode }, 5132 { "multiprocess", PACKET_DISABLE, remote_supported_packet, 5133 PACKET_multiprocess_feature }, 5134 { "QNonStop", PACKET_DISABLE, remote_supported_packet, PACKET_QNonStop }, 5135 { "qXfer:siginfo:read", PACKET_DISABLE, remote_supported_packet, 5136 PACKET_qXfer_siginfo_read }, 5137 { "qXfer:siginfo:write", PACKET_DISABLE, remote_supported_packet, 5138 PACKET_qXfer_siginfo_write }, 5139 { "ConditionalTracepoints", PACKET_DISABLE, remote_supported_packet, 5140 PACKET_ConditionalTracepoints }, 5141 { "ConditionalBreakpoints", PACKET_DISABLE, remote_supported_packet, 5142 PACKET_ConditionalBreakpoints }, 5143 { "BreakpointCommands", PACKET_DISABLE, remote_supported_packet, 5144 PACKET_BreakpointCommands }, 5145 { "FastTracepoints", PACKET_DISABLE, remote_supported_packet, 5146 PACKET_FastTracepoints }, 5147 { "StaticTracepoints", PACKET_DISABLE, remote_supported_packet, 5148 PACKET_StaticTracepoints }, 5149 {"InstallInTrace", PACKET_DISABLE, remote_supported_packet, 5150 PACKET_InstallInTrace}, 5151 { "DisconnectedTracing", PACKET_DISABLE, remote_supported_packet, 5152 PACKET_DisconnectedTracing_feature }, 5153 { "ReverseContinue", PACKET_DISABLE, remote_supported_packet, 5154 PACKET_bc }, 5155 { "ReverseStep", PACKET_DISABLE, remote_supported_packet, 5156 PACKET_bs }, 5157 { "TracepointSource", PACKET_DISABLE, remote_supported_packet, 5158 PACKET_TracepointSource }, 5159 { "QAllow", PACKET_DISABLE, remote_supported_packet, 5160 PACKET_QAllow }, 5161 { "EnableDisableTracepoints", PACKET_DISABLE, remote_supported_packet, 5162 PACKET_EnableDisableTracepoints_feature }, 5163 { "qXfer:fdpic:read", PACKET_DISABLE, remote_supported_packet, 5164 PACKET_qXfer_fdpic }, 5165 { "qXfer:uib:read", PACKET_DISABLE, remote_supported_packet, 5166 PACKET_qXfer_uib }, 5167 { "QDisableRandomization", PACKET_DISABLE, remote_supported_packet, 5168 PACKET_QDisableRandomization }, 5169 { "QAgent", PACKET_DISABLE, remote_supported_packet, PACKET_QAgent}, 5170 { "QTBuffer:size", PACKET_DISABLE, 5171 remote_supported_packet, PACKET_QTBuffer_size}, 5172 { "tracenz", PACKET_DISABLE, remote_supported_packet, PACKET_tracenz_feature }, 5173 { "Qbtrace:off", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_off }, 5174 { "Qbtrace:bts", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_bts }, 5175 { "Qbtrace:pt", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_pt }, 5176 { "qXfer:btrace:read", PACKET_DISABLE, remote_supported_packet, 5177 PACKET_qXfer_btrace }, 5178 { "qXfer:btrace-conf:read", PACKET_DISABLE, remote_supported_packet, 5179 PACKET_qXfer_btrace_conf }, 5180 { "Qbtrace-conf:bts:size", PACKET_DISABLE, remote_supported_packet, 5181 PACKET_Qbtrace_conf_bts_size }, 5182 { "swbreak", PACKET_DISABLE, remote_supported_packet, PACKET_swbreak_feature }, 5183 { "hwbreak", PACKET_DISABLE, remote_supported_packet, PACKET_hwbreak_feature }, 5184 { "fork-events", PACKET_DISABLE, remote_supported_packet, 5185 PACKET_fork_event_feature }, 5186 { "vfork-events", PACKET_DISABLE, remote_supported_packet, 5187 PACKET_vfork_event_feature }, 5188 { "exec-events", PACKET_DISABLE, remote_supported_packet, 5189 PACKET_exec_event_feature }, 5190 { "Qbtrace-conf:pt:size", PACKET_DISABLE, remote_supported_packet, 5191 PACKET_Qbtrace_conf_pt_size }, 5192 { "vContSupported", PACKET_DISABLE, remote_supported_packet, PACKET_vContSupported }, 5193 { "QThreadEvents", PACKET_DISABLE, remote_supported_packet, PACKET_QThreadEvents }, 5194 { "no-resumed", PACKET_DISABLE, remote_supported_packet, PACKET_no_resumed }, 5195}; 5196 5197static char *remote_support_xml; 5198 5199/* Register string appended to "xmlRegisters=" in qSupported query. */ 5200 5201void 5202register_remote_support_xml (const char *xml) 5203{ 5204#if defined(HAVE_LIBEXPAT) 5205 if (remote_support_xml == NULL) 5206 remote_support_xml = concat ("xmlRegisters=", xml, (char *) NULL); 5207 else 5208 { 5209 char *copy = xstrdup (remote_support_xml + 13); 5210 char *p = strtok (copy, ","); 5211 5212 do 5213 { 5214 if (strcmp (p, xml) == 0) 5215 { 5216 /* already there */ 5217 xfree (copy); 5218 return; 5219 } 5220 } 5221 while ((p = strtok (NULL, ",")) != NULL); 5222 xfree (copy); 5223 5224 remote_support_xml = reconcat (remote_support_xml, 5225 remote_support_xml, ",", xml, 5226 (char *) NULL); 5227 } 5228#endif 5229} 5230 5231static void 5232remote_query_supported_append (std::string *msg, const char *append) 5233{ 5234 if (!msg->empty ()) 5235 msg->append (";"); 5236 msg->append (append); 5237} 5238 5239void 5240remote_target::remote_query_supported () 5241{ 5242 struct remote_state *rs = get_remote_state (); 5243 char *next; 5244 int i; 5245 unsigned char seen [ARRAY_SIZE (remote_protocol_features)]; 5246 5247 /* The packet support flags are handled differently for this packet 5248 than for most others. We treat an error, a disabled packet, and 5249 an empty response identically: any features which must be reported 5250 to be used will be automatically disabled. An empty buffer 5251 accomplishes this, since that is also the representation for a list 5252 containing no features. */ 5253 5254 rs->buf[0] = 0; 5255 if (packet_support (PACKET_qSupported) != PACKET_DISABLE) 5256 { 5257 std::string q; 5258 5259 if (packet_set_cmd_state (PACKET_multiprocess_feature) != AUTO_BOOLEAN_FALSE) 5260 remote_query_supported_append (&q, "multiprocess+"); 5261 5262 if (packet_set_cmd_state (PACKET_swbreak_feature) != AUTO_BOOLEAN_FALSE) 5263 remote_query_supported_append (&q, "swbreak+"); 5264 if (packet_set_cmd_state (PACKET_hwbreak_feature) != AUTO_BOOLEAN_FALSE) 5265 remote_query_supported_append (&q, "hwbreak+"); 5266 5267 remote_query_supported_append (&q, "qRelocInsn+"); 5268 5269 if (packet_set_cmd_state (PACKET_fork_event_feature) 5270 != AUTO_BOOLEAN_FALSE) 5271 remote_query_supported_append (&q, "fork-events+"); 5272 if (packet_set_cmd_state (PACKET_vfork_event_feature) 5273 != AUTO_BOOLEAN_FALSE) 5274 remote_query_supported_append (&q, "vfork-events+"); 5275 if (packet_set_cmd_state (PACKET_exec_event_feature) 5276 != AUTO_BOOLEAN_FALSE) 5277 remote_query_supported_append (&q, "exec-events+"); 5278 5279 if (packet_set_cmd_state (PACKET_vContSupported) != AUTO_BOOLEAN_FALSE) 5280 remote_query_supported_append (&q, "vContSupported+"); 5281 5282 if (packet_set_cmd_state (PACKET_QThreadEvents) != AUTO_BOOLEAN_FALSE) 5283 remote_query_supported_append (&q, "QThreadEvents+"); 5284 5285 if (packet_set_cmd_state (PACKET_no_resumed) != AUTO_BOOLEAN_FALSE) 5286 remote_query_supported_append (&q, "no-resumed+"); 5287 5288 /* Keep this one last to work around a gdbserver <= 7.10 bug in 5289 the qSupported:xmlRegisters=i386 handling. */ 5290 if (remote_support_xml != NULL 5291 && packet_support (PACKET_qXfer_features) != PACKET_DISABLE) 5292 remote_query_supported_append (&q, remote_support_xml); 5293 5294 q = "qSupported:" + q; 5295 putpkt (q.c_str ()); 5296 5297 getpkt (&rs->buf, 0); 5298 5299 /* If an error occured, warn, but do not return - just reset the 5300 buffer to empty and go on to disable features. */ 5301 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported]) 5302 == PACKET_ERROR) 5303 { 5304 warning (_("Remote failure reply: %s"), rs->buf.data ()); 5305 rs->buf[0] = 0; 5306 } 5307 } 5308 5309 memset (seen, 0, sizeof (seen)); 5310 5311 next = rs->buf.data (); 5312 while (*next) 5313 { 5314 enum packet_support is_supported; 5315 char *p, *end, *name_end, *value; 5316 5317 /* First separate out this item from the rest of the packet. If 5318 there's another item after this, we overwrite the separator 5319 (terminated strings are much easier to work with). */ 5320 p = next; 5321 end = strchr (p, ';'); 5322 if (end == NULL) 5323 { 5324 end = p + strlen (p); 5325 next = end; 5326 } 5327 else 5328 { 5329 *end = '\0'; 5330 next = end + 1; 5331 5332 if (end == p) 5333 { 5334 warning (_("empty item in \"qSupported\" response")); 5335 continue; 5336 } 5337 } 5338 5339 name_end = strchr (p, '='); 5340 if (name_end) 5341 { 5342 /* This is a name=value entry. */ 5343 is_supported = PACKET_ENABLE; 5344 value = name_end + 1; 5345 *name_end = '\0'; 5346 } 5347 else 5348 { 5349 value = NULL; 5350 switch (end[-1]) 5351 { 5352 case '+': 5353 is_supported = PACKET_ENABLE; 5354 break; 5355 5356 case '-': 5357 is_supported = PACKET_DISABLE; 5358 break; 5359 5360 case '?': 5361 is_supported = PACKET_SUPPORT_UNKNOWN; 5362 break; 5363 5364 default: 5365 warning (_("unrecognized item \"%s\" " 5366 "in \"qSupported\" response"), p); 5367 continue; 5368 } 5369 end[-1] = '\0'; 5370 } 5371 5372 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++) 5373 if (strcmp (remote_protocol_features[i].name, p) == 0) 5374 { 5375 const struct protocol_feature *feature; 5376 5377 seen[i] = 1; 5378 feature = &remote_protocol_features[i]; 5379 feature->func (this, feature, is_supported, value); 5380 break; 5381 } 5382 } 5383 5384 /* If we increased the packet size, make sure to increase the global 5385 buffer size also. We delay this until after parsing the entire 5386 qSupported packet, because this is the same buffer we were 5387 parsing. */ 5388 if (rs->buf.size () < rs->explicit_packet_size) 5389 rs->buf.resize (rs->explicit_packet_size); 5390 5391 /* Handle the defaults for unmentioned features. */ 5392 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++) 5393 if (!seen[i]) 5394 { 5395 const struct protocol_feature *feature; 5396 5397 feature = &remote_protocol_features[i]; 5398 feature->func (this, feature, feature->default_support, NULL); 5399 } 5400} 5401 5402/* Serial QUIT handler for the remote serial descriptor. 5403 5404 Defers handling a Ctrl-C until we're done with the current 5405 command/response packet sequence, unless: 5406 5407 - We're setting up the connection. Don't send a remote interrupt 5408 request, as we're not fully synced yet. Quit immediately 5409 instead. 5410 5411 - The target has been resumed in the foreground 5412 (target_terminal::is_ours is false) with a synchronous resume 5413 packet, and we're blocked waiting for the stop reply, thus a 5414 Ctrl-C should be immediately sent to the target. 5415 5416 - We get a second Ctrl-C while still within the same serial read or 5417 write. In that case the serial is seemingly wedged --- offer to 5418 quit/disconnect. 5419 5420 - We see a second Ctrl-C without target response, after having 5421 previously interrupted the target. In that case the target/stub 5422 is probably wedged --- offer to quit/disconnect. 5423*/ 5424 5425void 5426remote_target::remote_serial_quit_handler () 5427{ 5428 struct remote_state *rs = get_remote_state (); 5429 5430 if (check_quit_flag ()) 5431 { 5432 /* If we're starting up, we're not fully synced yet. Quit 5433 immediately. */ 5434 if (rs->starting_up) 5435 quit (); 5436 else if (rs->got_ctrlc_during_io) 5437 { 5438 if (query (_("The target is not responding to GDB commands.\n" 5439 "Stop debugging it? "))) 5440 remote_unpush_and_throw (); 5441 } 5442 /* If ^C has already been sent once, offer to disconnect. */ 5443 else if (!target_terminal::is_ours () && rs->ctrlc_pending_p) 5444 interrupt_query (); 5445 /* All-stop protocol, and blocked waiting for stop reply. Send 5446 an interrupt request. */ 5447 else if (!target_terminal::is_ours () && rs->waiting_for_stop_reply) 5448 target_interrupt (); 5449 else 5450 rs->got_ctrlc_during_io = 1; 5451 } 5452} 5453 5454/* The remote_target that is current while the quit handler is 5455 overridden with remote_serial_quit_handler. */ 5456static remote_target *curr_quit_handler_target; 5457 5458static void 5459remote_serial_quit_handler () 5460{ 5461 curr_quit_handler_target->remote_serial_quit_handler (); 5462} 5463 5464/* Remove any of the remote.c targets from target stack. Upper targets depend 5465 on it so remove them first. */ 5466 5467static void 5468remote_unpush_target (void) 5469{ 5470 pop_all_targets_at_and_above (process_stratum); 5471} 5472 5473static void 5474remote_unpush_and_throw (void) 5475{ 5476 remote_unpush_target (); 5477 throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target.")); 5478} 5479 5480void 5481remote_target::open_1 (const char *name, int from_tty, int extended_p) 5482{ 5483 remote_target *curr_remote = get_current_remote_target (); 5484 5485 if (name == 0) 5486 error (_("To open a remote debug connection, you need to specify what\n" 5487 "serial device is attached to the remote system\n" 5488 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).")); 5489 5490 /* If we're connected to a running target, target_preopen will kill it. 5491 Ask this question first, before target_preopen has a chance to kill 5492 anything. */ 5493 if (curr_remote != NULL && !have_inferiors ()) 5494 { 5495 if (from_tty 5496 && !query (_("Already connected to a remote target. Disconnect? "))) 5497 error (_("Still connected.")); 5498 } 5499 5500 /* Here the possibly existing remote target gets unpushed. */ 5501 target_preopen (from_tty); 5502 5503 remote_fileio_reset (); 5504 reopen_exec_file (); 5505 reread_symbols (); 5506 5507 remote_target *remote 5508 = (extended_p ? new extended_remote_target () : new remote_target ()); 5509 target_ops_up target_holder (remote); 5510 5511 remote_state *rs = remote->get_remote_state (); 5512 5513 /* See FIXME above. */ 5514 if (!target_async_permitted) 5515 rs->wait_forever_enabled_p = 1; 5516 5517 rs->remote_desc = remote_serial_open (name); 5518 if (!rs->remote_desc) 5519 perror_with_name (name); 5520 5521 if (baud_rate != -1) 5522 { 5523 if (serial_setbaudrate (rs->remote_desc, baud_rate)) 5524 { 5525 /* The requested speed could not be set. Error out to 5526 top level after closing remote_desc. Take care to 5527 set remote_desc to NULL to avoid closing remote_desc 5528 more than once. */ 5529 serial_close (rs->remote_desc); 5530 rs->remote_desc = NULL; 5531 perror_with_name (name); 5532 } 5533 } 5534 5535 serial_setparity (rs->remote_desc, serial_parity); 5536 serial_raw (rs->remote_desc); 5537 5538 /* If there is something sitting in the buffer we might take it as a 5539 response to a command, which would be bad. */ 5540 serial_flush_input (rs->remote_desc); 5541 5542 if (from_tty) 5543 { 5544 puts_filtered ("Remote debugging using "); 5545 puts_filtered (name); 5546 puts_filtered ("\n"); 5547 } 5548 5549 /* Switch to using the remote target now. */ 5550 push_target (std::move (target_holder)); 5551 5552 /* Register extra event sources in the event loop. */ 5553 rs->remote_async_inferior_event_token 5554 = create_async_event_handler (remote_async_inferior_event_handler, 5555 remote); 5556 rs->notif_state = remote_notif_state_allocate (remote); 5557 5558 /* Reset the target state; these things will be queried either by 5559 remote_query_supported or as they are needed. */ 5560 reset_all_packet_configs_support (); 5561 rs->cached_wait_status = 0; 5562 rs->explicit_packet_size = 0; 5563 rs->noack_mode = 0; 5564 rs->extended = extended_p; 5565 rs->waiting_for_stop_reply = 0; 5566 rs->ctrlc_pending_p = 0; 5567 rs->got_ctrlc_during_io = 0; 5568 5569 rs->general_thread = not_sent_ptid; 5570 rs->continue_thread = not_sent_ptid; 5571 rs->remote_traceframe_number = -1; 5572 5573 rs->last_resume_exec_dir = EXEC_FORWARD; 5574 5575 /* Probe for ability to use "ThreadInfo" query, as required. */ 5576 rs->use_threadinfo_query = 1; 5577 rs->use_threadextra_query = 1; 5578 5579 rs->readahead_cache.invalidate (); 5580 5581 if (target_async_permitted) 5582 { 5583 /* FIXME: cagney/1999-09-23: During the initial connection it is 5584 assumed that the target is already ready and able to respond to 5585 requests. Unfortunately remote_start_remote() eventually calls 5586 wait_for_inferior() with no timeout. wait_forever_enabled_p gets 5587 around this. Eventually a mechanism that allows 5588 wait_for_inferior() to expect/get timeouts will be 5589 implemented. */ 5590 rs->wait_forever_enabled_p = 0; 5591 } 5592 5593 /* First delete any symbols previously loaded from shared libraries. */ 5594 no_shared_libraries (NULL, 0); 5595 5596 /* Start the remote connection. If error() or QUIT, discard this 5597 target (we'd otherwise be in an inconsistent state) and then 5598 propogate the error on up the exception chain. This ensures that 5599 the caller doesn't stumble along blindly assuming that the 5600 function succeeded. The CLI doesn't have this problem but other 5601 UI's, such as MI do. 5602 5603 FIXME: cagney/2002-05-19: Instead of re-throwing the exception, 5604 this function should return an error indication letting the 5605 caller restore the previous state. Unfortunately the command 5606 ``target remote'' is directly wired to this function making that 5607 impossible. On a positive note, the CLI side of this problem has 5608 been fixed - the function set_cmd_context() makes it possible for 5609 all the ``target ....'' commands to share a common callback 5610 function. See cli-dump.c. */ 5611 { 5612 5613 TRY 5614 { 5615 remote->start_remote (from_tty, extended_p); 5616 } 5617 CATCH (ex, RETURN_MASK_ALL) 5618 { 5619 /* Pop the partially set up target - unless something else did 5620 already before throwing the exception. */ 5621 if (ex.error != TARGET_CLOSE_ERROR) 5622 remote_unpush_target (); 5623 throw_exception (ex); 5624 } 5625 END_CATCH 5626 } 5627 5628 remote_btrace_reset (rs); 5629 5630 if (target_async_permitted) 5631 rs->wait_forever_enabled_p = 1; 5632} 5633 5634/* Detach the specified process. */ 5635 5636void 5637remote_target::remote_detach_pid (int pid) 5638{ 5639 struct remote_state *rs = get_remote_state (); 5640 5641 /* This should not be necessary, but the handling for D;PID in 5642 GDBserver versions prior to 8.2 incorrectly assumes that the 5643 selected process points to the same process we're detaching, 5644 leading to misbehavior (and possibly GDBserver crashing) when it 5645 does not. Since it's easy and cheap, work around it by forcing 5646 GDBserver to select GDB's current process. */ 5647 set_general_process (); 5648 5649 if (remote_multi_process_p (rs)) 5650 xsnprintf (rs->buf.data (), get_remote_packet_size (), "D;%x", pid); 5651 else 5652 strcpy (rs->buf.data (), "D"); 5653 5654 putpkt (rs->buf); 5655 getpkt (&rs->buf, 0); 5656 5657 if (rs->buf[0] == 'O' && rs->buf[1] == 'K') 5658 ; 5659 else if (rs->buf[0] == '\0') 5660 error (_("Remote doesn't know how to detach")); 5661 else 5662 error (_("Can't detach process.")); 5663} 5664 5665/* This detaches a program to which we previously attached, using 5666 inferior_ptid to identify the process. After this is done, GDB 5667 can be used to debug some other program. We better not have left 5668 any breakpoints in the target program or it'll die when it hits 5669 one. */ 5670 5671void 5672remote_target::remote_detach_1 (inferior *inf, int from_tty) 5673{ 5674 int pid = inferior_ptid.pid (); 5675 struct remote_state *rs = get_remote_state (); 5676 int is_fork_parent; 5677 5678 if (!target_has_execution) 5679 error (_("No process to detach from.")); 5680 5681 target_announce_detach (from_tty); 5682 5683 /* Tell the remote target to detach. */ 5684 remote_detach_pid (pid); 5685 5686 /* Exit only if this is the only active inferior. */ 5687 if (from_tty && !rs->extended && number_of_live_inferiors () == 1) 5688 puts_filtered (_("Ending remote debugging.\n")); 5689 5690 struct thread_info *tp = find_thread_ptid (inferior_ptid); 5691 5692 /* Check to see if we are detaching a fork parent. Note that if we 5693 are detaching a fork child, tp == NULL. */ 5694 is_fork_parent = (tp != NULL 5695 && tp->pending_follow.kind == TARGET_WAITKIND_FORKED); 5696 5697 /* If doing detach-on-fork, we don't mourn, because that will delete 5698 breakpoints that should be available for the followed inferior. */ 5699 if (!is_fork_parent) 5700 { 5701 /* Save the pid as a string before mourning, since that will 5702 unpush the remote target, and we need the string after. */ 5703 std::string infpid = target_pid_to_str (ptid_t (pid)); 5704 5705 target_mourn_inferior (inferior_ptid); 5706 if (print_inferior_events) 5707 printf_unfiltered (_("[Inferior %d (%s) detached]\n"), 5708 inf->num, infpid.c_str ()); 5709 } 5710 else 5711 { 5712 inferior_ptid = null_ptid; 5713 detach_inferior (current_inferior ()); 5714 } 5715} 5716 5717void 5718remote_target::detach (inferior *inf, int from_tty) 5719{ 5720 remote_detach_1 (inf, from_tty); 5721} 5722 5723void 5724extended_remote_target::detach (inferior *inf, int from_tty) 5725{ 5726 remote_detach_1 (inf, from_tty); 5727} 5728 5729/* Target follow-fork function for remote targets. On entry, and 5730 at return, the current inferior is the fork parent. 5731 5732 Note that although this is currently only used for extended-remote, 5733 it is named remote_follow_fork in anticipation of using it for the 5734 remote target as well. */ 5735 5736int 5737remote_target::follow_fork (int follow_child, int detach_fork) 5738{ 5739 struct remote_state *rs = get_remote_state (); 5740 enum target_waitkind kind = inferior_thread ()->pending_follow.kind; 5741 5742 if ((kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs)) 5743 || (kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs))) 5744 { 5745 /* When following the parent and detaching the child, we detach 5746 the child here. For the case of following the child and 5747 detaching the parent, the detach is done in the target- 5748 independent follow fork code in infrun.c. We can't use 5749 target_detach when detaching an unfollowed child because 5750 the client side doesn't know anything about the child. */ 5751 if (detach_fork && !follow_child) 5752 { 5753 /* Detach the fork child. */ 5754 ptid_t child_ptid; 5755 pid_t child_pid; 5756 5757 child_ptid = inferior_thread ()->pending_follow.value.related_pid; 5758 child_pid = child_ptid.pid (); 5759 5760 remote_detach_pid (child_pid); 5761 } 5762 } 5763 return 0; 5764} 5765 5766/* Target follow-exec function for remote targets. Save EXECD_PATHNAME 5767 in the program space of the new inferior. On entry and at return the 5768 current inferior is the exec'ing inferior. INF is the new exec'd 5769 inferior, which may be the same as the exec'ing inferior unless 5770 follow-exec-mode is "new". */ 5771 5772void 5773remote_target::follow_exec (struct inferior *inf, char *execd_pathname) 5774{ 5775 /* We know that this is a target file name, so if it has the "target:" 5776 prefix we strip it off before saving it in the program space. */ 5777 if (is_target_filename (execd_pathname)) 5778 execd_pathname += strlen (TARGET_SYSROOT_PREFIX); 5779 5780 set_pspace_remote_exec_file (inf->pspace, execd_pathname); 5781} 5782 5783/* Same as remote_detach, but don't send the "D" packet; just disconnect. */ 5784 5785void 5786remote_target::disconnect (const char *args, int from_tty) 5787{ 5788 if (args) 5789 error (_("Argument given to \"disconnect\" when remotely debugging.")); 5790 5791 /* Make sure we unpush even the extended remote targets. Calling 5792 target_mourn_inferior won't unpush, and remote_mourn won't 5793 unpush if there is more than one inferior left. */ 5794 unpush_target (this); 5795 generic_mourn_inferior (); 5796 5797 if (from_tty) 5798 puts_filtered ("Ending remote debugging.\n"); 5799} 5800 5801/* Attach to the process specified by ARGS. If FROM_TTY is non-zero, 5802 be chatty about it. */ 5803 5804void 5805extended_remote_target::attach (const char *args, int from_tty) 5806{ 5807 struct remote_state *rs = get_remote_state (); 5808 int pid; 5809 char *wait_status = NULL; 5810 5811 pid = parse_pid_to_attach (args); 5812 5813 /* Remote PID can be freely equal to getpid, do not check it here the same 5814 way as in other targets. */ 5815 5816 if (packet_support (PACKET_vAttach) == PACKET_DISABLE) 5817 error (_("This target does not support attaching to a process")); 5818 5819 if (from_tty) 5820 { 5821 char *exec_file = get_exec_file (0); 5822 5823 if (exec_file) 5824 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file, 5825 target_pid_to_str (ptid_t (pid))); 5826 else 5827 printf_unfiltered (_("Attaching to %s\n"), 5828 target_pid_to_str (ptid_t (pid))); 5829 5830 gdb_flush (gdb_stdout); 5831 } 5832 5833 xsnprintf (rs->buf.data (), get_remote_packet_size (), "vAttach;%x", pid); 5834 putpkt (rs->buf); 5835 getpkt (&rs->buf, 0); 5836 5837 switch (packet_ok (rs->buf, 5838 &remote_protocol_packets[PACKET_vAttach])) 5839 { 5840 case PACKET_OK: 5841 if (!target_is_non_stop_p ()) 5842 { 5843 /* Save the reply for later. */ 5844 wait_status = (char *) alloca (strlen (rs->buf.data ()) + 1); 5845 strcpy (wait_status, rs->buf.data ()); 5846 } 5847 else if (strcmp (rs->buf.data (), "OK") != 0) 5848 error (_("Attaching to %s failed with: %s"), 5849 target_pid_to_str (ptid_t (pid)), 5850 rs->buf.data ()); 5851 break; 5852 case PACKET_UNKNOWN: 5853 error (_("This target does not support attaching to a process")); 5854 default: 5855 error (_("Attaching to %s failed"), 5856 target_pid_to_str (ptid_t (pid))); 5857 } 5858 5859 set_current_inferior (remote_add_inferior (0, pid, 1, 0)); 5860 5861 inferior_ptid = ptid_t (pid); 5862 5863 if (target_is_non_stop_p ()) 5864 { 5865 struct thread_info *thread; 5866 5867 /* Get list of threads. */ 5868 update_thread_list (); 5869 5870 thread = first_thread_of_inferior (current_inferior ()); 5871 if (thread) 5872 inferior_ptid = thread->ptid; 5873 else 5874 inferior_ptid = ptid_t (pid); 5875 5876 /* Invalidate our notion of the remote current thread. */ 5877 record_currthread (rs, minus_one_ptid); 5878 } 5879 else 5880 { 5881 /* Now, if we have thread information, update inferior_ptid. */ 5882 inferior_ptid = remote_current_thread (inferior_ptid); 5883 5884 /* Add the main thread to the thread list. */ 5885 thread_info *thr = add_thread_silent (inferior_ptid); 5886 /* Don't consider the thread stopped until we've processed the 5887 saved stop reply. */ 5888 set_executing (thr->ptid, true); 5889 } 5890 5891 /* Next, if the target can specify a description, read it. We do 5892 this before anything involving memory or registers. */ 5893 target_find_description (); 5894 5895 if (!target_is_non_stop_p ()) 5896 { 5897 /* Use the previously fetched status. */ 5898 gdb_assert (wait_status != NULL); 5899 5900 if (target_can_async_p ()) 5901 { 5902 struct notif_event *reply 5903 = remote_notif_parse (this, ¬if_client_stop, wait_status); 5904 5905 push_stop_reply ((struct stop_reply *) reply); 5906 5907 target_async (1); 5908 } 5909 else 5910 { 5911 gdb_assert (wait_status != NULL); 5912 strcpy (rs->buf.data (), wait_status); 5913 rs->cached_wait_status = 1; 5914 } 5915 } 5916 else 5917 gdb_assert (wait_status == NULL); 5918} 5919 5920/* Implementation of the to_post_attach method. */ 5921 5922void 5923extended_remote_target::post_attach (int pid) 5924{ 5925 /* Get text, data & bss offsets. */ 5926 get_offsets (); 5927 5928 /* In certain cases GDB might not have had the chance to start 5929 symbol lookup up until now. This could happen if the debugged 5930 binary is not using shared libraries, the vsyscall page is not 5931 present (on Linux) and the binary itself hadn't changed since the 5932 debugging process was started. */ 5933 if (symfile_objfile != NULL) 5934 remote_check_symbols(); 5935} 5936 5937 5938/* Check for the availability of vCont. This function should also check 5939 the response. */ 5940 5941void 5942remote_target::remote_vcont_probe () 5943{ 5944 remote_state *rs = get_remote_state (); 5945 char *buf; 5946 5947 strcpy (rs->buf.data (), "vCont?"); 5948 putpkt (rs->buf); 5949 getpkt (&rs->buf, 0); 5950 buf = rs->buf.data (); 5951 5952 /* Make sure that the features we assume are supported. */ 5953 if (startswith (buf, "vCont")) 5954 { 5955 char *p = &buf[5]; 5956 int support_c, support_C; 5957 5958 rs->supports_vCont.s = 0; 5959 rs->supports_vCont.S = 0; 5960 support_c = 0; 5961 support_C = 0; 5962 rs->supports_vCont.t = 0; 5963 rs->supports_vCont.r = 0; 5964 while (p && *p == ';') 5965 { 5966 p++; 5967 if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0)) 5968 rs->supports_vCont.s = 1; 5969 else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0)) 5970 rs->supports_vCont.S = 1; 5971 else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0)) 5972 support_c = 1; 5973 else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0)) 5974 support_C = 1; 5975 else if (*p == 't' && (*(p + 1) == ';' || *(p + 1) == 0)) 5976 rs->supports_vCont.t = 1; 5977 else if (*p == 'r' && (*(p + 1) == ';' || *(p + 1) == 0)) 5978 rs->supports_vCont.r = 1; 5979 5980 p = strchr (p, ';'); 5981 } 5982 5983 /* If c, and C are not all supported, we can't use vCont. Clearing 5984 BUF will make packet_ok disable the packet. */ 5985 if (!support_c || !support_C) 5986 buf[0] = 0; 5987 } 5988 5989 packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCont]); 5990} 5991 5992/* Helper function for building "vCont" resumptions. Write a 5993 resumption to P. ENDP points to one-passed-the-end of the buffer 5994 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The 5995 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the 5996 resumed thread should be single-stepped and/or signalled. If PTID 5997 equals minus_one_ptid, then all threads are resumed; if PTID 5998 represents a process, then all threads of the process are resumed; 5999 the thread to be stepped and/or signalled is given in the global 6000 INFERIOR_PTID. */ 6001 6002char * 6003remote_target::append_resumption (char *p, char *endp, 6004 ptid_t ptid, int step, gdb_signal siggnal) 6005{ 6006 struct remote_state *rs = get_remote_state (); 6007 6008 if (step && siggnal != GDB_SIGNAL_0) 6009 p += xsnprintf (p, endp - p, ";S%02x", siggnal); 6010 else if (step 6011 /* GDB is willing to range step. */ 6012 && use_range_stepping 6013 /* Target supports range stepping. */ 6014 && rs->supports_vCont.r 6015 /* We don't currently support range stepping multiple 6016 threads with a wildcard (though the protocol allows it, 6017 so stubs shouldn't make an active effort to forbid 6018 it). */ 6019 && !(remote_multi_process_p (rs) && ptid.is_pid ())) 6020 { 6021 struct thread_info *tp; 6022 6023 if (ptid == minus_one_ptid) 6024 { 6025 /* If we don't know about the target thread's tid, then 6026 we're resuming magic_null_ptid (see caller). */ 6027 tp = find_thread_ptid (magic_null_ptid); 6028 } 6029 else 6030 tp = find_thread_ptid (ptid); 6031 gdb_assert (tp != NULL); 6032 6033 if (tp->control.may_range_step) 6034 { 6035 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; 6036 6037 p += xsnprintf (p, endp - p, ";r%s,%s", 6038 phex_nz (tp->control.step_range_start, 6039 addr_size), 6040 phex_nz (tp->control.step_range_end, 6041 addr_size)); 6042 } 6043 else 6044 p += xsnprintf (p, endp - p, ";s"); 6045 } 6046 else if (step) 6047 p += xsnprintf (p, endp - p, ";s"); 6048 else if (siggnal != GDB_SIGNAL_0) 6049 p += xsnprintf (p, endp - p, ";C%02x", siggnal); 6050 else 6051 p += xsnprintf (p, endp - p, ";c"); 6052 6053 if (remote_multi_process_p (rs) && ptid.is_pid ()) 6054 { 6055 ptid_t nptid; 6056 6057 /* All (-1) threads of process. */ 6058 nptid = ptid_t (ptid.pid (), -1, 0); 6059 6060 p += xsnprintf (p, endp - p, ":"); 6061 p = write_ptid (p, endp, nptid); 6062 } 6063 else if (ptid != minus_one_ptid) 6064 { 6065 p += xsnprintf (p, endp - p, ":"); 6066 p = write_ptid (p, endp, ptid); 6067 } 6068 6069 return p; 6070} 6071 6072/* Clear the thread's private info on resume. */ 6073 6074static void 6075resume_clear_thread_private_info (struct thread_info *thread) 6076{ 6077 if (thread->priv != NULL) 6078 { 6079 remote_thread_info *priv = get_remote_thread_info (thread); 6080 6081 priv->stop_reason = TARGET_STOPPED_BY_NO_REASON; 6082 priv->watch_data_address = 0; 6083 } 6084} 6085 6086/* Append a vCont continue-with-signal action for threads that have a 6087 non-zero stop signal. */ 6088 6089char * 6090remote_target::append_pending_thread_resumptions (char *p, char *endp, 6091 ptid_t ptid) 6092{ 6093 for (thread_info *thread : all_non_exited_threads (ptid)) 6094 if (inferior_ptid != thread->ptid 6095 && thread->suspend.stop_signal != GDB_SIGNAL_0) 6096 { 6097 p = append_resumption (p, endp, thread->ptid, 6098 0, thread->suspend.stop_signal); 6099 thread->suspend.stop_signal = GDB_SIGNAL_0; 6100 resume_clear_thread_private_info (thread); 6101 } 6102 6103 return p; 6104} 6105 6106/* Set the target running, using the packets that use Hc 6107 (c/s/C/S). */ 6108 6109void 6110remote_target::remote_resume_with_hc (ptid_t ptid, int step, 6111 gdb_signal siggnal) 6112{ 6113 struct remote_state *rs = get_remote_state (); 6114 char *buf; 6115 6116 rs->last_sent_signal = siggnal; 6117 rs->last_sent_step = step; 6118 6119 /* The c/s/C/S resume packets use Hc, so set the continue 6120 thread. */ 6121 if (ptid == minus_one_ptid) 6122 set_continue_thread (any_thread_ptid); 6123 else 6124 set_continue_thread (ptid); 6125 6126 for (thread_info *thread : all_non_exited_threads ()) 6127 resume_clear_thread_private_info (thread); 6128 6129 buf = rs->buf.data (); 6130 if (::execution_direction == EXEC_REVERSE) 6131 { 6132 /* We don't pass signals to the target in reverse exec mode. */ 6133 if (info_verbose && siggnal != GDB_SIGNAL_0) 6134 warning (_(" - Can't pass signal %d to target in reverse: ignored."), 6135 siggnal); 6136 6137 if (step && packet_support (PACKET_bs) == PACKET_DISABLE) 6138 error (_("Remote reverse-step not supported.")); 6139 if (!step && packet_support (PACKET_bc) == PACKET_DISABLE) 6140 error (_("Remote reverse-continue not supported.")); 6141 6142 strcpy (buf, step ? "bs" : "bc"); 6143 } 6144 else if (siggnal != GDB_SIGNAL_0) 6145 { 6146 buf[0] = step ? 'S' : 'C'; 6147 buf[1] = tohex (((int) siggnal >> 4) & 0xf); 6148 buf[2] = tohex (((int) siggnal) & 0xf); 6149 buf[3] = '\0'; 6150 } 6151 else 6152 strcpy (buf, step ? "s" : "c"); 6153 6154 putpkt (buf); 6155} 6156 6157/* Resume the remote inferior by using a "vCont" packet. The thread 6158 to be resumed is PTID; STEP and SIGGNAL indicate whether the 6159 resumed thread should be single-stepped and/or signalled. If PTID 6160 equals minus_one_ptid, then all threads are resumed; the thread to 6161 be stepped and/or signalled is given in the global INFERIOR_PTID. 6162 This function returns non-zero iff it resumes the inferior. 6163 6164 This function issues a strict subset of all possible vCont commands 6165 at the moment. */ 6166 6167int 6168remote_target::remote_resume_with_vcont (ptid_t ptid, int step, 6169 enum gdb_signal siggnal) 6170{ 6171 struct remote_state *rs = get_remote_state (); 6172 char *p; 6173 char *endp; 6174 6175 /* No reverse execution actions defined for vCont. */ 6176 if (::execution_direction == EXEC_REVERSE) 6177 return 0; 6178 6179 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN) 6180 remote_vcont_probe (); 6181 6182 if (packet_support (PACKET_vCont) == PACKET_DISABLE) 6183 return 0; 6184 6185 p = rs->buf.data (); 6186 endp = p + get_remote_packet_size (); 6187 6188 /* If we could generate a wider range of packets, we'd have to worry 6189 about overflowing BUF. Should there be a generic 6190 "multi-part-packet" packet? */ 6191 6192 p += xsnprintf (p, endp - p, "vCont"); 6193 6194 if (ptid == magic_null_ptid) 6195 { 6196 /* MAGIC_NULL_PTID means that we don't have any active threads, 6197 so we don't have any TID numbers the inferior will 6198 understand. Make sure to only send forms that do not specify 6199 a TID. */ 6200 append_resumption (p, endp, minus_one_ptid, step, siggnal); 6201 } 6202 else if (ptid == minus_one_ptid || ptid.is_pid ()) 6203 { 6204 /* Resume all threads (of all processes, or of a single 6205 process), with preference for INFERIOR_PTID. This assumes 6206 inferior_ptid belongs to the set of all threads we are about 6207 to resume. */ 6208 if (step || siggnal != GDB_SIGNAL_0) 6209 { 6210 /* Step inferior_ptid, with or without signal. */ 6211 p = append_resumption (p, endp, inferior_ptid, step, siggnal); 6212 } 6213 6214 /* Also pass down any pending signaled resumption for other 6215 threads not the current. */ 6216 p = append_pending_thread_resumptions (p, endp, ptid); 6217 6218 /* And continue others without a signal. */ 6219 append_resumption (p, endp, ptid, /*step=*/ 0, GDB_SIGNAL_0); 6220 } 6221 else 6222 { 6223 /* Scheduler locking; resume only PTID. */ 6224 append_resumption (p, endp, ptid, step, siggnal); 6225 } 6226 6227 gdb_assert (strlen (rs->buf.data ()) < get_remote_packet_size ()); 6228 putpkt (rs->buf); 6229 6230 if (target_is_non_stop_p ()) 6231 { 6232 /* In non-stop, the stub replies to vCont with "OK". The stop 6233 reply will be reported asynchronously by means of a `%Stop' 6234 notification. */ 6235 getpkt (&rs->buf, 0); 6236 if (strcmp (rs->buf.data (), "OK") != 0) 6237 error (_("Unexpected vCont reply in non-stop mode: %s"), 6238 rs->buf.data ()); 6239 } 6240 6241 return 1; 6242} 6243 6244/* Tell the remote machine to resume. */ 6245 6246void 6247remote_target::resume (ptid_t ptid, int step, enum gdb_signal siggnal) 6248{ 6249 struct remote_state *rs = get_remote_state (); 6250 6251 /* When connected in non-stop mode, the core resumes threads 6252 individually. Resuming remote threads directly in target_resume 6253 would thus result in sending one packet per thread. Instead, to 6254 minimize roundtrip latency, here we just store the resume 6255 request; the actual remote resumption will be done in 6256 target_commit_resume / remote_commit_resume, where we'll be able 6257 to do vCont action coalescing. */ 6258 if (target_is_non_stop_p () && ::execution_direction != EXEC_REVERSE) 6259 { 6260 remote_thread_info *remote_thr; 6261 6262 if (minus_one_ptid == ptid || ptid.is_pid ()) 6263 remote_thr = get_remote_thread_info (inferior_ptid); 6264 else 6265 remote_thr = get_remote_thread_info (ptid); 6266 6267 remote_thr->last_resume_step = step; 6268 remote_thr->last_resume_sig = siggnal; 6269 return; 6270 } 6271 6272 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN 6273 (explained in remote-notif.c:handle_notification) so 6274 remote_notif_process is not called. We need find a place where 6275 it is safe to start a 'vNotif' sequence. It is good to do it 6276 before resuming inferior, because inferior was stopped and no RSP 6277 traffic at that moment. */ 6278 if (!target_is_non_stop_p ()) 6279 remote_notif_process (rs->notif_state, ¬if_client_stop); 6280 6281 rs->last_resume_exec_dir = ::execution_direction; 6282 6283 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */ 6284 if (!remote_resume_with_vcont (ptid, step, siggnal)) 6285 remote_resume_with_hc (ptid, step, siggnal); 6286 6287 /* We are about to start executing the inferior, let's register it 6288 with the event loop. NOTE: this is the one place where all the 6289 execution commands end up. We could alternatively do this in each 6290 of the execution commands in infcmd.c. */ 6291 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here 6292 into infcmd.c in order to allow inferior function calls to work 6293 NOT asynchronously. */ 6294 if (target_can_async_p ()) 6295 target_async (1); 6296 6297 /* We've just told the target to resume. The remote server will 6298 wait for the inferior to stop, and then send a stop reply. In 6299 the mean time, we can't start another command/query ourselves 6300 because the stub wouldn't be ready to process it. This applies 6301 only to the base all-stop protocol, however. In non-stop (which 6302 only supports vCont), the stub replies with an "OK", and is 6303 immediate able to process further serial input. */ 6304 if (!target_is_non_stop_p ()) 6305 rs->waiting_for_stop_reply = 1; 6306} 6307 6308static int is_pending_fork_parent_thread (struct thread_info *thread); 6309 6310/* Private per-inferior info for target remote processes. */ 6311 6312struct remote_inferior : public private_inferior 6313{ 6314 /* Whether we can send a wildcard vCont for this process. */ 6315 bool may_wildcard_vcont = true; 6316}; 6317 6318/* Get the remote private inferior data associated to INF. */ 6319 6320static remote_inferior * 6321get_remote_inferior (inferior *inf) 6322{ 6323 if (inf->priv == NULL) 6324 inf->priv.reset (new remote_inferior); 6325 6326 return static_cast<remote_inferior *> (inf->priv.get ()); 6327} 6328 6329/* Class used to track the construction of a vCont packet in the 6330 outgoing packet buffer. This is used to send multiple vCont 6331 packets if we have more actions than would fit a single packet. */ 6332 6333class vcont_builder 6334{ 6335public: 6336 explicit vcont_builder (remote_target *remote) 6337 : m_remote (remote) 6338 { 6339 restart (); 6340 } 6341 6342 void flush (); 6343 void push_action (ptid_t ptid, bool step, gdb_signal siggnal); 6344 6345private: 6346 void restart (); 6347 6348 /* The remote target. */ 6349 remote_target *m_remote; 6350 6351 /* Pointer to the first action. P points here if no action has been 6352 appended yet. */ 6353 char *m_first_action; 6354 6355 /* Where the next action will be appended. */ 6356 char *m_p; 6357 6358 /* The end of the buffer. Must never write past this. */ 6359 char *m_endp; 6360}; 6361 6362/* Prepare the outgoing buffer for a new vCont packet. */ 6363 6364void 6365vcont_builder::restart () 6366{ 6367 struct remote_state *rs = m_remote->get_remote_state (); 6368 6369 m_p = rs->buf.data (); 6370 m_endp = m_p + m_remote->get_remote_packet_size (); 6371 m_p += xsnprintf (m_p, m_endp - m_p, "vCont"); 6372 m_first_action = m_p; 6373} 6374 6375/* If the vCont packet being built has any action, send it to the 6376 remote end. */ 6377 6378void 6379vcont_builder::flush () 6380{ 6381 struct remote_state *rs; 6382 6383 if (m_p == m_first_action) 6384 return; 6385 6386 rs = m_remote->get_remote_state (); 6387 m_remote->putpkt (rs->buf); 6388 m_remote->getpkt (&rs->buf, 0); 6389 if (strcmp (rs->buf.data (), "OK") != 0) 6390 error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf.data ()); 6391} 6392 6393/* The largest action is range-stepping, with its two addresses. This 6394 is more than sufficient. If a new, bigger action is created, it'll 6395 quickly trigger a failed assertion in append_resumption (and we'll 6396 just bump this). */ 6397#define MAX_ACTION_SIZE 200 6398 6399/* Append a new vCont action in the outgoing packet being built. If 6400 the action doesn't fit the packet along with previous actions, push 6401 what we've got so far to the remote end and start over a new vCont 6402 packet (with the new action). */ 6403 6404void 6405vcont_builder::push_action (ptid_t ptid, bool step, gdb_signal siggnal) 6406{ 6407 char buf[MAX_ACTION_SIZE + 1]; 6408 6409 char *endp = m_remote->append_resumption (buf, buf + sizeof (buf), 6410 ptid, step, siggnal); 6411 6412 /* Check whether this new action would fit in the vCont packet along 6413 with previous actions. If not, send what we've got so far and 6414 start a new vCont packet. */ 6415 size_t rsize = endp - buf; 6416 if (rsize > m_endp - m_p) 6417 { 6418 flush (); 6419 restart (); 6420 6421 /* Should now fit. */ 6422 gdb_assert (rsize <= m_endp - m_p); 6423 } 6424 6425 memcpy (m_p, buf, rsize); 6426 m_p += rsize; 6427 *m_p = '\0'; 6428} 6429 6430/* to_commit_resume implementation. */ 6431 6432void 6433remote_target::commit_resume () 6434{ 6435 int any_process_wildcard; 6436 int may_global_wildcard_vcont; 6437 6438 /* If connected in all-stop mode, we'd send the remote resume 6439 request directly from remote_resume. Likewise if 6440 reverse-debugging, as there are no defined vCont actions for 6441 reverse execution. */ 6442 if (!target_is_non_stop_p () || ::execution_direction == EXEC_REVERSE) 6443 return; 6444 6445 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1") 6446 instead of resuming all threads of each process individually. 6447 However, if any thread of a process must remain halted, we can't 6448 send wildcard resumes and must send one action per thread. 6449 6450 Care must be taken to not resume threads/processes the server 6451 side already told us are stopped, but the core doesn't know about 6452 yet, because the events are still in the vStopped notification 6453 queue. For example: 6454 6455 #1 => vCont s:p1.1;c 6456 #2 <= OK 6457 #3 <= %Stopped T05 p1.1 6458 #4 => vStopped 6459 #5 <= T05 p1.2 6460 #6 => vStopped 6461 #7 <= OK 6462 #8 (infrun handles the stop for p1.1 and continues stepping) 6463 #9 => vCont s:p1.1;c 6464 6465 The last vCont above would resume thread p1.2 by mistake, because 6466 the server has no idea that the event for p1.2 had not been 6467 handled yet. 6468 6469 The server side must similarly ignore resume actions for the 6470 thread that has a pending %Stopped notification (and any other 6471 threads with events pending), until GDB acks the notification 6472 with vStopped. Otherwise, e.g., the following case is 6473 mishandled: 6474 6475 #1 => g (or any other packet) 6476 #2 <= [registers] 6477 #3 <= %Stopped T05 p1.2 6478 #4 => vCont s:p1.1;c 6479 #5 <= OK 6480 6481 Above, the server must not resume thread p1.2. GDB can't know 6482 that p1.2 stopped until it acks the %Stopped notification, and 6483 since from GDB's perspective all threads should be running, it 6484 sends a "c" action. 6485 6486 Finally, special care must also be given to handling fork/vfork 6487 events. A (v)fork event actually tells us that two processes 6488 stopped -- the parent and the child. Until we follow the fork, 6489 we must not resume the child. Therefore, if we have a pending 6490 fork follow, we must not send a global wildcard resume action 6491 (vCont;c). We can still send process-wide wildcards though. */ 6492 6493 /* Start by assuming a global wildcard (vCont;c) is possible. */ 6494 may_global_wildcard_vcont = 1; 6495 6496 /* And assume every process is individually wildcard-able too. */ 6497 for (inferior *inf : all_non_exited_inferiors ()) 6498 { 6499 remote_inferior *priv = get_remote_inferior (inf); 6500 6501 priv->may_wildcard_vcont = true; 6502 } 6503 6504 /* Check for any pending events (not reported or processed yet) and 6505 disable process and global wildcard resumes appropriately. */ 6506 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont); 6507 6508 for (thread_info *tp : all_non_exited_threads ()) 6509 { 6510 /* If a thread of a process is not meant to be resumed, then we 6511 can't wildcard that process. */ 6512 if (!tp->executing) 6513 { 6514 get_remote_inferior (tp->inf)->may_wildcard_vcont = false; 6515 6516 /* And if we can't wildcard a process, we can't wildcard 6517 everything either. */ 6518 may_global_wildcard_vcont = 0; 6519 continue; 6520 } 6521 6522 /* If a thread is the parent of an unfollowed fork, then we 6523 can't do a global wildcard, as that would resume the fork 6524 child. */ 6525 if (is_pending_fork_parent_thread (tp)) 6526 may_global_wildcard_vcont = 0; 6527 } 6528 6529 /* Now let's build the vCont packet(s). Actions must be appended 6530 from narrower to wider scopes (thread -> process -> global). If 6531 we end up with too many actions for a single packet vcont_builder 6532 flushes the current vCont packet to the remote side and starts a 6533 new one. */ 6534 struct vcont_builder vcont_builder (this); 6535 6536 /* Threads first. */ 6537 for (thread_info *tp : all_non_exited_threads ()) 6538 { 6539 remote_thread_info *remote_thr = get_remote_thread_info (tp); 6540 6541 if (!tp->executing || remote_thr->vcont_resumed) 6542 continue; 6543 6544 gdb_assert (!thread_is_in_step_over_chain (tp)); 6545 6546 if (!remote_thr->last_resume_step 6547 && remote_thr->last_resume_sig == GDB_SIGNAL_0 6548 && get_remote_inferior (tp->inf)->may_wildcard_vcont) 6549 { 6550 /* We'll send a wildcard resume instead. */ 6551 remote_thr->vcont_resumed = 1; 6552 continue; 6553 } 6554 6555 vcont_builder.push_action (tp->ptid, 6556 remote_thr->last_resume_step, 6557 remote_thr->last_resume_sig); 6558 remote_thr->vcont_resumed = 1; 6559 } 6560 6561 /* Now check whether we can send any process-wide wildcard. This is 6562 to avoid sending a global wildcard in the case nothing is 6563 supposed to be resumed. */ 6564 any_process_wildcard = 0; 6565 6566 for (inferior *inf : all_non_exited_inferiors ()) 6567 { 6568 if (get_remote_inferior (inf)->may_wildcard_vcont) 6569 { 6570 any_process_wildcard = 1; 6571 break; 6572 } 6573 } 6574 6575 if (any_process_wildcard) 6576 { 6577 /* If all processes are wildcard-able, then send a single "c" 6578 action, otherwise, send an "all (-1) threads of process" 6579 continue action for each running process, if any. */ 6580 if (may_global_wildcard_vcont) 6581 { 6582 vcont_builder.push_action (minus_one_ptid, 6583 false, GDB_SIGNAL_0); 6584 } 6585 else 6586 { 6587 for (inferior *inf : all_non_exited_inferiors ()) 6588 { 6589 if (get_remote_inferior (inf)->may_wildcard_vcont) 6590 { 6591 vcont_builder.push_action (ptid_t (inf->pid), 6592 false, GDB_SIGNAL_0); 6593 } 6594 } 6595 } 6596 } 6597 6598 vcont_builder.flush (); 6599} 6600 6601 6602 6603/* Non-stop version of target_stop. Uses `vCont;t' to stop a remote 6604 thread, all threads of a remote process, or all threads of all 6605 processes. */ 6606 6607void 6608remote_target::remote_stop_ns (ptid_t ptid) 6609{ 6610 struct remote_state *rs = get_remote_state (); 6611 char *p = rs->buf.data (); 6612 char *endp = p + get_remote_packet_size (); 6613 6614 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN) 6615 remote_vcont_probe (); 6616 6617 if (!rs->supports_vCont.t) 6618 error (_("Remote server does not support stopping threads")); 6619 6620 if (ptid == minus_one_ptid 6621 || (!remote_multi_process_p (rs) && ptid.is_pid ())) 6622 p += xsnprintf (p, endp - p, "vCont;t"); 6623 else 6624 { 6625 ptid_t nptid; 6626 6627 p += xsnprintf (p, endp - p, "vCont;t:"); 6628 6629 if (ptid.is_pid ()) 6630 /* All (-1) threads of process. */ 6631 nptid = ptid_t (ptid.pid (), -1, 0); 6632 else 6633 { 6634 /* Small optimization: if we already have a stop reply for 6635 this thread, no use in telling the stub we want this 6636 stopped. */ 6637 if (peek_stop_reply (ptid)) 6638 return; 6639 6640 nptid = ptid; 6641 } 6642 6643 write_ptid (p, endp, nptid); 6644 } 6645 6646 /* In non-stop, we get an immediate OK reply. The stop reply will 6647 come in asynchronously by notification. */ 6648 putpkt (rs->buf); 6649 getpkt (&rs->buf, 0); 6650 if (strcmp (rs->buf.data (), "OK") != 0) 6651 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid), 6652 rs->buf.data ()); 6653} 6654 6655/* All-stop version of target_interrupt. Sends a break or a ^C to 6656 interrupt the remote target. It is undefined which thread of which 6657 process reports the interrupt. */ 6658 6659void 6660remote_target::remote_interrupt_as () 6661{ 6662 struct remote_state *rs = get_remote_state (); 6663 6664 rs->ctrlc_pending_p = 1; 6665 6666 /* If the inferior is stopped already, but the core didn't know 6667 about it yet, just ignore the request. The cached wait status 6668 will be collected in remote_wait. */ 6669 if (rs->cached_wait_status) 6670 return; 6671 6672 /* Send interrupt_sequence to remote target. */ 6673 send_interrupt_sequence (); 6674} 6675 6676/* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt 6677 the remote target. It is undefined which thread of which process 6678 reports the interrupt. Throws an error if the packet is not 6679 supported by the server. */ 6680 6681void 6682remote_target::remote_interrupt_ns () 6683{ 6684 struct remote_state *rs = get_remote_state (); 6685 char *p = rs->buf.data (); 6686 char *endp = p + get_remote_packet_size (); 6687 6688 xsnprintf (p, endp - p, "vCtrlC"); 6689 6690 /* In non-stop, we get an immediate OK reply. The stop reply will 6691 come in asynchronously by notification. */ 6692 putpkt (rs->buf); 6693 getpkt (&rs->buf, 0); 6694 6695 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCtrlC])) 6696 { 6697 case PACKET_OK: 6698 break; 6699 case PACKET_UNKNOWN: 6700 error (_("No support for interrupting the remote target.")); 6701 case PACKET_ERROR: 6702 error (_("Interrupting target failed: %s"), rs->buf.data ()); 6703 } 6704} 6705 6706/* Implement the to_stop function for the remote targets. */ 6707 6708void 6709remote_target::stop (ptid_t ptid) 6710{ 6711 if (remote_debug) 6712 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n"); 6713 6714 if (target_is_non_stop_p ()) 6715 remote_stop_ns (ptid); 6716 else 6717 { 6718 /* We don't currently have a way to transparently pause the 6719 remote target in all-stop mode. Interrupt it instead. */ 6720 remote_interrupt_as (); 6721 } 6722} 6723 6724/* Implement the to_interrupt function for the remote targets. */ 6725 6726void 6727remote_target::interrupt () 6728{ 6729 if (remote_debug) 6730 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n"); 6731 6732 if (target_is_non_stop_p ()) 6733 remote_interrupt_ns (); 6734 else 6735 remote_interrupt_as (); 6736} 6737 6738/* Implement the to_pass_ctrlc function for the remote targets. */ 6739 6740void 6741remote_target::pass_ctrlc () 6742{ 6743 struct remote_state *rs = get_remote_state (); 6744 6745 if (remote_debug) 6746 fprintf_unfiltered (gdb_stdlog, "remote_pass_ctrlc called\n"); 6747 6748 /* If we're starting up, we're not fully synced yet. Quit 6749 immediately. */ 6750 if (rs->starting_up) 6751 quit (); 6752 /* If ^C has already been sent once, offer to disconnect. */ 6753 else if (rs->ctrlc_pending_p) 6754 interrupt_query (); 6755 else 6756 target_interrupt (); 6757} 6758 6759/* Ask the user what to do when an interrupt is received. */ 6760 6761void 6762remote_target::interrupt_query () 6763{ 6764 struct remote_state *rs = get_remote_state (); 6765 6766 if (rs->waiting_for_stop_reply && rs->ctrlc_pending_p) 6767 { 6768 if (query (_("The target is not responding to interrupt requests.\n" 6769 "Stop debugging it? "))) 6770 { 6771 remote_unpush_target (); 6772 throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target.")); 6773 } 6774 } 6775 else 6776 { 6777 if (query (_("Interrupted while waiting for the program.\n" 6778 "Give up waiting? "))) 6779 quit (); 6780 } 6781} 6782 6783/* Enable/disable target terminal ownership. Most targets can use 6784 terminal groups to control terminal ownership. Remote targets are 6785 different in that explicit transfer of ownership to/from GDB/target 6786 is required. */ 6787 6788void 6789remote_target::terminal_inferior () 6790{ 6791 /* NOTE: At this point we could also register our selves as the 6792 recipient of all input. Any characters typed could then be 6793 passed on down to the target. */ 6794} 6795 6796void 6797remote_target::terminal_ours () 6798{ 6799} 6800 6801static void 6802remote_console_output (const char *msg) 6803{ 6804 const char *p; 6805 6806 for (p = msg; p[0] && p[1]; p += 2) 6807 { 6808 char tb[2]; 6809 char c = fromhex (p[0]) * 16 + fromhex (p[1]); 6810 6811 tb[0] = c; 6812 tb[1] = 0; 6813 fputs_unfiltered (tb, gdb_stdtarg); 6814 } 6815 gdb_flush (gdb_stdtarg); 6816} 6817 6818DEF_VEC_O(cached_reg_t); 6819 6820typedef struct stop_reply 6821{ 6822 struct notif_event base; 6823 6824 /* The identifier of the thread about this event */ 6825 ptid_t ptid; 6826 6827 /* The remote state this event is associated with. When the remote 6828 connection, represented by a remote_state object, is closed, 6829 all the associated stop_reply events should be released. */ 6830 struct remote_state *rs; 6831 6832 struct target_waitstatus ws; 6833 6834 /* The architecture associated with the expedited registers. */ 6835 gdbarch *arch; 6836 6837 /* Expedited registers. This makes remote debugging a bit more 6838 efficient for those targets that provide critical registers as 6839 part of their normal status mechanism (as another roundtrip to 6840 fetch them is avoided). */ 6841 VEC(cached_reg_t) *regcache; 6842 6843 enum target_stop_reason stop_reason; 6844 6845 CORE_ADDR watch_data_address; 6846 6847 int core; 6848} *stop_reply_p; 6849 6850static void 6851stop_reply_xfree (struct stop_reply *r) 6852{ 6853 notif_event_xfree ((struct notif_event *) r); 6854} 6855 6856/* Return the length of the stop reply queue. */ 6857 6858int 6859remote_target::stop_reply_queue_length () 6860{ 6861 remote_state *rs = get_remote_state (); 6862 return rs->stop_reply_queue.size (); 6863} 6864 6865void 6866remote_notif_stop_parse (remote_target *remote, 6867 struct notif_client *self, const char *buf, 6868 struct notif_event *event) 6869{ 6870 remote->remote_parse_stop_reply (buf, (struct stop_reply *) event); 6871} 6872 6873static void 6874remote_notif_stop_ack (remote_target *remote, 6875 struct notif_client *self, const char *buf, 6876 struct notif_event *event) 6877{ 6878 struct stop_reply *stop_reply = (struct stop_reply *) event; 6879 6880 /* acknowledge */ 6881 putpkt (remote, self->ack_command); 6882 6883 if (stop_reply->ws.kind == TARGET_WAITKIND_IGNORE) 6884 { 6885 /* We got an unknown stop reply. */ 6886 error (_("Unknown stop reply")); 6887 } 6888 6889 remote->push_stop_reply (stop_reply); 6890} 6891 6892static int 6893remote_notif_stop_can_get_pending_events (remote_target *remote, 6894 struct notif_client *self) 6895{ 6896 /* We can't get pending events in remote_notif_process for 6897 notification stop, and we have to do this in remote_wait_ns 6898 instead. If we fetch all queued events from stub, remote stub 6899 may exit and we have no chance to process them back in 6900 remote_wait_ns. */ 6901 remote_state *rs = remote->get_remote_state (); 6902 mark_async_event_handler (rs->remote_async_inferior_event_token); 6903 return 0; 6904} 6905 6906static void 6907stop_reply_dtr (struct notif_event *event) 6908{ 6909 struct stop_reply *r = (struct stop_reply *) event; 6910 cached_reg_t *reg; 6911 int ix; 6912 6913 for (ix = 0; 6914 VEC_iterate (cached_reg_t, r->regcache, ix, reg); 6915 ix++) 6916 xfree (reg->data); 6917 6918 VEC_free (cached_reg_t, r->regcache); 6919} 6920 6921static struct notif_event * 6922remote_notif_stop_alloc_reply (void) 6923{ 6924 /* We cast to a pointer to the "base class". */ 6925 struct notif_event *r = (struct notif_event *) XNEW (struct stop_reply); 6926 6927 r->dtr = stop_reply_dtr; 6928 6929 return r; 6930} 6931 6932/* A client of notification Stop. */ 6933 6934struct notif_client notif_client_stop = 6935{ 6936 "Stop", 6937 "vStopped", 6938 remote_notif_stop_parse, 6939 remote_notif_stop_ack, 6940 remote_notif_stop_can_get_pending_events, 6941 remote_notif_stop_alloc_reply, 6942 REMOTE_NOTIF_STOP, 6943}; 6944 6945/* Determine if THREAD_PTID is a pending fork parent thread. ARG contains 6946 the pid of the process that owns the threads we want to check, or 6947 -1 if we want to check all threads. */ 6948 6949static int 6950is_pending_fork_parent (struct target_waitstatus *ws, int event_pid, 6951 ptid_t thread_ptid) 6952{ 6953 if (ws->kind == TARGET_WAITKIND_FORKED 6954 || ws->kind == TARGET_WAITKIND_VFORKED) 6955 { 6956 if (event_pid == -1 || event_pid == thread_ptid.pid ()) 6957 return 1; 6958 } 6959 6960 return 0; 6961} 6962 6963/* Return the thread's pending status used to determine whether the 6964 thread is a fork parent stopped at a fork event. */ 6965 6966static struct target_waitstatus * 6967thread_pending_fork_status (struct thread_info *thread) 6968{ 6969 if (thread->suspend.waitstatus_pending_p) 6970 return &thread->suspend.waitstatus; 6971 else 6972 return &thread->pending_follow; 6973} 6974 6975/* Determine if THREAD is a pending fork parent thread. */ 6976 6977static int 6978is_pending_fork_parent_thread (struct thread_info *thread) 6979{ 6980 struct target_waitstatus *ws = thread_pending_fork_status (thread); 6981 int pid = -1; 6982 6983 return is_pending_fork_parent (ws, pid, thread->ptid); 6984} 6985 6986/* If CONTEXT contains any fork child threads that have not been 6987 reported yet, remove them from the CONTEXT list. If such a 6988 thread exists it is because we are stopped at a fork catchpoint 6989 and have not yet called follow_fork, which will set up the 6990 host-side data structures for the new process. */ 6991 6992void 6993remote_target::remove_new_fork_children (threads_listing_context *context) 6994{ 6995 int pid = -1; 6996 struct notif_client *notif = ¬if_client_stop; 6997 6998 /* For any threads stopped at a fork event, remove the corresponding 6999 fork child threads from the CONTEXT list. */ 7000 for (thread_info *thread : all_non_exited_threads ()) 7001 { 7002 struct target_waitstatus *ws = thread_pending_fork_status (thread); 7003 7004 if (is_pending_fork_parent (ws, pid, thread->ptid)) 7005 context->remove_thread (ws->value.related_pid); 7006 } 7007 7008 /* Check for any pending fork events (not reported or processed yet) 7009 in process PID and remove those fork child threads from the 7010 CONTEXT list as well. */ 7011 remote_notif_get_pending_events (notif); 7012 for (auto &event : get_remote_state ()->stop_reply_queue) 7013 if (event->ws.kind == TARGET_WAITKIND_FORKED 7014 || event->ws.kind == TARGET_WAITKIND_VFORKED 7015 || event->ws.kind == TARGET_WAITKIND_THREAD_EXITED) 7016 context->remove_thread (event->ws.value.related_pid); 7017} 7018 7019/* Check whether any event pending in the vStopped queue would prevent 7020 a global or process wildcard vCont action. Clear 7021 *may_global_wildcard if we can't do a global wildcard (vCont;c), 7022 and clear the event inferior's may_wildcard_vcont flag if we can't 7023 do a process-wide wildcard resume (vCont;c:pPID.-1). */ 7024 7025void 7026remote_target::check_pending_events_prevent_wildcard_vcont 7027 (int *may_global_wildcard) 7028{ 7029 struct notif_client *notif = ¬if_client_stop; 7030 7031 remote_notif_get_pending_events (notif); 7032 for (auto &event : get_remote_state ()->stop_reply_queue) 7033 { 7034 if (event->ws.kind == TARGET_WAITKIND_NO_RESUMED 7035 || event->ws.kind == TARGET_WAITKIND_NO_HISTORY) 7036 continue; 7037 7038 if (event->ws.kind == TARGET_WAITKIND_FORKED 7039 || event->ws.kind == TARGET_WAITKIND_VFORKED) 7040 *may_global_wildcard = 0; 7041 7042 struct inferior *inf = find_inferior_ptid (event->ptid); 7043 7044 /* This may be the first time we heard about this process. 7045 Regardless, we must not do a global wildcard resume, otherwise 7046 we'd resume this process too. */ 7047 *may_global_wildcard = 0; 7048 if (inf != NULL) 7049 get_remote_inferior (inf)->may_wildcard_vcont = false; 7050 } 7051} 7052 7053/* Discard all pending stop replies of inferior INF. */ 7054 7055void 7056remote_target::discard_pending_stop_replies (struct inferior *inf) 7057{ 7058 struct stop_reply *reply; 7059 struct remote_state *rs = get_remote_state (); 7060 struct remote_notif_state *rns = rs->notif_state; 7061 7062 /* This function can be notified when an inferior exists. When the 7063 target is not remote, the notification state is NULL. */ 7064 if (rs->remote_desc == NULL) 7065 return; 7066 7067 reply = (struct stop_reply *) rns->pending_event[notif_client_stop.id]; 7068 7069 /* Discard the in-flight notification. */ 7070 if (reply != NULL && reply->ptid.pid () == inf->pid) 7071 { 7072 stop_reply_xfree (reply); 7073 rns->pending_event[notif_client_stop.id] = NULL; 7074 } 7075 7076 /* Discard the stop replies we have already pulled with 7077 vStopped. */ 7078 auto iter = std::remove_if (rs->stop_reply_queue.begin (), 7079 rs->stop_reply_queue.end (), 7080 [=] (const stop_reply_up &event) 7081 { 7082 return event->ptid.pid () == inf->pid; 7083 }); 7084 rs->stop_reply_queue.erase (iter, rs->stop_reply_queue.end ()); 7085} 7086 7087/* Discard the stop replies for RS in stop_reply_queue. */ 7088 7089void 7090remote_target::discard_pending_stop_replies_in_queue () 7091{ 7092 remote_state *rs = get_remote_state (); 7093 7094 /* Discard the stop replies we have already pulled with 7095 vStopped. */ 7096 auto iter = std::remove_if (rs->stop_reply_queue.begin (), 7097 rs->stop_reply_queue.end (), 7098 [=] (const stop_reply_up &event) 7099 { 7100 return event->rs == rs; 7101 }); 7102 rs->stop_reply_queue.erase (iter, rs->stop_reply_queue.end ()); 7103} 7104 7105/* Remove the first reply in 'stop_reply_queue' which matches 7106 PTID. */ 7107 7108struct stop_reply * 7109remote_target::remote_notif_remove_queued_reply (ptid_t ptid) 7110{ 7111 remote_state *rs = get_remote_state (); 7112 7113 auto iter = std::find_if (rs->stop_reply_queue.begin (), 7114 rs->stop_reply_queue.end (), 7115 [=] (const stop_reply_up &event) 7116 { 7117 return event->ptid.matches (ptid); 7118 }); 7119 struct stop_reply *result; 7120 if (iter == rs->stop_reply_queue.end ()) 7121 result = nullptr; 7122 else 7123 { 7124 result = iter->release (); 7125 rs->stop_reply_queue.erase (iter); 7126 } 7127 7128 if (notif_debug) 7129 fprintf_unfiltered (gdb_stdlog, 7130 "notif: discard queued event: 'Stop' in %s\n", 7131 target_pid_to_str (ptid)); 7132 7133 return result; 7134} 7135 7136/* Look for a queued stop reply belonging to PTID. If one is found, 7137 remove it from the queue, and return it. Returns NULL if none is 7138 found. If there are still queued events left to process, tell the 7139 event loop to get back to target_wait soon. */ 7140 7141struct stop_reply * 7142remote_target::queued_stop_reply (ptid_t ptid) 7143{ 7144 remote_state *rs = get_remote_state (); 7145 struct stop_reply *r = remote_notif_remove_queued_reply (ptid); 7146 7147 if (!rs->stop_reply_queue.empty ()) 7148 { 7149 /* There's still at least an event left. */ 7150 mark_async_event_handler (rs->remote_async_inferior_event_token); 7151 } 7152 7153 return r; 7154} 7155 7156/* Push a fully parsed stop reply in the stop reply queue. Since we 7157 know that we now have at least one queued event left to pass to the 7158 core side, tell the event loop to get back to target_wait soon. */ 7159 7160void 7161remote_target::push_stop_reply (struct stop_reply *new_event) 7162{ 7163 remote_state *rs = get_remote_state (); 7164 rs->stop_reply_queue.push_back (stop_reply_up (new_event)); 7165 7166 if (notif_debug) 7167 fprintf_unfiltered (gdb_stdlog, 7168 "notif: push 'Stop' %s to queue %d\n", 7169 target_pid_to_str (new_event->ptid), 7170 int (rs->stop_reply_queue.size ())); 7171 7172 mark_async_event_handler (rs->remote_async_inferior_event_token); 7173} 7174 7175/* Returns true if we have a stop reply for PTID. */ 7176 7177int 7178remote_target::peek_stop_reply (ptid_t ptid) 7179{ 7180 remote_state *rs = get_remote_state (); 7181 for (auto &event : rs->stop_reply_queue) 7182 if (ptid == event->ptid 7183 && event->ws.kind == TARGET_WAITKIND_STOPPED) 7184 return 1; 7185 return 0; 7186} 7187 7188/* Helper for remote_parse_stop_reply. Return nonzero if the substring 7189 starting with P and ending with PEND matches PREFIX. */ 7190 7191static int 7192strprefix (const char *p, const char *pend, const char *prefix) 7193{ 7194 for ( ; p < pend; p++, prefix++) 7195 if (*p != *prefix) 7196 return 0; 7197 return *prefix == '\0'; 7198} 7199 7200/* Parse the stop reply in BUF. Either the function succeeds, and the 7201 result is stored in EVENT, or throws an error. */ 7202 7203void 7204remote_target::remote_parse_stop_reply (const char *buf, stop_reply *event) 7205{ 7206 remote_arch_state *rsa = NULL; 7207 ULONGEST addr; 7208 const char *p; 7209 int skipregs = 0; 7210 7211 event->ptid = null_ptid; 7212 event->rs = get_remote_state (); 7213 event->ws.kind = TARGET_WAITKIND_IGNORE; 7214 event->ws.value.integer = 0; 7215 event->stop_reason = TARGET_STOPPED_BY_NO_REASON; 7216 event->regcache = NULL; 7217 event->core = -1; 7218 7219 switch (buf[0]) 7220 { 7221 case 'T': /* Status with PC, SP, FP, ... */ 7222 /* Expedited reply, containing Signal, {regno, reg} repeat. */ 7223 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where 7224 ss = signal number 7225 n... = register number 7226 r... = register contents 7227 */ 7228 7229 p = &buf[3]; /* after Txx */ 7230 while (*p) 7231 { 7232 const char *p1; 7233 int fieldsize; 7234 7235 p1 = strchr (p, ':'); 7236 if (p1 == NULL) 7237 error (_("Malformed packet(a) (missing colon): %s\n\ 7238Packet: '%s'\n"), 7239 p, buf); 7240 if (p == p1) 7241 error (_("Malformed packet(a) (missing register number): %s\n\ 7242Packet: '%s'\n"), 7243 p, buf); 7244 7245 /* Some "registers" are actually extended stop information. 7246 Note if you're adding a new entry here: GDB 7.9 and 7247 earlier assume that all register "numbers" that start 7248 with an hex digit are real register numbers. Make sure 7249 the server only sends such a packet if it knows the 7250 client understands it. */ 7251 7252 if (strprefix (p, p1, "thread")) 7253 event->ptid = read_ptid (++p1, &p); 7254 else if (strprefix (p, p1, "syscall_entry")) 7255 { 7256 ULONGEST sysno; 7257 7258 event->ws.kind = TARGET_WAITKIND_SYSCALL_ENTRY; 7259 p = unpack_varlen_hex (++p1, &sysno); 7260 event->ws.value.syscall_number = (int) sysno; 7261 } 7262 else if (strprefix (p, p1, "syscall_return")) 7263 { 7264 ULONGEST sysno; 7265 7266 event->ws.kind = TARGET_WAITKIND_SYSCALL_RETURN; 7267 p = unpack_varlen_hex (++p1, &sysno); 7268 event->ws.value.syscall_number = (int) sysno; 7269 } 7270 else if (strprefix (p, p1, "watch") 7271 || strprefix (p, p1, "rwatch") 7272 || strprefix (p, p1, "awatch")) 7273 { 7274 event->stop_reason = TARGET_STOPPED_BY_WATCHPOINT; 7275 p = unpack_varlen_hex (++p1, &addr); 7276 event->watch_data_address = (CORE_ADDR) addr; 7277 } 7278 else if (strprefix (p, p1, "swbreak")) 7279 { 7280 event->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT; 7281 7282 /* Make sure the stub doesn't forget to indicate support 7283 with qSupported. */ 7284 if (packet_support (PACKET_swbreak_feature) != PACKET_ENABLE) 7285 error (_("Unexpected swbreak stop reason")); 7286 7287 /* The value part is documented as "must be empty", 7288 though we ignore it, in case we ever decide to make 7289 use of it in a backward compatible way. */ 7290 p = strchrnul (p1 + 1, ';'); 7291 } 7292 else if (strprefix (p, p1, "hwbreak")) 7293 { 7294 event->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT; 7295 7296 /* Make sure the stub doesn't forget to indicate support 7297 with qSupported. */ 7298 if (packet_support (PACKET_hwbreak_feature) != PACKET_ENABLE) 7299 error (_("Unexpected hwbreak stop reason")); 7300 7301 /* See above. */ 7302 p = strchrnul (p1 + 1, ';'); 7303 } 7304 else if (strprefix (p, p1, "library")) 7305 { 7306 event->ws.kind = TARGET_WAITKIND_LOADED; 7307 p = strchrnul (p1 + 1, ';'); 7308 } 7309 else if (strprefix (p, p1, "replaylog")) 7310 { 7311 event->ws.kind = TARGET_WAITKIND_NO_HISTORY; 7312 /* p1 will indicate "begin" or "end", but it makes 7313 no difference for now, so ignore it. */ 7314 p = strchrnul (p1 + 1, ';'); 7315 } 7316 else if (strprefix (p, p1, "core")) 7317 { 7318 ULONGEST c; 7319 7320 p = unpack_varlen_hex (++p1, &c); 7321 event->core = c; 7322 } 7323 else if (strprefix (p, p1, "fork")) 7324 { 7325 event->ws.value.related_pid = read_ptid (++p1, &p); 7326 event->ws.kind = TARGET_WAITKIND_FORKED; 7327 } 7328 else if (strprefix (p, p1, "vfork")) 7329 { 7330 event->ws.value.related_pid = read_ptid (++p1, &p); 7331 event->ws.kind = TARGET_WAITKIND_VFORKED; 7332 } 7333 else if (strprefix (p, p1, "vforkdone")) 7334 { 7335 event->ws.kind = TARGET_WAITKIND_VFORK_DONE; 7336 p = strchrnul (p1 + 1, ';'); 7337 } 7338 else if (strprefix (p, p1, "exec")) 7339 { 7340 ULONGEST ignored; 7341 int pathlen; 7342 7343 /* Determine the length of the execd pathname. */ 7344 p = unpack_varlen_hex (++p1, &ignored); 7345 pathlen = (p - p1) / 2; 7346 7347 /* Save the pathname for event reporting and for 7348 the next run command. */ 7349 char *pathname = (char *) xmalloc (pathlen + 1); 7350 struct cleanup *old_chain = make_cleanup (xfree, pathname); 7351 hex2bin (p1, (gdb_byte *) pathname, pathlen); 7352 pathname[pathlen] = '\0'; 7353 discard_cleanups (old_chain); 7354 7355 /* This is freed during event handling. */ 7356 event->ws.value.execd_pathname = pathname; 7357 event->ws.kind = TARGET_WAITKIND_EXECD; 7358 7359 /* Skip the registers included in this packet, since 7360 they may be for an architecture different from the 7361 one used by the original program. */ 7362 skipregs = 1; 7363 } 7364 else if (strprefix (p, p1, "create")) 7365 { 7366 event->ws.kind = TARGET_WAITKIND_THREAD_CREATED; 7367 p = strchrnul (p1 + 1, ';'); 7368 } 7369 else 7370 { 7371 ULONGEST pnum; 7372 const char *p_temp; 7373 7374 if (skipregs) 7375 { 7376 p = strchrnul (p1 + 1, ';'); 7377 p++; 7378 continue; 7379 } 7380 7381 /* Maybe a real ``P'' register number. */ 7382 p_temp = unpack_varlen_hex (p, &pnum); 7383 /* If the first invalid character is the colon, we got a 7384 register number. Otherwise, it's an unknown stop 7385 reason. */ 7386 if (p_temp == p1) 7387 { 7388 /* If we haven't parsed the event's thread yet, find 7389 it now, in order to find the architecture of the 7390 reported expedited registers. */ 7391 if (event->ptid == null_ptid) 7392 { 7393 const char *thr = strstr (p1 + 1, ";thread:"); 7394 if (thr != NULL) 7395 event->ptid = read_ptid (thr + strlen (";thread:"), 7396 NULL); 7397 else 7398 { 7399 /* Either the current thread hasn't changed, 7400 or the inferior is not multi-threaded. 7401 The event must be for the thread we last 7402 set as (or learned as being) current. */ 7403 event->ptid = event->rs->general_thread; 7404 } 7405 } 7406 7407 if (rsa == NULL) 7408 { 7409 inferior *inf = (event->ptid == null_ptid 7410 ? NULL 7411 : find_inferior_ptid (event->ptid)); 7412 /* If this is the first time we learn anything 7413 about this process, skip the registers 7414 included in this packet, since we don't yet 7415 know which architecture to use to parse them. 7416 We'll determine the architecture later when 7417 we process the stop reply and retrieve the 7418 target description, via 7419 remote_notice_new_inferior -> 7420 post_create_inferior. */ 7421 if (inf == NULL) 7422 { 7423 p = strchrnul (p1 + 1, ';'); 7424 p++; 7425 continue; 7426 } 7427 7428 event->arch = inf->gdbarch; 7429 rsa = event->rs->get_remote_arch_state (event->arch); 7430 } 7431 7432 packet_reg *reg 7433 = packet_reg_from_pnum (event->arch, rsa, pnum); 7434 cached_reg_t cached_reg; 7435 7436 if (reg == NULL) 7437 error (_("Remote sent bad register number %s: %s\n\ 7438Packet: '%s'\n"), 7439 hex_string (pnum), p, buf); 7440 7441 cached_reg.num = reg->regnum; 7442 cached_reg.data = (gdb_byte *) 7443 xmalloc (register_size (event->arch, reg->regnum)); 7444 7445 p = p1 + 1; 7446 fieldsize = hex2bin (p, cached_reg.data, 7447 register_size (event->arch, reg->regnum)); 7448 p += 2 * fieldsize; 7449 if (fieldsize < register_size (event->arch, reg->regnum)) 7450 warning (_("Remote reply is too short: %s"), buf); 7451 7452 VEC_safe_push (cached_reg_t, event->regcache, &cached_reg); 7453 } 7454 else 7455 { 7456 /* Not a number. Silently skip unknown optional 7457 info. */ 7458 p = strchrnul (p1 + 1, ';'); 7459 } 7460 } 7461 7462 if (*p != ';') 7463 error (_("Remote register badly formatted: %s\nhere: %s"), 7464 buf, p); 7465 ++p; 7466 } 7467 7468 if (event->ws.kind != TARGET_WAITKIND_IGNORE) 7469 break; 7470 7471 /* fall through */ 7472 case 'S': /* Old style status, just signal only. */ 7473 { 7474 int sig; 7475 7476 event->ws.kind = TARGET_WAITKIND_STOPPED; 7477 sig = (fromhex (buf[1]) << 4) + fromhex (buf[2]); 7478 if (GDB_SIGNAL_FIRST <= sig && sig < GDB_SIGNAL_LAST) 7479 event->ws.value.sig = (enum gdb_signal) sig; 7480 else 7481 event->ws.value.sig = GDB_SIGNAL_UNKNOWN; 7482 } 7483 break; 7484 case 'w': /* Thread exited. */ 7485 { 7486 ULONGEST value; 7487 7488 event->ws.kind = TARGET_WAITKIND_THREAD_EXITED; 7489 p = unpack_varlen_hex (&buf[1], &value); 7490 event->ws.value.integer = value; 7491 if (*p != ';') 7492 error (_("stop reply packet badly formatted: %s"), buf); 7493 event->ptid = read_ptid (++p, NULL); 7494 break; 7495 } 7496 case 'W': /* Target exited. */ 7497 case 'X': 7498 { 7499 int pid; 7500 ULONGEST value; 7501 7502 /* GDB used to accept only 2 hex chars here. Stubs should 7503 only send more if they detect GDB supports multi-process 7504 support. */ 7505 p = unpack_varlen_hex (&buf[1], &value); 7506 7507 if (buf[0] == 'W') 7508 { 7509 /* The remote process exited. */ 7510 event->ws.kind = TARGET_WAITKIND_EXITED; 7511 event->ws.value.integer = value; 7512 } 7513 else 7514 { 7515 /* The remote process exited with a signal. */ 7516 event->ws.kind = TARGET_WAITKIND_SIGNALLED; 7517 if (GDB_SIGNAL_FIRST <= value && value < GDB_SIGNAL_LAST) 7518 event->ws.value.sig = (enum gdb_signal) value; 7519 else 7520 event->ws.value.sig = GDB_SIGNAL_UNKNOWN; 7521 } 7522 7523 /* If no process is specified, assume inferior_ptid. */ 7524 pid = inferior_ptid.pid (); 7525 if (*p == '\0') 7526 ; 7527 else if (*p == ';') 7528 { 7529 p++; 7530 7531 if (*p == '\0') 7532 ; 7533 else if (startswith (p, "process:")) 7534 { 7535 ULONGEST upid; 7536 7537 p += sizeof ("process:") - 1; 7538 unpack_varlen_hex (p, &upid); 7539 pid = upid; 7540 } 7541 else 7542 error (_("unknown stop reply packet: %s"), buf); 7543 } 7544 else 7545 error (_("unknown stop reply packet: %s"), buf); 7546 event->ptid = ptid_t (pid); 7547 } 7548 break; 7549 case 'N': 7550 event->ws.kind = TARGET_WAITKIND_NO_RESUMED; 7551 event->ptid = minus_one_ptid; 7552 break; 7553 } 7554 7555 if (target_is_non_stop_p () && event->ptid == null_ptid) 7556 error (_("No process or thread specified in stop reply: %s"), buf); 7557} 7558 7559/* When the stub wants to tell GDB about a new notification reply, it 7560 sends a notification (%Stop, for example). Those can come it at 7561 any time, hence, we have to make sure that any pending 7562 putpkt/getpkt sequence we're making is finished, before querying 7563 the stub for more events with the corresponding ack command 7564 (vStopped, for example). E.g., if we started a vStopped sequence 7565 immediately upon receiving the notification, something like this 7566 could happen: 7567 7568 1.1) --> Hg 1 7569 1.2) <-- OK 7570 1.3) --> g 7571 1.4) <-- %Stop 7572 1.5) --> vStopped 7573 1.6) <-- (registers reply to step #1.3) 7574 7575 Obviously, the reply in step #1.6 would be unexpected to a vStopped 7576 query. 7577 7578 To solve this, whenever we parse a %Stop notification successfully, 7579 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on 7580 doing whatever we were doing: 7581 7582 2.1) --> Hg 1 7583 2.2) <-- OK 7584 2.3) --> g 7585 2.4) <-- %Stop 7586 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN> 7587 2.5) <-- (registers reply to step #2.3) 7588 7589 Eventualy after step #2.5, we return to the event loop, which 7590 notices there's an event on the 7591 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the 7592 associated callback --- the function below. At this point, we're 7593 always safe to start a vStopped sequence. : 7594 7595 2.6) --> vStopped 7596 2.7) <-- T05 thread:2 7597 2.8) --> vStopped 7598 2.9) --> OK 7599*/ 7600 7601void 7602remote_target::remote_notif_get_pending_events (notif_client *nc) 7603{ 7604 struct remote_state *rs = get_remote_state (); 7605 7606 if (rs->notif_state->pending_event[nc->id] != NULL) 7607 { 7608 if (notif_debug) 7609 fprintf_unfiltered (gdb_stdlog, 7610 "notif: process: '%s' ack pending event\n", 7611 nc->name); 7612 7613 /* acknowledge */ 7614 nc->ack (this, nc, rs->buf.data (), 7615 rs->notif_state->pending_event[nc->id]); 7616 rs->notif_state->pending_event[nc->id] = NULL; 7617 7618 while (1) 7619 { 7620 getpkt (&rs->buf, 0); 7621 if (strcmp (rs->buf.data (), "OK") == 0) 7622 break; 7623 else 7624 remote_notif_ack (this, nc, rs->buf.data ()); 7625 } 7626 } 7627 else 7628 { 7629 if (notif_debug) 7630 fprintf_unfiltered (gdb_stdlog, 7631 "notif: process: '%s' no pending reply\n", 7632 nc->name); 7633 } 7634} 7635 7636/* Wrapper around remote_target::remote_notif_get_pending_events to 7637 avoid having to export the whole remote_target class. */ 7638 7639void 7640remote_notif_get_pending_events (remote_target *remote, notif_client *nc) 7641{ 7642 remote->remote_notif_get_pending_events (nc); 7643} 7644 7645/* Called when it is decided that STOP_REPLY holds the info of the 7646 event that is to be returned to the core. This function always 7647 destroys STOP_REPLY. */ 7648 7649ptid_t 7650remote_target::process_stop_reply (struct stop_reply *stop_reply, 7651 struct target_waitstatus *status) 7652{ 7653 ptid_t ptid; 7654 7655 *status = stop_reply->ws; 7656 ptid = stop_reply->ptid; 7657 7658 /* If no thread/process was reported by the stub, assume the current 7659 inferior. */ 7660 if (ptid == null_ptid) 7661 ptid = inferior_ptid; 7662 7663 if (status->kind != TARGET_WAITKIND_EXITED 7664 && status->kind != TARGET_WAITKIND_SIGNALLED 7665 && status->kind != TARGET_WAITKIND_NO_RESUMED) 7666 { 7667 /* Expedited registers. */ 7668 if (stop_reply->regcache) 7669 { 7670 struct regcache *regcache 7671 = get_thread_arch_regcache (ptid, stop_reply->arch); 7672 cached_reg_t *reg; 7673 int ix; 7674 7675 for (ix = 0; 7676 VEC_iterate (cached_reg_t, stop_reply->regcache, ix, reg); 7677 ix++) 7678 { 7679 regcache->raw_supply (reg->num, reg->data); 7680 xfree (reg->data); 7681 } 7682 7683 VEC_free (cached_reg_t, stop_reply->regcache); 7684 } 7685 7686 remote_notice_new_inferior (ptid, 0); 7687 remote_thread_info *remote_thr = get_remote_thread_info (ptid); 7688 remote_thr->core = stop_reply->core; 7689 remote_thr->stop_reason = stop_reply->stop_reason; 7690 remote_thr->watch_data_address = stop_reply->watch_data_address; 7691 remote_thr->vcont_resumed = 0; 7692 } 7693 7694 stop_reply_xfree (stop_reply); 7695 return ptid; 7696} 7697 7698/* The non-stop mode version of target_wait. */ 7699 7700ptid_t 7701remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status, int options) 7702{ 7703 struct remote_state *rs = get_remote_state (); 7704 struct stop_reply *stop_reply; 7705 int ret; 7706 int is_notif = 0; 7707 7708 /* If in non-stop mode, get out of getpkt even if a 7709 notification is received. */ 7710 7711 ret = getpkt_or_notif_sane (&rs->buf, 0 /* forever */, &is_notif); 7712 while (1) 7713 { 7714 if (ret != -1 && !is_notif) 7715 switch (rs->buf[0]) 7716 { 7717 case 'E': /* Error of some sort. */ 7718 /* We're out of sync with the target now. Did it continue 7719 or not? We can't tell which thread it was in non-stop, 7720 so just ignore this. */ 7721 warning (_("Remote failure reply: %s"), rs->buf.data ()); 7722 break; 7723 case 'O': /* Console output. */ 7724 remote_console_output (&rs->buf[1]); 7725 break; 7726 default: 7727 warning (_("Invalid remote reply: %s"), rs->buf.data ()); 7728 break; 7729 } 7730 7731 /* Acknowledge a pending stop reply that may have arrived in the 7732 mean time. */ 7733 if (rs->notif_state->pending_event[notif_client_stop.id] != NULL) 7734 remote_notif_get_pending_events (¬if_client_stop); 7735 7736 /* If indeed we noticed a stop reply, we're done. */ 7737 stop_reply = queued_stop_reply (ptid); 7738 if (stop_reply != NULL) 7739 return process_stop_reply (stop_reply, status); 7740 7741 /* Still no event. If we're just polling for an event, then 7742 return to the event loop. */ 7743 if (options & TARGET_WNOHANG) 7744 { 7745 status->kind = TARGET_WAITKIND_IGNORE; 7746 return minus_one_ptid; 7747 } 7748 7749 /* Otherwise do a blocking wait. */ 7750 ret = getpkt_or_notif_sane (&rs->buf, 1 /* forever */, &is_notif); 7751 } 7752} 7753 7754/* Wait until the remote machine stops, then return, storing status in 7755 STATUS just as `wait' would. */ 7756 7757ptid_t 7758remote_target::wait_as (ptid_t ptid, target_waitstatus *status, int options) 7759{ 7760 struct remote_state *rs = get_remote_state (); 7761 ptid_t event_ptid = null_ptid; 7762 char *buf; 7763 struct stop_reply *stop_reply; 7764 7765 again: 7766 7767 status->kind = TARGET_WAITKIND_IGNORE; 7768 status->value.integer = 0; 7769 7770 stop_reply = queued_stop_reply (ptid); 7771 if (stop_reply != NULL) 7772 return process_stop_reply (stop_reply, status); 7773 7774 if (rs->cached_wait_status) 7775 /* Use the cached wait status, but only once. */ 7776 rs->cached_wait_status = 0; 7777 else 7778 { 7779 int ret; 7780 int is_notif; 7781 int forever = ((options & TARGET_WNOHANG) == 0 7782 && rs->wait_forever_enabled_p); 7783 7784 if (!rs->waiting_for_stop_reply) 7785 { 7786 status->kind = TARGET_WAITKIND_NO_RESUMED; 7787 return minus_one_ptid; 7788 } 7789 7790 /* FIXME: cagney/1999-09-27: If we're in async mode we should 7791 _never_ wait for ever -> test on target_is_async_p(). 7792 However, before we do that we need to ensure that the caller 7793 knows how to take the target into/out of async mode. */ 7794 ret = getpkt_or_notif_sane (&rs->buf, forever, &is_notif); 7795 7796 /* GDB gets a notification. Return to core as this event is 7797 not interesting. */ 7798 if (ret != -1 && is_notif) 7799 return minus_one_ptid; 7800 7801 if (ret == -1 && (options & TARGET_WNOHANG) != 0) 7802 return minus_one_ptid; 7803 } 7804 7805 buf = rs->buf.data (); 7806 7807 /* Assume that the target has acknowledged Ctrl-C unless we receive 7808 an 'F' or 'O' packet. */ 7809 if (buf[0] != 'F' && buf[0] != 'O') 7810 rs->ctrlc_pending_p = 0; 7811 7812 switch (buf[0]) 7813 { 7814 case 'E': /* Error of some sort. */ 7815 /* We're out of sync with the target now. Did it continue or 7816 not? Not is more likely, so report a stop. */ 7817 rs->waiting_for_stop_reply = 0; 7818 7819 warning (_("Remote failure reply: %s"), buf); 7820 status->kind = TARGET_WAITKIND_STOPPED; 7821 status->value.sig = GDB_SIGNAL_0; 7822 break; 7823 case 'F': /* File-I/O request. */ 7824 /* GDB may access the inferior memory while handling the File-I/O 7825 request, but we don't want GDB accessing memory while waiting 7826 for a stop reply. See the comments in putpkt_binary. Set 7827 waiting_for_stop_reply to 0 temporarily. */ 7828 rs->waiting_for_stop_reply = 0; 7829 remote_fileio_request (this, buf, rs->ctrlc_pending_p); 7830 rs->ctrlc_pending_p = 0; 7831 /* GDB handled the File-I/O request, and the target is running 7832 again. Keep waiting for events. */ 7833 rs->waiting_for_stop_reply = 1; 7834 break; 7835 case 'N': case 'T': case 'S': case 'X': case 'W': 7836 { 7837 /* There is a stop reply to handle. */ 7838 rs->waiting_for_stop_reply = 0; 7839 7840 stop_reply 7841 = (struct stop_reply *) remote_notif_parse (this, 7842 ¬if_client_stop, 7843 rs->buf.data ()); 7844 7845 event_ptid = process_stop_reply (stop_reply, status); 7846 break; 7847 } 7848 case 'O': /* Console output. */ 7849 remote_console_output (buf + 1); 7850 break; 7851 case '\0': 7852 if (rs->last_sent_signal != GDB_SIGNAL_0) 7853 { 7854 /* Zero length reply means that we tried 'S' or 'C' and the 7855 remote system doesn't support it. */ 7856 target_terminal::ours_for_output (); 7857 printf_filtered 7858 ("Can't send signals to this remote system. %s not sent.\n", 7859 gdb_signal_to_name (rs->last_sent_signal)); 7860 rs->last_sent_signal = GDB_SIGNAL_0; 7861 target_terminal::inferior (); 7862 7863 strcpy (buf, rs->last_sent_step ? "s" : "c"); 7864 putpkt (buf); 7865 break; 7866 } 7867 /* fallthrough */ 7868 default: 7869 warning (_("Invalid remote reply: %s"), buf); 7870 break; 7871 } 7872 7873 if (status->kind == TARGET_WAITKIND_NO_RESUMED) 7874 return minus_one_ptid; 7875 else if (status->kind == TARGET_WAITKIND_IGNORE) 7876 { 7877 /* Nothing interesting happened. If we're doing a non-blocking 7878 poll, we're done. Otherwise, go back to waiting. */ 7879 if (options & TARGET_WNOHANG) 7880 return minus_one_ptid; 7881 else 7882 goto again; 7883 } 7884 else if (status->kind != TARGET_WAITKIND_EXITED 7885 && status->kind != TARGET_WAITKIND_SIGNALLED) 7886 { 7887 if (event_ptid != null_ptid) 7888 record_currthread (rs, event_ptid); 7889 else 7890 event_ptid = inferior_ptid; 7891 } 7892 else 7893 /* A process exit. Invalidate our notion of current thread. */ 7894 record_currthread (rs, minus_one_ptid); 7895 7896 return event_ptid; 7897} 7898 7899/* Wait until the remote machine stops, then return, storing status in 7900 STATUS just as `wait' would. */ 7901 7902ptid_t 7903remote_target::wait (ptid_t ptid, struct target_waitstatus *status, int options) 7904{ 7905 ptid_t event_ptid; 7906 7907 if (target_is_non_stop_p ()) 7908 event_ptid = wait_ns (ptid, status, options); 7909 else 7910 event_ptid = wait_as (ptid, status, options); 7911 7912 if (target_is_async_p ()) 7913 { 7914 remote_state *rs = get_remote_state (); 7915 7916 /* If there are are events left in the queue tell the event loop 7917 to return here. */ 7918 if (!rs->stop_reply_queue.empty ()) 7919 mark_async_event_handler (rs->remote_async_inferior_event_token); 7920 } 7921 7922 return event_ptid; 7923} 7924 7925/* Fetch a single register using a 'p' packet. */ 7926 7927int 7928remote_target::fetch_register_using_p (struct regcache *regcache, 7929 packet_reg *reg) 7930{ 7931 struct gdbarch *gdbarch = regcache->arch (); 7932 struct remote_state *rs = get_remote_state (); 7933 char *buf, *p; 7934 gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum)); 7935 int i; 7936 7937 if (packet_support (PACKET_p) == PACKET_DISABLE) 7938 return 0; 7939 7940 if (reg->pnum == -1) 7941 return 0; 7942 7943 p = rs->buf.data (); 7944 *p++ = 'p'; 7945 p += hexnumstr (p, reg->pnum); 7946 *p++ = '\0'; 7947 putpkt (rs->buf); 7948 getpkt (&rs->buf, 0); 7949 7950 buf = rs->buf.data (); 7951 7952 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_p])) 7953 { 7954 case PACKET_OK: 7955 break; 7956 case PACKET_UNKNOWN: 7957 return 0; 7958 case PACKET_ERROR: 7959 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"), 7960 gdbarch_register_name (regcache->arch (), 7961 reg->regnum), 7962 buf); 7963 } 7964 7965 /* If this register is unfetchable, tell the regcache. */ 7966 if (buf[0] == 'x') 7967 { 7968 regcache->raw_supply (reg->regnum, NULL); 7969 return 1; 7970 } 7971 7972 /* Otherwise, parse and supply the value. */ 7973 p = buf; 7974 i = 0; 7975 while (p[0] != 0) 7976 { 7977 if (p[1] == 0) 7978 error (_("fetch_register_using_p: early buf termination")); 7979 7980 regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]); 7981 p += 2; 7982 } 7983 regcache->raw_supply (reg->regnum, regp); 7984 return 1; 7985} 7986 7987/* Fetch the registers included in the target's 'g' packet. */ 7988 7989int 7990remote_target::send_g_packet () 7991{ 7992 struct remote_state *rs = get_remote_state (); 7993 int buf_len; 7994 7995 xsnprintf (rs->buf.data (), get_remote_packet_size (), "g"); 7996 putpkt (rs->buf); 7997 getpkt (&rs->buf, 0); 7998 if (packet_check_result (rs->buf) == PACKET_ERROR) 7999 error (_("Could not read registers; remote failure reply '%s'"), 8000 rs->buf.data ()); 8001 8002 /* We can get out of synch in various cases. If the first character 8003 in the buffer is not a hex character, assume that has happened 8004 and try to fetch another packet to read. */ 8005 while ((rs->buf[0] < '0' || rs->buf[0] > '9') 8006 && (rs->buf[0] < 'A' || rs->buf[0] > 'F') 8007 && (rs->buf[0] < 'a' || rs->buf[0] > 'f') 8008 && rs->buf[0] != 'x') /* New: unavailable register value. */ 8009 { 8010 if (remote_debug) 8011 fprintf_unfiltered (gdb_stdlog, 8012 "Bad register packet; fetching a new packet\n"); 8013 getpkt (&rs->buf, 0); 8014 } 8015 8016 buf_len = strlen (rs->buf.data ()); 8017 8018 /* Sanity check the received packet. */ 8019 if (buf_len % 2 != 0) 8020 error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf.data ()); 8021 8022 return buf_len / 2; 8023} 8024 8025void 8026remote_target::process_g_packet (struct regcache *regcache) 8027{ 8028 struct gdbarch *gdbarch = regcache->arch (); 8029 struct remote_state *rs = get_remote_state (); 8030 remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch); 8031 int i, buf_len; 8032 char *p; 8033 char *regs; 8034 8035 buf_len = strlen (rs->buf.data ()); 8036 8037 /* Further sanity checks, with knowledge of the architecture. */ 8038 if (buf_len > 2 * rsa->sizeof_g_packet) 8039 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d " 8040 "bytes): %s"), 8041 rsa->sizeof_g_packet, buf_len / 2, 8042 rs->buf.data ()); 8043 8044 /* Save the size of the packet sent to us by the target. It is used 8045 as a heuristic when determining the max size of packets that the 8046 target can safely receive. */ 8047 if (rsa->actual_register_packet_size == 0) 8048 rsa->actual_register_packet_size = buf_len; 8049 8050 /* If this is smaller than we guessed the 'g' packet would be, 8051 update our records. A 'g' reply that doesn't include a register's 8052 value implies either that the register is not available, or that 8053 the 'p' packet must be used. */ 8054 if (buf_len < 2 * rsa->sizeof_g_packet) 8055 { 8056 long sizeof_g_packet = buf_len / 2; 8057 8058 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 8059 { 8060 long offset = rsa->regs[i].offset; 8061 long reg_size = register_size (gdbarch, i); 8062 8063 if (rsa->regs[i].pnum == -1) 8064 continue; 8065 8066 if (offset >= sizeof_g_packet) 8067 rsa->regs[i].in_g_packet = 0; 8068 else if (offset + reg_size > sizeof_g_packet) 8069 error (_("Truncated register %d in remote 'g' packet"), i); 8070 else 8071 rsa->regs[i].in_g_packet = 1; 8072 } 8073 8074 /* Looks valid enough, we can assume this is the correct length 8075 for a 'g' packet. It's important not to adjust 8076 rsa->sizeof_g_packet if we have truncated registers otherwise 8077 this "if" won't be run the next time the method is called 8078 with a packet of the same size and one of the internal errors 8079 below will trigger instead. */ 8080 rsa->sizeof_g_packet = sizeof_g_packet; 8081 } 8082 8083 regs = (char *) alloca (rsa->sizeof_g_packet); 8084 8085 /* Unimplemented registers read as all bits zero. */ 8086 memset (regs, 0, rsa->sizeof_g_packet); 8087 8088 /* Reply describes registers byte by byte, each byte encoded as two 8089 hex characters. Suck them all up, then supply them to the 8090 register cacheing/storage mechanism. */ 8091 8092 p = rs->buf.data (); 8093 for (i = 0; i < rsa->sizeof_g_packet; i++) 8094 { 8095 if (p[0] == 0 || p[1] == 0) 8096 /* This shouldn't happen - we adjusted sizeof_g_packet above. */ 8097 internal_error (__FILE__, __LINE__, 8098 _("unexpected end of 'g' packet reply")); 8099 8100 if (p[0] == 'x' && p[1] == 'x') 8101 regs[i] = 0; /* 'x' */ 8102 else 8103 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]); 8104 p += 2; 8105 } 8106 8107 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 8108 { 8109 struct packet_reg *r = &rsa->regs[i]; 8110 long reg_size = register_size (gdbarch, i); 8111 8112 if (r->in_g_packet) 8113 { 8114 if ((r->offset + reg_size) * 2 > strlen (rs->buf.data ())) 8115 /* This shouldn't happen - we adjusted in_g_packet above. */ 8116 internal_error (__FILE__, __LINE__, 8117 _("unexpected end of 'g' packet reply")); 8118 else if (rs->buf[r->offset * 2] == 'x') 8119 { 8120 gdb_assert (r->offset * 2 < strlen (rs->buf.data ())); 8121 /* The register isn't available, mark it as such (at 8122 the same time setting the value to zero). */ 8123 regcache->raw_supply (r->regnum, NULL); 8124 } 8125 else 8126 regcache->raw_supply (r->regnum, regs + r->offset); 8127 } 8128 } 8129} 8130 8131void 8132remote_target::fetch_registers_using_g (struct regcache *regcache) 8133{ 8134 send_g_packet (); 8135 process_g_packet (regcache); 8136} 8137 8138/* Make the remote selected traceframe match GDB's selected 8139 traceframe. */ 8140 8141void 8142remote_target::set_remote_traceframe () 8143{ 8144 int newnum; 8145 struct remote_state *rs = get_remote_state (); 8146 8147 if (rs->remote_traceframe_number == get_traceframe_number ()) 8148 return; 8149 8150 /* Avoid recursion, remote_trace_find calls us again. */ 8151 rs->remote_traceframe_number = get_traceframe_number (); 8152 8153 newnum = target_trace_find (tfind_number, 8154 get_traceframe_number (), 0, 0, NULL); 8155 8156 /* Should not happen. If it does, all bets are off. */ 8157 if (newnum != get_traceframe_number ()) 8158 warning (_("could not set remote traceframe")); 8159} 8160 8161void 8162remote_target::fetch_registers (struct regcache *regcache, int regnum) 8163{ 8164 struct gdbarch *gdbarch = regcache->arch (); 8165 struct remote_state *rs = get_remote_state (); 8166 remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch); 8167 int i; 8168 8169 set_remote_traceframe (); 8170 set_general_thread (regcache->ptid ()); 8171 8172 if (regnum >= 0) 8173 { 8174 packet_reg *reg = packet_reg_from_regnum (gdbarch, rsa, regnum); 8175 8176 gdb_assert (reg != NULL); 8177 8178 /* If this register might be in the 'g' packet, try that first - 8179 we are likely to read more than one register. If this is the 8180 first 'g' packet, we might be overly optimistic about its 8181 contents, so fall back to 'p'. */ 8182 if (reg->in_g_packet) 8183 { 8184 fetch_registers_using_g (regcache); 8185 if (reg->in_g_packet) 8186 return; 8187 } 8188 8189 if (fetch_register_using_p (regcache, reg)) 8190 return; 8191 8192 /* This register is not available. */ 8193 regcache->raw_supply (reg->regnum, NULL); 8194 8195 return; 8196 } 8197 8198 fetch_registers_using_g (regcache); 8199 8200 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 8201 if (!rsa->regs[i].in_g_packet) 8202 if (!fetch_register_using_p (regcache, &rsa->regs[i])) 8203 { 8204 /* This register is not available. */ 8205 regcache->raw_supply (i, NULL); 8206 } 8207} 8208 8209/* Prepare to store registers. Since we may send them all (using a 8210 'G' request), we have to read out the ones we don't want to change 8211 first. */ 8212 8213void 8214remote_target::prepare_to_store (struct regcache *regcache) 8215{ 8216 struct remote_state *rs = get_remote_state (); 8217 remote_arch_state *rsa = rs->get_remote_arch_state (regcache->arch ()); 8218 int i; 8219 8220 /* Make sure the entire registers array is valid. */ 8221 switch (packet_support (PACKET_P)) 8222 { 8223 case PACKET_DISABLE: 8224 case PACKET_SUPPORT_UNKNOWN: 8225 /* Make sure all the necessary registers are cached. */ 8226 for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++) 8227 if (rsa->regs[i].in_g_packet) 8228 regcache->raw_update (rsa->regs[i].regnum); 8229 break; 8230 case PACKET_ENABLE: 8231 break; 8232 } 8233} 8234 8235/* Helper: Attempt to store REGNUM using the P packet. Return fail IFF 8236 packet was not recognized. */ 8237 8238int 8239remote_target::store_register_using_P (const struct regcache *regcache, 8240 packet_reg *reg) 8241{ 8242 struct gdbarch *gdbarch = regcache->arch (); 8243 struct remote_state *rs = get_remote_state (); 8244 /* Try storing a single register. */ 8245 char *buf = rs->buf.data (); 8246 gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum)); 8247 char *p; 8248 8249 if (packet_support (PACKET_P) == PACKET_DISABLE) 8250 return 0; 8251 8252 if (reg->pnum == -1) 8253 return 0; 8254 8255 xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0)); 8256 p = buf + strlen (buf); 8257 regcache->raw_collect (reg->regnum, regp); 8258 bin2hex (regp, p, register_size (gdbarch, reg->regnum)); 8259 putpkt (rs->buf); 8260 getpkt (&rs->buf, 0); 8261 8262 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P])) 8263 { 8264 case PACKET_OK: 8265 return 1; 8266 case PACKET_ERROR: 8267 error (_("Could not write register \"%s\"; remote failure reply '%s'"), 8268 gdbarch_register_name (gdbarch, reg->regnum), rs->buf.data ()); 8269 case PACKET_UNKNOWN: 8270 return 0; 8271 default: 8272 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok")); 8273 } 8274} 8275 8276/* Store register REGNUM, or all registers if REGNUM == -1, from the 8277 contents of the register cache buffer. FIXME: ignores errors. */ 8278 8279void 8280remote_target::store_registers_using_G (const struct regcache *regcache) 8281{ 8282 struct remote_state *rs = get_remote_state (); 8283 remote_arch_state *rsa = rs->get_remote_arch_state (regcache->arch ()); 8284 gdb_byte *regs; 8285 char *p; 8286 8287 /* Extract all the registers in the regcache copying them into a 8288 local buffer. */ 8289 { 8290 int i; 8291 8292 regs = (gdb_byte *) alloca (rsa->sizeof_g_packet); 8293 memset (regs, 0, rsa->sizeof_g_packet); 8294 for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++) 8295 { 8296 struct packet_reg *r = &rsa->regs[i]; 8297 8298 if (r->in_g_packet) 8299 regcache->raw_collect (r->regnum, regs + r->offset); 8300 } 8301 } 8302 8303 /* Command describes registers byte by byte, 8304 each byte encoded as two hex characters. */ 8305 p = rs->buf.data (); 8306 *p++ = 'G'; 8307 bin2hex (regs, p, rsa->sizeof_g_packet); 8308 putpkt (rs->buf); 8309 getpkt (&rs->buf, 0); 8310 if (packet_check_result (rs->buf) == PACKET_ERROR) 8311 error (_("Could not write registers; remote failure reply '%s'"), 8312 rs->buf.data ()); 8313} 8314 8315/* Store register REGNUM, or all registers if REGNUM == -1, from the contents 8316 of the register cache buffer. FIXME: ignores errors. */ 8317 8318void 8319remote_target::store_registers (struct regcache *regcache, int regnum) 8320{ 8321 struct gdbarch *gdbarch = regcache->arch (); 8322 struct remote_state *rs = get_remote_state (); 8323 remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch); 8324 int i; 8325 8326 set_remote_traceframe (); 8327 set_general_thread (regcache->ptid ()); 8328 8329 if (regnum >= 0) 8330 { 8331 packet_reg *reg = packet_reg_from_regnum (gdbarch, rsa, regnum); 8332 8333 gdb_assert (reg != NULL); 8334 8335 /* Always prefer to store registers using the 'P' packet if 8336 possible; we often change only a small number of registers. 8337 Sometimes we change a larger number; we'd need help from a 8338 higher layer to know to use 'G'. */ 8339 if (store_register_using_P (regcache, reg)) 8340 return; 8341 8342 /* For now, don't complain if we have no way to write the 8343 register. GDB loses track of unavailable registers too 8344 easily. Some day, this may be an error. We don't have 8345 any way to read the register, either... */ 8346 if (!reg->in_g_packet) 8347 return; 8348 8349 store_registers_using_G (regcache); 8350 return; 8351 } 8352 8353 store_registers_using_G (regcache); 8354 8355 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 8356 if (!rsa->regs[i].in_g_packet) 8357 if (!store_register_using_P (regcache, &rsa->regs[i])) 8358 /* See above for why we do not issue an error here. */ 8359 continue; 8360} 8361 8362 8363/* Return the number of hex digits in num. */ 8364 8365static int 8366hexnumlen (ULONGEST num) 8367{ 8368 int i; 8369 8370 for (i = 0; num != 0; i++) 8371 num >>= 4; 8372 8373 return std::max (i, 1); 8374} 8375 8376/* Set BUF to the minimum number of hex digits representing NUM. */ 8377 8378static int 8379hexnumstr (char *buf, ULONGEST num) 8380{ 8381 int len = hexnumlen (num); 8382 8383 return hexnumnstr (buf, num, len); 8384} 8385 8386 8387/* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */ 8388 8389static int 8390hexnumnstr (char *buf, ULONGEST num, int width) 8391{ 8392 int i; 8393 8394 buf[width] = '\0'; 8395 8396 for (i = width - 1; i >= 0; i--) 8397 { 8398 buf[i] = "0123456789abcdef"[(num & 0xf)]; 8399 num >>= 4; 8400 } 8401 8402 return width; 8403} 8404 8405/* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */ 8406 8407static CORE_ADDR 8408remote_address_masked (CORE_ADDR addr) 8409{ 8410 unsigned int address_size = remote_address_size; 8411 8412 /* If "remoteaddresssize" was not set, default to target address size. */ 8413 if (!address_size) 8414 address_size = gdbarch_addr_bit (target_gdbarch ()); 8415 8416 if (address_size > 0 8417 && address_size < (sizeof (ULONGEST) * 8)) 8418 { 8419 /* Only create a mask when that mask can safely be constructed 8420 in a ULONGEST variable. */ 8421 ULONGEST mask = 1; 8422 8423 mask = (mask << address_size) - 1; 8424 addr &= mask; 8425 } 8426 return addr; 8427} 8428 8429/* Determine whether the remote target supports binary downloading. 8430 This is accomplished by sending a no-op memory write of zero length 8431 to the target at the specified address. It does not suffice to send 8432 the whole packet, since many stubs strip the eighth bit and 8433 subsequently compute a wrong checksum, which causes real havoc with 8434 remote_write_bytes. 8435 8436 NOTE: This can still lose if the serial line is not eight-bit 8437 clean. In cases like this, the user should clear "remote 8438 X-packet". */ 8439 8440void 8441remote_target::check_binary_download (CORE_ADDR addr) 8442{ 8443 struct remote_state *rs = get_remote_state (); 8444 8445 switch (packet_support (PACKET_X)) 8446 { 8447 case PACKET_DISABLE: 8448 break; 8449 case PACKET_ENABLE: 8450 break; 8451 case PACKET_SUPPORT_UNKNOWN: 8452 { 8453 char *p; 8454 8455 p = rs->buf.data (); 8456 *p++ = 'X'; 8457 p += hexnumstr (p, (ULONGEST) addr); 8458 *p++ = ','; 8459 p += hexnumstr (p, (ULONGEST) 0); 8460 *p++ = ':'; 8461 *p = '\0'; 8462 8463 putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ())); 8464 getpkt (&rs->buf, 0); 8465 8466 if (rs->buf[0] == '\0') 8467 { 8468 if (remote_debug) 8469 fprintf_unfiltered (gdb_stdlog, 8470 "binary downloading NOT " 8471 "supported by target\n"); 8472 remote_protocol_packets[PACKET_X].support = PACKET_DISABLE; 8473 } 8474 else 8475 { 8476 if (remote_debug) 8477 fprintf_unfiltered (gdb_stdlog, 8478 "binary downloading supported by target\n"); 8479 remote_protocol_packets[PACKET_X].support = PACKET_ENABLE; 8480 } 8481 break; 8482 } 8483 } 8484} 8485 8486/* Helper function to resize the payload in order to try to get a good 8487 alignment. We try to write an amount of data such that the next write will 8488 start on an address aligned on REMOTE_ALIGN_WRITES. */ 8489 8490static int 8491align_for_efficient_write (int todo, CORE_ADDR memaddr) 8492{ 8493 return ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr; 8494} 8495 8496/* Write memory data directly to the remote machine. 8497 This does not inform the data cache; the data cache uses this. 8498 HEADER is the starting part of the packet. 8499 MEMADDR is the address in the remote memory space. 8500 MYADDR is the address of the buffer in our space. 8501 LEN_UNITS is the number of addressable units to write. 8502 UNIT_SIZE is the length in bytes of an addressable unit. 8503 PACKET_FORMAT should be either 'X' or 'M', and indicates if we 8504 should send data as binary ('X'), or hex-encoded ('M'). 8505 8506 The function creates packet of the form 8507 <HEADER><ADDRESS>,<LENGTH>:<DATA> 8508 8509 where encoding of <DATA> is terminated by PACKET_FORMAT. 8510 8511 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma 8512 are omitted. 8513 8514 Return the transferred status, error or OK (an 8515 'enum target_xfer_status' value). Save the number of addressable units 8516 transferred in *XFERED_LEN_UNITS. Only transfer a single packet. 8517 8518 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an 8519 exchange between gdb and the stub could look like (?? in place of the 8520 checksum): 8521 8522 -> $m1000,4#?? 8523 <- aaaabbbbccccdddd 8524 8525 -> $M1000,3:eeeeffffeeee#?? 8526 <- OK 8527 8528 -> $m1000,4#?? 8529 <- eeeeffffeeeedddd */ 8530 8531target_xfer_status 8532remote_target::remote_write_bytes_aux (const char *header, CORE_ADDR memaddr, 8533 const gdb_byte *myaddr, 8534 ULONGEST len_units, 8535 int unit_size, 8536 ULONGEST *xfered_len_units, 8537 char packet_format, int use_length) 8538{ 8539 struct remote_state *rs = get_remote_state (); 8540 char *p; 8541 char *plen = NULL; 8542 int plenlen = 0; 8543 int todo_units; 8544 int units_written; 8545 int payload_capacity_bytes; 8546 int payload_length_bytes; 8547 8548 if (packet_format != 'X' && packet_format != 'M') 8549 internal_error (__FILE__, __LINE__, 8550 _("remote_write_bytes_aux: bad packet format")); 8551 8552 if (len_units == 0) 8553 return TARGET_XFER_EOF; 8554 8555 payload_capacity_bytes = get_memory_write_packet_size (); 8556 8557 /* The packet buffer will be large enough for the payload; 8558 get_memory_packet_size ensures this. */ 8559 rs->buf[0] = '\0'; 8560 8561 /* Compute the size of the actual payload by subtracting out the 8562 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */ 8563 8564 payload_capacity_bytes -= strlen ("$,:#NN"); 8565 if (!use_length) 8566 /* The comma won't be used. */ 8567 payload_capacity_bytes += 1; 8568 payload_capacity_bytes -= strlen (header); 8569 payload_capacity_bytes -= hexnumlen (memaddr); 8570 8571 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */ 8572 8573 strcat (rs->buf.data (), header); 8574 p = rs->buf.data () + strlen (header); 8575 8576 /* Compute a best guess of the number of bytes actually transfered. */ 8577 if (packet_format == 'X') 8578 { 8579 /* Best guess at number of bytes that will fit. */ 8580 todo_units = std::min (len_units, 8581 (ULONGEST) payload_capacity_bytes / unit_size); 8582 if (use_length) 8583 payload_capacity_bytes -= hexnumlen (todo_units); 8584 todo_units = std::min (todo_units, payload_capacity_bytes / unit_size); 8585 } 8586 else 8587 { 8588 /* Number of bytes that will fit. */ 8589 todo_units 8590 = std::min (len_units, 8591 (ULONGEST) (payload_capacity_bytes / unit_size) / 2); 8592 if (use_length) 8593 payload_capacity_bytes -= hexnumlen (todo_units); 8594 todo_units = std::min (todo_units, 8595 (payload_capacity_bytes / unit_size) / 2); 8596 } 8597 8598 if (todo_units <= 0) 8599 internal_error (__FILE__, __LINE__, 8600 _("minimum packet size too small to write data")); 8601 8602 /* If we already need another packet, then try to align the end 8603 of this packet to a useful boundary. */ 8604 if (todo_units > 2 * REMOTE_ALIGN_WRITES && todo_units < len_units) 8605 todo_units = align_for_efficient_write (todo_units, memaddr); 8606 8607 /* Append "<memaddr>". */ 8608 memaddr = remote_address_masked (memaddr); 8609 p += hexnumstr (p, (ULONGEST) memaddr); 8610 8611 if (use_length) 8612 { 8613 /* Append ",". */ 8614 *p++ = ','; 8615 8616 /* Append the length and retain its location and size. It may need to be 8617 adjusted once the packet body has been created. */ 8618 plen = p; 8619 plenlen = hexnumstr (p, (ULONGEST) todo_units); 8620 p += plenlen; 8621 } 8622 8623 /* Append ":". */ 8624 *p++ = ':'; 8625 *p = '\0'; 8626 8627 /* Append the packet body. */ 8628 if (packet_format == 'X') 8629 { 8630 /* Binary mode. Send target system values byte by byte, in 8631 increasing byte addresses. Only escape certain critical 8632 characters. */ 8633 payload_length_bytes = 8634 remote_escape_output (myaddr, todo_units, unit_size, (gdb_byte *) p, 8635 &units_written, payload_capacity_bytes); 8636 8637 /* If not all TODO units fit, then we'll need another packet. Make 8638 a second try to keep the end of the packet aligned. Don't do 8639 this if the packet is tiny. */ 8640 if (units_written < todo_units && units_written > 2 * REMOTE_ALIGN_WRITES) 8641 { 8642 int new_todo_units; 8643 8644 new_todo_units = align_for_efficient_write (units_written, memaddr); 8645 8646 if (new_todo_units != units_written) 8647 payload_length_bytes = 8648 remote_escape_output (myaddr, new_todo_units, unit_size, 8649 (gdb_byte *) p, &units_written, 8650 payload_capacity_bytes); 8651 } 8652 8653 p += payload_length_bytes; 8654 if (use_length && units_written < todo_units) 8655 { 8656 /* Escape chars have filled up the buffer prematurely, 8657 and we have actually sent fewer units than planned. 8658 Fix-up the length field of the packet. Use the same 8659 number of characters as before. */ 8660 plen += hexnumnstr (plen, (ULONGEST) units_written, 8661 plenlen); 8662 *plen = ':'; /* overwrite \0 from hexnumnstr() */ 8663 } 8664 } 8665 else 8666 { 8667 /* Normal mode: Send target system values byte by byte, in 8668 increasing byte addresses. Each byte is encoded as a two hex 8669 value. */ 8670 p += 2 * bin2hex (myaddr, p, todo_units * unit_size); 8671 units_written = todo_units; 8672 } 8673 8674 putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ())); 8675 getpkt (&rs->buf, 0); 8676 8677 if (rs->buf[0] == 'E') 8678 return TARGET_XFER_E_IO; 8679 8680 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to 8681 send fewer units than we'd planned. */ 8682 *xfered_len_units = (ULONGEST) units_written; 8683 return (*xfered_len_units != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF; 8684} 8685 8686/* Write memory data directly to the remote machine. 8687 This does not inform the data cache; the data cache uses this. 8688 MEMADDR is the address in the remote memory space. 8689 MYADDR is the address of the buffer in our space. 8690 LEN is the number of bytes. 8691 8692 Return the transferred status, error or OK (an 8693 'enum target_xfer_status' value). Save the number of bytes 8694 transferred in *XFERED_LEN. Only transfer a single packet. */ 8695 8696target_xfer_status 8697remote_target::remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, 8698 ULONGEST len, int unit_size, 8699 ULONGEST *xfered_len) 8700{ 8701 const char *packet_format = NULL; 8702 8703 /* Check whether the target supports binary download. */ 8704 check_binary_download (memaddr); 8705 8706 switch (packet_support (PACKET_X)) 8707 { 8708 case PACKET_ENABLE: 8709 packet_format = "X"; 8710 break; 8711 case PACKET_DISABLE: 8712 packet_format = "M"; 8713 break; 8714 case PACKET_SUPPORT_UNKNOWN: 8715 internal_error (__FILE__, __LINE__, 8716 _("remote_write_bytes: bad internal state")); 8717 default: 8718 internal_error (__FILE__, __LINE__, _("bad switch")); 8719 } 8720 8721 return remote_write_bytes_aux (packet_format, 8722 memaddr, myaddr, len, unit_size, xfered_len, 8723 packet_format[0], 1); 8724} 8725 8726/* Read memory data directly from the remote machine. 8727 This does not use the data cache; the data cache uses this. 8728 MEMADDR is the address in the remote memory space. 8729 MYADDR is the address of the buffer in our space. 8730 LEN_UNITS is the number of addressable memory units to read.. 8731 UNIT_SIZE is the length in bytes of an addressable unit. 8732 8733 Return the transferred status, error or OK (an 8734 'enum target_xfer_status' value). Save the number of bytes 8735 transferred in *XFERED_LEN_UNITS. 8736 8737 See the comment of remote_write_bytes_aux for an example of 8738 memory read/write exchange between gdb and the stub. */ 8739 8740target_xfer_status 8741remote_target::remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr, 8742 ULONGEST len_units, 8743 int unit_size, ULONGEST *xfered_len_units) 8744{ 8745 struct remote_state *rs = get_remote_state (); 8746 int buf_size_bytes; /* Max size of packet output buffer. */ 8747 char *p; 8748 int todo_units; 8749 int decoded_bytes; 8750 8751 buf_size_bytes = get_memory_read_packet_size (); 8752 /* The packet buffer will be large enough for the payload; 8753 get_memory_packet_size ensures this. */ 8754 8755 /* Number of units that will fit. */ 8756 todo_units = std::min (len_units, 8757 (ULONGEST) (buf_size_bytes / unit_size) / 2); 8758 8759 /* Construct "m"<memaddr>","<len>". */ 8760 memaddr = remote_address_masked (memaddr); 8761 p = rs->buf.data (); 8762 *p++ = 'm'; 8763 p += hexnumstr (p, (ULONGEST) memaddr); 8764 *p++ = ','; 8765 p += hexnumstr (p, (ULONGEST) todo_units); 8766 *p = '\0'; 8767 putpkt (rs->buf); 8768 getpkt (&rs->buf, 0); 8769 if (rs->buf[0] == 'E' 8770 && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2]) 8771 && rs->buf[3] == '\0') 8772 return TARGET_XFER_E_IO; 8773 /* Reply describes memory byte by byte, each byte encoded as two hex 8774 characters. */ 8775 p = rs->buf.data (); 8776 decoded_bytes = hex2bin (p, myaddr, todo_units * unit_size); 8777 /* Return what we have. Let higher layers handle partial reads. */ 8778 *xfered_len_units = (ULONGEST) (decoded_bytes / unit_size); 8779 return (*xfered_len_units != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF; 8780} 8781 8782/* Using the set of read-only target sections of remote, read live 8783 read-only memory. 8784 8785 For interface/parameters/return description see target.h, 8786 to_xfer_partial. */ 8787 8788target_xfer_status 8789remote_target::remote_xfer_live_readonly_partial (gdb_byte *readbuf, 8790 ULONGEST memaddr, 8791 ULONGEST len, 8792 int unit_size, 8793 ULONGEST *xfered_len) 8794{ 8795 struct target_section *secp; 8796 struct target_section_table *table; 8797 8798 secp = target_section_by_addr (this, memaddr); 8799 if (secp != NULL 8800 && (bfd_get_section_flags (secp->the_bfd_section->owner, 8801 secp->the_bfd_section) 8802 & SEC_READONLY)) 8803 { 8804 struct target_section *p; 8805 ULONGEST memend = memaddr + len; 8806 8807 table = target_get_section_table (this); 8808 8809 for (p = table->sections; p < table->sections_end; p++) 8810 { 8811 if (memaddr >= p->addr) 8812 { 8813 if (memend <= p->endaddr) 8814 { 8815 /* Entire transfer is within this section. */ 8816 return remote_read_bytes_1 (memaddr, readbuf, len, unit_size, 8817 xfered_len); 8818 } 8819 else if (memaddr >= p->endaddr) 8820 { 8821 /* This section ends before the transfer starts. */ 8822 continue; 8823 } 8824 else 8825 { 8826 /* This section overlaps the transfer. Just do half. */ 8827 len = p->endaddr - memaddr; 8828 return remote_read_bytes_1 (memaddr, readbuf, len, unit_size, 8829 xfered_len); 8830 } 8831 } 8832 } 8833 } 8834 8835 return TARGET_XFER_EOF; 8836} 8837 8838/* Similar to remote_read_bytes_1, but it reads from the remote stub 8839 first if the requested memory is unavailable in traceframe. 8840 Otherwise, fall back to remote_read_bytes_1. */ 8841 8842target_xfer_status 8843remote_target::remote_read_bytes (CORE_ADDR memaddr, 8844 gdb_byte *myaddr, ULONGEST len, int unit_size, 8845 ULONGEST *xfered_len) 8846{ 8847 if (len == 0) 8848 return TARGET_XFER_EOF; 8849 8850 if (get_traceframe_number () != -1) 8851 { 8852 std::vector<mem_range> available; 8853 8854 /* If we fail to get the set of available memory, then the 8855 target does not support querying traceframe info, and so we 8856 attempt reading from the traceframe anyway (assuming the 8857 target implements the old QTro packet then). */ 8858 if (traceframe_available_memory (&available, memaddr, len)) 8859 { 8860 if (available.empty () || available[0].start != memaddr) 8861 { 8862 enum target_xfer_status res; 8863 8864 /* Don't read into the traceframe's available 8865 memory. */ 8866 if (!available.empty ()) 8867 { 8868 LONGEST oldlen = len; 8869 8870 len = available[0].start - memaddr; 8871 gdb_assert (len <= oldlen); 8872 } 8873 8874 /* This goes through the topmost target again. */ 8875 res = remote_xfer_live_readonly_partial (myaddr, memaddr, 8876 len, unit_size, xfered_len); 8877 if (res == TARGET_XFER_OK) 8878 return TARGET_XFER_OK; 8879 else 8880 { 8881 /* No use trying further, we know some memory starting 8882 at MEMADDR isn't available. */ 8883 *xfered_len = len; 8884 return (*xfered_len != 0) ? 8885 TARGET_XFER_UNAVAILABLE : TARGET_XFER_EOF; 8886 } 8887 } 8888 8889 /* Don't try to read more than how much is available, in 8890 case the target implements the deprecated QTro packet to 8891 cater for older GDBs (the target's knowledge of read-only 8892 sections may be outdated by now). */ 8893 len = available[0].length; 8894 } 8895 } 8896 8897 return remote_read_bytes_1 (memaddr, myaddr, len, unit_size, xfered_len); 8898} 8899 8900 8901 8902/* Sends a packet with content determined by the printf format string 8903 FORMAT and the remaining arguments, then gets the reply. Returns 8904 whether the packet was a success, a failure, or unknown. */ 8905 8906packet_result 8907remote_target::remote_send_printf (const char *format, ...) 8908{ 8909 struct remote_state *rs = get_remote_state (); 8910 int max_size = get_remote_packet_size (); 8911 va_list ap; 8912 8913 va_start (ap, format); 8914 8915 rs->buf[0] = '\0'; 8916 int size = vsnprintf (rs->buf.data (), max_size, format, ap); 8917 8918 va_end (ap); 8919 8920 if (size >= max_size) 8921 internal_error (__FILE__, __LINE__, _("Too long remote packet.")); 8922 8923 if (putpkt (rs->buf) < 0) 8924 error (_("Communication problem with target.")); 8925 8926 rs->buf[0] = '\0'; 8927 getpkt (&rs->buf, 0); 8928 8929 return packet_check_result (rs->buf); 8930} 8931 8932/* Flash writing can take quite some time. We'll set 8933 effectively infinite timeout for flash operations. 8934 In future, we'll need to decide on a better approach. */ 8935static const int remote_flash_timeout = 1000; 8936 8937void 8938remote_target::flash_erase (ULONGEST address, LONGEST length) 8939{ 8940 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; 8941 enum packet_result ret; 8942 scoped_restore restore_timeout 8943 = make_scoped_restore (&remote_timeout, remote_flash_timeout); 8944 8945 ret = remote_send_printf ("vFlashErase:%s,%s", 8946 phex (address, addr_size), 8947 phex (length, 4)); 8948 switch (ret) 8949 { 8950 case PACKET_UNKNOWN: 8951 error (_("Remote target does not support flash erase")); 8952 case PACKET_ERROR: 8953 error (_("Error erasing flash with vFlashErase packet")); 8954 default: 8955 break; 8956 } 8957} 8958 8959target_xfer_status 8960remote_target::remote_flash_write (ULONGEST address, 8961 ULONGEST length, ULONGEST *xfered_len, 8962 const gdb_byte *data) 8963{ 8964 scoped_restore restore_timeout 8965 = make_scoped_restore (&remote_timeout, remote_flash_timeout); 8966 return remote_write_bytes_aux ("vFlashWrite:", address, data, length, 1, 8967 xfered_len,'X', 0); 8968} 8969 8970void 8971remote_target::flash_done () 8972{ 8973 int ret; 8974 8975 scoped_restore restore_timeout 8976 = make_scoped_restore (&remote_timeout, remote_flash_timeout); 8977 8978 ret = remote_send_printf ("vFlashDone"); 8979 8980 switch (ret) 8981 { 8982 case PACKET_UNKNOWN: 8983 error (_("Remote target does not support vFlashDone")); 8984 case PACKET_ERROR: 8985 error (_("Error finishing flash operation")); 8986 default: 8987 break; 8988 } 8989} 8990 8991void 8992remote_target::files_info () 8993{ 8994 puts_filtered ("Debugging a target over a serial line.\n"); 8995} 8996 8997/* Stuff for dealing with the packets which are part of this protocol. 8998 See comment at top of file for details. */ 8999 9000/* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR 9001 error to higher layers. Called when a serial error is detected. 9002 The exception message is STRING, followed by a colon and a blank, 9003 the system error message for errno at function entry and final dot 9004 for output compatibility with throw_perror_with_name. */ 9005 9006static void 9007unpush_and_perror (const char *string) 9008{ 9009 int saved_errno = errno; 9010 9011 remote_unpush_target (); 9012 throw_error (TARGET_CLOSE_ERROR, "%s: %s.", string, 9013 safe_strerror (saved_errno)); 9014} 9015 9016/* Read a single character from the remote end. The current quit 9017 handler is overridden to avoid quitting in the middle of packet 9018 sequence, as that would break communication with the remote server. 9019 See remote_serial_quit_handler for more detail. */ 9020 9021int 9022remote_target::readchar (int timeout) 9023{ 9024 int ch; 9025 struct remote_state *rs = get_remote_state (); 9026 9027 { 9028 scoped_restore restore_quit_target 9029 = make_scoped_restore (&curr_quit_handler_target, this); 9030 scoped_restore restore_quit 9031 = make_scoped_restore (&quit_handler, ::remote_serial_quit_handler); 9032 9033 rs->got_ctrlc_during_io = 0; 9034 9035 ch = serial_readchar (rs->remote_desc, timeout); 9036 9037 if (rs->got_ctrlc_during_io) 9038 set_quit_flag (); 9039 } 9040 9041 if (ch >= 0) 9042 return ch; 9043 9044 switch ((enum serial_rc) ch) 9045 { 9046 case SERIAL_EOF: 9047 remote_unpush_target (); 9048 throw_error (TARGET_CLOSE_ERROR, _("Remote connection closed")); 9049 /* no return */ 9050 case SERIAL_ERROR: 9051 unpush_and_perror (_("Remote communication error. " 9052 "Target disconnected.")); 9053 /* no return */ 9054 case SERIAL_TIMEOUT: 9055 break; 9056 } 9057 return ch; 9058} 9059 9060/* Wrapper for serial_write that closes the target and throws if 9061 writing fails. The current quit handler is overridden to avoid 9062 quitting in the middle of packet sequence, as that would break 9063 communication with the remote server. See 9064 remote_serial_quit_handler for more detail. */ 9065 9066void 9067remote_target::remote_serial_write (const char *str, int len) 9068{ 9069 struct remote_state *rs = get_remote_state (); 9070 9071 scoped_restore restore_quit_target 9072 = make_scoped_restore (&curr_quit_handler_target, this); 9073 scoped_restore restore_quit 9074 = make_scoped_restore (&quit_handler, ::remote_serial_quit_handler); 9075 9076 rs->got_ctrlc_during_io = 0; 9077 9078 if (serial_write (rs->remote_desc, str, len)) 9079 { 9080 unpush_and_perror (_("Remote communication error. " 9081 "Target disconnected.")); 9082 } 9083 9084 if (rs->got_ctrlc_during_io) 9085 set_quit_flag (); 9086} 9087 9088/* Return a string representing an escaped version of BUF, of len N. 9089 E.g. \n is converted to \\n, \t to \\t, etc. */ 9090 9091static std::string 9092escape_buffer (const char *buf, int n) 9093{ 9094 string_file stb; 9095 9096 stb.putstrn (buf, n, '\\'); 9097 return std::move (stb.string ()); 9098} 9099 9100/* Display a null-terminated packet on stdout, for debugging, using C 9101 string notation. */ 9102 9103static void 9104print_packet (const char *buf) 9105{ 9106 puts_filtered ("\""); 9107 fputstr_filtered (buf, '"', gdb_stdout); 9108 puts_filtered ("\""); 9109} 9110 9111int 9112remote_target::putpkt (const char *buf) 9113{ 9114 return putpkt_binary (buf, strlen (buf)); 9115} 9116 9117/* Wrapper around remote_target::putpkt to avoid exporting 9118 remote_target. */ 9119 9120int 9121putpkt (remote_target *remote, const char *buf) 9122{ 9123 return remote->putpkt (buf); 9124} 9125 9126/* Send a packet to the remote machine, with error checking. The data 9127 of the packet is in BUF. The string in BUF can be at most 9128 get_remote_packet_size () - 5 to account for the $, # and checksum, 9129 and for a possible /0 if we are debugging (remote_debug) and want 9130 to print the sent packet as a string. */ 9131 9132int 9133remote_target::putpkt_binary (const char *buf, int cnt) 9134{ 9135 struct remote_state *rs = get_remote_state (); 9136 int i; 9137 unsigned char csum = 0; 9138 gdb::def_vector<char> data (cnt + 6); 9139 char *buf2 = data.data (); 9140 9141 int ch; 9142 int tcount = 0; 9143 char *p; 9144 9145 /* Catch cases like trying to read memory or listing threads while 9146 we're waiting for a stop reply. The remote server wouldn't be 9147 ready to handle this request, so we'd hang and timeout. We don't 9148 have to worry about this in synchronous mode, because in that 9149 case it's not possible to issue a command while the target is 9150 running. This is not a problem in non-stop mode, because in that 9151 case, the stub is always ready to process serial input. */ 9152 if (!target_is_non_stop_p () 9153 && target_is_async_p () 9154 && rs->waiting_for_stop_reply) 9155 { 9156 error (_("Cannot execute this command while the target is running.\n" 9157 "Use the \"interrupt\" command to stop the target\n" 9158 "and then try again.")); 9159 } 9160 9161 /* We're sending out a new packet. Make sure we don't look at a 9162 stale cached response. */ 9163 rs->cached_wait_status = 0; 9164 9165 /* Copy the packet into buffer BUF2, encapsulating it 9166 and giving it a checksum. */ 9167 9168 p = buf2; 9169 *p++ = '$'; 9170 9171 for (i = 0; i < cnt; i++) 9172 { 9173 csum += buf[i]; 9174 *p++ = buf[i]; 9175 } 9176 *p++ = '#'; 9177 *p++ = tohex ((csum >> 4) & 0xf); 9178 *p++ = tohex (csum & 0xf); 9179 9180 /* Send it over and over until we get a positive ack. */ 9181 9182 while (1) 9183 { 9184 int started_error_output = 0; 9185 9186 if (remote_debug) 9187 { 9188 *p = '\0'; 9189 9190 int len = (int) (p - buf2); 9191 9192 std::string str 9193 = escape_buffer (buf2, std::min (len, REMOTE_DEBUG_MAX_CHAR)); 9194 9195 fprintf_unfiltered (gdb_stdlog, "Sending packet: %s", str.c_str ()); 9196 9197 if (len > REMOTE_DEBUG_MAX_CHAR) 9198 fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]", 9199 len - REMOTE_DEBUG_MAX_CHAR); 9200 9201 fprintf_unfiltered (gdb_stdlog, "..."); 9202 9203 gdb_flush (gdb_stdlog); 9204 } 9205 remote_serial_write (buf2, p - buf2); 9206 9207 /* If this is a no acks version of the remote protocol, send the 9208 packet and move on. */ 9209 if (rs->noack_mode) 9210 break; 9211 9212 /* Read until either a timeout occurs (-2) or '+' is read. 9213 Handle any notification that arrives in the mean time. */ 9214 while (1) 9215 { 9216 ch = readchar (remote_timeout); 9217 9218 if (remote_debug) 9219 { 9220 switch (ch) 9221 { 9222 case '+': 9223 case '-': 9224 case SERIAL_TIMEOUT: 9225 case '$': 9226 case '%': 9227 if (started_error_output) 9228 { 9229 putchar_unfiltered ('\n'); 9230 started_error_output = 0; 9231 } 9232 } 9233 } 9234 9235 switch (ch) 9236 { 9237 case '+': 9238 if (remote_debug) 9239 fprintf_unfiltered (gdb_stdlog, "Ack\n"); 9240 return 1; 9241 case '-': 9242 if (remote_debug) 9243 fprintf_unfiltered (gdb_stdlog, "Nak\n"); 9244 /* FALLTHROUGH */ 9245 case SERIAL_TIMEOUT: 9246 tcount++; 9247 if (tcount > 3) 9248 return 0; 9249 break; /* Retransmit buffer. */ 9250 case '$': 9251 { 9252 if (remote_debug) 9253 fprintf_unfiltered (gdb_stdlog, 9254 "Packet instead of Ack, ignoring it\n"); 9255 /* It's probably an old response sent because an ACK 9256 was lost. Gobble up the packet and ack it so it 9257 doesn't get retransmitted when we resend this 9258 packet. */ 9259 skip_frame (); 9260 remote_serial_write ("+", 1); 9261 continue; /* Now, go look for +. */ 9262 } 9263 9264 case '%': 9265 { 9266 int val; 9267 9268 /* If we got a notification, handle it, and go back to looking 9269 for an ack. */ 9270 /* We've found the start of a notification. Now 9271 collect the data. */ 9272 val = read_frame (&rs->buf); 9273 if (val >= 0) 9274 { 9275 if (remote_debug) 9276 { 9277 std::string str = escape_buffer (rs->buf.data (), val); 9278 9279 fprintf_unfiltered (gdb_stdlog, 9280 " Notification received: %s\n", 9281 str.c_str ()); 9282 } 9283 handle_notification (rs->notif_state, rs->buf.data ()); 9284 /* We're in sync now, rewait for the ack. */ 9285 tcount = 0; 9286 } 9287 else 9288 { 9289 if (remote_debug) 9290 { 9291 if (!started_error_output) 9292 { 9293 started_error_output = 1; 9294 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: "); 9295 } 9296 fputc_unfiltered (ch & 0177, gdb_stdlog); 9297 fprintf_unfiltered (gdb_stdlog, "%s", rs->buf.data ()); 9298 } 9299 } 9300 continue; 9301 } 9302 /* fall-through */ 9303 default: 9304 if (remote_debug) 9305 { 9306 if (!started_error_output) 9307 { 9308 started_error_output = 1; 9309 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: "); 9310 } 9311 fputc_unfiltered (ch & 0177, gdb_stdlog); 9312 } 9313 continue; 9314 } 9315 break; /* Here to retransmit. */ 9316 } 9317 9318#if 0 9319 /* This is wrong. If doing a long backtrace, the user should be 9320 able to get out next time we call QUIT, without anything as 9321 violent as interrupt_query. If we want to provide a way out of 9322 here without getting to the next QUIT, it should be based on 9323 hitting ^C twice as in remote_wait. */ 9324 if (quit_flag) 9325 { 9326 quit_flag = 0; 9327 interrupt_query (); 9328 } 9329#endif 9330 } 9331 9332 return 0; 9333} 9334 9335/* Come here after finding the start of a frame when we expected an 9336 ack. Do our best to discard the rest of this packet. */ 9337 9338void 9339remote_target::skip_frame () 9340{ 9341 int c; 9342 9343 while (1) 9344 { 9345 c = readchar (remote_timeout); 9346 switch (c) 9347 { 9348 case SERIAL_TIMEOUT: 9349 /* Nothing we can do. */ 9350 return; 9351 case '#': 9352 /* Discard the two bytes of checksum and stop. */ 9353 c = readchar (remote_timeout); 9354 if (c >= 0) 9355 c = readchar (remote_timeout); 9356 9357 return; 9358 case '*': /* Run length encoding. */ 9359 /* Discard the repeat count. */ 9360 c = readchar (remote_timeout); 9361 if (c < 0) 9362 return; 9363 break; 9364 default: 9365 /* A regular character. */ 9366 break; 9367 } 9368 } 9369} 9370 9371/* Come here after finding the start of the frame. Collect the rest 9372 into *BUF, verifying the checksum, length, and handling run-length 9373 compression. NUL terminate the buffer. If there is not enough room, 9374 expand *BUF. 9375 9376 Returns -1 on error, number of characters in buffer (ignoring the 9377 trailing NULL) on success. (could be extended to return one of the 9378 SERIAL status indications). */ 9379 9380long 9381remote_target::read_frame (gdb::char_vector *buf_p) 9382{ 9383 unsigned char csum; 9384 long bc; 9385 int c; 9386 char *buf = buf_p->data (); 9387 struct remote_state *rs = get_remote_state (); 9388 9389 csum = 0; 9390 bc = 0; 9391 9392 while (1) 9393 { 9394 c = readchar (remote_timeout); 9395 switch (c) 9396 { 9397 case SERIAL_TIMEOUT: 9398 if (remote_debug) 9399 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog); 9400 return -1; 9401 case '$': 9402 if (remote_debug) 9403 fputs_filtered ("Saw new packet start in middle of old one\n", 9404 gdb_stdlog); 9405 return -1; /* Start a new packet, count retries. */ 9406 case '#': 9407 { 9408 unsigned char pktcsum; 9409 int check_0 = 0; 9410 int check_1 = 0; 9411 9412 buf[bc] = '\0'; 9413 9414 check_0 = readchar (remote_timeout); 9415 if (check_0 >= 0) 9416 check_1 = readchar (remote_timeout); 9417 9418 if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT) 9419 { 9420 if (remote_debug) 9421 fputs_filtered ("Timeout in checksum, retrying\n", 9422 gdb_stdlog); 9423 return -1; 9424 } 9425 else if (check_0 < 0 || check_1 < 0) 9426 { 9427 if (remote_debug) 9428 fputs_filtered ("Communication error in checksum\n", 9429 gdb_stdlog); 9430 return -1; 9431 } 9432 9433 /* Don't recompute the checksum; with no ack packets we 9434 don't have any way to indicate a packet retransmission 9435 is necessary. */ 9436 if (rs->noack_mode) 9437 return bc; 9438 9439 pktcsum = (fromhex (check_0) << 4) | fromhex (check_1); 9440 if (csum == pktcsum) 9441 return bc; 9442 9443 if (remote_debug) 9444 { 9445 std::string str = escape_buffer (buf, bc); 9446 9447 fprintf_unfiltered (gdb_stdlog, 9448 "Bad checksum, sentsum=0x%x, " 9449 "csum=0x%x, buf=%s\n", 9450 pktcsum, csum, str.c_str ()); 9451 } 9452 /* Number of characters in buffer ignoring trailing 9453 NULL. */ 9454 return -1; 9455 } 9456 case '*': /* Run length encoding. */ 9457 { 9458 int repeat; 9459 9460 csum += c; 9461 c = readchar (remote_timeout); 9462 csum += c; 9463 repeat = c - ' ' + 3; /* Compute repeat count. */ 9464 9465 /* The character before ``*'' is repeated. */ 9466 9467 if (repeat > 0 && repeat <= 255 && bc > 0) 9468 { 9469 if (bc + repeat - 1 >= buf_p->size () - 1) 9470 { 9471 /* Make some more room in the buffer. */ 9472 buf_p->resize (buf_p->size () + repeat); 9473 buf = buf_p->data (); 9474 } 9475 9476 memset (&buf[bc], buf[bc - 1], repeat); 9477 bc += repeat; 9478 continue; 9479 } 9480 9481 buf[bc] = '\0'; 9482 printf_filtered (_("Invalid run length encoding: %s\n"), buf); 9483 return -1; 9484 } 9485 default: 9486 if (bc >= buf_p->size () - 1) 9487 { 9488 /* Make some more room in the buffer. */ 9489 buf_p->resize (buf_p->size () * 2); 9490 buf = buf_p->data (); 9491 } 9492 9493 buf[bc++] = c; 9494 csum += c; 9495 continue; 9496 } 9497 } 9498} 9499 9500/* Read a packet from the remote machine, with error checking, and 9501 store it in *BUF. Resize *BUF if necessary to hold the result. If 9502 FOREVER, wait forever rather than timing out; this is used (in 9503 synchronous mode) to wait for a target that is is executing user 9504 code to stop. */ 9505/* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we 9506 don't have to change all the calls to getpkt to deal with the 9507 return value, because at the moment I don't know what the right 9508 thing to do it for those. */ 9509 9510void 9511remote_target::getpkt (gdb::char_vector *buf, int forever) 9512{ 9513 getpkt_sane (buf, forever); 9514} 9515 9516 9517/* Read a packet from the remote machine, with error checking, and 9518 store it in *BUF. Resize *BUF if necessary to hold the result. If 9519 FOREVER, wait forever rather than timing out; this is used (in 9520 synchronous mode) to wait for a target that is is executing user 9521 code to stop. If FOREVER == 0, this function is allowed to time 9522 out gracefully and return an indication of this to the caller. 9523 Otherwise return the number of bytes read. If EXPECTING_NOTIF, 9524 consider receiving a notification enough reason to return to the 9525 caller. *IS_NOTIF is an output boolean that indicates whether *BUF 9526 holds a notification or not (a regular packet). */ 9527 9528int 9529remote_target::getpkt_or_notif_sane_1 (gdb::char_vector *buf, 9530 int forever, int expecting_notif, 9531 int *is_notif) 9532{ 9533 struct remote_state *rs = get_remote_state (); 9534 int c; 9535 int tries; 9536 int timeout; 9537 int val = -1; 9538 9539 /* We're reading a new response. Make sure we don't look at a 9540 previously cached response. */ 9541 rs->cached_wait_status = 0; 9542 9543 strcpy (buf->data (), "timeout"); 9544 9545 if (forever) 9546 timeout = watchdog > 0 ? watchdog : -1; 9547 else if (expecting_notif) 9548 timeout = 0; /* There should already be a char in the buffer. If 9549 not, bail out. */ 9550 else 9551 timeout = remote_timeout; 9552 9553#define MAX_TRIES 3 9554 9555 /* Process any number of notifications, and then return when 9556 we get a packet. */ 9557 for (;;) 9558 { 9559 /* If we get a timeout or bad checksum, retry up to MAX_TRIES 9560 times. */ 9561 for (tries = 1; tries <= MAX_TRIES; tries++) 9562 { 9563 /* This can loop forever if the remote side sends us 9564 characters continuously, but if it pauses, we'll get 9565 SERIAL_TIMEOUT from readchar because of timeout. Then 9566 we'll count that as a retry. 9567 9568 Note that even when forever is set, we will only wait 9569 forever prior to the start of a packet. After that, we 9570 expect characters to arrive at a brisk pace. They should 9571 show up within remote_timeout intervals. */ 9572 do 9573 c = readchar (timeout); 9574 while (c != SERIAL_TIMEOUT && c != '$' && c != '%'); 9575 9576 if (c == SERIAL_TIMEOUT) 9577 { 9578 if (expecting_notif) 9579 return -1; /* Don't complain, it's normal to not get 9580 anything in this case. */ 9581 9582 if (forever) /* Watchdog went off? Kill the target. */ 9583 { 9584 remote_unpush_target (); 9585 throw_error (TARGET_CLOSE_ERROR, 9586 _("Watchdog timeout has expired. " 9587 "Target detached.")); 9588 } 9589 if (remote_debug) 9590 fputs_filtered ("Timed out.\n", gdb_stdlog); 9591 } 9592 else 9593 { 9594 /* We've found the start of a packet or notification. 9595 Now collect the data. */ 9596 val = read_frame (buf); 9597 if (val >= 0) 9598 break; 9599 } 9600 9601 remote_serial_write ("-", 1); 9602 } 9603 9604 if (tries > MAX_TRIES) 9605 { 9606 /* We have tried hard enough, and just can't receive the 9607 packet/notification. Give up. */ 9608 printf_unfiltered (_("Ignoring packet error, continuing...\n")); 9609 9610 /* Skip the ack char if we're in no-ack mode. */ 9611 if (!rs->noack_mode) 9612 remote_serial_write ("+", 1); 9613 return -1; 9614 } 9615 9616 /* If we got an ordinary packet, return that to our caller. */ 9617 if (c == '$') 9618 { 9619 if (remote_debug) 9620 { 9621 std::string str 9622 = escape_buffer (buf->data (), 9623 std::min (val, REMOTE_DEBUG_MAX_CHAR)); 9624 9625 fprintf_unfiltered (gdb_stdlog, "Packet received: %s", 9626 str.c_str ()); 9627 9628 if (val > REMOTE_DEBUG_MAX_CHAR) 9629 fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]", 9630 val - REMOTE_DEBUG_MAX_CHAR); 9631 9632 fprintf_unfiltered (gdb_stdlog, "\n"); 9633 } 9634 9635 /* Skip the ack char if we're in no-ack mode. */ 9636 if (!rs->noack_mode) 9637 remote_serial_write ("+", 1); 9638 if (is_notif != NULL) 9639 *is_notif = 0; 9640 return val; 9641 } 9642 9643 /* If we got a notification, handle it, and go back to looking 9644 for a packet. */ 9645 else 9646 { 9647 gdb_assert (c == '%'); 9648 9649 if (remote_debug) 9650 { 9651 std::string str = escape_buffer (buf->data (), val); 9652 9653 fprintf_unfiltered (gdb_stdlog, 9654 " Notification received: %s\n", 9655 str.c_str ()); 9656 } 9657 if (is_notif != NULL) 9658 *is_notif = 1; 9659 9660 handle_notification (rs->notif_state, buf->data ()); 9661 9662 /* Notifications require no acknowledgement. */ 9663 9664 if (expecting_notif) 9665 return val; 9666 } 9667 } 9668} 9669 9670int 9671remote_target::getpkt_sane (gdb::char_vector *buf, int forever) 9672{ 9673 return getpkt_or_notif_sane_1 (buf, forever, 0, NULL); 9674} 9675 9676int 9677remote_target::getpkt_or_notif_sane (gdb::char_vector *buf, int forever, 9678 int *is_notif) 9679{ 9680 return getpkt_or_notif_sane_1 (buf, forever, 1, is_notif); 9681} 9682 9683/* Kill any new fork children of process PID that haven't been 9684 processed by follow_fork. */ 9685 9686void 9687remote_target::kill_new_fork_children (int pid) 9688{ 9689 remote_state *rs = get_remote_state (); 9690 struct notif_client *notif = ¬if_client_stop; 9691 9692 /* Kill the fork child threads of any threads in process PID 9693 that are stopped at a fork event. */ 9694 for (thread_info *thread : all_non_exited_threads ()) 9695 { 9696 struct target_waitstatus *ws = &thread->pending_follow; 9697 9698 if (is_pending_fork_parent (ws, pid, thread->ptid)) 9699 { 9700 int child_pid = ws->value.related_pid.pid (); 9701 int res; 9702 9703 res = remote_vkill (child_pid); 9704 if (res != 0) 9705 error (_("Can't kill fork child process %d"), child_pid); 9706 } 9707 } 9708 9709 /* Check for any pending fork events (not reported or processed yet) 9710 in process PID and kill those fork child threads as well. */ 9711 remote_notif_get_pending_events (notif); 9712 for (auto &event : rs->stop_reply_queue) 9713 if (is_pending_fork_parent (&event->ws, pid, event->ptid)) 9714 { 9715 int child_pid = event->ws.value.related_pid.pid (); 9716 int res; 9717 9718 res = remote_vkill (child_pid); 9719 if (res != 0) 9720 error (_("Can't kill fork child process %d"), child_pid); 9721 } 9722} 9723 9724 9725/* Target hook to kill the current inferior. */ 9726 9727void 9728remote_target::kill () 9729{ 9730 int res = -1; 9731 int pid = inferior_ptid.pid (); 9732 struct remote_state *rs = get_remote_state (); 9733 9734 if (packet_support (PACKET_vKill) != PACKET_DISABLE) 9735 { 9736 /* If we're stopped while forking and we haven't followed yet, 9737 kill the child task. We need to do this before killing the 9738 parent task because if this is a vfork then the parent will 9739 be sleeping. */ 9740 kill_new_fork_children (pid); 9741 9742 res = remote_vkill (pid); 9743 if (res == 0) 9744 { 9745 target_mourn_inferior (inferior_ptid); 9746 return; 9747 } 9748 } 9749 9750 /* If we are in 'target remote' mode and we are killing the only 9751 inferior, then we will tell gdbserver to exit and unpush the 9752 target. */ 9753 if (res == -1 && !remote_multi_process_p (rs) 9754 && number_of_live_inferiors () == 1) 9755 { 9756 remote_kill_k (); 9757 9758 /* We've killed the remote end, we get to mourn it. If we are 9759 not in extended mode, mourning the inferior also unpushes 9760 remote_ops from the target stack, which closes the remote 9761 connection. */ 9762 target_mourn_inferior (inferior_ptid); 9763 9764 return; 9765 } 9766 9767 error (_("Can't kill process")); 9768} 9769 9770/* Send a kill request to the target using the 'vKill' packet. */ 9771 9772int 9773remote_target::remote_vkill (int pid) 9774{ 9775 if (packet_support (PACKET_vKill) == PACKET_DISABLE) 9776 return -1; 9777 9778 remote_state *rs = get_remote_state (); 9779 9780 /* Tell the remote target to detach. */ 9781 xsnprintf (rs->buf.data (), get_remote_packet_size (), "vKill;%x", pid); 9782 putpkt (rs->buf); 9783 getpkt (&rs->buf, 0); 9784 9785 switch (packet_ok (rs->buf, 9786 &remote_protocol_packets[PACKET_vKill])) 9787 { 9788 case PACKET_OK: 9789 return 0; 9790 case PACKET_ERROR: 9791 return 1; 9792 case PACKET_UNKNOWN: 9793 return -1; 9794 default: 9795 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok")); 9796 } 9797} 9798 9799/* Send a kill request to the target using the 'k' packet. */ 9800 9801void 9802remote_target::remote_kill_k () 9803{ 9804 /* Catch errors so the user can quit from gdb even when we 9805 aren't on speaking terms with the remote system. */ 9806 TRY 9807 { 9808 putpkt ("k"); 9809 } 9810 CATCH (ex, RETURN_MASK_ERROR) 9811 { 9812 if (ex.error == TARGET_CLOSE_ERROR) 9813 { 9814 /* If we got an (EOF) error that caused the target 9815 to go away, then we're done, that's what we wanted. 9816 "k" is susceptible to cause a premature EOF, given 9817 that the remote server isn't actually required to 9818 reply to "k", and it can happen that it doesn't 9819 even get to reply ACK to the "k". */ 9820 return; 9821 } 9822 9823 /* Otherwise, something went wrong. We didn't actually kill 9824 the target. Just propagate the exception, and let the 9825 user or higher layers decide what to do. */ 9826 throw_exception (ex); 9827 } 9828 END_CATCH 9829} 9830 9831void 9832remote_target::mourn_inferior () 9833{ 9834 struct remote_state *rs = get_remote_state (); 9835 9836 /* We're no longer interested in notification events of an inferior 9837 that exited or was killed/detached. */ 9838 discard_pending_stop_replies (current_inferior ()); 9839 9840 /* In 'target remote' mode with one inferior, we close the connection. */ 9841 if (!rs->extended && number_of_live_inferiors () <= 1) 9842 { 9843 unpush_target (this); 9844 9845 /* remote_close takes care of doing most of the clean up. */ 9846 generic_mourn_inferior (); 9847 return; 9848 } 9849 9850 /* In case we got here due to an error, but we're going to stay 9851 connected. */ 9852 rs->waiting_for_stop_reply = 0; 9853 9854 /* If the current general thread belonged to the process we just 9855 detached from or has exited, the remote side current general 9856 thread becomes undefined. Considering a case like this: 9857 9858 - We just got here due to a detach. 9859 - The process that we're detaching from happens to immediately 9860 report a global breakpoint being hit in non-stop mode, in the 9861 same thread we had selected before. 9862 - GDB attaches to this process again. 9863 - This event happens to be the next event we handle. 9864 9865 GDB would consider that the current general thread didn't need to 9866 be set on the stub side (with Hg), since for all it knew, 9867 GENERAL_THREAD hadn't changed. 9868 9869 Notice that although in all-stop mode, the remote server always 9870 sets the current thread to the thread reporting the stop event, 9871 that doesn't happen in non-stop mode; in non-stop, the stub *must 9872 not* change the current thread when reporting a breakpoint hit, 9873 due to the decoupling of event reporting and event handling. 9874 9875 To keep things simple, we always invalidate our notion of the 9876 current thread. */ 9877 record_currthread (rs, minus_one_ptid); 9878 9879 /* Call common code to mark the inferior as not running. */ 9880 generic_mourn_inferior (); 9881 9882 if (!have_inferiors ()) 9883 { 9884 if (!remote_multi_process_p (rs)) 9885 { 9886 /* Check whether the target is running now - some remote stubs 9887 automatically restart after kill. */ 9888 putpkt ("?"); 9889 getpkt (&rs->buf, 0); 9890 9891 if (rs->buf[0] == 'S' || rs->buf[0] == 'T') 9892 { 9893 /* Assume that the target has been restarted. Set 9894 inferior_ptid so that bits of core GDB realizes 9895 there's something here, e.g., so that the user can 9896 say "kill" again. */ 9897 inferior_ptid = magic_null_ptid; 9898 } 9899 } 9900 } 9901} 9902 9903bool 9904extended_remote_target::supports_disable_randomization () 9905{ 9906 return packet_support (PACKET_QDisableRandomization) == PACKET_ENABLE; 9907} 9908 9909void 9910remote_target::extended_remote_disable_randomization (int val) 9911{ 9912 struct remote_state *rs = get_remote_state (); 9913 char *reply; 9914 9915 xsnprintf (rs->buf.data (), get_remote_packet_size (), 9916 "QDisableRandomization:%x", val); 9917 putpkt (rs->buf); 9918 reply = remote_get_noisy_reply (); 9919 if (*reply == '\0') 9920 error (_("Target does not support QDisableRandomization.")); 9921 if (strcmp (reply, "OK") != 0) 9922 error (_("Bogus QDisableRandomization reply from target: %s"), reply); 9923} 9924 9925int 9926remote_target::extended_remote_run (const std::string &args) 9927{ 9928 struct remote_state *rs = get_remote_state (); 9929 int len; 9930 const char *remote_exec_file = get_remote_exec_file (); 9931 9932 /* If the user has disabled vRun support, or we have detected that 9933 support is not available, do not try it. */ 9934 if (packet_support (PACKET_vRun) == PACKET_DISABLE) 9935 return -1; 9936 9937 strcpy (rs->buf.data (), "vRun;"); 9938 len = strlen (rs->buf.data ()); 9939 9940 if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ()) 9941 error (_("Remote file name too long for run packet")); 9942 len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf.data () + len, 9943 strlen (remote_exec_file)); 9944 9945 if (!args.empty ()) 9946 { 9947 int i; 9948 9949 gdb_argv argv (args.c_str ()); 9950 for (i = 0; argv[i] != NULL; i++) 9951 { 9952 if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ()) 9953 error (_("Argument list too long for run packet")); 9954 rs->buf[len++] = ';'; 9955 len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf.data () + len, 9956 strlen (argv[i])); 9957 } 9958 } 9959 9960 rs->buf[len++] = '\0'; 9961 9962 putpkt (rs->buf); 9963 getpkt (&rs->buf, 0); 9964 9965 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun])) 9966 { 9967 case PACKET_OK: 9968 /* We have a wait response. All is well. */ 9969 return 0; 9970 case PACKET_UNKNOWN: 9971 return -1; 9972 case PACKET_ERROR: 9973 if (remote_exec_file[0] == '\0') 9974 error (_("Running the default executable on the remote target failed; " 9975 "try \"set remote exec-file\"?")); 9976 else 9977 error (_("Running \"%s\" on the remote target failed"), 9978 remote_exec_file); 9979 default: 9980 gdb_assert_not_reached (_("bad switch")); 9981 } 9982} 9983 9984/* Helper function to send set/unset environment packets. ACTION is 9985 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded" 9986 or "QEnvironmentUnsetVariable". VALUE is the variable to be 9987 sent. */ 9988 9989void 9990remote_target::send_environment_packet (const char *action, 9991 const char *packet, 9992 const char *value) 9993{ 9994 remote_state *rs = get_remote_state (); 9995 9996 /* Convert the environment variable to an hex string, which 9997 is the best format to be transmitted over the wire. */ 9998 std::string encoded_value = bin2hex ((const gdb_byte *) value, 9999 strlen (value)); 10000 10001 xsnprintf (rs->buf.data (), get_remote_packet_size (), 10002 "%s:%s", packet, encoded_value.c_str ()); 10003 10004 putpkt (rs->buf); 10005 getpkt (&rs->buf, 0); 10006 if (strcmp (rs->buf.data (), "OK") != 0) 10007 warning (_("Unable to %s environment variable '%s' on remote."), 10008 action, value); 10009} 10010 10011/* Helper function to handle the QEnvironment* packets. */ 10012 10013void 10014remote_target::extended_remote_environment_support () 10015{ 10016 remote_state *rs = get_remote_state (); 10017 10018 if (packet_support (PACKET_QEnvironmentReset) != PACKET_DISABLE) 10019 { 10020 putpkt ("QEnvironmentReset"); 10021 getpkt (&rs->buf, 0); 10022 if (strcmp (rs->buf.data (), "OK") != 0) 10023 warning (_("Unable to reset environment on remote.")); 10024 } 10025 10026 gdb_environ *e = ¤t_inferior ()->environment; 10027 10028 if (packet_support (PACKET_QEnvironmentHexEncoded) != PACKET_DISABLE) 10029 for (const std::string &el : e->user_set_env ()) 10030 send_environment_packet ("set", "QEnvironmentHexEncoded", 10031 el.c_str ()); 10032 10033 if (packet_support (PACKET_QEnvironmentUnset) != PACKET_DISABLE) 10034 for (const std::string &el : e->user_unset_env ()) 10035 send_environment_packet ("unset", "QEnvironmentUnset", el.c_str ()); 10036} 10037 10038/* Helper function to set the current working directory for the 10039 inferior in the remote target. */ 10040 10041void 10042remote_target::extended_remote_set_inferior_cwd () 10043{ 10044 if (packet_support (PACKET_QSetWorkingDir) != PACKET_DISABLE) 10045 { 10046 const char *inferior_cwd = get_inferior_cwd (); 10047 remote_state *rs = get_remote_state (); 10048 10049 if (inferior_cwd != NULL) 10050 { 10051 std::string hexpath = bin2hex ((const gdb_byte *) inferior_cwd, 10052 strlen (inferior_cwd)); 10053 10054 xsnprintf (rs->buf.data (), get_remote_packet_size (), 10055 "QSetWorkingDir:%s", hexpath.c_str ()); 10056 } 10057 else 10058 { 10059 /* An empty inferior_cwd means that the user wants us to 10060 reset the remote server's inferior's cwd. */ 10061 xsnprintf (rs->buf.data (), get_remote_packet_size (), 10062 "QSetWorkingDir:"); 10063 } 10064 10065 putpkt (rs->buf); 10066 getpkt (&rs->buf, 0); 10067 if (packet_ok (rs->buf, 10068 &remote_protocol_packets[PACKET_QSetWorkingDir]) 10069 != PACKET_OK) 10070 error (_("\ 10071Remote replied unexpectedly while setting the inferior's working\n\ 10072directory: %s"), 10073 rs->buf.data ()); 10074 10075 } 10076} 10077 10078/* In the extended protocol we want to be able to do things like 10079 "run" and have them basically work as expected. So we need 10080 a special create_inferior function. We support changing the 10081 executable file and the command line arguments, but not the 10082 environment. */ 10083 10084void 10085extended_remote_target::create_inferior (const char *exec_file, 10086 const std::string &args, 10087 char **env, int from_tty) 10088{ 10089 int run_worked; 10090 char *stop_reply; 10091 struct remote_state *rs = get_remote_state (); 10092 const char *remote_exec_file = get_remote_exec_file (); 10093 10094 /* If running asynchronously, register the target file descriptor 10095 with the event loop. */ 10096 if (target_can_async_p ()) 10097 target_async (1); 10098 10099 /* Disable address space randomization if requested (and supported). */ 10100 if (supports_disable_randomization ()) 10101 extended_remote_disable_randomization (disable_randomization); 10102 10103 /* If startup-with-shell is on, we inform gdbserver to start the 10104 remote inferior using a shell. */ 10105 if (packet_support (PACKET_QStartupWithShell) != PACKET_DISABLE) 10106 { 10107 xsnprintf (rs->buf.data (), get_remote_packet_size (), 10108 "QStartupWithShell:%d", startup_with_shell ? 1 : 0); 10109 putpkt (rs->buf); 10110 getpkt (&rs->buf, 0); 10111 if (strcmp (rs->buf.data (), "OK") != 0) 10112 error (_("\ 10113Remote replied unexpectedly while setting startup-with-shell: %s"), 10114 rs->buf.data ()); 10115 } 10116 10117 extended_remote_environment_support (); 10118 10119 extended_remote_set_inferior_cwd (); 10120 10121 /* Now restart the remote server. */ 10122 run_worked = extended_remote_run (args) != -1; 10123 if (!run_worked) 10124 { 10125 /* vRun was not supported. Fail if we need it to do what the 10126 user requested. */ 10127 if (remote_exec_file[0]) 10128 error (_("Remote target does not support \"set remote exec-file\"")); 10129 if (!args.empty ()) 10130 error (_("Remote target does not support \"set args\" or run ARGS")); 10131 10132 /* Fall back to "R". */ 10133 extended_remote_restart (); 10134 } 10135 10136 /* vRun's success return is a stop reply. */ 10137 stop_reply = run_worked ? rs->buf.data () : NULL; 10138 add_current_inferior_and_thread (stop_reply); 10139 10140 /* Get updated offsets, if the stub uses qOffsets. */ 10141 get_offsets (); 10142} 10143 10144 10145/* Given a location's target info BP_TGT and the packet buffer BUF, output 10146 the list of conditions (in agent expression bytecode format), if any, the 10147 target needs to evaluate. The output is placed into the packet buffer 10148 started from BUF and ended at BUF_END. */ 10149 10150static int 10151remote_add_target_side_condition (struct gdbarch *gdbarch, 10152 struct bp_target_info *bp_tgt, char *buf, 10153 char *buf_end) 10154{ 10155 if (bp_tgt->conditions.empty ()) 10156 return 0; 10157 10158 buf += strlen (buf); 10159 xsnprintf (buf, buf_end - buf, "%s", ";"); 10160 buf++; 10161 10162 /* Send conditions to the target. */ 10163 for (agent_expr *aexpr : bp_tgt->conditions) 10164 { 10165 xsnprintf (buf, buf_end - buf, "X%x,", aexpr->len); 10166 buf += strlen (buf); 10167 for (int i = 0; i < aexpr->len; ++i) 10168 buf = pack_hex_byte (buf, aexpr->buf[i]); 10169 *buf = '\0'; 10170 } 10171 return 0; 10172} 10173 10174static void 10175remote_add_target_side_commands (struct gdbarch *gdbarch, 10176 struct bp_target_info *bp_tgt, char *buf) 10177{ 10178 if (bp_tgt->tcommands.empty ()) 10179 return; 10180 10181 buf += strlen (buf); 10182 10183 sprintf (buf, ";cmds:%x,", bp_tgt->persist); 10184 buf += strlen (buf); 10185 10186 /* Concatenate all the agent expressions that are commands into the 10187 cmds parameter. */ 10188 for (agent_expr *aexpr : bp_tgt->tcommands) 10189 { 10190 sprintf (buf, "X%x,", aexpr->len); 10191 buf += strlen (buf); 10192 for (int i = 0; i < aexpr->len; ++i) 10193 buf = pack_hex_byte (buf, aexpr->buf[i]); 10194 *buf = '\0'; 10195 } 10196} 10197 10198/* Insert a breakpoint. On targets that have software breakpoint 10199 support, we ask the remote target to do the work; on targets 10200 which don't, we insert a traditional memory breakpoint. */ 10201 10202int 10203remote_target::insert_breakpoint (struct gdbarch *gdbarch, 10204 struct bp_target_info *bp_tgt) 10205{ 10206 /* Try the "Z" s/w breakpoint packet if it is not already disabled. 10207 If it succeeds, then set the support to PACKET_ENABLE. If it 10208 fails, and the user has explicitly requested the Z support then 10209 report an error, otherwise, mark it disabled and go on. */ 10210 10211 if (packet_support (PACKET_Z0) != PACKET_DISABLE) 10212 { 10213 CORE_ADDR addr = bp_tgt->reqstd_address; 10214 struct remote_state *rs; 10215 char *p, *endbuf; 10216 10217 /* Make sure the remote is pointing at the right process, if 10218 necessary. */ 10219 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10220 set_general_process (); 10221 10222 rs = get_remote_state (); 10223 p = rs->buf.data (); 10224 endbuf = p + get_remote_packet_size (); 10225 10226 *(p++) = 'Z'; 10227 *(p++) = '0'; 10228 *(p++) = ','; 10229 addr = (ULONGEST) remote_address_masked (addr); 10230 p += hexnumstr (p, addr); 10231 xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind); 10232 10233 if (supports_evaluation_of_breakpoint_conditions ()) 10234 remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf); 10235 10236 if (can_run_breakpoint_commands ()) 10237 remote_add_target_side_commands (gdbarch, bp_tgt, p); 10238 10239 putpkt (rs->buf); 10240 getpkt (&rs->buf, 0); 10241 10242 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0])) 10243 { 10244 case PACKET_ERROR: 10245 return -1; 10246 case PACKET_OK: 10247 return 0; 10248 case PACKET_UNKNOWN: 10249 break; 10250 } 10251 } 10252 10253 /* If this breakpoint has target-side commands but this stub doesn't 10254 support Z0 packets, throw error. */ 10255 if (!bp_tgt->tcommands.empty ()) 10256 throw_error (NOT_SUPPORTED_ERROR, _("\ 10257Target doesn't support breakpoints that have target side commands.")); 10258 10259 return memory_insert_breakpoint (this, gdbarch, bp_tgt); 10260} 10261 10262int 10263remote_target::remove_breakpoint (struct gdbarch *gdbarch, 10264 struct bp_target_info *bp_tgt, 10265 enum remove_bp_reason reason) 10266{ 10267 CORE_ADDR addr = bp_tgt->placed_address; 10268 struct remote_state *rs = get_remote_state (); 10269 10270 if (packet_support (PACKET_Z0) != PACKET_DISABLE) 10271 { 10272 char *p = rs->buf.data (); 10273 char *endbuf = p + get_remote_packet_size (); 10274 10275 /* Make sure the remote is pointing at the right process, if 10276 necessary. */ 10277 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10278 set_general_process (); 10279 10280 *(p++) = 'z'; 10281 *(p++) = '0'; 10282 *(p++) = ','; 10283 10284 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address); 10285 p += hexnumstr (p, addr); 10286 xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind); 10287 10288 putpkt (rs->buf); 10289 getpkt (&rs->buf, 0); 10290 10291 return (rs->buf[0] == 'E'); 10292 } 10293 10294 return memory_remove_breakpoint (this, gdbarch, bp_tgt, reason); 10295} 10296 10297static enum Z_packet_type 10298watchpoint_to_Z_packet (int type) 10299{ 10300 switch (type) 10301 { 10302 case hw_write: 10303 return Z_PACKET_WRITE_WP; 10304 break; 10305 case hw_read: 10306 return Z_PACKET_READ_WP; 10307 break; 10308 case hw_access: 10309 return Z_PACKET_ACCESS_WP; 10310 break; 10311 default: 10312 internal_error (__FILE__, __LINE__, 10313 _("hw_bp_to_z: bad watchpoint type %d"), type); 10314 } 10315} 10316 10317int 10318remote_target::insert_watchpoint (CORE_ADDR addr, int len, 10319 enum target_hw_bp_type type, struct expression *cond) 10320{ 10321 struct remote_state *rs = get_remote_state (); 10322 char *endbuf = rs->buf.data () + get_remote_packet_size (); 10323 char *p; 10324 enum Z_packet_type packet = watchpoint_to_Z_packet (type); 10325 10326 if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE) 10327 return 1; 10328 10329 /* Make sure the remote is pointing at the right process, if 10330 necessary. */ 10331 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10332 set_general_process (); 10333 10334 xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "Z%x,", packet); 10335 p = strchr (rs->buf.data (), '\0'); 10336 addr = remote_address_masked (addr); 10337 p += hexnumstr (p, (ULONGEST) addr); 10338 xsnprintf (p, endbuf - p, ",%x", len); 10339 10340 putpkt (rs->buf); 10341 getpkt (&rs->buf, 0); 10342 10343 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet])) 10344 { 10345 case PACKET_ERROR: 10346 return -1; 10347 case PACKET_UNKNOWN: 10348 return 1; 10349 case PACKET_OK: 10350 return 0; 10351 } 10352 internal_error (__FILE__, __LINE__, 10353 _("remote_insert_watchpoint: reached end of function")); 10354} 10355 10356bool 10357remote_target::watchpoint_addr_within_range (CORE_ADDR addr, 10358 CORE_ADDR start, int length) 10359{ 10360 CORE_ADDR diff = remote_address_masked (addr - start); 10361 10362 return diff < length; 10363} 10364 10365 10366int 10367remote_target::remove_watchpoint (CORE_ADDR addr, int len, 10368 enum target_hw_bp_type type, struct expression *cond) 10369{ 10370 struct remote_state *rs = get_remote_state (); 10371 char *endbuf = rs->buf.data () + get_remote_packet_size (); 10372 char *p; 10373 enum Z_packet_type packet = watchpoint_to_Z_packet (type); 10374 10375 if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE) 10376 return -1; 10377 10378 /* Make sure the remote is pointing at the right process, if 10379 necessary. */ 10380 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10381 set_general_process (); 10382 10383 xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "z%x,", packet); 10384 p = strchr (rs->buf.data (), '\0'); 10385 addr = remote_address_masked (addr); 10386 p += hexnumstr (p, (ULONGEST) addr); 10387 xsnprintf (p, endbuf - p, ",%x", len); 10388 putpkt (rs->buf); 10389 getpkt (&rs->buf, 0); 10390 10391 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet])) 10392 { 10393 case PACKET_ERROR: 10394 case PACKET_UNKNOWN: 10395 return -1; 10396 case PACKET_OK: 10397 return 0; 10398 } 10399 internal_error (__FILE__, __LINE__, 10400 _("remote_remove_watchpoint: reached end of function")); 10401} 10402 10403 10404int remote_hw_watchpoint_limit = -1; 10405int remote_hw_watchpoint_length_limit = -1; 10406int remote_hw_breakpoint_limit = -1; 10407 10408int 10409remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) 10410{ 10411 if (remote_hw_watchpoint_length_limit == 0) 10412 return 0; 10413 else if (remote_hw_watchpoint_length_limit < 0) 10414 return 1; 10415 else if (len <= remote_hw_watchpoint_length_limit) 10416 return 1; 10417 else 10418 return 0; 10419} 10420 10421int 10422remote_target::can_use_hw_breakpoint (enum bptype type, int cnt, int ot) 10423{ 10424 if (type == bp_hardware_breakpoint) 10425 { 10426 if (remote_hw_breakpoint_limit == 0) 10427 return 0; 10428 else if (remote_hw_breakpoint_limit < 0) 10429 return 1; 10430 else if (cnt <= remote_hw_breakpoint_limit) 10431 return 1; 10432 } 10433 else 10434 { 10435 if (remote_hw_watchpoint_limit == 0) 10436 return 0; 10437 else if (remote_hw_watchpoint_limit < 0) 10438 return 1; 10439 else if (ot) 10440 return -1; 10441 else if (cnt <= remote_hw_watchpoint_limit) 10442 return 1; 10443 } 10444 return -1; 10445} 10446 10447/* The to_stopped_by_sw_breakpoint method of target remote. */ 10448 10449bool 10450remote_target::stopped_by_sw_breakpoint () 10451{ 10452 struct thread_info *thread = inferior_thread (); 10453 10454 return (thread->priv != NULL 10455 && (get_remote_thread_info (thread)->stop_reason 10456 == TARGET_STOPPED_BY_SW_BREAKPOINT)); 10457} 10458 10459/* The to_supports_stopped_by_sw_breakpoint method of target 10460 remote. */ 10461 10462bool 10463remote_target::supports_stopped_by_sw_breakpoint () 10464{ 10465 return (packet_support (PACKET_swbreak_feature) == PACKET_ENABLE); 10466} 10467 10468/* The to_stopped_by_hw_breakpoint method of target remote. */ 10469 10470bool 10471remote_target::stopped_by_hw_breakpoint () 10472{ 10473 struct thread_info *thread = inferior_thread (); 10474 10475 return (thread->priv != NULL 10476 && (get_remote_thread_info (thread)->stop_reason 10477 == TARGET_STOPPED_BY_HW_BREAKPOINT)); 10478} 10479 10480/* The to_supports_stopped_by_hw_breakpoint method of target 10481 remote. */ 10482 10483bool 10484remote_target::supports_stopped_by_hw_breakpoint () 10485{ 10486 return (packet_support (PACKET_hwbreak_feature) == PACKET_ENABLE); 10487} 10488 10489bool 10490remote_target::stopped_by_watchpoint () 10491{ 10492 struct thread_info *thread = inferior_thread (); 10493 10494 return (thread->priv != NULL 10495 && (get_remote_thread_info (thread)->stop_reason 10496 == TARGET_STOPPED_BY_WATCHPOINT)); 10497} 10498 10499bool 10500remote_target::stopped_data_address (CORE_ADDR *addr_p) 10501{ 10502 struct thread_info *thread = inferior_thread (); 10503 10504 if (thread->priv != NULL 10505 && (get_remote_thread_info (thread)->stop_reason 10506 == TARGET_STOPPED_BY_WATCHPOINT)) 10507 { 10508 *addr_p = get_remote_thread_info (thread)->watch_data_address; 10509 return true; 10510 } 10511 10512 return false; 10513} 10514 10515 10516int 10517remote_target::insert_hw_breakpoint (struct gdbarch *gdbarch, 10518 struct bp_target_info *bp_tgt) 10519{ 10520 CORE_ADDR addr = bp_tgt->reqstd_address; 10521 struct remote_state *rs; 10522 char *p, *endbuf; 10523 char *message; 10524 10525 if (packet_support (PACKET_Z1) == PACKET_DISABLE) 10526 return -1; 10527 10528 /* Make sure the remote is pointing at the right process, if 10529 necessary. */ 10530 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10531 set_general_process (); 10532 10533 rs = get_remote_state (); 10534 p = rs->buf.data (); 10535 endbuf = p + get_remote_packet_size (); 10536 10537 *(p++) = 'Z'; 10538 *(p++) = '1'; 10539 *(p++) = ','; 10540 10541 addr = remote_address_masked (addr); 10542 p += hexnumstr (p, (ULONGEST) addr); 10543 xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind); 10544 10545 if (supports_evaluation_of_breakpoint_conditions ()) 10546 remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf); 10547 10548 if (can_run_breakpoint_commands ()) 10549 remote_add_target_side_commands (gdbarch, bp_tgt, p); 10550 10551 putpkt (rs->buf); 10552 getpkt (&rs->buf, 0); 10553 10554 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1])) 10555 { 10556 case PACKET_ERROR: 10557 if (rs->buf[1] == '.') 10558 { 10559 message = strchr (&rs->buf[2], '.'); 10560 if (message) 10561 error (_("Remote failure reply: %s"), message + 1); 10562 } 10563 return -1; 10564 case PACKET_UNKNOWN: 10565 return -1; 10566 case PACKET_OK: 10567 return 0; 10568 } 10569 internal_error (__FILE__, __LINE__, 10570 _("remote_insert_hw_breakpoint: reached end of function")); 10571} 10572 10573 10574int 10575remote_target::remove_hw_breakpoint (struct gdbarch *gdbarch, 10576 struct bp_target_info *bp_tgt) 10577{ 10578 CORE_ADDR addr; 10579 struct remote_state *rs = get_remote_state (); 10580 char *p = rs->buf.data (); 10581 char *endbuf = p + get_remote_packet_size (); 10582 10583 if (packet_support (PACKET_Z1) == PACKET_DISABLE) 10584 return -1; 10585 10586 /* Make sure the remote is pointing at the right process, if 10587 necessary. */ 10588 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10589 set_general_process (); 10590 10591 *(p++) = 'z'; 10592 *(p++) = '1'; 10593 *(p++) = ','; 10594 10595 addr = remote_address_masked (bp_tgt->placed_address); 10596 p += hexnumstr (p, (ULONGEST) addr); 10597 xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind); 10598 10599 putpkt (rs->buf); 10600 getpkt (&rs->buf, 0); 10601 10602 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1])) 10603 { 10604 case PACKET_ERROR: 10605 case PACKET_UNKNOWN: 10606 return -1; 10607 case PACKET_OK: 10608 return 0; 10609 } 10610 internal_error (__FILE__, __LINE__, 10611 _("remote_remove_hw_breakpoint: reached end of function")); 10612} 10613 10614/* Verify memory using the "qCRC:" request. */ 10615 10616int 10617remote_target::verify_memory (const gdb_byte *data, CORE_ADDR lma, ULONGEST size) 10618{ 10619 struct remote_state *rs = get_remote_state (); 10620 unsigned long host_crc, target_crc; 10621 char *tmp; 10622 10623 /* It doesn't make sense to use qCRC if the remote target is 10624 connected but not running. */ 10625 if (target_has_execution && packet_support (PACKET_qCRC) != PACKET_DISABLE) 10626 { 10627 enum packet_result result; 10628 10629 /* Make sure the remote is pointing at the right process. */ 10630 set_general_process (); 10631 10632 /* FIXME: assumes lma can fit into long. */ 10633 xsnprintf (rs->buf.data (), get_remote_packet_size (), "qCRC:%lx,%lx", 10634 (long) lma, (long) size); 10635 putpkt (rs->buf); 10636 10637 /* Be clever; compute the host_crc before waiting for target 10638 reply. */ 10639 host_crc = xcrc32 (data, size, 0xffffffff); 10640 10641 getpkt (&rs->buf, 0); 10642 10643 result = packet_ok (rs->buf, 10644 &remote_protocol_packets[PACKET_qCRC]); 10645 if (result == PACKET_ERROR) 10646 return -1; 10647 else if (result == PACKET_OK) 10648 { 10649 for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++) 10650 target_crc = target_crc * 16 + fromhex (*tmp); 10651 10652 return (host_crc == target_crc); 10653 } 10654 } 10655 10656 return simple_verify_memory (this, data, lma, size); 10657} 10658 10659/* compare-sections command 10660 10661 With no arguments, compares each loadable section in the exec bfd 10662 with the same memory range on the target, and reports mismatches. 10663 Useful for verifying the image on the target against the exec file. */ 10664 10665static void 10666compare_sections_command (const char *args, int from_tty) 10667{ 10668 asection *s; 10669 const char *sectname; 10670 bfd_size_type size; 10671 bfd_vma lma; 10672 int matched = 0; 10673 int mismatched = 0; 10674 int res; 10675 int read_only = 0; 10676 10677 if (!exec_bfd) 10678 error (_("command cannot be used without an exec file")); 10679 10680 if (args != NULL && strcmp (args, "-r") == 0) 10681 { 10682 read_only = 1; 10683 args = NULL; 10684 } 10685 10686 for (s = exec_bfd->sections; s; s = s->next) 10687 { 10688 if (!(s->flags & SEC_LOAD)) 10689 continue; /* Skip non-loadable section. */ 10690 10691 if (read_only && (s->flags & SEC_READONLY) == 0) 10692 continue; /* Skip writeable sections */ 10693 10694 size = bfd_get_section_size (s); 10695 if (size == 0) 10696 continue; /* Skip zero-length section. */ 10697 10698 sectname = bfd_get_section_name (exec_bfd, s); 10699 if (args && strcmp (args, sectname) != 0) 10700 continue; /* Not the section selected by user. */ 10701 10702 matched = 1; /* Do this section. */ 10703 lma = s->lma; 10704 10705 gdb::byte_vector sectdata (size); 10706 bfd_get_section_contents (exec_bfd, s, sectdata.data (), 0, size); 10707 10708 res = target_verify_memory (sectdata.data (), lma, size); 10709 10710 if (res == -1) 10711 error (_("target memory fault, section %s, range %s -- %s"), sectname, 10712 paddress (target_gdbarch (), lma), 10713 paddress (target_gdbarch (), lma + size)); 10714 10715 printf_filtered ("Section %s, range %s -- %s: ", sectname, 10716 paddress (target_gdbarch (), lma), 10717 paddress (target_gdbarch (), lma + size)); 10718 if (res) 10719 printf_filtered ("matched.\n"); 10720 else 10721 { 10722 printf_filtered ("MIS-MATCHED!\n"); 10723 mismatched++; 10724 } 10725 } 10726 if (mismatched > 0) 10727 warning (_("One or more sections of the target image does not match\n\ 10728the loaded file\n")); 10729 if (args && !matched) 10730 printf_filtered (_("No loaded section named '%s'.\n"), args); 10731} 10732 10733/* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET 10734 into remote target. The number of bytes written to the remote 10735 target is returned, or -1 for error. */ 10736 10737target_xfer_status 10738remote_target::remote_write_qxfer (const char *object_name, 10739 const char *annex, const gdb_byte *writebuf, 10740 ULONGEST offset, LONGEST len, 10741 ULONGEST *xfered_len, 10742 struct packet_config *packet) 10743{ 10744 int i, buf_len; 10745 ULONGEST n; 10746 struct remote_state *rs = get_remote_state (); 10747 int max_size = get_memory_write_packet_size (); 10748 10749 if (packet_config_support (packet) == PACKET_DISABLE) 10750 return TARGET_XFER_E_IO; 10751 10752 /* Insert header. */ 10753 i = snprintf (rs->buf.data (), max_size, 10754 "qXfer:%s:write:%s:%s:", 10755 object_name, annex ? annex : "", 10756 phex_nz (offset, sizeof offset)); 10757 max_size -= (i + 1); 10758 10759 /* Escape as much data as fits into rs->buf. */ 10760 buf_len = remote_escape_output 10761 (writebuf, len, 1, (gdb_byte *) rs->buf.data () + i, &max_size, max_size); 10762 10763 if (putpkt_binary (rs->buf.data (), i + buf_len) < 0 10764 || getpkt_sane (&rs->buf, 0) < 0 10765 || packet_ok (rs->buf, packet) != PACKET_OK) 10766 return TARGET_XFER_E_IO; 10767 10768 unpack_varlen_hex (rs->buf.data (), &n); 10769 10770 *xfered_len = n; 10771 return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF; 10772} 10773 10774/* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet. 10775 Data at OFFSET, of up to LEN bytes, is read into READBUF; the 10776 number of bytes read is returned, or 0 for EOF, or -1 for error. 10777 The number of bytes read may be less than LEN without indicating an 10778 EOF. PACKET is checked and updated to indicate whether the remote 10779 target supports this object. */ 10780 10781target_xfer_status 10782remote_target::remote_read_qxfer (const char *object_name, 10783 const char *annex, 10784 gdb_byte *readbuf, ULONGEST offset, 10785 LONGEST len, 10786 ULONGEST *xfered_len, 10787 struct packet_config *packet) 10788{ 10789 struct remote_state *rs = get_remote_state (); 10790 LONGEST i, n, packet_len; 10791 10792 if (packet_config_support (packet) == PACKET_DISABLE) 10793 return TARGET_XFER_E_IO; 10794 10795 /* Check whether we've cached an end-of-object packet that matches 10796 this request. */ 10797 if (rs->finished_object) 10798 { 10799 if (strcmp (object_name, rs->finished_object) == 0 10800 && strcmp (annex ? annex : "", rs->finished_annex) == 0 10801 && offset == rs->finished_offset) 10802 return TARGET_XFER_EOF; 10803 10804 10805 /* Otherwise, we're now reading something different. Discard 10806 the cache. */ 10807 xfree (rs->finished_object); 10808 xfree (rs->finished_annex); 10809 rs->finished_object = NULL; 10810 rs->finished_annex = NULL; 10811 } 10812 10813 /* Request only enough to fit in a single packet. The actual data 10814 may not, since we don't know how much of it will need to be escaped; 10815 the target is free to respond with slightly less data. We subtract 10816 five to account for the response type and the protocol frame. */ 10817 n = std::min<LONGEST> (get_remote_packet_size () - 5, len); 10818 snprintf (rs->buf.data (), get_remote_packet_size () - 4, 10819 "qXfer:%s:read:%s:%s,%s", 10820 object_name, annex ? annex : "", 10821 phex_nz (offset, sizeof offset), 10822 phex_nz (n, sizeof n)); 10823 i = putpkt (rs->buf); 10824 if (i < 0) 10825 return TARGET_XFER_E_IO; 10826 10827 rs->buf[0] = '\0'; 10828 packet_len = getpkt_sane (&rs->buf, 0); 10829 if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK) 10830 return TARGET_XFER_E_IO; 10831 10832 if (rs->buf[0] != 'l' && rs->buf[0] != 'm') 10833 error (_("Unknown remote qXfer reply: %s"), rs->buf.data ()); 10834 10835 /* 'm' means there is (or at least might be) more data after this 10836 batch. That does not make sense unless there's at least one byte 10837 of data in this reply. */ 10838 if (rs->buf[0] == 'm' && packet_len == 1) 10839 error (_("Remote qXfer reply contained no data.")); 10840 10841 /* Got some data. */ 10842 i = remote_unescape_input ((gdb_byte *) rs->buf.data () + 1, 10843 packet_len - 1, readbuf, n); 10844 10845 /* 'l' is an EOF marker, possibly including a final block of data, 10846 or possibly empty. If we have the final block of a non-empty 10847 object, record this fact to bypass a subsequent partial read. */ 10848 if (rs->buf[0] == 'l' && offset + i > 0) 10849 { 10850 rs->finished_object = xstrdup (object_name); 10851 rs->finished_annex = xstrdup (annex ? annex : ""); 10852 rs->finished_offset = offset + i; 10853 } 10854 10855 if (i == 0) 10856 return TARGET_XFER_EOF; 10857 else 10858 { 10859 *xfered_len = i; 10860 return TARGET_XFER_OK; 10861 } 10862} 10863 10864enum target_xfer_status 10865remote_target::xfer_partial (enum target_object object, 10866 const char *annex, gdb_byte *readbuf, 10867 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, 10868 ULONGEST *xfered_len) 10869{ 10870 struct remote_state *rs; 10871 int i; 10872 char *p2; 10873 char query_type; 10874 int unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ()); 10875 10876 set_remote_traceframe (); 10877 set_general_thread (inferior_ptid); 10878 10879 rs = get_remote_state (); 10880 10881 /* Handle memory using the standard memory routines. */ 10882 if (object == TARGET_OBJECT_MEMORY) 10883 { 10884 /* If the remote target is connected but not running, we should 10885 pass this request down to a lower stratum (e.g. the executable 10886 file). */ 10887 if (!target_has_execution) 10888 return TARGET_XFER_EOF; 10889 10890 if (writebuf != NULL) 10891 return remote_write_bytes (offset, writebuf, len, unit_size, 10892 xfered_len); 10893 else 10894 return remote_read_bytes (offset, readbuf, len, unit_size, 10895 xfered_len); 10896 } 10897 10898 /* Handle SPU memory using qxfer packets. */ 10899 if (object == TARGET_OBJECT_SPU) 10900 { 10901 if (readbuf) 10902 return remote_read_qxfer ("spu", annex, readbuf, offset, len, 10903 xfered_len, &remote_protocol_packets 10904 [PACKET_qXfer_spu_read]); 10905 else 10906 return remote_write_qxfer ("spu", annex, writebuf, offset, len, 10907 xfered_len, &remote_protocol_packets 10908 [PACKET_qXfer_spu_write]); 10909 } 10910 10911 /* Handle extra signal info using qxfer packets. */ 10912 if (object == TARGET_OBJECT_SIGNAL_INFO) 10913 { 10914 if (readbuf) 10915 return remote_read_qxfer ("siginfo", annex, readbuf, offset, len, 10916 xfered_len, &remote_protocol_packets 10917 [PACKET_qXfer_siginfo_read]); 10918 else 10919 return remote_write_qxfer ("siginfo", annex, 10920 writebuf, offset, len, xfered_len, 10921 &remote_protocol_packets 10922 [PACKET_qXfer_siginfo_write]); 10923 } 10924 10925 if (object == TARGET_OBJECT_STATIC_TRACE_DATA) 10926 { 10927 if (readbuf) 10928 return remote_read_qxfer ("statictrace", annex, 10929 readbuf, offset, len, xfered_len, 10930 &remote_protocol_packets 10931 [PACKET_qXfer_statictrace_read]); 10932 else 10933 return TARGET_XFER_E_IO; 10934 } 10935 10936 /* Only handle flash writes. */ 10937 if (writebuf != NULL) 10938 { 10939 switch (object) 10940 { 10941 case TARGET_OBJECT_FLASH: 10942 return remote_flash_write (offset, len, xfered_len, 10943 writebuf); 10944 10945 default: 10946 return TARGET_XFER_E_IO; 10947 } 10948 } 10949 10950 /* Map pre-existing objects onto letters. DO NOT do this for new 10951 objects!!! Instead specify new query packets. */ 10952 switch (object) 10953 { 10954 case TARGET_OBJECT_AVR: 10955 query_type = 'R'; 10956 break; 10957 10958 case TARGET_OBJECT_AUXV: 10959 gdb_assert (annex == NULL); 10960 return remote_read_qxfer ("auxv", annex, readbuf, offset, len, 10961 xfered_len, 10962 &remote_protocol_packets[PACKET_qXfer_auxv]); 10963 10964 case TARGET_OBJECT_AVAILABLE_FEATURES: 10965 return remote_read_qxfer 10966 ("features", annex, readbuf, offset, len, xfered_len, 10967 &remote_protocol_packets[PACKET_qXfer_features]); 10968 10969 case TARGET_OBJECT_LIBRARIES: 10970 return remote_read_qxfer 10971 ("libraries", annex, readbuf, offset, len, xfered_len, 10972 &remote_protocol_packets[PACKET_qXfer_libraries]); 10973 10974 case TARGET_OBJECT_LIBRARIES_SVR4: 10975 return remote_read_qxfer 10976 ("libraries-svr4", annex, readbuf, offset, len, xfered_len, 10977 &remote_protocol_packets[PACKET_qXfer_libraries_svr4]); 10978 10979 case TARGET_OBJECT_MEMORY_MAP: 10980 gdb_assert (annex == NULL); 10981 return remote_read_qxfer ("memory-map", annex, readbuf, offset, len, 10982 xfered_len, 10983 &remote_protocol_packets[PACKET_qXfer_memory_map]); 10984 10985 case TARGET_OBJECT_OSDATA: 10986 /* Should only get here if we're connected. */ 10987 gdb_assert (rs->remote_desc); 10988 return remote_read_qxfer 10989 ("osdata", annex, readbuf, offset, len, xfered_len, 10990 &remote_protocol_packets[PACKET_qXfer_osdata]); 10991 10992 case TARGET_OBJECT_THREADS: 10993 gdb_assert (annex == NULL); 10994 return remote_read_qxfer ("threads", annex, readbuf, offset, len, 10995 xfered_len, 10996 &remote_protocol_packets[PACKET_qXfer_threads]); 10997 10998 case TARGET_OBJECT_TRACEFRAME_INFO: 10999 gdb_assert (annex == NULL); 11000 return remote_read_qxfer 11001 ("traceframe-info", annex, readbuf, offset, len, xfered_len, 11002 &remote_protocol_packets[PACKET_qXfer_traceframe_info]); 11003 11004 case TARGET_OBJECT_FDPIC: 11005 return remote_read_qxfer ("fdpic", annex, readbuf, offset, len, 11006 xfered_len, 11007 &remote_protocol_packets[PACKET_qXfer_fdpic]); 11008 11009 case TARGET_OBJECT_OPENVMS_UIB: 11010 return remote_read_qxfer ("uib", annex, readbuf, offset, len, 11011 xfered_len, 11012 &remote_protocol_packets[PACKET_qXfer_uib]); 11013 11014 case TARGET_OBJECT_BTRACE: 11015 return remote_read_qxfer ("btrace", annex, readbuf, offset, len, 11016 xfered_len, 11017 &remote_protocol_packets[PACKET_qXfer_btrace]); 11018 11019 case TARGET_OBJECT_BTRACE_CONF: 11020 return remote_read_qxfer ("btrace-conf", annex, readbuf, offset, 11021 len, xfered_len, 11022 &remote_protocol_packets[PACKET_qXfer_btrace_conf]); 11023 11024 case TARGET_OBJECT_EXEC_FILE: 11025 return remote_read_qxfer ("exec-file", annex, readbuf, offset, 11026 len, xfered_len, 11027 &remote_protocol_packets[PACKET_qXfer_exec_file]); 11028 11029 default: 11030 return TARGET_XFER_E_IO; 11031 } 11032 11033 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not 11034 large enough let the caller deal with it. */ 11035 if (len < get_remote_packet_size ()) 11036 return TARGET_XFER_E_IO; 11037 len = get_remote_packet_size (); 11038 11039 /* Except for querying the minimum buffer size, target must be open. */ 11040 if (!rs->remote_desc) 11041 error (_("remote query is only available after target open")); 11042 11043 gdb_assert (annex != NULL); 11044 gdb_assert (readbuf != NULL); 11045 11046 p2 = rs->buf.data (); 11047 *p2++ = 'q'; 11048 *p2++ = query_type; 11049 11050 /* We used one buffer char for the remote protocol q command and 11051 another for the query type. As the remote protocol encapsulation 11052 uses 4 chars plus one extra in case we are debugging 11053 (remote_debug), we have PBUFZIZ - 7 left to pack the query 11054 string. */ 11055 i = 0; 11056 while (annex[i] && (i < (get_remote_packet_size () - 8))) 11057 { 11058 /* Bad caller may have sent forbidden characters. */ 11059 gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#'); 11060 *p2++ = annex[i]; 11061 i++; 11062 } 11063 *p2 = '\0'; 11064 gdb_assert (annex[i] == '\0'); 11065 11066 i = putpkt (rs->buf); 11067 if (i < 0) 11068 return TARGET_XFER_E_IO; 11069 11070 getpkt (&rs->buf, 0); 11071 strcpy ((char *) readbuf, rs->buf.data ()); 11072 11073 *xfered_len = strlen ((char *) readbuf); 11074 return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF; 11075} 11076 11077/* Implementation of to_get_memory_xfer_limit. */ 11078 11079ULONGEST 11080remote_target::get_memory_xfer_limit () 11081{ 11082 return get_memory_write_packet_size (); 11083} 11084 11085int 11086remote_target::search_memory (CORE_ADDR start_addr, ULONGEST search_space_len, 11087 const gdb_byte *pattern, ULONGEST pattern_len, 11088 CORE_ADDR *found_addrp) 11089{ 11090 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; 11091 struct remote_state *rs = get_remote_state (); 11092 int max_size = get_memory_write_packet_size (); 11093 struct packet_config *packet = 11094 &remote_protocol_packets[PACKET_qSearch_memory]; 11095 /* Number of packet bytes used to encode the pattern; 11096 this could be more than PATTERN_LEN due to escape characters. */ 11097 int escaped_pattern_len; 11098 /* Amount of pattern that was encodable in the packet. */ 11099 int used_pattern_len; 11100 int i; 11101 int found; 11102 ULONGEST found_addr; 11103 11104 /* Don't go to the target if we don't have to. This is done before 11105 checking packet_config_support to avoid the possibility that a 11106 success for this edge case means the facility works in 11107 general. */ 11108 if (pattern_len > search_space_len) 11109 return 0; 11110 if (pattern_len == 0) 11111 { 11112 *found_addrp = start_addr; 11113 return 1; 11114 } 11115 11116 /* If we already know the packet isn't supported, fall back to the simple 11117 way of searching memory. */ 11118 11119 if (packet_config_support (packet) == PACKET_DISABLE) 11120 { 11121 /* Target doesn't provided special support, fall back and use the 11122 standard support (copy memory and do the search here). */ 11123 return simple_search_memory (this, start_addr, search_space_len, 11124 pattern, pattern_len, found_addrp); 11125 } 11126 11127 /* Make sure the remote is pointing at the right process. */ 11128 set_general_process (); 11129 11130 /* Insert header. */ 11131 i = snprintf (rs->buf.data (), max_size, 11132 "qSearch:memory:%s;%s;", 11133 phex_nz (start_addr, addr_size), 11134 phex_nz (search_space_len, sizeof (search_space_len))); 11135 max_size -= (i + 1); 11136 11137 /* Escape as much data as fits into rs->buf. */ 11138 escaped_pattern_len = 11139 remote_escape_output (pattern, pattern_len, 1, 11140 (gdb_byte *) rs->buf.data () + i, 11141 &used_pattern_len, max_size); 11142 11143 /* Bail if the pattern is too large. */ 11144 if (used_pattern_len != pattern_len) 11145 error (_("Pattern is too large to transmit to remote target.")); 11146 11147 if (putpkt_binary (rs->buf.data (), i + escaped_pattern_len) < 0 11148 || getpkt_sane (&rs->buf, 0) < 0 11149 || packet_ok (rs->buf, packet) != PACKET_OK) 11150 { 11151 /* The request may not have worked because the command is not 11152 supported. If so, fall back to the simple way. */ 11153 if (packet_config_support (packet) == PACKET_DISABLE) 11154 { 11155 return simple_search_memory (this, start_addr, search_space_len, 11156 pattern, pattern_len, found_addrp); 11157 } 11158 return -1; 11159 } 11160 11161 if (rs->buf[0] == '0') 11162 found = 0; 11163 else if (rs->buf[0] == '1') 11164 { 11165 found = 1; 11166 if (rs->buf[1] != ',') 11167 error (_("Unknown qSearch:memory reply: %s"), rs->buf.data ()); 11168 unpack_varlen_hex (&rs->buf[2], &found_addr); 11169 *found_addrp = found_addr; 11170 } 11171 else 11172 error (_("Unknown qSearch:memory reply: %s"), rs->buf.data ()); 11173 11174 return found; 11175} 11176 11177void 11178remote_target::rcmd (const char *command, struct ui_file *outbuf) 11179{ 11180 struct remote_state *rs = get_remote_state (); 11181 char *p = rs->buf.data (); 11182 11183 if (!rs->remote_desc) 11184 error (_("remote rcmd is only available after target open")); 11185 11186 /* Send a NULL command across as an empty command. */ 11187 if (command == NULL) 11188 command = ""; 11189 11190 /* The query prefix. */ 11191 strcpy (rs->buf.data (), "qRcmd,"); 11192 p = strchr (rs->buf.data (), '\0'); 11193 11194 if ((strlen (rs->buf.data ()) + strlen (command) * 2 + 8/*misc*/) 11195 > get_remote_packet_size ()) 11196 error (_("\"monitor\" command ``%s'' is too long."), command); 11197 11198 /* Encode the actual command. */ 11199 bin2hex ((const gdb_byte *) command, p, strlen (command)); 11200 11201 if (putpkt (rs->buf) < 0) 11202 error (_("Communication problem with target.")); 11203 11204 /* get/display the response */ 11205 while (1) 11206 { 11207 char *buf; 11208 11209 /* XXX - see also remote_get_noisy_reply(). */ 11210 QUIT; /* Allow user to bail out with ^C. */ 11211 rs->buf[0] = '\0'; 11212 if (getpkt_sane (&rs->buf, 0) == -1) 11213 { 11214 /* Timeout. Continue to (try to) read responses. 11215 This is better than stopping with an error, assuming the stub 11216 is still executing the (long) monitor command. 11217 If needed, the user can interrupt gdb using C-c, obtaining 11218 an effect similar to stop on timeout. */ 11219 continue; 11220 } 11221 buf = rs->buf.data (); 11222 if (buf[0] == '\0') 11223 error (_("Target does not support this command.")); 11224 if (buf[0] == 'O' && buf[1] != 'K') 11225 { 11226 remote_console_output (buf + 1); /* 'O' message from stub. */ 11227 continue; 11228 } 11229 if (strcmp (buf, "OK") == 0) 11230 break; 11231 if (strlen (buf) == 3 && buf[0] == 'E' 11232 && isdigit (buf[1]) && isdigit (buf[2])) 11233 { 11234 error (_("Protocol error with Rcmd")); 11235 } 11236 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2) 11237 { 11238 char c = (fromhex (p[0]) << 4) + fromhex (p[1]); 11239 11240 fputc_unfiltered (c, outbuf); 11241 } 11242 break; 11243 } 11244} 11245 11246std::vector<mem_region> 11247remote_target::memory_map () 11248{ 11249 std::vector<mem_region> result; 11250 gdb::optional<gdb::char_vector> text 11251 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP, NULL); 11252 11253 if (text) 11254 result = parse_memory_map (text->data ()); 11255 11256 return result; 11257} 11258 11259static void 11260packet_command (const char *args, int from_tty) 11261{ 11262 remote_target *remote = get_current_remote_target (); 11263 11264 if (remote == nullptr) 11265 error (_("command can only be used with remote target")); 11266 11267 remote->packet_command (args, from_tty); 11268} 11269 11270void 11271remote_target::packet_command (const char *args, int from_tty) 11272{ 11273 if (!args) 11274 error (_("remote-packet command requires packet text as argument")); 11275 11276 puts_filtered ("sending: "); 11277 print_packet (args); 11278 puts_filtered ("\n"); 11279 putpkt (args); 11280 11281 remote_state *rs = get_remote_state (); 11282 11283 getpkt (&rs->buf, 0); 11284 puts_filtered ("received: "); 11285 print_packet (rs->buf.data ()); 11286 puts_filtered ("\n"); 11287} 11288 11289#if 0 11290/* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */ 11291 11292static void display_thread_info (struct gdb_ext_thread_info *info); 11293 11294static void threadset_test_cmd (char *cmd, int tty); 11295 11296static void threadalive_test (char *cmd, int tty); 11297 11298static void threadlist_test_cmd (char *cmd, int tty); 11299 11300int get_and_display_threadinfo (threadref *ref); 11301 11302static void threadinfo_test_cmd (char *cmd, int tty); 11303 11304static int thread_display_step (threadref *ref, void *context); 11305 11306static void threadlist_update_test_cmd (char *cmd, int tty); 11307 11308static void init_remote_threadtests (void); 11309 11310#define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */ 11311 11312static void 11313threadset_test_cmd (const char *cmd, int tty) 11314{ 11315 int sample_thread = SAMPLE_THREAD; 11316 11317 printf_filtered (_("Remote threadset test\n")); 11318 set_general_thread (sample_thread); 11319} 11320 11321 11322static void 11323threadalive_test (const char *cmd, int tty) 11324{ 11325 int sample_thread = SAMPLE_THREAD; 11326 int pid = inferior_ptid.pid (); 11327 ptid_t ptid = ptid_t (pid, sample_thread, 0); 11328 11329 if (remote_thread_alive (ptid)) 11330 printf_filtered ("PASS: Thread alive test\n"); 11331 else 11332 printf_filtered ("FAIL: Thread alive test\n"); 11333} 11334 11335void output_threadid (char *title, threadref *ref); 11336 11337void 11338output_threadid (char *title, threadref *ref) 11339{ 11340 char hexid[20]; 11341 11342 pack_threadid (&hexid[0], ref); /* Convert threead id into hex. */ 11343 hexid[16] = 0; 11344 printf_filtered ("%s %s\n", title, (&hexid[0])); 11345} 11346 11347static void 11348threadlist_test_cmd (const char *cmd, int tty) 11349{ 11350 int startflag = 1; 11351 threadref nextthread; 11352 int done, result_count; 11353 threadref threadlist[3]; 11354 11355 printf_filtered ("Remote Threadlist test\n"); 11356 if (!remote_get_threadlist (startflag, &nextthread, 3, &done, 11357 &result_count, &threadlist[0])) 11358 printf_filtered ("FAIL: threadlist test\n"); 11359 else 11360 { 11361 threadref *scan = threadlist; 11362 threadref *limit = scan + result_count; 11363 11364 while (scan < limit) 11365 output_threadid (" thread ", scan++); 11366 } 11367} 11368 11369void 11370display_thread_info (struct gdb_ext_thread_info *info) 11371{ 11372 output_threadid ("Threadid: ", &info->threadid); 11373 printf_filtered ("Name: %s\n ", info->shortname); 11374 printf_filtered ("State: %s\n", info->display); 11375 printf_filtered ("other: %s\n\n", info->more_display); 11376} 11377 11378int 11379get_and_display_threadinfo (threadref *ref) 11380{ 11381 int result; 11382 int set; 11383 struct gdb_ext_thread_info threadinfo; 11384 11385 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME 11386 | TAG_MOREDISPLAY | TAG_DISPLAY; 11387 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo))) 11388 display_thread_info (&threadinfo); 11389 return result; 11390} 11391 11392static void 11393threadinfo_test_cmd (const char *cmd, int tty) 11394{ 11395 int athread = SAMPLE_THREAD; 11396 threadref thread; 11397 int set; 11398 11399 int_to_threadref (&thread, athread); 11400 printf_filtered ("Remote Threadinfo test\n"); 11401 if (!get_and_display_threadinfo (&thread)) 11402 printf_filtered ("FAIL cannot get thread info\n"); 11403} 11404 11405static int 11406thread_display_step (threadref *ref, void *context) 11407{ 11408 /* output_threadid(" threadstep ",ref); *//* simple test */ 11409 return get_and_display_threadinfo (ref); 11410} 11411 11412static void 11413threadlist_update_test_cmd (const char *cmd, int tty) 11414{ 11415 printf_filtered ("Remote Threadlist update test\n"); 11416 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS); 11417} 11418 11419static void 11420init_remote_threadtests (void) 11421{ 11422 add_com ("tlist", class_obscure, threadlist_test_cmd, 11423 _("Fetch and print the remote list of " 11424 "thread identifiers, one pkt only")); 11425 add_com ("tinfo", class_obscure, threadinfo_test_cmd, 11426 _("Fetch and display info about one thread")); 11427 add_com ("tset", class_obscure, threadset_test_cmd, 11428 _("Test setting to a different thread")); 11429 add_com ("tupd", class_obscure, threadlist_update_test_cmd, 11430 _("Iterate through updating all remote thread info")); 11431 add_com ("talive", class_obscure, threadalive_test, 11432 _(" Remote thread alive test ")); 11433} 11434 11435#endif /* 0 */ 11436 11437/* Convert a thread ID to a string. Returns the string in a static 11438 buffer. */ 11439 11440const char * 11441remote_target::pid_to_str (ptid_t ptid) 11442{ 11443 static char buf[64]; 11444 struct remote_state *rs = get_remote_state (); 11445 11446 if (ptid == null_ptid) 11447 return normal_pid_to_str (ptid); 11448 else if (ptid.is_pid ()) 11449 { 11450 /* Printing an inferior target id. */ 11451 11452 /* When multi-process extensions are off, there's no way in the 11453 remote protocol to know the remote process id, if there's any 11454 at all. There's one exception --- when we're connected with 11455 target extended-remote, and we manually attached to a process 11456 with "attach PID". We don't record anywhere a flag that 11457 allows us to distinguish that case from the case of 11458 connecting with extended-remote and the stub already being 11459 attached to a process, and reporting yes to qAttached, hence 11460 no smart special casing here. */ 11461 if (!remote_multi_process_p (rs)) 11462 { 11463 xsnprintf (buf, sizeof buf, "Remote target"); 11464 return buf; 11465 } 11466 11467 return normal_pid_to_str (ptid); 11468 } 11469 else 11470 { 11471 if (magic_null_ptid == ptid) 11472 xsnprintf (buf, sizeof buf, "Thread <main>"); 11473 else if (remote_multi_process_p (rs)) 11474 if (ptid.lwp () == 0) 11475 return normal_pid_to_str (ptid); 11476 else 11477 xsnprintf (buf, sizeof buf, "Thread %d.%ld", 11478 ptid.pid (), ptid.lwp ()); 11479 else 11480 xsnprintf (buf, sizeof buf, "Thread %ld", 11481 ptid.lwp ()); 11482 return buf; 11483 } 11484} 11485 11486/* Get the address of the thread local variable in OBJFILE which is 11487 stored at OFFSET within the thread local storage for thread PTID. */ 11488 11489CORE_ADDR 11490remote_target::get_thread_local_address (ptid_t ptid, CORE_ADDR lm, 11491 CORE_ADDR offset) 11492{ 11493 if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE) 11494 { 11495 struct remote_state *rs = get_remote_state (); 11496 char *p = rs->buf.data (); 11497 char *endp = p + get_remote_packet_size (); 11498 enum packet_result result; 11499 11500 strcpy (p, "qGetTLSAddr:"); 11501 p += strlen (p); 11502 p = write_ptid (p, endp, ptid); 11503 *p++ = ','; 11504 p += hexnumstr (p, offset); 11505 *p++ = ','; 11506 p += hexnumstr (p, lm); 11507 *p++ = '\0'; 11508 11509 putpkt (rs->buf); 11510 getpkt (&rs->buf, 0); 11511 result = packet_ok (rs->buf, 11512 &remote_protocol_packets[PACKET_qGetTLSAddr]); 11513 if (result == PACKET_OK) 11514 { 11515 ULONGEST addr; 11516 11517 unpack_varlen_hex (rs->buf.data (), &addr); 11518 return addr; 11519 } 11520 else if (result == PACKET_UNKNOWN) 11521 throw_error (TLS_GENERIC_ERROR, 11522 _("Remote target doesn't support qGetTLSAddr packet")); 11523 else 11524 throw_error (TLS_GENERIC_ERROR, 11525 _("Remote target failed to process qGetTLSAddr request")); 11526 } 11527 else 11528 throw_error (TLS_GENERIC_ERROR, 11529 _("TLS not supported or disabled on this target")); 11530 /* Not reached. */ 11531 return 0; 11532} 11533 11534/* Provide thread local base, i.e. Thread Information Block address. 11535 Returns 1 if ptid is found and thread_local_base is non zero. */ 11536 11537bool 11538remote_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr) 11539{ 11540 if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE) 11541 { 11542 struct remote_state *rs = get_remote_state (); 11543 char *p = rs->buf.data (); 11544 char *endp = p + get_remote_packet_size (); 11545 enum packet_result result; 11546 11547 strcpy (p, "qGetTIBAddr:"); 11548 p += strlen (p); 11549 p = write_ptid (p, endp, ptid); 11550 *p++ = '\0'; 11551 11552 putpkt (rs->buf); 11553 getpkt (&rs->buf, 0); 11554 result = packet_ok (rs->buf, 11555 &remote_protocol_packets[PACKET_qGetTIBAddr]); 11556 if (result == PACKET_OK) 11557 { 11558 ULONGEST val; 11559 unpack_varlen_hex (rs->buf.data (), &val); 11560 if (addr) 11561 *addr = (CORE_ADDR) val; 11562 return true; 11563 } 11564 else if (result == PACKET_UNKNOWN) 11565 error (_("Remote target doesn't support qGetTIBAddr packet")); 11566 else 11567 error (_("Remote target failed to process qGetTIBAddr request")); 11568 } 11569 else 11570 error (_("qGetTIBAddr not supported or disabled on this target")); 11571 /* Not reached. */ 11572 return false; 11573} 11574 11575/* Support for inferring a target description based on the current 11576 architecture and the size of a 'g' packet. While the 'g' packet 11577 can have any size (since optional registers can be left off the 11578 end), some sizes are easily recognizable given knowledge of the 11579 approximate architecture. */ 11580 11581struct remote_g_packet_guess 11582{ 11583 remote_g_packet_guess (int bytes_, const struct target_desc *tdesc_) 11584 : bytes (bytes_), 11585 tdesc (tdesc_) 11586 { 11587 } 11588 11589 int bytes; 11590 const struct target_desc *tdesc; 11591}; 11592 11593struct remote_g_packet_data : public allocate_on_obstack 11594{ 11595 std::vector<remote_g_packet_guess> guesses; 11596}; 11597 11598static struct gdbarch_data *remote_g_packet_data_handle; 11599 11600static void * 11601remote_g_packet_data_init (struct obstack *obstack) 11602{ 11603 return new (obstack) remote_g_packet_data; 11604} 11605 11606void 11607register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes, 11608 const struct target_desc *tdesc) 11609{ 11610 struct remote_g_packet_data *data 11611 = ((struct remote_g_packet_data *) 11612 gdbarch_data (gdbarch, remote_g_packet_data_handle)); 11613 11614 gdb_assert (tdesc != NULL); 11615 11616 for (const remote_g_packet_guess &guess : data->guesses) 11617 if (guess.bytes == bytes) 11618 internal_error (__FILE__, __LINE__, 11619 _("Duplicate g packet description added for size %d"), 11620 bytes); 11621 11622 data->guesses.emplace_back (bytes, tdesc); 11623} 11624 11625/* Return true if remote_read_description would do anything on this target 11626 and architecture, false otherwise. */ 11627 11628static bool 11629remote_read_description_p (struct target_ops *target) 11630{ 11631 struct remote_g_packet_data *data 11632 = ((struct remote_g_packet_data *) 11633 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle)); 11634 11635 return !data->guesses.empty (); 11636} 11637 11638const struct target_desc * 11639remote_target::read_description () 11640{ 11641 struct remote_g_packet_data *data 11642 = ((struct remote_g_packet_data *) 11643 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle)); 11644 11645 /* Do not try this during initial connection, when we do not know 11646 whether there is a running but stopped thread. */ 11647 if (!target_has_execution || inferior_ptid == null_ptid) 11648 return beneath ()->read_description (); 11649 11650 if (!data->guesses.empty ()) 11651 { 11652 int bytes = send_g_packet (); 11653 11654 for (const remote_g_packet_guess &guess : data->guesses) 11655 if (guess.bytes == bytes) 11656 return guess.tdesc; 11657 11658 /* We discard the g packet. A minor optimization would be to 11659 hold on to it, and fill the register cache once we have selected 11660 an architecture, but it's too tricky to do safely. */ 11661 } 11662 11663 return beneath ()->read_description (); 11664} 11665 11666/* Remote file transfer support. This is host-initiated I/O, not 11667 target-initiated; for target-initiated, see remote-fileio.c. */ 11668 11669/* If *LEFT is at least the length of STRING, copy STRING to 11670 *BUFFER, update *BUFFER to point to the new end of the buffer, and 11671 decrease *LEFT. Otherwise raise an error. */ 11672 11673static void 11674remote_buffer_add_string (char **buffer, int *left, const char *string) 11675{ 11676 int len = strlen (string); 11677 11678 if (len > *left) 11679 error (_("Packet too long for target.")); 11680 11681 memcpy (*buffer, string, len); 11682 *buffer += len; 11683 *left -= len; 11684 11685 /* NUL-terminate the buffer as a convenience, if there is 11686 room. */ 11687 if (*left) 11688 **buffer = '\0'; 11689} 11690 11691/* If *LEFT is large enough, hex encode LEN bytes from BYTES into 11692 *BUFFER, update *BUFFER to point to the new end of the buffer, and 11693 decrease *LEFT. Otherwise raise an error. */ 11694 11695static void 11696remote_buffer_add_bytes (char **buffer, int *left, const gdb_byte *bytes, 11697 int len) 11698{ 11699 if (2 * len > *left) 11700 error (_("Packet too long for target.")); 11701 11702 bin2hex (bytes, *buffer, len); 11703 *buffer += 2 * len; 11704 *left -= 2 * len; 11705 11706 /* NUL-terminate the buffer as a convenience, if there is 11707 room. */ 11708 if (*left) 11709 **buffer = '\0'; 11710} 11711 11712/* If *LEFT is large enough, convert VALUE to hex and add it to 11713 *BUFFER, update *BUFFER to point to the new end of the buffer, and 11714 decrease *LEFT. Otherwise raise an error. */ 11715 11716static void 11717remote_buffer_add_int (char **buffer, int *left, ULONGEST value) 11718{ 11719 int len = hexnumlen (value); 11720 11721 if (len > *left) 11722 error (_("Packet too long for target.")); 11723 11724 hexnumstr (*buffer, value); 11725 *buffer += len; 11726 *left -= len; 11727 11728 /* NUL-terminate the buffer as a convenience, if there is 11729 room. */ 11730 if (*left) 11731 **buffer = '\0'; 11732} 11733 11734/* Parse an I/O result packet from BUFFER. Set RETCODE to the return 11735 value, *REMOTE_ERRNO to the remote error number or zero if none 11736 was included, and *ATTACHMENT to point to the start of the annex 11737 if any. The length of the packet isn't needed here; there may 11738 be NUL bytes in BUFFER, but they will be after *ATTACHMENT. 11739 11740 Return 0 if the packet could be parsed, -1 if it could not. If 11741 -1 is returned, the other variables may not be initialized. */ 11742 11743static int 11744remote_hostio_parse_result (char *buffer, int *retcode, 11745 int *remote_errno, char **attachment) 11746{ 11747 char *p, *p2; 11748 11749 *remote_errno = 0; 11750 *attachment = NULL; 11751 11752 if (buffer[0] != 'F') 11753 return -1; 11754 11755 errno = 0; 11756 *retcode = strtol (&buffer[1], &p, 16); 11757 if (errno != 0 || p == &buffer[1]) 11758 return -1; 11759 11760 /* Check for ",errno". */ 11761 if (*p == ',') 11762 { 11763 errno = 0; 11764 *remote_errno = strtol (p + 1, &p2, 16); 11765 if (errno != 0 || p + 1 == p2) 11766 return -1; 11767 p = p2; 11768 } 11769 11770 /* Check for ";attachment". If there is no attachment, the 11771 packet should end here. */ 11772 if (*p == ';') 11773 { 11774 *attachment = p + 1; 11775 return 0; 11776 } 11777 else if (*p == '\0') 11778 return 0; 11779 else 11780 return -1; 11781} 11782 11783/* Send a prepared I/O packet to the target and read its response. 11784 The prepared packet is in the global RS->BUF before this function 11785 is called, and the answer is there when we return. 11786 11787 COMMAND_BYTES is the length of the request to send, which may include 11788 binary data. WHICH_PACKET is the packet configuration to check 11789 before attempting a packet. If an error occurs, *REMOTE_ERRNO 11790 is set to the error number and -1 is returned. Otherwise the value 11791 returned by the function is returned. 11792 11793 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an 11794 attachment is expected; an error will be reported if there's a 11795 mismatch. If one is found, *ATTACHMENT will be set to point into 11796 the packet buffer and *ATTACHMENT_LEN will be set to the 11797 attachment's length. */ 11798 11799int 11800remote_target::remote_hostio_send_command (int command_bytes, int which_packet, 11801 int *remote_errno, char **attachment, 11802 int *attachment_len) 11803{ 11804 struct remote_state *rs = get_remote_state (); 11805 int ret, bytes_read; 11806 char *attachment_tmp; 11807 11808 if (packet_support (which_packet) == PACKET_DISABLE) 11809 { 11810 *remote_errno = FILEIO_ENOSYS; 11811 return -1; 11812 } 11813 11814 putpkt_binary (rs->buf.data (), command_bytes); 11815 bytes_read = getpkt_sane (&rs->buf, 0); 11816 11817 /* If it timed out, something is wrong. Don't try to parse the 11818 buffer. */ 11819 if (bytes_read < 0) 11820 { 11821 *remote_errno = FILEIO_EINVAL; 11822 return -1; 11823 } 11824 11825 switch (packet_ok (rs->buf, &remote_protocol_packets[which_packet])) 11826 { 11827 case PACKET_ERROR: 11828 *remote_errno = FILEIO_EINVAL; 11829 return -1; 11830 case PACKET_UNKNOWN: 11831 *remote_errno = FILEIO_ENOSYS; 11832 return -1; 11833 case PACKET_OK: 11834 break; 11835 } 11836 11837 if (remote_hostio_parse_result (rs->buf.data (), &ret, remote_errno, 11838 &attachment_tmp)) 11839 { 11840 *remote_errno = FILEIO_EINVAL; 11841 return -1; 11842 } 11843 11844 /* Make sure we saw an attachment if and only if we expected one. */ 11845 if ((attachment_tmp == NULL && attachment != NULL) 11846 || (attachment_tmp != NULL && attachment == NULL)) 11847 { 11848 *remote_errno = FILEIO_EINVAL; 11849 return -1; 11850 } 11851 11852 /* If an attachment was found, it must point into the packet buffer; 11853 work out how many bytes there were. */ 11854 if (attachment_tmp != NULL) 11855 { 11856 *attachment = attachment_tmp; 11857 *attachment_len = bytes_read - (*attachment - rs->buf.data ()); 11858 } 11859 11860 return ret; 11861} 11862 11863/* See declaration.h. */ 11864 11865void 11866readahead_cache::invalidate () 11867{ 11868 this->fd = -1; 11869} 11870 11871/* See declaration.h. */ 11872 11873void 11874readahead_cache::invalidate_fd (int fd) 11875{ 11876 if (this->fd == fd) 11877 this->fd = -1; 11878} 11879 11880/* Set the filesystem remote_hostio functions that take FILENAME 11881 arguments will use. Return 0 on success, or -1 if an error 11882 occurs (and set *REMOTE_ERRNO). */ 11883 11884int 11885remote_target::remote_hostio_set_filesystem (struct inferior *inf, 11886 int *remote_errno) 11887{ 11888 struct remote_state *rs = get_remote_state (); 11889 int required_pid = (inf == NULL || inf->fake_pid_p) ? 0 : inf->pid; 11890 char *p = rs->buf.data (); 11891 int left = get_remote_packet_size () - 1; 11892 char arg[9]; 11893 int ret; 11894 11895 if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE) 11896 return 0; 11897 11898 if (rs->fs_pid != -1 && required_pid == rs->fs_pid) 11899 return 0; 11900 11901 remote_buffer_add_string (&p, &left, "vFile:setfs:"); 11902 11903 xsnprintf (arg, sizeof (arg), "%x", required_pid); 11904 remote_buffer_add_string (&p, &left, arg); 11905 11906 ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_setfs, 11907 remote_errno, NULL, NULL); 11908 11909 if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE) 11910 return 0; 11911 11912 if (ret == 0) 11913 rs->fs_pid = required_pid; 11914 11915 return ret; 11916} 11917 11918/* Implementation of to_fileio_open. */ 11919 11920int 11921remote_target::remote_hostio_open (inferior *inf, const char *filename, 11922 int flags, int mode, int warn_if_slow, 11923 int *remote_errno) 11924{ 11925 struct remote_state *rs = get_remote_state (); 11926 char *p = rs->buf.data (); 11927 int left = get_remote_packet_size () - 1; 11928 11929 if (warn_if_slow) 11930 { 11931 static int warning_issued = 0; 11932 11933 printf_unfiltered (_("Reading %s from remote target...\n"), 11934 filename); 11935 11936 if (!warning_issued) 11937 { 11938 warning (_("File transfers from remote targets can be slow." 11939 " Use \"set sysroot\" to access files locally" 11940 " instead.")); 11941 warning_issued = 1; 11942 } 11943 } 11944 11945 if (remote_hostio_set_filesystem (inf, remote_errno) != 0) 11946 return -1; 11947 11948 remote_buffer_add_string (&p, &left, "vFile:open:"); 11949 11950 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, 11951 strlen (filename)); 11952 remote_buffer_add_string (&p, &left, ","); 11953 11954 remote_buffer_add_int (&p, &left, flags); 11955 remote_buffer_add_string (&p, &left, ","); 11956 11957 remote_buffer_add_int (&p, &left, mode); 11958 11959 return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_open, 11960 remote_errno, NULL, NULL); 11961} 11962 11963int 11964remote_target::fileio_open (struct inferior *inf, const char *filename, 11965 int flags, int mode, int warn_if_slow, 11966 int *remote_errno) 11967{ 11968 return remote_hostio_open (inf, filename, flags, mode, warn_if_slow, 11969 remote_errno); 11970} 11971 11972/* Implementation of to_fileio_pwrite. */ 11973 11974int 11975remote_target::remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len, 11976 ULONGEST offset, int *remote_errno) 11977{ 11978 struct remote_state *rs = get_remote_state (); 11979 char *p = rs->buf.data (); 11980 int left = get_remote_packet_size (); 11981 int out_len; 11982 11983 rs->readahead_cache.invalidate_fd (fd); 11984 11985 remote_buffer_add_string (&p, &left, "vFile:pwrite:"); 11986 11987 remote_buffer_add_int (&p, &left, fd); 11988 remote_buffer_add_string (&p, &left, ","); 11989 11990 remote_buffer_add_int (&p, &left, offset); 11991 remote_buffer_add_string (&p, &left, ","); 11992 11993 p += remote_escape_output (write_buf, len, 1, (gdb_byte *) p, &out_len, 11994 (get_remote_packet_size () 11995 - (p - rs->buf.data ()))); 11996 11997 return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pwrite, 11998 remote_errno, NULL, NULL); 11999} 12000 12001int 12002remote_target::fileio_pwrite (int fd, const gdb_byte *write_buf, int len, 12003 ULONGEST offset, int *remote_errno) 12004{ 12005 return remote_hostio_pwrite (fd, write_buf, len, offset, remote_errno); 12006} 12007 12008/* Helper for the implementation of to_fileio_pread. Read the file 12009 from the remote side with vFile:pread. */ 12010 12011int 12012remote_target::remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len, 12013 ULONGEST offset, int *remote_errno) 12014{ 12015 struct remote_state *rs = get_remote_state (); 12016 char *p = rs->buf.data (); 12017 char *attachment; 12018 int left = get_remote_packet_size (); 12019 int ret, attachment_len; 12020 int read_len; 12021 12022 remote_buffer_add_string (&p, &left, "vFile:pread:"); 12023 12024 remote_buffer_add_int (&p, &left, fd); 12025 remote_buffer_add_string (&p, &left, ","); 12026 12027 remote_buffer_add_int (&p, &left, len); 12028 remote_buffer_add_string (&p, &left, ","); 12029 12030 remote_buffer_add_int (&p, &left, offset); 12031 12032 ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pread, 12033 remote_errno, &attachment, 12034 &attachment_len); 12035 12036 if (ret < 0) 12037 return ret; 12038 12039 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len, 12040 read_buf, len); 12041 if (read_len != ret) 12042 error (_("Read returned %d, but %d bytes."), ret, (int) read_len); 12043 12044 return ret; 12045} 12046 12047/* See declaration.h. */ 12048 12049int 12050readahead_cache::pread (int fd, gdb_byte *read_buf, size_t len, 12051 ULONGEST offset) 12052{ 12053 if (this->fd == fd 12054 && this->offset <= offset 12055 && offset < this->offset + this->bufsize) 12056 { 12057 ULONGEST max = this->offset + this->bufsize; 12058 12059 if (offset + len > max) 12060 len = max - offset; 12061 12062 memcpy (read_buf, this->buf + offset - this->offset, len); 12063 return len; 12064 } 12065 12066 return 0; 12067} 12068 12069/* Implementation of to_fileio_pread. */ 12070 12071int 12072remote_target::remote_hostio_pread (int fd, gdb_byte *read_buf, int len, 12073 ULONGEST offset, int *remote_errno) 12074{ 12075 int ret; 12076 struct remote_state *rs = get_remote_state (); 12077 readahead_cache *cache = &rs->readahead_cache; 12078 12079 ret = cache->pread (fd, read_buf, len, offset); 12080 if (ret > 0) 12081 { 12082 cache->hit_count++; 12083 12084 if (remote_debug) 12085 fprintf_unfiltered (gdb_stdlog, "readahead cache hit %s\n", 12086 pulongest (cache->hit_count)); 12087 return ret; 12088 } 12089 12090 cache->miss_count++; 12091 if (remote_debug) 12092 fprintf_unfiltered (gdb_stdlog, "readahead cache miss %s\n", 12093 pulongest (cache->miss_count)); 12094 12095 cache->fd = fd; 12096 cache->offset = offset; 12097 cache->bufsize = get_remote_packet_size (); 12098 cache->buf = (gdb_byte *) xrealloc (cache->buf, cache->bufsize); 12099 12100 ret = remote_hostio_pread_vFile (cache->fd, cache->buf, cache->bufsize, 12101 cache->offset, remote_errno); 12102 if (ret <= 0) 12103 { 12104 cache->invalidate_fd (fd); 12105 return ret; 12106 } 12107 12108 cache->bufsize = ret; 12109 return cache->pread (fd, read_buf, len, offset); 12110} 12111 12112int 12113remote_target::fileio_pread (int fd, gdb_byte *read_buf, int len, 12114 ULONGEST offset, int *remote_errno) 12115{ 12116 return remote_hostio_pread (fd, read_buf, len, offset, remote_errno); 12117} 12118 12119/* Implementation of to_fileio_close. */ 12120 12121int 12122remote_target::remote_hostio_close (int fd, int *remote_errno) 12123{ 12124 struct remote_state *rs = get_remote_state (); 12125 char *p = rs->buf.data (); 12126 int left = get_remote_packet_size () - 1; 12127 12128 rs->readahead_cache.invalidate_fd (fd); 12129 12130 remote_buffer_add_string (&p, &left, "vFile:close:"); 12131 12132 remote_buffer_add_int (&p, &left, fd); 12133 12134 return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_close, 12135 remote_errno, NULL, NULL); 12136} 12137 12138int 12139remote_target::fileio_close (int fd, int *remote_errno) 12140{ 12141 return remote_hostio_close (fd, remote_errno); 12142} 12143 12144/* Implementation of to_fileio_unlink. */ 12145 12146int 12147remote_target::remote_hostio_unlink (inferior *inf, const char *filename, 12148 int *remote_errno) 12149{ 12150 struct remote_state *rs = get_remote_state (); 12151 char *p = rs->buf.data (); 12152 int left = get_remote_packet_size () - 1; 12153 12154 if (remote_hostio_set_filesystem (inf, remote_errno) != 0) 12155 return -1; 12156 12157 remote_buffer_add_string (&p, &left, "vFile:unlink:"); 12158 12159 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, 12160 strlen (filename)); 12161 12162 return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_unlink, 12163 remote_errno, NULL, NULL); 12164} 12165 12166int 12167remote_target::fileio_unlink (struct inferior *inf, const char *filename, 12168 int *remote_errno) 12169{ 12170 return remote_hostio_unlink (inf, filename, remote_errno); 12171} 12172 12173/* Implementation of to_fileio_readlink. */ 12174 12175gdb::optional<std::string> 12176remote_target::fileio_readlink (struct inferior *inf, const char *filename, 12177 int *remote_errno) 12178{ 12179 struct remote_state *rs = get_remote_state (); 12180 char *p = rs->buf.data (); 12181 char *attachment; 12182 int left = get_remote_packet_size (); 12183 int len, attachment_len; 12184 int read_len; 12185 12186 if (remote_hostio_set_filesystem (inf, remote_errno) != 0) 12187 return {}; 12188 12189 remote_buffer_add_string (&p, &left, "vFile:readlink:"); 12190 12191 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, 12192 strlen (filename)); 12193 12194 len = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_readlink, 12195 remote_errno, &attachment, 12196 &attachment_len); 12197 12198 if (len < 0) 12199 return {}; 12200 12201 std::string ret (len, '\0'); 12202 12203 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len, 12204 (gdb_byte *) &ret[0], len); 12205 if (read_len != len) 12206 error (_("Readlink returned %d, but %d bytes."), len, read_len); 12207 12208 return ret; 12209} 12210 12211/* Implementation of to_fileio_fstat. */ 12212 12213int 12214remote_target::fileio_fstat (int fd, struct stat *st, int *remote_errno) 12215{ 12216 struct remote_state *rs = get_remote_state (); 12217 char *p = rs->buf.data (); 12218 int left = get_remote_packet_size (); 12219 int attachment_len, ret; 12220 char *attachment; 12221 struct fio_stat fst; 12222 int read_len; 12223 12224 remote_buffer_add_string (&p, &left, "vFile:fstat:"); 12225 12226 remote_buffer_add_int (&p, &left, fd); 12227 12228 ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_fstat, 12229 remote_errno, &attachment, 12230 &attachment_len); 12231 if (ret < 0) 12232 { 12233 if (*remote_errno != FILEIO_ENOSYS) 12234 return ret; 12235 12236 /* Strictly we should return -1, ENOSYS here, but when 12237 "set sysroot remote:" was implemented in August 2008 12238 BFD's need for a stat function was sidestepped with 12239 this hack. This was not remedied until March 2015 12240 so we retain the previous behavior to avoid breaking 12241 compatibility. 12242 12243 Note that the memset is a March 2015 addition; older 12244 GDBs set st_size *and nothing else* so the structure 12245 would have garbage in all other fields. This might 12246 break something but retaining the previous behavior 12247 here would be just too wrong. */ 12248 12249 memset (st, 0, sizeof (struct stat)); 12250 st->st_size = INT_MAX; 12251 return 0; 12252 } 12253 12254 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len, 12255 (gdb_byte *) &fst, sizeof (fst)); 12256 12257 if (read_len != ret) 12258 error (_("vFile:fstat returned %d, but %d bytes."), ret, read_len); 12259 12260 if (read_len != sizeof (fst)) 12261 error (_("vFile:fstat returned %d bytes, but expecting %d."), 12262 read_len, (int) sizeof (fst)); 12263 12264 remote_fileio_to_host_stat (&fst, st); 12265 12266 return 0; 12267} 12268 12269/* Implementation of to_filesystem_is_local. */ 12270 12271bool 12272remote_target::filesystem_is_local () 12273{ 12274 /* Valgrind GDB presents itself as a remote target but works 12275 on the local filesystem: it does not implement remote get 12276 and users are not expected to set a sysroot. To handle 12277 this case we treat the remote filesystem as local if the 12278 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub 12279 does not support vFile:open. */ 12280 if (strcmp (gdb_sysroot, TARGET_SYSROOT_PREFIX) == 0) 12281 { 12282 enum packet_support ps = packet_support (PACKET_vFile_open); 12283 12284 if (ps == PACKET_SUPPORT_UNKNOWN) 12285 { 12286 int fd, remote_errno; 12287 12288 /* Try opening a file to probe support. The supplied 12289 filename is irrelevant, we only care about whether 12290 the stub recognizes the packet or not. */ 12291 fd = remote_hostio_open (NULL, "just probing", 12292 FILEIO_O_RDONLY, 0700, 0, 12293 &remote_errno); 12294 12295 if (fd >= 0) 12296 remote_hostio_close (fd, &remote_errno); 12297 12298 ps = packet_support (PACKET_vFile_open); 12299 } 12300 12301 if (ps == PACKET_DISABLE) 12302 { 12303 static int warning_issued = 0; 12304 12305 if (!warning_issued) 12306 { 12307 warning (_("remote target does not support file" 12308 " transfer, attempting to access files" 12309 " from local filesystem.")); 12310 warning_issued = 1; 12311 } 12312 12313 return true; 12314 } 12315 } 12316 12317 return false; 12318} 12319 12320static int 12321remote_fileio_errno_to_host (int errnum) 12322{ 12323 switch (errnum) 12324 { 12325 case FILEIO_EPERM: 12326 return EPERM; 12327 case FILEIO_ENOENT: 12328 return ENOENT; 12329 case FILEIO_EINTR: 12330 return EINTR; 12331 case FILEIO_EIO: 12332 return EIO; 12333 case FILEIO_EBADF: 12334 return EBADF; 12335 case FILEIO_EACCES: 12336 return EACCES; 12337 case FILEIO_EFAULT: 12338 return EFAULT; 12339 case FILEIO_EBUSY: 12340 return EBUSY; 12341 case FILEIO_EEXIST: 12342 return EEXIST; 12343 case FILEIO_ENODEV: 12344 return ENODEV; 12345 case FILEIO_ENOTDIR: 12346 return ENOTDIR; 12347 case FILEIO_EISDIR: 12348 return EISDIR; 12349 case FILEIO_EINVAL: 12350 return EINVAL; 12351 case FILEIO_ENFILE: 12352 return ENFILE; 12353 case FILEIO_EMFILE: 12354 return EMFILE; 12355 case FILEIO_EFBIG: 12356 return EFBIG; 12357 case FILEIO_ENOSPC: 12358 return ENOSPC; 12359 case FILEIO_ESPIPE: 12360 return ESPIPE; 12361 case FILEIO_EROFS: 12362 return EROFS; 12363 case FILEIO_ENOSYS: 12364 return ENOSYS; 12365 case FILEIO_ENAMETOOLONG: 12366 return ENAMETOOLONG; 12367 } 12368 return -1; 12369} 12370 12371static char * 12372remote_hostio_error (int errnum) 12373{ 12374 int host_error = remote_fileio_errno_to_host (errnum); 12375 12376 if (host_error == -1) 12377 error (_("Unknown remote I/O error %d"), errnum); 12378 else 12379 error (_("Remote I/O error: %s"), safe_strerror (host_error)); 12380} 12381 12382/* A RAII wrapper around a remote file descriptor. */ 12383 12384class scoped_remote_fd 12385{ 12386public: 12387 scoped_remote_fd (remote_target *remote, int fd) 12388 : m_remote (remote), m_fd (fd) 12389 { 12390 } 12391 12392 ~scoped_remote_fd () 12393 { 12394 if (m_fd != -1) 12395 { 12396 try 12397 { 12398 int remote_errno; 12399 m_remote->remote_hostio_close (m_fd, &remote_errno); 12400 } 12401 catch (...) 12402 { 12403 /* Swallow exception before it escapes the dtor. If 12404 something goes wrong, likely the connection is gone, 12405 and there's nothing else that can be done. */ 12406 } 12407 } 12408 } 12409 12410 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd); 12411 12412 /* Release ownership of the file descriptor, and return it. */ 12413 int release () noexcept 12414 { 12415 int fd = m_fd; 12416 m_fd = -1; 12417 return fd; 12418 } 12419 12420 /* Return the owned file descriptor. */ 12421 int get () const noexcept 12422 { 12423 return m_fd; 12424 } 12425 12426private: 12427 /* The remote target. */ 12428 remote_target *m_remote; 12429 12430 /* The owned remote I/O file descriptor. */ 12431 int m_fd; 12432}; 12433 12434void 12435remote_file_put (const char *local_file, const char *remote_file, int from_tty) 12436{ 12437 remote_target *remote = get_current_remote_target (); 12438 12439 if (remote == nullptr) 12440 error (_("command can only be used with remote target")); 12441 12442 remote->remote_file_put (local_file, remote_file, from_tty); 12443} 12444 12445void 12446remote_target::remote_file_put (const char *local_file, const char *remote_file, 12447 int from_tty) 12448{ 12449 int retcode, remote_errno, bytes, io_size; 12450 int bytes_in_buffer; 12451 int saw_eof; 12452 ULONGEST offset; 12453 12454 gdb_file_up file = gdb_fopen_cloexec (local_file, "rb"); 12455 if (file == NULL) 12456 perror_with_name (local_file); 12457 12458 scoped_remote_fd fd 12459 (this, remote_hostio_open (NULL, 12460 remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT 12461 | FILEIO_O_TRUNC), 12462 0700, 0, &remote_errno)); 12463 if (fd.get () == -1) 12464 remote_hostio_error (remote_errno); 12465 12466 /* Send up to this many bytes at once. They won't all fit in the 12467 remote packet limit, so we'll transfer slightly fewer. */ 12468 io_size = get_remote_packet_size (); 12469 gdb::byte_vector buffer (io_size); 12470 12471 bytes_in_buffer = 0; 12472 saw_eof = 0; 12473 offset = 0; 12474 while (bytes_in_buffer || !saw_eof) 12475 { 12476 if (!saw_eof) 12477 { 12478 bytes = fread (buffer.data () + bytes_in_buffer, 1, 12479 io_size - bytes_in_buffer, 12480 file.get ()); 12481 if (bytes == 0) 12482 { 12483 if (ferror (file.get ())) 12484 error (_("Error reading %s."), local_file); 12485 else 12486 { 12487 /* EOF. Unless there is something still in the 12488 buffer from the last iteration, we are done. */ 12489 saw_eof = 1; 12490 if (bytes_in_buffer == 0) 12491 break; 12492 } 12493 } 12494 } 12495 else 12496 bytes = 0; 12497 12498 bytes += bytes_in_buffer; 12499 bytes_in_buffer = 0; 12500 12501 retcode = remote_hostio_pwrite (fd.get (), buffer.data (), bytes, 12502 offset, &remote_errno); 12503 12504 if (retcode < 0) 12505 remote_hostio_error (remote_errno); 12506 else if (retcode == 0) 12507 error (_("Remote write of %d bytes returned 0!"), bytes); 12508 else if (retcode < bytes) 12509 { 12510 /* Short write. Save the rest of the read data for the next 12511 write. */ 12512 bytes_in_buffer = bytes - retcode; 12513 memmove (buffer.data (), buffer.data () + retcode, bytes_in_buffer); 12514 } 12515 12516 offset += retcode; 12517 } 12518 12519 if (remote_hostio_close (fd.release (), &remote_errno)) 12520 remote_hostio_error (remote_errno); 12521 12522 if (from_tty) 12523 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file); 12524} 12525 12526void 12527remote_file_get (const char *remote_file, const char *local_file, int from_tty) 12528{ 12529 remote_target *remote = get_current_remote_target (); 12530 12531 if (remote == nullptr) 12532 error (_("command can only be used with remote target")); 12533 12534 remote->remote_file_get (remote_file, local_file, from_tty); 12535} 12536 12537void 12538remote_target::remote_file_get (const char *remote_file, const char *local_file, 12539 int from_tty) 12540{ 12541 int remote_errno, bytes, io_size; 12542 ULONGEST offset; 12543 12544 scoped_remote_fd fd 12545 (this, remote_hostio_open (NULL, 12546 remote_file, FILEIO_O_RDONLY, 0, 0, 12547 &remote_errno)); 12548 if (fd.get () == -1) 12549 remote_hostio_error (remote_errno); 12550 12551 gdb_file_up file = gdb_fopen_cloexec (local_file, "wb"); 12552 if (file == NULL) 12553 perror_with_name (local_file); 12554 12555 /* Send up to this many bytes at once. They won't all fit in the 12556 remote packet limit, so we'll transfer slightly fewer. */ 12557 io_size = get_remote_packet_size (); 12558 gdb::byte_vector buffer (io_size); 12559 12560 offset = 0; 12561 while (1) 12562 { 12563 bytes = remote_hostio_pread (fd.get (), buffer.data (), io_size, offset, 12564 &remote_errno); 12565 if (bytes == 0) 12566 /* Success, but no bytes, means end-of-file. */ 12567 break; 12568 if (bytes == -1) 12569 remote_hostio_error (remote_errno); 12570 12571 offset += bytes; 12572 12573 bytes = fwrite (buffer.data (), 1, bytes, file.get ()); 12574 if (bytes == 0) 12575 perror_with_name (local_file); 12576 } 12577 12578 if (remote_hostio_close (fd.release (), &remote_errno)) 12579 remote_hostio_error (remote_errno); 12580 12581 if (from_tty) 12582 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file); 12583} 12584 12585void 12586remote_file_delete (const char *remote_file, int from_tty) 12587{ 12588 remote_target *remote = get_current_remote_target (); 12589 12590 if (remote == nullptr) 12591 error (_("command can only be used with remote target")); 12592 12593 remote->remote_file_delete (remote_file, from_tty); 12594} 12595 12596void 12597remote_target::remote_file_delete (const char *remote_file, int from_tty) 12598{ 12599 int retcode, remote_errno; 12600 12601 retcode = remote_hostio_unlink (NULL, remote_file, &remote_errno); 12602 if (retcode == -1) 12603 remote_hostio_error (remote_errno); 12604 12605 if (from_tty) 12606 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file); 12607} 12608 12609static void 12610remote_put_command (const char *args, int from_tty) 12611{ 12612 if (args == NULL) 12613 error_no_arg (_("file to put")); 12614 12615 gdb_argv argv (args); 12616 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL) 12617 error (_("Invalid parameters to remote put")); 12618 12619 remote_file_put (argv[0], argv[1], from_tty); 12620} 12621 12622static void 12623remote_get_command (const char *args, int from_tty) 12624{ 12625 if (args == NULL) 12626 error_no_arg (_("file to get")); 12627 12628 gdb_argv argv (args); 12629 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL) 12630 error (_("Invalid parameters to remote get")); 12631 12632 remote_file_get (argv[0], argv[1], from_tty); 12633} 12634 12635static void 12636remote_delete_command (const char *args, int from_tty) 12637{ 12638 if (args == NULL) 12639 error_no_arg (_("file to delete")); 12640 12641 gdb_argv argv (args); 12642 if (argv[0] == NULL || argv[1] != NULL) 12643 error (_("Invalid parameters to remote delete")); 12644 12645 remote_file_delete (argv[0], from_tty); 12646} 12647 12648static void 12649remote_command (const char *args, int from_tty) 12650{ 12651 help_list (remote_cmdlist, "remote ", all_commands, gdb_stdout); 12652} 12653 12654bool 12655remote_target::can_execute_reverse () 12656{ 12657 if (packet_support (PACKET_bs) == PACKET_ENABLE 12658 || packet_support (PACKET_bc) == PACKET_ENABLE) 12659 return true; 12660 else 12661 return false; 12662} 12663 12664bool 12665remote_target::supports_non_stop () 12666{ 12667 return true; 12668} 12669 12670bool 12671remote_target::supports_disable_randomization () 12672{ 12673 /* Only supported in extended mode. */ 12674 return false; 12675} 12676 12677bool 12678remote_target::supports_multi_process () 12679{ 12680 struct remote_state *rs = get_remote_state (); 12681 12682 return remote_multi_process_p (rs); 12683} 12684 12685static int 12686remote_supports_cond_tracepoints () 12687{ 12688 return packet_support (PACKET_ConditionalTracepoints) == PACKET_ENABLE; 12689} 12690 12691bool 12692remote_target::supports_evaluation_of_breakpoint_conditions () 12693{ 12694 return packet_support (PACKET_ConditionalBreakpoints) == PACKET_ENABLE; 12695} 12696 12697static int 12698remote_supports_fast_tracepoints () 12699{ 12700 return packet_support (PACKET_FastTracepoints) == PACKET_ENABLE; 12701} 12702 12703static int 12704remote_supports_static_tracepoints () 12705{ 12706 return packet_support (PACKET_StaticTracepoints) == PACKET_ENABLE; 12707} 12708 12709static int 12710remote_supports_install_in_trace () 12711{ 12712 return packet_support (PACKET_InstallInTrace) == PACKET_ENABLE; 12713} 12714 12715bool 12716remote_target::supports_enable_disable_tracepoint () 12717{ 12718 return (packet_support (PACKET_EnableDisableTracepoints_feature) 12719 == PACKET_ENABLE); 12720} 12721 12722bool 12723remote_target::supports_string_tracing () 12724{ 12725 return packet_support (PACKET_tracenz_feature) == PACKET_ENABLE; 12726} 12727 12728bool 12729remote_target::can_run_breakpoint_commands () 12730{ 12731 return packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE; 12732} 12733 12734void 12735remote_target::trace_init () 12736{ 12737 struct remote_state *rs = get_remote_state (); 12738 12739 putpkt ("QTinit"); 12740 remote_get_noisy_reply (); 12741 if (strcmp (rs->buf.data (), "OK") != 0) 12742 error (_("Target does not support this command.")); 12743} 12744 12745/* Recursive routine to walk through command list including loops, and 12746 download packets for each command. */ 12747 12748void 12749remote_target::remote_download_command_source (int num, ULONGEST addr, 12750 struct command_line *cmds) 12751{ 12752 struct remote_state *rs = get_remote_state (); 12753 struct command_line *cmd; 12754 12755 for (cmd = cmds; cmd; cmd = cmd->next) 12756 { 12757 QUIT; /* Allow user to bail out with ^C. */ 12758 strcpy (rs->buf.data (), "QTDPsrc:"); 12759 encode_source_string (num, addr, "cmd", cmd->line, 12760 rs->buf.data () + strlen (rs->buf.data ()), 12761 rs->buf.size () - strlen (rs->buf.data ())); 12762 putpkt (rs->buf); 12763 remote_get_noisy_reply (); 12764 if (strcmp (rs->buf.data (), "OK")) 12765 warning (_("Target does not support source download.")); 12766 12767 if (cmd->control_type == while_control 12768 || cmd->control_type == while_stepping_control) 12769 { 12770 remote_download_command_source (num, addr, cmd->body_list_0.get ()); 12771 12772 QUIT; /* Allow user to bail out with ^C. */ 12773 strcpy (rs->buf.data (), "QTDPsrc:"); 12774 encode_source_string (num, addr, "cmd", "end", 12775 rs->buf.data () + strlen (rs->buf.data ()), 12776 rs->buf.size () - strlen (rs->buf.data ())); 12777 putpkt (rs->buf); 12778 remote_get_noisy_reply (); 12779 if (strcmp (rs->buf.data (), "OK")) 12780 warning (_("Target does not support source download.")); 12781 } 12782 } 12783} 12784 12785void 12786remote_target::download_tracepoint (struct bp_location *loc) 12787{ 12788 CORE_ADDR tpaddr; 12789 char addrbuf[40]; 12790 std::vector<std::string> tdp_actions; 12791 std::vector<std::string> stepping_actions; 12792 char *pkt; 12793 struct breakpoint *b = loc->owner; 12794 struct tracepoint *t = (struct tracepoint *) b; 12795 struct remote_state *rs = get_remote_state (); 12796 int ret; 12797 const char *err_msg = _("Tracepoint packet too large for target."); 12798 size_t size_left; 12799 12800 /* We use a buffer other than rs->buf because we'll build strings 12801 across multiple statements, and other statements in between could 12802 modify rs->buf. */ 12803 gdb::char_vector buf (get_remote_packet_size ()); 12804 12805 encode_actions_rsp (loc, &tdp_actions, &stepping_actions); 12806 12807 tpaddr = loc->address; 12808 sprintf_vma (addrbuf, tpaddr); 12809 ret = snprintf (buf.data (), buf.size (), "QTDP:%x:%s:%c:%lx:%x", 12810 b->number, addrbuf, /* address */ 12811 (b->enable_state == bp_enabled ? 'E' : 'D'), 12812 t->step_count, t->pass_count); 12813 12814 if (ret < 0 || ret >= buf.size ()) 12815 error ("%s", err_msg); 12816 12817 /* Fast tracepoints are mostly handled by the target, but we can 12818 tell the target how big of an instruction block should be moved 12819 around. */ 12820 if (b->type == bp_fast_tracepoint) 12821 { 12822 /* Only test for support at download time; we may not know 12823 target capabilities at definition time. */ 12824 if (remote_supports_fast_tracepoints ()) 12825 { 12826 if (gdbarch_fast_tracepoint_valid_at (loc->gdbarch, tpaddr, 12827 NULL)) 12828 { 12829 size_left = buf.size () - strlen (buf.data ()); 12830 ret = snprintf (buf.data () + strlen (buf.data ()), 12831 size_left, ":F%x", 12832 gdb_insn_length (loc->gdbarch, tpaddr)); 12833 12834 if (ret < 0 || ret >= size_left) 12835 error ("%s", err_msg); 12836 } 12837 else 12838 /* If it passed validation at definition but fails now, 12839 something is very wrong. */ 12840 internal_error (__FILE__, __LINE__, 12841 _("Fast tracepoint not " 12842 "valid during download")); 12843 } 12844 else 12845 /* Fast tracepoints are functionally identical to regular 12846 tracepoints, so don't take lack of support as a reason to 12847 give up on the trace run. */ 12848 warning (_("Target does not support fast tracepoints, " 12849 "downloading %d as regular tracepoint"), b->number); 12850 } 12851 else if (b->type == bp_static_tracepoint) 12852 { 12853 /* Only test for support at download time; we may not know 12854 target capabilities at definition time. */ 12855 if (remote_supports_static_tracepoints ()) 12856 { 12857 struct static_tracepoint_marker marker; 12858 12859 if (target_static_tracepoint_marker_at (tpaddr, &marker)) 12860 { 12861 size_left = buf.size () - strlen (buf.data ()); 12862 ret = snprintf (buf.data () + strlen (buf.data ()), 12863 size_left, ":S"); 12864 12865 if (ret < 0 || ret >= size_left) 12866 error ("%s", err_msg); 12867 } 12868 else 12869 error (_("Static tracepoint not valid during download")); 12870 } 12871 else 12872 /* Fast tracepoints are functionally identical to regular 12873 tracepoints, so don't take lack of support as a reason 12874 to give up on the trace run. */ 12875 error (_("Target does not support static tracepoints")); 12876 } 12877 /* If the tracepoint has a conditional, make it into an agent 12878 expression and append to the definition. */ 12879 if (loc->cond) 12880 { 12881 /* Only test support at download time, we may not know target 12882 capabilities at definition time. */ 12883 if (remote_supports_cond_tracepoints ()) 12884 { 12885 agent_expr_up aexpr = gen_eval_for_expr (tpaddr, 12886 loc->cond.get ()); 12887 12888 size_left = buf.size () - strlen (buf.data ()); 12889 12890 ret = snprintf (buf.data () + strlen (buf.data ()), 12891 size_left, ":X%x,", aexpr->len); 12892 12893 if (ret < 0 || ret >= size_left) 12894 error ("%s", err_msg); 12895 12896 size_left = buf.size () - strlen (buf.data ()); 12897 12898 /* Two bytes to encode each aexpr byte, plus the terminating 12899 null byte. */ 12900 if (aexpr->len * 2 + 1 > size_left) 12901 error ("%s", err_msg); 12902 12903 pkt = buf.data () + strlen (buf.data ()); 12904 12905 for (int ndx = 0; ndx < aexpr->len; ++ndx) 12906 pkt = pack_hex_byte (pkt, aexpr->buf[ndx]); 12907 *pkt = '\0'; 12908 } 12909 else 12910 warning (_("Target does not support conditional tracepoints, " 12911 "ignoring tp %d cond"), b->number); 12912 } 12913 12914 if (b->commands || *default_collect) 12915 { 12916 size_left = buf.size () - strlen (buf.data ()); 12917 12918 ret = snprintf (buf.data () + strlen (buf.data ()), 12919 size_left, "-"); 12920 12921 if (ret < 0 || ret >= size_left) 12922 error ("%s", err_msg); 12923 } 12924 12925 putpkt (buf.data ()); 12926 remote_get_noisy_reply (); 12927 if (strcmp (rs->buf.data (), "OK")) 12928 error (_("Target does not support tracepoints.")); 12929 12930 /* do_single_steps (t); */ 12931 for (auto action_it = tdp_actions.begin (); 12932 action_it != tdp_actions.end (); action_it++) 12933 { 12934 QUIT; /* Allow user to bail out with ^C. */ 12935 12936 bool has_more = ((action_it + 1) != tdp_actions.end () 12937 || !stepping_actions.empty ()); 12938 12939 ret = snprintf (buf.data (), buf.size (), "QTDP:-%x:%s:%s%c", 12940 b->number, addrbuf, /* address */ 12941 action_it->c_str (), 12942 has_more ? '-' : 0); 12943 12944 if (ret < 0 || ret >= buf.size ()) 12945 error ("%s", err_msg); 12946 12947 putpkt (buf.data ()); 12948 remote_get_noisy_reply (); 12949 if (strcmp (rs->buf.data (), "OK")) 12950 error (_("Error on target while setting tracepoints.")); 12951 } 12952 12953 for (auto action_it = stepping_actions.begin (); 12954 action_it != stepping_actions.end (); action_it++) 12955 { 12956 QUIT; /* Allow user to bail out with ^C. */ 12957 12958 bool is_first = action_it == stepping_actions.begin (); 12959 bool has_more = (action_it + 1) != stepping_actions.end (); 12960 12961 ret = snprintf (buf.data (), buf.size (), "QTDP:-%x:%s:%s%s%s", 12962 b->number, addrbuf, /* address */ 12963 is_first ? "S" : "", 12964 action_it->c_str (), 12965 has_more ? "-" : ""); 12966 12967 if (ret < 0 || ret >= buf.size ()) 12968 error ("%s", err_msg); 12969 12970 putpkt (buf.data ()); 12971 remote_get_noisy_reply (); 12972 if (strcmp (rs->buf.data (), "OK")) 12973 error (_("Error on target while setting tracepoints.")); 12974 } 12975 12976 if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE) 12977 { 12978 if (b->location != NULL) 12979 { 12980 ret = snprintf (buf.data (), buf.size (), "QTDPsrc:"); 12981 12982 if (ret < 0 || ret >= buf.size ()) 12983 error ("%s", err_msg); 12984 12985 encode_source_string (b->number, loc->address, "at", 12986 event_location_to_string (b->location.get ()), 12987 buf.data () + strlen (buf.data ()), 12988 buf.size () - strlen (buf.data ())); 12989 putpkt (buf.data ()); 12990 remote_get_noisy_reply (); 12991 if (strcmp (rs->buf.data (), "OK")) 12992 warning (_("Target does not support source download.")); 12993 } 12994 if (b->cond_string) 12995 { 12996 ret = snprintf (buf.data (), buf.size (), "QTDPsrc:"); 12997 12998 if (ret < 0 || ret >= buf.size ()) 12999 error ("%s", err_msg); 13000 13001 encode_source_string (b->number, loc->address, 13002 "cond", b->cond_string, 13003 buf.data () + strlen (buf.data ()), 13004 buf.size () - strlen (buf.data ())); 13005 putpkt (buf.data ()); 13006 remote_get_noisy_reply (); 13007 if (strcmp (rs->buf.data (), "OK")) 13008 warning (_("Target does not support source download.")); 13009 } 13010 remote_download_command_source (b->number, loc->address, 13011 breakpoint_commands (b)); 13012 } 13013} 13014 13015bool 13016remote_target::can_download_tracepoint () 13017{ 13018 struct remote_state *rs = get_remote_state (); 13019 struct trace_status *ts; 13020 int status; 13021 13022 /* Don't try to install tracepoints until we've relocated our 13023 symbols, and fetched and merged the target's tracepoint list with 13024 ours. */ 13025 if (rs->starting_up) 13026 return false; 13027 13028 ts = current_trace_status (); 13029 status = get_trace_status (ts); 13030 13031 if (status == -1 || !ts->running_known || !ts->running) 13032 return false; 13033 13034 /* If we are in a tracing experiment, but remote stub doesn't support 13035 installing tracepoint in trace, we have to return. */ 13036 if (!remote_supports_install_in_trace ()) 13037 return false; 13038 13039 return true; 13040} 13041 13042 13043void 13044remote_target::download_trace_state_variable (const trace_state_variable &tsv) 13045{ 13046 struct remote_state *rs = get_remote_state (); 13047 char *p; 13048 13049 xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:", 13050 tsv.number, phex ((ULONGEST) tsv.initial_value, 8), 13051 tsv.builtin); 13052 p = rs->buf.data () + strlen (rs->buf.data ()); 13053 if ((p - rs->buf.data ()) + tsv.name.length () * 2 13054 >= get_remote_packet_size ()) 13055 error (_("Trace state variable name too long for tsv definition packet")); 13056 p += 2 * bin2hex ((gdb_byte *) (tsv.name.data ()), p, tsv.name.length ()); 13057 *p++ = '\0'; 13058 putpkt (rs->buf); 13059 remote_get_noisy_reply (); 13060 if (rs->buf[0] == '\0') 13061 error (_("Target does not support this command.")); 13062 if (strcmp (rs->buf.data (), "OK") != 0) 13063 error (_("Error on target while downloading trace state variable.")); 13064} 13065 13066void 13067remote_target::enable_tracepoint (struct bp_location *location) 13068{ 13069 struct remote_state *rs = get_remote_state (); 13070 char addr_buf[40]; 13071 13072 sprintf_vma (addr_buf, location->address); 13073 xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTEnable:%x:%s", 13074 location->owner->number, addr_buf); 13075 putpkt (rs->buf); 13076 remote_get_noisy_reply (); 13077 if (rs->buf[0] == '\0') 13078 error (_("Target does not support enabling tracepoints while a trace run is ongoing.")); 13079 if (strcmp (rs->buf.data (), "OK") != 0) 13080 error (_("Error on target while enabling tracepoint.")); 13081} 13082 13083void 13084remote_target::disable_tracepoint (struct bp_location *location) 13085{ 13086 struct remote_state *rs = get_remote_state (); 13087 char addr_buf[40]; 13088 13089 sprintf_vma (addr_buf, location->address); 13090 xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDisable:%x:%s", 13091 location->owner->number, addr_buf); 13092 putpkt (rs->buf); 13093 remote_get_noisy_reply (); 13094 if (rs->buf[0] == '\0') 13095 error (_("Target does not support disabling tracepoints while a trace run is ongoing.")); 13096 if (strcmp (rs->buf.data (), "OK") != 0) 13097 error (_("Error on target while disabling tracepoint.")); 13098} 13099 13100void 13101remote_target::trace_set_readonly_regions () 13102{ 13103 asection *s; 13104 bfd *abfd = NULL; 13105 bfd_size_type size; 13106 bfd_vma vma; 13107 int anysecs = 0; 13108 int offset = 0; 13109 13110 if (!exec_bfd) 13111 return; /* No information to give. */ 13112 13113 struct remote_state *rs = get_remote_state (); 13114 13115 strcpy (rs->buf.data (), "QTro"); 13116 offset = strlen (rs->buf.data ()); 13117 for (s = exec_bfd->sections; s; s = s->next) 13118 { 13119 char tmp1[40], tmp2[40]; 13120 int sec_length; 13121 13122 if ((s->flags & SEC_LOAD) == 0 || 13123 /* (s->flags & SEC_CODE) == 0 || */ 13124 (s->flags & SEC_READONLY) == 0) 13125 continue; 13126 13127 anysecs = 1; 13128 vma = bfd_get_section_vma (abfd, s); 13129 size = bfd_get_section_size (s); 13130 sprintf_vma (tmp1, vma); 13131 sprintf_vma (tmp2, vma + size); 13132 sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2); 13133 if (offset + sec_length + 1 > rs->buf.size ()) 13134 { 13135 if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE) 13136 warning (_("\ 13137Too many sections for read-only sections definition packet.")); 13138 break; 13139 } 13140 xsnprintf (rs->buf.data () + offset, rs->buf.size () - offset, ":%s,%s", 13141 tmp1, tmp2); 13142 offset += sec_length; 13143 } 13144 if (anysecs) 13145 { 13146 putpkt (rs->buf); 13147 getpkt (&rs->buf, 0); 13148 } 13149} 13150 13151void 13152remote_target::trace_start () 13153{ 13154 struct remote_state *rs = get_remote_state (); 13155 13156 putpkt ("QTStart"); 13157 remote_get_noisy_reply (); 13158 if (rs->buf[0] == '\0') 13159 error (_("Target does not support this command.")); 13160 if (strcmp (rs->buf.data (), "OK") != 0) 13161 error (_("Bogus reply from target: %s"), rs->buf.data ()); 13162} 13163 13164int 13165remote_target::get_trace_status (struct trace_status *ts) 13166{ 13167 /* Initialize it just to avoid a GCC false warning. */ 13168 char *p = NULL; 13169 /* FIXME we need to get register block size some other way. */ 13170 extern int trace_regblock_size; 13171 enum packet_result result; 13172 struct remote_state *rs = get_remote_state (); 13173 13174 if (packet_support (PACKET_qTStatus) == PACKET_DISABLE) 13175 return -1; 13176 13177 trace_regblock_size 13178 = rs->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet; 13179 13180 putpkt ("qTStatus"); 13181 13182 TRY 13183 { 13184 p = remote_get_noisy_reply (); 13185 } 13186 CATCH (ex, RETURN_MASK_ERROR) 13187 { 13188 if (ex.error != TARGET_CLOSE_ERROR) 13189 { 13190 exception_fprintf (gdb_stderr, ex, "qTStatus: "); 13191 return -1; 13192 } 13193 throw_exception (ex); 13194 } 13195 END_CATCH 13196 13197 result = packet_ok (p, &remote_protocol_packets[PACKET_qTStatus]); 13198 13199 /* If the remote target doesn't do tracing, flag it. */ 13200 if (result == PACKET_UNKNOWN) 13201 return -1; 13202 13203 /* We're working with a live target. */ 13204 ts->filename = NULL; 13205 13206 if (*p++ != 'T') 13207 error (_("Bogus trace status reply from target: %s"), rs->buf.data ()); 13208 13209 /* Function 'parse_trace_status' sets default value of each field of 13210 'ts' at first, so we don't have to do it here. */ 13211 parse_trace_status (p, ts); 13212 13213 return ts->running; 13214} 13215 13216void 13217remote_target::get_tracepoint_status (struct breakpoint *bp, 13218 struct uploaded_tp *utp) 13219{ 13220 struct remote_state *rs = get_remote_state (); 13221 char *reply; 13222 struct bp_location *loc; 13223 struct tracepoint *tp = (struct tracepoint *) bp; 13224 size_t size = get_remote_packet_size (); 13225 13226 if (tp) 13227 { 13228 tp->hit_count = 0; 13229 tp->traceframe_usage = 0; 13230 for (loc = tp->loc; loc; loc = loc->next) 13231 { 13232 /* If the tracepoint was never downloaded, don't go asking for 13233 any status. */ 13234 if (tp->number_on_target == 0) 13235 continue; 13236 xsnprintf (rs->buf.data (), size, "qTP:%x:%s", tp->number_on_target, 13237 phex_nz (loc->address, 0)); 13238 putpkt (rs->buf); 13239 reply = remote_get_noisy_reply (); 13240 if (reply && *reply) 13241 { 13242 if (*reply == 'V') 13243 parse_tracepoint_status (reply + 1, bp, utp); 13244 } 13245 } 13246 } 13247 else if (utp) 13248 { 13249 utp->hit_count = 0; 13250 utp->traceframe_usage = 0; 13251 xsnprintf (rs->buf.data (), size, "qTP:%x:%s", utp->number, 13252 phex_nz (utp->addr, 0)); 13253 putpkt (rs->buf); 13254 reply = remote_get_noisy_reply (); 13255 if (reply && *reply) 13256 { 13257 if (*reply == 'V') 13258 parse_tracepoint_status (reply + 1, bp, utp); 13259 } 13260 } 13261} 13262 13263void 13264remote_target::trace_stop () 13265{ 13266 struct remote_state *rs = get_remote_state (); 13267 13268 putpkt ("QTStop"); 13269 remote_get_noisy_reply (); 13270 if (rs->buf[0] == '\0') 13271 error (_("Target does not support this command.")); 13272 if (strcmp (rs->buf.data (), "OK") != 0) 13273 error (_("Bogus reply from target: %s"), rs->buf.data ()); 13274} 13275 13276int 13277remote_target::trace_find (enum trace_find_type type, int num, 13278 CORE_ADDR addr1, CORE_ADDR addr2, 13279 int *tpp) 13280{ 13281 struct remote_state *rs = get_remote_state (); 13282 char *endbuf = rs->buf.data () + get_remote_packet_size (); 13283 char *p, *reply; 13284 int target_frameno = -1, target_tracept = -1; 13285 13286 /* Lookups other than by absolute frame number depend on the current 13287 trace selected, so make sure it is correct on the remote end 13288 first. */ 13289 if (type != tfind_number) 13290 set_remote_traceframe (); 13291 13292 p = rs->buf.data (); 13293 strcpy (p, "QTFrame:"); 13294 p = strchr (p, '\0'); 13295 switch (type) 13296 { 13297 case tfind_number: 13298 xsnprintf (p, endbuf - p, "%x", num); 13299 break; 13300 case tfind_pc: 13301 xsnprintf (p, endbuf - p, "pc:%s", phex_nz (addr1, 0)); 13302 break; 13303 case tfind_tp: 13304 xsnprintf (p, endbuf - p, "tdp:%x", num); 13305 break; 13306 case tfind_range: 13307 xsnprintf (p, endbuf - p, "range:%s:%s", phex_nz (addr1, 0), 13308 phex_nz (addr2, 0)); 13309 break; 13310 case tfind_outside: 13311 xsnprintf (p, endbuf - p, "outside:%s:%s", phex_nz (addr1, 0), 13312 phex_nz (addr2, 0)); 13313 break; 13314 default: 13315 error (_("Unknown trace find type %d"), type); 13316 } 13317 13318 putpkt (rs->buf); 13319 reply = remote_get_noisy_reply (); 13320 if (*reply == '\0') 13321 error (_("Target does not support this command.")); 13322 13323 while (reply && *reply) 13324 switch (*reply) 13325 { 13326 case 'F': 13327 p = ++reply; 13328 target_frameno = (int) strtol (p, &reply, 16); 13329 if (reply == p) 13330 error (_("Unable to parse trace frame number")); 13331 /* Don't update our remote traceframe number cache on failure 13332 to select a remote traceframe. */ 13333 if (target_frameno == -1) 13334 return -1; 13335 break; 13336 case 'T': 13337 p = ++reply; 13338 target_tracept = (int) strtol (p, &reply, 16); 13339 if (reply == p) 13340 error (_("Unable to parse tracepoint number")); 13341 break; 13342 case 'O': /* "OK"? */ 13343 if (reply[1] == 'K' && reply[2] == '\0') 13344 reply += 2; 13345 else 13346 error (_("Bogus reply from target: %s"), reply); 13347 break; 13348 default: 13349 error (_("Bogus reply from target: %s"), reply); 13350 } 13351 if (tpp) 13352 *tpp = target_tracept; 13353 13354 rs->remote_traceframe_number = target_frameno; 13355 return target_frameno; 13356} 13357 13358bool 13359remote_target::get_trace_state_variable_value (int tsvnum, LONGEST *val) 13360{ 13361 struct remote_state *rs = get_remote_state (); 13362 char *reply; 13363 ULONGEST uval; 13364 13365 set_remote_traceframe (); 13366 13367 xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTV:%x", tsvnum); 13368 putpkt (rs->buf); 13369 reply = remote_get_noisy_reply (); 13370 if (reply && *reply) 13371 { 13372 if (*reply == 'V') 13373 { 13374 unpack_varlen_hex (reply + 1, &uval); 13375 *val = (LONGEST) uval; 13376 return true; 13377 } 13378 } 13379 return false; 13380} 13381 13382int 13383remote_target::save_trace_data (const char *filename) 13384{ 13385 struct remote_state *rs = get_remote_state (); 13386 char *p, *reply; 13387 13388 p = rs->buf.data (); 13389 strcpy (p, "QTSave:"); 13390 p += strlen (p); 13391 if ((p - rs->buf.data ()) + strlen (filename) * 2 13392 >= get_remote_packet_size ()) 13393 error (_("Remote file name too long for trace save packet")); 13394 p += 2 * bin2hex ((gdb_byte *) filename, p, strlen (filename)); 13395 *p++ = '\0'; 13396 putpkt (rs->buf); 13397 reply = remote_get_noisy_reply (); 13398 if (*reply == '\0') 13399 error (_("Target does not support this command.")); 13400 if (strcmp (reply, "OK") != 0) 13401 error (_("Bogus reply from target: %s"), reply); 13402 return 0; 13403} 13404 13405/* This is basically a memory transfer, but needs to be its own packet 13406 because we don't know how the target actually organizes its trace 13407 memory, plus we want to be able to ask for as much as possible, but 13408 not be unhappy if we don't get as much as we ask for. */ 13409 13410LONGEST 13411remote_target::get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len) 13412{ 13413 struct remote_state *rs = get_remote_state (); 13414 char *reply; 13415 char *p; 13416 int rslt; 13417 13418 p = rs->buf.data (); 13419 strcpy (p, "qTBuffer:"); 13420 p += strlen (p); 13421 p += hexnumstr (p, offset); 13422 *p++ = ','; 13423 p += hexnumstr (p, len); 13424 *p++ = '\0'; 13425 13426 putpkt (rs->buf); 13427 reply = remote_get_noisy_reply (); 13428 if (reply && *reply) 13429 { 13430 /* 'l' by itself means we're at the end of the buffer and 13431 there is nothing more to get. */ 13432 if (*reply == 'l') 13433 return 0; 13434 13435 /* Convert the reply into binary. Limit the number of bytes to 13436 convert according to our passed-in buffer size, rather than 13437 what was returned in the packet; if the target is 13438 unexpectedly generous and gives us a bigger reply than we 13439 asked for, we don't want to crash. */ 13440 rslt = hex2bin (reply, buf, len); 13441 return rslt; 13442 } 13443 13444 /* Something went wrong, flag as an error. */ 13445 return -1; 13446} 13447 13448void 13449remote_target::set_disconnected_tracing (int val) 13450{ 13451 struct remote_state *rs = get_remote_state (); 13452 13453 if (packet_support (PACKET_DisconnectedTracing_feature) == PACKET_ENABLE) 13454 { 13455 char *reply; 13456 13457 xsnprintf (rs->buf.data (), get_remote_packet_size (), 13458 "QTDisconnected:%x", val); 13459 putpkt (rs->buf); 13460 reply = remote_get_noisy_reply (); 13461 if (*reply == '\0') 13462 error (_("Target does not support this command.")); 13463 if (strcmp (reply, "OK") != 0) 13464 error (_("Bogus reply from target: %s"), reply); 13465 } 13466 else if (val) 13467 warning (_("Target does not support disconnected tracing.")); 13468} 13469 13470int 13471remote_target::core_of_thread (ptid_t ptid) 13472{ 13473 struct thread_info *info = find_thread_ptid (ptid); 13474 13475 if (info != NULL && info->priv != NULL) 13476 return get_remote_thread_info (info)->core; 13477 13478 return -1; 13479} 13480 13481void 13482remote_target::set_circular_trace_buffer (int val) 13483{ 13484 struct remote_state *rs = get_remote_state (); 13485 char *reply; 13486 13487 xsnprintf (rs->buf.data (), get_remote_packet_size (), 13488 "QTBuffer:circular:%x", val); 13489 putpkt (rs->buf); 13490 reply = remote_get_noisy_reply (); 13491 if (*reply == '\0') 13492 error (_("Target does not support this command.")); 13493 if (strcmp (reply, "OK") != 0) 13494 error (_("Bogus reply from target: %s"), reply); 13495} 13496 13497traceframe_info_up 13498remote_target::traceframe_info () 13499{ 13500 gdb::optional<gdb::char_vector> text 13501 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO, 13502 NULL); 13503 if (text) 13504 return parse_traceframe_info (text->data ()); 13505 13506 return NULL; 13507} 13508 13509/* Handle the qTMinFTPILen packet. Returns the minimum length of 13510 instruction on which a fast tracepoint may be placed. Returns -1 13511 if the packet is not supported, and 0 if the minimum instruction 13512 length is unknown. */ 13513 13514int 13515remote_target::get_min_fast_tracepoint_insn_len () 13516{ 13517 struct remote_state *rs = get_remote_state (); 13518 char *reply; 13519 13520 /* If we're not debugging a process yet, the IPA can't be 13521 loaded. */ 13522 if (!target_has_execution) 13523 return 0; 13524 13525 /* Make sure the remote is pointing at the right process. */ 13526 set_general_process (); 13527 13528 xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTMinFTPILen"); 13529 putpkt (rs->buf); 13530 reply = remote_get_noisy_reply (); 13531 if (*reply == '\0') 13532 return -1; 13533 else 13534 { 13535 ULONGEST min_insn_len; 13536 13537 unpack_varlen_hex (reply, &min_insn_len); 13538 13539 return (int) min_insn_len; 13540 } 13541} 13542 13543void 13544remote_target::set_trace_buffer_size (LONGEST val) 13545{ 13546 if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE) 13547 { 13548 struct remote_state *rs = get_remote_state (); 13549 char *buf = rs->buf.data (); 13550 char *endbuf = buf + get_remote_packet_size (); 13551 enum packet_result result; 13552 13553 gdb_assert (val >= 0 || val == -1); 13554 buf += xsnprintf (buf, endbuf - buf, "QTBuffer:size:"); 13555 /* Send -1 as literal "-1" to avoid host size dependency. */ 13556 if (val < 0) 13557 { 13558 *buf++ = '-'; 13559 buf += hexnumstr (buf, (ULONGEST) -val); 13560 } 13561 else 13562 buf += hexnumstr (buf, (ULONGEST) val); 13563 13564 putpkt (rs->buf); 13565 remote_get_noisy_reply (); 13566 result = packet_ok (rs->buf, 13567 &remote_protocol_packets[PACKET_QTBuffer_size]); 13568 13569 if (result != PACKET_OK) 13570 warning (_("Bogus reply from target: %s"), rs->buf.data ()); 13571 } 13572} 13573 13574bool 13575remote_target::set_trace_notes (const char *user, const char *notes, 13576 const char *stop_notes) 13577{ 13578 struct remote_state *rs = get_remote_state (); 13579 char *reply; 13580 char *buf = rs->buf.data (); 13581 char *endbuf = buf + get_remote_packet_size (); 13582 int nbytes; 13583 13584 buf += xsnprintf (buf, endbuf - buf, "QTNotes:"); 13585 if (user) 13586 { 13587 buf += xsnprintf (buf, endbuf - buf, "user:"); 13588 nbytes = bin2hex ((gdb_byte *) user, buf, strlen (user)); 13589 buf += 2 * nbytes; 13590 *buf++ = ';'; 13591 } 13592 if (notes) 13593 { 13594 buf += xsnprintf (buf, endbuf - buf, "notes:"); 13595 nbytes = bin2hex ((gdb_byte *) notes, buf, strlen (notes)); 13596 buf += 2 * nbytes; 13597 *buf++ = ';'; 13598 } 13599 if (stop_notes) 13600 { 13601 buf += xsnprintf (buf, endbuf - buf, "tstop:"); 13602 nbytes = bin2hex ((gdb_byte *) stop_notes, buf, strlen (stop_notes)); 13603 buf += 2 * nbytes; 13604 *buf++ = ';'; 13605 } 13606 /* Ensure the buffer is terminated. */ 13607 *buf = '\0'; 13608 13609 putpkt (rs->buf); 13610 reply = remote_get_noisy_reply (); 13611 if (*reply == '\0') 13612 return false; 13613 13614 if (strcmp (reply, "OK") != 0) 13615 error (_("Bogus reply from target: %s"), reply); 13616 13617 return true; 13618} 13619 13620bool 13621remote_target::use_agent (bool use) 13622{ 13623 if (packet_support (PACKET_QAgent) != PACKET_DISABLE) 13624 { 13625 struct remote_state *rs = get_remote_state (); 13626 13627 /* If the stub supports QAgent. */ 13628 xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAgent:%d", use); 13629 putpkt (rs->buf); 13630 getpkt (&rs->buf, 0); 13631 13632 if (strcmp (rs->buf.data (), "OK") == 0) 13633 { 13634 ::use_agent = use; 13635 return true; 13636 } 13637 } 13638 13639 return false; 13640} 13641 13642bool 13643remote_target::can_use_agent () 13644{ 13645 return (packet_support (PACKET_QAgent) != PACKET_DISABLE); 13646} 13647 13648struct btrace_target_info 13649{ 13650 /* The ptid of the traced thread. */ 13651 ptid_t ptid; 13652 13653 /* The obtained branch trace configuration. */ 13654 struct btrace_config conf; 13655}; 13656 13657/* Reset our idea of our target's btrace configuration. */ 13658 13659static void 13660remote_btrace_reset (remote_state *rs) 13661{ 13662 memset (&rs->btrace_config, 0, sizeof (rs->btrace_config)); 13663} 13664 13665/* Synchronize the configuration with the target. */ 13666 13667void 13668remote_target::btrace_sync_conf (const btrace_config *conf) 13669{ 13670 struct packet_config *packet; 13671 struct remote_state *rs; 13672 char *buf, *pos, *endbuf; 13673 13674 rs = get_remote_state (); 13675 buf = rs->buf.data (); 13676 endbuf = buf + get_remote_packet_size (); 13677 13678 packet = &remote_protocol_packets[PACKET_Qbtrace_conf_bts_size]; 13679 if (packet_config_support (packet) == PACKET_ENABLE 13680 && conf->bts.size != rs->btrace_config.bts.size) 13681 { 13682 pos = buf; 13683 pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name, 13684 conf->bts.size); 13685 13686 putpkt (buf); 13687 getpkt (&rs->buf, 0); 13688 13689 if (packet_ok (buf, packet) == PACKET_ERROR) 13690 { 13691 if (buf[0] == 'E' && buf[1] == '.') 13692 error (_("Failed to configure the BTS buffer size: %s"), buf + 2); 13693 else 13694 error (_("Failed to configure the BTS buffer size.")); 13695 } 13696 13697 rs->btrace_config.bts.size = conf->bts.size; 13698 } 13699 13700 packet = &remote_protocol_packets[PACKET_Qbtrace_conf_pt_size]; 13701 if (packet_config_support (packet) == PACKET_ENABLE 13702 && conf->pt.size != rs->btrace_config.pt.size) 13703 { 13704 pos = buf; 13705 pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name, 13706 conf->pt.size); 13707 13708 putpkt (buf); 13709 getpkt (&rs->buf, 0); 13710 13711 if (packet_ok (buf, packet) == PACKET_ERROR) 13712 { 13713 if (buf[0] == 'E' && buf[1] == '.') 13714 error (_("Failed to configure the trace buffer size: %s"), buf + 2); 13715 else 13716 error (_("Failed to configure the trace buffer size.")); 13717 } 13718 13719 rs->btrace_config.pt.size = conf->pt.size; 13720 } 13721} 13722 13723/* Read the current thread's btrace configuration from the target and 13724 store it into CONF. */ 13725 13726static void 13727btrace_read_config (struct btrace_config *conf) 13728{ 13729 gdb::optional<gdb::char_vector> xml 13730 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF, ""); 13731 if (xml) 13732 parse_xml_btrace_conf (conf, xml->data ()); 13733} 13734 13735/* Maybe reopen target btrace. */ 13736 13737void 13738remote_target::remote_btrace_maybe_reopen () 13739{ 13740 struct remote_state *rs = get_remote_state (); 13741 int btrace_target_pushed = 0; 13742#if !defined (HAVE_LIBIPT) 13743 int warned = 0; 13744#endif 13745 13746 scoped_restore_current_thread restore_thread; 13747 13748 for (thread_info *tp : all_non_exited_threads ()) 13749 { 13750 set_general_thread (tp->ptid); 13751 13752 memset (&rs->btrace_config, 0x00, sizeof (struct btrace_config)); 13753 btrace_read_config (&rs->btrace_config); 13754 13755 if (rs->btrace_config.format == BTRACE_FORMAT_NONE) 13756 continue; 13757 13758#if !defined (HAVE_LIBIPT) 13759 if (rs->btrace_config.format == BTRACE_FORMAT_PT) 13760 { 13761 if (!warned) 13762 { 13763 warned = 1; 13764 warning (_("Target is recording using Intel Processor Trace " 13765 "but support was disabled at compile time.")); 13766 } 13767 13768 continue; 13769 } 13770#endif /* !defined (HAVE_LIBIPT) */ 13771 13772 /* Push target, once, but before anything else happens. This way our 13773 changes to the threads will be cleaned up by unpushing the target 13774 in case btrace_read_config () throws. */ 13775 if (!btrace_target_pushed) 13776 { 13777 btrace_target_pushed = 1; 13778 record_btrace_push_target (); 13779 printf_filtered (_("Target is recording using %s.\n"), 13780 btrace_format_string (rs->btrace_config.format)); 13781 } 13782 13783 tp->btrace.target = XCNEW (struct btrace_target_info); 13784 tp->btrace.target->ptid = tp->ptid; 13785 tp->btrace.target->conf = rs->btrace_config; 13786 } 13787} 13788 13789/* Enable branch tracing. */ 13790 13791struct btrace_target_info * 13792remote_target::enable_btrace (ptid_t ptid, const struct btrace_config *conf) 13793{ 13794 struct btrace_target_info *tinfo = NULL; 13795 struct packet_config *packet = NULL; 13796 struct remote_state *rs = get_remote_state (); 13797 char *buf = rs->buf.data (); 13798 char *endbuf = buf + get_remote_packet_size (); 13799 13800 switch (conf->format) 13801 { 13802 case BTRACE_FORMAT_BTS: 13803 packet = &remote_protocol_packets[PACKET_Qbtrace_bts]; 13804 break; 13805 13806 case BTRACE_FORMAT_PT: 13807 packet = &remote_protocol_packets[PACKET_Qbtrace_pt]; 13808 break; 13809 } 13810 13811 if (packet == NULL || packet_config_support (packet) != PACKET_ENABLE) 13812 error (_("Target does not support branch tracing.")); 13813 13814 btrace_sync_conf (conf); 13815 13816 set_general_thread (ptid); 13817 13818 buf += xsnprintf (buf, endbuf - buf, "%s", packet->name); 13819 putpkt (rs->buf); 13820 getpkt (&rs->buf, 0); 13821 13822 if (packet_ok (rs->buf, packet) == PACKET_ERROR) 13823 { 13824 if (rs->buf[0] == 'E' && rs->buf[1] == '.') 13825 error (_("Could not enable branch tracing for %s: %s"), 13826 target_pid_to_str (ptid), &rs->buf[2]); 13827 else 13828 error (_("Could not enable branch tracing for %s."), 13829 target_pid_to_str (ptid)); 13830 } 13831 13832 tinfo = XCNEW (struct btrace_target_info); 13833 tinfo->ptid = ptid; 13834 13835 /* If we fail to read the configuration, we lose some information, but the 13836 tracing itself is not impacted. */ 13837 TRY 13838 { 13839 btrace_read_config (&tinfo->conf); 13840 } 13841 CATCH (err, RETURN_MASK_ERROR) 13842 { 13843 if (err.message != NULL) 13844 warning ("%s", err.message); 13845 } 13846 END_CATCH 13847 13848 return tinfo; 13849} 13850 13851/* Disable branch tracing. */ 13852 13853void 13854remote_target::disable_btrace (struct btrace_target_info *tinfo) 13855{ 13856 struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_off]; 13857 struct remote_state *rs = get_remote_state (); 13858 char *buf = rs->buf.data (); 13859 char *endbuf = buf + get_remote_packet_size (); 13860 13861 if (packet_config_support (packet) != PACKET_ENABLE) 13862 error (_("Target does not support branch tracing.")); 13863 13864 set_general_thread (tinfo->ptid); 13865 13866 buf += xsnprintf (buf, endbuf - buf, "%s", packet->name); 13867 putpkt (rs->buf); 13868 getpkt (&rs->buf, 0); 13869 13870 if (packet_ok (rs->buf, packet) == PACKET_ERROR) 13871 { 13872 if (rs->buf[0] == 'E' && rs->buf[1] == '.') 13873 error (_("Could not disable branch tracing for %s: %s"), 13874 target_pid_to_str (tinfo->ptid), &rs->buf[2]); 13875 else 13876 error (_("Could not disable branch tracing for %s."), 13877 target_pid_to_str (tinfo->ptid)); 13878 } 13879 13880 xfree (tinfo); 13881} 13882 13883/* Teardown branch tracing. */ 13884 13885void 13886remote_target::teardown_btrace (struct btrace_target_info *tinfo) 13887{ 13888 /* We must not talk to the target during teardown. */ 13889 xfree (tinfo); 13890} 13891 13892/* Read the branch trace. */ 13893 13894enum btrace_error 13895remote_target::read_btrace (struct btrace_data *btrace, 13896 struct btrace_target_info *tinfo, 13897 enum btrace_read_type type) 13898{ 13899 struct packet_config *packet = &remote_protocol_packets[PACKET_qXfer_btrace]; 13900 const char *annex; 13901 13902 if (packet_config_support (packet) != PACKET_ENABLE) 13903 error (_("Target does not support branch tracing.")); 13904 13905#if !defined(HAVE_LIBEXPAT) 13906 error (_("Cannot process branch tracing result. XML parsing not supported.")); 13907#endif 13908 13909 switch (type) 13910 { 13911 case BTRACE_READ_ALL: 13912 annex = "all"; 13913 break; 13914 case BTRACE_READ_NEW: 13915 annex = "new"; 13916 break; 13917 case BTRACE_READ_DELTA: 13918 annex = "delta"; 13919 break; 13920 default: 13921 internal_error (__FILE__, __LINE__, 13922 _("Bad branch tracing read type: %u."), 13923 (unsigned int) type); 13924 } 13925 13926 gdb::optional<gdb::char_vector> xml 13927 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE, annex); 13928 if (!xml) 13929 return BTRACE_ERR_UNKNOWN; 13930 13931 parse_xml_btrace (btrace, xml->data ()); 13932 13933 return BTRACE_ERR_NONE; 13934} 13935 13936const struct btrace_config * 13937remote_target::btrace_conf (const struct btrace_target_info *tinfo) 13938{ 13939 return &tinfo->conf; 13940} 13941 13942bool 13943remote_target::augmented_libraries_svr4_read () 13944{ 13945 return (packet_support (PACKET_augmented_libraries_svr4_read_feature) 13946 == PACKET_ENABLE); 13947} 13948 13949/* Implementation of to_load. */ 13950 13951void 13952remote_target::load (const char *name, int from_tty) 13953{ 13954 generic_load (name, from_tty); 13955} 13956 13957/* Accepts an integer PID; returns a string representing a file that 13958 can be opened on the remote side to get the symbols for the child 13959 process. Returns NULL if the operation is not supported. */ 13960 13961char * 13962remote_target::pid_to_exec_file (int pid) 13963{ 13964 static gdb::optional<gdb::char_vector> filename; 13965 struct inferior *inf; 13966 char *annex = NULL; 13967 13968 if (packet_support (PACKET_qXfer_exec_file) != PACKET_ENABLE) 13969 return NULL; 13970 13971 inf = find_inferior_pid (pid); 13972 if (inf == NULL) 13973 internal_error (__FILE__, __LINE__, 13974 _("not currently attached to process %d"), pid); 13975 13976 if (!inf->fake_pid_p) 13977 { 13978 const int annex_size = 9; 13979 13980 annex = (char *) alloca (annex_size); 13981 xsnprintf (annex, annex_size, "%x", pid); 13982 } 13983 13984 filename = target_read_stralloc (current_top_target (), 13985 TARGET_OBJECT_EXEC_FILE, annex); 13986 13987 return filename ? filename->data () : nullptr; 13988} 13989 13990/* Implement the to_can_do_single_step target_ops method. */ 13991 13992int 13993remote_target::can_do_single_step () 13994{ 13995 /* We can only tell whether target supports single step or not by 13996 supported s and S vCont actions if the stub supports vContSupported 13997 feature. If the stub doesn't support vContSupported feature, 13998 we have conservatively to think target doesn't supports single 13999 step. */ 14000 if (packet_support (PACKET_vContSupported) == PACKET_ENABLE) 14001 { 14002 struct remote_state *rs = get_remote_state (); 14003 14004 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN) 14005 remote_vcont_probe (); 14006 14007 return rs->supports_vCont.s && rs->supports_vCont.S; 14008 } 14009 else 14010 return 0; 14011} 14012 14013/* Implementation of the to_execution_direction method for the remote 14014 target. */ 14015 14016enum exec_direction_kind 14017remote_target::execution_direction () 14018{ 14019 struct remote_state *rs = get_remote_state (); 14020 14021 return rs->last_resume_exec_dir; 14022} 14023 14024/* Return pointer to the thread_info struct which corresponds to 14025 THREAD_HANDLE (having length HANDLE_LEN). */ 14026 14027thread_info * 14028remote_target::thread_handle_to_thread_info (const gdb_byte *thread_handle, 14029 int handle_len, 14030 inferior *inf) 14031{ 14032 for (thread_info *tp : all_non_exited_threads ()) 14033 { 14034 remote_thread_info *priv = get_remote_thread_info (tp); 14035 14036 if (tp->inf == inf && priv != NULL) 14037 { 14038 if (handle_len != priv->thread_handle.size ()) 14039 error (_("Thread handle size mismatch: %d vs %zu (from remote)"), 14040 handle_len, priv->thread_handle.size ()); 14041 if (memcmp (thread_handle, priv->thread_handle.data (), 14042 handle_len) == 0) 14043 return tp; 14044 } 14045 } 14046 14047 return NULL; 14048} 14049 14050bool 14051remote_target::can_async_p () 14052{ 14053 struct remote_state *rs = get_remote_state (); 14054 14055 /* We don't go async if the user has explicitly prevented it with the 14056 "maint set target-async" command. */ 14057 if (!target_async_permitted) 14058 return false; 14059 14060 /* We're async whenever the serial device is. */ 14061 return serial_can_async_p (rs->remote_desc); 14062} 14063 14064bool 14065remote_target::is_async_p () 14066{ 14067 struct remote_state *rs = get_remote_state (); 14068 14069 if (!target_async_permitted) 14070 /* We only enable async when the user specifically asks for it. */ 14071 return false; 14072 14073 /* We're async whenever the serial device is. */ 14074 return serial_is_async_p (rs->remote_desc); 14075} 14076 14077/* Pass the SERIAL event on and up to the client. One day this code 14078 will be able to delay notifying the client of an event until the 14079 point where an entire packet has been received. */ 14080 14081static serial_event_ftype remote_async_serial_handler; 14082 14083static void 14084remote_async_serial_handler (struct serial *scb, void *context) 14085{ 14086 /* Don't propogate error information up to the client. Instead let 14087 the client find out about the error by querying the target. */ 14088 inferior_event_handler (INF_REG_EVENT, NULL); 14089} 14090 14091static void 14092remote_async_inferior_event_handler (gdb_client_data data) 14093{ 14094 inferior_event_handler (INF_REG_EVENT, data); 14095} 14096 14097void 14098remote_target::async (int enable) 14099{ 14100 struct remote_state *rs = get_remote_state (); 14101 14102 if (enable) 14103 { 14104 serial_async (rs->remote_desc, remote_async_serial_handler, rs); 14105 14106 /* If there are pending events in the stop reply queue tell the 14107 event loop to process them. */ 14108 if (!rs->stop_reply_queue.empty ()) 14109 mark_async_event_handler (rs->remote_async_inferior_event_token); 14110 /* For simplicity, below we clear the pending events token 14111 without remembering whether it is marked, so here we always 14112 mark it. If there's actually no pending notification to 14113 process, this ends up being a no-op (other than a spurious 14114 event-loop wakeup). */ 14115 if (target_is_non_stop_p ()) 14116 mark_async_event_handler (rs->notif_state->get_pending_events_token); 14117 } 14118 else 14119 { 14120 serial_async (rs->remote_desc, NULL, NULL); 14121 /* If the core is disabling async, it doesn't want to be 14122 disturbed with target events. Clear all async event sources 14123 too. */ 14124 clear_async_event_handler (rs->remote_async_inferior_event_token); 14125 if (target_is_non_stop_p ()) 14126 clear_async_event_handler (rs->notif_state->get_pending_events_token); 14127 } 14128} 14129 14130/* Implementation of the to_thread_events method. */ 14131 14132void 14133remote_target::thread_events (int enable) 14134{ 14135 struct remote_state *rs = get_remote_state (); 14136 size_t size = get_remote_packet_size (); 14137 14138 if (packet_support (PACKET_QThreadEvents) == PACKET_DISABLE) 14139 return; 14140 14141 xsnprintf (rs->buf.data (), size, "QThreadEvents:%x", enable ? 1 : 0); 14142 putpkt (rs->buf); 14143 getpkt (&rs->buf, 0); 14144 14145 switch (packet_ok (rs->buf, 14146 &remote_protocol_packets[PACKET_QThreadEvents])) 14147 { 14148 case PACKET_OK: 14149 if (strcmp (rs->buf.data (), "OK") != 0) 14150 error (_("Remote refused setting thread events: %s"), rs->buf.data ()); 14151 break; 14152 case PACKET_ERROR: 14153 warning (_("Remote failure reply: %s"), rs->buf.data ()); 14154 break; 14155 case PACKET_UNKNOWN: 14156 break; 14157 } 14158} 14159 14160static void 14161set_remote_cmd (const char *args, int from_tty) 14162{ 14163 help_list (remote_set_cmdlist, "set remote ", all_commands, gdb_stdout); 14164} 14165 14166static void 14167show_remote_cmd (const char *args, int from_tty) 14168{ 14169 /* We can't just use cmd_show_list here, because we want to skip 14170 the redundant "show remote Z-packet" and the legacy aliases. */ 14171 struct cmd_list_element *list = remote_show_cmdlist; 14172 struct ui_out *uiout = current_uiout; 14173 14174 ui_out_emit_tuple tuple_emitter (uiout, "showlist"); 14175 for (; list != NULL; list = list->next) 14176 if (strcmp (list->name, "Z-packet") == 0) 14177 continue; 14178 else if (list->type == not_set_cmd) 14179 /* Alias commands are exactly like the original, except they 14180 don't have the normal type. */ 14181 continue; 14182 else 14183 { 14184 ui_out_emit_tuple option_emitter (uiout, "option"); 14185 14186 uiout->field_string ("name", list->name); 14187 uiout->text (": "); 14188 if (list->type == show_cmd) 14189 do_show_command (NULL, from_tty, list); 14190 else 14191 cmd_func (list, NULL, from_tty); 14192 } 14193} 14194 14195 14196/* Function to be called whenever a new objfile (shlib) is detected. */ 14197static void 14198remote_new_objfile (struct objfile *objfile) 14199{ 14200 remote_target *remote = get_current_remote_target (); 14201 14202 if (remote != NULL) /* Have a remote connection. */ 14203 remote->remote_check_symbols (); 14204} 14205 14206/* Pull all the tracepoints defined on the target and create local 14207 data structures representing them. We don't want to create real 14208 tracepoints yet, we don't want to mess up the user's existing 14209 collection. */ 14210 14211int 14212remote_target::upload_tracepoints (struct uploaded_tp **utpp) 14213{ 14214 struct remote_state *rs = get_remote_state (); 14215 char *p; 14216 14217 /* Ask for a first packet of tracepoint definition. */ 14218 putpkt ("qTfP"); 14219 getpkt (&rs->buf, 0); 14220 p = rs->buf.data (); 14221 while (*p && *p != 'l') 14222 { 14223 parse_tracepoint_definition (p, utpp); 14224 /* Ask for another packet of tracepoint definition. */ 14225 putpkt ("qTsP"); 14226 getpkt (&rs->buf, 0); 14227 p = rs->buf.data (); 14228 } 14229 return 0; 14230} 14231 14232int 14233remote_target::upload_trace_state_variables (struct uploaded_tsv **utsvp) 14234{ 14235 struct remote_state *rs = get_remote_state (); 14236 char *p; 14237 14238 /* Ask for a first packet of variable definition. */ 14239 putpkt ("qTfV"); 14240 getpkt (&rs->buf, 0); 14241 p = rs->buf.data (); 14242 while (*p && *p != 'l') 14243 { 14244 parse_tsv_definition (p, utsvp); 14245 /* Ask for another packet of variable definition. */ 14246 putpkt ("qTsV"); 14247 getpkt (&rs->buf, 0); 14248 p = rs->buf.data (); 14249 } 14250 return 0; 14251} 14252 14253/* The "set/show range-stepping" show hook. */ 14254 14255static void 14256show_range_stepping (struct ui_file *file, int from_tty, 14257 struct cmd_list_element *c, 14258 const char *value) 14259{ 14260 fprintf_filtered (file, 14261 _("Debugger's willingness to use range stepping " 14262 "is %s.\n"), value); 14263} 14264 14265/* Return true if the vCont;r action is supported by the remote 14266 stub. */ 14267 14268bool 14269remote_target::vcont_r_supported () 14270{ 14271 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN) 14272 remote_vcont_probe (); 14273 14274 return (packet_support (PACKET_vCont) == PACKET_ENABLE 14275 && get_remote_state ()->supports_vCont.r); 14276} 14277 14278/* The "set/show range-stepping" set hook. */ 14279 14280static void 14281set_range_stepping (const char *ignore_args, int from_tty, 14282 struct cmd_list_element *c) 14283{ 14284 /* When enabling, check whether range stepping is actually supported 14285 by the target, and warn if not. */ 14286 if (use_range_stepping) 14287 { 14288 remote_target *remote = get_current_remote_target (); 14289 if (remote == NULL 14290 || !remote->vcont_r_supported ()) 14291 warning (_("Range stepping is not supported by the current target")); 14292 } 14293} 14294 14295void 14296_initialize_remote (void) 14297{ 14298 struct cmd_list_element *cmd; 14299 const char *cmd_name; 14300 14301 /* architecture specific data */ 14302 remote_g_packet_data_handle = 14303 gdbarch_data_register_pre_init (remote_g_packet_data_init); 14304 14305 remote_pspace_data 14306 = register_program_space_data_with_cleanup (NULL, 14307 remote_pspace_data_cleanup); 14308 14309 add_target (remote_target_info, remote_target::open); 14310 add_target (extended_remote_target_info, extended_remote_target::open); 14311 14312 /* Hook into new objfile notification. */ 14313 gdb::observers::new_objfile.attach (remote_new_objfile); 14314 14315#if 0 14316 init_remote_threadtests (); 14317#endif 14318 14319 /* set/show remote ... */ 14320 14321 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\ 14322Remote protocol specific variables\n\ 14323Configure various remote-protocol specific variables such as\n\ 14324the packets being used"), 14325 &remote_set_cmdlist, "set remote ", 14326 0 /* allow-unknown */, &setlist); 14327 add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\ 14328Remote protocol specific variables\n\ 14329Configure various remote-protocol specific variables such as\n\ 14330the packets being used"), 14331 &remote_show_cmdlist, "show remote ", 14332 0 /* allow-unknown */, &showlist); 14333 14334 add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\ 14335Compare section data on target to the exec file.\n\ 14336Argument is a single section name (default: all loaded sections).\n\ 14337To compare only read-only loaded sections, specify the -r option."), 14338 &cmdlist); 14339 14340 add_cmd ("packet", class_maintenance, packet_command, _("\ 14341Send an arbitrary packet to a remote target.\n\ 14342 maintenance packet TEXT\n\ 14343If GDB is talking to an inferior via the GDB serial protocol, then\n\ 14344this command sends the string TEXT to the inferior, and displays the\n\ 14345response packet. GDB supplies the initial `$' character, and the\n\ 14346terminating `#' character and checksum."), 14347 &maintenancelist); 14348 14349 add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\ 14350Set whether to send break if interrupted."), _("\ 14351Show whether to send break if interrupted."), _("\ 14352If set, a break, instead of a cntrl-c, is sent to the remote target."), 14353 set_remotebreak, show_remotebreak, 14354 &setlist, &showlist); 14355 cmd_name = "remotebreak"; 14356 cmd = lookup_cmd (&cmd_name, setlist, "", -1, 1); 14357 deprecate_cmd (cmd, "set remote interrupt-sequence"); 14358 cmd_name = "remotebreak"; /* needed because lookup_cmd updates the pointer */ 14359 cmd = lookup_cmd (&cmd_name, showlist, "", -1, 1); 14360 deprecate_cmd (cmd, "show remote interrupt-sequence"); 14361 14362 add_setshow_enum_cmd ("interrupt-sequence", class_support, 14363 interrupt_sequence_modes, &interrupt_sequence_mode, 14364 _("\ 14365Set interrupt sequence to remote target."), _("\ 14366Show interrupt sequence to remote target."), _("\ 14367Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."), 14368 NULL, show_interrupt_sequence, 14369 &remote_set_cmdlist, 14370 &remote_show_cmdlist); 14371 14372 add_setshow_boolean_cmd ("interrupt-on-connect", class_support, 14373 &interrupt_on_connect, _("\ 14374Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \ 14375Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \ 14376If set, interrupt sequence is sent to remote target."), 14377 NULL, NULL, 14378 &remote_set_cmdlist, &remote_show_cmdlist); 14379 14380 /* Install commands for configuring memory read/write packets. */ 14381 14382 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\ 14383Set the maximum number of bytes per memory write packet (deprecated)."), 14384 &setlist); 14385 add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\ 14386Show the maximum number of bytes per memory write packet (deprecated)."), 14387 &showlist); 14388 add_cmd ("memory-write-packet-size", no_class, 14389 set_memory_write_packet_size, _("\ 14390Set the maximum number of bytes per memory-write packet.\n\ 14391Specify the number of bytes in a packet or 0 (zero) for the\n\ 14392default packet size. The actual limit is further reduced\n\ 14393dependent on the target. Specify ``fixed'' to disable the\n\ 14394further restriction and ``limit'' to enable that restriction."), 14395 &remote_set_cmdlist); 14396 add_cmd ("memory-read-packet-size", no_class, 14397 set_memory_read_packet_size, _("\ 14398Set the maximum number of bytes per memory-read packet.\n\ 14399Specify the number of bytes in a packet or 0 (zero) for the\n\ 14400default packet size. The actual limit is further reduced\n\ 14401dependent on the target. Specify ``fixed'' to disable the\n\ 14402further restriction and ``limit'' to enable that restriction."), 14403 &remote_set_cmdlist); 14404 add_cmd ("memory-write-packet-size", no_class, 14405 show_memory_write_packet_size, 14406 _("Show the maximum number of bytes per memory-write packet."), 14407 &remote_show_cmdlist); 14408 add_cmd ("memory-read-packet-size", no_class, 14409 show_memory_read_packet_size, 14410 _("Show the maximum number of bytes per memory-read packet."), 14411 &remote_show_cmdlist); 14412 14413 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class, 14414 &remote_hw_watchpoint_limit, _("\ 14415Set the maximum number of target hardware watchpoints."), _("\ 14416Show the maximum number of target hardware watchpoints."), _("\ 14417Specify \"unlimited\" for unlimited hardware watchpoints."), 14418 NULL, show_hardware_watchpoint_limit, 14419 &remote_set_cmdlist, 14420 &remote_show_cmdlist); 14421 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit", 14422 no_class, 14423 &remote_hw_watchpoint_length_limit, _("\ 14424Set the maximum length (in bytes) of a target hardware watchpoint."), _("\ 14425Show the maximum length (in bytes) of a target hardware watchpoint."), _("\ 14426Specify \"unlimited\" to allow watchpoints of unlimited size."), 14427 NULL, show_hardware_watchpoint_length_limit, 14428 &remote_set_cmdlist, &remote_show_cmdlist); 14429 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class, 14430 &remote_hw_breakpoint_limit, _("\ 14431Set the maximum number of target hardware breakpoints."), _("\ 14432Show the maximum number of target hardware breakpoints."), _("\ 14433Specify \"unlimited\" for unlimited hardware breakpoints."), 14434 NULL, show_hardware_breakpoint_limit, 14435 &remote_set_cmdlist, &remote_show_cmdlist); 14436 14437 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure, 14438 &remote_address_size, _("\ 14439Set the maximum size of the address (in bits) in a memory packet."), _("\ 14440Show the maximum size of the address (in bits) in a memory packet."), NULL, 14441 NULL, 14442 NULL, /* FIXME: i18n: */ 14443 &setlist, &showlist); 14444 14445 init_all_packet_configs (); 14446 14447 add_packet_config_cmd (&remote_protocol_packets[PACKET_X], 14448 "X", "binary-download", 1); 14449 14450 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont], 14451 "vCont", "verbose-resume", 0); 14452 14453 add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals], 14454 "QPassSignals", "pass-signals", 0); 14455 14456 add_packet_config_cmd (&remote_protocol_packets[PACKET_QCatchSyscalls], 14457 "QCatchSyscalls", "catch-syscalls", 0); 14458 14459 add_packet_config_cmd (&remote_protocol_packets[PACKET_QProgramSignals], 14460 "QProgramSignals", "program-signals", 0); 14461 14462 add_packet_config_cmd (&remote_protocol_packets[PACKET_QSetWorkingDir], 14463 "QSetWorkingDir", "set-working-dir", 0); 14464 14465 add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartupWithShell], 14466 "QStartupWithShell", "startup-with-shell", 0); 14467 14468 add_packet_config_cmd (&remote_protocol_packets 14469 [PACKET_QEnvironmentHexEncoded], 14470 "QEnvironmentHexEncoded", "environment-hex-encoded", 14471 0); 14472 14473 add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentReset], 14474 "QEnvironmentReset", "environment-reset", 14475 0); 14476 14477 add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentUnset], 14478 "QEnvironmentUnset", "environment-unset", 14479 0); 14480 14481 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol], 14482 "qSymbol", "symbol-lookup", 0); 14483 14484 add_packet_config_cmd (&remote_protocol_packets[PACKET_P], 14485 "P", "set-register", 1); 14486 14487 add_packet_config_cmd (&remote_protocol_packets[PACKET_p], 14488 "p", "fetch-register", 1); 14489 14490 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0], 14491 "Z0", "software-breakpoint", 0); 14492 14493 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1], 14494 "Z1", "hardware-breakpoint", 0); 14495 14496 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2], 14497 "Z2", "write-watchpoint", 0); 14498 14499 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3], 14500 "Z3", "read-watchpoint", 0); 14501 14502 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4], 14503 "Z4", "access-watchpoint", 0); 14504 14505 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv], 14506 "qXfer:auxv:read", "read-aux-vector", 0); 14507 14508 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_exec_file], 14509 "qXfer:exec-file:read", "pid-to-exec-file", 0); 14510 14511 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features], 14512 "qXfer:features:read", "target-features", 0); 14513 14514 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries], 14515 "qXfer:libraries:read", "library-info", 0); 14516 14517 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries_svr4], 14518 "qXfer:libraries-svr4:read", "library-info-svr4", 0); 14519 14520 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map], 14521 "qXfer:memory-map:read", "memory-map", 0); 14522 14523 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read], 14524 "qXfer:spu:read", "read-spu-object", 0); 14525 14526 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write], 14527 "qXfer:spu:write", "write-spu-object", 0); 14528 14529 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata], 14530 "qXfer:osdata:read", "osdata", 0); 14531 14532 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_threads], 14533 "qXfer:threads:read", "threads", 0); 14534 14535 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_read], 14536 "qXfer:siginfo:read", "read-siginfo-object", 0); 14537 14538 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write], 14539 "qXfer:siginfo:write", "write-siginfo-object", 0); 14540 14541 add_packet_config_cmd 14542 (&remote_protocol_packets[PACKET_qXfer_traceframe_info], 14543 "qXfer:traceframe-info:read", "traceframe-info", 0); 14544 14545 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_uib], 14546 "qXfer:uib:read", "unwind-info-block", 0); 14547 14548 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr], 14549 "qGetTLSAddr", "get-thread-local-storage-address", 14550 0); 14551 14552 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTIBAddr], 14553 "qGetTIBAddr", "get-thread-information-block-address", 14554 0); 14555 14556 add_packet_config_cmd (&remote_protocol_packets[PACKET_bc], 14557 "bc", "reverse-continue", 0); 14558 14559 add_packet_config_cmd (&remote_protocol_packets[PACKET_bs], 14560 "bs", "reverse-step", 0); 14561 14562 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported], 14563 "qSupported", "supported-packets", 0); 14564 14565 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSearch_memory], 14566 "qSearch:memory", "search-memory", 0); 14567 14568 add_packet_config_cmd (&remote_protocol_packets[PACKET_qTStatus], 14569 "qTStatus", "trace-status", 0); 14570 14571 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_setfs], 14572 "vFile:setfs", "hostio-setfs", 0); 14573 14574 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_open], 14575 "vFile:open", "hostio-open", 0); 14576 14577 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pread], 14578 "vFile:pread", "hostio-pread", 0); 14579 14580 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pwrite], 14581 "vFile:pwrite", "hostio-pwrite", 0); 14582 14583 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_close], 14584 "vFile:close", "hostio-close", 0); 14585 14586 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink], 14587 "vFile:unlink", "hostio-unlink", 0); 14588 14589 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_readlink], 14590 "vFile:readlink", "hostio-readlink", 0); 14591 14592 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_fstat], 14593 "vFile:fstat", "hostio-fstat", 0); 14594 14595 add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach], 14596 "vAttach", "attach", 0); 14597 14598 add_packet_config_cmd (&remote_protocol_packets[PACKET_vRun], 14599 "vRun", "run", 0); 14600 14601 add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartNoAckMode], 14602 "QStartNoAckMode", "noack", 0); 14603 14604 add_packet_config_cmd (&remote_protocol_packets[PACKET_vKill], 14605 "vKill", "kill", 0); 14606 14607 add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached], 14608 "qAttached", "query-attached", 0); 14609 14610 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints], 14611 "ConditionalTracepoints", 14612 "conditional-tracepoints", 0); 14613 14614 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalBreakpoints], 14615 "ConditionalBreakpoints", 14616 "conditional-breakpoints", 0); 14617 14618 add_packet_config_cmd (&remote_protocol_packets[PACKET_BreakpointCommands], 14619 "BreakpointCommands", 14620 "breakpoint-commands", 0); 14621 14622 add_packet_config_cmd (&remote_protocol_packets[PACKET_FastTracepoints], 14623 "FastTracepoints", "fast-tracepoints", 0); 14624 14625 add_packet_config_cmd (&remote_protocol_packets[PACKET_TracepointSource], 14626 "TracepointSource", "TracepointSource", 0); 14627 14628 add_packet_config_cmd (&remote_protocol_packets[PACKET_QAllow], 14629 "QAllow", "allow", 0); 14630 14631 add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints], 14632 "StaticTracepoints", "static-tracepoints", 0); 14633 14634 add_packet_config_cmd (&remote_protocol_packets[PACKET_InstallInTrace], 14635 "InstallInTrace", "install-in-trace", 0); 14636 14637 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read], 14638 "qXfer:statictrace:read", "read-sdata-object", 0); 14639 14640 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_fdpic], 14641 "qXfer:fdpic:read", "read-fdpic-loadmap", 0); 14642 14643 add_packet_config_cmd (&remote_protocol_packets[PACKET_QDisableRandomization], 14644 "QDisableRandomization", "disable-randomization", 0); 14645 14646 add_packet_config_cmd (&remote_protocol_packets[PACKET_QAgent], 14647 "QAgent", "agent", 0); 14648 14649 add_packet_config_cmd (&remote_protocol_packets[PACKET_QTBuffer_size], 14650 "QTBuffer:size", "trace-buffer-size", 0); 14651 14652 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_off], 14653 "Qbtrace:off", "disable-btrace", 0); 14654 14655 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_bts], 14656 "Qbtrace:bts", "enable-btrace-bts", 0); 14657 14658 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_pt], 14659 "Qbtrace:pt", "enable-btrace-pt", 0); 14660 14661 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace], 14662 "qXfer:btrace", "read-btrace", 0); 14663 14664 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace_conf], 14665 "qXfer:btrace-conf", "read-btrace-conf", 0); 14666 14667 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_bts_size], 14668 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0); 14669 14670 add_packet_config_cmd (&remote_protocol_packets[PACKET_multiprocess_feature], 14671 "multiprocess-feature", "multiprocess-feature", 0); 14672 14673 add_packet_config_cmd (&remote_protocol_packets[PACKET_swbreak_feature], 14674 "swbreak-feature", "swbreak-feature", 0); 14675 14676 add_packet_config_cmd (&remote_protocol_packets[PACKET_hwbreak_feature], 14677 "hwbreak-feature", "hwbreak-feature", 0); 14678 14679 add_packet_config_cmd (&remote_protocol_packets[PACKET_fork_event_feature], 14680 "fork-event-feature", "fork-event-feature", 0); 14681 14682 add_packet_config_cmd (&remote_protocol_packets[PACKET_vfork_event_feature], 14683 "vfork-event-feature", "vfork-event-feature", 0); 14684 14685 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_pt_size], 14686 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0); 14687 14688 add_packet_config_cmd (&remote_protocol_packets[PACKET_vContSupported], 14689 "vContSupported", "verbose-resume-supported", 0); 14690 14691 add_packet_config_cmd (&remote_protocol_packets[PACKET_exec_event_feature], 14692 "exec-event-feature", "exec-event-feature", 0); 14693 14694 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCtrlC], 14695 "vCtrlC", "ctrl-c", 0); 14696 14697 add_packet_config_cmd (&remote_protocol_packets[PACKET_QThreadEvents], 14698 "QThreadEvents", "thread-events", 0); 14699 14700 add_packet_config_cmd (&remote_protocol_packets[PACKET_no_resumed], 14701 "N stop reply", "no-resumed-stop-reply", 0); 14702 14703 /* Assert that we've registered "set remote foo-packet" commands 14704 for all packet configs. */ 14705 { 14706 int i; 14707 14708 for (i = 0; i < PACKET_MAX; i++) 14709 { 14710 /* Ideally all configs would have a command associated. Some 14711 still don't though. */ 14712 int excepted; 14713 14714 switch (i) 14715 { 14716 case PACKET_QNonStop: 14717 case PACKET_EnableDisableTracepoints_feature: 14718 case PACKET_tracenz_feature: 14719 case PACKET_DisconnectedTracing_feature: 14720 case PACKET_augmented_libraries_svr4_read_feature: 14721 case PACKET_qCRC: 14722 /* Additions to this list need to be well justified: 14723 pre-existing packets are OK; new packets are not. */ 14724 excepted = 1; 14725 break; 14726 default: 14727 excepted = 0; 14728 break; 14729 } 14730 14731 /* This catches both forgetting to add a config command, and 14732 forgetting to remove a packet from the exception list. */ 14733 gdb_assert (excepted == (remote_protocol_packets[i].name == NULL)); 14734 } 14735 } 14736 14737 /* Keep the old ``set remote Z-packet ...'' working. Each individual 14738 Z sub-packet has its own set and show commands, but users may 14739 have sets to this variable in their .gdbinit files (or in their 14740 documentation). */ 14741 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure, 14742 &remote_Z_packet_detect, _("\ 14743Set use of remote protocol `Z' packets"), _("\ 14744Show use of remote protocol `Z' packets "), _("\ 14745When set, GDB will attempt to use the remote breakpoint and watchpoint\n\ 14746packets."), 14747 set_remote_protocol_Z_packet_cmd, 14748 show_remote_protocol_Z_packet_cmd, 14749 /* FIXME: i18n: Use of remote protocol 14750 `Z' packets is %s. */ 14751 &remote_set_cmdlist, &remote_show_cmdlist); 14752 14753 add_prefix_cmd ("remote", class_files, remote_command, _("\ 14754Manipulate files on the remote system\n\ 14755Transfer files to and from the remote target system."), 14756 &remote_cmdlist, "remote ", 14757 0 /* allow-unknown */, &cmdlist); 14758 14759 add_cmd ("put", class_files, remote_put_command, 14760 _("Copy a local file to the remote system."), 14761 &remote_cmdlist); 14762 14763 add_cmd ("get", class_files, remote_get_command, 14764 _("Copy a remote file to the local system."), 14765 &remote_cmdlist); 14766 14767 add_cmd ("delete", class_files, remote_delete_command, 14768 _("Delete a remote file."), 14769 &remote_cmdlist); 14770 14771 add_setshow_string_noescape_cmd ("exec-file", class_files, 14772 &remote_exec_file_var, _("\ 14773Set the remote pathname for \"run\""), _("\ 14774Show the remote pathname for \"run\""), NULL, 14775 set_remote_exec_file, 14776 show_remote_exec_file, 14777 &remote_set_cmdlist, 14778 &remote_show_cmdlist); 14779 14780 add_setshow_boolean_cmd ("range-stepping", class_run, 14781 &use_range_stepping, _("\ 14782Enable or disable range stepping."), _("\ 14783Show whether target-assisted range stepping is enabled."), _("\ 14784If on, and the target supports it, when stepping a source line, GDB\n\ 14785tells the target to step the corresponding range of addresses itself instead\n\ 14786of issuing multiple single-steps. This speeds up source level\n\ 14787stepping. If off, GDB always issues single-steps, even if range\n\ 14788stepping is supported by the target. The default is on."), 14789 set_range_stepping, 14790 show_range_stepping, 14791 &setlist, 14792 &showlist); 14793 14794 /* Eventually initialize fileio. See fileio.c */ 14795 initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist); 14796 14797 /* Take advantage of the fact that the TID field is not used, to tag 14798 special ptids with it set to != 0. */ 14799 magic_null_ptid = ptid_t (42000, -1, 1); 14800 not_sent_ptid = ptid_t (42000, -2, 1); 14801 any_thread_ptid = ptid_t (42000, 0, 1); 14802} 14803