remote.c revision 1.7
1/* Remote target communications for serial-line targets in custom GDB protocol 2 3 Copyright (C) 1988-2017 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 "terminal.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 "observer.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 "filestuff.h" 46#include "rsp-low.h" 47#include "disasm.h" 48#include "location.h" 49 50#include "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 "agent.h" 72#include "btrace.h" 73#include "record-btrace.h" 74#include <algorithm> 75 76/* Temp hacks for tracepoint encoding migration. */ 77static char *target_buf; 78static long target_buf_size; 79 80/* Per-program-space data key. */ 81static const struct program_space_data *remote_pspace_data; 82 83/* The variable registered as the control variable used by the 84 remote exec-file commands. While the remote exec-file setting is 85 per-program-space, the set/show machinery uses this as the 86 location of the remote exec-file value. */ 87static char *remote_exec_file_var; 88 89/* The size to align memory write packets, when practical. The protocol 90 does not guarantee any alignment, and gdb will generate short 91 writes and unaligned writes, but even as a best-effort attempt this 92 can improve bulk transfers. For instance, if a write is misaligned 93 relative to the target's data bus, the stub may need to make an extra 94 round trip fetching data from the target. This doesn't make a 95 huge difference, but it's easy to do, so we try to be helpful. 96 97 The alignment chosen is arbitrary; usually data bus width is 98 important here, not the possibly larger cache line size. */ 99enum { REMOTE_ALIGN_WRITES = 16 }; 100 101/* Prototypes for local functions. */ 102static int getpkt_sane (char **buf, long *sizeof_buf, int forever); 103static int getpkt_or_notif_sane (char **buf, long *sizeof_buf, 104 int forever, int *is_notif); 105 106static void remote_files_info (struct target_ops *ignore); 107 108static void remote_prepare_to_store (struct target_ops *self, 109 struct regcache *regcache); 110 111static void remote_open_1 (const char *, int, struct target_ops *, 112 int extended_p); 113 114static void remote_close (struct target_ops *self); 115 116struct remote_state; 117 118static int remote_vkill (int pid, struct remote_state *rs); 119 120static void remote_kill_k (void); 121 122static void remote_mourn (struct target_ops *ops); 123 124static void extended_remote_restart (void); 125 126static void remote_send (char **buf, long *sizeof_buf_p); 127 128static int readchar (int timeout); 129 130static void remote_serial_write (const char *str, int len); 131 132static void remote_kill (struct target_ops *ops); 133 134static int remote_can_async_p (struct target_ops *); 135 136static int remote_is_async_p (struct target_ops *); 137 138static void remote_async (struct target_ops *ops, int enable); 139 140static void remote_thread_events (struct target_ops *ops, int enable); 141 142static void interrupt_query (void); 143 144static void set_general_thread (ptid_t ptid); 145static void set_continue_thread (ptid_t ptid); 146 147static void get_offsets (void); 148 149static void skip_frame (void); 150 151static long read_frame (char **buf_p, long *sizeof_buf); 152 153static int hexnumlen (ULONGEST num); 154 155static void init_remote_ops (void); 156 157static void init_extended_remote_ops (void); 158 159static void remote_stop (struct target_ops *self, ptid_t); 160 161static int stubhex (int ch); 162 163static int hexnumstr (char *, ULONGEST); 164 165static int hexnumnstr (char *, ULONGEST, int); 166 167static CORE_ADDR remote_address_masked (CORE_ADDR); 168 169static void print_packet (const char *); 170 171static void compare_sections_command (char *, int); 172 173static void packet_command (char *, int); 174 175static int stub_unpack_int (char *buff, int fieldlength); 176 177static ptid_t remote_current_thread (ptid_t oldptid); 178 179static int putpkt_binary (const char *buf, int cnt); 180 181static void check_binary_download (CORE_ADDR addr); 182 183struct packet_config; 184 185static void show_packet_config_cmd (struct packet_config *config); 186 187static void show_remote_protocol_packet_cmd (struct ui_file *file, 188 int from_tty, 189 struct cmd_list_element *c, 190 const char *value); 191 192static char *write_ptid (char *buf, const char *endbuf, ptid_t ptid); 193static ptid_t read_ptid (char *buf, char **obuf); 194 195static void remote_set_permissions (struct target_ops *self); 196 197static int remote_get_trace_status (struct target_ops *self, 198 struct trace_status *ts); 199 200static int remote_upload_tracepoints (struct target_ops *self, 201 struct uploaded_tp **utpp); 202 203static int remote_upload_trace_state_variables (struct target_ops *self, 204 struct uploaded_tsv **utsvp); 205 206static void remote_query_supported (void); 207 208static void remote_check_symbols (void); 209 210void _initialize_remote (void); 211 212struct stop_reply; 213static void stop_reply_xfree (struct stop_reply *); 214static void remote_parse_stop_reply (char *, struct stop_reply *); 215static void push_stop_reply (struct stop_reply *); 216static void discard_pending_stop_replies_in_queue (struct remote_state *); 217static int peek_stop_reply (ptid_t ptid); 218 219struct threads_listing_context; 220static void remove_new_fork_children (struct threads_listing_context *); 221 222static void remote_async_inferior_event_handler (gdb_client_data); 223 224static void remote_terminal_ours (struct target_ops *self); 225 226static int remote_read_description_p (struct target_ops *target); 227 228static void remote_console_output (char *msg); 229 230static int remote_supports_cond_breakpoints (struct target_ops *self); 231 232static int remote_can_run_breakpoint_commands (struct target_ops *self); 233 234static void remote_btrace_reset (void); 235 236static void remote_btrace_maybe_reopen (void); 237 238static int stop_reply_queue_length (void); 239 240static void readahead_cache_invalidate (void); 241 242static void remote_unpush_and_throw (void); 243 244/* For "remote". */ 245 246static struct cmd_list_element *remote_cmdlist; 247 248/* For "set remote" and "show remote". */ 249 250static struct cmd_list_element *remote_set_cmdlist; 251static struct cmd_list_element *remote_show_cmdlist; 252 253/* Stub vCont actions support. 254 255 Each field is a boolean flag indicating whether the stub reports 256 support for the corresponding action. */ 257 258struct vCont_action_support 259{ 260 /* vCont;t */ 261 int t; 262 263 /* vCont;r */ 264 int r; 265 266 /* vCont;s */ 267 int s; 268 269 /* vCont;S */ 270 int S; 271}; 272 273/* Controls whether GDB is willing to use range stepping. */ 274 275static int use_range_stepping = 1; 276 277#define OPAQUETHREADBYTES 8 278 279/* a 64 bit opaque identifier */ 280typedef unsigned char threadref[OPAQUETHREADBYTES]; 281 282/* About this many threadisds fit in a packet. */ 283 284#define MAXTHREADLISTRESULTS 32 285 286/* The max number of chars in debug output. The rest of chars are 287 omitted. */ 288 289#define REMOTE_DEBUG_MAX_CHAR 512 290 291/* Data for the vFile:pread readahead cache. */ 292 293struct readahead_cache 294{ 295 /* The file descriptor for the file that is being cached. -1 if the 296 cache is invalid. */ 297 int fd; 298 299 /* The offset into the file that the cache buffer corresponds 300 to. */ 301 ULONGEST offset; 302 303 /* The buffer holding the cache contents. */ 304 gdb_byte *buf; 305 /* The buffer's size. We try to read as much as fits into a packet 306 at a time. */ 307 size_t bufsize; 308 309 /* Cache hit and miss counters. */ 310 ULONGEST hit_count; 311 ULONGEST miss_count; 312}; 313 314/* Description of the remote protocol state for the currently 315 connected target. This is per-target state, and independent of the 316 selected architecture. */ 317 318struct remote_state 319{ 320 /* A buffer to use for incoming packets, and its current size. The 321 buffer is grown dynamically for larger incoming packets. 322 Outgoing packets may also be constructed in this buffer. 323 BUF_SIZE is always at least REMOTE_PACKET_SIZE; 324 REMOTE_PACKET_SIZE should be used to limit the length of outgoing 325 packets. */ 326 char *buf; 327 long buf_size; 328 329 /* True if we're going through initial connection setup (finding out 330 about the remote side's threads, relocating symbols, etc.). */ 331 int starting_up; 332 333 /* If we negotiated packet size explicitly (and thus can bypass 334 heuristics for the largest packet size that will not overflow 335 a buffer in the stub), this will be set to that packet size. 336 Otherwise zero, meaning to use the guessed size. */ 337 long explicit_packet_size; 338 339 /* remote_wait is normally called when the target is running and 340 waits for a stop reply packet. But sometimes we need to call it 341 when the target is already stopped. We can send a "?" packet 342 and have remote_wait read the response. Or, if we already have 343 the response, we can stash it in BUF and tell remote_wait to 344 skip calling getpkt. This flag is set when BUF contains a 345 stop reply packet and the target is not waiting. */ 346 int cached_wait_status; 347 348 /* True, if in no ack mode. That is, neither GDB nor the stub will 349 expect acks from each other. The connection is assumed to be 350 reliable. */ 351 int noack_mode; 352 353 /* True if we're connected in extended remote mode. */ 354 int extended; 355 356 /* True if we resumed the target and we're waiting for the target to 357 stop. In the mean time, we can't start another command/query. 358 The remote server wouldn't be ready to process it, so we'd 359 timeout waiting for a reply that would never come and eventually 360 we'd close the connection. This can happen in asynchronous mode 361 because we allow GDB commands while the target is running. */ 362 int waiting_for_stop_reply; 363 364 /* The status of the stub support for the various vCont actions. */ 365 struct vCont_action_support supports_vCont; 366 367 /* Nonzero if the user has pressed Ctrl-C, but the target hasn't 368 responded to that. */ 369 int ctrlc_pending_p; 370 371 /* True if we saw a Ctrl-C while reading or writing from/to the 372 remote descriptor. At that point it is not safe to send a remote 373 interrupt packet, so we instead remember we saw the Ctrl-C and 374 process it once we're done with sending/receiving the current 375 packet, which should be shortly. If however that takes too long, 376 and the user presses Ctrl-C again, we offer to disconnect. */ 377 int got_ctrlc_during_io; 378 379 /* Descriptor for I/O to remote machine. Initialize it to NULL so that 380 remote_open knows that we don't have a file open when the program 381 starts. */ 382 struct serial *remote_desc; 383 384 /* These are the threads which we last sent to the remote system. The 385 TID member will be -1 for all or -2 for not sent yet. */ 386 ptid_t general_thread; 387 ptid_t continue_thread; 388 389 /* This is the traceframe which we last selected on the remote system. 390 It will be -1 if no traceframe is selected. */ 391 int remote_traceframe_number; 392 393 char *last_pass_packet; 394 395 /* The last QProgramSignals packet sent to the target. We bypass 396 sending a new program signals list down to the target if the new 397 packet is exactly the same as the last we sent. IOW, we only let 398 the target know about program signals list changes. */ 399 char *last_program_signals_packet; 400 401 enum gdb_signal last_sent_signal; 402 403 int last_sent_step; 404 405 /* The execution direction of the last resume we got. */ 406 enum exec_direction_kind last_resume_exec_dir; 407 408 char *finished_object; 409 char *finished_annex; 410 ULONGEST finished_offset; 411 412 /* Should we try the 'ThreadInfo' query packet? 413 414 This variable (NOT available to the user: auto-detect only!) 415 determines whether GDB will use the new, simpler "ThreadInfo" 416 query or the older, more complex syntax for thread queries. 417 This is an auto-detect variable (set to true at each connect, 418 and set to false when the target fails to recognize it). */ 419 int use_threadinfo_query; 420 int use_threadextra_query; 421 422 threadref echo_nextthread; 423 threadref nextthread; 424 threadref resultthreadlist[MAXTHREADLISTRESULTS]; 425 426 /* The state of remote notification. */ 427 struct remote_notif_state *notif_state; 428 429 /* The branch trace configuration. */ 430 struct btrace_config btrace_config; 431 432 /* The argument to the last "vFile:setfs:" packet we sent, used 433 to avoid sending repeated unnecessary "vFile:setfs:" packets. 434 Initialized to -1 to indicate that no "vFile:setfs:" packet 435 has yet been sent. */ 436 int fs_pid; 437 438 /* A readahead cache for vFile:pread. Often, reading a binary 439 involves a sequence of small reads. E.g., when parsing an ELF 440 file. A readahead cache helps mostly the case of remote 441 debugging on a connection with higher latency, due to the 442 request/reply nature of the RSP. We only cache data for a single 443 file descriptor at a time. */ 444 struct readahead_cache readahead_cache; 445}; 446 447/* Private data that we'll store in (struct thread_info)->private. */ 448struct private_thread_info 449{ 450 char *extra; 451 char *name; 452 int core; 453 454 /* Whether the target stopped for a breakpoint/watchpoint. */ 455 enum target_stop_reason stop_reason; 456 457 /* This is set to the data address of the access causing the target 458 to stop for a watchpoint. */ 459 CORE_ADDR watch_data_address; 460 461 /* Fields used by the vCont action coalescing implemented in 462 remote_resume / remote_commit_resume. remote_resume stores each 463 thread's last resume request in these fields, so that a later 464 remote_commit_resume knows which is the proper action for this 465 thread to include in the vCont packet. */ 466 467 /* True if the last target_resume call for this thread was a step 468 request, false if a continue request. */ 469 int last_resume_step; 470 471 /* The signal specified in the last target_resume call for this 472 thread. */ 473 enum gdb_signal last_resume_sig; 474 475 /* Whether this thread was already vCont-resumed on the remote 476 side. */ 477 int vcont_resumed; 478}; 479 480static void 481free_private_thread_info (struct private_thread_info *info) 482{ 483 xfree (info->extra); 484 xfree (info->name); 485 xfree (info); 486} 487 488/* This data could be associated with a target, but we do not always 489 have access to the current target when we need it, so for now it is 490 static. This will be fine for as long as only one target is in use 491 at a time. */ 492static struct remote_state *remote_state; 493 494static struct remote_state * 495get_remote_state_raw (void) 496{ 497 return remote_state; 498} 499 500/* Allocate a new struct remote_state with xmalloc, initialize it, and 501 return it. */ 502 503static struct remote_state * 504new_remote_state (void) 505{ 506 struct remote_state *result = XCNEW (struct remote_state); 507 508 /* The default buffer size is unimportant; it will be expanded 509 whenever a larger buffer is needed. */ 510 result->buf_size = 400; 511 result->buf = (char *) xmalloc (result->buf_size); 512 result->remote_traceframe_number = -1; 513 result->last_sent_signal = GDB_SIGNAL_0; 514 result->last_resume_exec_dir = EXEC_FORWARD; 515 result->fs_pid = -1; 516 517 return result; 518} 519 520/* Description of the remote protocol for a given architecture. */ 521 522struct packet_reg 523{ 524 long offset; /* Offset into G packet. */ 525 long regnum; /* GDB's internal register number. */ 526 LONGEST pnum; /* Remote protocol register number. */ 527 int in_g_packet; /* Always part of G packet. */ 528 /* long size in bytes; == register_size (target_gdbarch (), regnum); 529 at present. */ 530 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum); 531 at present. */ 532}; 533 534struct remote_arch_state 535{ 536 /* Description of the remote protocol registers. */ 537 long sizeof_g_packet; 538 539 /* Description of the remote protocol registers indexed by REGNUM 540 (making an array gdbarch_num_regs in size). */ 541 struct packet_reg *regs; 542 543 /* This is the size (in chars) of the first response to the ``g'' 544 packet. It is used as a heuristic when determining the maximum 545 size of memory-read and memory-write packets. A target will 546 typically only reserve a buffer large enough to hold the ``g'' 547 packet. The size does not include packet overhead (headers and 548 trailers). */ 549 long actual_register_packet_size; 550 551 /* This is the maximum size (in chars) of a non read/write packet. 552 It is also used as a cap on the size of read/write packets. */ 553 long remote_packet_size; 554}; 555 556/* Utility: generate error from an incoming stub packet. */ 557static void 558trace_error (char *buf) 559{ 560 if (*buf++ != 'E') 561 return; /* not an error msg */ 562 switch (*buf) 563 { 564 case '1': /* malformed packet error */ 565 if (*++buf == '0') /* general case: */ 566 error (_("remote.c: error in outgoing packet.")); 567 else 568 error (_("remote.c: error in outgoing packet at field #%ld."), 569 strtol (buf, NULL, 16)); 570 default: 571 error (_("Target returns error code '%s'."), buf); 572 } 573} 574 575/* Utility: wait for reply from stub, while accepting "O" packets. */ 576static char * 577remote_get_noisy_reply (char **buf_p, 578 long *sizeof_buf) 579{ 580 do /* Loop on reply from remote stub. */ 581 { 582 char *buf; 583 584 QUIT; /* Allow user to bail out with ^C. */ 585 getpkt (buf_p, sizeof_buf, 0); 586 buf = *buf_p; 587 if (buf[0] == 'E') 588 trace_error (buf); 589 else if (startswith (buf, "qRelocInsn:")) 590 { 591 ULONGEST ul; 592 CORE_ADDR from, to, org_to; 593 char *p, *pp; 594 int adjusted_size = 0; 595 int relocated = 0; 596 597 p = buf + strlen ("qRelocInsn:"); 598 pp = unpack_varlen_hex (p, &ul); 599 if (*pp != ';') 600 error (_("invalid qRelocInsn packet: %s"), buf); 601 from = ul; 602 603 p = pp + 1; 604 unpack_varlen_hex (p, &ul); 605 to = ul; 606 607 org_to = to; 608 609 TRY 610 { 611 gdbarch_relocate_instruction (target_gdbarch (), &to, from); 612 relocated = 1; 613 } 614 CATCH (ex, RETURN_MASK_ALL) 615 { 616 if (ex.error == MEMORY_ERROR) 617 { 618 /* Propagate memory errors silently back to the 619 target. The stub may have limited the range of 620 addresses we can write to, for example. */ 621 } 622 else 623 { 624 /* Something unexpectedly bad happened. Be verbose 625 so we can tell what, and propagate the error back 626 to the stub, so it doesn't get stuck waiting for 627 a response. */ 628 exception_fprintf (gdb_stderr, ex, 629 _("warning: relocating instruction: ")); 630 } 631 putpkt ("E01"); 632 } 633 END_CATCH 634 635 if (relocated) 636 { 637 adjusted_size = to - org_to; 638 639 xsnprintf (buf, *sizeof_buf, "qRelocInsn:%x", adjusted_size); 640 putpkt (buf); 641 } 642 } 643 else if (buf[0] == 'O' && buf[1] != 'K') 644 remote_console_output (buf + 1); /* 'O' message from stub */ 645 else 646 return buf; /* Here's the actual reply. */ 647 } 648 while (1); 649} 650 651/* Handle for retreving the remote protocol data from gdbarch. */ 652static struct gdbarch_data *remote_gdbarch_data_handle; 653 654static struct remote_arch_state * 655get_remote_arch_state (void) 656{ 657 gdb_assert (target_gdbarch () != NULL); 658 return ((struct remote_arch_state *) 659 gdbarch_data (target_gdbarch (), remote_gdbarch_data_handle)); 660} 661 662/* Fetch the global remote target state. */ 663 664static struct remote_state * 665get_remote_state (void) 666{ 667 /* Make sure that the remote architecture state has been 668 initialized, because doing so might reallocate rs->buf. Any 669 function which calls getpkt also needs to be mindful of changes 670 to rs->buf, but this call limits the number of places which run 671 into trouble. */ 672 get_remote_arch_state (); 673 674 return get_remote_state_raw (); 675} 676 677/* Cleanup routine for the remote module's pspace data. */ 678 679static void 680remote_pspace_data_cleanup (struct program_space *pspace, void *arg) 681{ 682 char *remote_exec_file = (char *) arg; 683 684 xfree (remote_exec_file); 685} 686 687/* Fetch the remote exec-file from the current program space. */ 688 689static const char * 690get_remote_exec_file (void) 691{ 692 char *remote_exec_file; 693 694 remote_exec_file 695 = (char *) program_space_data (current_program_space, 696 remote_pspace_data); 697 if (remote_exec_file == NULL) 698 return ""; 699 700 return remote_exec_file; 701} 702 703/* Set the remote exec file for PSPACE. */ 704 705static void 706set_pspace_remote_exec_file (struct program_space *pspace, 707 char *remote_exec_file) 708{ 709 char *old_file = (char *) program_space_data (pspace, remote_pspace_data); 710 711 xfree (old_file); 712 set_program_space_data (pspace, remote_pspace_data, 713 xstrdup (remote_exec_file)); 714} 715 716/* The "set/show remote exec-file" set command hook. */ 717 718static void 719set_remote_exec_file (char *ignored, int from_tty, 720 struct cmd_list_element *c) 721{ 722 gdb_assert (remote_exec_file_var != NULL); 723 set_pspace_remote_exec_file (current_program_space, remote_exec_file_var); 724} 725 726/* The "set/show remote exec-file" show command hook. */ 727 728static void 729show_remote_exec_file (struct ui_file *file, int from_tty, 730 struct cmd_list_element *cmd, const char *value) 731{ 732 fprintf_filtered (file, "%s\n", remote_exec_file_var); 733} 734 735static int 736compare_pnums (const void *lhs_, const void *rhs_) 737{ 738 const struct packet_reg * const *lhs 739 = (const struct packet_reg * const *) lhs_; 740 const struct packet_reg * const *rhs 741 = (const struct packet_reg * const *) rhs_; 742 743 if ((*lhs)->pnum < (*rhs)->pnum) 744 return -1; 745 else if ((*lhs)->pnum == (*rhs)->pnum) 746 return 0; 747 else 748 return 1; 749} 750 751static int 752map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs) 753{ 754 int regnum, num_remote_regs, offset; 755 struct packet_reg **remote_regs; 756 757 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++) 758 { 759 struct packet_reg *r = ®s[regnum]; 760 761 if (register_size (gdbarch, regnum) == 0) 762 /* Do not try to fetch zero-sized (placeholder) registers. */ 763 r->pnum = -1; 764 else 765 r->pnum = gdbarch_remote_register_number (gdbarch, regnum); 766 767 r->regnum = regnum; 768 } 769 770 /* Define the g/G packet format as the contents of each register 771 with a remote protocol number, in order of ascending protocol 772 number. */ 773 774 remote_regs = XALLOCAVEC (struct packet_reg *, gdbarch_num_regs (gdbarch)); 775 for (num_remote_regs = 0, regnum = 0; 776 regnum < gdbarch_num_regs (gdbarch); 777 regnum++) 778 if (regs[regnum].pnum != -1) 779 remote_regs[num_remote_regs++] = ®s[regnum]; 780 781 qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *), 782 compare_pnums); 783 784 for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++) 785 { 786 remote_regs[regnum]->in_g_packet = 1; 787 remote_regs[regnum]->offset = offset; 788 offset += register_size (gdbarch, remote_regs[regnum]->regnum); 789 } 790 791 return offset; 792} 793 794/* Given the architecture described by GDBARCH, return the remote 795 protocol register's number and the register's offset in the g/G 796 packets of GDB register REGNUM, in PNUM and POFFSET respectively. 797 If the target does not have a mapping for REGNUM, return false, 798 otherwise, return true. */ 799 800int 801remote_register_number_and_offset (struct gdbarch *gdbarch, int regnum, 802 int *pnum, int *poffset) 803{ 804 struct packet_reg *regs; 805 struct cleanup *old_chain; 806 807 gdb_assert (regnum < gdbarch_num_regs (gdbarch)); 808 809 regs = XCNEWVEC (struct packet_reg, gdbarch_num_regs (gdbarch)); 810 old_chain = make_cleanup (xfree, regs); 811 812 map_regcache_remote_table (gdbarch, regs); 813 814 *pnum = regs[regnum].pnum; 815 *poffset = regs[regnum].offset; 816 817 do_cleanups (old_chain); 818 819 return *pnum != -1; 820} 821 822static void * 823init_remote_state (struct gdbarch *gdbarch) 824{ 825 struct remote_state *rs = get_remote_state_raw (); 826 struct remote_arch_state *rsa; 827 828 rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state); 829 830 /* Use the architecture to build a regnum<->pnum table, which will be 831 1:1 unless a feature set specifies otherwise. */ 832 rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch, 833 gdbarch_num_regs (gdbarch), 834 struct packet_reg); 835 836 /* Record the maximum possible size of the g packet - it may turn out 837 to be smaller. */ 838 rsa->sizeof_g_packet = map_regcache_remote_table (gdbarch, rsa->regs); 839 840 /* Default maximum number of characters in a packet body. Many 841 remote stubs have a hardwired buffer size of 400 bytes 842 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used 843 as the maximum packet-size to ensure that the packet and an extra 844 NUL character can always fit in the buffer. This stops GDB 845 trashing stubs that try to squeeze an extra NUL into what is 846 already a full buffer (As of 1999-12-04 that was most stubs). */ 847 rsa->remote_packet_size = 400 - 1; 848 849 /* This one is filled in when a ``g'' packet is received. */ 850 rsa->actual_register_packet_size = 0; 851 852 /* Should rsa->sizeof_g_packet needs more space than the 853 default, adjust the size accordingly. Remember that each byte is 854 encoded as two characters. 32 is the overhead for the packet 855 header / footer. NOTE: cagney/1999-10-26: I suspect that 8 856 (``$NN:G...#NN'') is a better guess, the below has been padded a 857 little. */ 858 if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2)) 859 rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32); 860 861 /* Make sure that the packet buffer is plenty big enough for 862 this architecture. */ 863 if (rs->buf_size < rsa->remote_packet_size) 864 { 865 rs->buf_size = 2 * rsa->remote_packet_size; 866 rs->buf = (char *) xrealloc (rs->buf, rs->buf_size); 867 } 868 869 return rsa; 870} 871 872/* Return the current allowed size of a remote packet. This is 873 inferred from the current architecture, and should be used to 874 limit the length of outgoing packets. */ 875static long 876get_remote_packet_size (void) 877{ 878 struct remote_state *rs = get_remote_state (); 879 struct remote_arch_state *rsa = get_remote_arch_state (); 880 881 if (rs->explicit_packet_size) 882 return rs->explicit_packet_size; 883 884 return rsa->remote_packet_size; 885} 886 887static struct packet_reg * 888packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum) 889{ 890 if (regnum < 0 && regnum >= gdbarch_num_regs (target_gdbarch ())) 891 return NULL; 892 else 893 { 894 struct packet_reg *r = &rsa->regs[regnum]; 895 896 gdb_assert (r->regnum == regnum); 897 return r; 898 } 899} 900 901static struct packet_reg * 902packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum) 903{ 904 int i; 905 906 for (i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++) 907 { 908 struct packet_reg *r = &rsa->regs[i]; 909 910 if (r->pnum == pnum) 911 return r; 912 } 913 return NULL; 914} 915 916static struct target_ops remote_ops; 917 918static struct target_ops extended_remote_ops; 919 920/* FIXME: cagney/1999-09-23: Even though getpkt was called with 921 ``forever'' still use the normal timeout mechanism. This is 922 currently used by the ASYNC code to guarentee that target reads 923 during the initial connect always time-out. Once getpkt has been 924 modified to return a timeout indication and, in turn 925 remote_wait()/wait_for_inferior() have gained a timeout parameter 926 this can go away. */ 927static int wait_forever_enabled_p = 1; 928 929/* Allow the user to specify what sequence to send to the remote 930 when he requests a program interruption: Although ^C is usually 931 what remote systems expect (this is the default, here), it is 932 sometimes preferable to send a break. On other systems such 933 as the Linux kernel, a break followed by g, which is Magic SysRq g 934 is required in order to interrupt the execution. */ 935const char interrupt_sequence_control_c[] = "Ctrl-C"; 936const char interrupt_sequence_break[] = "BREAK"; 937const char interrupt_sequence_break_g[] = "BREAK-g"; 938static const char *const interrupt_sequence_modes[] = 939 { 940 interrupt_sequence_control_c, 941 interrupt_sequence_break, 942 interrupt_sequence_break_g, 943 NULL 944 }; 945static const char *interrupt_sequence_mode = interrupt_sequence_control_c; 946 947static void 948show_interrupt_sequence (struct ui_file *file, int from_tty, 949 struct cmd_list_element *c, 950 const char *value) 951{ 952 if (interrupt_sequence_mode == interrupt_sequence_control_c) 953 fprintf_filtered (file, 954 _("Send the ASCII ETX character (Ctrl-c) " 955 "to the remote target to interrupt the " 956 "execution of the program.\n")); 957 else if (interrupt_sequence_mode == interrupt_sequence_break) 958 fprintf_filtered (file, 959 _("send a break signal to the remote target " 960 "to interrupt the execution of the program.\n")); 961 else if (interrupt_sequence_mode == interrupt_sequence_break_g) 962 fprintf_filtered (file, 963 _("Send a break signal and 'g' a.k.a. Magic SysRq g to " 964 "the remote target to interrupt the execution " 965 "of Linux kernel.\n")); 966 else 967 internal_error (__FILE__, __LINE__, 968 _("Invalid value for interrupt_sequence_mode: %s."), 969 interrupt_sequence_mode); 970} 971 972/* This boolean variable specifies whether interrupt_sequence is sent 973 to the remote target when gdb connects to it. 974 This is mostly needed when you debug the Linux kernel: The Linux kernel 975 expects BREAK g which is Magic SysRq g for connecting gdb. */ 976static int interrupt_on_connect = 0; 977 978/* This variable is used to implement the "set/show remotebreak" commands. 979 Since these commands are now deprecated in favor of "set/show remote 980 interrupt-sequence", it no longer has any effect on the code. */ 981static int remote_break; 982 983static void 984set_remotebreak (char *args, int from_tty, struct cmd_list_element *c) 985{ 986 if (remote_break) 987 interrupt_sequence_mode = interrupt_sequence_break; 988 else 989 interrupt_sequence_mode = interrupt_sequence_control_c; 990} 991 992static void 993show_remotebreak (struct ui_file *file, int from_tty, 994 struct cmd_list_element *c, 995 const char *value) 996{ 997} 998 999/* This variable sets the number of bits in an address that are to be 1000 sent in a memory ("M" or "m") packet. Normally, after stripping 1001 leading zeros, the entire address would be sent. This variable 1002 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The 1003 initial implementation of remote.c restricted the address sent in 1004 memory packets to ``host::sizeof long'' bytes - (typically 32 1005 bits). Consequently, for 64 bit targets, the upper 32 bits of an 1006 address was never sent. Since fixing this bug may cause a break in 1007 some remote targets this variable is principly provided to 1008 facilitate backward compatibility. */ 1009 1010static unsigned int remote_address_size; 1011 1012/* Temporary to track who currently owns the terminal. See 1013 remote_terminal_* for more details. */ 1014 1015static int remote_async_terminal_ours_p; 1016 1017 1018/* User configurable variables for the number of characters in a 1019 memory read/write packet. MIN (rsa->remote_packet_size, 1020 rsa->sizeof_g_packet) is the default. Some targets need smaller 1021 values (fifo overruns, et.al.) and some users need larger values 1022 (speed up transfers). The variables ``preferred_*'' (the user 1023 request), ``current_*'' (what was actually set) and ``forced_*'' 1024 (Positive - a soft limit, negative - a hard limit). */ 1025 1026struct memory_packet_config 1027{ 1028 const char *name; 1029 long size; 1030 int fixed_p; 1031}; 1032 1033/* The default max memory-write-packet-size. The 16k is historical. 1034 (It came from older GDB's using alloca for buffers and the 1035 knowledge (folklore?) that some hosts don't cope very well with 1036 large alloca calls.) */ 1037#define DEFAULT_MAX_MEMORY_PACKET_SIZE 16384 1038 1039/* The minimum remote packet size for memory transfers. Ensures we 1040 can write at least one byte. */ 1041#define MIN_MEMORY_PACKET_SIZE 20 1042 1043/* Compute the current size of a read/write packet. Since this makes 1044 use of ``actual_register_packet_size'' the computation is dynamic. */ 1045 1046static long 1047get_memory_packet_size (struct memory_packet_config *config) 1048{ 1049 struct remote_state *rs = get_remote_state (); 1050 struct remote_arch_state *rsa = get_remote_arch_state (); 1051 1052 long what_they_get; 1053 if (config->fixed_p) 1054 { 1055 if (config->size <= 0) 1056 what_they_get = DEFAULT_MAX_MEMORY_PACKET_SIZE; 1057 else 1058 what_they_get = config->size; 1059 } 1060 else 1061 { 1062 what_they_get = get_remote_packet_size (); 1063 /* Limit the packet to the size specified by the user. */ 1064 if (config->size > 0 1065 && what_they_get > config->size) 1066 what_they_get = config->size; 1067 1068 /* Limit it to the size of the targets ``g'' response unless we have 1069 permission from the stub to use a larger packet size. */ 1070 if (rs->explicit_packet_size == 0 1071 && rsa->actual_register_packet_size > 0 1072 && what_they_get > rsa->actual_register_packet_size) 1073 what_they_get = rsa->actual_register_packet_size; 1074 } 1075 if (what_they_get < MIN_MEMORY_PACKET_SIZE) 1076 what_they_get = MIN_MEMORY_PACKET_SIZE; 1077 1078 /* Make sure there is room in the global buffer for this packet 1079 (including its trailing NUL byte). */ 1080 if (rs->buf_size < what_they_get + 1) 1081 { 1082 rs->buf_size = 2 * what_they_get; 1083 rs->buf = (char *) xrealloc (rs->buf, 2 * what_they_get); 1084 } 1085 1086 return what_they_get; 1087} 1088 1089/* Update the size of a read/write packet. If they user wants 1090 something really big then do a sanity check. */ 1091 1092static void 1093set_memory_packet_size (char *args, struct memory_packet_config *config) 1094{ 1095 int fixed_p = config->fixed_p; 1096 long size = config->size; 1097 1098 if (args == NULL) 1099 error (_("Argument required (integer, `fixed' or `limited').")); 1100 else if (strcmp (args, "hard") == 0 1101 || strcmp (args, "fixed") == 0) 1102 fixed_p = 1; 1103 else if (strcmp (args, "soft") == 0 1104 || strcmp (args, "limit") == 0) 1105 fixed_p = 0; 1106 else 1107 { 1108 char *end; 1109 1110 size = strtoul (args, &end, 0); 1111 if (args == end) 1112 error (_("Invalid %s (bad syntax)."), config->name); 1113 1114 /* Instead of explicitly capping the size of a packet to or 1115 disallowing it, the user is allowed to set the size to 1116 something arbitrarily large. */ 1117 } 1118 1119 /* So that the query shows the correct value. */ 1120 if (size <= 0) 1121 size = DEFAULT_MAX_MEMORY_PACKET_SIZE; 1122 1123 /* Extra checks? */ 1124 if (fixed_p && !config->fixed_p) 1125 { 1126 if (! query (_("The target may not be able to correctly handle a %s\n" 1127 "of %ld bytes. Change the packet size? "), 1128 config->name, size)) 1129 error (_("Packet size not changed.")); 1130 } 1131 /* Update the config. */ 1132 config->fixed_p = fixed_p; 1133 config->size = size; 1134} 1135 1136static void 1137show_memory_packet_size (struct memory_packet_config *config) 1138{ 1139 printf_filtered (_("The %s is %ld. "), config->name, config->size); 1140 if (config->fixed_p) 1141 printf_filtered (_("Packets are fixed at %ld bytes.\n"), 1142 get_memory_packet_size (config)); 1143 else 1144 printf_filtered (_("Packets are limited to %ld bytes.\n"), 1145 get_memory_packet_size (config)); 1146} 1147 1148static struct memory_packet_config memory_write_packet_config = 1149{ 1150 "memory-write-packet-size", 1151}; 1152 1153static void 1154set_memory_write_packet_size (char *args, int from_tty) 1155{ 1156 set_memory_packet_size (args, &memory_write_packet_config); 1157} 1158 1159static void 1160show_memory_write_packet_size (char *args, int from_tty) 1161{ 1162 show_memory_packet_size (&memory_write_packet_config); 1163} 1164 1165static long 1166get_memory_write_packet_size (void) 1167{ 1168 return get_memory_packet_size (&memory_write_packet_config); 1169} 1170 1171static struct memory_packet_config memory_read_packet_config = 1172{ 1173 "memory-read-packet-size", 1174}; 1175 1176static void 1177set_memory_read_packet_size (char *args, int from_tty) 1178{ 1179 set_memory_packet_size (args, &memory_read_packet_config); 1180} 1181 1182static void 1183show_memory_read_packet_size (char *args, int from_tty) 1184{ 1185 show_memory_packet_size (&memory_read_packet_config); 1186} 1187 1188static long 1189get_memory_read_packet_size (void) 1190{ 1191 long size = get_memory_packet_size (&memory_read_packet_config); 1192 1193 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an 1194 extra buffer size argument before the memory read size can be 1195 increased beyond this. */ 1196 if (size > get_remote_packet_size ()) 1197 size = get_remote_packet_size (); 1198 return size; 1199} 1200 1201 1202/* Generic configuration support for packets the stub optionally 1203 supports. Allows the user to specify the use of the packet as well 1204 as allowing GDB to auto-detect support in the remote stub. */ 1205 1206enum packet_support 1207 { 1208 PACKET_SUPPORT_UNKNOWN = 0, 1209 PACKET_ENABLE, 1210 PACKET_DISABLE 1211 }; 1212 1213struct packet_config 1214 { 1215 const char *name; 1216 const char *title; 1217 1218 /* If auto, GDB auto-detects support for this packet or feature, 1219 either through qSupported, or by trying the packet and looking 1220 at the response. If true, GDB assumes the target supports this 1221 packet. If false, the packet is disabled. Configs that don't 1222 have an associated command always have this set to auto. */ 1223 enum auto_boolean detect; 1224 1225 /* Does the target support this packet? */ 1226 enum packet_support support; 1227 }; 1228 1229/* Analyze a packet's return value and update the packet config 1230 accordingly. */ 1231 1232enum packet_result 1233{ 1234 PACKET_ERROR, 1235 PACKET_OK, 1236 PACKET_UNKNOWN 1237}; 1238 1239static enum packet_support packet_config_support (struct packet_config *config); 1240static enum packet_support packet_support (int packet); 1241 1242static void 1243show_packet_config_cmd (struct packet_config *config) 1244{ 1245 const char *support = "internal-error"; 1246 1247 switch (packet_config_support (config)) 1248 { 1249 case PACKET_ENABLE: 1250 support = "enabled"; 1251 break; 1252 case PACKET_DISABLE: 1253 support = "disabled"; 1254 break; 1255 case PACKET_SUPPORT_UNKNOWN: 1256 support = "unknown"; 1257 break; 1258 } 1259 switch (config->detect) 1260 { 1261 case AUTO_BOOLEAN_AUTO: 1262 printf_filtered (_("Support for the `%s' packet " 1263 "is auto-detected, currently %s.\n"), 1264 config->name, support); 1265 break; 1266 case AUTO_BOOLEAN_TRUE: 1267 case AUTO_BOOLEAN_FALSE: 1268 printf_filtered (_("Support for the `%s' packet is currently %s.\n"), 1269 config->name, support); 1270 break; 1271 } 1272} 1273 1274static void 1275add_packet_config_cmd (struct packet_config *config, const char *name, 1276 const char *title, int legacy) 1277{ 1278 char *set_doc; 1279 char *show_doc; 1280 char *cmd_name; 1281 1282 config->name = name; 1283 config->title = title; 1284 set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet", 1285 name, title); 1286 show_doc = xstrprintf ("Show current use of remote " 1287 "protocol `%s' (%s) packet", 1288 name, title); 1289 /* set/show TITLE-packet {auto,on,off} */ 1290 cmd_name = xstrprintf ("%s-packet", title); 1291 add_setshow_auto_boolean_cmd (cmd_name, class_obscure, 1292 &config->detect, set_doc, 1293 show_doc, NULL, /* help_doc */ 1294 NULL, 1295 show_remote_protocol_packet_cmd, 1296 &remote_set_cmdlist, &remote_show_cmdlist); 1297 /* The command code copies the documentation strings. */ 1298 xfree (set_doc); 1299 xfree (show_doc); 1300 /* set/show remote NAME-packet {auto,on,off} -- legacy. */ 1301 if (legacy) 1302 { 1303 char *legacy_name; 1304 1305 legacy_name = xstrprintf ("%s-packet", name); 1306 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0, 1307 &remote_set_cmdlist); 1308 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0, 1309 &remote_show_cmdlist); 1310 } 1311} 1312 1313static enum packet_result 1314packet_check_result (const char *buf) 1315{ 1316 if (buf[0] != '\0') 1317 { 1318 /* The stub recognized the packet request. Check that the 1319 operation succeeded. */ 1320 if (buf[0] == 'E' 1321 && isxdigit (buf[1]) && isxdigit (buf[2]) 1322 && buf[3] == '\0') 1323 /* "Enn" - definitly an error. */ 1324 return PACKET_ERROR; 1325 1326 /* Always treat "E." as an error. This will be used for 1327 more verbose error messages, such as E.memtypes. */ 1328 if (buf[0] == 'E' && buf[1] == '.') 1329 return PACKET_ERROR; 1330 1331 /* The packet may or may not be OK. Just assume it is. */ 1332 return PACKET_OK; 1333 } 1334 else 1335 /* The stub does not support the packet. */ 1336 return PACKET_UNKNOWN; 1337} 1338 1339static enum packet_result 1340packet_ok (const char *buf, struct packet_config *config) 1341{ 1342 enum packet_result result; 1343 1344 if (config->detect != AUTO_BOOLEAN_TRUE 1345 && config->support == PACKET_DISABLE) 1346 internal_error (__FILE__, __LINE__, 1347 _("packet_ok: attempt to use a disabled packet")); 1348 1349 result = packet_check_result (buf); 1350 switch (result) 1351 { 1352 case PACKET_OK: 1353 case PACKET_ERROR: 1354 /* The stub recognized the packet request. */ 1355 if (config->support == PACKET_SUPPORT_UNKNOWN) 1356 { 1357 if (remote_debug) 1358 fprintf_unfiltered (gdb_stdlog, 1359 "Packet %s (%s) is supported\n", 1360 config->name, config->title); 1361 config->support = PACKET_ENABLE; 1362 } 1363 break; 1364 case PACKET_UNKNOWN: 1365 /* The stub does not support the packet. */ 1366 if (config->detect == AUTO_BOOLEAN_AUTO 1367 && config->support == PACKET_ENABLE) 1368 { 1369 /* If the stub previously indicated that the packet was 1370 supported then there is a protocol error. */ 1371 error (_("Protocol error: %s (%s) conflicting enabled responses."), 1372 config->name, config->title); 1373 } 1374 else if (config->detect == AUTO_BOOLEAN_TRUE) 1375 { 1376 /* The user set it wrong. */ 1377 error (_("Enabled packet %s (%s) not recognized by stub"), 1378 config->name, config->title); 1379 } 1380 1381 if (remote_debug) 1382 fprintf_unfiltered (gdb_stdlog, 1383 "Packet %s (%s) is NOT supported\n", 1384 config->name, config->title); 1385 config->support = PACKET_DISABLE; 1386 break; 1387 } 1388 1389 return result; 1390} 1391 1392enum { 1393 PACKET_vCont = 0, 1394 PACKET_X, 1395 PACKET_qSymbol, 1396 PACKET_P, 1397 PACKET_p, 1398 PACKET_Z0, 1399 PACKET_Z1, 1400 PACKET_Z2, 1401 PACKET_Z3, 1402 PACKET_Z4, 1403 PACKET_vFile_setfs, 1404 PACKET_vFile_open, 1405 PACKET_vFile_pread, 1406 PACKET_vFile_pwrite, 1407 PACKET_vFile_close, 1408 PACKET_vFile_unlink, 1409 PACKET_vFile_readlink, 1410 PACKET_vFile_fstat, 1411 PACKET_qXfer_auxv, 1412 PACKET_qXfer_features, 1413 PACKET_qXfer_exec_file, 1414 PACKET_qXfer_libraries, 1415 PACKET_qXfer_libraries_svr4, 1416 PACKET_qXfer_memory_map, 1417 PACKET_qXfer_spu_read, 1418 PACKET_qXfer_spu_write, 1419 PACKET_qXfer_osdata, 1420 PACKET_qXfer_threads, 1421 PACKET_qXfer_statictrace_read, 1422 PACKET_qXfer_traceframe_info, 1423 PACKET_qXfer_uib, 1424 PACKET_qGetTIBAddr, 1425 PACKET_qGetTLSAddr, 1426 PACKET_qSupported, 1427 PACKET_qTStatus, 1428 PACKET_QPassSignals, 1429 PACKET_QCatchSyscalls, 1430 PACKET_QProgramSignals, 1431 PACKET_qCRC, 1432 PACKET_qSearch_memory, 1433 PACKET_vAttach, 1434 PACKET_vRun, 1435 PACKET_QStartNoAckMode, 1436 PACKET_vKill, 1437 PACKET_qXfer_siginfo_read, 1438 PACKET_qXfer_siginfo_write, 1439 PACKET_qAttached, 1440 1441 /* Support for conditional tracepoints. */ 1442 PACKET_ConditionalTracepoints, 1443 1444 /* Support for target-side breakpoint conditions. */ 1445 PACKET_ConditionalBreakpoints, 1446 1447 /* Support for target-side breakpoint commands. */ 1448 PACKET_BreakpointCommands, 1449 1450 /* Support for fast tracepoints. */ 1451 PACKET_FastTracepoints, 1452 1453 /* Support for static tracepoints. */ 1454 PACKET_StaticTracepoints, 1455 1456 /* Support for installing tracepoints while a trace experiment is 1457 running. */ 1458 PACKET_InstallInTrace, 1459 1460 PACKET_bc, 1461 PACKET_bs, 1462 PACKET_TracepointSource, 1463 PACKET_QAllow, 1464 PACKET_qXfer_fdpic, 1465 PACKET_QDisableRandomization, 1466 PACKET_QAgent, 1467 PACKET_QTBuffer_size, 1468 PACKET_Qbtrace_off, 1469 PACKET_Qbtrace_bts, 1470 PACKET_Qbtrace_pt, 1471 PACKET_qXfer_btrace, 1472 1473 /* Support for the QNonStop packet. */ 1474 PACKET_QNonStop, 1475 1476 /* Support for the QThreadEvents packet. */ 1477 PACKET_QThreadEvents, 1478 1479 /* Support for multi-process extensions. */ 1480 PACKET_multiprocess_feature, 1481 1482 /* Support for enabling and disabling tracepoints while a trace 1483 experiment is running. */ 1484 PACKET_EnableDisableTracepoints_feature, 1485 1486 /* Support for collecting strings using the tracenz bytecode. */ 1487 PACKET_tracenz_feature, 1488 1489 /* Support for continuing to run a trace experiment while GDB is 1490 disconnected. */ 1491 PACKET_DisconnectedTracing_feature, 1492 1493 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */ 1494 PACKET_augmented_libraries_svr4_read_feature, 1495 1496 /* Support for the qXfer:btrace-conf:read packet. */ 1497 PACKET_qXfer_btrace_conf, 1498 1499 /* Support for the Qbtrace-conf:bts:size packet. */ 1500 PACKET_Qbtrace_conf_bts_size, 1501 1502 /* Support for swbreak+ feature. */ 1503 PACKET_swbreak_feature, 1504 1505 /* Support for hwbreak+ feature. */ 1506 PACKET_hwbreak_feature, 1507 1508 /* Support for fork events. */ 1509 PACKET_fork_event_feature, 1510 1511 /* Support for vfork events. */ 1512 PACKET_vfork_event_feature, 1513 1514 /* Support for the Qbtrace-conf:pt:size packet. */ 1515 PACKET_Qbtrace_conf_pt_size, 1516 1517 /* Support for exec events. */ 1518 PACKET_exec_event_feature, 1519 1520 /* Support for query supported vCont actions. */ 1521 PACKET_vContSupported, 1522 1523 /* Support remote CTRL-C. */ 1524 PACKET_vCtrlC, 1525 1526 /* Support TARGET_WAITKIND_NO_RESUMED. */ 1527 PACKET_no_resumed, 1528 1529 PACKET_MAX 1530}; 1531 1532static struct packet_config remote_protocol_packets[PACKET_MAX]; 1533 1534/* Returns the packet's corresponding "set remote foo-packet" command 1535 state. See struct packet_config for more details. */ 1536 1537static enum auto_boolean 1538packet_set_cmd_state (int packet) 1539{ 1540 return remote_protocol_packets[packet].detect; 1541} 1542 1543/* Returns whether a given packet or feature is supported. This takes 1544 into account the state of the corresponding "set remote foo-packet" 1545 command, which may be used to bypass auto-detection. */ 1546 1547static enum packet_support 1548packet_config_support (struct packet_config *config) 1549{ 1550 switch (config->detect) 1551 { 1552 case AUTO_BOOLEAN_TRUE: 1553 return PACKET_ENABLE; 1554 case AUTO_BOOLEAN_FALSE: 1555 return PACKET_DISABLE; 1556 case AUTO_BOOLEAN_AUTO: 1557 return config->support; 1558 default: 1559 gdb_assert_not_reached (_("bad switch")); 1560 } 1561} 1562 1563/* Same as packet_config_support, but takes the packet's enum value as 1564 argument. */ 1565 1566static enum packet_support 1567packet_support (int packet) 1568{ 1569 struct packet_config *config = &remote_protocol_packets[packet]; 1570 1571 return packet_config_support (config); 1572} 1573 1574static void 1575show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty, 1576 struct cmd_list_element *c, 1577 const char *value) 1578{ 1579 struct packet_config *packet; 1580 1581 for (packet = remote_protocol_packets; 1582 packet < &remote_protocol_packets[PACKET_MAX]; 1583 packet++) 1584 { 1585 if (&packet->detect == c->var) 1586 { 1587 show_packet_config_cmd (packet); 1588 return; 1589 } 1590 } 1591 internal_error (__FILE__, __LINE__, _("Could not find config for %s"), 1592 c->name); 1593} 1594 1595/* Should we try one of the 'Z' requests? */ 1596 1597enum Z_packet_type 1598{ 1599 Z_PACKET_SOFTWARE_BP, 1600 Z_PACKET_HARDWARE_BP, 1601 Z_PACKET_WRITE_WP, 1602 Z_PACKET_READ_WP, 1603 Z_PACKET_ACCESS_WP, 1604 NR_Z_PACKET_TYPES 1605}; 1606 1607/* For compatibility with older distributions. Provide a ``set remote 1608 Z-packet ...'' command that updates all the Z packet types. */ 1609 1610static enum auto_boolean remote_Z_packet_detect; 1611 1612static void 1613set_remote_protocol_Z_packet_cmd (char *args, int from_tty, 1614 struct cmd_list_element *c) 1615{ 1616 int i; 1617 1618 for (i = 0; i < NR_Z_PACKET_TYPES; i++) 1619 remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect; 1620} 1621 1622static void 1623show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty, 1624 struct cmd_list_element *c, 1625 const char *value) 1626{ 1627 int i; 1628 1629 for (i = 0; i < NR_Z_PACKET_TYPES; i++) 1630 { 1631 show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]); 1632 } 1633} 1634 1635/* Returns true if the multi-process extensions are in effect. */ 1636 1637static int 1638remote_multi_process_p (struct remote_state *rs) 1639{ 1640 return packet_support (PACKET_multiprocess_feature) == PACKET_ENABLE; 1641} 1642 1643/* Returns true if fork events are supported. */ 1644 1645static int 1646remote_fork_event_p (struct remote_state *rs) 1647{ 1648 return packet_support (PACKET_fork_event_feature) == PACKET_ENABLE; 1649} 1650 1651/* Returns true if vfork events are supported. */ 1652 1653static int 1654remote_vfork_event_p (struct remote_state *rs) 1655{ 1656 return packet_support (PACKET_vfork_event_feature) == PACKET_ENABLE; 1657} 1658 1659/* Returns true if exec events are supported. */ 1660 1661static int 1662remote_exec_event_p (struct remote_state *rs) 1663{ 1664 return packet_support (PACKET_exec_event_feature) == PACKET_ENABLE; 1665} 1666 1667/* Insert fork catchpoint target routine. If fork events are enabled 1668 then return success, nothing more to do. */ 1669 1670static int 1671remote_insert_fork_catchpoint (struct target_ops *ops, int pid) 1672{ 1673 struct remote_state *rs = get_remote_state (); 1674 1675 return !remote_fork_event_p (rs); 1676} 1677 1678/* Remove fork catchpoint target routine. Nothing to do, just 1679 return success. */ 1680 1681static int 1682remote_remove_fork_catchpoint (struct target_ops *ops, int pid) 1683{ 1684 return 0; 1685} 1686 1687/* Insert vfork catchpoint target routine. If vfork events are enabled 1688 then return success, nothing more to do. */ 1689 1690static int 1691remote_insert_vfork_catchpoint (struct target_ops *ops, int pid) 1692{ 1693 struct remote_state *rs = get_remote_state (); 1694 1695 return !remote_vfork_event_p (rs); 1696} 1697 1698/* Remove vfork catchpoint target routine. Nothing to do, just 1699 return success. */ 1700 1701static int 1702remote_remove_vfork_catchpoint (struct target_ops *ops, int pid) 1703{ 1704 return 0; 1705} 1706 1707/* Insert exec catchpoint target routine. If exec events are 1708 enabled, just return success. */ 1709 1710static int 1711remote_insert_exec_catchpoint (struct target_ops *ops, int pid) 1712{ 1713 struct remote_state *rs = get_remote_state (); 1714 1715 return !remote_exec_event_p (rs); 1716} 1717 1718/* Remove exec catchpoint target routine. Nothing to do, just 1719 return success. */ 1720 1721static int 1722remote_remove_exec_catchpoint (struct target_ops *ops, int pid) 1723{ 1724 return 0; 1725} 1726 1727 1728/* Asynchronous signal handle registered as event loop source for 1729 when we have pending events ready to be passed to the core. */ 1730 1731static struct async_event_handler *remote_async_inferior_event_token; 1732 1733 1734 1735static ptid_t magic_null_ptid; 1736static ptid_t not_sent_ptid; 1737static ptid_t any_thread_ptid; 1738 1739/* Find out if the stub attached to PID (and hence GDB should offer to 1740 detach instead of killing it when bailing out). */ 1741 1742static int 1743remote_query_attached (int pid) 1744{ 1745 struct remote_state *rs = get_remote_state (); 1746 size_t size = get_remote_packet_size (); 1747 1748 if (packet_support (PACKET_qAttached) == PACKET_DISABLE) 1749 return 0; 1750 1751 if (remote_multi_process_p (rs)) 1752 xsnprintf (rs->buf, size, "qAttached:%x", pid); 1753 else 1754 xsnprintf (rs->buf, size, "qAttached"); 1755 1756 putpkt (rs->buf); 1757 getpkt (&rs->buf, &rs->buf_size, 0); 1758 1759 switch (packet_ok (rs->buf, 1760 &remote_protocol_packets[PACKET_qAttached])) 1761 { 1762 case PACKET_OK: 1763 if (strcmp (rs->buf, "1") == 0) 1764 return 1; 1765 break; 1766 case PACKET_ERROR: 1767 warning (_("Remote failure reply: %s"), rs->buf); 1768 break; 1769 case PACKET_UNKNOWN: 1770 break; 1771 } 1772 1773 return 0; 1774} 1775 1776/* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID 1777 has been invented by GDB, instead of reported by the target. Since 1778 we can be connected to a remote system before before knowing about 1779 any inferior, mark the target with execution when we find the first 1780 inferior. If ATTACHED is 1, then we had just attached to this 1781 inferior. If it is 0, then we just created this inferior. If it 1782 is -1, then try querying the remote stub to find out if it had 1783 attached to the inferior or not. If TRY_OPEN_EXEC is true then 1784 attempt to open this inferior's executable as the main executable 1785 if no main executable is open already. */ 1786 1787static struct inferior * 1788remote_add_inferior (int fake_pid_p, int pid, int attached, 1789 int try_open_exec) 1790{ 1791 struct inferior *inf; 1792 1793 /* Check whether this process we're learning about is to be 1794 considered attached, or if is to be considered to have been 1795 spawned by the stub. */ 1796 if (attached == -1) 1797 attached = remote_query_attached (pid); 1798 1799 if (gdbarch_has_global_solist (target_gdbarch ())) 1800 { 1801 /* If the target shares code across all inferiors, then every 1802 attach adds a new inferior. */ 1803 inf = add_inferior (pid); 1804 1805 /* ... and every inferior is bound to the same program space. 1806 However, each inferior may still have its own address 1807 space. */ 1808 inf->aspace = maybe_new_address_space (); 1809 inf->pspace = current_program_space; 1810 } 1811 else 1812 { 1813 /* In the traditional debugging scenario, there's a 1-1 match 1814 between program/address spaces. We simply bind the inferior 1815 to the program space's address space. */ 1816 inf = current_inferior (); 1817 inferior_appeared (inf, pid); 1818 } 1819 1820 inf->attach_flag = attached; 1821 inf->fake_pid_p = fake_pid_p; 1822 1823 /* If no main executable is currently open then attempt to 1824 open the file that was executed to create this inferior. */ 1825 if (try_open_exec && get_exec_file (0) == NULL) 1826 exec_file_locate_attach (pid, 0, 1); 1827 1828 return inf; 1829} 1830 1831static struct private_thread_info * 1832 get_private_info_thread (struct thread_info *info); 1833 1834/* Add thread PTID to GDB's thread list. Tag it as executing/running 1835 according to RUNNING. */ 1836 1837static void 1838remote_add_thread (ptid_t ptid, int running, int executing) 1839{ 1840 struct remote_state *rs = get_remote_state (); 1841 struct thread_info *thread; 1842 1843 /* GDB historically didn't pull threads in the initial connection 1844 setup. If the remote target doesn't even have a concept of 1845 threads (e.g., a bare-metal target), even if internally we 1846 consider that a single-threaded target, mentioning a new thread 1847 might be confusing to the user. Be silent then, preserving the 1848 age old behavior. */ 1849 if (rs->starting_up) 1850 thread = add_thread_silent (ptid); 1851 else 1852 thread = add_thread (ptid); 1853 1854 get_private_info_thread (thread)->vcont_resumed = executing; 1855 set_executing (ptid, executing); 1856 set_running (ptid, running); 1857} 1858 1859/* Come here when we learn about a thread id from the remote target. 1860 It may be the first time we hear about such thread, so take the 1861 opportunity to add it to GDB's thread list. In case this is the 1862 first time we're noticing its corresponding inferior, add it to 1863 GDB's inferior list as well. EXECUTING indicates whether the 1864 thread is (internally) executing or stopped. */ 1865 1866static void 1867remote_notice_new_inferior (ptid_t currthread, int executing) 1868{ 1869 /* In non-stop mode, we assume new found threads are (externally) 1870 running until proven otherwise with a stop reply. In all-stop, 1871 we can only get here if all threads are stopped. */ 1872 int running = target_is_non_stop_p () ? 1 : 0; 1873 1874 /* If this is a new thread, add it to GDB's thread list. 1875 If we leave it up to WFI to do this, bad things will happen. */ 1876 1877 if (in_thread_list (currthread) && is_exited (currthread)) 1878 { 1879 /* We're seeing an event on a thread id we knew had exited. 1880 This has to be a new thread reusing the old id. Add it. */ 1881 remote_add_thread (currthread, running, executing); 1882 return; 1883 } 1884 1885 if (!in_thread_list (currthread)) 1886 { 1887 struct inferior *inf = NULL; 1888 int pid = ptid_get_pid (currthread); 1889 1890 if (ptid_is_pid (inferior_ptid) 1891 && pid == ptid_get_pid (inferior_ptid)) 1892 { 1893 /* inferior_ptid has no thread member yet. This can happen 1894 with the vAttach -> remote_wait,"TAAthread:" path if the 1895 stub doesn't support qC. This is the first stop reported 1896 after an attach, so this is the main thread. Update the 1897 ptid in the thread list. */ 1898 if (in_thread_list (pid_to_ptid (pid))) 1899 thread_change_ptid (inferior_ptid, currthread); 1900 else 1901 { 1902 remote_add_thread (currthread, running, executing); 1903 inferior_ptid = currthread; 1904 } 1905 return; 1906 } 1907 1908 if (ptid_equal (magic_null_ptid, inferior_ptid)) 1909 { 1910 /* inferior_ptid is not set yet. This can happen with the 1911 vRun -> remote_wait,"TAAthread:" path if the stub 1912 doesn't support qC. This is the first stop reported 1913 after an attach, so this is the main thread. Update the 1914 ptid in the thread list. */ 1915 thread_change_ptid (inferior_ptid, currthread); 1916 return; 1917 } 1918 1919 /* When connecting to a target remote, or to a target 1920 extended-remote which already was debugging an inferior, we 1921 may not know about it yet. Add it before adding its child 1922 thread, so notifications are emitted in a sensible order. */ 1923 if (!in_inferior_list (ptid_get_pid (currthread))) 1924 { 1925 struct remote_state *rs = get_remote_state (); 1926 int fake_pid_p = !remote_multi_process_p (rs); 1927 1928 inf = remote_add_inferior (fake_pid_p, 1929 ptid_get_pid (currthread), -1, 1); 1930 } 1931 1932 /* This is really a new thread. Add it. */ 1933 remote_add_thread (currthread, running, executing); 1934 1935 /* If we found a new inferior, let the common code do whatever 1936 it needs to with it (e.g., read shared libraries, insert 1937 breakpoints), unless we're just setting up an all-stop 1938 connection. */ 1939 if (inf != NULL) 1940 { 1941 struct remote_state *rs = get_remote_state (); 1942 1943 if (!rs->starting_up) 1944 notice_new_inferior (currthread, executing, 0); 1945 } 1946 } 1947} 1948 1949/* Return THREAD's private thread data, creating it if necessary. */ 1950 1951static struct private_thread_info * 1952get_private_info_thread (struct thread_info *thread) 1953{ 1954 gdb_assert (thread != NULL); 1955 1956 if (thread->priv == NULL) 1957 { 1958 struct private_thread_info *priv = XNEW (struct private_thread_info); 1959 1960 thread->private_dtor = free_private_thread_info; 1961 thread->priv = priv; 1962 1963 priv->core = -1; 1964 priv->extra = NULL; 1965 priv->name = NULL; 1966 priv->name = NULL; 1967 priv->last_resume_step = 0; 1968 priv->last_resume_sig = GDB_SIGNAL_0; 1969 priv->vcont_resumed = 0; 1970 } 1971 1972 return thread->priv; 1973} 1974 1975/* Return PTID's private thread data, creating it if necessary. */ 1976 1977static struct private_thread_info * 1978get_private_info_ptid (ptid_t ptid) 1979{ 1980 struct thread_info *info = find_thread_ptid (ptid); 1981 1982 return get_private_info_thread (info); 1983} 1984 1985/* Call this function as a result of 1986 1) A halt indication (T packet) containing a thread id 1987 2) A direct query of currthread 1988 3) Successful execution of set thread */ 1989 1990static void 1991record_currthread (struct remote_state *rs, ptid_t currthread) 1992{ 1993 rs->general_thread = currthread; 1994} 1995 1996/* If 'QPassSignals' is supported, tell the remote stub what signals 1997 it can simply pass through to the inferior without reporting. */ 1998 1999static void 2000remote_pass_signals (struct target_ops *self, 2001 int numsigs, unsigned char *pass_signals) 2002{ 2003 if (packet_support (PACKET_QPassSignals) != PACKET_DISABLE) 2004 { 2005 char *pass_packet, *p; 2006 int count = 0, i; 2007 struct remote_state *rs = get_remote_state (); 2008 2009 gdb_assert (numsigs < 256); 2010 for (i = 0; i < numsigs; i++) 2011 { 2012 if (pass_signals[i]) 2013 count++; 2014 } 2015 pass_packet = (char *) xmalloc (count * 3 + strlen ("QPassSignals:") + 1); 2016 strcpy (pass_packet, "QPassSignals:"); 2017 p = pass_packet + strlen (pass_packet); 2018 for (i = 0; i < numsigs; i++) 2019 { 2020 if (pass_signals[i]) 2021 { 2022 if (i >= 16) 2023 *p++ = tohex (i >> 4); 2024 *p++ = tohex (i & 15); 2025 if (count) 2026 *p++ = ';'; 2027 else 2028 break; 2029 count--; 2030 } 2031 } 2032 *p = 0; 2033 if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet)) 2034 { 2035 putpkt (pass_packet); 2036 getpkt (&rs->buf, &rs->buf_size, 0); 2037 packet_ok (rs->buf, &remote_protocol_packets[PACKET_QPassSignals]); 2038 if (rs->last_pass_packet) 2039 xfree (rs->last_pass_packet); 2040 rs->last_pass_packet = pass_packet; 2041 } 2042 else 2043 xfree (pass_packet); 2044 } 2045} 2046 2047/* If 'QCatchSyscalls' is supported, tell the remote stub 2048 to report syscalls to GDB. */ 2049 2050static int 2051remote_set_syscall_catchpoint (struct target_ops *self, 2052 int pid, int needed, int any_count, 2053 int table_size, int *table) 2054{ 2055 char *catch_packet; 2056 enum packet_result result; 2057 int n_sysno = 0; 2058 2059 if (packet_support (PACKET_QCatchSyscalls) == PACKET_DISABLE) 2060 { 2061 /* Not supported. */ 2062 return 1; 2063 } 2064 2065 if (needed && !any_count) 2066 { 2067 int i; 2068 2069 /* Count how many syscalls are to be caught (table[sysno] != 0). */ 2070 for (i = 0; i < table_size; i++) 2071 { 2072 if (table[i] != 0) 2073 n_sysno++; 2074 } 2075 } 2076 2077 if (remote_debug) 2078 { 2079 fprintf_unfiltered (gdb_stdlog, 2080 "remote_set_syscall_catchpoint " 2081 "pid %d needed %d any_count %d n_sysno %d\n", 2082 pid, needed, any_count, n_sysno); 2083 } 2084 2085 if (needed) 2086 { 2087 /* Prepare a packet with the sysno list, assuming max 8+1 2088 characters for a sysno. If the resulting packet size is too 2089 big, fallback on the non-selective packet. */ 2090 const int maxpktsz = strlen ("QCatchSyscalls:1") + n_sysno * 9 + 1; 2091 2092 catch_packet = (char *) xmalloc (maxpktsz); 2093 strcpy (catch_packet, "QCatchSyscalls:1"); 2094 if (!any_count) 2095 { 2096 int i; 2097 char *p; 2098 2099 p = catch_packet; 2100 p += strlen (p); 2101 2102 /* Add in catch_packet each syscall to be caught (table[i] != 0). */ 2103 for (i = 0; i < table_size; i++) 2104 { 2105 if (table[i] != 0) 2106 p += xsnprintf (p, catch_packet + maxpktsz - p, ";%x", i); 2107 } 2108 } 2109 if (strlen (catch_packet) > get_remote_packet_size ()) 2110 { 2111 /* catch_packet too big. Fallback to less efficient 2112 non selective mode, with GDB doing the filtering. */ 2113 catch_packet[sizeof ("QCatchSyscalls:1") - 1] = 0; 2114 } 2115 } 2116 else 2117 catch_packet = xstrdup ("QCatchSyscalls:0"); 2118 2119 { 2120 struct cleanup *old_chain = make_cleanup (xfree, catch_packet); 2121 struct remote_state *rs = get_remote_state (); 2122 2123 putpkt (catch_packet); 2124 getpkt (&rs->buf, &rs->buf_size, 0); 2125 result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_QCatchSyscalls]); 2126 do_cleanups (old_chain); 2127 if (result == PACKET_OK) 2128 return 0; 2129 else 2130 return -1; 2131 } 2132} 2133 2134/* If 'QProgramSignals' is supported, tell the remote stub what 2135 signals it should pass through to the inferior when detaching. */ 2136 2137static void 2138remote_program_signals (struct target_ops *self, 2139 int numsigs, unsigned char *signals) 2140{ 2141 if (packet_support (PACKET_QProgramSignals) != PACKET_DISABLE) 2142 { 2143 char *packet, *p; 2144 int count = 0, i; 2145 struct remote_state *rs = get_remote_state (); 2146 2147 gdb_assert (numsigs < 256); 2148 for (i = 0; i < numsigs; i++) 2149 { 2150 if (signals[i]) 2151 count++; 2152 } 2153 packet = (char *) xmalloc (count * 3 + strlen ("QProgramSignals:") + 1); 2154 strcpy (packet, "QProgramSignals:"); 2155 p = packet + strlen (packet); 2156 for (i = 0; i < numsigs; i++) 2157 { 2158 if (signal_pass_state (i)) 2159 { 2160 if (i >= 16) 2161 *p++ = tohex (i >> 4); 2162 *p++ = tohex (i & 15); 2163 if (count) 2164 *p++ = ';'; 2165 else 2166 break; 2167 count--; 2168 } 2169 } 2170 *p = 0; 2171 if (!rs->last_program_signals_packet 2172 || strcmp (rs->last_program_signals_packet, packet) != 0) 2173 { 2174 putpkt (packet); 2175 getpkt (&rs->buf, &rs->buf_size, 0); 2176 packet_ok (rs->buf, &remote_protocol_packets[PACKET_QProgramSignals]); 2177 xfree (rs->last_program_signals_packet); 2178 rs->last_program_signals_packet = packet; 2179 } 2180 else 2181 xfree (packet); 2182 } 2183} 2184 2185/* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is 2186 MINUS_ONE_PTID, set the thread to -1, so the stub returns the 2187 thread. If GEN is set, set the general thread, if not, then set 2188 the step/continue thread. */ 2189static void 2190set_thread (ptid_t ptid, int gen) 2191{ 2192 struct remote_state *rs = get_remote_state (); 2193 ptid_t state = gen ? rs->general_thread : rs->continue_thread; 2194 char *buf = rs->buf; 2195 char *endbuf = rs->buf + get_remote_packet_size (); 2196 2197 if (ptid_equal (state, ptid)) 2198 return; 2199 2200 *buf++ = 'H'; 2201 *buf++ = gen ? 'g' : 'c'; 2202 if (ptid_equal (ptid, magic_null_ptid)) 2203 xsnprintf (buf, endbuf - buf, "0"); 2204 else if (ptid_equal (ptid, any_thread_ptid)) 2205 xsnprintf (buf, endbuf - buf, "0"); 2206 else if (ptid_equal (ptid, minus_one_ptid)) 2207 xsnprintf (buf, endbuf - buf, "-1"); 2208 else 2209 write_ptid (buf, endbuf, ptid); 2210 putpkt (rs->buf); 2211 getpkt (&rs->buf, &rs->buf_size, 0); 2212 if (gen) 2213 rs->general_thread = ptid; 2214 else 2215 rs->continue_thread = ptid; 2216} 2217 2218static void 2219set_general_thread (ptid_t ptid) 2220{ 2221 set_thread (ptid, 1); 2222} 2223 2224static void 2225set_continue_thread (ptid_t ptid) 2226{ 2227 set_thread (ptid, 0); 2228} 2229 2230/* Change the remote current process. Which thread within the process 2231 ends up selected isn't important, as long as it is the same process 2232 as what INFERIOR_PTID points to. 2233 2234 This comes from that fact that there is no explicit notion of 2235 "selected process" in the protocol. The selected process for 2236 general operations is the process the selected general thread 2237 belongs to. */ 2238 2239static void 2240set_general_process (void) 2241{ 2242 struct remote_state *rs = get_remote_state (); 2243 2244 /* If the remote can't handle multiple processes, don't bother. */ 2245 if (!remote_multi_process_p (rs)) 2246 return; 2247 2248 /* We only need to change the remote current thread if it's pointing 2249 at some other process. */ 2250 if (ptid_get_pid (rs->general_thread) != ptid_get_pid (inferior_ptid)) 2251 set_general_thread (inferior_ptid); 2252} 2253 2254 2255/* Return nonzero if this is the main thread that we made up ourselves 2256 to model non-threaded targets as single-threaded. */ 2257 2258static int 2259remote_thread_always_alive (struct target_ops *ops, ptid_t ptid) 2260{ 2261 if (ptid_equal (ptid, magic_null_ptid)) 2262 /* The main thread is always alive. */ 2263 return 1; 2264 2265 if (ptid_get_pid (ptid) != 0 && ptid_get_lwp (ptid) == 0) 2266 /* The main thread is always alive. This can happen after a 2267 vAttach, if the remote side doesn't support 2268 multi-threading. */ 2269 return 1; 2270 2271 return 0; 2272} 2273 2274/* Return nonzero if the thread PTID is still alive on the remote 2275 system. */ 2276 2277static int 2278remote_thread_alive (struct target_ops *ops, ptid_t ptid) 2279{ 2280 struct remote_state *rs = get_remote_state (); 2281 char *p, *endp; 2282 2283 /* Check if this is a thread that we made up ourselves to model 2284 non-threaded targets as single-threaded. */ 2285 if (remote_thread_always_alive (ops, ptid)) 2286 return 1; 2287 2288 p = rs->buf; 2289 endp = rs->buf + get_remote_packet_size (); 2290 2291 *p++ = 'T'; 2292 write_ptid (p, endp, ptid); 2293 2294 putpkt (rs->buf); 2295 getpkt (&rs->buf, &rs->buf_size, 0); 2296 return (rs->buf[0] == 'O' && rs->buf[1] == 'K'); 2297} 2298 2299/* Return a pointer to a thread name if we know it and NULL otherwise. 2300 The thread_info object owns the memory for the name. */ 2301 2302static const char * 2303remote_thread_name (struct target_ops *ops, struct thread_info *info) 2304{ 2305 if (info->priv != NULL) 2306 return info->priv->name; 2307 2308 return NULL; 2309} 2310 2311/* About these extended threadlist and threadinfo packets. They are 2312 variable length packets but, the fields within them are often fixed 2313 length. They are redundent enough to send over UDP as is the 2314 remote protocol in general. There is a matching unit test module 2315 in libstub. */ 2316 2317/* WARNING: This threadref data structure comes from the remote O.S., 2318 libstub protocol encoding, and remote.c. It is not particularly 2319 changable. */ 2320 2321/* Right now, the internal structure is int. We want it to be bigger. 2322 Plan to fix this. */ 2323 2324typedef int gdb_threadref; /* Internal GDB thread reference. */ 2325 2326/* gdb_ext_thread_info is an internal GDB data structure which is 2327 equivalent to the reply of the remote threadinfo packet. */ 2328 2329struct gdb_ext_thread_info 2330 { 2331 threadref threadid; /* External form of thread reference. */ 2332 int active; /* Has state interesting to GDB? 2333 regs, stack. */ 2334 char display[256]; /* Brief state display, name, 2335 blocked/suspended. */ 2336 char shortname[32]; /* To be used to name threads. */ 2337 char more_display[256]; /* Long info, statistics, queue depth, 2338 whatever. */ 2339 }; 2340 2341/* The volume of remote transfers can be limited by submitting 2342 a mask containing bits specifying the desired information. 2343 Use a union of these values as the 'selection' parameter to 2344 get_thread_info. FIXME: Make these TAG names more thread specific. */ 2345 2346#define TAG_THREADID 1 2347#define TAG_EXISTS 2 2348#define TAG_DISPLAY 4 2349#define TAG_THREADNAME 8 2350#define TAG_MOREDISPLAY 16 2351 2352#define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2) 2353 2354static char *unpack_nibble (char *buf, int *val); 2355 2356static char *unpack_byte (char *buf, int *value); 2357 2358static char *pack_int (char *buf, int value); 2359 2360static char *unpack_int (char *buf, int *value); 2361 2362static char *unpack_string (char *src, char *dest, int length); 2363 2364static char *pack_threadid (char *pkt, threadref *id); 2365 2366static char *unpack_threadid (char *inbuf, threadref *id); 2367 2368void int_to_threadref (threadref *id, int value); 2369 2370static int threadref_to_int (threadref *ref); 2371 2372static void copy_threadref (threadref *dest, threadref *src); 2373 2374static int threadmatch (threadref *dest, threadref *src); 2375 2376static char *pack_threadinfo_request (char *pkt, int mode, 2377 threadref *id); 2378 2379static int remote_unpack_thread_info_response (char *pkt, 2380 threadref *expectedref, 2381 struct gdb_ext_thread_info 2382 *info); 2383 2384 2385static int remote_get_threadinfo (threadref *threadid, 2386 int fieldset, /*TAG mask */ 2387 struct gdb_ext_thread_info *info); 2388 2389static char *pack_threadlist_request (char *pkt, int startflag, 2390 int threadcount, 2391 threadref *nextthread); 2392 2393static int parse_threadlist_response (char *pkt, 2394 int result_limit, 2395 threadref *original_echo, 2396 threadref *resultlist, 2397 int *doneflag); 2398 2399static int remote_get_threadlist (int startflag, 2400 threadref *nextthread, 2401 int result_limit, 2402 int *done, 2403 int *result_count, 2404 threadref *threadlist); 2405 2406typedef int (*rmt_thread_action) (threadref *ref, void *context); 2407 2408static int remote_threadlist_iterator (rmt_thread_action stepfunction, 2409 void *context, int looplimit); 2410 2411static int remote_newthread_step (threadref *ref, void *context); 2412 2413 2414/* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the 2415 buffer we're allowed to write to. Returns 2416 BUF+CHARACTERS_WRITTEN. */ 2417 2418static char * 2419write_ptid (char *buf, const char *endbuf, ptid_t ptid) 2420{ 2421 int pid, tid; 2422 struct remote_state *rs = get_remote_state (); 2423 2424 if (remote_multi_process_p (rs)) 2425 { 2426 pid = ptid_get_pid (ptid); 2427 if (pid < 0) 2428 buf += xsnprintf (buf, endbuf - buf, "p-%x.", -pid); 2429 else 2430 buf += xsnprintf (buf, endbuf - buf, "p%x.", pid); 2431 } 2432 tid = ptid_get_lwp (ptid); 2433 if (tid < 0) 2434 buf += xsnprintf (buf, endbuf - buf, "-%x", -tid); 2435 else 2436 buf += xsnprintf (buf, endbuf - buf, "%x", tid); 2437 2438 return buf; 2439} 2440 2441/* Extract a PTID from BUF. If non-null, OBUF is set to the to one 2442 passed the last parsed char. Returns null_ptid on error. */ 2443 2444static ptid_t 2445read_ptid (char *buf, char **obuf) 2446{ 2447 char *p = buf; 2448 char *pp; 2449 ULONGEST pid = 0, tid = 0; 2450 2451 if (*p == 'p') 2452 { 2453 /* Multi-process ptid. */ 2454 pp = unpack_varlen_hex (p + 1, &pid); 2455 if (*pp != '.') 2456 error (_("invalid remote ptid: %s"), p); 2457 2458 p = pp; 2459 pp = unpack_varlen_hex (p + 1, &tid); 2460 if (obuf) 2461 *obuf = pp; 2462 return ptid_build (pid, tid, 0); 2463 } 2464 2465 /* No multi-process. Just a tid. */ 2466 pp = unpack_varlen_hex (p, &tid); 2467 2468 /* Return null_ptid when no thread id is found. */ 2469 if (p == pp) 2470 { 2471 if (obuf) 2472 *obuf = pp; 2473 return null_ptid; 2474 } 2475 2476 /* Since the stub is not sending a process id, then default to 2477 what's in inferior_ptid, unless it's null at this point. If so, 2478 then since there's no way to know the pid of the reported 2479 threads, use the magic number. */ 2480 if (ptid_equal (inferior_ptid, null_ptid)) 2481 pid = ptid_get_pid (magic_null_ptid); 2482 else 2483 pid = ptid_get_pid (inferior_ptid); 2484 2485 if (obuf) 2486 *obuf = pp; 2487 return ptid_build (pid, tid, 0); 2488} 2489 2490static int 2491stubhex (int ch) 2492{ 2493 if (ch >= 'a' && ch <= 'f') 2494 return ch - 'a' + 10; 2495 if (ch >= '0' && ch <= '9') 2496 return ch - '0'; 2497 if (ch >= 'A' && ch <= 'F') 2498 return ch - 'A' + 10; 2499 return -1; 2500} 2501 2502static int 2503stub_unpack_int (char *buff, int fieldlength) 2504{ 2505 int nibble; 2506 int retval = 0; 2507 2508 while (fieldlength) 2509 { 2510 nibble = stubhex (*buff++); 2511 retval |= nibble; 2512 fieldlength--; 2513 if (fieldlength) 2514 retval = retval << 4; 2515 } 2516 return retval; 2517} 2518 2519static char * 2520unpack_nibble (char *buf, int *val) 2521{ 2522 *val = fromhex (*buf++); 2523 return buf; 2524} 2525 2526static char * 2527unpack_byte (char *buf, int *value) 2528{ 2529 *value = stub_unpack_int (buf, 2); 2530 return buf + 2; 2531} 2532 2533static char * 2534pack_int (char *buf, int value) 2535{ 2536 buf = pack_hex_byte (buf, (value >> 24) & 0xff); 2537 buf = pack_hex_byte (buf, (value >> 16) & 0xff); 2538 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff); 2539 buf = pack_hex_byte (buf, (value & 0xff)); 2540 return buf; 2541} 2542 2543static char * 2544unpack_int (char *buf, int *value) 2545{ 2546 *value = stub_unpack_int (buf, 8); 2547 return buf + 8; 2548} 2549 2550#if 0 /* Currently unused, uncomment when needed. */ 2551static char *pack_string (char *pkt, char *string); 2552 2553static char * 2554pack_string (char *pkt, char *string) 2555{ 2556 char ch; 2557 int len; 2558 2559 len = strlen (string); 2560 if (len > 200) 2561 len = 200; /* Bigger than most GDB packets, junk??? */ 2562 pkt = pack_hex_byte (pkt, len); 2563 while (len-- > 0) 2564 { 2565 ch = *string++; 2566 if ((ch == '\0') || (ch == '#')) 2567 ch = '*'; /* Protect encapsulation. */ 2568 *pkt++ = ch; 2569 } 2570 return pkt; 2571} 2572#endif /* 0 (unused) */ 2573 2574static char * 2575unpack_string (char *src, char *dest, int length) 2576{ 2577 while (length--) 2578 *dest++ = *src++; 2579 *dest = '\0'; 2580 return src; 2581} 2582 2583static char * 2584pack_threadid (char *pkt, threadref *id) 2585{ 2586 char *limit; 2587 unsigned char *altid; 2588 2589 altid = (unsigned char *) id; 2590 limit = pkt + BUF_THREAD_ID_SIZE; 2591 while (pkt < limit) 2592 pkt = pack_hex_byte (pkt, *altid++); 2593 return pkt; 2594} 2595 2596 2597static char * 2598unpack_threadid (char *inbuf, threadref *id) 2599{ 2600 char *altref; 2601 char *limit = inbuf + BUF_THREAD_ID_SIZE; 2602 int x, y; 2603 2604 altref = (char *) id; 2605 2606 while (inbuf < limit) 2607 { 2608 x = stubhex (*inbuf++); 2609 y = stubhex (*inbuf++); 2610 *altref++ = (x << 4) | y; 2611 } 2612 return inbuf; 2613} 2614 2615/* Externally, threadrefs are 64 bits but internally, they are still 2616 ints. This is due to a mismatch of specifications. We would like 2617 to use 64bit thread references internally. This is an adapter 2618 function. */ 2619 2620void 2621int_to_threadref (threadref *id, int value) 2622{ 2623 unsigned char *scan; 2624 2625 scan = (unsigned char *) id; 2626 { 2627 int i = 4; 2628 while (i--) 2629 *scan++ = 0; 2630 } 2631 *scan++ = (value >> 24) & 0xff; 2632 *scan++ = (value >> 16) & 0xff; 2633 *scan++ = (value >> 8) & 0xff; 2634 *scan++ = (value & 0xff); 2635} 2636 2637static int 2638threadref_to_int (threadref *ref) 2639{ 2640 int i, value = 0; 2641 unsigned char *scan; 2642 2643 scan = *ref; 2644 scan += 4; 2645 i = 4; 2646 while (i-- > 0) 2647 value = (value << 8) | ((*scan++) & 0xff); 2648 return value; 2649} 2650 2651static void 2652copy_threadref (threadref *dest, threadref *src) 2653{ 2654 int i; 2655 unsigned char *csrc, *cdest; 2656 2657 csrc = (unsigned char *) src; 2658 cdest = (unsigned char *) dest; 2659 i = 8; 2660 while (i--) 2661 *cdest++ = *csrc++; 2662} 2663 2664static int 2665threadmatch (threadref *dest, threadref *src) 2666{ 2667 /* Things are broken right now, so just assume we got a match. */ 2668#if 0 2669 unsigned char *srcp, *destp; 2670 int i, result; 2671 srcp = (char *) src; 2672 destp = (char *) dest; 2673 2674 result = 1; 2675 while (i-- > 0) 2676 result &= (*srcp++ == *destp++) ? 1 : 0; 2677 return result; 2678#endif 2679 return 1; 2680} 2681 2682/* 2683 threadid:1, # always request threadid 2684 context_exists:2, 2685 display:4, 2686 unique_name:8, 2687 more_display:16 2688 */ 2689 2690/* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */ 2691 2692static char * 2693pack_threadinfo_request (char *pkt, int mode, threadref *id) 2694{ 2695 *pkt++ = 'q'; /* Info Query */ 2696 *pkt++ = 'P'; /* process or thread info */ 2697 pkt = pack_int (pkt, mode); /* mode */ 2698 pkt = pack_threadid (pkt, id); /* threadid */ 2699 *pkt = '\0'; /* terminate */ 2700 return pkt; 2701} 2702 2703/* These values tag the fields in a thread info response packet. */ 2704/* Tagging the fields allows us to request specific fields and to 2705 add more fields as time goes by. */ 2706 2707#define TAG_THREADID 1 /* Echo the thread identifier. */ 2708#define TAG_EXISTS 2 /* Is this process defined enough to 2709 fetch registers and its stack? */ 2710#define TAG_DISPLAY 4 /* A short thing maybe to put on a window */ 2711#define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */ 2712#define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about 2713 the process. */ 2714 2715static int 2716remote_unpack_thread_info_response (char *pkt, threadref *expectedref, 2717 struct gdb_ext_thread_info *info) 2718{ 2719 struct remote_state *rs = get_remote_state (); 2720 int mask, length; 2721 int tag; 2722 threadref ref; 2723 char *limit = pkt + rs->buf_size; /* Plausible parsing limit. */ 2724 int retval = 1; 2725 2726 /* info->threadid = 0; FIXME: implement zero_threadref. */ 2727 info->active = 0; 2728 info->display[0] = '\0'; 2729 info->shortname[0] = '\0'; 2730 info->more_display[0] = '\0'; 2731 2732 /* Assume the characters indicating the packet type have been 2733 stripped. */ 2734 pkt = unpack_int (pkt, &mask); /* arg mask */ 2735 pkt = unpack_threadid (pkt, &ref); 2736 2737 if (mask == 0) 2738 warning (_("Incomplete response to threadinfo request.")); 2739 if (!threadmatch (&ref, expectedref)) 2740 { /* This is an answer to a different request. */ 2741 warning (_("ERROR RMT Thread info mismatch.")); 2742 return 0; 2743 } 2744 copy_threadref (&info->threadid, &ref); 2745 2746 /* Loop on tagged fields , try to bail if somthing goes wrong. */ 2747 2748 /* Packets are terminated with nulls. */ 2749 while ((pkt < limit) && mask && *pkt) 2750 { 2751 pkt = unpack_int (pkt, &tag); /* tag */ 2752 pkt = unpack_byte (pkt, &length); /* length */ 2753 if (!(tag & mask)) /* Tags out of synch with mask. */ 2754 { 2755 warning (_("ERROR RMT: threadinfo tag mismatch.")); 2756 retval = 0; 2757 break; 2758 } 2759 if (tag == TAG_THREADID) 2760 { 2761 if (length != 16) 2762 { 2763 warning (_("ERROR RMT: length of threadid is not 16.")); 2764 retval = 0; 2765 break; 2766 } 2767 pkt = unpack_threadid (pkt, &ref); 2768 mask = mask & ~TAG_THREADID; 2769 continue; 2770 } 2771 if (tag == TAG_EXISTS) 2772 { 2773 info->active = stub_unpack_int (pkt, length); 2774 pkt += length; 2775 mask = mask & ~(TAG_EXISTS); 2776 if (length > 8) 2777 { 2778 warning (_("ERROR RMT: 'exists' length too long.")); 2779 retval = 0; 2780 break; 2781 } 2782 continue; 2783 } 2784 if (tag == TAG_THREADNAME) 2785 { 2786 pkt = unpack_string (pkt, &info->shortname[0], length); 2787 mask = mask & ~TAG_THREADNAME; 2788 continue; 2789 } 2790 if (tag == TAG_DISPLAY) 2791 { 2792 pkt = unpack_string (pkt, &info->display[0], length); 2793 mask = mask & ~TAG_DISPLAY; 2794 continue; 2795 } 2796 if (tag == TAG_MOREDISPLAY) 2797 { 2798 pkt = unpack_string (pkt, &info->more_display[0], length); 2799 mask = mask & ~TAG_MOREDISPLAY; 2800 continue; 2801 } 2802 warning (_("ERROR RMT: unknown thread info tag.")); 2803 break; /* Not a tag we know about. */ 2804 } 2805 return retval; 2806} 2807 2808static int 2809remote_get_threadinfo (threadref *threadid, int fieldset, /* TAG mask */ 2810 struct gdb_ext_thread_info *info) 2811{ 2812 struct remote_state *rs = get_remote_state (); 2813 int result; 2814 2815 pack_threadinfo_request (rs->buf, fieldset, threadid); 2816 putpkt (rs->buf); 2817 getpkt (&rs->buf, &rs->buf_size, 0); 2818 2819 if (rs->buf[0] == '\0') 2820 return 0; 2821 2822 result = remote_unpack_thread_info_response (rs->buf + 2, 2823 threadid, info); 2824 return result; 2825} 2826 2827/* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */ 2828 2829static char * 2830pack_threadlist_request (char *pkt, int startflag, int threadcount, 2831 threadref *nextthread) 2832{ 2833 *pkt++ = 'q'; /* info query packet */ 2834 *pkt++ = 'L'; /* Process LIST or threadLIST request */ 2835 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */ 2836 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */ 2837 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */ 2838 *pkt = '\0'; 2839 return pkt; 2840} 2841 2842/* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */ 2843 2844static int 2845parse_threadlist_response (char *pkt, int result_limit, 2846 threadref *original_echo, threadref *resultlist, 2847 int *doneflag) 2848{ 2849 struct remote_state *rs = get_remote_state (); 2850 char *limit; 2851 int count, resultcount, done; 2852 2853 resultcount = 0; 2854 /* Assume the 'q' and 'M chars have been stripped. */ 2855 limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE); 2856 /* done parse past here */ 2857 pkt = unpack_byte (pkt, &count); /* count field */ 2858 pkt = unpack_nibble (pkt, &done); 2859 /* The first threadid is the argument threadid. */ 2860 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */ 2861 while ((count-- > 0) && (pkt < limit)) 2862 { 2863 pkt = unpack_threadid (pkt, resultlist++); 2864 if (resultcount++ >= result_limit) 2865 break; 2866 } 2867 if (doneflag) 2868 *doneflag = done; 2869 return resultcount; 2870} 2871 2872/* Fetch the next batch of threads from the remote. Returns -1 if the 2873 qL packet is not supported, 0 on error and 1 on success. */ 2874 2875static int 2876remote_get_threadlist (int startflag, threadref *nextthread, int result_limit, 2877 int *done, int *result_count, threadref *threadlist) 2878{ 2879 struct remote_state *rs = get_remote_state (); 2880 int result = 1; 2881 2882 /* Trancate result limit to be smaller than the packet size. */ 2883 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) 2884 >= get_remote_packet_size ()) 2885 result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2; 2886 2887 pack_threadlist_request (rs->buf, startflag, result_limit, nextthread); 2888 putpkt (rs->buf); 2889 getpkt (&rs->buf, &rs->buf_size, 0); 2890 if (*rs->buf == '\0') 2891 { 2892 /* Packet not supported. */ 2893 return -1; 2894 } 2895 2896 *result_count = 2897 parse_threadlist_response (rs->buf + 2, result_limit, 2898 &rs->echo_nextthread, threadlist, done); 2899 2900 if (!threadmatch (&rs->echo_nextthread, nextthread)) 2901 { 2902 /* FIXME: This is a good reason to drop the packet. */ 2903 /* Possably, there is a duplicate response. */ 2904 /* Possabilities : 2905 retransmit immediatly - race conditions 2906 retransmit after timeout - yes 2907 exit 2908 wait for packet, then exit 2909 */ 2910 warning (_("HMM: threadlist did not echo arg thread, dropping it.")); 2911 return 0; /* I choose simply exiting. */ 2912 } 2913 if (*result_count <= 0) 2914 { 2915 if (*done != 1) 2916 { 2917 warning (_("RMT ERROR : failed to get remote thread list.")); 2918 result = 0; 2919 } 2920 return result; /* break; */ 2921 } 2922 if (*result_count > result_limit) 2923 { 2924 *result_count = 0; 2925 warning (_("RMT ERROR: threadlist response longer than requested.")); 2926 return 0; 2927 } 2928 return result; 2929} 2930 2931/* Fetch the list of remote threads, with the qL packet, and call 2932 STEPFUNCTION for each thread found. Stops iterating and returns 1 2933 if STEPFUNCTION returns true. Stops iterating and returns 0 if the 2934 STEPFUNCTION returns false. If the packet is not supported, 2935 returns -1. */ 2936 2937static int 2938remote_threadlist_iterator (rmt_thread_action stepfunction, void *context, 2939 int looplimit) 2940{ 2941 struct remote_state *rs = get_remote_state (); 2942 int done, i, result_count; 2943 int startflag = 1; 2944 int result = 1; 2945 int loopcount = 0; 2946 2947 done = 0; 2948 while (!done) 2949 { 2950 if (loopcount++ > looplimit) 2951 { 2952 result = 0; 2953 warning (_("Remote fetch threadlist -infinite loop-.")); 2954 break; 2955 } 2956 result = remote_get_threadlist (startflag, &rs->nextthread, 2957 MAXTHREADLISTRESULTS, 2958 &done, &result_count, 2959 rs->resultthreadlist); 2960 if (result <= 0) 2961 break; 2962 /* Clear for later iterations. */ 2963 startflag = 0; 2964 /* Setup to resume next batch of thread references, set nextthread. */ 2965 if (result_count >= 1) 2966 copy_threadref (&rs->nextthread, 2967 &rs->resultthreadlist[result_count - 1]); 2968 i = 0; 2969 while (result_count--) 2970 { 2971 if (!(*stepfunction) (&rs->resultthreadlist[i++], context)) 2972 { 2973 result = 0; 2974 break; 2975 } 2976 } 2977 } 2978 return result; 2979} 2980 2981/* A thread found on the remote target. */ 2982 2983typedef struct thread_item 2984{ 2985 /* The thread's PTID. */ 2986 ptid_t ptid; 2987 2988 /* The thread's extra info. May be NULL. */ 2989 char *extra; 2990 2991 /* The thread's name. May be NULL. */ 2992 char *name; 2993 2994 /* The core the thread was running on. -1 if not known. */ 2995 int core; 2996} thread_item_t; 2997DEF_VEC_O(thread_item_t); 2998 2999/* Context passed around to the various methods listing remote 3000 threads. As new threads are found, they're added to the ITEMS 3001 vector. */ 3002 3003struct threads_listing_context 3004{ 3005 /* The threads found on the remote target. */ 3006 VEC (thread_item_t) *items; 3007}; 3008 3009/* Discard the contents of the constructed thread listing context. */ 3010 3011static void 3012clear_threads_listing_context (void *p) 3013{ 3014 struct threads_listing_context *context 3015 = (struct threads_listing_context *) p; 3016 int i; 3017 struct thread_item *item; 3018 3019 for (i = 0; VEC_iterate (thread_item_t, context->items, i, item); ++i) 3020 { 3021 xfree (item->extra); 3022 xfree (item->name); 3023 } 3024 3025 VEC_free (thread_item_t, context->items); 3026} 3027 3028/* Remove the thread specified as the related_pid field of WS 3029 from the CONTEXT list. */ 3030 3031static void 3032threads_listing_context_remove (struct target_waitstatus *ws, 3033 struct threads_listing_context *context) 3034{ 3035 struct thread_item *item; 3036 int i; 3037 ptid_t child_ptid = ws->value.related_pid; 3038 3039 for (i = 0; VEC_iterate (thread_item_t, context->items, i, item); ++i) 3040 { 3041 if (ptid_equal (item->ptid, child_ptid)) 3042 { 3043 VEC_ordered_remove (thread_item_t, context->items, i); 3044 break; 3045 } 3046 } 3047} 3048 3049static int 3050remote_newthread_step (threadref *ref, void *data) 3051{ 3052 struct threads_listing_context *context 3053 = (struct threads_listing_context *) data; 3054 struct thread_item item; 3055 int pid = ptid_get_pid (inferior_ptid); 3056 3057 item.ptid = ptid_build (pid, threadref_to_int (ref), 0); 3058 item.core = -1; 3059 item.name = NULL; 3060 item.extra = NULL; 3061 3062 VEC_safe_push (thread_item_t, context->items, &item); 3063 3064 return 1; /* continue iterator */ 3065} 3066 3067#define CRAZY_MAX_THREADS 1000 3068 3069static ptid_t 3070remote_current_thread (ptid_t oldpid) 3071{ 3072 struct remote_state *rs = get_remote_state (); 3073 3074 putpkt ("qC"); 3075 getpkt (&rs->buf, &rs->buf_size, 0); 3076 if (rs->buf[0] == 'Q' && rs->buf[1] == 'C') 3077 { 3078 char *obuf; 3079 ptid_t result; 3080 3081 result = read_ptid (&rs->buf[2], &obuf); 3082 if (*obuf != '\0' && remote_debug) 3083 fprintf_unfiltered (gdb_stdlog, 3084 "warning: garbage in qC reply\n"); 3085 3086 return result; 3087 } 3088 else 3089 return oldpid; 3090} 3091 3092/* List remote threads using the deprecated qL packet. */ 3093 3094static int 3095remote_get_threads_with_ql (struct target_ops *ops, 3096 struct threads_listing_context *context) 3097{ 3098 if (remote_threadlist_iterator (remote_newthread_step, context, 3099 CRAZY_MAX_THREADS) >= 0) 3100 return 1; 3101 3102 return 0; 3103} 3104 3105#if defined(HAVE_LIBEXPAT) 3106 3107static void 3108start_thread (struct gdb_xml_parser *parser, 3109 const struct gdb_xml_element *element, 3110 void *user_data, VEC(gdb_xml_value_s) *attributes) 3111{ 3112 struct threads_listing_context *data 3113 = (struct threads_listing_context *) user_data; 3114 3115 struct thread_item item; 3116 char *id; 3117 struct gdb_xml_value *attr; 3118 3119 id = (char *) xml_find_attribute (attributes, "id")->value; 3120 item.ptid = read_ptid (id, NULL); 3121 3122 attr = xml_find_attribute (attributes, "core"); 3123 if (attr != NULL) 3124 item.core = *(ULONGEST *) attr->value; 3125 else 3126 item.core = -1; 3127 3128 attr = xml_find_attribute (attributes, "name"); 3129 item.name = attr != NULL ? xstrdup ((const char *) attr->value) : NULL; 3130 3131 item.extra = 0; 3132 3133 VEC_safe_push (thread_item_t, data->items, &item); 3134} 3135 3136static void 3137end_thread (struct gdb_xml_parser *parser, 3138 const struct gdb_xml_element *element, 3139 void *user_data, const char *body_text) 3140{ 3141 struct threads_listing_context *data 3142 = (struct threads_listing_context *) user_data; 3143 3144 if (body_text && *body_text) 3145 VEC_last (thread_item_t, data->items)->extra = xstrdup (body_text); 3146} 3147 3148const struct gdb_xml_attribute thread_attributes[] = { 3149 { "id", GDB_XML_AF_NONE, NULL, NULL }, 3150 { "core", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL }, 3151 { "name", GDB_XML_AF_OPTIONAL, NULL, NULL }, 3152 { NULL, GDB_XML_AF_NONE, NULL, NULL } 3153}; 3154 3155const struct gdb_xml_element thread_children[] = { 3156 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } 3157}; 3158 3159const struct gdb_xml_element threads_children[] = { 3160 { "thread", thread_attributes, thread_children, 3161 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL, 3162 start_thread, end_thread }, 3163 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } 3164}; 3165 3166const struct gdb_xml_element threads_elements[] = { 3167 { "threads", NULL, threads_children, 3168 GDB_XML_EF_NONE, NULL, NULL }, 3169 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } 3170}; 3171 3172#endif 3173 3174/* List remote threads using qXfer:threads:read. */ 3175 3176static int 3177remote_get_threads_with_qxfer (struct target_ops *ops, 3178 struct threads_listing_context *context) 3179{ 3180#if defined(HAVE_LIBEXPAT) 3181 if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE) 3182 { 3183 char *xml = target_read_stralloc (ops, TARGET_OBJECT_THREADS, NULL); 3184 struct cleanup *back_to = make_cleanup (xfree, xml); 3185 3186 if (xml != NULL && *xml != '\0') 3187 { 3188 gdb_xml_parse_quick (_("threads"), "threads.dtd", 3189 threads_elements, xml, context); 3190 } 3191 3192 do_cleanups (back_to); 3193 return 1; 3194 } 3195#endif 3196 3197 return 0; 3198} 3199 3200/* List remote threads using qfThreadInfo/qsThreadInfo. */ 3201 3202static int 3203remote_get_threads_with_qthreadinfo (struct target_ops *ops, 3204 struct threads_listing_context *context) 3205{ 3206 struct remote_state *rs = get_remote_state (); 3207 3208 if (rs->use_threadinfo_query) 3209 { 3210 char *bufp; 3211 3212 putpkt ("qfThreadInfo"); 3213 getpkt (&rs->buf, &rs->buf_size, 0); 3214 bufp = rs->buf; 3215 if (bufp[0] != '\0') /* q packet recognized */ 3216 { 3217 while (*bufp++ == 'm') /* reply contains one or more TID */ 3218 { 3219 do 3220 { 3221 struct thread_item item; 3222 3223 item.ptid = read_ptid (bufp, &bufp); 3224 item.core = -1; 3225 item.name = NULL; 3226 item.extra = NULL; 3227 3228 VEC_safe_push (thread_item_t, context->items, &item); 3229 } 3230 while (*bufp++ == ','); /* comma-separated list */ 3231 putpkt ("qsThreadInfo"); 3232 getpkt (&rs->buf, &rs->buf_size, 0); 3233 bufp = rs->buf; 3234 } 3235 return 1; 3236 } 3237 else 3238 { 3239 /* Packet not recognized. */ 3240 rs->use_threadinfo_query = 0; 3241 } 3242 } 3243 3244 return 0; 3245} 3246 3247/* Implement the to_update_thread_list function for the remote 3248 targets. */ 3249 3250static void 3251remote_update_thread_list (struct target_ops *ops) 3252{ 3253 struct threads_listing_context context; 3254 struct cleanup *old_chain; 3255 int got_list = 0; 3256 3257 context.items = NULL; 3258 old_chain = make_cleanup (clear_threads_listing_context, &context); 3259 3260 /* We have a few different mechanisms to fetch the thread list. Try 3261 them all, starting with the most preferred one first, falling 3262 back to older methods. */ 3263 if (remote_get_threads_with_qxfer (ops, &context) 3264 || remote_get_threads_with_qthreadinfo (ops, &context) 3265 || remote_get_threads_with_ql (ops, &context)) 3266 { 3267 int i; 3268 struct thread_item *item; 3269 struct thread_info *tp, *tmp; 3270 3271 got_list = 1; 3272 3273 if (VEC_empty (thread_item_t, context.items) 3274 && remote_thread_always_alive (ops, inferior_ptid)) 3275 { 3276 /* Some targets don't really support threads, but still 3277 reply an (empty) thread list in response to the thread 3278 listing packets, instead of replying "packet not 3279 supported". Exit early so we don't delete the main 3280 thread. */ 3281 do_cleanups (old_chain); 3282 return; 3283 } 3284 3285 /* CONTEXT now holds the current thread list on the remote 3286 target end. Delete GDB-side threads no longer found on the 3287 target. */ 3288 ALL_THREADS_SAFE (tp, tmp) 3289 { 3290 for (i = 0; 3291 VEC_iterate (thread_item_t, context.items, i, item); 3292 ++i) 3293 { 3294 if (ptid_equal (item->ptid, tp->ptid)) 3295 break; 3296 } 3297 3298 if (i == VEC_length (thread_item_t, context.items)) 3299 { 3300 /* Not found. */ 3301 delete_thread (tp->ptid); 3302 } 3303 } 3304 3305 /* Remove any unreported fork child threads from CONTEXT so 3306 that we don't interfere with follow fork, which is where 3307 creation of such threads is handled. */ 3308 remove_new_fork_children (&context); 3309 3310 /* And now add threads we don't know about yet to our list. */ 3311 for (i = 0; 3312 VEC_iterate (thread_item_t, context.items, i, item); 3313 ++i) 3314 { 3315 if (!ptid_equal (item->ptid, null_ptid)) 3316 { 3317 struct private_thread_info *info; 3318 /* In non-stop mode, we assume new found threads are 3319 executing until proven otherwise with a stop reply. 3320 In all-stop, we can only get here if all threads are 3321 stopped. */ 3322 int executing = target_is_non_stop_p () ? 1 : 0; 3323 3324 remote_notice_new_inferior (item->ptid, executing); 3325 3326 info = get_private_info_ptid (item->ptid); 3327 info->core = item->core; 3328 info->extra = item->extra; 3329 item->extra = NULL; 3330 info->name = item->name; 3331 item->name = NULL; 3332 } 3333 } 3334 } 3335 3336 if (!got_list) 3337 { 3338 /* If no thread listing method is supported, then query whether 3339 each known thread is alive, one by one, with the T packet. 3340 If the target doesn't support threads at all, then this is a 3341 no-op. See remote_thread_alive. */ 3342 prune_threads (); 3343 } 3344 3345 do_cleanups (old_chain); 3346} 3347 3348/* 3349 * Collect a descriptive string about the given thread. 3350 * The target may say anything it wants to about the thread 3351 * (typically info about its blocked / runnable state, name, etc.). 3352 * This string will appear in the info threads display. 3353 * 3354 * Optional: targets are not required to implement this function. 3355 */ 3356 3357static const char * 3358remote_threads_extra_info (struct target_ops *self, struct thread_info *tp) 3359{ 3360 struct remote_state *rs = get_remote_state (); 3361 int result; 3362 int set; 3363 threadref id; 3364 struct gdb_ext_thread_info threadinfo; 3365 static char display_buf[100]; /* arbitrary... */ 3366 int n = 0; /* position in display_buf */ 3367 3368 if (rs->remote_desc == 0) /* paranoia */ 3369 internal_error (__FILE__, __LINE__, 3370 _("remote_threads_extra_info")); 3371 3372 if (ptid_equal (tp->ptid, magic_null_ptid) 3373 || (ptid_get_pid (tp->ptid) != 0 && ptid_get_lwp (tp->ptid) == 0)) 3374 /* This is the main thread which was added by GDB. The remote 3375 server doesn't know about it. */ 3376 return NULL; 3377 3378 if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE) 3379 { 3380 struct thread_info *info = find_thread_ptid (tp->ptid); 3381 3382 if (info && info->priv) 3383 return info->priv->extra; 3384 else 3385 return NULL; 3386 } 3387 3388 if (rs->use_threadextra_query) 3389 { 3390 char *b = rs->buf; 3391 char *endb = rs->buf + get_remote_packet_size (); 3392 3393 xsnprintf (b, endb - b, "qThreadExtraInfo,"); 3394 b += strlen (b); 3395 write_ptid (b, endb, tp->ptid); 3396 3397 putpkt (rs->buf); 3398 getpkt (&rs->buf, &rs->buf_size, 0); 3399 if (rs->buf[0] != 0) 3400 { 3401 n = std::min (strlen (rs->buf) / 2, sizeof (display_buf)); 3402 result = hex2bin (rs->buf, (gdb_byte *) display_buf, n); 3403 display_buf [result] = '\0'; 3404 return display_buf; 3405 } 3406 } 3407 3408 /* If the above query fails, fall back to the old method. */ 3409 rs->use_threadextra_query = 0; 3410 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME 3411 | TAG_MOREDISPLAY | TAG_DISPLAY; 3412 int_to_threadref (&id, ptid_get_lwp (tp->ptid)); 3413 if (remote_get_threadinfo (&id, set, &threadinfo)) 3414 if (threadinfo.active) 3415 { 3416 if (*threadinfo.shortname) 3417 n += xsnprintf (&display_buf[0], sizeof (display_buf) - n, 3418 " Name: %s,", threadinfo.shortname); 3419 if (*threadinfo.display) 3420 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n, 3421 " State: %s,", threadinfo.display); 3422 if (*threadinfo.more_display) 3423 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n, 3424 " Priority: %s", threadinfo.more_display); 3425 3426 if (n > 0) 3427 { 3428 /* For purely cosmetic reasons, clear up trailing commas. */ 3429 if (',' == display_buf[n-1]) 3430 display_buf[n-1] = ' '; 3431 return display_buf; 3432 } 3433 } 3434 return NULL; 3435} 3436 3437 3438static int 3439remote_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR addr, 3440 struct static_tracepoint_marker *marker) 3441{ 3442 struct remote_state *rs = get_remote_state (); 3443 char *p = rs->buf; 3444 3445 xsnprintf (p, get_remote_packet_size (), "qTSTMat:"); 3446 p += strlen (p); 3447 p += hexnumstr (p, addr); 3448 putpkt (rs->buf); 3449 getpkt (&rs->buf, &rs->buf_size, 0); 3450 p = rs->buf; 3451 3452 if (*p == 'E') 3453 error (_("Remote failure reply: %s"), p); 3454 3455 if (*p++ == 'm') 3456 { 3457 parse_static_tracepoint_marker_definition (p, &p, marker); 3458 return 1; 3459 } 3460 3461 return 0; 3462} 3463 3464static VEC(static_tracepoint_marker_p) * 3465remote_static_tracepoint_markers_by_strid (struct target_ops *self, 3466 const char *strid) 3467{ 3468 struct remote_state *rs = get_remote_state (); 3469 VEC(static_tracepoint_marker_p) *markers = NULL; 3470 struct static_tracepoint_marker *marker = NULL; 3471 struct cleanup *old_chain; 3472 char *p; 3473 3474 /* Ask for a first packet of static tracepoint marker 3475 definition. */ 3476 putpkt ("qTfSTM"); 3477 getpkt (&rs->buf, &rs->buf_size, 0); 3478 p = rs->buf; 3479 if (*p == 'E') 3480 error (_("Remote failure reply: %s"), p); 3481 3482 old_chain = make_cleanup (free_current_marker, &marker); 3483 3484 while (*p++ == 'm') 3485 { 3486 if (marker == NULL) 3487 marker = XCNEW (struct static_tracepoint_marker); 3488 3489 do 3490 { 3491 parse_static_tracepoint_marker_definition (p, &p, marker); 3492 3493 if (strid == NULL || strcmp (strid, marker->str_id) == 0) 3494 { 3495 VEC_safe_push (static_tracepoint_marker_p, 3496 markers, marker); 3497 marker = NULL; 3498 } 3499 else 3500 { 3501 release_static_tracepoint_marker (marker); 3502 memset (marker, 0, sizeof (*marker)); 3503 } 3504 } 3505 while (*p++ == ','); /* comma-separated list */ 3506 /* Ask for another packet of static tracepoint definition. */ 3507 putpkt ("qTsSTM"); 3508 getpkt (&rs->buf, &rs->buf_size, 0); 3509 p = rs->buf; 3510 } 3511 3512 do_cleanups (old_chain); 3513 return markers; 3514} 3515 3516 3517/* Implement the to_get_ada_task_ptid function for the remote targets. */ 3518 3519static ptid_t 3520remote_get_ada_task_ptid (struct target_ops *self, long lwp, long thread) 3521{ 3522 return ptid_build (ptid_get_pid (inferior_ptid), lwp, 0); 3523} 3524 3525 3526/* Restart the remote side; this is an extended protocol operation. */ 3527 3528static void 3529extended_remote_restart (void) 3530{ 3531 struct remote_state *rs = get_remote_state (); 3532 3533 /* Send the restart command; for reasons I don't understand the 3534 remote side really expects a number after the "R". */ 3535 xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0); 3536 putpkt (rs->buf); 3537 3538 remote_fileio_reset (); 3539} 3540 3541/* Clean up connection to a remote debugger. */ 3542 3543static void 3544remote_close (struct target_ops *self) 3545{ 3546 struct remote_state *rs = get_remote_state (); 3547 3548 if (rs->remote_desc == NULL) 3549 return; /* already closed */ 3550 3551 /* Make sure we leave stdin registered in the event loop. */ 3552 remote_terminal_ours (self); 3553 3554 serial_close (rs->remote_desc); 3555 rs->remote_desc = NULL; 3556 3557 /* We don't have a connection to the remote stub anymore. Get rid 3558 of all the inferiors and their threads we were controlling. 3559 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame 3560 will be unable to find the thread corresponding to (pid, 0, 0). */ 3561 inferior_ptid = null_ptid; 3562 discard_all_inferiors (); 3563 3564 /* We are closing the remote target, so we should discard 3565 everything of this target. */ 3566 discard_pending_stop_replies_in_queue (rs); 3567 3568 if (remote_async_inferior_event_token) 3569 delete_async_event_handler (&remote_async_inferior_event_token); 3570 3571 remote_notif_state_xfree (rs->notif_state); 3572 3573 trace_reset_local_state (); 3574} 3575 3576/* Query the remote side for the text, data and bss offsets. */ 3577 3578static void 3579get_offsets (void) 3580{ 3581 struct remote_state *rs = get_remote_state (); 3582 char *buf; 3583 char *ptr; 3584 int lose, num_segments = 0, do_sections, do_segments; 3585 CORE_ADDR text_addr, data_addr, bss_addr, segments[2]; 3586 struct section_offsets *offs; 3587 struct symfile_segment_data *data; 3588 3589 if (symfile_objfile == NULL) 3590 return; 3591 3592 putpkt ("qOffsets"); 3593 getpkt (&rs->buf, &rs->buf_size, 0); 3594 buf = rs->buf; 3595 3596 if (buf[0] == '\000') 3597 return; /* Return silently. Stub doesn't support 3598 this command. */ 3599 if (buf[0] == 'E') 3600 { 3601 warning (_("Remote failure reply: %s"), buf); 3602 return; 3603 } 3604 3605 /* Pick up each field in turn. This used to be done with scanf, but 3606 scanf will make trouble if CORE_ADDR size doesn't match 3607 conversion directives correctly. The following code will work 3608 with any size of CORE_ADDR. */ 3609 text_addr = data_addr = bss_addr = 0; 3610 ptr = buf; 3611 lose = 0; 3612 3613 if (startswith (ptr, "Text=")) 3614 { 3615 ptr += 5; 3616 /* Don't use strtol, could lose on big values. */ 3617 while (*ptr && *ptr != ';') 3618 text_addr = (text_addr << 4) + fromhex (*ptr++); 3619 3620 if (startswith (ptr, ";Data=")) 3621 { 3622 ptr += 6; 3623 while (*ptr && *ptr != ';') 3624 data_addr = (data_addr << 4) + fromhex (*ptr++); 3625 } 3626 else 3627 lose = 1; 3628 3629 if (!lose && startswith (ptr, ";Bss=")) 3630 { 3631 ptr += 5; 3632 while (*ptr && *ptr != ';') 3633 bss_addr = (bss_addr << 4) + fromhex (*ptr++); 3634 3635 if (bss_addr != data_addr) 3636 warning (_("Target reported unsupported offsets: %s"), buf); 3637 } 3638 else 3639 lose = 1; 3640 } 3641 else if (startswith (ptr, "TextSeg=")) 3642 { 3643 ptr += 8; 3644 /* Don't use strtol, could lose on big values. */ 3645 while (*ptr && *ptr != ';') 3646 text_addr = (text_addr << 4) + fromhex (*ptr++); 3647 num_segments = 1; 3648 3649 if (startswith (ptr, ";DataSeg=")) 3650 { 3651 ptr += 9; 3652 while (*ptr && *ptr != ';') 3653 data_addr = (data_addr << 4) + fromhex (*ptr++); 3654 num_segments++; 3655 } 3656 } 3657 else 3658 lose = 1; 3659 3660 if (lose) 3661 error (_("Malformed response to offset query, %s"), buf); 3662 else if (*ptr != '\0') 3663 warning (_("Target reported unsupported offsets: %s"), buf); 3664 3665 offs = ((struct section_offsets *) 3666 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections))); 3667 memcpy (offs, symfile_objfile->section_offsets, 3668 SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)); 3669 3670 data = get_symfile_segment_data (symfile_objfile->obfd); 3671 do_segments = (data != NULL); 3672 do_sections = num_segments == 0; 3673 3674 if (num_segments > 0) 3675 { 3676 segments[0] = text_addr; 3677 segments[1] = data_addr; 3678 } 3679 /* If we have two segments, we can still try to relocate everything 3680 by assuming that the .text and .data offsets apply to the whole 3681 text and data segments. Convert the offsets given in the packet 3682 to base addresses for symfile_map_offsets_to_segments. */ 3683 else if (data && data->num_segments == 2) 3684 { 3685 segments[0] = data->segment_bases[0] + text_addr; 3686 segments[1] = data->segment_bases[1] + data_addr; 3687 num_segments = 2; 3688 } 3689 /* If the object file has only one segment, assume that it is text 3690 rather than data; main programs with no writable data are rare, 3691 but programs with no code are useless. Of course the code might 3692 have ended up in the data segment... to detect that we would need 3693 the permissions here. */ 3694 else if (data && data->num_segments == 1) 3695 { 3696 segments[0] = data->segment_bases[0] + text_addr; 3697 num_segments = 1; 3698 } 3699 /* There's no way to relocate by segment. */ 3700 else 3701 do_segments = 0; 3702 3703 if (do_segments) 3704 { 3705 int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data, 3706 offs, num_segments, segments); 3707 3708 if (ret == 0 && !do_sections) 3709 error (_("Can not handle qOffsets TextSeg " 3710 "response with this symbol file")); 3711 3712 if (ret > 0) 3713 do_sections = 0; 3714 } 3715 3716 if (data) 3717 free_symfile_segment_data (data); 3718 3719 if (do_sections) 3720 { 3721 offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr; 3722 3723 /* This is a temporary kludge to force data and bss to use the 3724 same offsets because that's what nlmconv does now. The real 3725 solution requires changes to the stub and remote.c that I 3726 don't have time to do right now. */ 3727 3728 offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr; 3729 offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr; 3730 } 3731 3732 objfile_relocate (symfile_objfile, offs); 3733} 3734 3735/* Send interrupt_sequence to remote target. */ 3736static void 3737send_interrupt_sequence (void) 3738{ 3739 struct remote_state *rs = get_remote_state (); 3740 3741 if (interrupt_sequence_mode == interrupt_sequence_control_c) 3742 remote_serial_write ("\x03", 1); 3743 else if (interrupt_sequence_mode == interrupt_sequence_break) 3744 serial_send_break (rs->remote_desc); 3745 else if (interrupt_sequence_mode == interrupt_sequence_break_g) 3746 { 3747 serial_send_break (rs->remote_desc); 3748 remote_serial_write ("g", 1); 3749 } 3750 else 3751 internal_error (__FILE__, __LINE__, 3752 _("Invalid value for interrupt_sequence_mode: %s."), 3753 interrupt_sequence_mode); 3754} 3755 3756 3757/* If STOP_REPLY is a T stop reply, look for the "thread" register, 3758 and extract the PTID. Returns NULL_PTID if not found. */ 3759 3760static ptid_t 3761stop_reply_extract_thread (char *stop_reply) 3762{ 3763 if (stop_reply[0] == 'T' && strlen (stop_reply) > 3) 3764 { 3765 char *p; 3766 3767 /* Txx r:val ; r:val (...) */ 3768 p = &stop_reply[3]; 3769 3770 /* Look for "register" named "thread". */ 3771 while (*p != '\0') 3772 { 3773 char *p1; 3774 3775 p1 = strchr (p, ':'); 3776 if (p1 == NULL) 3777 return null_ptid; 3778 3779 if (strncmp (p, "thread", p1 - p) == 0) 3780 return read_ptid (++p1, &p); 3781 3782 p1 = strchr (p, ';'); 3783 if (p1 == NULL) 3784 return null_ptid; 3785 p1++; 3786 3787 p = p1; 3788 } 3789 } 3790 3791 return null_ptid; 3792} 3793 3794/* Determine the remote side's current thread. If we have a stop 3795 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a 3796 "thread" register we can extract the current thread from. If not, 3797 ask the remote which is the current thread with qC. The former 3798 method avoids a roundtrip. */ 3799 3800static ptid_t 3801get_current_thread (char *wait_status) 3802{ 3803 ptid_t ptid = null_ptid; 3804 3805 /* Note we don't use remote_parse_stop_reply as that makes use of 3806 the target architecture, which we haven't yet fully determined at 3807 this point. */ 3808 if (wait_status != NULL) 3809 ptid = stop_reply_extract_thread (wait_status); 3810 if (ptid_equal (ptid, null_ptid)) 3811 ptid = remote_current_thread (inferior_ptid); 3812 3813 return ptid; 3814} 3815 3816/* Query the remote target for which is the current thread/process, 3817 add it to our tables, and update INFERIOR_PTID. The caller is 3818 responsible for setting the state such that the remote end is ready 3819 to return the current thread. 3820 3821 This function is called after handling the '?' or 'vRun' packets, 3822 whose response is a stop reply from which we can also try 3823 extracting the thread. If the target doesn't support the explicit 3824 qC query, we infer the current thread from that stop reply, passed 3825 in in WAIT_STATUS, which may be NULL. */ 3826 3827static void 3828add_current_inferior_and_thread (char *wait_status) 3829{ 3830 struct remote_state *rs = get_remote_state (); 3831 int fake_pid_p = 0; 3832 ptid_t ptid; 3833 3834 inferior_ptid = null_ptid; 3835 3836 /* Now, if we have thread information, update inferior_ptid. */ 3837 ptid = get_current_thread (wait_status); 3838 3839 if (!ptid_equal (ptid, null_ptid)) 3840 { 3841 if (!remote_multi_process_p (rs)) 3842 fake_pid_p = 1; 3843 3844 inferior_ptid = ptid; 3845 } 3846 else 3847 { 3848 /* Without this, some commands which require an active target 3849 (such as kill) won't work. This variable serves (at least) 3850 double duty as both the pid of the target process (if it has 3851 such), and as a flag indicating that a target is active. */ 3852 inferior_ptid = magic_null_ptid; 3853 fake_pid_p = 1; 3854 } 3855 3856 remote_add_inferior (fake_pid_p, ptid_get_pid (inferior_ptid), -1, 1); 3857 3858 /* Add the main thread. */ 3859 add_thread_silent (inferior_ptid); 3860} 3861 3862/* Print info about a thread that was found already stopped on 3863 connection. */ 3864 3865static void 3866print_one_stopped_thread (struct thread_info *thread) 3867{ 3868 struct target_waitstatus *ws = &thread->suspend.waitstatus; 3869 3870 switch_to_thread (thread->ptid); 3871 stop_pc = get_frame_pc (get_current_frame ()); 3872 set_current_sal_from_frame (get_current_frame ()); 3873 3874 thread->suspend.waitstatus_pending_p = 0; 3875 3876 if (ws->kind == TARGET_WAITKIND_STOPPED) 3877 { 3878 enum gdb_signal sig = ws->value.sig; 3879 3880 if (signal_print_state (sig)) 3881 observer_notify_signal_received (sig); 3882 } 3883 observer_notify_normal_stop (NULL, 1); 3884} 3885 3886/* Process all initial stop replies the remote side sent in response 3887 to the ? packet. These indicate threads that were already stopped 3888 on initial connection. We mark these threads as stopped and print 3889 their current frame before giving the user the prompt. */ 3890 3891static void 3892process_initial_stop_replies (int from_tty) 3893{ 3894 int pending_stop_replies = stop_reply_queue_length (); 3895 struct inferior *inf; 3896 struct thread_info *thread; 3897 struct thread_info *selected = NULL; 3898 struct thread_info *lowest_stopped = NULL; 3899 struct thread_info *first = NULL; 3900 3901 /* Consume the initial pending events. */ 3902 while (pending_stop_replies-- > 0) 3903 { 3904 ptid_t waiton_ptid = minus_one_ptid; 3905 ptid_t event_ptid; 3906 struct target_waitstatus ws; 3907 int ignore_event = 0; 3908 struct thread_info *thread; 3909 3910 memset (&ws, 0, sizeof (ws)); 3911 event_ptid = target_wait (waiton_ptid, &ws, TARGET_WNOHANG); 3912 if (remote_debug) 3913 print_target_wait_results (waiton_ptid, event_ptid, &ws); 3914 3915 switch (ws.kind) 3916 { 3917 case TARGET_WAITKIND_IGNORE: 3918 case TARGET_WAITKIND_NO_RESUMED: 3919 case TARGET_WAITKIND_SIGNALLED: 3920 case TARGET_WAITKIND_EXITED: 3921 /* We shouldn't see these, but if we do, just ignore. */ 3922 if (remote_debug) 3923 fprintf_unfiltered (gdb_stdlog, "remote: event ignored\n"); 3924 ignore_event = 1; 3925 break; 3926 3927 case TARGET_WAITKIND_EXECD: 3928 xfree (ws.value.execd_pathname); 3929 break; 3930 default: 3931 break; 3932 } 3933 3934 if (ignore_event) 3935 continue; 3936 3937 thread = find_thread_ptid (event_ptid); 3938 3939 if (ws.kind == TARGET_WAITKIND_STOPPED) 3940 { 3941 enum gdb_signal sig = ws.value.sig; 3942 3943 /* Stubs traditionally report SIGTRAP as initial signal, 3944 instead of signal 0. Suppress it. */ 3945 if (sig == GDB_SIGNAL_TRAP) 3946 sig = GDB_SIGNAL_0; 3947 thread->suspend.stop_signal = sig; 3948 ws.value.sig = sig; 3949 } 3950 3951 thread->suspend.waitstatus = ws; 3952 3953 if (ws.kind != TARGET_WAITKIND_STOPPED 3954 || ws.value.sig != GDB_SIGNAL_0) 3955 thread->suspend.waitstatus_pending_p = 1; 3956 3957 set_executing (event_ptid, 0); 3958 set_running (event_ptid, 0); 3959 thread->priv->vcont_resumed = 0; 3960 } 3961 3962 /* "Notice" the new inferiors before anything related to 3963 registers/memory. */ 3964 ALL_INFERIORS (inf) 3965 { 3966 if (inf->pid == 0) 3967 continue; 3968 3969 inf->needs_setup = 1; 3970 3971 if (non_stop) 3972 { 3973 thread = any_live_thread_of_process (inf->pid); 3974 notice_new_inferior (thread->ptid, 3975 thread->state == THREAD_RUNNING, 3976 from_tty); 3977 } 3978 } 3979 3980 /* If all-stop on top of non-stop, pause all threads. Note this 3981 records the threads' stop pc, so must be done after "noticing" 3982 the inferiors. */ 3983 if (!non_stop) 3984 { 3985 stop_all_threads (); 3986 3987 /* If all threads of an inferior were already stopped, we 3988 haven't setup the inferior yet. */ 3989 ALL_INFERIORS (inf) 3990 { 3991 if (inf->pid == 0) 3992 continue; 3993 3994 if (inf->needs_setup) 3995 { 3996 thread = any_live_thread_of_process (inf->pid); 3997 switch_to_thread_no_regs (thread); 3998 setup_inferior (0); 3999 } 4000 } 4001 } 4002 4003 /* Now go over all threads that are stopped, and print their current 4004 frame. If all-stop, then if there's a signalled thread, pick 4005 that as current. */ 4006 ALL_NON_EXITED_THREADS (thread) 4007 { 4008 if (first == NULL) 4009 first = thread; 4010 4011 if (!non_stop) 4012 set_running (thread->ptid, 0); 4013 else if (thread->state != THREAD_STOPPED) 4014 continue; 4015 4016 if (selected == NULL 4017 && thread->suspend.waitstatus_pending_p) 4018 selected = thread; 4019 4020 if (lowest_stopped == NULL 4021 || thread->inf->num < lowest_stopped->inf->num 4022 || thread->per_inf_num < lowest_stopped->per_inf_num) 4023 lowest_stopped = thread; 4024 4025 if (non_stop) 4026 print_one_stopped_thread (thread); 4027 } 4028 4029 /* In all-stop, we only print the status of one thread, and leave 4030 others with their status pending. */ 4031 if (!non_stop) 4032 { 4033 thread = selected; 4034 if (thread == NULL) 4035 thread = lowest_stopped; 4036 if (thread == NULL) 4037 thread = first; 4038 4039 print_one_stopped_thread (thread); 4040 } 4041 4042 /* For "info program". */ 4043 thread = inferior_thread (); 4044 if (thread->state == THREAD_STOPPED) 4045 set_last_target_status (inferior_ptid, thread->suspend.waitstatus); 4046} 4047 4048/* Start the remote connection and sync state. */ 4049 4050static void 4051remote_start_remote (int from_tty, struct target_ops *target, int extended_p) 4052{ 4053 struct remote_state *rs = get_remote_state (); 4054 struct packet_config *noack_config; 4055 char *wait_status = NULL; 4056 4057 /* Signal other parts that we're going through the initial setup, 4058 and so things may not be stable yet. E.g., we don't try to 4059 install tracepoints until we've relocated symbols. Also, a 4060 Ctrl-C before we're connected and synced up can't interrupt the 4061 target. Instead, it offers to drop the (potentially wedged) 4062 connection. */ 4063 rs->starting_up = 1; 4064 4065 QUIT; 4066 4067 if (interrupt_on_connect) 4068 send_interrupt_sequence (); 4069 4070 /* Ack any packet which the remote side has already sent. */ 4071 remote_serial_write ("+", 1); 4072 4073 /* The first packet we send to the target is the optional "supported 4074 packets" request. If the target can answer this, it will tell us 4075 which later probes to skip. */ 4076 remote_query_supported (); 4077 4078 /* If the stub wants to get a QAllow, compose one and send it. */ 4079 if (packet_support (PACKET_QAllow) != PACKET_DISABLE) 4080 remote_set_permissions (target); 4081 4082 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any 4083 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB 4084 as a reply to known packet. For packet "vFile:setfs:" it is an 4085 invalid reply and GDB would return error in 4086 remote_hostio_set_filesystem, making remote files access impossible. 4087 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as 4088 other "vFile" packets get correctly detected even on gdbserver < 7.7. */ 4089 { 4090 const char v_mustreplyempty[] = "vMustReplyEmpty"; 4091 4092 putpkt (v_mustreplyempty); 4093 getpkt (&rs->buf, &rs->buf_size, 0); 4094 if (strcmp (rs->buf, "OK") == 0) 4095 remote_protocol_packets[PACKET_vFile_setfs].support = PACKET_DISABLE; 4096 else if (strcmp (rs->buf, "") != 0) 4097 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty, 4098 rs->buf); 4099 } 4100 4101 /* Next, we possibly activate noack mode. 4102 4103 If the QStartNoAckMode packet configuration is set to AUTO, 4104 enable noack mode if the stub reported a wish for it with 4105 qSupported. 4106 4107 If set to TRUE, then enable noack mode even if the stub didn't 4108 report it in qSupported. If the stub doesn't reply OK, the 4109 session ends with an error. 4110 4111 If FALSE, then don't activate noack mode, regardless of what the 4112 stub claimed should be the default with qSupported. */ 4113 4114 noack_config = &remote_protocol_packets[PACKET_QStartNoAckMode]; 4115 if (packet_config_support (noack_config) != PACKET_DISABLE) 4116 { 4117 putpkt ("QStartNoAckMode"); 4118 getpkt (&rs->buf, &rs->buf_size, 0); 4119 if (packet_ok (rs->buf, noack_config) == PACKET_OK) 4120 rs->noack_mode = 1; 4121 } 4122 4123 if (extended_p) 4124 { 4125 /* Tell the remote that we are using the extended protocol. */ 4126 putpkt ("!"); 4127 getpkt (&rs->buf, &rs->buf_size, 0); 4128 } 4129 4130 /* Let the target know which signals it is allowed to pass down to 4131 the program. */ 4132 update_signals_program_target (); 4133 4134 /* Next, if the target can specify a description, read it. We do 4135 this before anything involving memory or registers. */ 4136 target_find_description (); 4137 4138 /* Next, now that we know something about the target, update the 4139 address spaces in the program spaces. */ 4140 update_address_spaces (); 4141 4142 /* On OSs where the list of libraries is global to all 4143 processes, we fetch them early. */ 4144 if (gdbarch_has_global_solist (target_gdbarch ())) 4145 solib_add (NULL, from_tty, auto_solib_add); 4146 4147 if (target_is_non_stop_p ()) 4148 { 4149 if (packet_support (PACKET_QNonStop) != PACKET_ENABLE) 4150 error (_("Non-stop mode requested, but remote " 4151 "does not support non-stop")); 4152 4153 putpkt ("QNonStop:1"); 4154 getpkt (&rs->buf, &rs->buf_size, 0); 4155 4156 if (strcmp (rs->buf, "OK") != 0) 4157 error (_("Remote refused setting non-stop mode with: %s"), rs->buf); 4158 4159 /* Find about threads and processes the stub is already 4160 controlling. We default to adding them in the running state. 4161 The '?' query below will then tell us about which threads are 4162 stopped. */ 4163 remote_update_thread_list (target); 4164 } 4165 else if (packet_support (PACKET_QNonStop) == PACKET_ENABLE) 4166 { 4167 /* Don't assume that the stub can operate in all-stop mode. 4168 Request it explicitly. */ 4169 putpkt ("QNonStop:0"); 4170 getpkt (&rs->buf, &rs->buf_size, 0); 4171 4172 if (strcmp (rs->buf, "OK") != 0) 4173 error (_("Remote refused setting all-stop mode with: %s"), rs->buf); 4174 } 4175 4176 /* Upload TSVs regardless of whether the target is running or not. The 4177 remote stub, such as GDBserver, may have some predefined or builtin 4178 TSVs, even if the target is not running. */ 4179 if (remote_get_trace_status (target, current_trace_status ()) != -1) 4180 { 4181 struct uploaded_tsv *uploaded_tsvs = NULL; 4182 4183 remote_upload_trace_state_variables (target, &uploaded_tsvs); 4184 merge_uploaded_trace_state_variables (&uploaded_tsvs); 4185 } 4186 4187 /* Check whether the target is running now. */ 4188 putpkt ("?"); 4189 getpkt (&rs->buf, &rs->buf_size, 0); 4190 4191 if (!target_is_non_stop_p ()) 4192 { 4193 if (rs->buf[0] == 'W' || rs->buf[0] == 'X') 4194 { 4195 if (!extended_p) 4196 error (_("The target is not running (try extended-remote?)")); 4197 4198 /* We're connected, but not running. Drop out before we 4199 call start_remote. */ 4200 rs->starting_up = 0; 4201 return; 4202 } 4203 else 4204 { 4205 /* Save the reply for later. */ 4206 wait_status = (char *) alloca (strlen (rs->buf) + 1); 4207 strcpy (wait_status, rs->buf); 4208 } 4209 4210 /* Fetch thread list. */ 4211 target_update_thread_list (); 4212 4213 /* Let the stub know that we want it to return the thread. */ 4214 set_continue_thread (minus_one_ptid); 4215 4216 if (thread_count () == 0) 4217 { 4218 /* Target has no concept of threads at all. GDB treats 4219 non-threaded target as single-threaded; add a main 4220 thread. */ 4221 add_current_inferior_and_thread (wait_status); 4222 } 4223 else 4224 { 4225 /* We have thread information; select the thread the target 4226 says should be current. If we're reconnecting to a 4227 multi-threaded program, this will ideally be the thread 4228 that last reported an event before GDB disconnected. */ 4229 inferior_ptid = get_current_thread (wait_status); 4230 if (ptid_equal (inferior_ptid, null_ptid)) 4231 { 4232 /* Odd... The target was able to list threads, but not 4233 tell us which thread was current (no "thread" 4234 register in T stop reply?). Just pick the first 4235 thread in the thread list then. */ 4236 4237 if (remote_debug) 4238 fprintf_unfiltered (gdb_stdlog, 4239 "warning: couldn't determine remote " 4240 "current thread; picking first in list.\n"); 4241 4242 inferior_ptid = thread_list->ptid; 4243 } 4244 } 4245 4246 /* init_wait_for_inferior should be called before get_offsets in order 4247 to manage `inserted' flag in bp loc in a correct state. 4248 breakpoint_init_inferior, called from init_wait_for_inferior, set 4249 `inserted' flag to 0, while before breakpoint_re_set, called from 4250 start_remote, set `inserted' flag to 1. In the initialization of 4251 inferior, breakpoint_init_inferior should be called first, and then 4252 breakpoint_re_set can be called. If this order is broken, state of 4253 `inserted' flag is wrong, and cause some problems on breakpoint 4254 manipulation. */ 4255 init_wait_for_inferior (); 4256 4257 get_offsets (); /* Get text, data & bss offsets. */ 4258 4259 /* If we could not find a description using qXfer, and we know 4260 how to do it some other way, try again. This is not 4261 supported for non-stop; it could be, but it is tricky if 4262 there are no stopped threads when we connect. */ 4263 if (remote_read_description_p (target) 4264 && gdbarch_target_desc (target_gdbarch ()) == NULL) 4265 { 4266 target_clear_description (); 4267 target_find_description (); 4268 } 4269 4270 /* Use the previously fetched status. */ 4271 gdb_assert (wait_status != NULL); 4272 strcpy (rs->buf, wait_status); 4273 rs->cached_wait_status = 1; 4274 4275 start_remote (from_tty); /* Initialize gdb process mechanisms. */ 4276 } 4277 else 4278 { 4279 /* Clear WFI global state. Do this before finding about new 4280 threads and inferiors, and setting the current inferior. 4281 Otherwise we would clear the proceed status of the current 4282 inferior when we want its stop_soon state to be preserved 4283 (see notice_new_inferior). */ 4284 init_wait_for_inferior (); 4285 4286 /* In non-stop, we will either get an "OK", meaning that there 4287 are no stopped threads at this time; or, a regular stop 4288 reply. In the latter case, there may be more than one thread 4289 stopped --- we pull them all out using the vStopped 4290 mechanism. */ 4291 if (strcmp (rs->buf, "OK") != 0) 4292 { 4293 struct notif_client *notif = ¬if_client_stop; 4294 4295 /* remote_notif_get_pending_replies acks this one, and gets 4296 the rest out. */ 4297 rs->notif_state->pending_event[notif_client_stop.id] 4298 = remote_notif_parse (notif, rs->buf); 4299 remote_notif_get_pending_events (notif); 4300 } 4301 4302 if (thread_count () == 0) 4303 { 4304 if (!extended_p) 4305 error (_("The target is not running (try extended-remote?)")); 4306 4307 /* We're connected, but not running. Drop out before we 4308 call start_remote. */ 4309 rs->starting_up = 0; 4310 return; 4311 } 4312 4313 /* In non-stop mode, any cached wait status will be stored in 4314 the stop reply queue. */ 4315 gdb_assert (wait_status == NULL); 4316 4317 /* Report all signals during attach/startup. */ 4318 remote_pass_signals (target, 0, NULL); 4319 4320 /* If there are already stopped threads, mark them stopped and 4321 report their stops before giving the prompt to the user. */ 4322 process_initial_stop_replies (from_tty); 4323 4324 if (target_can_async_p ()) 4325 target_async (1); 4326 } 4327 4328 /* If we connected to a live target, do some additional setup. */ 4329 if (target_has_execution) 4330 { 4331 if (symfile_objfile) /* No use without a symbol-file. */ 4332 remote_check_symbols (); 4333 } 4334 4335 /* Possibly the target has been engaged in a trace run started 4336 previously; find out where things are at. */ 4337 if (remote_get_trace_status (target, current_trace_status ()) != -1) 4338 { 4339 struct uploaded_tp *uploaded_tps = NULL; 4340 4341 if (current_trace_status ()->running) 4342 printf_filtered (_("Trace is already running on the target.\n")); 4343 4344 remote_upload_tracepoints (target, &uploaded_tps); 4345 4346 merge_uploaded_tracepoints (&uploaded_tps); 4347 } 4348 4349 /* Possibly the target has been engaged in a btrace record started 4350 previously; find out where things are at. */ 4351 remote_btrace_maybe_reopen (); 4352 4353 /* The thread and inferior lists are now synchronized with the 4354 target, our symbols have been relocated, and we're merged the 4355 target's tracepoints with ours. We're done with basic start 4356 up. */ 4357 rs->starting_up = 0; 4358 4359 /* Maybe breakpoints are global and need to be inserted now. */ 4360 if (breakpoints_should_be_inserted_now ()) 4361 insert_breakpoints (); 4362} 4363 4364/* Open a connection to a remote debugger. 4365 NAME is the filename used for communication. */ 4366 4367static void 4368remote_open (const char *name, int from_tty) 4369{ 4370 remote_open_1 (name, from_tty, &remote_ops, 0); 4371} 4372 4373/* Open a connection to a remote debugger using the extended 4374 remote gdb protocol. NAME is the filename used for communication. */ 4375 4376static void 4377extended_remote_open (const char *name, int from_tty) 4378{ 4379 remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */); 4380} 4381 4382/* Reset all packets back to "unknown support". Called when opening a 4383 new connection to a remote target. */ 4384 4385static void 4386reset_all_packet_configs_support (void) 4387{ 4388 int i; 4389 4390 for (i = 0; i < PACKET_MAX; i++) 4391 remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN; 4392} 4393 4394/* Initialize all packet configs. */ 4395 4396static void 4397init_all_packet_configs (void) 4398{ 4399 int i; 4400 4401 for (i = 0; i < PACKET_MAX; i++) 4402 { 4403 remote_protocol_packets[i].detect = AUTO_BOOLEAN_AUTO; 4404 remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN; 4405 } 4406} 4407 4408/* Symbol look-up. */ 4409 4410static void 4411remote_check_symbols (void) 4412{ 4413 struct remote_state *rs = get_remote_state (); 4414 char *msg, *reply, *tmp; 4415 int end; 4416 long reply_size; 4417 struct cleanup *old_chain; 4418 4419 /* The remote side has no concept of inferiors that aren't running 4420 yet, it only knows about running processes. If we're connected 4421 but our current inferior is not running, we should not invite the 4422 remote target to request symbol lookups related to its 4423 (unrelated) current process. */ 4424 if (!target_has_execution) 4425 return; 4426 4427 if (packet_support (PACKET_qSymbol) == PACKET_DISABLE) 4428 return; 4429 4430 /* Make sure the remote is pointing at the right process. Note 4431 there's no way to select "no process". */ 4432 set_general_process (); 4433 4434 /* Allocate a message buffer. We can't reuse the input buffer in RS, 4435 because we need both at the same time. */ 4436 msg = (char *) xmalloc (get_remote_packet_size ()); 4437 old_chain = make_cleanup (xfree, msg); 4438 reply = (char *) xmalloc (get_remote_packet_size ()); 4439 make_cleanup (free_current_contents, &reply); 4440 reply_size = get_remote_packet_size (); 4441 4442 /* Invite target to request symbol lookups. */ 4443 4444 putpkt ("qSymbol::"); 4445 getpkt (&reply, &reply_size, 0); 4446 packet_ok (reply, &remote_protocol_packets[PACKET_qSymbol]); 4447 4448 while (startswith (reply, "qSymbol:")) 4449 { 4450 struct bound_minimal_symbol sym; 4451 4452 tmp = &reply[8]; 4453 end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2); 4454 msg[end] = '\0'; 4455 sym = lookup_minimal_symbol (msg, NULL, NULL); 4456 if (sym.minsym == NULL) 4457 xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]); 4458 else 4459 { 4460 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; 4461 CORE_ADDR sym_addr = BMSYMBOL_VALUE_ADDRESS (sym); 4462 4463 /* If this is a function address, return the start of code 4464 instead of any data function descriptor. */ 4465 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (), 4466 sym_addr, 4467 ¤t_target); 4468 4469 xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s", 4470 phex_nz (sym_addr, addr_size), &reply[8]); 4471 } 4472 4473 putpkt (msg); 4474 getpkt (&reply, &reply_size, 0); 4475 } 4476 4477 do_cleanups (old_chain); 4478} 4479 4480static struct serial * 4481remote_serial_open (const char *name) 4482{ 4483 static int udp_warning = 0; 4484 4485 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead 4486 of in ser-tcp.c, because it is the remote protocol assuming that the 4487 serial connection is reliable and not the serial connection promising 4488 to be. */ 4489 if (!udp_warning && startswith (name, "udp:")) 4490 { 4491 warning (_("The remote protocol may be unreliable over UDP.\n" 4492 "Some events may be lost, rendering further debugging " 4493 "impossible.")); 4494 udp_warning = 1; 4495 } 4496 4497 return serial_open (name); 4498} 4499 4500/* Inform the target of our permission settings. The permission flags 4501 work without this, but if the target knows the settings, it can do 4502 a couple things. First, it can add its own check, to catch cases 4503 that somehow manage to get by the permissions checks in target 4504 methods. Second, if the target is wired to disallow particular 4505 settings (for instance, a system in the field that is not set up to 4506 be able to stop at a breakpoint), it can object to any unavailable 4507 permissions. */ 4508 4509void 4510remote_set_permissions (struct target_ops *self) 4511{ 4512 struct remote_state *rs = get_remote_state (); 4513 4514 xsnprintf (rs->buf, get_remote_packet_size (), "QAllow:" 4515 "WriteReg:%x;WriteMem:%x;" 4516 "InsertBreak:%x;InsertTrace:%x;" 4517 "InsertFastTrace:%x;Stop:%x", 4518 may_write_registers, may_write_memory, 4519 may_insert_breakpoints, may_insert_tracepoints, 4520 may_insert_fast_tracepoints, may_stop); 4521 putpkt (rs->buf); 4522 getpkt (&rs->buf, &rs->buf_size, 0); 4523 4524 /* If the target didn't like the packet, warn the user. Do not try 4525 to undo the user's settings, that would just be maddening. */ 4526 if (strcmp (rs->buf, "OK") != 0) 4527 warning (_("Remote refused setting permissions with: %s"), rs->buf); 4528} 4529 4530/* This type describes each known response to the qSupported 4531 packet. */ 4532struct protocol_feature 4533{ 4534 /* The name of this protocol feature. */ 4535 const char *name; 4536 4537 /* The default for this protocol feature. */ 4538 enum packet_support default_support; 4539 4540 /* The function to call when this feature is reported, or after 4541 qSupported processing if the feature is not supported. 4542 The first argument points to this structure. The second 4543 argument indicates whether the packet requested support be 4544 enabled, disabled, or probed (or the default, if this function 4545 is being called at the end of processing and this feature was 4546 not reported). The third argument may be NULL; if not NULL, it 4547 is a NUL-terminated string taken from the packet following 4548 this feature's name and an equals sign. */ 4549 void (*func) (const struct protocol_feature *, enum packet_support, 4550 const char *); 4551 4552 /* The corresponding packet for this feature. Only used if 4553 FUNC is remote_supported_packet. */ 4554 int packet; 4555}; 4556 4557static void 4558remote_supported_packet (const struct protocol_feature *feature, 4559 enum packet_support support, 4560 const char *argument) 4561{ 4562 if (argument) 4563 { 4564 warning (_("Remote qSupported response supplied an unexpected value for" 4565 " \"%s\"."), feature->name); 4566 return; 4567 } 4568 4569 remote_protocol_packets[feature->packet].support = support; 4570} 4571 4572static void 4573remote_packet_size (const struct protocol_feature *feature, 4574 enum packet_support support, const char *value) 4575{ 4576 struct remote_state *rs = get_remote_state (); 4577 4578 int packet_size; 4579 char *value_end; 4580 4581 if (support != PACKET_ENABLE) 4582 return; 4583 4584 if (value == NULL || *value == '\0') 4585 { 4586 warning (_("Remote target reported \"%s\" without a size."), 4587 feature->name); 4588 return; 4589 } 4590 4591 errno = 0; 4592 packet_size = strtol (value, &value_end, 16); 4593 if (errno != 0 || *value_end != '\0' || packet_size < 0) 4594 { 4595 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."), 4596 feature->name, value); 4597 return; 4598 } 4599 4600 /* Record the new maximum packet size. */ 4601 rs->explicit_packet_size = packet_size; 4602} 4603 4604static const struct protocol_feature remote_protocol_features[] = { 4605 { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 }, 4606 { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet, 4607 PACKET_qXfer_auxv }, 4608 { "qXfer:exec-file:read", PACKET_DISABLE, remote_supported_packet, 4609 PACKET_qXfer_exec_file }, 4610 { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet, 4611 PACKET_qXfer_features }, 4612 { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet, 4613 PACKET_qXfer_libraries }, 4614 { "qXfer:libraries-svr4:read", PACKET_DISABLE, remote_supported_packet, 4615 PACKET_qXfer_libraries_svr4 }, 4616 { "augmented-libraries-svr4-read", PACKET_DISABLE, 4617 remote_supported_packet, PACKET_augmented_libraries_svr4_read_feature }, 4618 { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet, 4619 PACKET_qXfer_memory_map }, 4620 { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet, 4621 PACKET_qXfer_spu_read }, 4622 { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet, 4623 PACKET_qXfer_spu_write }, 4624 { "qXfer:osdata:read", PACKET_DISABLE, remote_supported_packet, 4625 PACKET_qXfer_osdata }, 4626 { "qXfer:threads:read", PACKET_DISABLE, remote_supported_packet, 4627 PACKET_qXfer_threads }, 4628 { "qXfer:traceframe-info:read", PACKET_DISABLE, remote_supported_packet, 4629 PACKET_qXfer_traceframe_info }, 4630 { "QPassSignals", PACKET_DISABLE, remote_supported_packet, 4631 PACKET_QPassSignals }, 4632 { "QCatchSyscalls", PACKET_DISABLE, remote_supported_packet, 4633 PACKET_QCatchSyscalls }, 4634 { "QProgramSignals", PACKET_DISABLE, remote_supported_packet, 4635 PACKET_QProgramSignals }, 4636 { "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet, 4637 PACKET_QStartNoAckMode }, 4638 { "multiprocess", PACKET_DISABLE, remote_supported_packet, 4639 PACKET_multiprocess_feature }, 4640 { "QNonStop", PACKET_DISABLE, remote_supported_packet, PACKET_QNonStop }, 4641 { "qXfer:siginfo:read", PACKET_DISABLE, remote_supported_packet, 4642 PACKET_qXfer_siginfo_read }, 4643 { "qXfer:siginfo:write", PACKET_DISABLE, remote_supported_packet, 4644 PACKET_qXfer_siginfo_write }, 4645 { "ConditionalTracepoints", PACKET_DISABLE, remote_supported_packet, 4646 PACKET_ConditionalTracepoints }, 4647 { "ConditionalBreakpoints", PACKET_DISABLE, remote_supported_packet, 4648 PACKET_ConditionalBreakpoints }, 4649 { "BreakpointCommands", PACKET_DISABLE, remote_supported_packet, 4650 PACKET_BreakpointCommands }, 4651 { "FastTracepoints", PACKET_DISABLE, remote_supported_packet, 4652 PACKET_FastTracepoints }, 4653 { "StaticTracepoints", PACKET_DISABLE, remote_supported_packet, 4654 PACKET_StaticTracepoints }, 4655 {"InstallInTrace", PACKET_DISABLE, remote_supported_packet, 4656 PACKET_InstallInTrace}, 4657 { "DisconnectedTracing", PACKET_DISABLE, remote_supported_packet, 4658 PACKET_DisconnectedTracing_feature }, 4659 { "ReverseContinue", PACKET_DISABLE, remote_supported_packet, 4660 PACKET_bc }, 4661 { "ReverseStep", PACKET_DISABLE, remote_supported_packet, 4662 PACKET_bs }, 4663 { "TracepointSource", PACKET_DISABLE, remote_supported_packet, 4664 PACKET_TracepointSource }, 4665 { "QAllow", PACKET_DISABLE, remote_supported_packet, 4666 PACKET_QAllow }, 4667 { "EnableDisableTracepoints", PACKET_DISABLE, remote_supported_packet, 4668 PACKET_EnableDisableTracepoints_feature }, 4669 { "qXfer:fdpic:read", PACKET_DISABLE, remote_supported_packet, 4670 PACKET_qXfer_fdpic }, 4671 { "qXfer:uib:read", PACKET_DISABLE, remote_supported_packet, 4672 PACKET_qXfer_uib }, 4673 { "QDisableRandomization", PACKET_DISABLE, remote_supported_packet, 4674 PACKET_QDisableRandomization }, 4675 { "QAgent", PACKET_DISABLE, remote_supported_packet, PACKET_QAgent}, 4676 { "QTBuffer:size", PACKET_DISABLE, 4677 remote_supported_packet, PACKET_QTBuffer_size}, 4678 { "tracenz", PACKET_DISABLE, remote_supported_packet, PACKET_tracenz_feature }, 4679 { "Qbtrace:off", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_off }, 4680 { "Qbtrace:bts", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_bts }, 4681 { "Qbtrace:pt", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_pt }, 4682 { "qXfer:btrace:read", PACKET_DISABLE, remote_supported_packet, 4683 PACKET_qXfer_btrace }, 4684 { "qXfer:btrace-conf:read", PACKET_DISABLE, remote_supported_packet, 4685 PACKET_qXfer_btrace_conf }, 4686 { "Qbtrace-conf:bts:size", PACKET_DISABLE, remote_supported_packet, 4687 PACKET_Qbtrace_conf_bts_size }, 4688 { "swbreak", PACKET_DISABLE, remote_supported_packet, PACKET_swbreak_feature }, 4689 { "hwbreak", PACKET_DISABLE, remote_supported_packet, PACKET_hwbreak_feature }, 4690 { "fork-events", PACKET_DISABLE, remote_supported_packet, 4691 PACKET_fork_event_feature }, 4692 { "vfork-events", PACKET_DISABLE, remote_supported_packet, 4693 PACKET_vfork_event_feature }, 4694 { "exec-events", PACKET_DISABLE, remote_supported_packet, 4695 PACKET_exec_event_feature }, 4696 { "Qbtrace-conf:pt:size", PACKET_DISABLE, remote_supported_packet, 4697 PACKET_Qbtrace_conf_pt_size }, 4698 { "vContSupported", PACKET_DISABLE, remote_supported_packet, PACKET_vContSupported }, 4699 { "QThreadEvents", PACKET_DISABLE, remote_supported_packet, PACKET_QThreadEvents }, 4700 { "no-resumed", PACKET_DISABLE, remote_supported_packet, PACKET_no_resumed }, 4701}; 4702 4703static char *remote_support_xml; 4704 4705/* Register string appended to "xmlRegisters=" in qSupported query. */ 4706 4707void 4708register_remote_support_xml (const char *xml) 4709{ 4710#if defined(HAVE_LIBEXPAT) 4711 if (remote_support_xml == NULL) 4712 remote_support_xml = concat ("xmlRegisters=", xml, (char *) NULL); 4713 else 4714 { 4715 char *copy = xstrdup (remote_support_xml + 13); 4716 char *p = strtok (copy, ","); 4717 4718 do 4719 { 4720 if (strcmp (p, xml) == 0) 4721 { 4722 /* already there */ 4723 xfree (copy); 4724 return; 4725 } 4726 } 4727 while ((p = strtok (NULL, ",")) != NULL); 4728 xfree (copy); 4729 4730 remote_support_xml = reconcat (remote_support_xml, 4731 remote_support_xml, ",", xml, 4732 (char *) NULL); 4733 } 4734#endif 4735} 4736 4737static char * 4738remote_query_supported_append (char *msg, const char *append) 4739{ 4740 if (msg) 4741 return reconcat (msg, msg, ";", append, (char *) NULL); 4742 else 4743 return xstrdup (append); 4744} 4745 4746static void 4747remote_query_supported (void) 4748{ 4749 struct remote_state *rs = get_remote_state (); 4750 char *next; 4751 int i; 4752 unsigned char seen [ARRAY_SIZE (remote_protocol_features)]; 4753 4754 /* The packet support flags are handled differently for this packet 4755 than for most others. We treat an error, a disabled packet, and 4756 an empty response identically: any features which must be reported 4757 to be used will be automatically disabled. An empty buffer 4758 accomplishes this, since that is also the representation for a list 4759 containing no features. */ 4760 4761 rs->buf[0] = 0; 4762 if (packet_support (PACKET_qSupported) != PACKET_DISABLE) 4763 { 4764 char *q = NULL; 4765 struct cleanup *old_chain = make_cleanup (free_current_contents, &q); 4766 4767 if (packet_set_cmd_state (PACKET_multiprocess_feature) != AUTO_BOOLEAN_FALSE) 4768 q = remote_query_supported_append (q, "multiprocess+"); 4769 4770 if (packet_set_cmd_state (PACKET_swbreak_feature) != AUTO_BOOLEAN_FALSE) 4771 q = remote_query_supported_append (q, "swbreak+"); 4772 if (packet_set_cmd_state (PACKET_hwbreak_feature) != AUTO_BOOLEAN_FALSE) 4773 q = remote_query_supported_append (q, "hwbreak+"); 4774 4775 q = remote_query_supported_append (q, "qRelocInsn+"); 4776 4777 if (packet_set_cmd_state (PACKET_fork_event_feature) 4778 != AUTO_BOOLEAN_FALSE) 4779 q = remote_query_supported_append (q, "fork-events+"); 4780 if (packet_set_cmd_state (PACKET_vfork_event_feature) 4781 != AUTO_BOOLEAN_FALSE) 4782 q = remote_query_supported_append (q, "vfork-events+"); 4783 if (packet_set_cmd_state (PACKET_exec_event_feature) 4784 != AUTO_BOOLEAN_FALSE) 4785 q = remote_query_supported_append (q, "exec-events+"); 4786 4787 if (packet_set_cmd_state (PACKET_vContSupported) != AUTO_BOOLEAN_FALSE) 4788 q = remote_query_supported_append (q, "vContSupported+"); 4789 4790 if (packet_set_cmd_state (PACKET_QThreadEvents) != AUTO_BOOLEAN_FALSE) 4791 q = remote_query_supported_append (q, "QThreadEvents+"); 4792 4793 if (packet_set_cmd_state (PACKET_no_resumed) != AUTO_BOOLEAN_FALSE) 4794 q = remote_query_supported_append (q, "no-resumed+"); 4795 4796 /* Keep this one last to work around a gdbserver <= 7.10 bug in 4797 the qSupported:xmlRegisters=i386 handling. */ 4798 if (remote_support_xml != NULL) 4799 q = remote_query_supported_append (q, remote_support_xml); 4800 4801 q = reconcat (q, "qSupported:", q, (char *) NULL); 4802 putpkt (q); 4803 4804 do_cleanups (old_chain); 4805 4806 getpkt (&rs->buf, &rs->buf_size, 0); 4807 4808 /* If an error occured, warn, but do not return - just reset the 4809 buffer to empty and go on to disable features. */ 4810 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported]) 4811 == PACKET_ERROR) 4812 { 4813 warning (_("Remote failure reply: %s"), rs->buf); 4814 rs->buf[0] = 0; 4815 } 4816 } 4817 4818 memset (seen, 0, sizeof (seen)); 4819 4820 next = rs->buf; 4821 while (*next) 4822 { 4823 enum packet_support is_supported; 4824 char *p, *end, *name_end, *value; 4825 4826 /* First separate out this item from the rest of the packet. If 4827 there's another item after this, we overwrite the separator 4828 (terminated strings are much easier to work with). */ 4829 p = next; 4830 end = strchr (p, ';'); 4831 if (end == NULL) 4832 { 4833 end = p + strlen (p); 4834 next = end; 4835 } 4836 else 4837 { 4838 *end = '\0'; 4839 next = end + 1; 4840 4841 if (end == p) 4842 { 4843 warning (_("empty item in \"qSupported\" response")); 4844 continue; 4845 } 4846 } 4847 4848 name_end = strchr (p, '='); 4849 if (name_end) 4850 { 4851 /* This is a name=value entry. */ 4852 is_supported = PACKET_ENABLE; 4853 value = name_end + 1; 4854 *name_end = '\0'; 4855 } 4856 else 4857 { 4858 value = NULL; 4859 switch (end[-1]) 4860 { 4861 case '+': 4862 is_supported = PACKET_ENABLE; 4863 break; 4864 4865 case '-': 4866 is_supported = PACKET_DISABLE; 4867 break; 4868 4869 case '?': 4870 is_supported = PACKET_SUPPORT_UNKNOWN; 4871 break; 4872 4873 default: 4874 warning (_("unrecognized item \"%s\" " 4875 "in \"qSupported\" response"), p); 4876 continue; 4877 } 4878 end[-1] = '\0'; 4879 } 4880 4881 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++) 4882 if (strcmp (remote_protocol_features[i].name, p) == 0) 4883 { 4884 const struct protocol_feature *feature; 4885 4886 seen[i] = 1; 4887 feature = &remote_protocol_features[i]; 4888 feature->func (feature, is_supported, value); 4889 break; 4890 } 4891 } 4892 4893 /* If we increased the packet size, make sure to increase the global 4894 buffer size also. We delay this until after parsing the entire 4895 qSupported packet, because this is the same buffer we were 4896 parsing. */ 4897 if (rs->buf_size < rs->explicit_packet_size) 4898 { 4899 rs->buf_size = rs->explicit_packet_size; 4900 rs->buf = (char *) xrealloc (rs->buf, rs->buf_size); 4901 } 4902 4903 /* Handle the defaults for unmentioned features. */ 4904 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++) 4905 if (!seen[i]) 4906 { 4907 const struct protocol_feature *feature; 4908 4909 feature = &remote_protocol_features[i]; 4910 feature->func (feature, feature->default_support, NULL); 4911 } 4912} 4913 4914/* Serial QUIT handler for the remote serial descriptor. 4915 4916 Defers handling a Ctrl-C until we're done with the current 4917 command/response packet sequence, unless: 4918 4919 - We're setting up the connection. Don't send a remote interrupt 4920 request, as we're not fully synced yet. Quit immediately 4921 instead. 4922 4923 - The target has been resumed in the foreground 4924 (target_terminal_is_ours is false) with a synchronous resume 4925 packet, and we're blocked waiting for the stop reply, thus a 4926 Ctrl-C should be immediately sent to the target. 4927 4928 - We get a second Ctrl-C while still within the same serial read or 4929 write. In that case the serial is seemingly wedged --- offer to 4930 quit/disconnect. 4931 4932 - We see a second Ctrl-C without target response, after having 4933 previously interrupted the target. In that case the target/stub 4934 is probably wedged --- offer to quit/disconnect. 4935*/ 4936 4937static void 4938remote_serial_quit_handler (void) 4939{ 4940 struct remote_state *rs = get_remote_state (); 4941 4942 if (check_quit_flag ()) 4943 { 4944 /* If we're starting up, we're not fully synced yet. Quit 4945 immediately. */ 4946 if (rs->starting_up) 4947 quit (); 4948 else if (rs->got_ctrlc_during_io) 4949 { 4950 if (query (_("The target is not responding to GDB commands.\n" 4951 "Stop debugging it? "))) 4952 remote_unpush_and_throw (); 4953 } 4954 /* If ^C has already been sent once, offer to disconnect. */ 4955 else if (!target_terminal_is_ours () && rs->ctrlc_pending_p) 4956 interrupt_query (); 4957 /* All-stop protocol, and blocked waiting for stop reply. Send 4958 an interrupt request. */ 4959 else if (!target_terminal_is_ours () && rs->waiting_for_stop_reply) 4960 target_interrupt (inferior_ptid); 4961 else 4962 rs->got_ctrlc_during_io = 1; 4963 } 4964} 4965 4966/* Remove any of the remote.c targets from target stack. Upper targets depend 4967 on it so remove them first. */ 4968 4969static void 4970remote_unpush_target (void) 4971{ 4972 pop_all_targets_at_and_above (process_stratum); 4973} 4974 4975static void 4976remote_unpush_and_throw (void) 4977{ 4978 remote_unpush_target (); 4979 throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target.")); 4980} 4981 4982static void 4983remote_open_1 (const char *name, int from_tty, 4984 struct target_ops *target, int extended_p) 4985{ 4986 struct remote_state *rs = get_remote_state (); 4987 4988 if (name == 0) 4989 error (_("To open a remote debug connection, you need to specify what\n" 4990 "serial device is attached to the remote system\n" 4991 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).")); 4992 4993 /* See FIXME above. */ 4994 if (!target_async_permitted) 4995 wait_forever_enabled_p = 1; 4996 4997 /* If we're connected to a running target, target_preopen will kill it. 4998 Ask this question first, before target_preopen has a chance to kill 4999 anything. */ 5000 if (rs->remote_desc != NULL && !have_inferiors ()) 5001 { 5002 if (from_tty 5003 && !query (_("Already connected to a remote target. Disconnect? "))) 5004 error (_("Still connected.")); 5005 } 5006 5007 /* Here the possibly existing remote target gets unpushed. */ 5008 target_preopen (from_tty); 5009 5010 /* Make sure we send the passed signals list the next time we resume. */ 5011 xfree (rs->last_pass_packet); 5012 rs->last_pass_packet = NULL; 5013 5014 /* Make sure we send the program signals list the next time we 5015 resume. */ 5016 xfree (rs->last_program_signals_packet); 5017 rs->last_program_signals_packet = NULL; 5018 5019 remote_fileio_reset (); 5020 reopen_exec_file (); 5021 reread_symbols (); 5022 5023 rs->remote_desc = remote_serial_open (name); 5024 if (!rs->remote_desc) 5025 perror_with_name (name); 5026 5027 if (baud_rate != -1) 5028 { 5029 if (serial_setbaudrate (rs->remote_desc, baud_rate)) 5030 { 5031 /* The requested speed could not be set. Error out to 5032 top level after closing remote_desc. Take care to 5033 set remote_desc to NULL to avoid closing remote_desc 5034 more than once. */ 5035 serial_close (rs->remote_desc); 5036 rs->remote_desc = NULL; 5037 perror_with_name (name); 5038 } 5039 } 5040 5041 serial_setparity (rs->remote_desc, serial_parity); 5042 serial_raw (rs->remote_desc); 5043 5044 /* If there is something sitting in the buffer we might take it as a 5045 response to a command, which would be bad. */ 5046 serial_flush_input (rs->remote_desc); 5047 5048 if (from_tty) 5049 { 5050 puts_filtered ("Remote debugging using "); 5051 puts_filtered (name); 5052 puts_filtered ("\n"); 5053 } 5054 push_target (target); /* Switch to using remote target now. */ 5055 5056 /* Register extra event sources in the event loop. */ 5057 remote_async_inferior_event_token 5058 = create_async_event_handler (remote_async_inferior_event_handler, 5059 NULL); 5060 rs->notif_state = remote_notif_state_allocate (); 5061 5062 /* Reset the target state; these things will be queried either by 5063 remote_query_supported or as they are needed. */ 5064 reset_all_packet_configs_support (); 5065 rs->cached_wait_status = 0; 5066 rs->explicit_packet_size = 0; 5067 rs->noack_mode = 0; 5068 rs->extended = extended_p; 5069 rs->waiting_for_stop_reply = 0; 5070 rs->ctrlc_pending_p = 0; 5071 rs->got_ctrlc_during_io = 0; 5072 5073 rs->general_thread = not_sent_ptid; 5074 rs->continue_thread = not_sent_ptid; 5075 rs->remote_traceframe_number = -1; 5076 5077 rs->last_resume_exec_dir = EXEC_FORWARD; 5078 5079 /* Probe for ability to use "ThreadInfo" query, as required. */ 5080 rs->use_threadinfo_query = 1; 5081 rs->use_threadextra_query = 1; 5082 5083 readahead_cache_invalidate (); 5084 5085 /* Start out by owning the terminal. */ 5086 remote_async_terminal_ours_p = 1; 5087 5088 if (target_async_permitted) 5089 { 5090 /* FIXME: cagney/1999-09-23: During the initial connection it is 5091 assumed that the target is already ready and able to respond to 5092 requests. Unfortunately remote_start_remote() eventually calls 5093 wait_for_inferior() with no timeout. wait_forever_enabled_p gets 5094 around this. Eventually a mechanism that allows 5095 wait_for_inferior() to expect/get timeouts will be 5096 implemented. */ 5097 wait_forever_enabled_p = 0; 5098 } 5099 5100 /* First delete any symbols previously loaded from shared libraries. */ 5101 no_shared_libraries (NULL, 0); 5102 5103 /* Start afresh. */ 5104 init_thread_list (); 5105 5106 /* Start the remote connection. If error() or QUIT, discard this 5107 target (we'd otherwise be in an inconsistent state) and then 5108 propogate the error on up the exception chain. This ensures that 5109 the caller doesn't stumble along blindly assuming that the 5110 function succeeded. The CLI doesn't have this problem but other 5111 UI's, such as MI do. 5112 5113 FIXME: cagney/2002-05-19: Instead of re-throwing the exception, 5114 this function should return an error indication letting the 5115 caller restore the previous state. Unfortunately the command 5116 ``target remote'' is directly wired to this function making that 5117 impossible. On a positive note, the CLI side of this problem has 5118 been fixed - the function set_cmd_context() makes it possible for 5119 all the ``target ....'' commands to share a common callback 5120 function. See cli-dump.c. */ 5121 { 5122 5123 TRY 5124 { 5125 remote_start_remote (from_tty, target, extended_p); 5126 } 5127 CATCH (ex, RETURN_MASK_ALL) 5128 { 5129 /* Pop the partially set up target - unless something else did 5130 already before throwing the exception. */ 5131 if (rs->remote_desc != NULL) 5132 remote_unpush_target (); 5133 if (target_async_permitted) 5134 wait_forever_enabled_p = 1; 5135 throw_exception (ex); 5136 } 5137 END_CATCH 5138 } 5139 5140 remote_btrace_reset (); 5141 5142 if (target_async_permitted) 5143 wait_forever_enabled_p = 1; 5144} 5145 5146/* Detach the specified process. */ 5147 5148static void 5149remote_detach_pid (int pid) 5150{ 5151 struct remote_state *rs = get_remote_state (); 5152 5153 if (remote_multi_process_p (rs)) 5154 xsnprintf (rs->buf, get_remote_packet_size (), "D;%x", pid); 5155 else 5156 strcpy (rs->buf, "D"); 5157 5158 putpkt (rs->buf); 5159 getpkt (&rs->buf, &rs->buf_size, 0); 5160 5161 if (rs->buf[0] == 'O' && rs->buf[1] == 'K') 5162 ; 5163 else if (rs->buf[0] == '\0') 5164 error (_("Remote doesn't know how to detach")); 5165 else 5166 error (_("Can't detach process.")); 5167} 5168 5169/* This detaches a program to which we previously attached, using 5170 inferior_ptid to identify the process. After this is done, GDB 5171 can be used to debug some other program. We better not have left 5172 any breakpoints in the target program or it'll die when it hits 5173 one. */ 5174 5175static void 5176remote_detach_1 (const char *args, int from_tty) 5177{ 5178 int pid = ptid_get_pid (inferior_ptid); 5179 struct remote_state *rs = get_remote_state (); 5180 struct thread_info *tp = find_thread_ptid (inferior_ptid); 5181 int is_fork_parent; 5182 5183 if (args) 5184 error (_("Argument given to \"detach\" when remotely debugging.")); 5185 5186 if (!target_has_execution) 5187 error (_("No process to detach from.")); 5188 5189 target_announce_detach (from_tty); 5190 5191 /* Tell the remote target to detach. */ 5192 remote_detach_pid (pid); 5193 5194 /* Exit only if this is the only active inferior. */ 5195 if (from_tty && !rs->extended && number_of_live_inferiors () == 1) 5196 puts_filtered (_("Ending remote debugging.\n")); 5197 5198 /* Check to see if we are detaching a fork parent. Note that if we 5199 are detaching a fork child, tp == NULL. */ 5200 is_fork_parent = (tp != NULL 5201 && tp->pending_follow.kind == TARGET_WAITKIND_FORKED); 5202 5203 /* If doing detach-on-fork, we don't mourn, because that will delete 5204 breakpoints that should be available for the followed inferior. */ 5205 if (!is_fork_parent) 5206 target_mourn_inferior (inferior_ptid); 5207 else 5208 { 5209 inferior_ptid = null_ptid; 5210 detach_inferior (pid); 5211 } 5212} 5213 5214static void 5215remote_detach (struct target_ops *ops, const char *args, int from_tty) 5216{ 5217 remote_detach_1 (args, from_tty); 5218} 5219 5220static void 5221extended_remote_detach (struct target_ops *ops, const char *args, int from_tty) 5222{ 5223 remote_detach_1 (args, from_tty); 5224} 5225 5226/* Target follow-fork function for remote targets. On entry, and 5227 at return, the current inferior is the fork parent. 5228 5229 Note that although this is currently only used for extended-remote, 5230 it is named remote_follow_fork in anticipation of using it for the 5231 remote target as well. */ 5232 5233static int 5234remote_follow_fork (struct target_ops *ops, int follow_child, 5235 int detach_fork) 5236{ 5237 struct remote_state *rs = get_remote_state (); 5238 enum target_waitkind kind = inferior_thread ()->pending_follow.kind; 5239 5240 if ((kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs)) 5241 || (kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs))) 5242 { 5243 /* When following the parent and detaching the child, we detach 5244 the child here. For the case of following the child and 5245 detaching the parent, the detach is done in the target- 5246 independent follow fork code in infrun.c. We can't use 5247 target_detach when detaching an unfollowed child because 5248 the client side doesn't know anything about the child. */ 5249 if (detach_fork && !follow_child) 5250 { 5251 /* Detach the fork child. */ 5252 ptid_t child_ptid; 5253 pid_t child_pid; 5254 5255 child_ptid = inferior_thread ()->pending_follow.value.related_pid; 5256 child_pid = ptid_get_pid (child_ptid); 5257 5258 remote_detach_pid (child_pid); 5259 detach_inferior (child_pid); 5260 } 5261 } 5262 return 0; 5263} 5264 5265/* Target follow-exec function for remote targets. Save EXECD_PATHNAME 5266 in the program space of the new inferior. On entry and at return the 5267 current inferior is the exec'ing inferior. INF is the new exec'd 5268 inferior, which may be the same as the exec'ing inferior unless 5269 follow-exec-mode is "new". */ 5270 5271static void 5272remote_follow_exec (struct target_ops *ops, 5273 struct inferior *inf, char *execd_pathname) 5274{ 5275 /* We know that this is a target file name, so if it has the "target:" 5276 prefix we strip it off before saving it in the program space. */ 5277 if (is_target_filename (execd_pathname)) 5278 execd_pathname += strlen (TARGET_SYSROOT_PREFIX); 5279 5280 set_pspace_remote_exec_file (inf->pspace, execd_pathname); 5281} 5282 5283/* Same as remote_detach, but don't send the "D" packet; just disconnect. */ 5284 5285static void 5286remote_disconnect (struct target_ops *target, const char *args, int from_tty) 5287{ 5288 if (args) 5289 error (_("Argument given to \"disconnect\" when remotely debugging.")); 5290 5291 /* Make sure we unpush even the extended remote targets. Calling 5292 target_mourn_inferior won't unpush, and remote_mourn won't 5293 unpush if there is more than one inferior left. */ 5294 unpush_target (target); 5295 generic_mourn_inferior (); 5296 5297 if (from_tty) 5298 puts_filtered ("Ending remote debugging.\n"); 5299} 5300 5301/* Attach to the process specified by ARGS. If FROM_TTY is non-zero, 5302 be chatty about it. */ 5303 5304static void 5305extended_remote_attach (struct target_ops *target, const char *args, 5306 int from_tty) 5307{ 5308 struct remote_state *rs = get_remote_state (); 5309 int pid; 5310 char *wait_status = NULL; 5311 5312 pid = parse_pid_to_attach (args); 5313 5314 /* Remote PID can be freely equal to getpid, do not check it here the same 5315 way as in other targets. */ 5316 5317 if (packet_support (PACKET_vAttach) == PACKET_DISABLE) 5318 error (_("This target does not support attaching to a process")); 5319 5320 if (from_tty) 5321 { 5322 char *exec_file = get_exec_file (0); 5323 5324 if (exec_file) 5325 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file, 5326 target_pid_to_str (pid_to_ptid (pid))); 5327 else 5328 printf_unfiltered (_("Attaching to %s\n"), 5329 target_pid_to_str (pid_to_ptid (pid))); 5330 5331 gdb_flush (gdb_stdout); 5332 } 5333 5334 xsnprintf (rs->buf, get_remote_packet_size (), "vAttach;%x", pid); 5335 putpkt (rs->buf); 5336 getpkt (&rs->buf, &rs->buf_size, 0); 5337 5338 switch (packet_ok (rs->buf, 5339 &remote_protocol_packets[PACKET_vAttach])) 5340 { 5341 case PACKET_OK: 5342 if (!target_is_non_stop_p ()) 5343 { 5344 /* Save the reply for later. */ 5345 wait_status = (char *) alloca (strlen (rs->buf) + 1); 5346 strcpy (wait_status, rs->buf); 5347 } 5348 else if (strcmp (rs->buf, "OK") != 0) 5349 error (_("Attaching to %s failed with: %s"), 5350 target_pid_to_str (pid_to_ptid (pid)), 5351 rs->buf); 5352 break; 5353 case PACKET_UNKNOWN: 5354 error (_("This target does not support attaching to a process")); 5355 default: 5356 error (_("Attaching to %s failed"), 5357 target_pid_to_str (pid_to_ptid (pid))); 5358 } 5359 5360 set_current_inferior (remote_add_inferior (0, pid, 1, 0)); 5361 5362 inferior_ptid = pid_to_ptid (pid); 5363 5364 if (target_is_non_stop_p ()) 5365 { 5366 struct thread_info *thread; 5367 5368 /* Get list of threads. */ 5369 remote_update_thread_list (target); 5370 5371 thread = first_thread_of_process (pid); 5372 if (thread) 5373 inferior_ptid = thread->ptid; 5374 else 5375 inferior_ptid = pid_to_ptid (pid); 5376 5377 /* Invalidate our notion of the remote current thread. */ 5378 record_currthread (rs, minus_one_ptid); 5379 } 5380 else 5381 { 5382 /* Now, if we have thread information, update inferior_ptid. */ 5383 inferior_ptid = remote_current_thread (inferior_ptid); 5384 5385 /* Add the main thread to the thread list. */ 5386 add_thread_silent (inferior_ptid); 5387 } 5388 5389 /* Next, if the target can specify a description, read it. We do 5390 this before anything involving memory or registers. */ 5391 target_find_description (); 5392 5393 if (!target_is_non_stop_p ()) 5394 { 5395 /* Use the previously fetched status. */ 5396 gdb_assert (wait_status != NULL); 5397 5398 if (target_can_async_p ()) 5399 { 5400 struct notif_event *reply 5401 = remote_notif_parse (¬if_client_stop, wait_status); 5402 5403 push_stop_reply ((struct stop_reply *) reply); 5404 5405 target_async (1); 5406 } 5407 else 5408 { 5409 gdb_assert (wait_status != NULL); 5410 strcpy (rs->buf, wait_status); 5411 rs->cached_wait_status = 1; 5412 } 5413 } 5414 else 5415 gdb_assert (wait_status == NULL); 5416} 5417 5418/* Implementation of the to_post_attach method. */ 5419 5420static void 5421extended_remote_post_attach (struct target_ops *ops, int pid) 5422{ 5423 /* Get text, data & bss offsets. */ 5424 get_offsets (); 5425 5426 /* In certain cases GDB might not have had the chance to start 5427 symbol lookup up until now. This could happen if the debugged 5428 binary is not using shared libraries, the vsyscall page is not 5429 present (on Linux) and the binary itself hadn't changed since the 5430 debugging process was started. */ 5431 if (symfile_objfile != NULL) 5432 remote_check_symbols(); 5433} 5434 5435 5436/* Check for the availability of vCont. This function should also check 5437 the response. */ 5438 5439static void 5440remote_vcont_probe (struct remote_state *rs) 5441{ 5442 char *buf; 5443 5444 strcpy (rs->buf, "vCont?"); 5445 putpkt (rs->buf); 5446 getpkt (&rs->buf, &rs->buf_size, 0); 5447 buf = rs->buf; 5448 5449 /* Make sure that the features we assume are supported. */ 5450 if (startswith (buf, "vCont")) 5451 { 5452 char *p = &buf[5]; 5453 int support_c, support_C; 5454 5455 rs->supports_vCont.s = 0; 5456 rs->supports_vCont.S = 0; 5457 support_c = 0; 5458 support_C = 0; 5459 rs->supports_vCont.t = 0; 5460 rs->supports_vCont.r = 0; 5461 while (p && *p == ';') 5462 { 5463 p++; 5464 if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0)) 5465 rs->supports_vCont.s = 1; 5466 else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0)) 5467 rs->supports_vCont.S = 1; 5468 else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0)) 5469 support_c = 1; 5470 else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0)) 5471 support_C = 1; 5472 else if (*p == 't' && (*(p + 1) == ';' || *(p + 1) == 0)) 5473 rs->supports_vCont.t = 1; 5474 else if (*p == 'r' && (*(p + 1) == ';' || *(p + 1) == 0)) 5475 rs->supports_vCont.r = 1; 5476 5477 p = strchr (p, ';'); 5478 } 5479 5480 /* If c, and C are not all supported, we can't use vCont. Clearing 5481 BUF will make packet_ok disable the packet. */ 5482 if (!support_c || !support_C) 5483 buf[0] = 0; 5484 } 5485 5486 packet_ok (buf, &remote_protocol_packets[PACKET_vCont]); 5487} 5488 5489/* Helper function for building "vCont" resumptions. Write a 5490 resumption to P. ENDP points to one-passed-the-end of the buffer 5491 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The 5492 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the 5493 resumed thread should be single-stepped and/or signalled. If PTID 5494 equals minus_one_ptid, then all threads are resumed; if PTID 5495 represents a process, then all threads of the process are resumed; 5496 the thread to be stepped and/or signalled is given in the global 5497 INFERIOR_PTID. */ 5498 5499static char * 5500append_resumption (char *p, char *endp, 5501 ptid_t ptid, int step, enum gdb_signal siggnal) 5502{ 5503 struct remote_state *rs = get_remote_state (); 5504 5505 if (step && siggnal != GDB_SIGNAL_0) 5506 p += xsnprintf (p, endp - p, ";S%02x", siggnal); 5507 else if (step 5508 /* GDB is willing to range step. */ 5509 && use_range_stepping 5510 /* Target supports range stepping. */ 5511 && rs->supports_vCont.r 5512 /* We don't currently support range stepping multiple 5513 threads with a wildcard (though the protocol allows it, 5514 so stubs shouldn't make an active effort to forbid 5515 it). */ 5516 && !(remote_multi_process_p (rs) && ptid_is_pid (ptid))) 5517 { 5518 struct thread_info *tp; 5519 5520 if (ptid_equal (ptid, minus_one_ptid)) 5521 { 5522 /* If we don't know about the target thread's tid, then 5523 we're resuming magic_null_ptid (see caller). */ 5524 tp = find_thread_ptid (magic_null_ptid); 5525 } 5526 else 5527 tp = find_thread_ptid (ptid); 5528 gdb_assert (tp != NULL); 5529 5530 if (tp->control.may_range_step) 5531 { 5532 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; 5533 5534 p += xsnprintf (p, endp - p, ";r%s,%s", 5535 phex_nz (tp->control.step_range_start, 5536 addr_size), 5537 phex_nz (tp->control.step_range_end, 5538 addr_size)); 5539 } 5540 else 5541 p += xsnprintf (p, endp - p, ";s"); 5542 } 5543 else if (step) 5544 p += xsnprintf (p, endp - p, ";s"); 5545 else if (siggnal != GDB_SIGNAL_0) 5546 p += xsnprintf (p, endp - p, ";C%02x", siggnal); 5547 else 5548 p += xsnprintf (p, endp - p, ";c"); 5549 5550 if (remote_multi_process_p (rs) && ptid_is_pid (ptid)) 5551 { 5552 ptid_t nptid; 5553 5554 /* All (-1) threads of process. */ 5555 nptid = ptid_build (ptid_get_pid (ptid), -1, 0); 5556 5557 p += xsnprintf (p, endp - p, ":"); 5558 p = write_ptid (p, endp, nptid); 5559 } 5560 else if (!ptid_equal (ptid, minus_one_ptid)) 5561 { 5562 p += xsnprintf (p, endp - p, ":"); 5563 p = write_ptid (p, endp, ptid); 5564 } 5565 5566 return p; 5567} 5568 5569/* Clear the thread's private info on resume. */ 5570 5571static void 5572resume_clear_thread_private_info (struct thread_info *thread) 5573{ 5574 if (thread->priv != NULL) 5575 { 5576 thread->priv->stop_reason = TARGET_STOPPED_BY_NO_REASON; 5577 thread->priv->watch_data_address = 0; 5578 } 5579} 5580 5581/* Append a vCont continue-with-signal action for threads that have a 5582 non-zero stop signal. */ 5583 5584static char * 5585append_pending_thread_resumptions (char *p, char *endp, ptid_t ptid) 5586{ 5587 struct thread_info *thread; 5588 5589 ALL_NON_EXITED_THREADS (thread) 5590 if (ptid_match (thread->ptid, ptid) 5591 && !ptid_equal (inferior_ptid, thread->ptid) 5592 && thread->suspend.stop_signal != GDB_SIGNAL_0) 5593 { 5594 p = append_resumption (p, endp, thread->ptid, 5595 0, thread->suspend.stop_signal); 5596 thread->suspend.stop_signal = GDB_SIGNAL_0; 5597 resume_clear_thread_private_info (thread); 5598 } 5599 5600 return p; 5601} 5602 5603/* Set the target running, using the packets that use Hc 5604 (c/s/C/S). */ 5605 5606static void 5607remote_resume_with_hc (struct target_ops *ops, 5608 ptid_t ptid, int step, enum gdb_signal siggnal) 5609{ 5610 struct remote_state *rs = get_remote_state (); 5611 struct thread_info *thread; 5612 char *buf; 5613 5614 rs->last_sent_signal = siggnal; 5615 rs->last_sent_step = step; 5616 5617 /* The c/s/C/S resume packets use Hc, so set the continue 5618 thread. */ 5619 if (ptid_equal (ptid, minus_one_ptid)) 5620 set_continue_thread (any_thread_ptid); 5621 else 5622 set_continue_thread (ptid); 5623 5624 ALL_NON_EXITED_THREADS (thread) 5625 resume_clear_thread_private_info (thread); 5626 5627 buf = rs->buf; 5628 if (execution_direction == EXEC_REVERSE) 5629 { 5630 /* We don't pass signals to the target in reverse exec mode. */ 5631 if (info_verbose && siggnal != GDB_SIGNAL_0) 5632 warning (_(" - Can't pass signal %d to target in reverse: ignored."), 5633 siggnal); 5634 5635 if (step && packet_support (PACKET_bs) == PACKET_DISABLE) 5636 error (_("Remote reverse-step not supported.")); 5637 if (!step && packet_support (PACKET_bc) == PACKET_DISABLE) 5638 error (_("Remote reverse-continue not supported.")); 5639 5640 strcpy (buf, step ? "bs" : "bc"); 5641 } 5642 else if (siggnal != GDB_SIGNAL_0) 5643 { 5644 buf[0] = step ? 'S' : 'C'; 5645 buf[1] = tohex (((int) siggnal >> 4) & 0xf); 5646 buf[2] = tohex (((int) siggnal) & 0xf); 5647 buf[3] = '\0'; 5648 } 5649 else 5650 strcpy (buf, step ? "s" : "c"); 5651 5652 putpkt (buf); 5653} 5654 5655/* Resume the remote inferior by using a "vCont" packet. The thread 5656 to be resumed is PTID; STEP and SIGGNAL indicate whether the 5657 resumed thread should be single-stepped and/or signalled. If PTID 5658 equals minus_one_ptid, then all threads are resumed; the thread to 5659 be stepped and/or signalled is given in the global INFERIOR_PTID. 5660 This function returns non-zero iff it resumes the inferior. 5661 5662 This function issues a strict subset of all possible vCont commands 5663 at the moment. */ 5664 5665static int 5666remote_resume_with_vcont (ptid_t ptid, int step, enum gdb_signal siggnal) 5667{ 5668 struct remote_state *rs = get_remote_state (); 5669 char *p; 5670 char *endp; 5671 5672 /* No reverse execution actions defined for vCont. */ 5673 if (execution_direction == EXEC_REVERSE) 5674 return 0; 5675 5676 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN) 5677 remote_vcont_probe (rs); 5678 5679 if (packet_support (PACKET_vCont) == PACKET_DISABLE) 5680 return 0; 5681 5682 p = rs->buf; 5683 endp = rs->buf + get_remote_packet_size (); 5684 5685 /* If we could generate a wider range of packets, we'd have to worry 5686 about overflowing BUF. Should there be a generic 5687 "multi-part-packet" packet? */ 5688 5689 p += xsnprintf (p, endp - p, "vCont"); 5690 5691 if (ptid_equal (ptid, magic_null_ptid)) 5692 { 5693 /* MAGIC_NULL_PTID means that we don't have any active threads, 5694 so we don't have any TID numbers the inferior will 5695 understand. Make sure to only send forms that do not specify 5696 a TID. */ 5697 append_resumption (p, endp, minus_one_ptid, step, siggnal); 5698 } 5699 else if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid)) 5700 { 5701 /* Resume all threads (of all processes, or of a single 5702 process), with preference for INFERIOR_PTID. This assumes 5703 inferior_ptid belongs to the set of all threads we are about 5704 to resume. */ 5705 if (step || siggnal != GDB_SIGNAL_0) 5706 { 5707 /* Step inferior_ptid, with or without signal. */ 5708 p = append_resumption (p, endp, inferior_ptid, step, siggnal); 5709 } 5710 5711 /* Also pass down any pending signaled resumption for other 5712 threads not the current. */ 5713 p = append_pending_thread_resumptions (p, endp, ptid); 5714 5715 /* And continue others without a signal. */ 5716 append_resumption (p, endp, ptid, /*step=*/ 0, GDB_SIGNAL_0); 5717 } 5718 else 5719 { 5720 /* Scheduler locking; resume only PTID. */ 5721 append_resumption (p, endp, ptid, step, siggnal); 5722 } 5723 5724 gdb_assert (strlen (rs->buf) < get_remote_packet_size ()); 5725 putpkt (rs->buf); 5726 5727 if (target_is_non_stop_p ()) 5728 { 5729 /* In non-stop, the stub replies to vCont with "OK". The stop 5730 reply will be reported asynchronously by means of a `%Stop' 5731 notification. */ 5732 getpkt (&rs->buf, &rs->buf_size, 0); 5733 if (strcmp (rs->buf, "OK") != 0) 5734 error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf); 5735 } 5736 5737 return 1; 5738} 5739 5740/* Tell the remote machine to resume. */ 5741 5742static void 5743remote_resume (struct target_ops *ops, 5744 ptid_t ptid, int step, enum gdb_signal siggnal) 5745{ 5746 struct remote_state *rs = get_remote_state (); 5747 5748 /* When connected in non-stop mode, the core resumes threads 5749 individually. Resuming remote threads directly in target_resume 5750 would thus result in sending one packet per thread. Instead, to 5751 minimize roundtrip latency, here we just store the resume 5752 request; the actual remote resumption will be done in 5753 target_commit_resume / remote_commit_resume, where we'll be able 5754 to do vCont action coalescing. */ 5755 if (target_is_non_stop_p () && execution_direction != EXEC_REVERSE) 5756 { 5757 struct private_thread_info *remote_thr; 5758 5759 if (ptid_equal (minus_one_ptid, ptid) || ptid_is_pid (ptid)) 5760 remote_thr = get_private_info_ptid (inferior_ptid); 5761 else 5762 remote_thr = get_private_info_ptid (ptid); 5763 remote_thr->last_resume_step = step; 5764 remote_thr->last_resume_sig = siggnal; 5765 return; 5766 } 5767 5768 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN 5769 (explained in remote-notif.c:handle_notification) so 5770 remote_notif_process is not called. We need find a place where 5771 it is safe to start a 'vNotif' sequence. It is good to do it 5772 before resuming inferior, because inferior was stopped and no RSP 5773 traffic at that moment. */ 5774 if (!target_is_non_stop_p ()) 5775 remote_notif_process (rs->notif_state, ¬if_client_stop); 5776 5777 rs->last_resume_exec_dir = execution_direction; 5778 5779 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */ 5780 if (!remote_resume_with_vcont (ptid, step, siggnal)) 5781 remote_resume_with_hc (ops, ptid, step, siggnal); 5782 5783 /* We are about to start executing the inferior, let's register it 5784 with the event loop. NOTE: this is the one place where all the 5785 execution commands end up. We could alternatively do this in each 5786 of the execution commands in infcmd.c. */ 5787 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here 5788 into infcmd.c in order to allow inferior function calls to work 5789 NOT asynchronously. */ 5790 if (target_can_async_p ()) 5791 target_async (1); 5792 5793 /* We've just told the target to resume. The remote server will 5794 wait for the inferior to stop, and then send a stop reply. In 5795 the mean time, we can't start another command/query ourselves 5796 because the stub wouldn't be ready to process it. This applies 5797 only to the base all-stop protocol, however. In non-stop (which 5798 only supports vCont), the stub replies with an "OK", and is 5799 immediate able to process further serial input. */ 5800 if (!target_is_non_stop_p ()) 5801 rs->waiting_for_stop_reply = 1; 5802} 5803 5804static void check_pending_events_prevent_wildcard_vcont 5805 (int *may_global_wildcard_vcont); 5806static int is_pending_fork_parent_thread (struct thread_info *thread); 5807 5808/* Private per-inferior info for target remote processes. */ 5809 5810struct private_inferior 5811{ 5812 /* Whether we can send a wildcard vCont for this process. */ 5813 int may_wildcard_vcont; 5814}; 5815 5816/* Structure used to track the construction of a vCont packet in the 5817 outgoing packet buffer. This is used to send multiple vCont 5818 packets if we have more actions than would fit a single packet. */ 5819 5820struct vcont_builder 5821{ 5822 /* Pointer to the first action. P points here if no action has been 5823 appended yet. */ 5824 char *first_action; 5825 5826 /* Where the next action will be appended. */ 5827 char *p; 5828 5829 /* The end of the buffer. Must never write past this. */ 5830 char *endp; 5831}; 5832 5833/* Prepare the outgoing buffer for a new vCont packet. */ 5834 5835static void 5836vcont_builder_restart (struct vcont_builder *builder) 5837{ 5838 struct remote_state *rs = get_remote_state (); 5839 5840 builder->p = rs->buf; 5841 builder->endp = rs->buf + get_remote_packet_size (); 5842 builder->p += xsnprintf (builder->p, builder->endp - builder->p, "vCont"); 5843 builder->first_action = builder->p; 5844} 5845 5846/* If the vCont packet being built has any action, send it to the 5847 remote end. */ 5848 5849static void 5850vcont_builder_flush (struct vcont_builder *builder) 5851{ 5852 struct remote_state *rs; 5853 5854 if (builder->p == builder->first_action) 5855 return; 5856 5857 rs = get_remote_state (); 5858 putpkt (rs->buf); 5859 getpkt (&rs->buf, &rs->buf_size, 0); 5860 if (strcmp (rs->buf, "OK") != 0) 5861 error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf); 5862} 5863 5864/* The largest action is range-stepping, with its two addresses. This 5865 is more than sufficient. If a new, bigger action is created, it'll 5866 quickly trigger a failed assertion in append_resumption (and we'll 5867 just bump this). */ 5868#define MAX_ACTION_SIZE 200 5869 5870/* Append a new vCont action in the outgoing packet being built. If 5871 the action doesn't fit the packet along with previous actions, push 5872 what we've got so far to the remote end and start over a new vCont 5873 packet (with the new action). */ 5874 5875static void 5876vcont_builder_push_action (struct vcont_builder *builder, 5877 ptid_t ptid, int step, enum gdb_signal siggnal) 5878{ 5879 char buf[MAX_ACTION_SIZE + 1]; 5880 char *endp; 5881 size_t rsize; 5882 5883 endp = append_resumption (buf, buf + sizeof (buf), 5884 ptid, step, siggnal); 5885 5886 /* Check whether this new action would fit in the vCont packet along 5887 with previous actions. If not, send what we've got so far and 5888 start a new vCont packet. */ 5889 rsize = endp - buf; 5890 if (rsize > builder->endp - builder->p) 5891 { 5892 vcont_builder_flush (builder); 5893 vcont_builder_restart (builder); 5894 5895 /* Should now fit. */ 5896 gdb_assert (rsize <= builder->endp - builder->p); 5897 } 5898 5899 memcpy (builder->p, buf, rsize); 5900 builder->p += rsize; 5901 *builder->p = '\0'; 5902} 5903 5904/* to_commit_resume implementation. */ 5905 5906static void 5907remote_commit_resume (struct target_ops *ops) 5908{ 5909 struct remote_state *rs = get_remote_state (); 5910 struct inferior *inf; 5911 struct thread_info *tp; 5912 int any_process_wildcard; 5913 int may_global_wildcard_vcont; 5914 struct vcont_builder vcont_builder; 5915 5916 /* If connected in all-stop mode, we'd send the remote resume 5917 request directly from remote_resume. Likewise if 5918 reverse-debugging, as there are no defined vCont actions for 5919 reverse execution. */ 5920 if (!target_is_non_stop_p () || execution_direction == EXEC_REVERSE) 5921 return; 5922 5923 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1") 5924 instead of resuming all threads of each process individually. 5925 However, if any thread of a process must remain halted, we can't 5926 send wildcard resumes and must send one action per thread. 5927 5928 Care must be taken to not resume threads/processes the server 5929 side already told us are stopped, but the core doesn't know about 5930 yet, because the events are still in the vStopped notification 5931 queue. For example: 5932 5933 #1 => vCont s:p1.1;c 5934 #2 <= OK 5935 #3 <= %Stopped T05 p1.1 5936 #4 => vStopped 5937 #5 <= T05 p1.2 5938 #6 => vStopped 5939 #7 <= OK 5940 #8 (infrun handles the stop for p1.1 and continues stepping) 5941 #9 => vCont s:p1.1;c 5942 5943 The last vCont above would resume thread p1.2 by mistake, because 5944 the server has no idea that the event for p1.2 had not been 5945 handled yet. 5946 5947 The server side must similarly ignore resume actions for the 5948 thread that has a pending %Stopped notification (and any other 5949 threads with events pending), until GDB acks the notification 5950 with vStopped. Otherwise, e.g., the following case is 5951 mishandled: 5952 5953 #1 => g (or any other packet) 5954 #2 <= [registers] 5955 #3 <= %Stopped T05 p1.2 5956 #4 => vCont s:p1.1;c 5957 #5 <= OK 5958 5959 Above, the server must not resume thread p1.2. GDB can't know 5960 that p1.2 stopped until it acks the %Stopped notification, and 5961 since from GDB's perspective all threads should be running, it 5962 sends a "c" action. 5963 5964 Finally, special care must also be given to handling fork/vfork 5965 events. A (v)fork event actually tells us that two processes 5966 stopped -- the parent and the child. Until we follow the fork, 5967 we must not resume the child. Therefore, if we have a pending 5968 fork follow, we must not send a global wildcard resume action 5969 (vCont;c). We can still send process-wide wildcards though. */ 5970 5971 /* Start by assuming a global wildcard (vCont;c) is possible. */ 5972 may_global_wildcard_vcont = 1; 5973 5974 /* And assume every process is individually wildcard-able too. */ 5975 ALL_NON_EXITED_INFERIORS (inf) 5976 { 5977 if (inf->priv == NULL) 5978 inf->priv = XNEW (struct private_inferior); 5979 inf->priv->may_wildcard_vcont = 1; 5980 } 5981 5982 /* Check for any pending events (not reported or processed yet) and 5983 disable process and global wildcard resumes appropriately. */ 5984 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont); 5985 5986 ALL_NON_EXITED_THREADS (tp) 5987 { 5988 /* If a thread of a process is not meant to be resumed, then we 5989 can't wildcard that process. */ 5990 if (!tp->executing) 5991 { 5992 tp->inf->priv->may_wildcard_vcont = 0; 5993 5994 /* And if we can't wildcard a process, we can't wildcard 5995 everything either. */ 5996 may_global_wildcard_vcont = 0; 5997 continue; 5998 } 5999 6000 /* If a thread is the parent of an unfollowed fork, then we 6001 can't do a global wildcard, as that would resume the fork 6002 child. */ 6003 if (is_pending_fork_parent_thread (tp)) 6004 may_global_wildcard_vcont = 0; 6005 } 6006 6007 /* Now let's build the vCont packet(s). Actions must be appended 6008 from narrower to wider scopes (thread -> process -> global). If 6009 we end up with too many actions for a single packet vcont_builder 6010 flushes the current vCont packet to the remote side and starts a 6011 new one. */ 6012 vcont_builder_restart (&vcont_builder); 6013 6014 /* Threads first. */ 6015 ALL_NON_EXITED_THREADS (tp) 6016 { 6017 struct private_thread_info *remote_thr = tp->priv; 6018 6019 if (!tp->executing || remote_thr->vcont_resumed) 6020 continue; 6021 6022 gdb_assert (!thread_is_in_step_over_chain (tp)); 6023 6024 if (!remote_thr->last_resume_step 6025 && remote_thr->last_resume_sig == GDB_SIGNAL_0 6026 && tp->inf->priv->may_wildcard_vcont) 6027 { 6028 /* We'll send a wildcard resume instead. */ 6029 remote_thr->vcont_resumed = 1; 6030 continue; 6031 } 6032 6033 vcont_builder_push_action (&vcont_builder, tp->ptid, 6034 remote_thr->last_resume_step, 6035 remote_thr->last_resume_sig); 6036 remote_thr->vcont_resumed = 1; 6037 } 6038 6039 /* Now check whether we can send any process-wide wildcard. This is 6040 to avoid sending a global wildcard in the case nothing is 6041 supposed to be resumed. */ 6042 any_process_wildcard = 0; 6043 6044 ALL_NON_EXITED_INFERIORS (inf) 6045 { 6046 if (inf->priv->may_wildcard_vcont) 6047 { 6048 any_process_wildcard = 1; 6049 break; 6050 } 6051 } 6052 6053 if (any_process_wildcard) 6054 { 6055 /* If all processes are wildcard-able, then send a single "c" 6056 action, otherwise, send an "all (-1) threads of process" 6057 continue action for each running process, if any. */ 6058 if (may_global_wildcard_vcont) 6059 { 6060 vcont_builder_push_action (&vcont_builder, minus_one_ptid, 6061 0, GDB_SIGNAL_0); 6062 } 6063 else 6064 { 6065 ALL_NON_EXITED_INFERIORS (inf) 6066 { 6067 if (inf->priv->may_wildcard_vcont) 6068 { 6069 vcont_builder_push_action (&vcont_builder, 6070 pid_to_ptid (inf->pid), 6071 0, GDB_SIGNAL_0); 6072 } 6073 } 6074 } 6075 } 6076 6077 vcont_builder_flush (&vcont_builder); 6078} 6079 6080 6081 6082/* Non-stop version of target_stop. Uses `vCont;t' to stop a remote 6083 thread, all threads of a remote process, or all threads of all 6084 processes. */ 6085 6086static void 6087remote_stop_ns (ptid_t ptid) 6088{ 6089 struct remote_state *rs = get_remote_state (); 6090 char *p = rs->buf; 6091 char *endp = rs->buf + get_remote_packet_size (); 6092 6093 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN) 6094 remote_vcont_probe (rs); 6095 6096 if (!rs->supports_vCont.t) 6097 error (_("Remote server does not support stopping threads")); 6098 6099 if (ptid_equal (ptid, minus_one_ptid) 6100 || (!remote_multi_process_p (rs) && ptid_is_pid (ptid))) 6101 p += xsnprintf (p, endp - p, "vCont;t"); 6102 else 6103 { 6104 ptid_t nptid; 6105 6106 p += xsnprintf (p, endp - p, "vCont;t:"); 6107 6108 if (ptid_is_pid (ptid)) 6109 /* All (-1) threads of process. */ 6110 nptid = ptid_build (ptid_get_pid (ptid), -1, 0); 6111 else 6112 { 6113 /* Small optimization: if we already have a stop reply for 6114 this thread, no use in telling the stub we want this 6115 stopped. */ 6116 if (peek_stop_reply (ptid)) 6117 return; 6118 6119 nptid = ptid; 6120 } 6121 6122 write_ptid (p, endp, nptid); 6123 } 6124 6125 /* In non-stop, we get an immediate OK reply. The stop reply will 6126 come in asynchronously by notification. */ 6127 putpkt (rs->buf); 6128 getpkt (&rs->buf, &rs->buf_size, 0); 6129 if (strcmp (rs->buf, "OK") != 0) 6130 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid), rs->buf); 6131} 6132 6133/* All-stop version of target_interrupt. Sends a break or a ^C to 6134 interrupt the remote target. It is undefined which thread of which 6135 process reports the interrupt. */ 6136 6137static void 6138remote_interrupt_as (void) 6139{ 6140 struct remote_state *rs = get_remote_state (); 6141 6142 rs->ctrlc_pending_p = 1; 6143 6144 /* If the inferior is stopped already, but the core didn't know 6145 about it yet, just ignore the request. The cached wait status 6146 will be collected in remote_wait. */ 6147 if (rs->cached_wait_status) 6148 return; 6149 6150 /* Send interrupt_sequence to remote target. */ 6151 send_interrupt_sequence (); 6152} 6153 6154/* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt 6155 the remote target. It is undefined which thread of which process 6156 reports the interrupt. Throws an error if the packet is not 6157 supported by the server. */ 6158 6159static void 6160remote_interrupt_ns (void) 6161{ 6162 struct remote_state *rs = get_remote_state (); 6163 char *p = rs->buf; 6164 char *endp = rs->buf + get_remote_packet_size (); 6165 6166 xsnprintf (p, endp - p, "vCtrlC"); 6167 6168 /* In non-stop, we get an immediate OK reply. The stop reply will 6169 come in asynchronously by notification. */ 6170 putpkt (rs->buf); 6171 getpkt (&rs->buf, &rs->buf_size, 0); 6172 6173 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCtrlC])) 6174 { 6175 case PACKET_OK: 6176 break; 6177 case PACKET_UNKNOWN: 6178 error (_("No support for interrupting the remote target.")); 6179 case PACKET_ERROR: 6180 error (_("Interrupting target failed: %s"), rs->buf); 6181 } 6182} 6183 6184/* Implement the to_stop function for the remote targets. */ 6185 6186static void 6187remote_stop (struct target_ops *self, ptid_t ptid) 6188{ 6189 if (remote_debug) 6190 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n"); 6191 6192 if (target_is_non_stop_p ()) 6193 remote_stop_ns (ptid); 6194 else 6195 { 6196 /* We don't currently have a way to transparently pause the 6197 remote target in all-stop mode. Interrupt it instead. */ 6198 remote_interrupt_as (); 6199 } 6200} 6201 6202/* Implement the to_interrupt function for the remote targets. */ 6203 6204static void 6205remote_interrupt (struct target_ops *self, ptid_t ptid) 6206{ 6207 struct remote_state *rs = get_remote_state (); 6208 6209 if (remote_debug) 6210 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n"); 6211 6212 if (target_is_non_stop_p ()) 6213 remote_interrupt_ns (); 6214 else 6215 remote_interrupt_as (); 6216} 6217 6218/* Implement the to_pass_ctrlc function for the remote targets. */ 6219 6220static void 6221remote_pass_ctrlc (struct target_ops *self) 6222{ 6223 struct remote_state *rs = get_remote_state (); 6224 6225 if (remote_debug) 6226 fprintf_unfiltered (gdb_stdlog, "remote_pass_ctrlc called\n"); 6227 6228 /* If we're starting up, we're not fully synced yet. Quit 6229 immediately. */ 6230 if (rs->starting_up) 6231 quit (); 6232 /* If ^C has already been sent once, offer to disconnect. */ 6233 else if (rs->ctrlc_pending_p) 6234 interrupt_query (); 6235 else 6236 target_interrupt (inferior_ptid); 6237} 6238 6239/* Ask the user what to do when an interrupt is received. */ 6240 6241static void 6242interrupt_query (void) 6243{ 6244 struct remote_state *rs = get_remote_state (); 6245 6246 if (rs->waiting_for_stop_reply && rs->ctrlc_pending_p) 6247 { 6248 if (query (_("The target is not responding to interrupt requests.\n" 6249 "Stop debugging it? "))) 6250 { 6251 remote_unpush_target (); 6252 throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target.")); 6253 } 6254 } 6255 else 6256 { 6257 if (query (_("Interrupted while waiting for the program.\n" 6258 "Give up waiting? "))) 6259 quit (); 6260 } 6261} 6262 6263/* Enable/disable target terminal ownership. Most targets can use 6264 terminal groups to control terminal ownership. Remote targets are 6265 different in that explicit transfer of ownership to/from GDB/target 6266 is required. */ 6267 6268static void 6269remote_terminal_inferior (struct target_ops *self) 6270{ 6271 /* FIXME: cagney/1999-09-27: Make calls to target_terminal_*() 6272 idempotent. The event-loop GDB talking to an asynchronous target 6273 with a synchronous command calls this function from both 6274 event-top.c and infrun.c/infcmd.c. Once GDB stops trying to 6275 transfer the terminal to the target when it shouldn't this guard 6276 can go away. */ 6277 if (!remote_async_terminal_ours_p) 6278 return; 6279 remote_async_terminal_ours_p = 0; 6280 /* NOTE: At this point we could also register our selves as the 6281 recipient of all input. Any characters typed could then be 6282 passed on down to the target. */ 6283} 6284 6285static void 6286remote_terminal_ours (struct target_ops *self) 6287{ 6288 /* See FIXME in remote_terminal_inferior. */ 6289 if (remote_async_terminal_ours_p) 6290 return; 6291 remote_async_terminal_ours_p = 1; 6292} 6293 6294static void 6295remote_console_output (char *msg) 6296{ 6297 char *p; 6298 6299 for (p = msg; p[0] && p[1]; p += 2) 6300 { 6301 char tb[2]; 6302 char c = fromhex (p[0]) * 16 + fromhex (p[1]); 6303 6304 tb[0] = c; 6305 tb[1] = 0; 6306 fputs_unfiltered (tb, gdb_stdtarg); 6307 } 6308 gdb_flush (gdb_stdtarg); 6309} 6310 6311typedef struct cached_reg 6312{ 6313 int num; 6314 gdb_byte *data; 6315} cached_reg_t; 6316 6317DEF_VEC_O(cached_reg_t); 6318 6319typedef struct stop_reply 6320{ 6321 struct notif_event base; 6322 6323 /* The identifier of the thread about this event */ 6324 ptid_t ptid; 6325 6326 /* The remote state this event is associated with. When the remote 6327 connection, represented by a remote_state object, is closed, 6328 all the associated stop_reply events should be released. */ 6329 struct remote_state *rs; 6330 6331 struct target_waitstatus ws; 6332 6333 /* Expedited registers. This makes remote debugging a bit more 6334 efficient for those targets that provide critical registers as 6335 part of their normal status mechanism (as another roundtrip to 6336 fetch them is avoided). */ 6337 VEC(cached_reg_t) *regcache; 6338 6339 enum target_stop_reason stop_reason; 6340 6341 CORE_ADDR watch_data_address; 6342 6343 int core; 6344} *stop_reply_p; 6345 6346DECLARE_QUEUE_P (stop_reply_p); 6347DEFINE_QUEUE_P (stop_reply_p); 6348/* The list of already fetched and acknowledged stop events. This 6349 queue is used for notification Stop, and other notifications 6350 don't need queue for their events, because the notification events 6351 of Stop can't be consumed immediately, so that events should be 6352 queued first, and be consumed by remote_wait_{ns,as} one per 6353 time. Other notifications can consume their events immediately, 6354 so queue is not needed for them. */ 6355static QUEUE (stop_reply_p) *stop_reply_queue; 6356 6357static void 6358stop_reply_xfree (struct stop_reply *r) 6359{ 6360 notif_event_xfree ((struct notif_event *) r); 6361} 6362 6363/* Return the length of the stop reply queue. */ 6364 6365static int 6366stop_reply_queue_length (void) 6367{ 6368 return QUEUE_length (stop_reply_p, stop_reply_queue); 6369} 6370 6371static void 6372remote_notif_stop_parse (struct notif_client *self, char *buf, 6373 struct notif_event *event) 6374{ 6375 remote_parse_stop_reply (buf, (struct stop_reply *) event); 6376} 6377 6378static void 6379remote_notif_stop_ack (struct notif_client *self, char *buf, 6380 struct notif_event *event) 6381{ 6382 struct stop_reply *stop_reply = (struct stop_reply *) event; 6383 6384 /* acknowledge */ 6385 putpkt (self->ack_command); 6386 6387 if (stop_reply->ws.kind == TARGET_WAITKIND_IGNORE) 6388 /* We got an unknown stop reply. */ 6389 error (_("Unknown stop reply")); 6390 6391 push_stop_reply (stop_reply); 6392} 6393 6394static int 6395remote_notif_stop_can_get_pending_events (struct notif_client *self) 6396{ 6397 /* We can't get pending events in remote_notif_process for 6398 notification stop, and we have to do this in remote_wait_ns 6399 instead. If we fetch all queued events from stub, remote stub 6400 may exit and we have no chance to process them back in 6401 remote_wait_ns. */ 6402 mark_async_event_handler (remote_async_inferior_event_token); 6403 return 0; 6404} 6405 6406static void 6407stop_reply_dtr (struct notif_event *event) 6408{ 6409 struct stop_reply *r = (struct stop_reply *) event; 6410 cached_reg_t *reg; 6411 int ix; 6412 6413 for (ix = 0; 6414 VEC_iterate (cached_reg_t, r->regcache, ix, reg); 6415 ix++) 6416 xfree (reg->data); 6417 6418 VEC_free (cached_reg_t, r->regcache); 6419} 6420 6421static struct notif_event * 6422remote_notif_stop_alloc_reply (void) 6423{ 6424 /* We cast to a pointer to the "base class". */ 6425 struct notif_event *r = (struct notif_event *) XNEW (struct stop_reply); 6426 6427 r->dtr = stop_reply_dtr; 6428 6429 return r; 6430} 6431 6432/* A client of notification Stop. */ 6433 6434struct notif_client notif_client_stop = 6435{ 6436 "Stop", 6437 "vStopped", 6438 remote_notif_stop_parse, 6439 remote_notif_stop_ack, 6440 remote_notif_stop_can_get_pending_events, 6441 remote_notif_stop_alloc_reply, 6442 REMOTE_NOTIF_STOP, 6443}; 6444 6445/* A parameter to pass data in and out. */ 6446 6447struct queue_iter_param 6448{ 6449 void *input; 6450 struct stop_reply *output; 6451}; 6452 6453/* Determine if THREAD_PTID is a pending fork parent thread. ARG contains 6454 the pid of the process that owns the threads we want to check, or 6455 -1 if we want to check all threads. */ 6456 6457static int 6458is_pending_fork_parent (struct target_waitstatus *ws, int event_pid, 6459 ptid_t thread_ptid) 6460{ 6461 if (ws->kind == TARGET_WAITKIND_FORKED 6462 || ws->kind == TARGET_WAITKIND_VFORKED) 6463 { 6464 if (event_pid == -1 || event_pid == ptid_get_pid (thread_ptid)) 6465 return 1; 6466 } 6467 6468 return 0; 6469} 6470 6471/* Return the thread's pending status used to determine whether the 6472 thread is a fork parent stopped at a fork event. */ 6473 6474static struct target_waitstatus * 6475thread_pending_fork_status (struct thread_info *thread) 6476{ 6477 if (thread->suspend.waitstatus_pending_p) 6478 return &thread->suspend.waitstatus; 6479 else 6480 return &thread->pending_follow; 6481} 6482 6483/* Determine if THREAD is a pending fork parent thread. */ 6484 6485static int 6486is_pending_fork_parent_thread (struct thread_info *thread) 6487{ 6488 struct target_waitstatus *ws = thread_pending_fork_status (thread); 6489 int pid = -1; 6490 6491 return is_pending_fork_parent (ws, pid, thread->ptid); 6492} 6493 6494/* Check whether EVENT is a fork event, and if it is, remove the 6495 fork child from the context list passed in DATA. */ 6496 6497static int 6498remove_child_of_pending_fork (QUEUE (stop_reply_p) *q, 6499 QUEUE_ITER (stop_reply_p) *iter, 6500 stop_reply_p event, 6501 void *data) 6502{ 6503 struct queue_iter_param *param = (struct queue_iter_param *) data; 6504 struct threads_listing_context *context 6505 = (struct threads_listing_context *) param->input; 6506 6507 if (event->ws.kind == TARGET_WAITKIND_FORKED 6508 || event->ws.kind == TARGET_WAITKIND_VFORKED 6509 || event->ws.kind == TARGET_WAITKIND_THREAD_EXITED) 6510 threads_listing_context_remove (&event->ws, context); 6511 6512 return 1; 6513} 6514 6515/* If CONTEXT contains any fork child threads that have not been 6516 reported yet, remove them from the CONTEXT list. If such a 6517 thread exists it is because we are stopped at a fork catchpoint 6518 and have not yet called follow_fork, which will set up the 6519 host-side data structures for the new process. */ 6520 6521static void 6522remove_new_fork_children (struct threads_listing_context *context) 6523{ 6524 struct thread_info * thread; 6525 int pid = -1; 6526 struct notif_client *notif = ¬if_client_stop; 6527 struct queue_iter_param param; 6528 6529 /* For any threads stopped at a fork event, remove the corresponding 6530 fork child threads from the CONTEXT list. */ 6531 ALL_NON_EXITED_THREADS (thread) 6532 { 6533 struct target_waitstatus *ws = thread_pending_fork_status (thread); 6534 6535 if (is_pending_fork_parent (ws, pid, thread->ptid)) 6536 { 6537 threads_listing_context_remove (ws, context); 6538 } 6539 } 6540 6541 /* Check for any pending fork events (not reported or processed yet) 6542 in process PID and remove those fork child threads from the 6543 CONTEXT list as well. */ 6544 remote_notif_get_pending_events (notif); 6545 param.input = context; 6546 param.output = NULL; 6547 QUEUE_iterate (stop_reply_p, stop_reply_queue, 6548 remove_child_of_pending_fork, ¶m); 6549} 6550 6551/* Check whether EVENT would prevent a global or process wildcard 6552 vCont action. */ 6553 6554static int 6555check_pending_event_prevents_wildcard_vcont_callback 6556 (QUEUE (stop_reply_p) *q, 6557 QUEUE_ITER (stop_reply_p) *iter, 6558 stop_reply_p event, 6559 void *data) 6560{ 6561 struct inferior *inf; 6562 int *may_global_wildcard_vcont = (int *) data; 6563 6564 if (event->ws.kind == TARGET_WAITKIND_NO_RESUMED 6565 || event->ws.kind == TARGET_WAITKIND_NO_HISTORY) 6566 return 1; 6567 6568 if (event->ws.kind == TARGET_WAITKIND_FORKED 6569 || event->ws.kind == TARGET_WAITKIND_VFORKED) 6570 *may_global_wildcard_vcont = 0; 6571 6572 inf = find_inferior_ptid (event->ptid); 6573 6574 /* This may be the first time we heard about this process. 6575 Regardless, we must not do a global wildcard resume, otherwise 6576 we'd resume this process too. */ 6577 *may_global_wildcard_vcont = 0; 6578 if (inf != NULL) 6579 inf->priv->may_wildcard_vcont = 0; 6580 6581 return 1; 6582} 6583 6584/* Check whether any event pending in the vStopped queue would prevent 6585 a global or process wildcard vCont action. Clear 6586 *may_global_wildcard if we can't do a global wildcard (vCont;c), 6587 and clear the event inferior's may_wildcard_vcont flag if we can't 6588 do a process-wide wildcard resume (vCont;c:pPID.-1). */ 6589 6590static void 6591check_pending_events_prevent_wildcard_vcont (int *may_global_wildcard) 6592{ 6593 struct notif_client *notif = ¬if_client_stop; 6594 6595 remote_notif_get_pending_events (notif); 6596 QUEUE_iterate (stop_reply_p, stop_reply_queue, 6597 check_pending_event_prevents_wildcard_vcont_callback, 6598 may_global_wildcard); 6599} 6600 6601/* Remove stop replies in the queue if its pid is equal to the given 6602 inferior's pid. */ 6603 6604static int 6605remove_stop_reply_for_inferior (QUEUE (stop_reply_p) *q, 6606 QUEUE_ITER (stop_reply_p) *iter, 6607 stop_reply_p event, 6608 void *data) 6609{ 6610 struct queue_iter_param *param = (struct queue_iter_param *) data; 6611 struct inferior *inf = (struct inferior *) param->input; 6612 6613 if (ptid_get_pid (event->ptid) == inf->pid) 6614 { 6615 stop_reply_xfree (event); 6616 QUEUE_remove_elem (stop_reply_p, q, iter); 6617 } 6618 6619 return 1; 6620} 6621 6622/* Discard all pending stop replies of inferior INF. */ 6623 6624static void 6625discard_pending_stop_replies (struct inferior *inf) 6626{ 6627 struct queue_iter_param param; 6628 struct stop_reply *reply; 6629 struct remote_state *rs = get_remote_state (); 6630 struct remote_notif_state *rns = rs->notif_state; 6631 6632 /* This function can be notified when an inferior exists. When the 6633 target is not remote, the notification state is NULL. */ 6634 if (rs->remote_desc == NULL) 6635 return; 6636 6637 reply = (struct stop_reply *) rns->pending_event[notif_client_stop.id]; 6638 6639 /* Discard the in-flight notification. */ 6640 if (reply != NULL && ptid_get_pid (reply->ptid) == inf->pid) 6641 { 6642 stop_reply_xfree (reply); 6643 rns->pending_event[notif_client_stop.id] = NULL; 6644 } 6645 6646 param.input = inf; 6647 param.output = NULL; 6648 /* Discard the stop replies we have already pulled with 6649 vStopped. */ 6650 QUEUE_iterate (stop_reply_p, stop_reply_queue, 6651 remove_stop_reply_for_inferior, ¶m); 6652} 6653 6654/* If its remote state is equal to the given remote state, 6655 remove EVENT from the stop reply queue. */ 6656 6657static int 6658remove_stop_reply_of_remote_state (QUEUE (stop_reply_p) *q, 6659 QUEUE_ITER (stop_reply_p) *iter, 6660 stop_reply_p event, 6661 void *data) 6662{ 6663 struct queue_iter_param *param = (struct queue_iter_param *) data; 6664 struct remote_state *rs = (struct remote_state *) param->input; 6665 6666 if (event->rs == rs) 6667 { 6668 stop_reply_xfree (event); 6669 QUEUE_remove_elem (stop_reply_p, q, iter); 6670 } 6671 6672 return 1; 6673} 6674 6675/* Discard the stop replies for RS in stop_reply_queue. */ 6676 6677static void 6678discard_pending_stop_replies_in_queue (struct remote_state *rs) 6679{ 6680 struct queue_iter_param param; 6681 6682 param.input = rs; 6683 param.output = NULL; 6684 /* Discard the stop replies we have already pulled with 6685 vStopped. */ 6686 QUEUE_iterate (stop_reply_p, stop_reply_queue, 6687 remove_stop_reply_of_remote_state, ¶m); 6688} 6689 6690/* A parameter to pass data in and out. */ 6691 6692static int 6693remote_notif_remove_once_on_match (QUEUE (stop_reply_p) *q, 6694 QUEUE_ITER (stop_reply_p) *iter, 6695 stop_reply_p event, 6696 void *data) 6697{ 6698 struct queue_iter_param *param = (struct queue_iter_param *) data; 6699 ptid_t *ptid = (ptid_t *) param->input; 6700 6701 if (ptid_match (event->ptid, *ptid)) 6702 { 6703 param->output = event; 6704 QUEUE_remove_elem (stop_reply_p, q, iter); 6705 return 0; 6706 } 6707 6708 return 1; 6709} 6710 6711/* Remove the first reply in 'stop_reply_queue' which matches 6712 PTID. */ 6713 6714static struct stop_reply * 6715remote_notif_remove_queued_reply (ptid_t ptid) 6716{ 6717 struct queue_iter_param param; 6718 6719 param.input = &ptid; 6720 param.output = NULL; 6721 6722 QUEUE_iterate (stop_reply_p, stop_reply_queue, 6723 remote_notif_remove_once_on_match, ¶m); 6724 if (notif_debug) 6725 fprintf_unfiltered (gdb_stdlog, 6726 "notif: discard queued event: 'Stop' in %s\n", 6727 target_pid_to_str (ptid)); 6728 6729 return param.output; 6730} 6731 6732/* Look for a queued stop reply belonging to PTID. If one is found, 6733 remove it from the queue, and return it. Returns NULL if none is 6734 found. If there are still queued events left to process, tell the 6735 event loop to get back to target_wait soon. */ 6736 6737static struct stop_reply * 6738queued_stop_reply (ptid_t ptid) 6739{ 6740 struct stop_reply *r = remote_notif_remove_queued_reply (ptid); 6741 6742 if (!QUEUE_is_empty (stop_reply_p, stop_reply_queue)) 6743 /* There's still at least an event left. */ 6744 mark_async_event_handler (remote_async_inferior_event_token); 6745 6746 return r; 6747} 6748 6749/* Push a fully parsed stop reply in the stop reply queue. Since we 6750 know that we now have at least one queued event left to pass to the 6751 core side, tell the event loop to get back to target_wait soon. */ 6752 6753static void 6754push_stop_reply (struct stop_reply *new_event) 6755{ 6756 QUEUE_enque (stop_reply_p, stop_reply_queue, new_event); 6757 6758 if (notif_debug) 6759 fprintf_unfiltered (gdb_stdlog, 6760 "notif: push 'Stop' %s to queue %d\n", 6761 target_pid_to_str (new_event->ptid), 6762 QUEUE_length (stop_reply_p, 6763 stop_reply_queue)); 6764 6765 mark_async_event_handler (remote_async_inferior_event_token); 6766} 6767 6768static int 6769stop_reply_match_ptid_and_ws (QUEUE (stop_reply_p) *q, 6770 QUEUE_ITER (stop_reply_p) *iter, 6771 struct stop_reply *event, 6772 void *data) 6773{ 6774 ptid_t *ptid = (ptid_t *) data; 6775 6776 return !(ptid_equal (*ptid, event->ptid) 6777 && event->ws.kind == TARGET_WAITKIND_STOPPED); 6778} 6779 6780/* Returns true if we have a stop reply for PTID. */ 6781 6782static int 6783peek_stop_reply (ptid_t ptid) 6784{ 6785 return !QUEUE_iterate (stop_reply_p, stop_reply_queue, 6786 stop_reply_match_ptid_and_ws, &ptid); 6787} 6788 6789/* Helper for remote_parse_stop_reply. Return nonzero if the substring 6790 starting with P and ending with PEND matches PREFIX. */ 6791 6792static int 6793strprefix (const char *p, const char *pend, const char *prefix) 6794{ 6795 for ( ; p < pend; p++, prefix++) 6796 if (*p != *prefix) 6797 return 0; 6798 return *prefix == '\0'; 6799} 6800 6801/* Parse the stop reply in BUF. Either the function succeeds, and the 6802 result is stored in EVENT, or throws an error. */ 6803 6804static void 6805remote_parse_stop_reply (char *buf, struct stop_reply *event) 6806{ 6807 struct remote_arch_state *rsa = get_remote_arch_state (); 6808 ULONGEST addr; 6809 char *p; 6810 int skipregs = 0; 6811 6812 event->ptid = null_ptid; 6813 event->rs = get_remote_state (); 6814 event->ws.kind = TARGET_WAITKIND_IGNORE; 6815 event->ws.value.integer = 0; 6816 event->stop_reason = TARGET_STOPPED_BY_NO_REASON; 6817 event->regcache = NULL; 6818 event->core = -1; 6819 6820 switch (buf[0]) 6821 { 6822 case 'T': /* Status with PC, SP, FP, ... */ 6823 /* Expedited reply, containing Signal, {regno, reg} repeat. */ 6824 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where 6825 ss = signal number 6826 n... = register number 6827 r... = register contents 6828 */ 6829 6830 p = &buf[3]; /* after Txx */ 6831 while (*p) 6832 { 6833 char *p1; 6834 int fieldsize; 6835 6836 p1 = strchr (p, ':'); 6837 if (p1 == NULL) 6838 error (_("Malformed packet(a) (missing colon): %s\n\ 6839Packet: '%s'\n"), 6840 p, buf); 6841 if (p == p1) 6842 error (_("Malformed packet(a) (missing register number): %s\n\ 6843Packet: '%s'\n"), 6844 p, buf); 6845 6846 /* Some "registers" are actually extended stop information. 6847 Note if you're adding a new entry here: GDB 7.9 and 6848 earlier assume that all register "numbers" that start 6849 with an hex digit are real register numbers. Make sure 6850 the server only sends such a packet if it knows the 6851 client understands it. */ 6852 6853 if (strprefix (p, p1, "thread")) 6854 event->ptid = read_ptid (++p1, &p); 6855 else if (strprefix (p, p1, "syscall_entry")) 6856 { 6857 ULONGEST sysno; 6858 6859 event->ws.kind = TARGET_WAITKIND_SYSCALL_ENTRY; 6860 p = unpack_varlen_hex (++p1, &sysno); 6861 event->ws.value.syscall_number = (int) sysno; 6862 } 6863 else if (strprefix (p, p1, "syscall_return")) 6864 { 6865 ULONGEST sysno; 6866 6867 event->ws.kind = TARGET_WAITKIND_SYSCALL_RETURN; 6868 p = unpack_varlen_hex (++p1, &sysno); 6869 event->ws.value.syscall_number = (int) sysno; 6870 } 6871 else if (strprefix (p, p1, "watch") 6872 || strprefix (p, p1, "rwatch") 6873 || strprefix (p, p1, "awatch")) 6874 { 6875 event->stop_reason = TARGET_STOPPED_BY_WATCHPOINT; 6876 p = unpack_varlen_hex (++p1, &addr); 6877 event->watch_data_address = (CORE_ADDR) addr; 6878 } 6879 else if (strprefix (p, p1, "swbreak")) 6880 { 6881 event->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT; 6882 6883 /* Make sure the stub doesn't forget to indicate support 6884 with qSupported. */ 6885 if (packet_support (PACKET_swbreak_feature) != PACKET_ENABLE) 6886 error (_("Unexpected swbreak stop reason")); 6887 6888 /* The value part is documented as "must be empty", 6889 though we ignore it, in case we ever decide to make 6890 use of it in a backward compatible way. */ 6891 p = strchrnul (p1 + 1, ';'); 6892 } 6893 else if (strprefix (p, p1, "hwbreak")) 6894 { 6895 event->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT; 6896 6897 /* Make sure the stub doesn't forget to indicate support 6898 with qSupported. */ 6899 if (packet_support (PACKET_hwbreak_feature) != PACKET_ENABLE) 6900 error (_("Unexpected hwbreak stop reason")); 6901 6902 /* See above. */ 6903 p = strchrnul (p1 + 1, ';'); 6904 } 6905 else if (strprefix (p, p1, "library")) 6906 { 6907 event->ws.kind = TARGET_WAITKIND_LOADED; 6908 p = strchrnul (p1 + 1, ';'); 6909 } 6910 else if (strprefix (p, p1, "replaylog")) 6911 { 6912 event->ws.kind = TARGET_WAITKIND_NO_HISTORY; 6913 /* p1 will indicate "begin" or "end", but it makes 6914 no difference for now, so ignore it. */ 6915 p = strchrnul (p1 + 1, ';'); 6916 } 6917 else if (strprefix (p, p1, "core")) 6918 { 6919 ULONGEST c; 6920 6921 p = unpack_varlen_hex (++p1, &c); 6922 event->core = c; 6923 } 6924 else if (strprefix (p, p1, "fork")) 6925 { 6926 event->ws.value.related_pid = read_ptid (++p1, &p); 6927 event->ws.kind = TARGET_WAITKIND_FORKED; 6928 } 6929 else if (strprefix (p, p1, "vfork")) 6930 { 6931 event->ws.value.related_pid = read_ptid (++p1, &p); 6932 event->ws.kind = TARGET_WAITKIND_VFORKED; 6933 } 6934 else if (strprefix (p, p1, "vforkdone")) 6935 { 6936 event->ws.kind = TARGET_WAITKIND_VFORK_DONE; 6937 p = strchrnul (p1 + 1, ';'); 6938 } 6939 else if (strprefix (p, p1, "exec")) 6940 { 6941 ULONGEST ignored; 6942 char pathname[PATH_MAX]; 6943 int pathlen; 6944 6945 /* Determine the length of the execd pathname. */ 6946 p = unpack_varlen_hex (++p1, &ignored); 6947 pathlen = (p - p1) / 2; 6948 6949 /* Save the pathname for event reporting and for 6950 the next run command. */ 6951 hex2bin (p1, (gdb_byte *) pathname, pathlen); 6952 pathname[pathlen] = '\0'; 6953 6954 /* This is freed during event handling. */ 6955 event->ws.value.execd_pathname = xstrdup (pathname); 6956 event->ws.kind = TARGET_WAITKIND_EXECD; 6957 6958 /* Skip the registers included in this packet, since 6959 they may be for an architecture different from the 6960 one used by the original program. */ 6961 skipregs = 1; 6962 } 6963 else if (strprefix (p, p1, "create")) 6964 { 6965 event->ws.kind = TARGET_WAITKIND_THREAD_CREATED; 6966 p = strchrnul (p1 + 1, ';'); 6967 } 6968 else 6969 { 6970 ULONGEST pnum; 6971 char *p_temp; 6972 6973 if (skipregs) 6974 { 6975 p = strchrnul (p1 + 1, ';'); 6976 p++; 6977 continue; 6978 } 6979 6980 /* Maybe a real ``P'' register number. */ 6981 p_temp = unpack_varlen_hex (p, &pnum); 6982 /* If the first invalid character is the colon, we got a 6983 register number. Otherwise, it's an unknown stop 6984 reason. */ 6985 if (p_temp == p1) 6986 { 6987 struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum); 6988 cached_reg_t cached_reg; 6989 struct gdbarch *gdbarch = target_gdbarch (); 6990 6991 if (reg == NULL) 6992 error (_("Remote sent bad register number %s: %s\n\ 6993Packet: '%s'\n"), 6994 hex_string (pnum), p, buf); 6995 6996 cached_reg.num = reg->regnum; 6997 cached_reg.data = (gdb_byte *) 6998 xmalloc (register_size (gdbarch, reg->regnum)); 6999 7000 p = p1 + 1; 7001 fieldsize = hex2bin (p, cached_reg.data, 7002 register_size (gdbarch, reg->regnum)); 7003 p += 2 * fieldsize; 7004 if (fieldsize < register_size (gdbarch, reg->regnum)) 7005 warning (_("Remote reply is too short: %s"), buf); 7006 7007 VEC_safe_push (cached_reg_t, event->regcache, &cached_reg); 7008 } 7009 else 7010 { 7011 /* Not a number. Silently skip unknown optional 7012 info. */ 7013 p = strchrnul (p1 + 1, ';'); 7014 } 7015 } 7016 7017 if (*p != ';') 7018 error (_("Remote register badly formatted: %s\nhere: %s"), 7019 buf, p); 7020 ++p; 7021 } 7022 7023 if (event->ws.kind != TARGET_WAITKIND_IGNORE) 7024 break; 7025 7026 /* fall through */ 7027 case 'S': /* Old style status, just signal only. */ 7028 { 7029 int sig; 7030 7031 event->ws.kind = TARGET_WAITKIND_STOPPED; 7032 sig = (fromhex (buf[1]) << 4) + fromhex (buf[2]); 7033 if (GDB_SIGNAL_FIRST <= sig && sig < GDB_SIGNAL_LAST) 7034 event->ws.value.sig = (enum gdb_signal) sig; 7035 else 7036 event->ws.value.sig = GDB_SIGNAL_UNKNOWN; 7037 } 7038 break; 7039 case 'w': /* Thread exited. */ 7040 { 7041 char *p; 7042 ULONGEST value; 7043 7044 event->ws.kind = TARGET_WAITKIND_THREAD_EXITED; 7045 p = unpack_varlen_hex (&buf[1], &value); 7046 event->ws.value.integer = value; 7047 if (*p != ';') 7048 error (_("stop reply packet badly formatted: %s"), buf); 7049 event->ptid = read_ptid (++p, NULL); 7050 break; 7051 } 7052 case 'W': /* Target exited. */ 7053 case 'X': 7054 { 7055 char *p; 7056 int pid; 7057 ULONGEST value; 7058 7059 /* GDB used to accept only 2 hex chars here. Stubs should 7060 only send more if they detect GDB supports multi-process 7061 support. */ 7062 p = unpack_varlen_hex (&buf[1], &value); 7063 7064 if (buf[0] == 'W') 7065 { 7066 /* The remote process exited. */ 7067 event->ws.kind = TARGET_WAITKIND_EXITED; 7068 event->ws.value.integer = value; 7069 } 7070 else 7071 { 7072 /* The remote process exited with a signal. */ 7073 event->ws.kind = TARGET_WAITKIND_SIGNALLED; 7074 if (GDB_SIGNAL_FIRST <= value && value < GDB_SIGNAL_LAST) 7075 event->ws.value.sig = (enum gdb_signal) value; 7076 else 7077 event->ws.value.sig = GDB_SIGNAL_UNKNOWN; 7078 } 7079 7080 /* If no process is specified, assume inferior_ptid. */ 7081 pid = ptid_get_pid (inferior_ptid); 7082 if (*p == '\0') 7083 ; 7084 else if (*p == ';') 7085 { 7086 p++; 7087 7088 if (*p == '\0') 7089 ; 7090 else if (startswith (p, "process:")) 7091 { 7092 ULONGEST upid; 7093 7094 p += sizeof ("process:") - 1; 7095 unpack_varlen_hex (p, &upid); 7096 pid = upid; 7097 } 7098 else 7099 error (_("unknown stop reply packet: %s"), buf); 7100 } 7101 else 7102 error (_("unknown stop reply packet: %s"), buf); 7103 event->ptid = pid_to_ptid (pid); 7104 } 7105 break; 7106 case 'N': 7107 event->ws.kind = TARGET_WAITKIND_NO_RESUMED; 7108 event->ptid = minus_one_ptid; 7109 break; 7110 } 7111 7112 if (target_is_non_stop_p () && ptid_equal (event->ptid, null_ptid)) 7113 error (_("No process or thread specified in stop reply: %s"), buf); 7114} 7115 7116/* When the stub wants to tell GDB about a new notification reply, it 7117 sends a notification (%Stop, for example). Those can come it at 7118 any time, hence, we have to make sure that any pending 7119 putpkt/getpkt sequence we're making is finished, before querying 7120 the stub for more events with the corresponding ack command 7121 (vStopped, for example). E.g., if we started a vStopped sequence 7122 immediately upon receiving the notification, something like this 7123 could happen: 7124 7125 1.1) --> Hg 1 7126 1.2) <-- OK 7127 1.3) --> g 7128 1.4) <-- %Stop 7129 1.5) --> vStopped 7130 1.6) <-- (registers reply to step #1.3) 7131 7132 Obviously, the reply in step #1.6 would be unexpected to a vStopped 7133 query. 7134 7135 To solve this, whenever we parse a %Stop notification successfully, 7136 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on 7137 doing whatever we were doing: 7138 7139 2.1) --> Hg 1 7140 2.2) <-- OK 7141 2.3) --> g 7142 2.4) <-- %Stop 7143 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN> 7144 2.5) <-- (registers reply to step #2.3) 7145 7146 Eventualy after step #2.5, we return to the event loop, which 7147 notices there's an event on the 7148 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the 7149 associated callback --- the function below. At this point, we're 7150 always safe to start a vStopped sequence. : 7151 7152 2.6) --> vStopped 7153 2.7) <-- T05 thread:2 7154 2.8) --> vStopped 7155 2.9) --> OK 7156*/ 7157 7158void 7159remote_notif_get_pending_events (struct notif_client *nc) 7160{ 7161 struct remote_state *rs = get_remote_state (); 7162 7163 if (rs->notif_state->pending_event[nc->id] != NULL) 7164 { 7165 if (notif_debug) 7166 fprintf_unfiltered (gdb_stdlog, 7167 "notif: process: '%s' ack pending event\n", 7168 nc->name); 7169 7170 /* acknowledge */ 7171 nc->ack (nc, rs->buf, rs->notif_state->pending_event[nc->id]); 7172 rs->notif_state->pending_event[nc->id] = NULL; 7173 7174 while (1) 7175 { 7176 getpkt (&rs->buf, &rs->buf_size, 0); 7177 if (strcmp (rs->buf, "OK") == 0) 7178 break; 7179 else 7180 remote_notif_ack (nc, rs->buf); 7181 } 7182 } 7183 else 7184 { 7185 if (notif_debug) 7186 fprintf_unfiltered (gdb_stdlog, 7187 "notif: process: '%s' no pending reply\n", 7188 nc->name); 7189 } 7190} 7191 7192/* Called when it is decided that STOP_REPLY holds the info of the 7193 event that is to be returned to the core. This function always 7194 destroys STOP_REPLY. */ 7195 7196static ptid_t 7197process_stop_reply (struct stop_reply *stop_reply, 7198 struct target_waitstatus *status) 7199{ 7200 ptid_t ptid; 7201 7202 *status = stop_reply->ws; 7203 ptid = stop_reply->ptid; 7204 7205 /* If no thread/process was reported by the stub, assume the current 7206 inferior. */ 7207 if (ptid_equal (ptid, null_ptid)) 7208 ptid = inferior_ptid; 7209 7210 if (status->kind != TARGET_WAITKIND_EXITED 7211 && status->kind != TARGET_WAITKIND_SIGNALLED 7212 && status->kind != TARGET_WAITKIND_NO_RESUMED) 7213 { 7214 struct private_thread_info *remote_thr; 7215 7216 /* Expedited registers. */ 7217 if (stop_reply->regcache) 7218 { 7219 struct regcache *regcache 7220 = get_thread_arch_regcache (ptid, target_gdbarch ()); 7221 cached_reg_t *reg; 7222 int ix; 7223 7224 for (ix = 0; 7225 VEC_iterate (cached_reg_t, stop_reply->regcache, ix, reg); 7226 ix++) 7227 { 7228 regcache_raw_supply (regcache, reg->num, reg->data); 7229 xfree (reg->data); 7230 } 7231 7232 VEC_free (cached_reg_t, stop_reply->regcache); 7233 } 7234 7235 remote_notice_new_inferior (ptid, 0); 7236 remote_thr = get_private_info_ptid (ptid); 7237 remote_thr->core = stop_reply->core; 7238 remote_thr->stop_reason = stop_reply->stop_reason; 7239 remote_thr->watch_data_address = stop_reply->watch_data_address; 7240 remote_thr->vcont_resumed = 0; 7241 } 7242 7243 stop_reply_xfree (stop_reply); 7244 return ptid; 7245} 7246 7247/* The non-stop mode version of target_wait. */ 7248 7249static ptid_t 7250remote_wait_ns (ptid_t ptid, struct target_waitstatus *status, int options) 7251{ 7252 struct remote_state *rs = get_remote_state (); 7253 struct stop_reply *stop_reply; 7254 int ret; 7255 int is_notif = 0; 7256 7257 /* If in non-stop mode, get out of getpkt even if a 7258 notification is received. */ 7259 7260 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size, 7261 0 /* forever */, &is_notif); 7262 while (1) 7263 { 7264 if (ret != -1 && !is_notif) 7265 switch (rs->buf[0]) 7266 { 7267 case 'E': /* Error of some sort. */ 7268 /* We're out of sync with the target now. Did it continue 7269 or not? We can't tell which thread it was in non-stop, 7270 so just ignore this. */ 7271 warning (_("Remote failure reply: %s"), rs->buf); 7272 break; 7273 case 'O': /* Console output. */ 7274 remote_console_output (rs->buf + 1); 7275 break; 7276 default: 7277 warning (_("Invalid remote reply: %s"), rs->buf); 7278 break; 7279 } 7280 7281 /* Acknowledge a pending stop reply that may have arrived in the 7282 mean time. */ 7283 if (rs->notif_state->pending_event[notif_client_stop.id] != NULL) 7284 remote_notif_get_pending_events (¬if_client_stop); 7285 7286 /* If indeed we noticed a stop reply, we're done. */ 7287 stop_reply = queued_stop_reply (ptid); 7288 if (stop_reply != NULL) 7289 return process_stop_reply (stop_reply, status); 7290 7291 /* Still no event. If we're just polling for an event, then 7292 return to the event loop. */ 7293 if (options & TARGET_WNOHANG) 7294 { 7295 status->kind = TARGET_WAITKIND_IGNORE; 7296 return minus_one_ptid; 7297 } 7298 7299 /* Otherwise do a blocking wait. */ 7300 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size, 7301 1 /* forever */, &is_notif); 7302 } 7303} 7304 7305/* Wait until the remote machine stops, then return, storing status in 7306 STATUS just as `wait' would. */ 7307 7308static ptid_t 7309remote_wait_as (ptid_t ptid, struct target_waitstatus *status, int options) 7310{ 7311 struct remote_state *rs = get_remote_state (); 7312 ptid_t event_ptid = null_ptid; 7313 char *buf; 7314 struct stop_reply *stop_reply; 7315 7316 again: 7317 7318 status->kind = TARGET_WAITKIND_IGNORE; 7319 status->value.integer = 0; 7320 7321 stop_reply = queued_stop_reply (ptid); 7322 if (stop_reply != NULL) 7323 return process_stop_reply (stop_reply, status); 7324 7325 if (rs->cached_wait_status) 7326 /* Use the cached wait status, but only once. */ 7327 rs->cached_wait_status = 0; 7328 else 7329 { 7330 int ret; 7331 int is_notif; 7332 int forever = ((options & TARGET_WNOHANG) == 0 7333 && wait_forever_enabled_p); 7334 7335 if (!rs->waiting_for_stop_reply) 7336 { 7337 status->kind = TARGET_WAITKIND_NO_RESUMED; 7338 return minus_one_ptid; 7339 } 7340 7341 /* FIXME: cagney/1999-09-27: If we're in async mode we should 7342 _never_ wait for ever -> test on target_is_async_p(). 7343 However, before we do that we need to ensure that the caller 7344 knows how to take the target into/out of async mode. */ 7345 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size, 7346 forever, &is_notif); 7347 7348 /* GDB gets a notification. Return to core as this event is 7349 not interesting. */ 7350 if (ret != -1 && is_notif) 7351 return minus_one_ptid; 7352 7353 if (ret == -1 && (options & TARGET_WNOHANG) != 0) 7354 return minus_one_ptid; 7355 } 7356 7357 buf = rs->buf; 7358 7359 /* Assume that the target has acknowledged Ctrl-C unless we receive 7360 an 'F' or 'O' packet. */ 7361 if (buf[0] != 'F' && buf[0] != 'O') 7362 rs->ctrlc_pending_p = 0; 7363 7364 switch (buf[0]) 7365 { 7366 case 'E': /* Error of some sort. */ 7367 /* We're out of sync with the target now. Did it continue or 7368 not? Not is more likely, so report a stop. */ 7369 rs->waiting_for_stop_reply = 0; 7370 7371 warning (_("Remote failure reply: %s"), buf); 7372 status->kind = TARGET_WAITKIND_STOPPED; 7373 status->value.sig = GDB_SIGNAL_0; 7374 break; 7375 case 'F': /* File-I/O request. */ 7376 /* GDB may access the inferior memory while handling the File-I/O 7377 request, but we don't want GDB accessing memory while waiting 7378 for a stop reply. See the comments in putpkt_binary. Set 7379 waiting_for_stop_reply to 0 temporarily. */ 7380 rs->waiting_for_stop_reply = 0; 7381 remote_fileio_request (buf, rs->ctrlc_pending_p); 7382 rs->ctrlc_pending_p = 0; 7383 /* GDB handled the File-I/O request, and the target is running 7384 again. Keep waiting for events. */ 7385 rs->waiting_for_stop_reply = 1; 7386 break; 7387 case 'N': case 'T': case 'S': case 'X': case 'W': 7388 { 7389 struct stop_reply *stop_reply; 7390 7391 /* There is a stop reply to handle. */ 7392 rs->waiting_for_stop_reply = 0; 7393 7394 stop_reply 7395 = (struct stop_reply *) remote_notif_parse (¬if_client_stop, 7396 rs->buf); 7397 7398 event_ptid = process_stop_reply (stop_reply, status); 7399 break; 7400 } 7401 case 'O': /* Console output. */ 7402 remote_console_output (buf + 1); 7403 break; 7404 case '\0': 7405 if (rs->last_sent_signal != GDB_SIGNAL_0) 7406 { 7407 /* Zero length reply means that we tried 'S' or 'C' and the 7408 remote system doesn't support it. */ 7409 target_terminal_ours_for_output (); 7410 printf_filtered 7411 ("Can't send signals to this remote system. %s not sent.\n", 7412 gdb_signal_to_name (rs->last_sent_signal)); 7413 rs->last_sent_signal = GDB_SIGNAL_0; 7414 target_terminal_inferior (); 7415 7416 strcpy (buf, rs->last_sent_step ? "s" : "c"); 7417 putpkt (buf); 7418 break; 7419 } 7420 /* else fallthrough */ 7421 default: 7422 warning (_("Invalid remote reply: %s"), buf); 7423 break; 7424 } 7425 7426 if (status->kind == TARGET_WAITKIND_NO_RESUMED) 7427 return minus_one_ptid; 7428 else if (status->kind == TARGET_WAITKIND_IGNORE) 7429 { 7430 /* Nothing interesting happened. If we're doing a non-blocking 7431 poll, we're done. Otherwise, go back to waiting. */ 7432 if (options & TARGET_WNOHANG) 7433 return minus_one_ptid; 7434 else 7435 goto again; 7436 } 7437 else if (status->kind != TARGET_WAITKIND_EXITED 7438 && status->kind != TARGET_WAITKIND_SIGNALLED) 7439 { 7440 if (!ptid_equal (event_ptid, null_ptid)) 7441 record_currthread (rs, event_ptid); 7442 else 7443 event_ptid = inferior_ptid; 7444 } 7445 else 7446 /* A process exit. Invalidate our notion of current thread. */ 7447 record_currthread (rs, minus_one_ptid); 7448 7449 return event_ptid; 7450} 7451 7452/* Wait until the remote machine stops, then return, storing status in 7453 STATUS just as `wait' would. */ 7454 7455static ptid_t 7456remote_wait (struct target_ops *ops, 7457 ptid_t ptid, struct target_waitstatus *status, int options) 7458{ 7459 ptid_t event_ptid; 7460 7461 if (target_is_non_stop_p ()) 7462 event_ptid = remote_wait_ns (ptid, status, options); 7463 else 7464 event_ptid = remote_wait_as (ptid, status, options); 7465 7466 if (target_is_async_p ()) 7467 { 7468 /* If there are are events left in the queue tell the event loop 7469 to return here. */ 7470 if (!QUEUE_is_empty (stop_reply_p, stop_reply_queue)) 7471 mark_async_event_handler (remote_async_inferior_event_token); 7472 } 7473 7474 return event_ptid; 7475} 7476 7477/* Fetch a single register using a 'p' packet. */ 7478 7479static int 7480fetch_register_using_p (struct regcache *regcache, struct packet_reg *reg) 7481{ 7482 struct gdbarch *gdbarch = get_regcache_arch (regcache); 7483 struct remote_state *rs = get_remote_state (); 7484 char *buf, *p; 7485 gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum)); 7486 int i; 7487 7488 if (packet_support (PACKET_p) == PACKET_DISABLE) 7489 return 0; 7490 7491 if (reg->pnum == -1) 7492 return 0; 7493 7494 p = rs->buf; 7495 *p++ = 'p'; 7496 p += hexnumstr (p, reg->pnum); 7497 *p++ = '\0'; 7498 putpkt (rs->buf); 7499 getpkt (&rs->buf, &rs->buf_size, 0); 7500 7501 buf = rs->buf; 7502 7503 switch (packet_ok (buf, &remote_protocol_packets[PACKET_p])) 7504 { 7505 case PACKET_OK: 7506 break; 7507 case PACKET_UNKNOWN: 7508 return 0; 7509 case PACKET_ERROR: 7510 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"), 7511 gdbarch_register_name (get_regcache_arch (regcache), 7512 reg->regnum), 7513 buf); 7514 } 7515 7516 /* If this register is unfetchable, tell the regcache. */ 7517 if (buf[0] == 'x') 7518 { 7519 regcache_raw_supply (regcache, reg->regnum, NULL); 7520 return 1; 7521 } 7522 7523 /* Otherwise, parse and supply the value. */ 7524 p = buf; 7525 i = 0; 7526 while (p[0] != 0) 7527 { 7528 if (p[1] == 0) 7529 error (_("fetch_register_using_p: early buf termination")); 7530 7531 regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]); 7532 p += 2; 7533 } 7534 regcache_raw_supply (regcache, reg->regnum, regp); 7535 return 1; 7536} 7537 7538/* Fetch the registers included in the target's 'g' packet. */ 7539 7540static int 7541send_g_packet (void) 7542{ 7543 struct remote_state *rs = get_remote_state (); 7544 int buf_len; 7545 7546 xsnprintf (rs->buf, get_remote_packet_size (), "g"); 7547 remote_send (&rs->buf, &rs->buf_size); 7548 7549 /* We can get out of synch in various cases. If the first character 7550 in the buffer is not a hex character, assume that has happened 7551 and try to fetch another packet to read. */ 7552 while ((rs->buf[0] < '0' || rs->buf[0] > '9') 7553 && (rs->buf[0] < 'A' || rs->buf[0] > 'F') 7554 && (rs->buf[0] < 'a' || rs->buf[0] > 'f') 7555 && rs->buf[0] != 'x') /* New: unavailable register value. */ 7556 { 7557 if (remote_debug) 7558 fprintf_unfiltered (gdb_stdlog, 7559 "Bad register packet; fetching a new packet\n"); 7560 getpkt (&rs->buf, &rs->buf_size, 0); 7561 } 7562 7563 buf_len = strlen (rs->buf); 7564 7565 /* Sanity check the received packet. */ 7566 if (buf_len % 2 != 0) 7567 error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf); 7568 7569 return buf_len / 2; 7570} 7571 7572static void 7573process_g_packet (struct regcache *regcache) 7574{ 7575 struct gdbarch *gdbarch = get_regcache_arch (regcache); 7576 struct remote_state *rs = get_remote_state (); 7577 struct remote_arch_state *rsa = get_remote_arch_state (); 7578 int i, buf_len; 7579 char *p; 7580 char *regs; 7581 7582 buf_len = strlen (rs->buf); 7583 7584 /* Further sanity checks, with knowledge of the architecture. */ 7585 if (buf_len > 2 * rsa->sizeof_g_packet) 7586 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d " 7587 "bytes): %s"), rsa->sizeof_g_packet, buf_len / 2, rs->buf); 7588 7589 /* Save the size of the packet sent to us by the target. It is used 7590 as a heuristic when determining the max size of packets that the 7591 target can safely receive. */ 7592 if (rsa->actual_register_packet_size == 0) 7593 rsa->actual_register_packet_size = buf_len; 7594 7595 /* If this is smaller than we guessed the 'g' packet would be, 7596 update our records. A 'g' reply that doesn't include a register's 7597 value implies either that the register is not available, or that 7598 the 'p' packet must be used. */ 7599 if (buf_len < 2 * rsa->sizeof_g_packet) 7600 { 7601 long sizeof_g_packet = buf_len / 2; 7602 7603 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 7604 { 7605 long offset = rsa->regs[i].offset; 7606 long reg_size = register_size (gdbarch, i); 7607 7608 if (rsa->regs[i].pnum == -1) 7609 continue; 7610 7611 if (offset >= sizeof_g_packet) 7612 rsa->regs[i].in_g_packet = 0; 7613 else if (offset + reg_size > sizeof_g_packet) 7614 error (_("Truncated register %d in remote 'g' packet"), i); 7615 else 7616 rsa->regs[i].in_g_packet = 1; 7617 } 7618 7619 /* Looks valid enough, we can assume this is the correct length 7620 for a 'g' packet. It's important not to adjust 7621 rsa->sizeof_g_packet if we have truncated registers otherwise 7622 this "if" won't be run the next time the method is called 7623 with a packet of the same size and one of the internal errors 7624 below will trigger instead. */ 7625 rsa->sizeof_g_packet = sizeof_g_packet; 7626 } 7627 7628 regs = (char *) alloca (rsa->sizeof_g_packet); 7629 7630 /* Unimplemented registers read as all bits zero. */ 7631 memset (regs, 0, rsa->sizeof_g_packet); 7632 7633 /* Reply describes registers byte by byte, each byte encoded as two 7634 hex characters. Suck them all up, then supply them to the 7635 register cacheing/storage mechanism. */ 7636 7637 p = rs->buf; 7638 for (i = 0; i < rsa->sizeof_g_packet; i++) 7639 { 7640 if (p[0] == 0 || p[1] == 0) 7641 /* This shouldn't happen - we adjusted sizeof_g_packet above. */ 7642 internal_error (__FILE__, __LINE__, 7643 _("unexpected end of 'g' packet reply")); 7644 7645 if (p[0] == 'x' && p[1] == 'x') 7646 regs[i] = 0; /* 'x' */ 7647 else 7648 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]); 7649 p += 2; 7650 } 7651 7652 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 7653 { 7654 struct packet_reg *r = &rsa->regs[i]; 7655 long reg_size = register_size (gdbarch, i); 7656 7657 if (r->in_g_packet) 7658 { 7659 if ((r->offset + reg_size) * 2 > strlen (rs->buf)) 7660 /* This shouldn't happen - we adjusted in_g_packet above. */ 7661 internal_error (__FILE__, __LINE__, 7662 _("unexpected end of 'g' packet reply")); 7663 else if (rs->buf[r->offset * 2] == 'x') 7664 { 7665 gdb_assert (r->offset * 2 < strlen (rs->buf)); 7666 /* The register isn't available, mark it as such (at 7667 the same time setting the value to zero). */ 7668 regcache_raw_supply (regcache, r->regnum, NULL); 7669 } 7670 else 7671 regcache_raw_supply (regcache, r->regnum, 7672 regs + r->offset); 7673 } 7674 } 7675} 7676 7677static void 7678fetch_registers_using_g (struct regcache *regcache) 7679{ 7680 send_g_packet (); 7681 process_g_packet (regcache); 7682} 7683 7684/* Make the remote selected traceframe match GDB's selected 7685 traceframe. */ 7686 7687static void 7688set_remote_traceframe (void) 7689{ 7690 int newnum; 7691 struct remote_state *rs = get_remote_state (); 7692 7693 if (rs->remote_traceframe_number == get_traceframe_number ()) 7694 return; 7695 7696 /* Avoid recursion, remote_trace_find calls us again. */ 7697 rs->remote_traceframe_number = get_traceframe_number (); 7698 7699 newnum = target_trace_find (tfind_number, 7700 get_traceframe_number (), 0, 0, NULL); 7701 7702 /* Should not happen. If it does, all bets are off. */ 7703 if (newnum != get_traceframe_number ()) 7704 warning (_("could not set remote traceframe")); 7705} 7706 7707static void 7708remote_fetch_registers (struct target_ops *ops, 7709 struct regcache *regcache, int regnum) 7710{ 7711 struct remote_arch_state *rsa = get_remote_arch_state (); 7712 int i; 7713 7714 set_remote_traceframe (); 7715 set_general_thread (regcache_get_ptid (regcache)); 7716 7717 if (regnum >= 0) 7718 { 7719 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum); 7720 7721 gdb_assert (reg != NULL); 7722 7723 /* If this register might be in the 'g' packet, try that first - 7724 we are likely to read more than one register. If this is the 7725 first 'g' packet, we might be overly optimistic about its 7726 contents, so fall back to 'p'. */ 7727 if (reg->in_g_packet) 7728 { 7729 fetch_registers_using_g (regcache); 7730 if (reg->in_g_packet) 7731 return; 7732 } 7733 7734 if (fetch_register_using_p (regcache, reg)) 7735 return; 7736 7737 /* This register is not available. */ 7738 regcache_raw_supply (regcache, reg->regnum, NULL); 7739 7740 return; 7741 } 7742 7743 fetch_registers_using_g (regcache); 7744 7745 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++) 7746 if (!rsa->regs[i].in_g_packet) 7747 if (!fetch_register_using_p (regcache, &rsa->regs[i])) 7748 { 7749 /* This register is not available. */ 7750 regcache_raw_supply (regcache, i, NULL); 7751 } 7752} 7753 7754/* Prepare to store registers. Since we may send them all (using a 7755 'G' request), we have to read out the ones we don't want to change 7756 first. */ 7757 7758static void 7759remote_prepare_to_store (struct target_ops *self, struct regcache *regcache) 7760{ 7761 struct remote_arch_state *rsa = get_remote_arch_state (); 7762 int i; 7763 7764 /* Make sure the entire registers array is valid. */ 7765 switch (packet_support (PACKET_P)) 7766 { 7767 case PACKET_DISABLE: 7768 case PACKET_SUPPORT_UNKNOWN: 7769 /* Make sure all the necessary registers are cached. */ 7770 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++) 7771 if (rsa->regs[i].in_g_packet) 7772 regcache_raw_update (regcache, rsa->regs[i].regnum); 7773 break; 7774 case PACKET_ENABLE: 7775 break; 7776 } 7777} 7778 7779/* Helper: Attempt to store REGNUM using the P packet. Return fail IFF 7780 packet was not recognized. */ 7781 7782static int 7783store_register_using_P (const struct regcache *regcache, 7784 struct packet_reg *reg) 7785{ 7786 struct gdbarch *gdbarch = get_regcache_arch (regcache); 7787 struct remote_state *rs = get_remote_state (); 7788 /* Try storing a single register. */ 7789 char *buf = rs->buf; 7790 gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum)); 7791 char *p; 7792 7793 if (packet_support (PACKET_P) == PACKET_DISABLE) 7794 return 0; 7795 7796 if (reg->pnum == -1) 7797 return 0; 7798 7799 xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0)); 7800 p = buf + strlen (buf); 7801 regcache_raw_collect (regcache, reg->regnum, regp); 7802 bin2hex (regp, p, register_size (gdbarch, reg->regnum)); 7803 putpkt (rs->buf); 7804 getpkt (&rs->buf, &rs->buf_size, 0); 7805 7806 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P])) 7807 { 7808 case PACKET_OK: 7809 return 1; 7810 case PACKET_ERROR: 7811 error (_("Could not write register \"%s\"; remote failure reply '%s'"), 7812 gdbarch_register_name (gdbarch, reg->regnum), rs->buf); 7813 case PACKET_UNKNOWN: 7814 return 0; 7815 default: 7816 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok")); 7817 } 7818} 7819 7820/* Store register REGNUM, or all registers if REGNUM == -1, from the 7821 contents of the register cache buffer. FIXME: ignores errors. */ 7822 7823static void 7824store_registers_using_G (const struct regcache *regcache) 7825{ 7826 struct remote_state *rs = get_remote_state (); 7827 struct remote_arch_state *rsa = get_remote_arch_state (); 7828 gdb_byte *regs; 7829 char *p; 7830 7831 /* Extract all the registers in the regcache copying them into a 7832 local buffer. */ 7833 { 7834 int i; 7835 7836 regs = (gdb_byte *) alloca (rsa->sizeof_g_packet); 7837 memset (regs, 0, rsa->sizeof_g_packet); 7838 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++) 7839 { 7840 struct packet_reg *r = &rsa->regs[i]; 7841 7842 if (r->in_g_packet) 7843 regcache_raw_collect (regcache, r->regnum, regs + r->offset); 7844 } 7845 } 7846 7847 /* Command describes registers byte by byte, 7848 each byte encoded as two hex characters. */ 7849 p = rs->buf; 7850 *p++ = 'G'; 7851 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets 7852 updated. */ 7853 bin2hex (regs, p, rsa->sizeof_g_packet); 7854 putpkt (rs->buf); 7855 getpkt (&rs->buf, &rs->buf_size, 0); 7856 if (packet_check_result (rs->buf) == PACKET_ERROR) 7857 error (_("Could not write registers; remote failure reply '%s'"), 7858 rs->buf); 7859} 7860 7861/* Store register REGNUM, or all registers if REGNUM == -1, from the contents 7862 of the register cache buffer. FIXME: ignores errors. */ 7863 7864static void 7865remote_store_registers (struct target_ops *ops, 7866 struct regcache *regcache, int regnum) 7867{ 7868 struct remote_arch_state *rsa = get_remote_arch_state (); 7869 int i; 7870 7871 set_remote_traceframe (); 7872 set_general_thread (regcache_get_ptid (regcache)); 7873 7874 if (regnum >= 0) 7875 { 7876 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum); 7877 7878 gdb_assert (reg != NULL); 7879 7880 /* Always prefer to store registers using the 'P' packet if 7881 possible; we often change only a small number of registers. 7882 Sometimes we change a larger number; we'd need help from a 7883 higher layer to know to use 'G'. */ 7884 if (store_register_using_P (regcache, reg)) 7885 return; 7886 7887 /* For now, don't complain if we have no way to write the 7888 register. GDB loses track of unavailable registers too 7889 easily. Some day, this may be an error. We don't have 7890 any way to read the register, either... */ 7891 if (!reg->in_g_packet) 7892 return; 7893 7894 store_registers_using_G (regcache); 7895 return; 7896 } 7897 7898 store_registers_using_G (regcache); 7899 7900 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++) 7901 if (!rsa->regs[i].in_g_packet) 7902 if (!store_register_using_P (regcache, &rsa->regs[i])) 7903 /* See above for why we do not issue an error here. */ 7904 continue; 7905} 7906 7907 7908/* Return the number of hex digits in num. */ 7909 7910static int 7911hexnumlen (ULONGEST num) 7912{ 7913 int i; 7914 7915 for (i = 0; num != 0; i++) 7916 num >>= 4; 7917 7918 return std::max (i, 1); 7919} 7920 7921/* Set BUF to the minimum number of hex digits representing NUM. */ 7922 7923static int 7924hexnumstr (char *buf, ULONGEST num) 7925{ 7926 int len = hexnumlen (num); 7927 7928 return hexnumnstr (buf, num, len); 7929} 7930 7931 7932/* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */ 7933 7934static int 7935hexnumnstr (char *buf, ULONGEST num, int width) 7936{ 7937 int i; 7938 7939 buf[width] = '\0'; 7940 7941 for (i = width - 1; i >= 0; i--) 7942 { 7943 buf[i] = "0123456789abcdef"[(num & 0xf)]; 7944 num >>= 4; 7945 } 7946 7947 return width; 7948} 7949 7950/* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */ 7951 7952static CORE_ADDR 7953remote_address_masked (CORE_ADDR addr) 7954{ 7955 unsigned int address_size = remote_address_size; 7956 7957 /* If "remoteaddresssize" was not set, default to target address size. */ 7958 if (!address_size) 7959 address_size = gdbarch_addr_bit (target_gdbarch ()); 7960 7961 if (address_size > 0 7962 && address_size < (sizeof (ULONGEST) * 8)) 7963 { 7964 /* Only create a mask when that mask can safely be constructed 7965 in a ULONGEST variable. */ 7966 ULONGEST mask = 1; 7967 7968 mask = (mask << address_size) - 1; 7969 addr &= mask; 7970 } 7971 return addr; 7972} 7973 7974/* Determine whether the remote target supports binary downloading. 7975 This is accomplished by sending a no-op memory write of zero length 7976 to the target at the specified address. It does not suffice to send 7977 the whole packet, since many stubs strip the eighth bit and 7978 subsequently compute a wrong checksum, which causes real havoc with 7979 remote_write_bytes. 7980 7981 NOTE: This can still lose if the serial line is not eight-bit 7982 clean. In cases like this, the user should clear "remote 7983 X-packet". */ 7984 7985static void 7986check_binary_download (CORE_ADDR addr) 7987{ 7988 struct remote_state *rs = get_remote_state (); 7989 7990 switch (packet_support (PACKET_X)) 7991 { 7992 case PACKET_DISABLE: 7993 break; 7994 case PACKET_ENABLE: 7995 break; 7996 case PACKET_SUPPORT_UNKNOWN: 7997 { 7998 char *p; 7999 8000 p = rs->buf; 8001 *p++ = 'X'; 8002 p += hexnumstr (p, (ULONGEST) addr); 8003 *p++ = ','; 8004 p += hexnumstr (p, (ULONGEST) 0); 8005 *p++ = ':'; 8006 *p = '\0'; 8007 8008 putpkt_binary (rs->buf, (int) (p - rs->buf)); 8009 getpkt (&rs->buf, &rs->buf_size, 0); 8010 8011 if (rs->buf[0] == '\0') 8012 { 8013 if (remote_debug) 8014 fprintf_unfiltered (gdb_stdlog, 8015 "binary downloading NOT " 8016 "supported by target\n"); 8017 remote_protocol_packets[PACKET_X].support = PACKET_DISABLE; 8018 } 8019 else 8020 { 8021 if (remote_debug) 8022 fprintf_unfiltered (gdb_stdlog, 8023 "binary downloading supported by target\n"); 8024 remote_protocol_packets[PACKET_X].support = PACKET_ENABLE; 8025 } 8026 break; 8027 } 8028 } 8029} 8030 8031/* Helper function to resize the payload in order to try to get a good 8032 alignment. We try to write an amount of data such that the next write will 8033 start on an address aligned on REMOTE_ALIGN_WRITES. */ 8034 8035static int 8036align_for_efficient_write (int todo, CORE_ADDR memaddr) 8037{ 8038 return ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr; 8039} 8040 8041/* Write memory data directly to the remote machine. 8042 This does not inform the data cache; the data cache uses this. 8043 HEADER is the starting part of the packet. 8044 MEMADDR is the address in the remote memory space. 8045 MYADDR is the address of the buffer in our space. 8046 LEN_UNITS is the number of addressable units to write. 8047 UNIT_SIZE is the length in bytes of an addressable unit. 8048 PACKET_FORMAT should be either 'X' or 'M', and indicates if we 8049 should send data as binary ('X'), or hex-encoded ('M'). 8050 8051 The function creates packet of the form 8052 <HEADER><ADDRESS>,<LENGTH>:<DATA> 8053 8054 where encoding of <DATA> is terminated by PACKET_FORMAT. 8055 8056 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma 8057 are omitted. 8058 8059 Return the transferred status, error or OK (an 8060 'enum target_xfer_status' value). Save the number of addressable units 8061 transferred in *XFERED_LEN_UNITS. Only transfer a single packet. 8062 8063 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an 8064 exchange between gdb and the stub could look like (?? in place of the 8065 checksum): 8066 8067 -> $m1000,4#?? 8068 <- aaaabbbbccccdddd 8069 8070 -> $M1000,3:eeeeffffeeee#?? 8071 <- OK 8072 8073 -> $m1000,4#?? 8074 <- eeeeffffeeeedddd */ 8075 8076static enum target_xfer_status 8077remote_write_bytes_aux (const char *header, CORE_ADDR memaddr, 8078 const gdb_byte *myaddr, ULONGEST len_units, 8079 int unit_size, ULONGEST *xfered_len_units, 8080 char packet_format, int use_length) 8081{ 8082 struct remote_state *rs = get_remote_state (); 8083 char *p; 8084 char *plen = NULL; 8085 int plenlen = 0; 8086 int todo_units; 8087 int units_written; 8088 int payload_capacity_bytes; 8089 int payload_length_bytes; 8090 8091 if (packet_format != 'X' && packet_format != 'M') 8092 internal_error (__FILE__, __LINE__, 8093 _("remote_write_bytes_aux: bad packet format")); 8094 8095 if (len_units == 0) 8096 return TARGET_XFER_EOF; 8097 8098 payload_capacity_bytes = get_memory_write_packet_size (); 8099 8100 /* The packet buffer will be large enough for the payload; 8101 get_memory_packet_size ensures this. */ 8102 rs->buf[0] = '\0'; 8103 8104 /* Compute the size of the actual payload by subtracting out the 8105 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */ 8106 8107 payload_capacity_bytes -= strlen ("$,:#NN"); 8108 if (!use_length) 8109 /* The comma won't be used. */ 8110 payload_capacity_bytes += 1; 8111 payload_capacity_bytes -= strlen (header); 8112 payload_capacity_bytes -= hexnumlen (memaddr); 8113 8114 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */ 8115 8116 strcat (rs->buf, header); 8117 p = rs->buf + strlen (header); 8118 8119 /* Compute a best guess of the number of bytes actually transfered. */ 8120 if (packet_format == 'X') 8121 { 8122 /* Best guess at number of bytes that will fit. */ 8123 todo_units = std::min (len_units, 8124 (ULONGEST) payload_capacity_bytes / unit_size); 8125 if (use_length) 8126 payload_capacity_bytes -= hexnumlen (todo_units); 8127 todo_units = std::min (todo_units, payload_capacity_bytes / unit_size); 8128 } 8129 else 8130 { 8131 /* Number of bytes that will fit. */ 8132 todo_units 8133 = std::min (len_units, 8134 (ULONGEST) (payload_capacity_bytes / unit_size) / 2); 8135 if (use_length) 8136 payload_capacity_bytes -= hexnumlen (todo_units); 8137 todo_units = std::min (todo_units, 8138 (payload_capacity_bytes / unit_size) / 2); 8139 } 8140 8141 if (todo_units <= 0) 8142 internal_error (__FILE__, __LINE__, 8143 _("minimum packet size too small to write data")); 8144 8145 /* If we already need another packet, then try to align the end 8146 of this packet to a useful boundary. */ 8147 if (todo_units > 2 * REMOTE_ALIGN_WRITES && todo_units < len_units) 8148 todo_units = align_for_efficient_write (todo_units, memaddr); 8149 8150 /* Append "<memaddr>". */ 8151 memaddr = remote_address_masked (memaddr); 8152 p += hexnumstr (p, (ULONGEST) memaddr); 8153 8154 if (use_length) 8155 { 8156 /* Append ",". */ 8157 *p++ = ','; 8158 8159 /* Append the length and retain its location and size. It may need to be 8160 adjusted once the packet body has been created. */ 8161 plen = p; 8162 plenlen = hexnumstr (p, (ULONGEST) todo_units); 8163 p += plenlen; 8164 } 8165 8166 /* Append ":". */ 8167 *p++ = ':'; 8168 *p = '\0'; 8169 8170 /* Append the packet body. */ 8171 if (packet_format == 'X') 8172 { 8173 /* Binary mode. Send target system values byte by byte, in 8174 increasing byte addresses. Only escape certain critical 8175 characters. */ 8176 payload_length_bytes = 8177 remote_escape_output (myaddr, todo_units, unit_size, (gdb_byte *) p, 8178 &units_written, payload_capacity_bytes); 8179 8180 /* If not all TODO units fit, then we'll need another packet. Make 8181 a second try to keep the end of the packet aligned. Don't do 8182 this if the packet is tiny. */ 8183 if (units_written < todo_units && units_written > 2 * REMOTE_ALIGN_WRITES) 8184 { 8185 int new_todo_units; 8186 8187 new_todo_units = align_for_efficient_write (units_written, memaddr); 8188 8189 if (new_todo_units != units_written) 8190 payload_length_bytes = 8191 remote_escape_output (myaddr, new_todo_units, unit_size, 8192 (gdb_byte *) p, &units_written, 8193 payload_capacity_bytes); 8194 } 8195 8196 p += payload_length_bytes; 8197 if (use_length && units_written < todo_units) 8198 { 8199 /* Escape chars have filled up the buffer prematurely, 8200 and we have actually sent fewer units than planned. 8201 Fix-up the length field of the packet. Use the same 8202 number of characters as before. */ 8203 plen += hexnumnstr (plen, (ULONGEST) units_written, 8204 plenlen); 8205 *plen = ':'; /* overwrite \0 from hexnumnstr() */ 8206 } 8207 } 8208 else 8209 { 8210 /* Normal mode: Send target system values byte by byte, in 8211 increasing byte addresses. Each byte is encoded as a two hex 8212 value. */ 8213 p += 2 * bin2hex (myaddr, p, todo_units * unit_size); 8214 units_written = todo_units; 8215 } 8216 8217 putpkt_binary (rs->buf, (int) (p - rs->buf)); 8218 getpkt (&rs->buf, &rs->buf_size, 0); 8219 8220 if (rs->buf[0] == 'E') 8221 return TARGET_XFER_E_IO; 8222 8223 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to 8224 send fewer units than we'd planned. */ 8225 *xfered_len_units = (ULONGEST) units_written; 8226 return TARGET_XFER_OK; 8227} 8228 8229/* Write memory data directly to the remote machine. 8230 This does not inform the data cache; the data cache uses this. 8231 MEMADDR is the address in the remote memory space. 8232 MYADDR is the address of the buffer in our space. 8233 LEN is the number of bytes. 8234 8235 Return the transferred status, error or OK (an 8236 'enum target_xfer_status' value). Save the number of bytes 8237 transferred in *XFERED_LEN. Only transfer a single packet. */ 8238 8239static enum target_xfer_status 8240remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, ULONGEST len, 8241 int unit_size, ULONGEST *xfered_len) 8242{ 8243 const char *packet_format = NULL; 8244 8245 /* Check whether the target supports binary download. */ 8246 check_binary_download (memaddr); 8247 8248 switch (packet_support (PACKET_X)) 8249 { 8250 case PACKET_ENABLE: 8251 packet_format = "X"; 8252 break; 8253 case PACKET_DISABLE: 8254 packet_format = "M"; 8255 break; 8256 case PACKET_SUPPORT_UNKNOWN: 8257 internal_error (__FILE__, __LINE__, 8258 _("remote_write_bytes: bad internal state")); 8259 default: 8260 internal_error (__FILE__, __LINE__, _("bad switch")); 8261 } 8262 8263 return remote_write_bytes_aux (packet_format, 8264 memaddr, myaddr, len, unit_size, xfered_len, 8265 packet_format[0], 1); 8266} 8267 8268/* Read memory data directly from the remote machine. 8269 This does not use the data cache; the data cache uses this. 8270 MEMADDR is the address in the remote memory space. 8271 MYADDR is the address of the buffer in our space. 8272 LEN_UNITS is the number of addressable memory units to read.. 8273 UNIT_SIZE is the length in bytes of an addressable unit. 8274 8275 Return the transferred status, error or OK (an 8276 'enum target_xfer_status' value). Save the number of bytes 8277 transferred in *XFERED_LEN_UNITS. 8278 8279 See the comment of remote_write_bytes_aux for an example of 8280 memory read/write exchange between gdb and the stub. */ 8281 8282static enum target_xfer_status 8283remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len_units, 8284 int unit_size, ULONGEST *xfered_len_units) 8285{ 8286 struct remote_state *rs = get_remote_state (); 8287 int buf_size_bytes; /* Max size of packet output buffer. */ 8288 char *p; 8289 int todo_units; 8290 int decoded_bytes; 8291 8292 buf_size_bytes = get_memory_read_packet_size (); 8293 /* The packet buffer will be large enough for the payload; 8294 get_memory_packet_size ensures this. */ 8295 8296 /* Number of units that will fit. */ 8297 todo_units = std::min (len_units, 8298 (ULONGEST) (buf_size_bytes / unit_size) / 2); 8299 8300 /* Construct "m"<memaddr>","<len>". */ 8301 memaddr = remote_address_masked (memaddr); 8302 p = rs->buf; 8303 *p++ = 'm'; 8304 p += hexnumstr (p, (ULONGEST) memaddr); 8305 *p++ = ','; 8306 p += hexnumstr (p, (ULONGEST) todo_units); 8307 *p = '\0'; 8308 putpkt (rs->buf); 8309 getpkt (&rs->buf, &rs->buf_size, 0); 8310 if (rs->buf[0] == 'E' 8311 && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2]) 8312 && rs->buf[3] == '\0') 8313 return TARGET_XFER_E_IO; 8314 /* Reply describes memory byte by byte, each byte encoded as two hex 8315 characters. */ 8316 p = rs->buf; 8317 decoded_bytes = hex2bin (p, myaddr, todo_units * unit_size); 8318 /* Return what we have. Let higher layers handle partial reads. */ 8319 *xfered_len_units = (ULONGEST) (decoded_bytes / unit_size); 8320 return TARGET_XFER_OK; 8321} 8322 8323/* Using the set of read-only target sections of remote, read live 8324 read-only memory. 8325 8326 For interface/parameters/return description see target.h, 8327 to_xfer_partial. */ 8328 8329static enum target_xfer_status 8330remote_xfer_live_readonly_partial (struct target_ops *ops, gdb_byte *readbuf, 8331 ULONGEST memaddr, ULONGEST len, 8332 int unit_size, ULONGEST *xfered_len) 8333{ 8334 struct target_section *secp; 8335 struct target_section_table *table; 8336 8337 secp = target_section_by_addr (ops, memaddr); 8338 if (secp != NULL 8339 && (bfd_get_section_flags (secp->the_bfd_section->owner, 8340 secp->the_bfd_section) 8341 & SEC_READONLY)) 8342 { 8343 struct target_section *p; 8344 ULONGEST memend = memaddr + len; 8345 8346 table = target_get_section_table (ops); 8347 8348 for (p = table->sections; p < table->sections_end; p++) 8349 { 8350 if (memaddr >= p->addr) 8351 { 8352 if (memend <= p->endaddr) 8353 { 8354 /* Entire transfer is within this section. */ 8355 return remote_read_bytes_1 (memaddr, readbuf, len, unit_size, 8356 xfered_len); 8357 } 8358 else if (memaddr >= p->endaddr) 8359 { 8360 /* This section ends before the transfer starts. */ 8361 continue; 8362 } 8363 else 8364 { 8365 /* This section overlaps the transfer. Just do half. */ 8366 len = p->endaddr - memaddr; 8367 return remote_read_bytes_1 (memaddr, readbuf, len, unit_size, 8368 xfered_len); 8369 } 8370 } 8371 } 8372 } 8373 8374 return TARGET_XFER_EOF; 8375} 8376 8377/* Similar to remote_read_bytes_1, but it reads from the remote stub 8378 first if the requested memory is unavailable in traceframe. 8379 Otherwise, fall back to remote_read_bytes_1. */ 8380 8381static enum target_xfer_status 8382remote_read_bytes (struct target_ops *ops, CORE_ADDR memaddr, 8383 gdb_byte *myaddr, ULONGEST len, int unit_size, 8384 ULONGEST *xfered_len) 8385{ 8386 if (len == 0) 8387 return TARGET_XFER_EOF; 8388 8389 if (get_traceframe_number () != -1) 8390 { 8391 VEC(mem_range_s) *available; 8392 8393 /* If we fail to get the set of available memory, then the 8394 target does not support querying traceframe info, and so we 8395 attempt reading from the traceframe anyway (assuming the 8396 target implements the old QTro packet then). */ 8397 if (traceframe_available_memory (&available, memaddr, len)) 8398 { 8399 struct cleanup *old_chain; 8400 8401 old_chain = make_cleanup (VEC_cleanup(mem_range_s), &available); 8402 8403 if (VEC_empty (mem_range_s, available) 8404 || VEC_index (mem_range_s, available, 0)->start != memaddr) 8405 { 8406 enum target_xfer_status res; 8407 8408 /* Don't read into the traceframe's available 8409 memory. */ 8410 if (!VEC_empty (mem_range_s, available)) 8411 { 8412 LONGEST oldlen = len; 8413 8414 len = VEC_index (mem_range_s, available, 0)->start - memaddr; 8415 gdb_assert (len <= oldlen); 8416 } 8417 8418 do_cleanups (old_chain); 8419 8420 /* This goes through the topmost target again. */ 8421 res = remote_xfer_live_readonly_partial (ops, myaddr, memaddr, 8422 len, unit_size, xfered_len); 8423 if (res == TARGET_XFER_OK) 8424 return TARGET_XFER_OK; 8425 else 8426 { 8427 /* No use trying further, we know some memory starting 8428 at MEMADDR isn't available. */ 8429 *xfered_len = len; 8430 return TARGET_XFER_UNAVAILABLE; 8431 } 8432 } 8433 8434 /* Don't try to read more than how much is available, in 8435 case the target implements the deprecated QTro packet to 8436 cater for older GDBs (the target's knowledge of read-only 8437 sections may be outdated by now). */ 8438 len = VEC_index (mem_range_s, available, 0)->length; 8439 8440 do_cleanups (old_chain); 8441 } 8442 } 8443 8444 return remote_read_bytes_1 (memaddr, myaddr, len, unit_size, xfered_len); 8445} 8446 8447 8448 8449/* Sends a packet with content determined by the printf format string 8450 FORMAT and the remaining arguments, then gets the reply. Returns 8451 whether the packet was a success, a failure, or unknown. */ 8452 8453static enum packet_result remote_send_printf (const char *format, ...) 8454 ATTRIBUTE_PRINTF (1, 2); 8455 8456static enum packet_result 8457remote_send_printf (const char *format, ...) 8458{ 8459 struct remote_state *rs = get_remote_state (); 8460 int max_size = get_remote_packet_size (); 8461 va_list ap; 8462 8463 va_start (ap, format); 8464 8465 rs->buf[0] = '\0'; 8466 if (vsnprintf (rs->buf, max_size, format, ap) >= max_size) 8467 internal_error (__FILE__, __LINE__, _("Too long remote packet.")); 8468 8469 if (putpkt (rs->buf) < 0) 8470 error (_("Communication problem with target.")); 8471 8472 rs->buf[0] = '\0'; 8473 getpkt (&rs->buf, &rs->buf_size, 0); 8474 8475 return packet_check_result (rs->buf); 8476} 8477 8478static void 8479restore_remote_timeout (void *p) 8480{ 8481 int value = *(int *)p; 8482 8483 remote_timeout = value; 8484} 8485 8486/* Flash writing can take quite some time. We'll set 8487 effectively infinite timeout for flash operations. 8488 In future, we'll need to decide on a better approach. */ 8489static const int remote_flash_timeout = 1000; 8490 8491static void 8492remote_flash_erase (struct target_ops *ops, 8493 ULONGEST address, LONGEST length) 8494{ 8495 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; 8496 int saved_remote_timeout = remote_timeout; 8497 enum packet_result ret; 8498 struct cleanup *back_to = make_cleanup (restore_remote_timeout, 8499 &saved_remote_timeout); 8500 8501 remote_timeout = remote_flash_timeout; 8502 8503 ret = remote_send_printf ("vFlashErase:%s,%s", 8504 phex (address, addr_size), 8505 phex (length, 4)); 8506 switch (ret) 8507 { 8508 case PACKET_UNKNOWN: 8509 error (_("Remote target does not support flash erase")); 8510 case PACKET_ERROR: 8511 error (_("Error erasing flash with vFlashErase packet")); 8512 default: 8513 break; 8514 } 8515 8516 do_cleanups (back_to); 8517} 8518 8519static enum target_xfer_status 8520remote_flash_write (struct target_ops *ops, ULONGEST address, 8521 ULONGEST length, ULONGEST *xfered_len, 8522 const gdb_byte *data) 8523{ 8524 int saved_remote_timeout = remote_timeout; 8525 enum target_xfer_status ret; 8526 struct cleanup *back_to = make_cleanup (restore_remote_timeout, 8527 &saved_remote_timeout); 8528 8529 remote_timeout = remote_flash_timeout; 8530 ret = remote_write_bytes_aux ("vFlashWrite:", address, data, length, 1, 8531 xfered_len,'X', 0); 8532 do_cleanups (back_to); 8533 8534 return ret; 8535} 8536 8537static void 8538remote_flash_done (struct target_ops *ops) 8539{ 8540 int saved_remote_timeout = remote_timeout; 8541 int ret; 8542 struct cleanup *back_to = make_cleanup (restore_remote_timeout, 8543 &saved_remote_timeout); 8544 8545 remote_timeout = remote_flash_timeout; 8546 ret = remote_send_printf ("vFlashDone"); 8547 do_cleanups (back_to); 8548 8549 switch (ret) 8550 { 8551 case PACKET_UNKNOWN: 8552 error (_("Remote target does not support vFlashDone")); 8553 case PACKET_ERROR: 8554 error (_("Error finishing flash operation")); 8555 default: 8556 break; 8557 } 8558} 8559 8560static void 8561remote_files_info (struct target_ops *ignore) 8562{ 8563 puts_filtered ("Debugging a target over a serial line.\n"); 8564} 8565 8566/* Stuff for dealing with the packets which are part of this protocol. 8567 See comment at top of file for details. */ 8568 8569/* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR 8570 error to higher layers. Called when a serial error is detected. 8571 The exception message is STRING, followed by a colon and a blank, 8572 the system error message for errno at function entry and final dot 8573 for output compatibility with throw_perror_with_name. */ 8574 8575static void 8576unpush_and_perror (const char *string) 8577{ 8578 int saved_errno = errno; 8579 8580 remote_unpush_target (); 8581 throw_error (TARGET_CLOSE_ERROR, "%s: %s.", string, 8582 safe_strerror (saved_errno)); 8583} 8584 8585/* Read a single character from the remote end. The current quit 8586 handler is overridden to avoid quitting in the middle of packet 8587 sequence, as that would break communication with the remote server. 8588 See remote_serial_quit_handler for more detail. */ 8589 8590static int 8591readchar (int timeout) 8592{ 8593 int ch; 8594 struct remote_state *rs = get_remote_state (); 8595 struct cleanup *old_chain; 8596 8597 old_chain = make_cleanup_override_quit_handler (remote_serial_quit_handler); 8598 8599 rs->got_ctrlc_during_io = 0; 8600 8601 ch = serial_readchar (rs->remote_desc, timeout); 8602 8603 if (rs->got_ctrlc_during_io) 8604 set_quit_flag (); 8605 8606 do_cleanups (old_chain); 8607 8608 if (ch >= 0) 8609 return ch; 8610 8611 switch ((enum serial_rc) ch) 8612 { 8613 case SERIAL_EOF: 8614 remote_unpush_target (); 8615 throw_error (TARGET_CLOSE_ERROR, _("Remote connection closed")); 8616 /* no return */ 8617 case SERIAL_ERROR: 8618 unpush_and_perror (_("Remote communication error. " 8619 "Target disconnected.")); 8620 /* no return */ 8621 case SERIAL_TIMEOUT: 8622 break; 8623 } 8624 return ch; 8625} 8626 8627/* Wrapper for serial_write that closes the target and throws if 8628 writing fails. The current quit handler is overridden to avoid 8629 quitting in the middle of packet sequence, as that would break 8630 communication with the remote server. See 8631 remote_serial_quit_handler for more detail. */ 8632 8633static void 8634remote_serial_write (const char *str, int len) 8635{ 8636 struct remote_state *rs = get_remote_state (); 8637 struct cleanup *old_chain; 8638 8639 old_chain = make_cleanup_override_quit_handler (remote_serial_quit_handler); 8640 8641 rs->got_ctrlc_during_io = 0; 8642 8643 if (serial_write (rs->remote_desc, str, len)) 8644 { 8645 unpush_and_perror (_("Remote communication error. " 8646 "Target disconnected.")); 8647 } 8648 8649 if (rs->got_ctrlc_during_io) 8650 set_quit_flag (); 8651 8652 do_cleanups (old_chain); 8653} 8654 8655/* Send the command in *BUF to the remote machine, and read the reply 8656 into *BUF. Report an error if we get an error reply. Resize 8657 *BUF using xrealloc if necessary to hold the result, and update 8658 *SIZEOF_BUF. */ 8659 8660static void 8661remote_send (char **buf, 8662 long *sizeof_buf) 8663{ 8664 putpkt (*buf); 8665 getpkt (buf, sizeof_buf, 0); 8666 8667 if ((*buf)[0] == 'E') 8668 error (_("Remote failure reply: %s"), *buf); 8669} 8670 8671/* Return a string representing an escaped version of BUF, of len N. 8672 E.g. \n is converted to \\n, \t to \\t, etc. */ 8673 8674static std::string 8675escape_buffer (const char *buf, int n) 8676{ 8677 string_file stb; 8678 8679 stb.putstrn (buf, n, '\\'); 8680 return std::move (stb.string ()); 8681} 8682 8683/* Display a null-terminated packet on stdout, for debugging, using C 8684 string notation. */ 8685 8686static void 8687print_packet (const char *buf) 8688{ 8689 puts_filtered ("\""); 8690 fputstr_filtered (buf, '"', gdb_stdout); 8691 puts_filtered ("\""); 8692} 8693 8694int 8695putpkt (const char *buf) 8696{ 8697 return putpkt_binary (buf, strlen (buf)); 8698} 8699 8700/* Send a packet to the remote machine, with error checking. The data 8701 of the packet is in BUF. The string in BUF can be at most 8702 get_remote_packet_size () - 5 to account for the $, # and checksum, 8703 and for a possible /0 if we are debugging (remote_debug) and want 8704 to print the sent packet as a string. */ 8705 8706static int 8707putpkt_binary (const char *buf, int cnt) 8708{ 8709 struct remote_state *rs = get_remote_state (); 8710 int i; 8711 unsigned char csum = 0; 8712 char *buf2 = (char *) xmalloc (cnt + 6); 8713 struct cleanup *old_chain = make_cleanup (xfree, buf2); 8714 8715 int ch; 8716 int tcount = 0; 8717 char *p; 8718 8719 /* Catch cases like trying to read memory or listing threads while 8720 we're waiting for a stop reply. The remote server wouldn't be 8721 ready to handle this request, so we'd hang and timeout. We don't 8722 have to worry about this in synchronous mode, because in that 8723 case it's not possible to issue a command while the target is 8724 running. This is not a problem in non-stop mode, because in that 8725 case, the stub is always ready to process serial input. */ 8726 if (!target_is_non_stop_p () 8727 && target_is_async_p () 8728 && rs->waiting_for_stop_reply) 8729 { 8730 error (_("Cannot execute this command while the target is running.\n" 8731 "Use the \"interrupt\" command to stop the target\n" 8732 "and then try again.")); 8733 } 8734 8735 /* We're sending out a new packet. Make sure we don't look at a 8736 stale cached response. */ 8737 rs->cached_wait_status = 0; 8738 8739 /* Copy the packet into buffer BUF2, encapsulating it 8740 and giving it a checksum. */ 8741 8742 p = buf2; 8743 *p++ = '$'; 8744 8745 for (i = 0; i < cnt; i++) 8746 { 8747 csum += buf[i]; 8748 *p++ = buf[i]; 8749 } 8750 *p++ = '#'; 8751 *p++ = tohex ((csum >> 4) & 0xf); 8752 *p++ = tohex (csum & 0xf); 8753 8754 /* Send it over and over until we get a positive ack. */ 8755 8756 while (1) 8757 { 8758 int started_error_output = 0; 8759 8760 if (remote_debug) 8761 { 8762 *p = '\0'; 8763 8764 int len = (int) (p - buf2); 8765 8766 std::string str 8767 = escape_buffer (buf2, std::min (len, REMOTE_DEBUG_MAX_CHAR)); 8768 8769 fprintf_unfiltered (gdb_stdlog, "Sending packet: %s", str.c_str ()); 8770 8771 if (str.length () > REMOTE_DEBUG_MAX_CHAR) 8772 { 8773 fprintf_unfiltered (gdb_stdlog, "[%zu bytes omitted]", 8774 str.length () - REMOTE_DEBUG_MAX_CHAR); 8775 } 8776 8777 fprintf_unfiltered (gdb_stdlog, "..."); 8778 8779 gdb_flush (gdb_stdlog); 8780 } 8781 remote_serial_write (buf2, p - buf2); 8782 8783 /* If this is a no acks version of the remote protocol, send the 8784 packet and move on. */ 8785 if (rs->noack_mode) 8786 break; 8787 8788 /* Read until either a timeout occurs (-2) or '+' is read. 8789 Handle any notification that arrives in the mean time. */ 8790 while (1) 8791 { 8792 ch = readchar (remote_timeout); 8793 8794 if (remote_debug) 8795 { 8796 switch (ch) 8797 { 8798 case '+': 8799 case '-': 8800 case SERIAL_TIMEOUT: 8801 case '$': 8802 case '%': 8803 if (started_error_output) 8804 { 8805 putchar_unfiltered ('\n'); 8806 started_error_output = 0; 8807 } 8808 } 8809 } 8810 8811 switch (ch) 8812 { 8813 case '+': 8814 if (remote_debug) 8815 fprintf_unfiltered (gdb_stdlog, "Ack\n"); 8816 do_cleanups (old_chain); 8817 return 1; 8818 case '-': 8819 if (remote_debug) 8820 fprintf_unfiltered (gdb_stdlog, "Nak\n"); 8821 /* FALLTHROUGH */ 8822 case SERIAL_TIMEOUT: 8823 tcount++; 8824 if (tcount > 3) 8825 { 8826 do_cleanups (old_chain); 8827 return 0; 8828 } 8829 break; /* Retransmit buffer. */ 8830 case '$': 8831 { 8832 if (remote_debug) 8833 fprintf_unfiltered (gdb_stdlog, 8834 "Packet instead of Ack, ignoring it\n"); 8835 /* It's probably an old response sent because an ACK 8836 was lost. Gobble up the packet and ack it so it 8837 doesn't get retransmitted when we resend this 8838 packet. */ 8839 skip_frame (); 8840 remote_serial_write ("+", 1); 8841 continue; /* Now, go look for +. */ 8842 } 8843 8844 case '%': 8845 { 8846 int val; 8847 8848 /* If we got a notification, handle it, and go back to looking 8849 for an ack. */ 8850 /* We've found the start of a notification. Now 8851 collect the data. */ 8852 val = read_frame (&rs->buf, &rs->buf_size); 8853 if (val >= 0) 8854 { 8855 if (remote_debug) 8856 { 8857 std::string str = escape_buffer (rs->buf, val); 8858 8859 fprintf_unfiltered (gdb_stdlog, 8860 " Notification received: %s\n", 8861 str.c_str ()); 8862 } 8863 handle_notification (rs->notif_state, rs->buf); 8864 /* We're in sync now, rewait for the ack. */ 8865 tcount = 0; 8866 } 8867 else 8868 { 8869 if (remote_debug) 8870 { 8871 if (!started_error_output) 8872 { 8873 started_error_output = 1; 8874 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: "); 8875 } 8876 fputc_unfiltered (ch & 0177, gdb_stdlog); 8877 fprintf_unfiltered (gdb_stdlog, "%s", rs->buf); 8878 } 8879 } 8880 continue; 8881 } 8882 /* fall-through */ 8883 default: 8884 if (remote_debug) 8885 { 8886 if (!started_error_output) 8887 { 8888 started_error_output = 1; 8889 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: "); 8890 } 8891 fputc_unfiltered (ch & 0177, gdb_stdlog); 8892 } 8893 continue; 8894 } 8895 break; /* Here to retransmit. */ 8896 } 8897 8898#if 0 8899 /* This is wrong. If doing a long backtrace, the user should be 8900 able to get out next time we call QUIT, without anything as 8901 violent as interrupt_query. If we want to provide a way out of 8902 here without getting to the next QUIT, it should be based on 8903 hitting ^C twice as in remote_wait. */ 8904 if (quit_flag) 8905 { 8906 quit_flag = 0; 8907 interrupt_query (); 8908 } 8909#endif 8910 } 8911 8912 do_cleanups (old_chain); 8913 return 0; 8914} 8915 8916/* Come here after finding the start of a frame when we expected an 8917 ack. Do our best to discard the rest of this packet. */ 8918 8919static void 8920skip_frame (void) 8921{ 8922 int c; 8923 8924 while (1) 8925 { 8926 c = readchar (remote_timeout); 8927 switch (c) 8928 { 8929 case SERIAL_TIMEOUT: 8930 /* Nothing we can do. */ 8931 return; 8932 case '#': 8933 /* Discard the two bytes of checksum and stop. */ 8934 c = readchar (remote_timeout); 8935 if (c >= 0) 8936 c = readchar (remote_timeout); 8937 8938 return; 8939 case '*': /* Run length encoding. */ 8940 /* Discard the repeat count. */ 8941 c = readchar (remote_timeout); 8942 if (c < 0) 8943 return; 8944 break; 8945 default: 8946 /* A regular character. */ 8947 break; 8948 } 8949 } 8950} 8951 8952/* Come here after finding the start of the frame. Collect the rest 8953 into *BUF, verifying the checksum, length, and handling run-length 8954 compression. NUL terminate the buffer. If there is not enough room, 8955 expand *BUF using xrealloc. 8956 8957 Returns -1 on error, number of characters in buffer (ignoring the 8958 trailing NULL) on success. (could be extended to return one of the 8959 SERIAL status indications). */ 8960 8961static long 8962read_frame (char **buf_p, 8963 long *sizeof_buf) 8964{ 8965 unsigned char csum; 8966 long bc; 8967 int c; 8968 char *buf = *buf_p; 8969 struct remote_state *rs = get_remote_state (); 8970 8971 csum = 0; 8972 bc = 0; 8973 8974 while (1) 8975 { 8976 c = readchar (remote_timeout); 8977 switch (c) 8978 { 8979 case SERIAL_TIMEOUT: 8980 if (remote_debug) 8981 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog); 8982 return -1; 8983 case '$': 8984 if (remote_debug) 8985 fputs_filtered ("Saw new packet start in middle of old one\n", 8986 gdb_stdlog); 8987 return -1; /* Start a new packet, count retries. */ 8988 case '#': 8989 { 8990 unsigned char pktcsum; 8991 int check_0 = 0; 8992 int check_1 = 0; 8993 8994 buf[bc] = '\0'; 8995 8996 check_0 = readchar (remote_timeout); 8997 if (check_0 >= 0) 8998 check_1 = readchar (remote_timeout); 8999 9000 if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT) 9001 { 9002 if (remote_debug) 9003 fputs_filtered ("Timeout in checksum, retrying\n", 9004 gdb_stdlog); 9005 return -1; 9006 } 9007 else if (check_0 < 0 || check_1 < 0) 9008 { 9009 if (remote_debug) 9010 fputs_filtered ("Communication error in checksum\n", 9011 gdb_stdlog); 9012 return -1; 9013 } 9014 9015 /* Don't recompute the checksum; with no ack packets we 9016 don't have any way to indicate a packet retransmission 9017 is necessary. */ 9018 if (rs->noack_mode) 9019 return bc; 9020 9021 pktcsum = (fromhex (check_0) << 4) | fromhex (check_1); 9022 if (csum == pktcsum) 9023 return bc; 9024 9025 if (remote_debug) 9026 { 9027 std::string str = escape_buffer (buf, bc); 9028 9029 fprintf_unfiltered (gdb_stdlog, 9030 "Bad checksum, sentsum=0x%x, " 9031 "csum=0x%x, buf=%s\n", 9032 pktcsum, csum, str.c_str ()); 9033 } 9034 /* Number of characters in buffer ignoring trailing 9035 NULL. */ 9036 return -1; 9037 } 9038 case '*': /* Run length encoding. */ 9039 { 9040 int repeat; 9041 9042 csum += c; 9043 c = readchar (remote_timeout); 9044 csum += c; 9045 repeat = c - ' ' + 3; /* Compute repeat count. */ 9046 9047 /* The character before ``*'' is repeated. */ 9048 9049 if (repeat > 0 && repeat <= 255 && bc > 0) 9050 { 9051 if (bc + repeat - 1 >= *sizeof_buf - 1) 9052 { 9053 /* Make some more room in the buffer. */ 9054 *sizeof_buf += repeat; 9055 *buf_p = (char *) xrealloc (*buf_p, *sizeof_buf); 9056 buf = *buf_p; 9057 } 9058 9059 memset (&buf[bc], buf[bc - 1], repeat); 9060 bc += repeat; 9061 continue; 9062 } 9063 9064 buf[bc] = '\0'; 9065 printf_filtered (_("Invalid run length encoding: %s\n"), buf); 9066 return -1; 9067 } 9068 default: 9069 if (bc >= *sizeof_buf - 1) 9070 { 9071 /* Make some more room in the buffer. */ 9072 *sizeof_buf *= 2; 9073 *buf_p = (char *) xrealloc (*buf_p, *sizeof_buf); 9074 buf = *buf_p; 9075 } 9076 9077 buf[bc++] = c; 9078 csum += c; 9079 continue; 9080 } 9081 } 9082} 9083 9084/* Read a packet from the remote machine, with error checking, and 9085 store it in *BUF. Resize *BUF using xrealloc if necessary to hold 9086 the result, and update *SIZEOF_BUF. If FOREVER, wait forever 9087 rather than timing out; this is used (in synchronous mode) to wait 9088 for a target that is is executing user code to stop. */ 9089/* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we 9090 don't have to change all the calls to getpkt to deal with the 9091 return value, because at the moment I don't know what the right 9092 thing to do it for those. */ 9093void 9094getpkt (char **buf, 9095 long *sizeof_buf, 9096 int forever) 9097{ 9098 getpkt_sane (buf, sizeof_buf, forever); 9099} 9100 9101 9102/* Read a packet from the remote machine, with error checking, and 9103 store it in *BUF. Resize *BUF using xrealloc if necessary to hold 9104 the result, and update *SIZEOF_BUF. If FOREVER, wait forever 9105 rather than timing out; this is used (in synchronous mode) to wait 9106 for a target that is is executing user code to stop. If FOREVER == 9107 0, this function is allowed to time out gracefully and return an 9108 indication of this to the caller. Otherwise return the number of 9109 bytes read. If EXPECTING_NOTIF, consider receiving a notification 9110 enough reason to return to the caller. *IS_NOTIF is an output 9111 boolean that indicates whether *BUF holds a notification or not 9112 (a regular packet). */ 9113 9114static int 9115getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, int forever, 9116 int expecting_notif, int *is_notif) 9117{ 9118 struct remote_state *rs = get_remote_state (); 9119 int c; 9120 int tries; 9121 int timeout; 9122 int val = -1; 9123 9124 /* We're reading a new response. Make sure we don't look at a 9125 previously cached response. */ 9126 rs->cached_wait_status = 0; 9127 9128 strcpy (*buf, "timeout"); 9129 9130 if (forever) 9131 timeout = watchdog > 0 ? watchdog : -1; 9132 else if (expecting_notif) 9133 timeout = 0; /* There should already be a char in the buffer. If 9134 not, bail out. */ 9135 else 9136 timeout = remote_timeout; 9137 9138#define MAX_TRIES 3 9139 9140 /* Process any number of notifications, and then return when 9141 we get a packet. */ 9142 for (;;) 9143 { 9144 /* If we get a timeout or bad checksum, retry up to MAX_TRIES 9145 times. */ 9146 for (tries = 1; tries <= MAX_TRIES; tries++) 9147 { 9148 /* This can loop forever if the remote side sends us 9149 characters continuously, but if it pauses, we'll get 9150 SERIAL_TIMEOUT from readchar because of timeout. Then 9151 we'll count that as a retry. 9152 9153 Note that even when forever is set, we will only wait 9154 forever prior to the start of a packet. After that, we 9155 expect characters to arrive at a brisk pace. They should 9156 show up within remote_timeout intervals. */ 9157 do 9158 c = readchar (timeout); 9159 while (c != SERIAL_TIMEOUT && c != '$' && c != '%'); 9160 9161 if (c == SERIAL_TIMEOUT) 9162 { 9163 if (expecting_notif) 9164 return -1; /* Don't complain, it's normal to not get 9165 anything in this case. */ 9166 9167 if (forever) /* Watchdog went off? Kill the target. */ 9168 { 9169 remote_unpush_target (); 9170 throw_error (TARGET_CLOSE_ERROR, 9171 _("Watchdog timeout has expired. " 9172 "Target detached.")); 9173 } 9174 if (remote_debug) 9175 fputs_filtered ("Timed out.\n", gdb_stdlog); 9176 } 9177 else 9178 { 9179 /* We've found the start of a packet or notification. 9180 Now collect the data. */ 9181 val = read_frame (buf, sizeof_buf); 9182 if (val >= 0) 9183 break; 9184 } 9185 9186 remote_serial_write ("-", 1); 9187 } 9188 9189 if (tries > MAX_TRIES) 9190 { 9191 /* We have tried hard enough, and just can't receive the 9192 packet/notification. Give up. */ 9193 printf_unfiltered (_("Ignoring packet error, continuing...\n")); 9194 9195 /* Skip the ack char if we're in no-ack mode. */ 9196 if (!rs->noack_mode) 9197 remote_serial_write ("+", 1); 9198 return -1; 9199 } 9200 9201 /* If we got an ordinary packet, return that to our caller. */ 9202 if (c == '$') 9203 { 9204 if (remote_debug) 9205 { 9206 std::string str 9207 = escape_buffer (*buf, 9208 std::min (val, REMOTE_DEBUG_MAX_CHAR)); 9209 9210 fprintf_unfiltered (gdb_stdlog, "Packet received: %s", 9211 str.c_str ()); 9212 9213 if (str.length () > REMOTE_DEBUG_MAX_CHAR) 9214 { 9215 fprintf_unfiltered (gdb_stdlog, "[%zu bytes omitted]", 9216 str.length () - REMOTE_DEBUG_MAX_CHAR); 9217 } 9218 9219 fprintf_unfiltered (gdb_stdlog, "\n"); 9220 } 9221 9222 /* Skip the ack char if we're in no-ack mode. */ 9223 if (!rs->noack_mode) 9224 remote_serial_write ("+", 1); 9225 if (is_notif != NULL) 9226 *is_notif = 0; 9227 return val; 9228 } 9229 9230 /* If we got a notification, handle it, and go back to looking 9231 for a packet. */ 9232 else 9233 { 9234 gdb_assert (c == '%'); 9235 9236 if (remote_debug) 9237 { 9238 std::string str = escape_buffer (*buf, val); 9239 9240 fprintf_unfiltered (gdb_stdlog, 9241 " Notification received: %s\n", 9242 str.c_str ()); 9243 } 9244 if (is_notif != NULL) 9245 *is_notif = 1; 9246 9247 handle_notification (rs->notif_state, *buf); 9248 9249 /* Notifications require no acknowledgement. */ 9250 9251 if (expecting_notif) 9252 return val; 9253 } 9254 } 9255} 9256 9257static int 9258getpkt_sane (char **buf, long *sizeof_buf, int forever) 9259{ 9260 return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 0, NULL); 9261} 9262 9263static int 9264getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever, 9265 int *is_notif) 9266{ 9267 return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 1, 9268 is_notif); 9269} 9270 9271/* Check whether EVENT is a fork event for the process specified 9272 by the pid passed in DATA, and if it is, kill the fork child. */ 9273 9274static int 9275kill_child_of_pending_fork (QUEUE (stop_reply_p) *q, 9276 QUEUE_ITER (stop_reply_p) *iter, 9277 stop_reply_p event, 9278 void *data) 9279{ 9280 struct queue_iter_param *param = (struct queue_iter_param *) data; 9281 int parent_pid = *(int *) param->input; 9282 9283 if (is_pending_fork_parent (&event->ws, parent_pid, event->ptid)) 9284 { 9285 struct remote_state *rs = get_remote_state (); 9286 int child_pid = ptid_get_pid (event->ws.value.related_pid); 9287 int res; 9288 9289 res = remote_vkill (child_pid, rs); 9290 if (res != 0) 9291 error (_("Can't kill fork child process %d"), child_pid); 9292 } 9293 9294 return 1; 9295} 9296 9297/* Kill any new fork children of process PID that haven't been 9298 processed by follow_fork. */ 9299 9300static void 9301kill_new_fork_children (int pid, struct remote_state *rs) 9302{ 9303 struct thread_info *thread; 9304 struct notif_client *notif = ¬if_client_stop; 9305 struct queue_iter_param param; 9306 9307 /* Kill the fork child threads of any threads in process PID 9308 that are stopped at a fork event. */ 9309 ALL_NON_EXITED_THREADS (thread) 9310 { 9311 struct target_waitstatus *ws = &thread->pending_follow; 9312 9313 if (is_pending_fork_parent (ws, pid, thread->ptid)) 9314 { 9315 struct remote_state *rs = get_remote_state (); 9316 int child_pid = ptid_get_pid (ws->value.related_pid); 9317 int res; 9318 9319 res = remote_vkill (child_pid, rs); 9320 if (res != 0) 9321 error (_("Can't kill fork child process %d"), child_pid); 9322 } 9323 } 9324 9325 /* Check for any pending fork events (not reported or processed yet) 9326 in process PID and kill those fork child threads as well. */ 9327 remote_notif_get_pending_events (notif); 9328 param.input = &pid; 9329 param.output = NULL; 9330 QUEUE_iterate (stop_reply_p, stop_reply_queue, 9331 kill_child_of_pending_fork, ¶m); 9332} 9333 9334 9335/* Target hook to kill the current inferior. */ 9336 9337static void 9338remote_kill (struct target_ops *ops) 9339{ 9340 int res = -1; 9341 int pid = ptid_get_pid (inferior_ptid); 9342 struct remote_state *rs = get_remote_state (); 9343 9344 if (packet_support (PACKET_vKill) != PACKET_DISABLE) 9345 { 9346 /* If we're stopped while forking and we haven't followed yet, 9347 kill the child task. We need to do this before killing the 9348 parent task because if this is a vfork then the parent will 9349 be sleeping. */ 9350 kill_new_fork_children (pid, rs); 9351 9352 res = remote_vkill (pid, rs); 9353 if (res == 0) 9354 { 9355 target_mourn_inferior (inferior_ptid); 9356 return; 9357 } 9358 } 9359 9360 /* If we are in 'target remote' mode and we are killing the only 9361 inferior, then we will tell gdbserver to exit and unpush the 9362 target. */ 9363 if (res == -1 && !remote_multi_process_p (rs) 9364 && number_of_live_inferiors () == 1) 9365 { 9366 remote_kill_k (); 9367 9368 /* We've killed the remote end, we get to mourn it. If we are 9369 not in extended mode, mourning the inferior also unpushes 9370 remote_ops from the target stack, which closes the remote 9371 connection. */ 9372 target_mourn_inferior (inferior_ptid); 9373 9374 return; 9375 } 9376 9377 error (_("Can't kill process")); 9378} 9379 9380/* Send a kill request to the target using the 'vKill' packet. */ 9381 9382static int 9383remote_vkill (int pid, struct remote_state *rs) 9384{ 9385 if (packet_support (PACKET_vKill) == PACKET_DISABLE) 9386 return -1; 9387 9388 /* Tell the remote target to detach. */ 9389 xsnprintf (rs->buf, get_remote_packet_size (), "vKill;%x", pid); 9390 putpkt (rs->buf); 9391 getpkt (&rs->buf, &rs->buf_size, 0); 9392 9393 switch (packet_ok (rs->buf, 9394 &remote_protocol_packets[PACKET_vKill])) 9395 { 9396 case PACKET_OK: 9397 return 0; 9398 case PACKET_ERROR: 9399 return 1; 9400 case PACKET_UNKNOWN: 9401 return -1; 9402 default: 9403 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok")); 9404 } 9405} 9406 9407/* Send a kill request to the target using the 'k' packet. */ 9408 9409static void 9410remote_kill_k (void) 9411{ 9412 /* Catch errors so the user can quit from gdb even when we 9413 aren't on speaking terms with the remote system. */ 9414 TRY 9415 { 9416 putpkt ("k"); 9417 } 9418 CATCH (ex, RETURN_MASK_ERROR) 9419 { 9420 if (ex.error == TARGET_CLOSE_ERROR) 9421 { 9422 /* If we got an (EOF) error that caused the target 9423 to go away, then we're done, that's what we wanted. 9424 "k" is susceptible to cause a premature EOF, given 9425 that the remote server isn't actually required to 9426 reply to "k", and it can happen that it doesn't 9427 even get to reply ACK to the "k". */ 9428 return; 9429 } 9430 9431 /* Otherwise, something went wrong. We didn't actually kill 9432 the target. Just propagate the exception, and let the 9433 user or higher layers decide what to do. */ 9434 throw_exception (ex); 9435 } 9436 END_CATCH 9437} 9438 9439static void 9440remote_mourn (struct target_ops *target) 9441{ 9442 struct remote_state *rs = get_remote_state (); 9443 9444 /* In 'target remote' mode with one inferior, we close the connection. */ 9445 if (!rs->extended && number_of_live_inferiors () <= 1) 9446 { 9447 unpush_target (target); 9448 9449 /* remote_close takes care of doing most of the clean up. */ 9450 generic_mourn_inferior (); 9451 return; 9452 } 9453 9454 /* In case we got here due to an error, but we're going to stay 9455 connected. */ 9456 rs->waiting_for_stop_reply = 0; 9457 9458 /* If the current general thread belonged to the process we just 9459 detached from or has exited, the remote side current general 9460 thread becomes undefined. Considering a case like this: 9461 9462 - We just got here due to a detach. 9463 - The process that we're detaching from happens to immediately 9464 report a global breakpoint being hit in non-stop mode, in the 9465 same thread we had selected before. 9466 - GDB attaches to this process again. 9467 - This event happens to be the next event we handle. 9468 9469 GDB would consider that the current general thread didn't need to 9470 be set on the stub side (with Hg), since for all it knew, 9471 GENERAL_THREAD hadn't changed. 9472 9473 Notice that although in all-stop mode, the remote server always 9474 sets the current thread to the thread reporting the stop event, 9475 that doesn't happen in non-stop mode; in non-stop, the stub *must 9476 not* change the current thread when reporting a breakpoint hit, 9477 due to the decoupling of event reporting and event handling. 9478 9479 To keep things simple, we always invalidate our notion of the 9480 current thread. */ 9481 record_currthread (rs, minus_one_ptid); 9482 9483 /* Call common code to mark the inferior as not running. */ 9484 generic_mourn_inferior (); 9485 9486 if (!have_inferiors ()) 9487 { 9488 if (!remote_multi_process_p (rs)) 9489 { 9490 /* Check whether the target is running now - some remote stubs 9491 automatically restart after kill. */ 9492 putpkt ("?"); 9493 getpkt (&rs->buf, &rs->buf_size, 0); 9494 9495 if (rs->buf[0] == 'S' || rs->buf[0] == 'T') 9496 { 9497 /* Assume that the target has been restarted. Set 9498 inferior_ptid so that bits of core GDB realizes 9499 there's something here, e.g., so that the user can 9500 say "kill" again. */ 9501 inferior_ptid = magic_null_ptid; 9502 } 9503 } 9504 } 9505} 9506 9507static int 9508extended_remote_supports_disable_randomization (struct target_ops *self) 9509{ 9510 return packet_support (PACKET_QDisableRandomization) == PACKET_ENABLE; 9511} 9512 9513static void 9514extended_remote_disable_randomization (int val) 9515{ 9516 struct remote_state *rs = get_remote_state (); 9517 char *reply; 9518 9519 xsnprintf (rs->buf, get_remote_packet_size (), "QDisableRandomization:%x", 9520 val); 9521 putpkt (rs->buf); 9522 reply = remote_get_noisy_reply (&target_buf, &target_buf_size); 9523 if (*reply == '\0') 9524 error (_("Target does not support QDisableRandomization.")); 9525 if (strcmp (reply, "OK") != 0) 9526 error (_("Bogus QDisableRandomization reply from target: %s"), reply); 9527} 9528 9529static int 9530extended_remote_run (const std::string &args) 9531{ 9532 struct remote_state *rs = get_remote_state (); 9533 int len; 9534 const char *remote_exec_file = get_remote_exec_file (); 9535 9536 /* If the user has disabled vRun support, or we have detected that 9537 support is not available, do not try it. */ 9538 if (packet_support (PACKET_vRun) == PACKET_DISABLE) 9539 return -1; 9540 9541 strcpy (rs->buf, "vRun;"); 9542 len = strlen (rs->buf); 9543 9544 if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ()) 9545 error (_("Remote file name too long for run packet")); 9546 len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf + len, 9547 strlen (remote_exec_file)); 9548 9549 if (!args.empty ()) 9550 { 9551 struct cleanup *back_to; 9552 int i; 9553 char **argv; 9554 9555 argv = gdb_buildargv (args.c_str ()); 9556 back_to = make_cleanup_freeargv (argv); 9557 for (i = 0; argv[i] != NULL; i++) 9558 { 9559 if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ()) 9560 error (_("Argument list too long for run packet")); 9561 rs->buf[len++] = ';'; 9562 len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf + len, 9563 strlen (argv[i])); 9564 } 9565 do_cleanups (back_to); 9566 } 9567 9568 rs->buf[len++] = '\0'; 9569 9570 putpkt (rs->buf); 9571 getpkt (&rs->buf, &rs->buf_size, 0); 9572 9573 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun])) 9574 { 9575 case PACKET_OK: 9576 /* We have a wait response. All is well. */ 9577 return 0; 9578 case PACKET_UNKNOWN: 9579 return -1; 9580 case PACKET_ERROR: 9581 if (remote_exec_file[0] == '\0') 9582 error (_("Running the default executable on the remote target failed; " 9583 "try \"set remote exec-file\"?")); 9584 else 9585 error (_("Running \"%s\" on the remote target failed"), 9586 remote_exec_file); 9587 default: 9588 gdb_assert_not_reached (_("bad switch")); 9589 } 9590} 9591 9592/* In the extended protocol we want to be able to do things like 9593 "run" and have them basically work as expected. So we need 9594 a special create_inferior function. We support changing the 9595 executable file and the command line arguments, but not the 9596 environment. */ 9597 9598static void 9599extended_remote_create_inferior (struct target_ops *ops, 9600 const char *exec_file, 9601 const std::string &args, 9602 char **env, int from_tty) 9603{ 9604 int run_worked; 9605 char *stop_reply; 9606 struct remote_state *rs = get_remote_state (); 9607 const char *remote_exec_file = get_remote_exec_file (); 9608 9609 /* If running asynchronously, register the target file descriptor 9610 with the event loop. */ 9611 if (target_can_async_p ()) 9612 target_async (1); 9613 9614 /* Disable address space randomization if requested (and supported). */ 9615 if (extended_remote_supports_disable_randomization (ops)) 9616 extended_remote_disable_randomization (disable_randomization); 9617 9618 /* Now restart the remote server. */ 9619 run_worked = extended_remote_run (args) != -1; 9620 if (!run_worked) 9621 { 9622 /* vRun was not supported. Fail if we need it to do what the 9623 user requested. */ 9624 if (remote_exec_file[0]) 9625 error (_("Remote target does not support \"set remote exec-file\"")); 9626 if (!args.empty ()) 9627 error (_("Remote target does not support \"set args\" or run <ARGS>")); 9628 9629 /* Fall back to "R". */ 9630 extended_remote_restart (); 9631 } 9632 9633 if (!have_inferiors ()) 9634 { 9635 /* Clean up from the last time we ran, before we mark the target 9636 running again. This will mark breakpoints uninserted, and 9637 get_offsets may insert breakpoints. */ 9638 init_thread_list (); 9639 init_wait_for_inferior (); 9640 } 9641 9642 /* vRun's success return is a stop reply. */ 9643 stop_reply = run_worked ? rs->buf : NULL; 9644 add_current_inferior_and_thread (stop_reply); 9645 9646 /* Get updated offsets, if the stub uses qOffsets. */ 9647 get_offsets (); 9648} 9649 9650 9651/* Given a location's target info BP_TGT and the packet buffer BUF, output 9652 the list of conditions (in agent expression bytecode format), if any, the 9653 target needs to evaluate. The output is placed into the packet buffer 9654 started from BUF and ended at BUF_END. */ 9655 9656static int 9657remote_add_target_side_condition (struct gdbarch *gdbarch, 9658 struct bp_target_info *bp_tgt, char *buf, 9659 char *buf_end) 9660{ 9661 if (bp_tgt->conditions.empty ()) 9662 return 0; 9663 9664 buf += strlen (buf); 9665 xsnprintf (buf, buf_end - buf, "%s", ";"); 9666 buf++; 9667 9668 /* Send conditions to the target. */ 9669 for (agent_expr *aexpr : bp_tgt->conditions) 9670 { 9671 xsnprintf (buf, buf_end - buf, "X%x,", aexpr->len); 9672 buf += strlen (buf); 9673 for (int i = 0; i < aexpr->len; ++i) 9674 buf = pack_hex_byte (buf, aexpr->buf[i]); 9675 *buf = '\0'; 9676 } 9677 return 0; 9678} 9679 9680static void 9681remote_add_target_side_commands (struct gdbarch *gdbarch, 9682 struct bp_target_info *bp_tgt, char *buf) 9683{ 9684 if (bp_tgt->tcommands.empty ()) 9685 return; 9686 9687 buf += strlen (buf); 9688 9689 sprintf (buf, ";cmds:%x,", bp_tgt->persist); 9690 buf += strlen (buf); 9691 9692 /* Concatenate all the agent expressions that are commands into the 9693 cmds parameter. */ 9694 for (agent_expr *aexpr : bp_tgt->tcommands) 9695 { 9696 sprintf (buf, "X%x,", aexpr->len); 9697 buf += strlen (buf); 9698 for (int i = 0; i < aexpr->len; ++i) 9699 buf = pack_hex_byte (buf, aexpr->buf[i]); 9700 *buf = '\0'; 9701 } 9702} 9703 9704/* Insert a breakpoint. On targets that have software breakpoint 9705 support, we ask the remote target to do the work; on targets 9706 which don't, we insert a traditional memory breakpoint. */ 9707 9708static int 9709remote_insert_breakpoint (struct target_ops *ops, 9710 struct gdbarch *gdbarch, 9711 struct bp_target_info *bp_tgt) 9712{ 9713 /* Try the "Z" s/w breakpoint packet if it is not already disabled. 9714 If it succeeds, then set the support to PACKET_ENABLE. If it 9715 fails, and the user has explicitly requested the Z support then 9716 report an error, otherwise, mark it disabled and go on. */ 9717 9718 if (packet_support (PACKET_Z0) != PACKET_DISABLE) 9719 { 9720 CORE_ADDR addr = bp_tgt->reqstd_address; 9721 struct remote_state *rs; 9722 char *p, *endbuf; 9723 int bpsize; 9724 9725 /* Make sure the remote is pointing at the right process, if 9726 necessary. */ 9727 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 9728 set_general_process (); 9729 9730 rs = get_remote_state (); 9731 p = rs->buf; 9732 endbuf = rs->buf + get_remote_packet_size (); 9733 9734 *(p++) = 'Z'; 9735 *(p++) = '0'; 9736 *(p++) = ','; 9737 addr = (ULONGEST) remote_address_masked (addr); 9738 p += hexnumstr (p, addr); 9739 xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind); 9740 9741 if (remote_supports_cond_breakpoints (ops)) 9742 remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf); 9743 9744 if (remote_can_run_breakpoint_commands (ops)) 9745 remote_add_target_side_commands (gdbarch, bp_tgt, p); 9746 9747 putpkt (rs->buf); 9748 getpkt (&rs->buf, &rs->buf_size, 0); 9749 9750 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0])) 9751 { 9752 case PACKET_ERROR: 9753 return -1; 9754 case PACKET_OK: 9755 return 0; 9756 case PACKET_UNKNOWN: 9757 break; 9758 } 9759 } 9760 9761 /* If this breakpoint has target-side commands but this stub doesn't 9762 support Z0 packets, throw error. */ 9763 if (!bp_tgt->tcommands.empty ()) 9764 throw_error (NOT_SUPPORTED_ERROR, _("\ 9765Target doesn't support breakpoints that have target side commands.")); 9766 9767 return memory_insert_breakpoint (ops, gdbarch, bp_tgt); 9768} 9769 9770static int 9771remote_remove_breakpoint (struct target_ops *ops, 9772 struct gdbarch *gdbarch, 9773 struct bp_target_info *bp_tgt, 9774 enum remove_bp_reason reason) 9775{ 9776 CORE_ADDR addr = bp_tgt->placed_address; 9777 struct remote_state *rs = get_remote_state (); 9778 9779 if (packet_support (PACKET_Z0) != PACKET_DISABLE) 9780 { 9781 char *p = rs->buf; 9782 char *endbuf = rs->buf + get_remote_packet_size (); 9783 9784 /* Make sure the remote is pointing at the right process, if 9785 necessary. */ 9786 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 9787 set_general_process (); 9788 9789 *(p++) = 'z'; 9790 *(p++) = '0'; 9791 *(p++) = ','; 9792 9793 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address); 9794 p += hexnumstr (p, addr); 9795 xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind); 9796 9797 putpkt (rs->buf); 9798 getpkt (&rs->buf, &rs->buf_size, 0); 9799 9800 return (rs->buf[0] == 'E'); 9801 } 9802 9803 return memory_remove_breakpoint (ops, gdbarch, bp_tgt, reason); 9804} 9805 9806static enum Z_packet_type 9807watchpoint_to_Z_packet (int type) 9808{ 9809 switch (type) 9810 { 9811 case hw_write: 9812 return Z_PACKET_WRITE_WP; 9813 break; 9814 case hw_read: 9815 return Z_PACKET_READ_WP; 9816 break; 9817 case hw_access: 9818 return Z_PACKET_ACCESS_WP; 9819 break; 9820 default: 9821 internal_error (__FILE__, __LINE__, 9822 _("hw_bp_to_z: bad watchpoint type %d"), type); 9823 } 9824} 9825 9826static int 9827remote_insert_watchpoint (struct target_ops *self, CORE_ADDR addr, int len, 9828 enum target_hw_bp_type type, struct expression *cond) 9829{ 9830 struct remote_state *rs = get_remote_state (); 9831 char *endbuf = rs->buf + get_remote_packet_size (); 9832 char *p; 9833 enum Z_packet_type packet = watchpoint_to_Z_packet (type); 9834 9835 if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE) 9836 return 1; 9837 9838 /* Make sure the remote is pointing at the right process, if 9839 necessary. */ 9840 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 9841 set_general_process (); 9842 9843 xsnprintf (rs->buf, endbuf - rs->buf, "Z%x,", packet); 9844 p = strchr (rs->buf, '\0'); 9845 addr = remote_address_masked (addr); 9846 p += hexnumstr (p, (ULONGEST) addr); 9847 xsnprintf (p, endbuf - p, ",%x", len); 9848 9849 putpkt (rs->buf); 9850 getpkt (&rs->buf, &rs->buf_size, 0); 9851 9852 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet])) 9853 { 9854 case PACKET_ERROR: 9855 return -1; 9856 case PACKET_UNKNOWN: 9857 return 1; 9858 case PACKET_OK: 9859 return 0; 9860 } 9861 internal_error (__FILE__, __LINE__, 9862 _("remote_insert_watchpoint: reached end of function")); 9863} 9864 9865static int 9866remote_watchpoint_addr_within_range (struct target_ops *target, CORE_ADDR addr, 9867 CORE_ADDR start, int length) 9868{ 9869 CORE_ADDR diff = remote_address_masked (addr - start); 9870 9871 return diff < length; 9872} 9873 9874 9875static int 9876remote_remove_watchpoint (struct target_ops *self, CORE_ADDR addr, int len, 9877 enum target_hw_bp_type type, struct expression *cond) 9878{ 9879 struct remote_state *rs = get_remote_state (); 9880 char *endbuf = rs->buf + get_remote_packet_size (); 9881 char *p; 9882 enum Z_packet_type packet = watchpoint_to_Z_packet (type); 9883 9884 if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE) 9885 return -1; 9886 9887 /* Make sure the remote is pointing at the right process, if 9888 necessary. */ 9889 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 9890 set_general_process (); 9891 9892 xsnprintf (rs->buf, endbuf - rs->buf, "z%x,", packet); 9893 p = strchr (rs->buf, '\0'); 9894 addr = remote_address_masked (addr); 9895 p += hexnumstr (p, (ULONGEST) addr); 9896 xsnprintf (p, endbuf - p, ",%x", len); 9897 putpkt (rs->buf); 9898 getpkt (&rs->buf, &rs->buf_size, 0); 9899 9900 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet])) 9901 { 9902 case PACKET_ERROR: 9903 case PACKET_UNKNOWN: 9904 return -1; 9905 case PACKET_OK: 9906 return 0; 9907 } 9908 internal_error (__FILE__, __LINE__, 9909 _("remote_remove_watchpoint: reached end of function")); 9910} 9911 9912 9913int remote_hw_watchpoint_limit = -1; 9914int remote_hw_watchpoint_length_limit = -1; 9915int remote_hw_breakpoint_limit = -1; 9916 9917static int 9918remote_region_ok_for_hw_watchpoint (struct target_ops *self, 9919 CORE_ADDR addr, int len) 9920{ 9921 if (remote_hw_watchpoint_length_limit == 0) 9922 return 0; 9923 else if (remote_hw_watchpoint_length_limit < 0) 9924 return 1; 9925 else if (len <= remote_hw_watchpoint_length_limit) 9926 return 1; 9927 else 9928 return 0; 9929} 9930 9931static int 9932remote_check_watch_resources (struct target_ops *self, 9933 enum bptype type, int cnt, int ot) 9934{ 9935 if (type == bp_hardware_breakpoint) 9936 { 9937 if (remote_hw_breakpoint_limit == 0) 9938 return 0; 9939 else if (remote_hw_breakpoint_limit < 0) 9940 return 1; 9941 else if (cnt <= remote_hw_breakpoint_limit) 9942 return 1; 9943 } 9944 else 9945 { 9946 if (remote_hw_watchpoint_limit == 0) 9947 return 0; 9948 else if (remote_hw_watchpoint_limit < 0) 9949 return 1; 9950 else if (ot) 9951 return -1; 9952 else if (cnt <= remote_hw_watchpoint_limit) 9953 return 1; 9954 } 9955 return -1; 9956} 9957 9958/* The to_stopped_by_sw_breakpoint method of target remote. */ 9959 9960static int 9961remote_stopped_by_sw_breakpoint (struct target_ops *ops) 9962{ 9963 struct thread_info *thread = inferior_thread (); 9964 9965 return (thread->priv != NULL 9966 && thread->priv->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT); 9967} 9968 9969/* The to_supports_stopped_by_sw_breakpoint method of target 9970 remote. */ 9971 9972static int 9973remote_supports_stopped_by_sw_breakpoint (struct target_ops *ops) 9974{ 9975 return (packet_support (PACKET_swbreak_feature) == PACKET_ENABLE); 9976} 9977 9978/* The to_stopped_by_hw_breakpoint method of target remote. */ 9979 9980static int 9981remote_stopped_by_hw_breakpoint (struct target_ops *ops) 9982{ 9983 struct thread_info *thread = inferior_thread (); 9984 9985 return (thread->priv != NULL 9986 && thread->priv->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT); 9987} 9988 9989/* The to_supports_stopped_by_hw_breakpoint method of target 9990 remote. */ 9991 9992static int 9993remote_supports_stopped_by_hw_breakpoint (struct target_ops *ops) 9994{ 9995 return (packet_support (PACKET_hwbreak_feature) == PACKET_ENABLE); 9996} 9997 9998static int 9999remote_stopped_by_watchpoint (struct target_ops *ops) 10000{ 10001 struct thread_info *thread = inferior_thread (); 10002 10003 return (thread->priv != NULL 10004 && thread->priv->stop_reason == TARGET_STOPPED_BY_WATCHPOINT); 10005} 10006 10007static int 10008remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p) 10009{ 10010 struct thread_info *thread = inferior_thread (); 10011 10012 if (thread->priv != NULL 10013 && thread->priv->stop_reason == TARGET_STOPPED_BY_WATCHPOINT) 10014 { 10015 *addr_p = thread->priv->watch_data_address; 10016 return 1; 10017 } 10018 10019 return 0; 10020} 10021 10022 10023static int 10024remote_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch, 10025 struct bp_target_info *bp_tgt) 10026{ 10027 CORE_ADDR addr = bp_tgt->reqstd_address; 10028 struct remote_state *rs; 10029 char *p, *endbuf; 10030 char *message; 10031 10032 if (packet_support (PACKET_Z1) == PACKET_DISABLE) 10033 return -1; 10034 10035 /* Make sure the remote is pointing at the right process, if 10036 necessary. */ 10037 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10038 set_general_process (); 10039 10040 rs = get_remote_state (); 10041 p = rs->buf; 10042 endbuf = rs->buf + get_remote_packet_size (); 10043 10044 *(p++) = 'Z'; 10045 *(p++) = '1'; 10046 *(p++) = ','; 10047 10048 addr = remote_address_masked (addr); 10049 p += hexnumstr (p, (ULONGEST) addr); 10050 xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind); 10051 10052 if (remote_supports_cond_breakpoints (self)) 10053 remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf); 10054 10055 if (remote_can_run_breakpoint_commands (self)) 10056 remote_add_target_side_commands (gdbarch, bp_tgt, p); 10057 10058 putpkt (rs->buf); 10059 getpkt (&rs->buf, &rs->buf_size, 0); 10060 10061 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1])) 10062 { 10063 case PACKET_ERROR: 10064 if (rs->buf[1] == '.') 10065 { 10066 message = strchr (rs->buf + 2, '.'); 10067 if (message) 10068 error (_("Remote failure reply: %s"), message + 1); 10069 } 10070 return -1; 10071 case PACKET_UNKNOWN: 10072 return -1; 10073 case PACKET_OK: 10074 return 0; 10075 } 10076 internal_error (__FILE__, __LINE__, 10077 _("remote_insert_hw_breakpoint: reached end of function")); 10078} 10079 10080 10081static int 10082remote_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch, 10083 struct bp_target_info *bp_tgt) 10084{ 10085 CORE_ADDR addr; 10086 struct remote_state *rs = get_remote_state (); 10087 char *p = rs->buf; 10088 char *endbuf = rs->buf + get_remote_packet_size (); 10089 10090 if (packet_support (PACKET_Z1) == PACKET_DISABLE) 10091 return -1; 10092 10093 /* Make sure the remote is pointing at the right process, if 10094 necessary. */ 10095 if (!gdbarch_has_global_breakpoints (target_gdbarch ())) 10096 set_general_process (); 10097 10098 *(p++) = 'z'; 10099 *(p++) = '1'; 10100 *(p++) = ','; 10101 10102 addr = remote_address_masked (bp_tgt->placed_address); 10103 p += hexnumstr (p, (ULONGEST) addr); 10104 xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind); 10105 10106 putpkt (rs->buf); 10107 getpkt (&rs->buf, &rs->buf_size, 0); 10108 10109 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1])) 10110 { 10111 case PACKET_ERROR: 10112 case PACKET_UNKNOWN: 10113 return -1; 10114 case PACKET_OK: 10115 return 0; 10116 } 10117 internal_error (__FILE__, __LINE__, 10118 _("remote_remove_hw_breakpoint: reached end of function")); 10119} 10120 10121/* Verify memory using the "qCRC:" request. */ 10122 10123static int 10124remote_verify_memory (struct target_ops *ops, 10125 const gdb_byte *data, CORE_ADDR lma, ULONGEST size) 10126{ 10127 struct remote_state *rs = get_remote_state (); 10128 unsigned long host_crc, target_crc; 10129 char *tmp; 10130 10131 /* It doesn't make sense to use qCRC if the remote target is 10132 connected but not running. */ 10133 if (target_has_execution && packet_support (PACKET_qCRC) != PACKET_DISABLE) 10134 { 10135 enum packet_result result; 10136 10137 /* Make sure the remote is pointing at the right process. */ 10138 set_general_process (); 10139 10140 /* FIXME: assumes lma can fit into long. */ 10141 xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx", 10142 (long) lma, (long) size); 10143 putpkt (rs->buf); 10144 10145 /* Be clever; compute the host_crc before waiting for target 10146 reply. */ 10147 host_crc = xcrc32 (data, size, 0xffffffff); 10148 10149 getpkt (&rs->buf, &rs->buf_size, 0); 10150 10151 result = packet_ok (rs->buf, 10152 &remote_protocol_packets[PACKET_qCRC]); 10153 if (result == PACKET_ERROR) 10154 return -1; 10155 else if (result == PACKET_OK) 10156 { 10157 for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++) 10158 target_crc = target_crc * 16 + fromhex (*tmp); 10159 10160 return (host_crc == target_crc); 10161 } 10162 } 10163 10164 return simple_verify_memory (ops, data, lma, size); 10165} 10166 10167/* compare-sections command 10168 10169 With no arguments, compares each loadable section in the exec bfd 10170 with the same memory range on the target, and reports mismatches. 10171 Useful for verifying the image on the target against the exec file. */ 10172 10173static void 10174compare_sections_command (char *args, int from_tty) 10175{ 10176 asection *s; 10177 struct cleanup *old_chain; 10178 gdb_byte *sectdata; 10179 const char *sectname; 10180 bfd_size_type size; 10181 bfd_vma lma; 10182 int matched = 0; 10183 int mismatched = 0; 10184 int res; 10185 int read_only = 0; 10186 10187 if (!exec_bfd) 10188 error (_("command cannot be used without an exec file")); 10189 10190 /* Make sure the remote is pointing at the right process. */ 10191 set_general_process (); 10192 10193 if (args != NULL && strcmp (args, "-r") == 0) 10194 { 10195 read_only = 1; 10196 args = NULL; 10197 } 10198 10199 for (s = exec_bfd->sections; s; s = s->next) 10200 { 10201 if (!(s->flags & SEC_LOAD)) 10202 continue; /* Skip non-loadable section. */ 10203 10204 if (read_only && (s->flags & SEC_READONLY) == 0) 10205 continue; /* Skip writeable sections */ 10206 10207 size = bfd_get_section_size (s); 10208 if (size == 0) 10209 continue; /* Skip zero-length section. */ 10210 10211 sectname = bfd_get_section_name (exec_bfd, s); 10212 if (args && strcmp (args, sectname) != 0) 10213 continue; /* Not the section selected by user. */ 10214 10215 matched = 1; /* Do this section. */ 10216 lma = s->lma; 10217 10218 sectdata = (gdb_byte *) xmalloc (size); 10219 old_chain = make_cleanup (xfree, sectdata); 10220 bfd_get_section_contents (exec_bfd, s, sectdata, 0, size); 10221 10222 res = target_verify_memory (sectdata, lma, size); 10223 10224 if (res == -1) 10225 error (_("target memory fault, section %s, range %s -- %s"), sectname, 10226 paddress (target_gdbarch (), lma), 10227 paddress (target_gdbarch (), lma + size)); 10228 10229 printf_filtered ("Section %s, range %s -- %s: ", sectname, 10230 paddress (target_gdbarch (), lma), 10231 paddress (target_gdbarch (), lma + size)); 10232 if (res) 10233 printf_filtered ("matched.\n"); 10234 else 10235 { 10236 printf_filtered ("MIS-MATCHED!\n"); 10237 mismatched++; 10238 } 10239 10240 do_cleanups (old_chain); 10241 } 10242 if (mismatched > 0) 10243 warning (_("One or more sections of the target image does not match\n\ 10244the loaded file\n")); 10245 if (args && !matched) 10246 printf_filtered (_("No loaded section named '%s'.\n"), args); 10247} 10248 10249/* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET 10250 into remote target. The number of bytes written to the remote 10251 target is returned, or -1 for error. */ 10252 10253static enum target_xfer_status 10254remote_write_qxfer (struct target_ops *ops, const char *object_name, 10255 const char *annex, const gdb_byte *writebuf, 10256 ULONGEST offset, LONGEST len, ULONGEST *xfered_len, 10257 struct packet_config *packet) 10258{ 10259 int i, buf_len; 10260 ULONGEST n; 10261 struct remote_state *rs = get_remote_state (); 10262 int max_size = get_memory_write_packet_size (); 10263 10264 if (packet->support == PACKET_DISABLE) 10265 return TARGET_XFER_E_IO; 10266 10267 /* Insert header. */ 10268 i = snprintf (rs->buf, max_size, 10269 "qXfer:%s:write:%s:%s:", 10270 object_name, annex ? annex : "", 10271 phex_nz (offset, sizeof offset)); 10272 max_size -= (i + 1); 10273 10274 /* Escape as much data as fits into rs->buf. */ 10275 buf_len = remote_escape_output 10276 (writebuf, len, 1, (gdb_byte *) rs->buf + i, &max_size, max_size); 10277 10278 if (putpkt_binary (rs->buf, i + buf_len) < 0 10279 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0 10280 || packet_ok (rs->buf, packet) != PACKET_OK) 10281 return TARGET_XFER_E_IO; 10282 10283 unpack_varlen_hex (rs->buf, &n); 10284 10285 *xfered_len = n; 10286 return TARGET_XFER_OK; 10287} 10288 10289/* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet. 10290 Data at OFFSET, of up to LEN bytes, is read into READBUF; the 10291 number of bytes read is returned, or 0 for EOF, or -1 for error. 10292 The number of bytes read may be less than LEN without indicating an 10293 EOF. PACKET is checked and updated to indicate whether the remote 10294 target supports this object. */ 10295 10296static enum target_xfer_status 10297remote_read_qxfer (struct target_ops *ops, const char *object_name, 10298 const char *annex, 10299 gdb_byte *readbuf, ULONGEST offset, LONGEST len, 10300 ULONGEST *xfered_len, 10301 struct packet_config *packet) 10302{ 10303 struct remote_state *rs = get_remote_state (); 10304 LONGEST i, n, packet_len; 10305 10306 if (packet->support == PACKET_DISABLE) 10307 return TARGET_XFER_E_IO; 10308 10309 /* Check whether we've cached an end-of-object packet that matches 10310 this request. */ 10311 if (rs->finished_object) 10312 { 10313 if (strcmp (object_name, rs->finished_object) == 0 10314 && strcmp (annex ? annex : "", rs->finished_annex) == 0 10315 && offset == rs->finished_offset) 10316 return TARGET_XFER_EOF; 10317 10318 10319 /* Otherwise, we're now reading something different. Discard 10320 the cache. */ 10321 xfree (rs->finished_object); 10322 xfree (rs->finished_annex); 10323 rs->finished_object = NULL; 10324 rs->finished_annex = NULL; 10325 } 10326 10327 /* Request only enough to fit in a single packet. The actual data 10328 may not, since we don't know how much of it will need to be escaped; 10329 the target is free to respond with slightly less data. We subtract 10330 five to account for the response type and the protocol frame. */ 10331 n = std::min<LONGEST> (get_remote_packet_size () - 5, len); 10332 snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s", 10333 object_name, annex ? annex : "", 10334 phex_nz (offset, sizeof offset), 10335 phex_nz (n, sizeof n)); 10336 i = putpkt (rs->buf); 10337 if (i < 0) 10338 return TARGET_XFER_E_IO; 10339 10340 rs->buf[0] = '\0'; 10341 packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0); 10342 if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK) 10343 return TARGET_XFER_E_IO; 10344 10345 if (rs->buf[0] != 'l' && rs->buf[0] != 'm') 10346 error (_("Unknown remote qXfer reply: %s"), rs->buf); 10347 10348 /* 'm' means there is (or at least might be) more data after this 10349 batch. That does not make sense unless there's at least one byte 10350 of data in this reply. */ 10351 if (rs->buf[0] == 'm' && packet_len == 1) 10352 error (_("Remote qXfer reply contained no data.")); 10353 10354 /* Got some data. */ 10355 i = remote_unescape_input ((gdb_byte *) rs->buf + 1, 10356 packet_len - 1, readbuf, n); 10357 10358 /* 'l' is an EOF marker, possibly including a final block of data, 10359 or possibly empty. If we have the final block of a non-empty 10360 object, record this fact to bypass a subsequent partial read. */ 10361 if (rs->buf[0] == 'l' && offset + i > 0) 10362 { 10363 rs->finished_object = xstrdup (object_name); 10364 rs->finished_annex = xstrdup (annex ? annex : ""); 10365 rs->finished_offset = offset + i; 10366 } 10367 10368 if (i == 0) 10369 return TARGET_XFER_EOF; 10370 else 10371 { 10372 *xfered_len = i; 10373 return TARGET_XFER_OK; 10374 } 10375} 10376 10377static enum target_xfer_status 10378remote_xfer_partial (struct target_ops *ops, enum target_object object, 10379 const char *annex, gdb_byte *readbuf, 10380 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, 10381 ULONGEST *xfered_len) 10382{ 10383 struct remote_state *rs; 10384 int i; 10385 char *p2; 10386 char query_type; 10387 int unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ()); 10388 10389 set_remote_traceframe (); 10390 set_general_thread (inferior_ptid); 10391 10392 rs = get_remote_state (); 10393 10394 /* Handle memory using the standard memory routines. */ 10395 if (object == TARGET_OBJECT_MEMORY) 10396 { 10397 /* If the remote target is connected but not running, we should 10398 pass this request down to a lower stratum (e.g. the executable 10399 file). */ 10400 if (!target_has_execution) 10401 return TARGET_XFER_EOF; 10402 10403 if (writebuf != NULL) 10404 return remote_write_bytes (offset, writebuf, len, unit_size, 10405 xfered_len); 10406 else 10407 return remote_read_bytes (ops, offset, readbuf, len, unit_size, 10408 xfered_len); 10409 } 10410 10411 /* Handle SPU memory using qxfer packets. */ 10412 if (object == TARGET_OBJECT_SPU) 10413 { 10414 if (readbuf) 10415 return remote_read_qxfer (ops, "spu", annex, readbuf, offset, len, 10416 xfered_len, &remote_protocol_packets 10417 [PACKET_qXfer_spu_read]); 10418 else 10419 return remote_write_qxfer (ops, "spu", annex, writebuf, offset, len, 10420 xfered_len, &remote_protocol_packets 10421 [PACKET_qXfer_spu_write]); 10422 } 10423 10424 /* Handle extra signal info using qxfer packets. */ 10425 if (object == TARGET_OBJECT_SIGNAL_INFO) 10426 { 10427 if (readbuf) 10428 return remote_read_qxfer (ops, "siginfo", annex, readbuf, offset, len, 10429 xfered_len, &remote_protocol_packets 10430 [PACKET_qXfer_siginfo_read]); 10431 else 10432 return remote_write_qxfer (ops, "siginfo", annex, 10433 writebuf, offset, len, xfered_len, 10434 &remote_protocol_packets 10435 [PACKET_qXfer_siginfo_write]); 10436 } 10437 10438 if (object == TARGET_OBJECT_STATIC_TRACE_DATA) 10439 { 10440 if (readbuf) 10441 return remote_read_qxfer (ops, "statictrace", annex, 10442 readbuf, offset, len, xfered_len, 10443 &remote_protocol_packets 10444 [PACKET_qXfer_statictrace_read]); 10445 else 10446 return TARGET_XFER_E_IO; 10447 } 10448 10449 /* Only handle flash writes. */ 10450 if (writebuf != NULL) 10451 { 10452 switch (object) 10453 { 10454 case TARGET_OBJECT_FLASH: 10455 return remote_flash_write (ops, offset, len, xfered_len, 10456 writebuf); 10457 10458 default: 10459 return TARGET_XFER_E_IO; 10460 } 10461 } 10462 10463 /* Map pre-existing objects onto letters. DO NOT do this for new 10464 objects!!! Instead specify new query packets. */ 10465 switch (object) 10466 { 10467 case TARGET_OBJECT_AVR: 10468 query_type = 'R'; 10469 break; 10470 10471 case TARGET_OBJECT_AUXV: 10472 gdb_assert (annex == NULL); 10473 return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len, 10474 xfered_len, 10475 &remote_protocol_packets[PACKET_qXfer_auxv]); 10476 10477 case TARGET_OBJECT_AVAILABLE_FEATURES: 10478 return remote_read_qxfer 10479 (ops, "features", annex, readbuf, offset, len, xfered_len, 10480 &remote_protocol_packets[PACKET_qXfer_features]); 10481 10482 case TARGET_OBJECT_LIBRARIES: 10483 return remote_read_qxfer 10484 (ops, "libraries", annex, readbuf, offset, len, xfered_len, 10485 &remote_protocol_packets[PACKET_qXfer_libraries]); 10486 10487 case TARGET_OBJECT_LIBRARIES_SVR4: 10488 return remote_read_qxfer 10489 (ops, "libraries-svr4", annex, readbuf, offset, len, xfered_len, 10490 &remote_protocol_packets[PACKET_qXfer_libraries_svr4]); 10491 10492 case TARGET_OBJECT_MEMORY_MAP: 10493 gdb_assert (annex == NULL); 10494 return remote_read_qxfer (ops, "memory-map", annex, readbuf, offset, len, 10495 xfered_len, 10496 &remote_protocol_packets[PACKET_qXfer_memory_map]); 10497 10498 case TARGET_OBJECT_OSDATA: 10499 /* Should only get here if we're connected. */ 10500 gdb_assert (rs->remote_desc); 10501 return remote_read_qxfer 10502 (ops, "osdata", annex, readbuf, offset, len, xfered_len, 10503 &remote_protocol_packets[PACKET_qXfer_osdata]); 10504 10505 case TARGET_OBJECT_THREADS: 10506 gdb_assert (annex == NULL); 10507 return remote_read_qxfer (ops, "threads", annex, readbuf, offset, len, 10508 xfered_len, 10509 &remote_protocol_packets[PACKET_qXfer_threads]); 10510 10511 case TARGET_OBJECT_TRACEFRAME_INFO: 10512 gdb_assert (annex == NULL); 10513 return remote_read_qxfer 10514 (ops, "traceframe-info", annex, readbuf, offset, len, xfered_len, 10515 &remote_protocol_packets[PACKET_qXfer_traceframe_info]); 10516 10517 case TARGET_OBJECT_FDPIC: 10518 return remote_read_qxfer (ops, "fdpic", annex, readbuf, offset, len, 10519 xfered_len, 10520 &remote_protocol_packets[PACKET_qXfer_fdpic]); 10521 10522 case TARGET_OBJECT_OPENVMS_UIB: 10523 return remote_read_qxfer (ops, "uib", annex, readbuf, offset, len, 10524 xfered_len, 10525 &remote_protocol_packets[PACKET_qXfer_uib]); 10526 10527 case TARGET_OBJECT_BTRACE: 10528 return remote_read_qxfer (ops, "btrace", annex, readbuf, offset, len, 10529 xfered_len, 10530 &remote_protocol_packets[PACKET_qXfer_btrace]); 10531 10532 case TARGET_OBJECT_BTRACE_CONF: 10533 return remote_read_qxfer (ops, "btrace-conf", annex, readbuf, offset, 10534 len, xfered_len, 10535 &remote_protocol_packets[PACKET_qXfer_btrace_conf]); 10536 10537 case TARGET_OBJECT_EXEC_FILE: 10538 return remote_read_qxfer (ops, "exec-file", annex, readbuf, offset, 10539 len, xfered_len, 10540 &remote_protocol_packets[PACKET_qXfer_exec_file]); 10541 10542 default: 10543 return TARGET_XFER_E_IO; 10544 } 10545 10546 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not 10547 large enough let the caller deal with it. */ 10548 if (len < get_remote_packet_size ()) 10549 return TARGET_XFER_E_IO; 10550 len = get_remote_packet_size (); 10551 10552 /* Except for querying the minimum buffer size, target must be open. */ 10553 if (!rs->remote_desc) 10554 error (_("remote query is only available after target open")); 10555 10556 gdb_assert (annex != NULL); 10557 gdb_assert (readbuf != NULL); 10558 10559 p2 = rs->buf; 10560 *p2++ = 'q'; 10561 *p2++ = query_type; 10562 10563 /* We used one buffer char for the remote protocol q command and 10564 another for the query type. As the remote protocol encapsulation 10565 uses 4 chars plus one extra in case we are debugging 10566 (remote_debug), we have PBUFZIZ - 7 left to pack the query 10567 string. */ 10568 i = 0; 10569 while (annex[i] && (i < (get_remote_packet_size () - 8))) 10570 { 10571 /* Bad caller may have sent forbidden characters. */ 10572 gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#'); 10573 *p2++ = annex[i]; 10574 i++; 10575 } 10576 *p2 = '\0'; 10577 gdb_assert (annex[i] == '\0'); 10578 10579 i = putpkt (rs->buf); 10580 if (i < 0) 10581 return TARGET_XFER_E_IO; 10582 10583 getpkt (&rs->buf, &rs->buf_size, 0); 10584 strcpy ((char *) readbuf, rs->buf); 10585 10586 *xfered_len = strlen ((char *) readbuf); 10587 return TARGET_XFER_OK; 10588} 10589 10590/* Implementation of to_get_memory_xfer_limit. */ 10591 10592static ULONGEST 10593remote_get_memory_xfer_limit (struct target_ops *ops) 10594{ 10595 return get_memory_write_packet_size (); 10596} 10597 10598static int 10599remote_search_memory (struct target_ops* ops, 10600 CORE_ADDR start_addr, ULONGEST search_space_len, 10601 const gdb_byte *pattern, ULONGEST pattern_len, 10602 CORE_ADDR *found_addrp) 10603{ 10604 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; 10605 struct remote_state *rs = get_remote_state (); 10606 int max_size = get_memory_write_packet_size (); 10607 struct packet_config *packet = 10608 &remote_protocol_packets[PACKET_qSearch_memory]; 10609 /* Number of packet bytes used to encode the pattern; 10610 this could be more than PATTERN_LEN due to escape characters. */ 10611 int escaped_pattern_len; 10612 /* Amount of pattern that was encodable in the packet. */ 10613 int used_pattern_len; 10614 int i; 10615 int found; 10616 ULONGEST found_addr; 10617 10618 /* Don't go to the target if we don't have to. 10619 This is done before checking packet->support to avoid the possibility that 10620 a success for this edge case means the facility works in general. */ 10621 if (pattern_len > search_space_len) 10622 return 0; 10623 if (pattern_len == 0) 10624 { 10625 *found_addrp = start_addr; 10626 return 1; 10627 } 10628 10629 /* If we already know the packet isn't supported, fall back to the simple 10630 way of searching memory. */ 10631 10632 if (packet_config_support (packet) == PACKET_DISABLE) 10633 { 10634 /* Target doesn't provided special support, fall back and use the 10635 standard support (copy memory and do the search here). */ 10636 return simple_search_memory (ops, start_addr, search_space_len, 10637 pattern, pattern_len, found_addrp); 10638 } 10639 10640 /* Make sure the remote is pointing at the right process. */ 10641 set_general_process (); 10642 10643 /* Insert header. */ 10644 i = snprintf (rs->buf, max_size, 10645 "qSearch:memory:%s;%s;", 10646 phex_nz (start_addr, addr_size), 10647 phex_nz (search_space_len, sizeof (search_space_len))); 10648 max_size -= (i + 1); 10649 10650 /* Escape as much data as fits into rs->buf. */ 10651 escaped_pattern_len = 10652 remote_escape_output (pattern, pattern_len, 1, (gdb_byte *) rs->buf + i, 10653 &used_pattern_len, max_size); 10654 10655 /* Bail if the pattern is too large. */ 10656 if (used_pattern_len != pattern_len) 10657 error (_("Pattern is too large to transmit to remote target.")); 10658 10659 if (putpkt_binary (rs->buf, i + escaped_pattern_len) < 0 10660 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0 10661 || packet_ok (rs->buf, packet) != PACKET_OK) 10662 { 10663 /* The request may not have worked because the command is not 10664 supported. If so, fall back to the simple way. */ 10665 if (packet->support == PACKET_DISABLE) 10666 { 10667 return simple_search_memory (ops, start_addr, search_space_len, 10668 pattern, pattern_len, found_addrp); 10669 } 10670 return -1; 10671 } 10672 10673 if (rs->buf[0] == '0') 10674 found = 0; 10675 else if (rs->buf[0] == '1') 10676 { 10677 found = 1; 10678 if (rs->buf[1] != ',') 10679 error (_("Unknown qSearch:memory reply: %s"), rs->buf); 10680 unpack_varlen_hex (rs->buf + 2, &found_addr); 10681 *found_addrp = found_addr; 10682 } 10683 else 10684 error (_("Unknown qSearch:memory reply: %s"), rs->buf); 10685 10686 return found; 10687} 10688 10689static void 10690remote_rcmd (struct target_ops *self, const char *command, 10691 struct ui_file *outbuf) 10692{ 10693 struct remote_state *rs = get_remote_state (); 10694 char *p = rs->buf; 10695 10696 if (!rs->remote_desc) 10697 error (_("remote rcmd is only available after target open")); 10698 10699 /* Send a NULL command across as an empty command. */ 10700 if (command == NULL) 10701 command = ""; 10702 10703 /* The query prefix. */ 10704 strcpy (rs->buf, "qRcmd,"); 10705 p = strchr (rs->buf, '\0'); 10706 10707 if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/) 10708 > get_remote_packet_size ()) 10709 error (_("\"monitor\" command ``%s'' is too long."), command); 10710 10711 /* Encode the actual command. */ 10712 bin2hex ((const gdb_byte *) command, p, strlen (command)); 10713 10714 if (putpkt (rs->buf) < 0) 10715 error (_("Communication problem with target.")); 10716 10717 /* get/display the response */ 10718 while (1) 10719 { 10720 char *buf; 10721 10722 /* XXX - see also remote_get_noisy_reply(). */ 10723 QUIT; /* Allow user to bail out with ^C. */ 10724 rs->buf[0] = '\0'; 10725 if (getpkt_sane (&rs->buf, &rs->buf_size, 0) == -1) 10726 { 10727 /* Timeout. Continue to (try to) read responses. 10728 This is better than stopping with an error, assuming the stub 10729 is still executing the (long) monitor command. 10730 If needed, the user can interrupt gdb using C-c, obtaining 10731 an effect similar to stop on timeout. */ 10732 continue; 10733 } 10734 buf = rs->buf; 10735 if (buf[0] == '\0') 10736 error (_("Target does not support this command.")); 10737 if (buf[0] == 'O' && buf[1] != 'K') 10738 { 10739 remote_console_output (buf + 1); /* 'O' message from stub. */ 10740 continue; 10741 } 10742 if (strcmp (buf, "OK") == 0) 10743 break; 10744 if (strlen (buf) == 3 && buf[0] == 'E' 10745 && isdigit (buf[1]) && isdigit (buf[2])) 10746 { 10747 error (_("Protocol error with Rcmd")); 10748 } 10749 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2) 10750 { 10751 char c = (fromhex (p[0]) << 4) + fromhex (p[1]); 10752 10753 fputc_unfiltered (c, outbuf); 10754 } 10755 break; 10756 } 10757} 10758 10759static VEC(mem_region_s) * 10760remote_memory_map (struct target_ops *ops) 10761{ 10762 VEC(mem_region_s) *result = NULL; 10763 char *text = target_read_stralloc (¤t_target, 10764 TARGET_OBJECT_MEMORY_MAP, NULL); 10765 10766 if (text) 10767 { 10768 struct cleanup *back_to = make_cleanup (xfree, text); 10769 10770 result = parse_memory_map (text); 10771 do_cleanups (back_to); 10772 } 10773 10774 return result; 10775} 10776 10777static void 10778packet_command (char *args, int from_tty) 10779{ 10780 struct remote_state *rs = get_remote_state (); 10781 10782 if (!rs->remote_desc) 10783 error (_("command can only be used with remote target")); 10784 10785 if (!args) 10786 error (_("remote-packet command requires packet text as argument")); 10787 10788 puts_filtered ("sending: "); 10789 print_packet (args); 10790 puts_filtered ("\n"); 10791 putpkt (args); 10792 10793 getpkt (&rs->buf, &rs->buf_size, 0); 10794 puts_filtered ("received: "); 10795 print_packet (rs->buf); 10796 puts_filtered ("\n"); 10797} 10798 10799#if 0 10800/* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */ 10801 10802static void display_thread_info (struct gdb_ext_thread_info *info); 10803 10804static void threadset_test_cmd (char *cmd, int tty); 10805 10806static void threadalive_test (char *cmd, int tty); 10807 10808static void threadlist_test_cmd (char *cmd, int tty); 10809 10810int get_and_display_threadinfo (threadref *ref); 10811 10812static void threadinfo_test_cmd (char *cmd, int tty); 10813 10814static int thread_display_step (threadref *ref, void *context); 10815 10816static void threadlist_update_test_cmd (char *cmd, int tty); 10817 10818static void init_remote_threadtests (void); 10819 10820#define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */ 10821 10822static void 10823threadset_test_cmd (char *cmd, int tty) 10824{ 10825 int sample_thread = SAMPLE_THREAD; 10826 10827 printf_filtered (_("Remote threadset test\n")); 10828 set_general_thread (sample_thread); 10829} 10830 10831 10832static void 10833threadalive_test (char *cmd, int tty) 10834{ 10835 int sample_thread = SAMPLE_THREAD; 10836 int pid = ptid_get_pid (inferior_ptid); 10837 ptid_t ptid = ptid_build (pid, sample_thread, 0); 10838 10839 if (remote_thread_alive (ptid)) 10840 printf_filtered ("PASS: Thread alive test\n"); 10841 else 10842 printf_filtered ("FAIL: Thread alive test\n"); 10843} 10844 10845void output_threadid (char *title, threadref *ref); 10846 10847void 10848output_threadid (char *title, threadref *ref) 10849{ 10850 char hexid[20]; 10851 10852 pack_threadid (&hexid[0], ref); /* Convert threead id into hex. */ 10853 hexid[16] = 0; 10854 printf_filtered ("%s %s\n", title, (&hexid[0])); 10855} 10856 10857static void 10858threadlist_test_cmd (char *cmd, int tty) 10859{ 10860 int startflag = 1; 10861 threadref nextthread; 10862 int done, result_count; 10863 threadref threadlist[3]; 10864 10865 printf_filtered ("Remote Threadlist test\n"); 10866 if (!remote_get_threadlist (startflag, &nextthread, 3, &done, 10867 &result_count, &threadlist[0])) 10868 printf_filtered ("FAIL: threadlist test\n"); 10869 else 10870 { 10871 threadref *scan = threadlist; 10872 threadref *limit = scan + result_count; 10873 10874 while (scan < limit) 10875 output_threadid (" thread ", scan++); 10876 } 10877} 10878 10879void 10880display_thread_info (struct gdb_ext_thread_info *info) 10881{ 10882 output_threadid ("Threadid: ", &info->threadid); 10883 printf_filtered ("Name: %s\n ", info->shortname); 10884 printf_filtered ("State: %s\n", info->display); 10885 printf_filtered ("other: %s\n\n", info->more_display); 10886} 10887 10888int 10889get_and_display_threadinfo (threadref *ref) 10890{ 10891 int result; 10892 int set; 10893 struct gdb_ext_thread_info threadinfo; 10894 10895 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME 10896 | TAG_MOREDISPLAY | TAG_DISPLAY; 10897 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo))) 10898 display_thread_info (&threadinfo); 10899 return result; 10900} 10901 10902static void 10903threadinfo_test_cmd (char *cmd, int tty) 10904{ 10905 int athread = SAMPLE_THREAD; 10906 threadref thread; 10907 int set; 10908 10909 int_to_threadref (&thread, athread); 10910 printf_filtered ("Remote Threadinfo test\n"); 10911 if (!get_and_display_threadinfo (&thread)) 10912 printf_filtered ("FAIL cannot get thread info\n"); 10913} 10914 10915static int 10916thread_display_step (threadref *ref, void *context) 10917{ 10918 /* output_threadid(" threadstep ",ref); *//* simple test */ 10919 return get_and_display_threadinfo (ref); 10920} 10921 10922static void 10923threadlist_update_test_cmd (char *cmd, int tty) 10924{ 10925 printf_filtered ("Remote Threadlist update test\n"); 10926 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS); 10927} 10928 10929static void 10930init_remote_threadtests (void) 10931{ 10932 add_com ("tlist", class_obscure, threadlist_test_cmd, 10933 _("Fetch and print the remote list of " 10934 "thread identifiers, one pkt only")); 10935 add_com ("tinfo", class_obscure, threadinfo_test_cmd, 10936 _("Fetch and display info about one thread")); 10937 add_com ("tset", class_obscure, threadset_test_cmd, 10938 _("Test setting to a different thread")); 10939 add_com ("tupd", class_obscure, threadlist_update_test_cmd, 10940 _("Iterate through updating all remote thread info")); 10941 add_com ("talive", class_obscure, threadalive_test, 10942 _(" Remote thread alive test ")); 10943} 10944 10945#endif /* 0 */ 10946 10947/* Convert a thread ID to a string. Returns the string in a static 10948 buffer. */ 10949 10950static const char * 10951remote_pid_to_str (struct target_ops *ops, ptid_t ptid) 10952{ 10953 static char buf[64]; 10954 struct remote_state *rs = get_remote_state (); 10955 10956 if (ptid_equal (ptid, null_ptid)) 10957 return normal_pid_to_str (ptid); 10958 else if (ptid_is_pid (ptid)) 10959 { 10960 /* Printing an inferior target id. */ 10961 10962 /* When multi-process extensions are off, there's no way in the 10963 remote protocol to know the remote process id, if there's any 10964 at all. There's one exception --- when we're connected with 10965 target extended-remote, and we manually attached to a process 10966 with "attach PID". We don't record anywhere a flag that 10967 allows us to distinguish that case from the case of 10968 connecting with extended-remote and the stub already being 10969 attached to a process, and reporting yes to qAttached, hence 10970 no smart special casing here. */ 10971 if (!remote_multi_process_p (rs)) 10972 { 10973 xsnprintf (buf, sizeof buf, "Remote target"); 10974 return buf; 10975 } 10976 10977 return normal_pid_to_str (ptid); 10978 } 10979 else 10980 { 10981 if (ptid_equal (magic_null_ptid, ptid)) 10982 xsnprintf (buf, sizeof buf, "Thread <main>"); 10983 else if (remote_multi_process_p (rs)) 10984 if (ptid_get_lwp (ptid) == 0) 10985 return normal_pid_to_str (ptid); 10986 else 10987 xsnprintf (buf, sizeof buf, "Thread %d.%ld", 10988 ptid_get_pid (ptid), ptid_get_lwp (ptid)); 10989 else 10990 xsnprintf (buf, sizeof buf, "Thread %ld", 10991 ptid_get_lwp (ptid)); 10992 return buf; 10993 } 10994} 10995 10996/* Get the address of the thread local variable in OBJFILE which is 10997 stored at OFFSET within the thread local storage for thread PTID. */ 10998 10999static CORE_ADDR 11000remote_get_thread_local_address (struct target_ops *ops, 11001 ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset) 11002{ 11003 if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE) 11004 { 11005 struct remote_state *rs = get_remote_state (); 11006 char *p = rs->buf; 11007 char *endp = rs->buf + get_remote_packet_size (); 11008 enum packet_result result; 11009 11010 strcpy (p, "qGetTLSAddr:"); 11011 p += strlen (p); 11012 p = write_ptid (p, endp, ptid); 11013 *p++ = ','; 11014 p += hexnumstr (p, offset); 11015 *p++ = ','; 11016 p += hexnumstr (p, lm); 11017 *p++ = '\0'; 11018 11019 putpkt (rs->buf); 11020 getpkt (&rs->buf, &rs->buf_size, 0); 11021 result = packet_ok (rs->buf, 11022 &remote_protocol_packets[PACKET_qGetTLSAddr]); 11023 if (result == PACKET_OK) 11024 { 11025 ULONGEST result; 11026 11027 unpack_varlen_hex (rs->buf, &result); 11028 return result; 11029 } 11030 else if (result == PACKET_UNKNOWN) 11031 throw_error (TLS_GENERIC_ERROR, 11032 _("Remote target doesn't support qGetTLSAddr packet")); 11033 else 11034 throw_error (TLS_GENERIC_ERROR, 11035 _("Remote target failed to process qGetTLSAddr request")); 11036 } 11037 else 11038 throw_error (TLS_GENERIC_ERROR, 11039 _("TLS not supported or disabled on this target")); 11040 /* Not reached. */ 11041 return 0; 11042} 11043 11044/* Provide thread local base, i.e. Thread Information Block address. 11045 Returns 1 if ptid is found and thread_local_base is non zero. */ 11046 11047static int 11048remote_get_tib_address (struct target_ops *self, ptid_t ptid, CORE_ADDR *addr) 11049{ 11050 if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE) 11051 { 11052 struct remote_state *rs = get_remote_state (); 11053 char *p = rs->buf; 11054 char *endp = rs->buf + get_remote_packet_size (); 11055 enum packet_result result; 11056 11057 strcpy (p, "qGetTIBAddr:"); 11058 p += strlen (p); 11059 p = write_ptid (p, endp, ptid); 11060 *p++ = '\0'; 11061 11062 putpkt (rs->buf); 11063 getpkt (&rs->buf, &rs->buf_size, 0); 11064 result = packet_ok (rs->buf, 11065 &remote_protocol_packets[PACKET_qGetTIBAddr]); 11066 if (result == PACKET_OK) 11067 { 11068 ULONGEST result; 11069 11070 unpack_varlen_hex (rs->buf, &result); 11071 if (addr) 11072 *addr = (CORE_ADDR) result; 11073 return 1; 11074 } 11075 else if (result == PACKET_UNKNOWN) 11076 error (_("Remote target doesn't support qGetTIBAddr packet")); 11077 else 11078 error (_("Remote target failed to process qGetTIBAddr request")); 11079 } 11080 else 11081 error (_("qGetTIBAddr not supported or disabled on this target")); 11082 /* Not reached. */ 11083 return 0; 11084} 11085 11086/* Support for inferring a target description based on the current 11087 architecture and the size of a 'g' packet. While the 'g' packet 11088 can have any size (since optional registers can be left off the 11089 end), some sizes are easily recognizable given knowledge of the 11090 approximate architecture. */ 11091 11092struct remote_g_packet_guess 11093{ 11094 int bytes; 11095 const struct target_desc *tdesc; 11096}; 11097typedef struct remote_g_packet_guess remote_g_packet_guess_s; 11098DEF_VEC_O(remote_g_packet_guess_s); 11099 11100struct remote_g_packet_data 11101{ 11102 VEC(remote_g_packet_guess_s) *guesses; 11103}; 11104 11105static struct gdbarch_data *remote_g_packet_data_handle; 11106 11107static void * 11108remote_g_packet_data_init (struct obstack *obstack) 11109{ 11110 return OBSTACK_ZALLOC (obstack, struct remote_g_packet_data); 11111} 11112 11113void 11114register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes, 11115 const struct target_desc *tdesc) 11116{ 11117 struct remote_g_packet_data *data 11118 = ((struct remote_g_packet_data *) 11119 gdbarch_data (gdbarch, remote_g_packet_data_handle)); 11120 struct remote_g_packet_guess new_guess, *guess; 11121 int ix; 11122 11123 gdb_assert (tdesc != NULL); 11124 11125 for (ix = 0; 11126 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess); 11127 ix++) 11128 if (guess->bytes == bytes) 11129 internal_error (__FILE__, __LINE__, 11130 _("Duplicate g packet description added for size %d"), 11131 bytes); 11132 11133 new_guess.bytes = bytes; 11134 new_guess.tdesc = tdesc; 11135 VEC_safe_push (remote_g_packet_guess_s, data->guesses, &new_guess); 11136} 11137 11138/* Return 1 if remote_read_description would do anything on this target 11139 and architecture, 0 otherwise. */ 11140 11141static int 11142remote_read_description_p (struct target_ops *target) 11143{ 11144 struct remote_g_packet_data *data 11145 = ((struct remote_g_packet_data *) 11146 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle)); 11147 11148 if (!VEC_empty (remote_g_packet_guess_s, data->guesses)) 11149 return 1; 11150 11151 return 0; 11152} 11153 11154static const struct target_desc * 11155remote_read_description (struct target_ops *target) 11156{ 11157 struct remote_g_packet_data *data 11158 = ((struct remote_g_packet_data *) 11159 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle)); 11160 11161 /* Do not try this during initial connection, when we do not know 11162 whether there is a running but stopped thread. */ 11163 if (!target_has_execution || ptid_equal (inferior_ptid, null_ptid)) 11164 return target->beneath->to_read_description (target->beneath); 11165 11166 if (!VEC_empty (remote_g_packet_guess_s, data->guesses)) 11167 { 11168 struct remote_g_packet_guess *guess; 11169 int ix; 11170 int bytes = send_g_packet (); 11171 11172 for (ix = 0; 11173 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess); 11174 ix++) 11175 if (guess->bytes == bytes) 11176 return guess->tdesc; 11177 11178 /* We discard the g packet. A minor optimization would be to 11179 hold on to it, and fill the register cache once we have selected 11180 an architecture, but it's too tricky to do safely. */ 11181 } 11182 11183 return target->beneath->to_read_description (target->beneath); 11184} 11185 11186/* Remote file transfer support. This is host-initiated I/O, not 11187 target-initiated; for target-initiated, see remote-fileio.c. */ 11188 11189/* If *LEFT is at least the length of STRING, copy STRING to 11190 *BUFFER, update *BUFFER to point to the new end of the buffer, and 11191 decrease *LEFT. Otherwise raise an error. */ 11192 11193static void 11194remote_buffer_add_string (char **buffer, int *left, const char *string) 11195{ 11196 int len = strlen (string); 11197 11198 if (len > *left) 11199 error (_("Packet too long for target.")); 11200 11201 memcpy (*buffer, string, len); 11202 *buffer += len; 11203 *left -= len; 11204 11205 /* NUL-terminate the buffer as a convenience, if there is 11206 room. */ 11207 if (*left) 11208 **buffer = '\0'; 11209} 11210 11211/* If *LEFT is large enough, hex encode LEN bytes from BYTES into 11212 *BUFFER, update *BUFFER to point to the new end of the buffer, and 11213 decrease *LEFT. Otherwise raise an error. */ 11214 11215static void 11216remote_buffer_add_bytes (char **buffer, int *left, const gdb_byte *bytes, 11217 int len) 11218{ 11219 if (2 * len > *left) 11220 error (_("Packet too long for target.")); 11221 11222 bin2hex (bytes, *buffer, len); 11223 *buffer += 2 * len; 11224 *left -= 2 * len; 11225 11226 /* NUL-terminate the buffer as a convenience, if there is 11227 room. */ 11228 if (*left) 11229 **buffer = '\0'; 11230} 11231 11232/* If *LEFT is large enough, convert VALUE to hex and add it to 11233 *BUFFER, update *BUFFER to point to the new end of the buffer, and 11234 decrease *LEFT. Otherwise raise an error. */ 11235 11236static void 11237remote_buffer_add_int (char **buffer, int *left, ULONGEST value) 11238{ 11239 int len = hexnumlen (value); 11240 11241 if (len > *left) 11242 error (_("Packet too long for target.")); 11243 11244 hexnumstr (*buffer, value); 11245 *buffer += len; 11246 *left -= len; 11247 11248 /* NUL-terminate the buffer as a convenience, if there is 11249 room. */ 11250 if (*left) 11251 **buffer = '\0'; 11252} 11253 11254/* Parse an I/O result packet from BUFFER. Set RETCODE to the return 11255 value, *REMOTE_ERRNO to the remote error number or zero if none 11256 was included, and *ATTACHMENT to point to the start of the annex 11257 if any. The length of the packet isn't needed here; there may 11258 be NUL bytes in BUFFER, but they will be after *ATTACHMENT. 11259 11260 Return 0 if the packet could be parsed, -1 if it could not. If 11261 -1 is returned, the other variables may not be initialized. */ 11262 11263static int 11264remote_hostio_parse_result (char *buffer, int *retcode, 11265 int *remote_errno, char **attachment) 11266{ 11267 char *p, *p2; 11268 11269 *remote_errno = 0; 11270 *attachment = NULL; 11271 11272 if (buffer[0] != 'F') 11273 return -1; 11274 11275 errno = 0; 11276 *retcode = strtol (&buffer[1], &p, 16); 11277 if (errno != 0 || p == &buffer[1]) 11278 return -1; 11279 11280 /* Check for ",errno". */ 11281 if (*p == ',') 11282 { 11283 errno = 0; 11284 *remote_errno = strtol (p + 1, &p2, 16); 11285 if (errno != 0 || p + 1 == p2) 11286 return -1; 11287 p = p2; 11288 } 11289 11290 /* Check for ";attachment". If there is no attachment, the 11291 packet should end here. */ 11292 if (*p == ';') 11293 { 11294 *attachment = p + 1; 11295 return 0; 11296 } 11297 else if (*p == '\0') 11298 return 0; 11299 else 11300 return -1; 11301} 11302 11303/* Send a prepared I/O packet to the target and read its response. 11304 The prepared packet is in the global RS->BUF before this function 11305 is called, and the answer is there when we return. 11306 11307 COMMAND_BYTES is the length of the request to send, which may include 11308 binary data. WHICH_PACKET is the packet configuration to check 11309 before attempting a packet. If an error occurs, *REMOTE_ERRNO 11310 is set to the error number and -1 is returned. Otherwise the value 11311 returned by the function is returned. 11312 11313 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an 11314 attachment is expected; an error will be reported if there's a 11315 mismatch. If one is found, *ATTACHMENT will be set to point into 11316 the packet buffer and *ATTACHMENT_LEN will be set to the 11317 attachment's length. */ 11318 11319static int 11320remote_hostio_send_command (int command_bytes, int which_packet, 11321 int *remote_errno, char **attachment, 11322 int *attachment_len) 11323{ 11324 struct remote_state *rs = get_remote_state (); 11325 int ret, bytes_read; 11326 char *attachment_tmp; 11327 11328 if (!rs->remote_desc 11329 || packet_support (which_packet) == PACKET_DISABLE) 11330 { 11331 *remote_errno = FILEIO_ENOSYS; 11332 return -1; 11333 } 11334 11335 putpkt_binary (rs->buf, command_bytes); 11336 bytes_read = getpkt_sane (&rs->buf, &rs->buf_size, 0); 11337 11338 /* If it timed out, something is wrong. Don't try to parse the 11339 buffer. */ 11340 if (bytes_read < 0) 11341 { 11342 *remote_errno = FILEIO_EINVAL; 11343 return -1; 11344 } 11345 11346 switch (packet_ok (rs->buf, &remote_protocol_packets[which_packet])) 11347 { 11348 case PACKET_ERROR: 11349 *remote_errno = FILEIO_EINVAL; 11350 return -1; 11351 case PACKET_UNKNOWN: 11352 *remote_errno = FILEIO_ENOSYS; 11353 return -1; 11354 case PACKET_OK: 11355 break; 11356 } 11357 11358 if (remote_hostio_parse_result (rs->buf, &ret, remote_errno, 11359 &attachment_tmp)) 11360 { 11361 *remote_errno = FILEIO_EINVAL; 11362 return -1; 11363 } 11364 11365 /* Make sure we saw an attachment if and only if we expected one. */ 11366 if ((attachment_tmp == NULL && attachment != NULL) 11367 || (attachment_tmp != NULL && attachment == NULL)) 11368 { 11369 *remote_errno = FILEIO_EINVAL; 11370 return -1; 11371 } 11372 11373 /* If an attachment was found, it must point into the packet buffer; 11374 work out how many bytes there were. */ 11375 if (attachment_tmp != NULL) 11376 { 11377 *attachment = attachment_tmp; 11378 *attachment_len = bytes_read - (*attachment - rs->buf); 11379 } 11380 11381 return ret; 11382} 11383 11384/* Invalidate the readahead cache. */ 11385 11386static void 11387readahead_cache_invalidate (void) 11388{ 11389 struct remote_state *rs = get_remote_state (); 11390 11391 rs->readahead_cache.fd = -1; 11392} 11393 11394/* Invalidate the readahead cache if it is holding data for FD. */ 11395 11396static void 11397readahead_cache_invalidate_fd (int fd) 11398{ 11399 struct remote_state *rs = get_remote_state (); 11400 11401 if (rs->readahead_cache.fd == fd) 11402 rs->readahead_cache.fd = -1; 11403} 11404 11405/* Set the filesystem remote_hostio functions that take FILENAME 11406 arguments will use. Return 0 on success, or -1 if an error 11407 occurs (and set *REMOTE_ERRNO). */ 11408 11409static int 11410remote_hostio_set_filesystem (struct inferior *inf, int *remote_errno) 11411{ 11412 struct remote_state *rs = get_remote_state (); 11413 int required_pid = (inf == NULL || inf->fake_pid_p) ? 0 : inf->pid; 11414 char *p = rs->buf; 11415 int left = get_remote_packet_size () - 1; 11416 char arg[9]; 11417 int ret; 11418 11419 if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE) 11420 return 0; 11421 11422 if (rs->fs_pid != -1 && required_pid == rs->fs_pid) 11423 return 0; 11424 11425 remote_buffer_add_string (&p, &left, "vFile:setfs:"); 11426 11427 xsnprintf (arg, sizeof (arg), "%x", required_pid); 11428 remote_buffer_add_string (&p, &left, arg); 11429 11430 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_setfs, 11431 remote_errno, NULL, NULL); 11432 11433 if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE) 11434 return 0; 11435 11436 if (ret == 0) 11437 rs->fs_pid = required_pid; 11438 11439 return ret; 11440} 11441 11442/* Implementation of to_fileio_open. */ 11443 11444static int 11445remote_hostio_open (struct target_ops *self, 11446 struct inferior *inf, const char *filename, 11447 int flags, int mode, int warn_if_slow, 11448 int *remote_errno) 11449{ 11450 struct remote_state *rs = get_remote_state (); 11451 char *p = rs->buf; 11452 int left = get_remote_packet_size () - 1; 11453 11454 if (warn_if_slow) 11455 { 11456 static int warning_issued = 0; 11457 11458 printf_unfiltered (_("Reading %s from remote target...\n"), 11459 filename); 11460 11461 if (!warning_issued) 11462 { 11463 warning (_("File transfers from remote targets can be slow." 11464 " Use \"set sysroot\" to access files locally" 11465 " instead.")); 11466 warning_issued = 1; 11467 } 11468 } 11469 11470 if (remote_hostio_set_filesystem (inf, remote_errno) != 0) 11471 return -1; 11472 11473 remote_buffer_add_string (&p, &left, "vFile:open:"); 11474 11475 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, 11476 strlen (filename)); 11477 remote_buffer_add_string (&p, &left, ","); 11478 11479 remote_buffer_add_int (&p, &left, flags); 11480 remote_buffer_add_string (&p, &left, ","); 11481 11482 remote_buffer_add_int (&p, &left, mode); 11483 11484 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_open, 11485 remote_errno, NULL, NULL); 11486} 11487 11488/* Implementation of to_fileio_pwrite. */ 11489 11490static int 11491remote_hostio_pwrite (struct target_ops *self, 11492 int fd, const gdb_byte *write_buf, int len, 11493 ULONGEST offset, int *remote_errno) 11494{ 11495 struct remote_state *rs = get_remote_state (); 11496 char *p = rs->buf; 11497 int left = get_remote_packet_size (); 11498 int out_len; 11499 11500 readahead_cache_invalidate_fd (fd); 11501 11502 remote_buffer_add_string (&p, &left, "vFile:pwrite:"); 11503 11504 remote_buffer_add_int (&p, &left, fd); 11505 remote_buffer_add_string (&p, &left, ","); 11506 11507 remote_buffer_add_int (&p, &left, offset); 11508 remote_buffer_add_string (&p, &left, ","); 11509 11510 p += remote_escape_output (write_buf, len, 1, (gdb_byte *) p, &out_len, 11511 get_remote_packet_size () - (p - rs->buf)); 11512 11513 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_pwrite, 11514 remote_errno, NULL, NULL); 11515} 11516 11517/* Helper for the implementation of to_fileio_pread. Read the file 11518 from the remote side with vFile:pread. */ 11519 11520static int 11521remote_hostio_pread_vFile (struct target_ops *self, 11522 int fd, gdb_byte *read_buf, int len, 11523 ULONGEST offset, int *remote_errno) 11524{ 11525 struct remote_state *rs = get_remote_state (); 11526 char *p = rs->buf; 11527 char *attachment; 11528 int left = get_remote_packet_size (); 11529 int ret, attachment_len; 11530 int read_len; 11531 11532 remote_buffer_add_string (&p, &left, "vFile:pread:"); 11533 11534 remote_buffer_add_int (&p, &left, fd); 11535 remote_buffer_add_string (&p, &left, ","); 11536 11537 remote_buffer_add_int (&p, &left, len); 11538 remote_buffer_add_string (&p, &left, ","); 11539 11540 remote_buffer_add_int (&p, &left, offset); 11541 11542 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_pread, 11543 remote_errno, &attachment, 11544 &attachment_len); 11545 11546 if (ret < 0) 11547 return ret; 11548 11549 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len, 11550 read_buf, len); 11551 if (read_len != ret) 11552 error (_("Read returned %d, but %d bytes."), ret, (int) read_len); 11553 11554 return ret; 11555} 11556 11557/* Serve pread from the readahead cache. Returns number of bytes 11558 read, or 0 if the request can't be served from the cache. */ 11559 11560static int 11561remote_hostio_pread_from_cache (struct remote_state *rs, 11562 int fd, gdb_byte *read_buf, size_t len, 11563 ULONGEST offset) 11564{ 11565 struct readahead_cache *cache = &rs->readahead_cache; 11566 11567 if (cache->fd == fd 11568 && cache->offset <= offset 11569 && offset < cache->offset + cache->bufsize) 11570 { 11571 ULONGEST max = cache->offset + cache->bufsize; 11572 11573 if (offset + len > max) 11574 len = max - offset; 11575 11576 memcpy (read_buf, cache->buf + offset - cache->offset, len); 11577 return len; 11578 } 11579 11580 return 0; 11581} 11582 11583/* Implementation of to_fileio_pread. */ 11584 11585static int 11586remote_hostio_pread (struct target_ops *self, 11587 int fd, gdb_byte *read_buf, int len, 11588 ULONGEST offset, int *remote_errno) 11589{ 11590 int ret; 11591 struct remote_state *rs = get_remote_state (); 11592 struct readahead_cache *cache = &rs->readahead_cache; 11593 11594 ret = remote_hostio_pread_from_cache (rs, fd, read_buf, len, offset); 11595 if (ret > 0) 11596 { 11597 cache->hit_count++; 11598 11599 if (remote_debug) 11600 fprintf_unfiltered (gdb_stdlog, "readahead cache hit %s\n", 11601 pulongest (cache->hit_count)); 11602 return ret; 11603 } 11604 11605 cache->miss_count++; 11606 if (remote_debug) 11607 fprintf_unfiltered (gdb_stdlog, "readahead cache miss %s\n", 11608 pulongest (cache->miss_count)); 11609 11610 cache->fd = fd; 11611 cache->offset = offset; 11612 cache->bufsize = get_remote_packet_size (); 11613 cache->buf = (gdb_byte *) xrealloc (cache->buf, cache->bufsize); 11614 11615 ret = remote_hostio_pread_vFile (self, cache->fd, cache->buf, cache->bufsize, 11616 cache->offset, remote_errno); 11617 if (ret <= 0) 11618 { 11619 readahead_cache_invalidate_fd (fd); 11620 return ret; 11621 } 11622 11623 cache->bufsize = ret; 11624 return remote_hostio_pread_from_cache (rs, fd, read_buf, len, offset); 11625} 11626 11627/* Implementation of to_fileio_close. */ 11628 11629static int 11630remote_hostio_close (struct target_ops *self, int fd, int *remote_errno) 11631{ 11632 struct remote_state *rs = get_remote_state (); 11633 char *p = rs->buf; 11634 int left = get_remote_packet_size () - 1; 11635 11636 readahead_cache_invalidate_fd (fd); 11637 11638 remote_buffer_add_string (&p, &left, "vFile:close:"); 11639 11640 remote_buffer_add_int (&p, &left, fd); 11641 11642 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_close, 11643 remote_errno, NULL, NULL); 11644} 11645 11646/* Implementation of to_fileio_unlink. */ 11647 11648static int 11649remote_hostio_unlink (struct target_ops *self, 11650 struct inferior *inf, const char *filename, 11651 int *remote_errno) 11652{ 11653 struct remote_state *rs = get_remote_state (); 11654 char *p = rs->buf; 11655 int left = get_remote_packet_size () - 1; 11656 11657 if (remote_hostio_set_filesystem (inf, remote_errno) != 0) 11658 return -1; 11659 11660 remote_buffer_add_string (&p, &left, "vFile:unlink:"); 11661 11662 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, 11663 strlen (filename)); 11664 11665 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_unlink, 11666 remote_errno, NULL, NULL); 11667} 11668 11669/* Implementation of to_fileio_readlink. */ 11670 11671static char * 11672remote_hostio_readlink (struct target_ops *self, 11673 struct inferior *inf, const char *filename, 11674 int *remote_errno) 11675{ 11676 struct remote_state *rs = get_remote_state (); 11677 char *p = rs->buf; 11678 char *attachment; 11679 int left = get_remote_packet_size (); 11680 int len, attachment_len; 11681 int read_len; 11682 char *ret; 11683 11684 if (remote_hostio_set_filesystem (inf, remote_errno) != 0) 11685 return NULL; 11686 11687 remote_buffer_add_string (&p, &left, "vFile:readlink:"); 11688 11689 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, 11690 strlen (filename)); 11691 11692 len = remote_hostio_send_command (p - rs->buf, PACKET_vFile_readlink, 11693 remote_errno, &attachment, 11694 &attachment_len); 11695 11696 if (len < 0) 11697 return NULL; 11698 11699 ret = (char *) xmalloc (len + 1); 11700 11701 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len, 11702 (gdb_byte *) ret, len); 11703 if (read_len != len) 11704 error (_("Readlink returned %d, but %d bytes."), len, read_len); 11705 11706 ret[len] = '\0'; 11707 return ret; 11708} 11709 11710/* Implementation of to_fileio_fstat. */ 11711 11712static int 11713remote_hostio_fstat (struct target_ops *self, 11714 int fd, struct stat *st, 11715 int *remote_errno) 11716{ 11717 struct remote_state *rs = get_remote_state (); 11718 char *p = rs->buf; 11719 int left = get_remote_packet_size (); 11720 int attachment_len, ret; 11721 char *attachment; 11722 struct fio_stat fst; 11723 int read_len; 11724 11725 remote_buffer_add_string (&p, &left, "vFile:fstat:"); 11726 11727 remote_buffer_add_int (&p, &left, fd); 11728 11729 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_fstat, 11730 remote_errno, &attachment, 11731 &attachment_len); 11732 if (ret < 0) 11733 { 11734 if (*remote_errno != FILEIO_ENOSYS) 11735 return ret; 11736 11737 /* Strictly we should return -1, ENOSYS here, but when 11738 "set sysroot remote:" was implemented in August 2008 11739 BFD's need for a stat function was sidestepped with 11740 this hack. This was not remedied until March 2015 11741 so we retain the previous behavior to avoid breaking 11742 compatibility. 11743 11744 Note that the memset is a March 2015 addition; older 11745 GDBs set st_size *and nothing else* so the structure 11746 would have garbage in all other fields. This might 11747 break something but retaining the previous behavior 11748 here would be just too wrong. */ 11749 11750 memset (st, 0, sizeof (struct stat)); 11751 st->st_size = INT_MAX; 11752 return 0; 11753 } 11754 11755 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len, 11756 (gdb_byte *) &fst, sizeof (fst)); 11757 11758 if (read_len != ret) 11759 error (_("vFile:fstat returned %d, but %d bytes."), ret, read_len); 11760 11761 if (read_len != sizeof (fst)) 11762 error (_("vFile:fstat returned %d bytes, but expecting %d."), 11763 read_len, (int) sizeof (fst)); 11764 11765 remote_fileio_to_host_stat (&fst, st); 11766 11767 return 0; 11768} 11769 11770/* Implementation of to_filesystem_is_local. */ 11771 11772static int 11773remote_filesystem_is_local (struct target_ops *self) 11774{ 11775 /* Valgrind GDB presents itself as a remote target but works 11776 on the local filesystem: it does not implement remote get 11777 and users are not expected to set a sysroot. To handle 11778 this case we treat the remote filesystem as local if the 11779 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub 11780 does not support vFile:open. */ 11781 if (strcmp (gdb_sysroot, TARGET_SYSROOT_PREFIX) == 0) 11782 { 11783 enum packet_support ps = packet_support (PACKET_vFile_open); 11784 11785 if (ps == PACKET_SUPPORT_UNKNOWN) 11786 { 11787 int fd, remote_errno; 11788 11789 /* Try opening a file to probe support. The supplied 11790 filename is irrelevant, we only care about whether 11791 the stub recognizes the packet or not. */ 11792 fd = remote_hostio_open (self, NULL, "just probing", 11793 FILEIO_O_RDONLY, 0700, 0, 11794 &remote_errno); 11795 11796 if (fd >= 0) 11797 remote_hostio_close (self, fd, &remote_errno); 11798 11799 ps = packet_support (PACKET_vFile_open); 11800 } 11801 11802 if (ps == PACKET_DISABLE) 11803 { 11804 static int warning_issued = 0; 11805 11806 if (!warning_issued) 11807 { 11808 warning (_("remote target does not support file" 11809 " transfer, attempting to access files" 11810 " from local filesystem.")); 11811 warning_issued = 1; 11812 } 11813 11814 return 1; 11815 } 11816 } 11817 11818 return 0; 11819} 11820 11821static int 11822remote_fileio_errno_to_host (int errnum) 11823{ 11824 switch (errnum) 11825 { 11826 case FILEIO_EPERM: 11827 return EPERM; 11828 case FILEIO_ENOENT: 11829 return ENOENT; 11830 case FILEIO_EINTR: 11831 return EINTR; 11832 case FILEIO_EIO: 11833 return EIO; 11834 case FILEIO_EBADF: 11835 return EBADF; 11836 case FILEIO_EACCES: 11837 return EACCES; 11838 case FILEIO_EFAULT: 11839 return EFAULT; 11840 case FILEIO_EBUSY: 11841 return EBUSY; 11842 case FILEIO_EEXIST: 11843 return EEXIST; 11844 case FILEIO_ENODEV: 11845 return ENODEV; 11846 case FILEIO_ENOTDIR: 11847 return ENOTDIR; 11848 case FILEIO_EISDIR: 11849 return EISDIR; 11850 case FILEIO_EINVAL: 11851 return EINVAL; 11852 case FILEIO_ENFILE: 11853 return ENFILE; 11854 case FILEIO_EMFILE: 11855 return EMFILE; 11856 case FILEIO_EFBIG: 11857 return EFBIG; 11858 case FILEIO_ENOSPC: 11859 return ENOSPC; 11860 case FILEIO_ESPIPE: 11861 return ESPIPE; 11862 case FILEIO_EROFS: 11863 return EROFS; 11864 case FILEIO_ENOSYS: 11865 return ENOSYS; 11866 case FILEIO_ENAMETOOLONG: 11867 return ENAMETOOLONG; 11868 } 11869 return -1; 11870} 11871 11872static char * 11873remote_hostio_error (int errnum) 11874{ 11875 int host_error = remote_fileio_errno_to_host (errnum); 11876 11877 if (host_error == -1) 11878 error (_("Unknown remote I/O error %d"), errnum); 11879 else 11880 error (_("Remote I/O error: %s"), safe_strerror (host_error)); 11881} 11882 11883static void 11884remote_hostio_close_cleanup (void *opaque) 11885{ 11886 int fd = *(int *) opaque; 11887 int remote_errno; 11888 11889 remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno); 11890} 11891 11892void 11893remote_file_put (const char *local_file, const char *remote_file, int from_tty) 11894{ 11895 struct cleanup *back_to, *close_cleanup; 11896 int retcode, fd, remote_errno, bytes, io_size; 11897 FILE *file; 11898 gdb_byte *buffer; 11899 int bytes_in_buffer; 11900 int saw_eof; 11901 ULONGEST offset; 11902 struct remote_state *rs = get_remote_state (); 11903 11904 if (!rs->remote_desc) 11905 error (_("command can only be used with remote target")); 11906 11907 file = gdb_fopen_cloexec (local_file, "rb"); 11908 if (file == NULL) 11909 perror_with_name (local_file); 11910 back_to = make_cleanup_fclose (file); 11911 11912 fd = remote_hostio_open (find_target_at (process_stratum), NULL, 11913 remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT 11914 | FILEIO_O_TRUNC), 11915 0700, 0, &remote_errno); 11916 if (fd == -1) 11917 remote_hostio_error (remote_errno); 11918 11919 /* Send up to this many bytes at once. They won't all fit in the 11920 remote packet limit, so we'll transfer slightly fewer. */ 11921 io_size = get_remote_packet_size (); 11922 buffer = (gdb_byte *) xmalloc (io_size); 11923 make_cleanup (xfree, buffer); 11924 11925 close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd); 11926 11927 bytes_in_buffer = 0; 11928 saw_eof = 0; 11929 offset = 0; 11930 while (bytes_in_buffer || !saw_eof) 11931 { 11932 if (!saw_eof) 11933 { 11934 bytes = fread (buffer + bytes_in_buffer, 1, 11935 io_size - bytes_in_buffer, 11936 file); 11937 if (bytes == 0) 11938 { 11939 if (ferror (file)) 11940 error (_("Error reading %s."), local_file); 11941 else 11942 { 11943 /* EOF. Unless there is something still in the 11944 buffer from the last iteration, we are done. */ 11945 saw_eof = 1; 11946 if (bytes_in_buffer == 0) 11947 break; 11948 } 11949 } 11950 } 11951 else 11952 bytes = 0; 11953 11954 bytes += bytes_in_buffer; 11955 bytes_in_buffer = 0; 11956 11957 retcode = remote_hostio_pwrite (find_target_at (process_stratum), 11958 fd, buffer, bytes, 11959 offset, &remote_errno); 11960 11961 if (retcode < 0) 11962 remote_hostio_error (remote_errno); 11963 else if (retcode == 0) 11964 error (_("Remote write of %d bytes returned 0!"), bytes); 11965 else if (retcode < bytes) 11966 { 11967 /* Short write. Save the rest of the read data for the next 11968 write. */ 11969 bytes_in_buffer = bytes - retcode; 11970 memmove (buffer, buffer + retcode, bytes_in_buffer); 11971 } 11972 11973 offset += retcode; 11974 } 11975 11976 discard_cleanups (close_cleanup); 11977 if (remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno)) 11978 remote_hostio_error (remote_errno); 11979 11980 if (from_tty) 11981 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file); 11982 do_cleanups (back_to); 11983} 11984 11985void 11986remote_file_get (const char *remote_file, const char *local_file, int from_tty) 11987{ 11988 struct cleanup *back_to, *close_cleanup; 11989 int fd, remote_errno, bytes, io_size; 11990 FILE *file; 11991 gdb_byte *buffer; 11992 ULONGEST offset; 11993 struct remote_state *rs = get_remote_state (); 11994 11995 if (!rs->remote_desc) 11996 error (_("command can only be used with remote target")); 11997 11998 fd = remote_hostio_open (find_target_at (process_stratum), NULL, 11999 remote_file, FILEIO_O_RDONLY, 0, 0, 12000 &remote_errno); 12001 if (fd == -1) 12002 remote_hostio_error (remote_errno); 12003 12004 file = gdb_fopen_cloexec (local_file, "wb"); 12005 if (file == NULL) 12006 perror_with_name (local_file); 12007 back_to = make_cleanup_fclose (file); 12008 12009 /* Send up to this many bytes at once. They won't all fit in the 12010 remote packet limit, so we'll transfer slightly fewer. */ 12011 io_size = get_remote_packet_size (); 12012 buffer = (gdb_byte *) xmalloc (io_size); 12013 make_cleanup (xfree, buffer); 12014 12015 close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd); 12016 12017 offset = 0; 12018 while (1) 12019 { 12020 bytes = remote_hostio_pread (find_target_at (process_stratum), 12021 fd, buffer, io_size, offset, &remote_errno); 12022 if (bytes == 0) 12023 /* Success, but no bytes, means end-of-file. */ 12024 break; 12025 if (bytes == -1) 12026 remote_hostio_error (remote_errno); 12027 12028 offset += bytes; 12029 12030 bytes = fwrite (buffer, 1, bytes, file); 12031 if (bytes == 0) 12032 perror_with_name (local_file); 12033 } 12034 12035 discard_cleanups (close_cleanup); 12036 if (remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno)) 12037 remote_hostio_error (remote_errno); 12038 12039 if (from_tty) 12040 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file); 12041 do_cleanups (back_to); 12042} 12043 12044void 12045remote_file_delete (const char *remote_file, int from_tty) 12046{ 12047 int retcode, remote_errno; 12048 struct remote_state *rs = get_remote_state (); 12049 12050 if (!rs->remote_desc) 12051 error (_("command can only be used with remote target")); 12052 12053 retcode = remote_hostio_unlink (find_target_at (process_stratum), 12054 NULL, remote_file, &remote_errno); 12055 if (retcode == -1) 12056 remote_hostio_error (remote_errno); 12057 12058 if (from_tty) 12059 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file); 12060} 12061 12062static void 12063remote_put_command (char *args, int from_tty) 12064{ 12065 struct cleanup *back_to; 12066 char **argv; 12067 12068 if (args == NULL) 12069 error_no_arg (_("file to put")); 12070 12071 argv = gdb_buildargv (args); 12072 back_to = make_cleanup_freeargv (argv); 12073 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL) 12074 error (_("Invalid parameters to remote put")); 12075 12076 remote_file_put (argv[0], argv[1], from_tty); 12077 12078 do_cleanups (back_to); 12079} 12080 12081static void 12082remote_get_command (char *args, int from_tty) 12083{ 12084 struct cleanup *back_to; 12085 char **argv; 12086 12087 if (args == NULL) 12088 error_no_arg (_("file to get")); 12089 12090 argv = gdb_buildargv (args); 12091 back_to = make_cleanup_freeargv (argv); 12092 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL) 12093 error (_("Invalid parameters to remote get")); 12094 12095 remote_file_get (argv[0], argv[1], from_tty); 12096 12097 do_cleanups (back_to); 12098} 12099 12100static void 12101remote_delete_command (char *args, int from_tty) 12102{ 12103 struct cleanup *back_to; 12104 char **argv; 12105 12106 if (args == NULL) 12107 error_no_arg (_("file to delete")); 12108 12109 argv = gdb_buildargv (args); 12110 back_to = make_cleanup_freeargv (argv); 12111 if (argv[0] == NULL || argv[1] != NULL) 12112 error (_("Invalid parameters to remote delete")); 12113 12114 remote_file_delete (argv[0], from_tty); 12115 12116 do_cleanups (back_to); 12117} 12118 12119static void 12120remote_command (char *args, int from_tty) 12121{ 12122 help_list (remote_cmdlist, "remote ", all_commands, gdb_stdout); 12123} 12124 12125static int 12126remote_can_execute_reverse (struct target_ops *self) 12127{ 12128 if (packet_support (PACKET_bs) == PACKET_ENABLE 12129 || packet_support (PACKET_bc) == PACKET_ENABLE) 12130 return 1; 12131 else 12132 return 0; 12133} 12134 12135static int 12136remote_supports_non_stop (struct target_ops *self) 12137{ 12138 return 1; 12139} 12140 12141static int 12142remote_supports_disable_randomization (struct target_ops *self) 12143{ 12144 /* Only supported in extended mode. */ 12145 return 0; 12146} 12147 12148static int 12149remote_supports_multi_process (struct target_ops *self) 12150{ 12151 struct remote_state *rs = get_remote_state (); 12152 12153 return remote_multi_process_p (rs); 12154} 12155 12156static int 12157remote_supports_cond_tracepoints (void) 12158{ 12159 return packet_support (PACKET_ConditionalTracepoints) == PACKET_ENABLE; 12160} 12161 12162static int 12163remote_supports_cond_breakpoints (struct target_ops *self) 12164{ 12165 return packet_support (PACKET_ConditionalBreakpoints) == PACKET_ENABLE; 12166} 12167 12168static int 12169remote_supports_fast_tracepoints (void) 12170{ 12171 return packet_support (PACKET_FastTracepoints) == PACKET_ENABLE; 12172} 12173 12174static int 12175remote_supports_static_tracepoints (void) 12176{ 12177 return packet_support (PACKET_StaticTracepoints) == PACKET_ENABLE; 12178} 12179 12180static int 12181remote_supports_install_in_trace (void) 12182{ 12183 return packet_support (PACKET_InstallInTrace) == PACKET_ENABLE; 12184} 12185 12186static int 12187remote_supports_enable_disable_tracepoint (struct target_ops *self) 12188{ 12189 return (packet_support (PACKET_EnableDisableTracepoints_feature) 12190 == PACKET_ENABLE); 12191} 12192 12193static int 12194remote_supports_string_tracing (struct target_ops *self) 12195{ 12196 return packet_support (PACKET_tracenz_feature) == PACKET_ENABLE; 12197} 12198 12199static int 12200remote_can_run_breakpoint_commands (struct target_ops *self) 12201{ 12202 return packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE; 12203} 12204 12205static void 12206remote_trace_init (struct target_ops *self) 12207{ 12208 putpkt ("QTinit"); 12209 remote_get_noisy_reply (&target_buf, &target_buf_size); 12210 if (strcmp (target_buf, "OK") != 0) 12211 error (_("Target does not support this command.")); 12212} 12213 12214static void free_actions_list (char **actions_list); 12215static void free_actions_list_cleanup_wrapper (void *); 12216static void 12217free_actions_list_cleanup_wrapper (void *al) 12218{ 12219 free_actions_list ((char **) al); 12220} 12221 12222static void 12223free_actions_list (char **actions_list) 12224{ 12225 int ndx; 12226 12227 if (actions_list == 0) 12228 return; 12229 12230 for (ndx = 0; actions_list[ndx]; ndx++) 12231 xfree (actions_list[ndx]); 12232 12233 xfree (actions_list); 12234} 12235 12236/* Recursive routine to walk through command list including loops, and 12237 download packets for each command. */ 12238 12239static void 12240remote_download_command_source (int num, ULONGEST addr, 12241 struct command_line *cmds) 12242{ 12243 struct remote_state *rs = get_remote_state (); 12244 struct command_line *cmd; 12245 12246 for (cmd = cmds; cmd; cmd = cmd->next) 12247 { 12248 QUIT; /* Allow user to bail out with ^C. */ 12249 strcpy (rs->buf, "QTDPsrc:"); 12250 encode_source_string (num, addr, "cmd", cmd->line, 12251 rs->buf + strlen (rs->buf), 12252 rs->buf_size - strlen (rs->buf)); 12253 putpkt (rs->buf); 12254 remote_get_noisy_reply (&target_buf, &target_buf_size); 12255 if (strcmp (target_buf, "OK")) 12256 warning (_("Target does not support source download.")); 12257 12258 if (cmd->control_type == while_control 12259 || cmd->control_type == while_stepping_control) 12260 { 12261 remote_download_command_source (num, addr, *cmd->body_list); 12262 12263 QUIT; /* Allow user to bail out with ^C. */ 12264 strcpy (rs->buf, "QTDPsrc:"); 12265 encode_source_string (num, addr, "cmd", "end", 12266 rs->buf + strlen (rs->buf), 12267 rs->buf_size - strlen (rs->buf)); 12268 putpkt (rs->buf); 12269 remote_get_noisy_reply (&target_buf, &target_buf_size); 12270 if (strcmp (target_buf, "OK")) 12271 warning (_("Target does not support source download.")); 12272 } 12273 } 12274} 12275 12276static void 12277remote_download_tracepoint (struct target_ops *self, struct bp_location *loc) 12278{ 12279#define BUF_SIZE 2048 12280 12281 CORE_ADDR tpaddr; 12282 char addrbuf[40]; 12283 char buf[BUF_SIZE]; 12284 char **tdp_actions; 12285 char **stepping_actions; 12286 int ndx; 12287 struct cleanup *old_chain = NULL; 12288 char *pkt; 12289 struct breakpoint *b = loc->owner; 12290 struct tracepoint *t = (struct tracepoint *) b; 12291 12292 encode_actions_rsp (loc, &tdp_actions, &stepping_actions); 12293 old_chain = make_cleanup (free_actions_list_cleanup_wrapper, 12294 tdp_actions); 12295 (void) make_cleanup (free_actions_list_cleanup_wrapper, 12296 stepping_actions); 12297 12298 tpaddr = loc->address; 12299 sprintf_vma (addrbuf, tpaddr); 12300 xsnprintf (buf, BUF_SIZE, "QTDP:%x:%s:%c:%lx:%x", b->number, 12301 addrbuf, /* address */ 12302 (b->enable_state == bp_enabled ? 'E' : 'D'), 12303 t->step_count, t->pass_count); 12304 /* Fast tracepoints are mostly handled by the target, but we can 12305 tell the target how big of an instruction block should be moved 12306 around. */ 12307 if (b->type == bp_fast_tracepoint) 12308 { 12309 /* Only test for support at download time; we may not know 12310 target capabilities at definition time. */ 12311 if (remote_supports_fast_tracepoints ()) 12312 { 12313 if (gdbarch_fast_tracepoint_valid_at (loc->gdbarch, tpaddr, 12314 NULL)) 12315 xsnprintf (buf + strlen (buf), BUF_SIZE - strlen (buf), ":F%x", 12316 gdb_insn_length (loc->gdbarch, tpaddr)); 12317 else 12318 /* If it passed validation at definition but fails now, 12319 something is very wrong. */ 12320 internal_error (__FILE__, __LINE__, 12321 _("Fast tracepoint not " 12322 "valid during download")); 12323 } 12324 else 12325 /* Fast tracepoints are functionally identical to regular 12326 tracepoints, so don't take lack of support as a reason to 12327 give up on the trace run. */ 12328 warning (_("Target does not support fast tracepoints, " 12329 "downloading %d as regular tracepoint"), b->number); 12330 } 12331 else if (b->type == bp_static_tracepoint) 12332 { 12333 /* Only test for support at download time; we may not know 12334 target capabilities at definition time. */ 12335 if (remote_supports_static_tracepoints ()) 12336 { 12337 struct static_tracepoint_marker marker; 12338 12339 if (target_static_tracepoint_marker_at (tpaddr, &marker)) 12340 strcat (buf, ":S"); 12341 else 12342 error (_("Static tracepoint not valid during download")); 12343 } 12344 else 12345 /* Fast tracepoints are functionally identical to regular 12346 tracepoints, so don't take lack of support as a reason 12347 to give up on the trace run. */ 12348 error (_("Target does not support static tracepoints")); 12349 } 12350 /* If the tracepoint has a conditional, make it into an agent 12351 expression and append to the definition. */ 12352 if (loc->cond) 12353 { 12354 /* Only test support at download time, we may not know target 12355 capabilities at definition time. */ 12356 if (remote_supports_cond_tracepoints ()) 12357 { 12358 agent_expr_up aexpr = gen_eval_for_expr (tpaddr, loc->cond.get ()); 12359 xsnprintf (buf + strlen (buf), BUF_SIZE - strlen (buf), ":X%x,", 12360 aexpr->len); 12361 pkt = buf + strlen (buf); 12362 for (ndx = 0; ndx < aexpr->len; ++ndx) 12363 pkt = pack_hex_byte (pkt, aexpr->buf[ndx]); 12364 *pkt = '\0'; 12365 } 12366 else 12367 warning (_("Target does not support conditional tracepoints, " 12368 "ignoring tp %d cond"), b->number); 12369 } 12370 12371 if (b->commands || *default_collect) 12372 strcat (buf, "-"); 12373 putpkt (buf); 12374 remote_get_noisy_reply (&target_buf, &target_buf_size); 12375 if (strcmp (target_buf, "OK")) 12376 error (_("Target does not support tracepoints.")); 12377 12378 /* do_single_steps (t); */ 12379 if (tdp_actions) 12380 { 12381 for (ndx = 0; tdp_actions[ndx]; ndx++) 12382 { 12383 QUIT; /* Allow user to bail out with ^C. */ 12384 xsnprintf (buf, BUF_SIZE, "QTDP:-%x:%s:%s%c", 12385 b->number, addrbuf, /* address */ 12386 tdp_actions[ndx], 12387 ((tdp_actions[ndx + 1] || stepping_actions) 12388 ? '-' : 0)); 12389 putpkt (buf); 12390 remote_get_noisy_reply (&target_buf, 12391 &target_buf_size); 12392 if (strcmp (target_buf, "OK")) 12393 error (_("Error on target while setting tracepoints.")); 12394 } 12395 } 12396 if (stepping_actions) 12397 { 12398 for (ndx = 0; stepping_actions[ndx]; ndx++) 12399 { 12400 QUIT; /* Allow user to bail out with ^C. */ 12401 xsnprintf (buf, BUF_SIZE, "QTDP:-%x:%s:%s%s%s", 12402 b->number, addrbuf, /* address */ 12403 ((ndx == 0) ? "S" : ""), 12404 stepping_actions[ndx], 12405 (stepping_actions[ndx + 1] ? "-" : "")); 12406 putpkt (buf); 12407 remote_get_noisy_reply (&target_buf, 12408 &target_buf_size); 12409 if (strcmp (target_buf, "OK")) 12410 error (_("Error on target while setting tracepoints.")); 12411 } 12412 } 12413 12414 if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE) 12415 { 12416 if (b->location != NULL) 12417 { 12418 strcpy (buf, "QTDPsrc:"); 12419 encode_source_string (b->number, loc->address, "at", 12420 event_location_to_string (b->location.get ()), 12421 buf + strlen (buf), 2048 - strlen (buf)); 12422 putpkt (buf); 12423 remote_get_noisy_reply (&target_buf, &target_buf_size); 12424 if (strcmp (target_buf, "OK")) 12425 warning (_("Target does not support source download.")); 12426 } 12427 if (b->cond_string) 12428 { 12429 strcpy (buf, "QTDPsrc:"); 12430 encode_source_string (b->number, loc->address, 12431 "cond", b->cond_string, buf + strlen (buf), 12432 2048 - strlen (buf)); 12433 putpkt (buf); 12434 remote_get_noisy_reply (&target_buf, &target_buf_size); 12435 if (strcmp (target_buf, "OK")) 12436 warning (_("Target does not support source download.")); 12437 } 12438 remote_download_command_source (b->number, loc->address, 12439 breakpoint_commands (b)); 12440 } 12441 12442 do_cleanups (old_chain); 12443} 12444 12445static int 12446remote_can_download_tracepoint (struct target_ops *self) 12447{ 12448 struct remote_state *rs = get_remote_state (); 12449 struct trace_status *ts; 12450 int status; 12451 12452 /* Don't try to install tracepoints until we've relocated our 12453 symbols, and fetched and merged the target's tracepoint list with 12454 ours. */ 12455 if (rs->starting_up) 12456 return 0; 12457 12458 ts = current_trace_status (); 12459 status = remote_get_trace_status (self, ts); 12460 12461 if (status == -1 || !ts->running_known || !ts->running) 12462 return 0; 12463 12464 /* If we are in a tracing experiment, but remote stub doesn't support 12465 installing tracepoint in trace, we have to return. */ 12466 if (!remote_supports_install_in_trace ()) 12467 return 0; 12468 12469 return 1; 12470} 12471 12472 12473static void 12474remote_download_trace_state_variable (struct target_ops *self, 12475 struct trace_state_variable *tsv) 12476{ 12477 struct remote_state *rs = get_remote_state (); 12478 char *p; 12479 12480 xsnprintf (rs->buf, get_remote_packet_size (), "QTDV:%x:%s:%x:", 12481 tsv->number, phex ((ULONGEST) tsv->initial_value, 8), 12482 tsv->builtin); 12483 p = rs->buf + strlen (rs->buf); 12484 if ((p - rs->buf) + strlen (tsv->name) * 2 >= get_remote_packet_size ()) 12485 error (_("Trace state variable name too long for tsv definition packet")); 12486 p += 2 * bin2hex ((gdb_byte *) (tsv->name), p, strlen (tsv->name)); 12487 *p++ = '\0'; 12488 putpkt (rs->buf); 12489 remote_get_noisy_reply (&target_buf, &target_buf_size); 12490 if (*target_buf == '\0') 12491 error (_("Target does not support this command.")); 12492 if (strcmp (target_buf, "OK") != 0) 12493 error (_("Error on target while downloading trace state variable.")); 12494} 12495 12496static void 12497remote_enable_tracepoint (struct target_ops *self, 12498 struct bp_location *location) 12499{ 12500 struct remote_state *rs = get_remote_state (); 12501 char addr_buf[40]; 12502 12503 sprintf_vma (addr_buf, location->address); 12504 xsnprintf (rs->buf, get_remote_packet_size (), "QTEnable:%x:%s", 12505 location->owner->number, addr_buf); 12506 putpkt (rs->buf); 12507 remote_get_noisy_reply (&rs->buf, &rs->buf_size); 12508 if (*rs->buf == '\0') 12509 error (_("Target does not support enabling tracepoints while a trace run is ongoing.")); 12510 if (strcmp (rs->buf, "OK") != 0) 12511 error (_("Error on target while enabling tracepoint.")); 12512} 12513 12514static void 12515remote_disable_tracepoint (struct target_ops *self, 12516 struct bp_location *location) 12517{ 12518 struct remote_state *rs = get_remote_state (); 12519 char addr_buf[40]; 12520 12521 sprintf_vma (addr_buf, location->address); 12522 xsnprintf (rs->buf, get_remote_packet_size (), "QTDisable:%x:%s", 12523 location->owner->number, addr_buf); 12524 putpkt (rs->buf); 12525 remote_get_noisy_reply (&rs->buf, &rs->buf_size); 12526 if (*rs->buf == '\0') 12527 error (_("Target does not support disabling tracepoints while a trace run is ongoing.")); 12528 if (strcmp (rs->buf, "OK") != 0) 12529 error (_("Error on target while disabling tracepoint.")); 12530} 12531 12532static void 12533remote_trace_set_readonly_regions (struct target_ops *self) 12534{ 12535 asection *s; 12536 bfd *abfd = NULL; 12537 bfd_size_type size; 12538 bfd_vma vma; 12539 int anysecs = 0; 12540 int offset = 0; 12541 12542 if (!exec_bfd) 12543 return; /* No information to give. */ 12544 12545 strcpy (target_buf, "QTro"); 12546 offset = strlen (target_buf); 12547 for (s = exec_bfd->sections; s; s = s->next) 12548 { 12549 char tmp1[40], tmp2[40]; 12550 int sec_length; 12551 12552 if ((s->flags & SEC_LOAD) == 0 || 12553 /* (s->flags & SEC_CODE) == 0 || */ 12554 (s->flags & SEC_READONLY) == 0) 12555 continue; 12556 12557 anysecs = 1; 12558 vma = bfd_get_section_vma (abfd, s); 12559 size = bfd_get_section_size (s); 12560 sprintf_vma (tmp1, vma); 12561 sprintf_vma (tmp2, vma + size); 12562 sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2); 12563 if (offset + sec_length + 1 > target_buf_size) 12564 { 12565 if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE) 12566 warning (_("\ 12567Too many sections for read-only sections definition packet.")); 12568 break; 12569 } 12570 xsnprintf (target_buf + offset, target_buf_size - offset, ":%s,%s", 12571 tmp1, tmp2); 12572 offset += sec_length; 12573 } 12574 if (anysecs) 12575 { 12576 putpkt (target_buf); 12577 getpkt (&target_buf, &target_buf_size, 0); 12578 } 12579} 12580 12581static void 12582remote_trace_start (struct target_ops *self) 12583{ 12584 putpkt ("QTStart"); 12585 remote_get_noisy_reply (&target_buf, &target_buf_size); 12586 if (*target_buf == '\0') 12587 error (_("Target does not support this command.")); 12588 if (strcmp (target_buf, "OK") != 0) 12589 error (_("Bogus reply from target: %s"), target_buf); 12590} 12591 12592static int 12593remote_get_trace_status (struct target_ops *self, struct trace_status *ts) 12594{ 12595 /* Initialize it just to avoid a GCC false warning. */ 12596 char *p = NULL; 12597 /* FIXME we need to get register block size some other way. */ 12598 extern int trace_regblock_size; 12599 enum packet_result result; 12600 12601 if (packet_support (PACKET_qTStatus) == PACKET_DISABLE) 12602 return -1; 12603 12604 trace_regblock_size = get_remote_arch_state ()->sizeof_g_packet; 12605 12606 putpkt ("qTStatus"); 12607 12608 TRY 12609 { 12610 p = remote_get_noisy_reply (&target_buf, &target_buf_size); 12611 } 12612 CATCH (ex, RETURN_MASK_ERROR) 12613 { 12614 if (ex.error != TARGET_CLOSE_ERROR) 12615 { 12616 exception_fprintf (gdb_stderr, ex, "qTStatus: "); 12617 return -1; 12618 } 12619 throw_exception (ex); 12620 } 12621 END_CATCH 12622 12623 result = packet_ok (p, &remote_protocol_packets[PACKET_qTStatus]); 12624 12625 /* If the remote target doesn't do tracing, flag it. */ 12626 if (result == PACKET_UNKNOWN) 12627 return -1; 12628 12629 /* We're working with a live target. */ 12630 ts->filename = NULL; 12631 12632 if (*p++ != 'T') 12633 error (_("Bogus trace status reply from target: %s"), target_buf); 12634 12635 /* Function 'parse_trace_status' sets default value of each field of 12636 'ts' at first, so we don't have to do it here. */ 12637 parse_trace_status (p, ts); 12638 12639 return ts->running; 12640} 12641 12642static void 12643remote_get_tracepoint_status (struct target_ops *self, struct breakpoint *bp, 12644 struct uploaded_tp *utp) 12645{ 12646 struct remote_state *rs = get_remote_state (); 12647 char *reply; 12648 struct bp_location *loc; 12649 struct tracepoint *tp = (struct tracepoint *) bp; 12650 size_t size = get_remote_packet_size (); 12651 12652 if (tp) 12653 { 12654 tp->base.hit_count = 0; 12655 tp->traceframe_usage = 0; 12656 for (loc = tp->base.loc; loc; loc = loc->next) 12657 { 12658 /* If the tracepoint was never downloaded, don't go asking for 12659 any status. */ 12660 if (tp->number_on_target == 0) 12661 continue; 12662 xsnprintf (rs->buf, size, "qTP:%x:%s", tp->number_on_target, 12663 phex_nz (loc->address, 0)); 12664 putpkt (rs->buf); 12665 reply = remote_get_noisy_reply (&target_buf, &target_buf_size); 12666 if (reply && *reply) 12667 { 12668 if (*reply == 'V') 12669 parse_tracepoint_status (reply + 1, bp, utp); 12670 } 12671 } 12672 } 12673 else if (utp) 12674 { 12675 utp->hit_count = 0; 12676 utp->traceframe_usage = 0; 12677 xsnprintf (rs->buf, size, "qTP:%x:%s", utp->number, 12678 phex_nz (utp->addr, 0)); 12679 putpkt (rs->buf); 12680 reply = remote_get_noisy_reply (&target_buf, &target_buf_size); 12681 if (reply && *reply) 12682 { 12683 if (*reply == 'V') 12684 parse_tracepoint_status (reply + 1, bp, utp); 12685 } 12686 } 12687} 12688 12689static void 12690remote_trace_stop (struct target_ops *self) 12691{ 12692 putpkt ("QTStop"); 12693 remote_get_noisy_reply (&target_buf, &target_buf_size); 12694 if (*target_buf == '\0') 12695 error (_("Target does not support this command.")); 12696 if (strcmp (target_buf, "OK") != 0) 12697 error (_("Bogus reply from target: %s"), target_buf); 12698} 12699 12700static int 12701remote_trace_find (struct target_ops *self, 12702 enum trace_find_type type, int num, 12703 CORE_ADDR addr1, CORE_ADDR addr2, 12704 int *tpp) 12705{ 12706 struct remote_state *rs = get_remote_state (); 12707 char *endbuf = rs->buf + get_remote_packet_size (); 12708 char *p, *reply; 12709 int target_frameno = -1, target_tracept = -1; 12710 12711 /* Lookups other than by absolute frame number depend on the current 12712 trace selected, so make sure it is correct on the remote end 12713 first. */ 12714 if (type != tfind_number) 12715 set_remote_traceframe (); 12716 12717 p = rs->buf; 12718 strcpy (p, "QTFrame:"); 12719 p = strchr (p, '\0'); 12720 switch (type) 12721 { 12722 case tfind_number: 12723 xsnprintf (p, endbuf - p, "%x", num); 12724 break; 12725 case tfind_pc: 12726 xsnprintf (p, endbuf - p, "pc:%s", phex_nz (addr1, 0)); 12727 break; 12728 case tfind_tp: 12729 xsnprintf (p, endbuf - p, "tdp:%x", num); 12730 break; 12731 case tfind_range: 12732 xsnprintf (p, endbuf - p, "range:%s:%s", phex_nz (addr1, 0), 12733 phex_nz (addr2, 0)); 12734 break; 12735 case tfind_outside: 12736 xsnprintf (p, endbuf - p, "outside:%s:%s", phex_nz (addr1, 0), 12737 phex_nz (addr2, 0)); 12738 break; 12739 default: 12740 error (_("Unknown trace find type %d"), type); 12741 } 12742 12743 putpkt (rs->buf); 12744 reply = remote_get_noisy_reply (&(rs->buf), &rs->buf_size); 12745 if (*reply == '\0') 12746 error (_("Target does not support this command.")); 12747 12748 while (reply && *reply) 12749 switch (*reply) 12750 { 12751 case 'F': 12752 p = ++reply; 12753 target_frameno = (int) strtol (p, &reply, 16); 12754 if (reply == p) 12755 error (_("Unable to parse trace frame number")); 12756 /* Don't update our remote traceframe number cache on failure 12757 to select a remote traceframe. */ 12758 if (target_frameno == -1) 12759 return -1; 12760 break; 12761 case 'T': 12762 p = ++reply; 12763 target_tracept = (int) strtol (p, &reply, 16); 12764 if (reply == p) 12765 error (_("Unable to parse tracepoint number")); 12766 break; 12767 case 'O': /* "OK"? */ 12768 if (reply[1] == 'K' && reply[2] == '\0') 12769 reply += 2; 12770 else 12771 error (_("Bogus reply from target: %s"), reply); 12772 break; 12773 default: 12774 error (_("Bogus reply from target: %s"), reply); 12775 } 12776 if (tpp) 12777 *tpp = target_tracept; 12778 12779 rs->remote_traceframe_number = target_frameno; 12780 return target_frameno; 12781} 12782 12783static int 12784remote_get_trace_state_variable_value (struct target_ops *self, 12785 int tsvnum, LONGEST *val) 12786{ 12787 struct remote_state *rs = get_remote_state (); 12788 char *reply; 12789 ULONGEST uval; 12790 12791 set_remote_traceframe (); 12792 12793 xsnprintf (rs->buf, get_remote_packet_size (), "qTV:%x", tsvnum); 12794 putpkt (rs->buf); 12795 reply = remote_get_noisy_reply (&target_buf, &target_buf_size); 12796 if (reply && *reply) 12797 { 12798 if (*reply == 'V') 12799 { 12800 unpack_varlen_hex (reply + 1, &uval); 12801 *val = (LONGEST) uval; 12802 return 1; 12803 } 12804 } 12805 return 0; 12806} 12807 12808static int 12809remote_save_trace_data (struct target_ops *self, const char *filename) 12810{ 12811 struct remote_state *rs = get_remote_state (); 12812 char *p, *reply; 12813 12814 p = rs->buf; 12815 strcpy (p, "QTSave:"); 12816 p += strlen (p); 12817 if ((p - rs->buf) + strlen (filename) * 2 >= get_remote_packet_size ()) 12818 error (_("Remote file name too long for trace save packet")); 12819 p += 2 * bin2hex ((gdb_byte *) filename, p, strlen (filename)); 12820 *p++ = '\0'; 12821 putpkt (rs->buf); 12822 reply = remote_get_noisy_reply (&target_buf, &target_buf_size); 12823 if (*reply == '\0') 12824 error (_("Target does not support this command.")); 12825 if (strcmp (reply, "OK") != 0) 12826 error (_("Bogus reply from target: %s"), reply); 12827 return 0; 12828} 12829 12830/* This is basically a memory transfer, but needs to be its own packet 12831 because we don't know how the target actually organizes its trace 12832 memory, plus we want to be able to ask for as much as possible, but 12833 not be unhappy if we don't get as much as we ask for. */ 12834 12835static LONGEST 12836remote_get_raw_trace_data (struct target_ops *self, 12837 gdb_byte *buf, ULONGEST offset, LONGEST len) 12838{ 12839 struct remote_state *rs = get_remote_state (); 12840 char *reply; 12841 char *p; 12842 int rslt; 12843 12844 p = rs->buf; 12845 strcpy (p, "qTBuffer:"); 12846 p += strlen (p); 12847 p += hexnumstr (p, offset); 12848 *p++ = ','; 12849 p += hexnumstr (p, len); 12850 *p++ = '\0'; 12851 12852 putpkt (rs->buf); 12853 reply = remote_get_noisy_reply (&target_buf, &target_buf_size); 12854 if (reply && *reply) 12855 { 12856 /* 'l' by itself means we're at the end of the buffer and 12857 there is nothing more to get. */ 12858 if (*reply == 'l') 12859 return 0; 12860 12861 /* Convert the reply into binary. Limit the number of bytes to 12862 convert according to our passed-in buffer size, rather than 12863 what was returned in the packet; if the target is 12864 unexpectedly generous and gives us a bigger reply than we 12865 asked for, we don't want to crash. */ 12866 rslt = hex2bin (target_buf, buf, len); 12867 return rslt; 12868 } 12869 12870 /* Something went wrong, flag as an error. */ 12871 return -1; 12872} 12873 12874static void 12875remote_set_disconnected_tracing (struct target_ops *self, int val) 12876{ 12877 struct remote_state *rs = get_remote_state (); 12878 12879 if (packet_support (PACKET_DisconnectedTracing_feature) == PACKET_ENABLE) 12880 { 12881 char *reply; 12882 12883 xsnprintf (rs->buf, get_remote_packet_size (), "QTDisconnected:%x", val); 12884 putpkt (rs->buf); 12885 reply = remote_get_noisy_reply (&target_buf, &target_buf_size); 12886 if (*reply == '\0') 12887 error (_("Target does not support this command.")); 12888 if (strcmp (reply, "OK") != 0) 12889 error (_("Bogus reply from target: %s"), reply); 12890 } 12891 else if (val) 12892 warning (_("Target does not support disconnected tracing.")); 12893} 12894 12895static int 12896remote_core_of_thread (struct target_ops *ops, ptid_t ptid) 12897{ 12898 struct thread_info *info = find_thread_ptid (ptid); 12899 12900 if (info && info->priv) 12901 return info->priv->core; 12902 return -1; 12903} 12904 12905static void 12906remote_set_circular_trace_buffer (struct target_ops *self, int val) 12907{ 12908 struct remote_state *rs = get_remote_state (); 12909 char *reply; 12910 12911 xsnprintf (rs->buf, get_remote_packet_size (), "QTBuffer:circular:%x", val); 12912 putpkt (rs->buf); 12913 reply = remote_get_noisy_reply (&target_buf, &target_buf_size); 12914 if (*reply == '\0') 12915 error (_("Target does not support this command.")); 12916 if (strcmp (reply, "OK") != 0) 12917 error (_("Bogus reply from target: %s"), reply); 12918} 12919 12920static struct traceframe_info * 12921remote_traceframe_info (struct target_ops *self) 12922{ 12923 char *text; 12924 12925 text = target_read_stralloc (¤t_target, 12926 TARGET_OBJECT_TRACEFRAME_INFO, NULL); 12927 if (text != NULL) 12928 { 12929 struct traceframe_info *info; 12930 struct cleanup *back_to = make_cleanup (xfree, text); 12931 12932 info = parse_traceframe_info (text); 12933 do_cleanups (back_to); 12934 return info; 12935 } 12936 12937 return NULL; 12938} 12939 12940/* Handle the qTMinFTPILen packet. Returns the minimum length of 12941 instruction on which a fast tracepoint may be placed. Returns -1 12942 if the packet is not supported, and 0 if the minimum instruction 12943 length is unknown. */ 12944 12945static int 12946remote_get_min_fast_tracepoint_insn_len (struct target_ops *self) 12947{ 12948 struct remote_state *rs = get_remote_state (); 12949 char *reply; 12950 12951 /* If we're not debugging a process yet, the IPA can't be 12952 loaded. */ 12953 if (!target_has_execution) 12954 return 0; 12955 12956 /* Make sure the remote is pointing at the right process. */ 12957 set_general_process (); 12958 12959 xsnprintf (rs->buf, get_remote_packet_size (), "qTMinFTPILen"); 12960 putpkt (rs->buf); 12961 reply = remote_get_noisy_reply (&target_buf, &target_buf_size); 12962 if (*reply == '\0') 12963 return -1; 12964 else 12965 { 12966 ULONGEST min_insn_len; 12967 12968 unpack_varlen_hex (reply, &min_insn_len); 12969 12970 return (int) min_insn_len; 12971 } 12972} 12973 12974static void 12975remote_set_trace_buffer_size (struct target_ops *self, LONGEST val) 12976{ 12977 if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE) 12978 { 12979 struct remote_state *rs = get_remote_state (); 12980 char *buf = rs->buf; 12981 char *endbuf = rs->buf + get_remote_packet_size (); 12982 enum packet_result result; 12983 12984 gdb_assert (val >= 0 || val == -1); 12985 buf += xsnprintf (buf, endbuf - buf, "QTBuffer:size:"); 12986 /* Send -1 as literal "-1" to avoid host size dependency. */ 12987 if (val < 0) 12988 { 12989 *buf++ = '-'; 12990 buf += hexnumstr (buf, (ULONGEST) -val); 12991 } 12992 else 12993 buf += hexnumstr (buf, (ULONGEST) val); 12994 12995 putpkt (rs->buf); 12996 remote_get_noisy_reply (&rs->buf, &rs->buf_size); 12997 result = packet_ok (rs->buf, 12998 &remote_protocol_packets[PACKET_QTBuffer_size]); 12999 13000 if (result != PACKET_OK) 13001 warning (_("Bogus reply from target: %s"), rs->buf); 13002 } 13003} 13004 13005static int 13006remote_set_trace_notes (struct target_ops *self, 13007 const char *user, const char *notes, 13008 const char *stop_notes) 13009{ 13010 struct remote_state *rs = get_remote_state (); 13011 char *reply; 13012 char *buf = rs->buf; 13013 char *endbuf = rs->buf + get_remote_packet_size (); 13014 int nbytes; 13015 13016 buf += xsnprintf (buf, endbuf - buf, "QTNotes:"); 13017 if (user) 13018 { 13019 buf += xsnprintf (buf, endbuf - buf, "user:"); 13020 nbytes = bin2hex ((gdb_byte *) user, buf, strlen (user)); 13021 buf += 2 * nbytes; 13022 *buf++ = ';'; 13023 } 13024 if (notes) 13025 { 13026 buf += xsnprintf (buf, endbuf - buf, "notes:"); 13027 nbytes = bin2hex ((gdb_byte *) notes, buf, strlen (notes)); 13028 buf += 2 * nbytes; 13029 *buf++ = ';'; 13030 } 13031 if (stop_notes) 13032 { 13033 buf += xsnprintf (buf, endbuf - buf, "tstop:"); 13034 nbytes = bin2hex ((gdb_byte *) stop_notes, buf, strlen (stop_notes)); 13035 buf += 2 * nbytes; 13036 *buf++ = ';'; 13037 } 13038 /* Ensure the buffer is terminated. */ 13039 *buf = '\0'; 13040 13041 putpkt (rs->buf); 13042 reply = remote_get_noisy_reply (&target_buf, &target_buf_size); 13043 if (*reply == '\0') 13044 return 0; 13045 13046 if (strcmp (reply, "OK") != 0) 13047 error (_("Bogus reply from target: %s"), reply); 13048 13049 return 1; 13050} 13051 13052static int 13053remote_use_agent (struct target_ops *self, int use) 13054{ 13055 if (packet_support (PACKET_QAgent) != PACKET_DISABLE) 13056 { 13057 struct remote_state *rs = get_remote_state (); 13058 13059 /* If the stub supports QAgent. */ 13060 xsnprintf (rs->buf, get_remote_packet_size (), "QAgent:%d", use); 13061 putpkt (rs->buf); 13062 getpkt (&rs->buf, &rs->buf_size, 0); 13063 13064 if (strcmp (rs->buf, "OK") == 0) 13065 { 13066 use_agent = use; 13067 return 1; 13068 } 13069 } 13070 13071 return 0; 13072} 13073 13074static int 13075remote_can_use_agent (struct target_ops *self) 13076{ 13077 return (packet_support (PACKET_QAgent) != PACKET_DISABLE); 13078} 13079 13080struct btrace_target_info 13081{ 13082 /* The ptid of the traced thread. */ 13083 ptid_t ptid; 13084 13085 /* The obtained branch trace configuration. */ 13086 struct btrace_config conf; 13087}; 13088 13089/* Reset our idea of our target's btrace configuration. */ 13090 13091static void 13092remote_btrace_reset (void) 13093{ 13094 struct remote_state *rs = get_remote_state (); 13095 13096 memset (&rs->btrace_config, 0, sizeof (rs->btrace_config)); 13097} 13098 13099/* Check whether the target supports branch tracing. */ 13100 13101static int 13102remote_supports_btrace (struct target_ops *self, enum btrace_format format) 13103{ 13104 if (packet_support (PACKET_Qbtrace_off) != PACKET_ENABLE) 13105 return 0; 13106 if (packet_support (PACKET_qXfer_btrace) != PACKET_ENABLE) 13107 return 0; 13108 13109 switch (format) 13110 { 13111 case BTRACE_FORMAT_NONE: 13112 return 0; 13113 13114 case BTRACE_FORMAT_BTS: 13115 return (packet_support (PACKET_Qbtrace_bts) == PACKET_ENABLE); 13116 13117 case BTRACE_FORMAT_PT: 13118 /* The trace is decoded on the host. Even if our target supports it, 13119 we still need to have libipt to decode the trace. */ 13120#if defined (HAVE_LIBIPT) 13121 return (packet_support (PACKET_Qbtrace_pt) == PACKET_ENABLE); 13122#else /* !defined (HAVE_LIBIPT) */ 13123 return 0; 13124#endif /* !defined (HAVE_LIBIPT) */ 13125 } 13126 13127 internal_error (__FILE__, __LINE__, _("Unknown branch trace format")); 13128} 13129 13130/* Synchronize the configuration with the target. */ 13131 13132static void 13133btrace_sync_conf (const struct btrace_config *conf) 13134{ 13135 struct packet_config *packet; 13136 struct remote_state *rs; 13137 char *buf, *pos, *endbuf; 13138 13139 rs = get_remote_state (); 13140 buf = rs->buf; 13141 endbuf = buf + get_remote_packet_size (); 13142 13143 packet = &remote_protocol_packets[PACKET_Qbtrace_conf_bts_size]; 13144 if (packet_config_support (packet) == PACKET_ENABLE 13145 && conf->bts.size != rs->btrace_config.bts.size) 13146 { 13147 pos = buf; 13148 pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name, 13149 conf->bts.size); 13150 13151 putpkt (buf); 13152 getpkt (&buf, &rs->buf_size, 0); 13153 13154 if (packet_ok (buf, packet) == PACKET_ERROR) 13155 { 13156 if (buf[0] == 'E' && buf[1] == '.') 13157 error (_("Failed to configure the BTS buffer size: %s"), buf + 2); 13158 else 13159 error (_("Failed to configure the BTS buffer size.")); 13160 } 13161 13162 rs->btrace_config.bts.size = conf->bts.size; 13163 } 13164 13165 packet = &remote_protocol_packets[PACKET_Qbtrace_conf_pt_size]; 13166 if (packet_config_support (packet) == PACKET_ENABLE 13167 && conf->pt.size != rs->btrace_config.pt.size) 13168 { 13169 pos = buf; 13170 pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name, 13171 conf->pt.size); 13172 13173 putpkt (buf); 13174 getpkt (&buf, &rs->buf_size, 0); 13175 13176 if (packet_ok (buf, packet) == PACKET_ERROR) 13177 { 13178 if (buf[0] == 'E' && buf[1] == '.') 13179 error (_("Failed to configure the trace buffer size: %s"), buf + 2); 13180 else 13181 error (_("Failed to configure the trace buffer size.")); 13182 } 13183 13184 rs->btrace_config.pt.size = conf->pt.size; 13185 } 13186} 13187 13188/* Read the current thread's btrace configuration from the target and 13189 store it into CONF. */ 13190 13191static void 13192btrace_read_config (struct btrace_config *conf) 13193{ 13194 char *xml; 13195 13196 xml = target_read_stralloc (¤t_target, 13197 TARGET_OBJECT_BTRACE_CONF, ""); 13198 if (xml != NULL) 13199 { 13200 struct cleanup *cleanup; 13201 13202 cleanup = make_cleanup (xfree, xml); 13203 parse_xml_btrace_conf (conf, xml); 13204 do_cleanups (cleanup); 13205 } 13206} 13207 13208/* Maybe reopen target btrace. */ 13209 13210static void 13211remote_btrace_maybe_reopen (void) 13212{ 13213 struct remote_state *rs = get_remote_state (); 13214 struct cleanup *cleanup; 13215 struct thread_info *tp; 13216 int btrace_target_pushed = 0; 13217 int warned = 0; 13218 13219 cleanup = make_cleanup_restore_current_thread (); 13220 ALL_NON_EXITED_THREADS (tp) 13221 { 13222 set_general_thread (tp->ptid); 13223 13224 memset (&rs->btrace_config, 0x00, sizeof (struct btrace_config)); 13225 btrace_read_config (&rs->btrace_config); 13226 13227 if (rs->btrace_config.format == BTRACE_FORMAT_NONE) 13228 continue; 13229 13230#if !defined (HAVE_LIBIPT) 13231 if (rs->btrace_config.format == BTRACE_FORMAT_PT) 13232 { 13233 if (!warned) 13234 { 13235 warned = 1; 13236 warning (_("GDB does not support Intel Processor Trace. " 13237 "\"record\" will not work in this session.")); 13238 } 13239 13240 continue; 13241 } 13242#endif /* !defined (HAVE_LIBIPT) */ 13243 13244 /* Push target, once, but before anything else happens. This way our 13245 changes to the threads will be cleaned up by unpushing the target 13246 in case btrace_read_config () throws. */ 13247 if (!btrace_target_pushed) 13248 { 13249 btrace_target_pushed = 1; 13250 record_btrace_push_target (); 13251 printf_filtered (_("Target is recording using %s.\n"), 13252 btrace_format_string (rs->btrace_config.format)); 13253 } 13254 13255 tp->btrace.target = XCNEW (struct btrace_target_info); 13256 tp->btrace.target->ptid = tp->ptid; 13257 tp->btrace.target->conf = rs->btrace_config; 13258 } 13259 do_cleanups (cleanup); 13260} 13261 13262/* Enable branch tracing. */ 13263 13264static struct btrace_target_info * 13265remote_enable_btrace (struct target_ops *self, ptid_t ptid, 13266 const struct btrace_config *conf) 13267{ 13268 struct btrace_target_info *tinfo = NULL; 13269 struct packet_config *packet = NULL; 13270 struct remote_state *rs = get_remote_state (); 13271 char *buf = rs->buf; 13272 char *endbuf = rs->buf + get_remote_packet_size (); 13273 13274 switch (conf->format) 13275 { 13276 case BTRACE_FORMAT_BTS: 13277 packet = &remote_protocol_packets[PACKET_Qbtrace_bts]; 13278 break; 13279 13280 case BTRACE_FORMAT_PT: 13281 packet = &remote_protocol_packets[PACKET_Qbtrace_pt]; 13282 break; 13283 } 13284 13285 if (packet == NULL || packet_config_support (packet) != PACKET_ENABLE) 13286 error (_("Target does not support branch tracing.")); 13287 13288 btrace_sync_conf (conf); 13289 13290 set_general_thread (ptid); 13291 13292 buf += xsnprintf (buf, endbuf - buf, "%s", packet->name); 13293 putpkt (rs->buf); 13294 getpkt (&rs->buf, &rs->buf_size, 0); 13295 13296 if (packet_ok (rs->buf, packet) == PACKET_ERROR) 13297 { 13298 if (rs->buf[0] == 'E' && rs->buf[1] == '.') 13299 error (_("Could not enable branch tracing for %s: %s"), 13300 target_pid_to_str (ptid), rs->buf + 2); 13301 else 13302 error (_("Could not enable branch tracing for %s."), 13303 target_pid_to_str (ptid)); 13304 } 13305 13306 tinfo = XCNEW (struct btrace_target_info); 13307 tinfo->ptid = ptid; 13308 13309 /* If we fail to read the configuration, we lose some information, but the 13310 tracing itself is not impacted. */ 13311 TRY 13312 { 13313 btrace_read_config (&tinfo->conf); 13314 } 13315 CATCH (err, RETURN_MASK_ERROR) 13316 { 13317 if (err.message != NULL) 13318 warning ("%s", err.message); 13319 } 13320 END_CATCH 13321 13322 return tinfo; 13323} 13324 13325/* Disable branch tracing. */ 13326 13327static void 13328remote_disable_btrace (struct target_ops *self, 13329 struct btrace_target_info *tinfo) 13330{ 13331 struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_off]; 13332 struct remote_state *rs = get_remote_state (); 13333 char *buf = rs->buf; 13334 char *endbuf = rs->buf + get_remote_packet_size (); 13335 13336 if (packet_config_support (packet) != PACKET_ENABLE) 13337 error (_("Target does not support branch tracing.")); 13338 13339 set_general_thread (tinfo->ptid); 13340 13341 buf += xsnprintf (buf, endbuf - buf, "%s", packet->name); 13342 putpkt (rs->buf); 13343 getpkt (&rs->buf, &rs->buf_size, 0); 13344 13345 if (packet_ok (rs->buf, packet) == PACKET_ERROR) 13346 { 13347 if (rs->buf[0] == 'E' && rs->buf[1] == '.') 13348 error (_("Could not disable branch tracing for %s: %s"), 13349 target_pid_to_str (tinfo->ptid), rs->buf + 2); 13350 else 13351 error (_("Could not disable branch tracing for %s."), 13352 target_pid_to_str (tinfo->ptid)); 13353 } 13354 13355 xfree (tinfo); 13356} 13357 13358/* Teardown branch tracing. */ 13359 13360static void 13361remote_teardown_btrace (struct target_ops *self, 13362 struct btrace_target_info *tinfo) 13363{ 13364 /* We must not talk to the target during teardown. */ 13365 xfree (tinfo); 13366} 13367 13368/* Read the branch trace. */ 13369 13370static enum btrace_error 13371remote_read_btrace (struct target_ops *self, 13372 struct btrace_data *btrace, 13373 struct btrace_target_info *tinfo, 13374 enum btrace_read_type type) 13375{ 13376 struct packet_config *packet = &remote_protocol_packets[PACKET_qXfer_btrace]; 13377 struct cleanup *cleanup; 13378 const char *annex; 13379 char *xml; 13380 13381 if (packet_config_support (packet) != PACKET_ENABLE) 13382 error (_("Target does not support branch tracing.")); 13383 13384#if !defined(HAVE_LIBEXPAT) 13385 error (_("Cannot process branch tracing result. XML parsing not supported.")); 13386#endif 13387 13388 switch (type) 13389 { 13390 case BTRACE_READ_ALL: 13391 annex = "all"; 13392 break; 13393 case BTRACE_READ_NEW: 13394 annex = "new"; 13395 break; 13396 case BTRACE_READ_DELTA: 13397 annex = "delta"; 13398 break; 13399 default: 13400 internal_error (__FILE__, __LINE__, 13401 _("Bad branch tracing read type: %u."), 13402 (unsigned int) type); 13403 } 13404 13405 xml = target_read_stralloc (¤t_target, 13406 TARGET_OBJECT_BTRACE, annex); 13407 if (xml == NULL) 13408 return BTRACE_ERR_UNKNOWN; 13409 13410 cleanup = make_cleanup (xfree, xml); 13411 parse_xml_btrace (btrace, xml); 13412 do_cleanups (cleanup); 13413 13414 return BTRACE_ERR_NONE; 13415} 13416 13417static const struct btrace_config * 13418remote_btrace_conf (struct target_ops *self, 13419 const struct btrace_target_info *tinfo) 13420{ 13421 return &tinfo->conf; 13422} 13423 13424static int 13425remote_augmented_libraries_svr4_read (struct target_ops *self) 13426{ 13427 return (packet_support (PACKET_augmented_libraries_svr4_read_feature) 13428 == PACKET_ENABLE); 13429} 13430 13431/* Implementation of to_load. */ 13432 13433static void 13434remote_load (struct target_ops *self, const char *name, int from_tty) 13435{ 13436 generic_load (name, from_tty); 13437} 13438 13439/* Accepts an integer PID; returns a string representing a file that 13440 can be opened on the remote side to get the symbols for the child 13441 process. Returns NULL if the operation is not supported. */ 13442 13443static char * 13444remote_pid_to_exec_file (struct target_ops *self, int pid) 13445{ 13446 static char *filename = NULL; 13447 struct inferior *inf; 13448 char *annex = NULL; 13449 13450 if (packet_support (PACKET_qXfer_exec_file) != PACKET_ENABLE) 13451 return NULL; 13452 13453 if (filename != NULL) 13454 xfree (filename); 13455 13456 inf = find_inferior_pid (pid); 13457 if (inf == NULL) 13458 internal_error (__FILE__, __LINE__, 13459 _("not currently attached to process %d"), pid); 13460 13461 if (!inf->fake_pid_p) 13462 { 13463 const int annex_size = 9; 13464 13465 annex = (char *) alloca (annex_size); 13466 xsnprintf (annex, annex_size, "%x", pid); 13467 } 13468 13469 filename = target_read_stralloc (¤t_target, 13470 TARGET_OBJECT_EXEC_FILE, annex); 13471 13472 return filename; 13473} 13474 13475/* Implement the to_can_do_single_step target_ops method. */ 13476 13477static int 13478remote_can_do_single_step (struct target_ops *ops) 13479{ 13480 /* We can only tell whether target supports single step or not by 13481 supported s and S vCont actions if the stub supports vContSupported 13482 feature. If the stub doesn't support vContSupported feature, 13483 we have conservatively to think target doesn't supports single 13484 step. */ 13485 if (packet_support (PACKET_vContSupported) == PACKET_ENABLE) 13486 { 13487 struct remote_state *rs = get_remote_state (); 13488 13489 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN) 13490 remote_vcont_probe (rs); 13491 13492 return rs->supports_vCont.s && rs->supports_vCont.S; 13493 } 13494 else 13495 return 0; 13496} 13497 13498/* Implementation of the to_execution_direction method for the remote 13499 target. */ 13500 13501static enum exec_direction_kind 13502remote_execution_direction (struct target_ops *self) 13503{ 13504 struct remote_state *rs = get_remote_state (); 13505 13506 return rs->last_resume_exec_dir; 13507} 13508 13509static void 13510init_remote_ops (void) 13511{ 13512 remote_ops.to_shortname = "remote"; 13513 remote_ops.to_longname = "Remote serial target in gdb-specific protocol"; 13514 remote_ops.to_doc = 13515 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\ 13516Specify the serial device it is connected to\n\ 13517(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."; 13518 remote_ops.to_open = remote_open; 13519 remote_ops.to_close = remote_close; 13520 remote_ops.to_detach = remote_detach; 13521 remote_ops.to_disconnect = remote_disconnect; 13522 remote_ops.to_resume = remote_resume; 13523 remote_ops.to_commit_resume = remote_commit_resume; 13524 remote_ops.to_wait = remote_wait; 13525 remote_ops.to_fetch_registers = remote_fetch_registers; 13526 remote_ops.to_store_registers = remote_store_registers; 13527 remote_ops.to_prepare_to_store = remote_prepare_to_store; 13528 remote_ops.to_files_info = remote_files_info; 13529 remote_ops.to_insert_breakpoint = remote_insert_breakpoint; 13530 remote_ops.to_remove_breakpoint = remote_remove_breakpoint; 13531 remote_ops.to_stopped_by_sw_breakpoint = remote_stopped_by_sw_breakpoint; 13532 remote_ops.to_supports_stopped_by_sw_breakpoint = remote_supports_stopped_by_sw_breakpoint; 13533 remote_ops.to_stopped_by_hw_breakpoint = remote_stopped_by_hw_breakpoint; 13534 remote_ops.to_supports_stopped_by_hw_breakpoint = remote_supports_stopped_by_hw_breakpoint; 13535 remote_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint; 13536 remote_ops.to_stopped_data_address = remote_stopped_data_address; 13537 remote_ops.to_watchpoint_addr_within_range = 13538 remote_watchpoint_addr_within_range; 13539 remote_ops.to_can_use_hw_breakpoint = remote_check_watch_resources; 13540 remote_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint; 13541 remote_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint; 13542 remote_ops.to_region_ok_for_hw_watchpoint 13543 = remote_region_ok_for_hw_watchpoint; 13544 remote_ops.to_insert_watchpoint = remote_insert_watchpoint; 13545 remote_ops.to_remove_watchpoint = remote_remove_watchpoint; 13546 remote_ops.to_kill = remote_kill; 13547 remote_ops.to_load = remote_load; 13548 remote_ops.to_mourn_inferior = remote_mourn; 13549 remote_ops.to_pass_signals = remote_pass_signals; 13550 remote_ops.to_set_syscall_catchpoint = remote_set_syscall_catchpoint; 13551 remote_ops.to_program_signals = remote_program_signals; 13552 remote_ops.to_thread_alive = remote_thread_alive; 13553 remote_ops.to_thread_name = remote_thread_name; 13554 remote_ops.to_update_thread_list = remote_update_thread_list; 13555 remote_ops.to_pid_to_str = remote_pid_to_str; 13556 remote_ops.to_extra_thread_info = remote_threads_extra_info; 13557 remote_ops.to_get_ada_task_ptid = remote_get_ada_task_ptid; 13558 remote_ops.to_stop = remote_stop; 13559 remote_ops.to_interrupt = remote_interrupt; 13560 remote_ops.to_pass_ctrlc = remote_pass_ctrlc; 13561 remote_ops.to_xfer_partial = remote_xfer_partial; 13562 remote_ops.to_get_memory_xfer_limit = remote_get_memory_xfer_limit; 13563 remote_ops.to_rcmd = remote_rcmd; 13564 remote_ops.to_pid_to_exec_file = remote_pid_to_exec_file; 13565 remote_ops.to_log_command = serial_log_command; 13566 remote_ops.to_get_thread_local_address = remote_get_thread_local_address; 13567 remote_ops.to_stratum = process_stratum; 13568 remote_ops.to_has_all_memory = default_child_has_all_memory; 13569 remote_ops.to_has_memory = default_child_has_memory; 13570 remote_ops.to_has_stack = default_child_has_stack; 13571 remote_ops.to_has_registers = default_child_has_registers; 13572 remote_ops.to_has_execution = default_child_has_execution; 13573 remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */ 13574 remote_ops.to_can_execute_reverse = remote_can_execute_reverse; 13575 remote_ops.to_magic = OPS_MAGIC; 13576 remote_ops.to_memory_map = remote_memory_map; 13577 remote_ops.to_flash_erase = remote_flash_erase; 13578 remote_ops.to_flash_done = remote_flash_done; 13579 remote_ops.to_read_description = remote_read_description; 13580 remote_ops.to_search_memory = remote_search_memory; 13581 remote_ops.to_can_async_p = remote_can_async_p; 13582 remote_ops.to_is_async_p = remote_is_async_p; 13583 remote_ops.to_async = remote_async; 13584 remote_ops.to_thread_events = remote_thread_events; 13585 remote_ops.to_can_do_single_step = remote_can_do_single_step; 13586 remote_ops.to_terminal_inferior = remote_terminal_inferior; 13587 remote_ops.to_terminal_ours = remote_terminal_ours; 13588 remote_ops.to_supports_non_stop = remote_supports_non_stop; 13589 remote_ops.to_supports_multi_process = remote_supports_multi_process; 13590 remote_ops.to_supports_disable_randomization 13591 = remote_supports_disable_randomization; 13592 remote_ops.to_filesystem_is_local = remote_filesystem_is_local; 13593 remote_ops.to_fileio_open = remote_hostio_open; 13594 remote_ops.to_fileio_pwrite = remote_hostio_pwrite; 13595 remote_ops.to_fileio_pread = remote_hostio_pread; 13596 remote_ops.to_fileio_fstat = remote_hostio_fstat; 13597 remote_ops.to_fileio_close = remote_hostio_close; 13598 remote_ops.to_fileio_unlink = remote_hostio_unlink; 13599 remote_ops.to_fileio_readlink = remote_hostio_readlink; 13600 remote_ops.to_supports_enable_disable_tracepoint = remote_supports_enable_disable_tracepoint; 13601 remote_ops.to_supports_string_tracing = remote_supports_string_tracing; 13602 remote_ops.to_supports_evaluation_of_breakpoint_conditions = remote_supports_cond_breakpoints; 13603 remote_ops.to_can_run_breakpoint_commands = remote_can_run_breakpoint_commands; 13604 remote_ops.to_trace_init = remote_trace_init; 13605 remote_ops.to_download_tracepoint = remote_download_tracepoint; 13606 remote_ops.to_can_download_tracepoint = remote_can_download_tracepoint; 13607 remote_ops.to_download_trace_state_variable 13608 = remote_download_trace_state_variable; 13609 remote_ops.to_enable_tracepoint = remote_enable_tracepoint; 13610 remote_ops.to_disable_tracepoint = remote_disable_tracepoint; 13611 remote_ops.to_trace_set_readonly_regions = remote_trace_set_readonly_regions; 13612 remote_ops.to_trace_start = remote_trace_start; 13613 remote_ops.to_get_trace_status = remote_get_trace_status; 13614 remote_ops.to_get_tracepoint_status = remote_get_tracepoint_status; 13615 remote_ops.to_trace_stop = remote_trace_stop; 13616 remote_ops.to_trace_find = remote_trace_find; 13617 remote_ops.to_get_trace_state_variable_value 13618 = remote_get_trace_state_variable_value; 13619 remote_ops.to_save_trace_data = remote_save_trace_data; 13620 remote_ops.to_upload_tracepoints = remote_upload_tracepoints; 13621 remote_ops.to_upload_trace_state_variables 13622 = remote_upload_trace_state_variables; 13623 remote_ops.to_get_raw_trace_data = remote_get_raw_trace_data; 13624 remote_ops.to_get_min_fast_tracepoint_insn_len = remote_get_min_fast_tracepoint_insn_len; 13625 remote_ops.to_set_disconnected_tracing = remote_set_disconnected_tracing; 13626 remote_ops.to_set_circular_trace_buffer = remote_set_circular_trace_buffer; 13627 remote_ops.to_set_trace_buffer_size = remote_set_trace_buffer_size; 13628 remote_ops.to_set_trace_notes = remote_set_trace_notes; 13629 remote_ops.to_core_of_thread = remote_core_of_thread; 13630 remote_ops.to_verify_memory = remote_verify_memory; 13631 remote_ops.to_get_tib_address = remote_get_tib_address; 13632 remote_ops.to_set_permissions = remote_set_permissions; 13633 remote_ops.to_static_tracepoint_marker_at 13634 = remote_static_tracepoint_marker_at; 13635 remote_ops.to_static_tracepoint_markers_by_strid 13636 = remote_static_tracepoint_markers_by_strid; 13637 remote_ops.to_traceframe_info = remote_traceframe_info; 13638 remote_ops.to_use_agent = remote_use_agent; 13639 remote_ops.to_can_use_agent = remote_can_use_agent; 13640 remote_ops.to_supports_btrace = remote_supports_btrace; 13641 remote_ops.to_enable_btrace = remote_enable_btrace; 13642 remote_ops.to_disable_btrace = remote_disable_btrace; 13643 remote_ops.to_teardown_btrace = remote_teardown_btrace; 13644 remote_ops.to_read_btrace = remote_read_btrace; 13645 remote_ops.to_btrace_conf = remote_btrace_conf; 13646 remote_ops.to_augmented_libraries_svr4_read = 13647 remote_augmented_libraries_svr4_read; 13648 remote_ops.to_follow_fork = remote_follow_fork; 13649 remote_ops.to_follow_exec = remote_follow_exec; 13650 remote_ops.to_insert_fork_catchpoint = remote_insert_fork_catchpoint; 13651 remote_ops.to_remove_fork_catchpoint = remote_remove_fork_catchpoint; 13652 remote_ops.to_insert_vfork_catchpoint = remote_insert_vfork_catchpoint; 13653 remote_ops.to_remove_vfork_catchpoint = remote_remove_vfork_catchpoint; 13654 remote_ops.to_insert_exec_catchpoint = remote_insert_exec_catchpoint; 13655 remote_ops.to_remove_exec_catchpoint = remote_remove_exec_catchpoint; 13656 remote_ops.to_execution_direction = remote_execution_direction; 13657} 13658 13659/* Set up the extended remote vector by making a copy of the standard 13660 remote vector and adding to it. */ 13661 13662static void 13663init_extended_remote_ops (void) 13664{ 13665 extended_remote_ops = remote_ops; 13666 13667 extended_remote_ops.to_shortname = "extended-remote"; 13668 extended_remote_ops.to_longname = 13669 "Extended remote serial target in gdb-specific protocol"; 13670 extended_remote_ops.to_doc = 13671 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\ 13672Specify the serial device it is connected to (e.g. /dev/ttya)."; 13673 extended_remote_ops.to_open = extended_remote_open; 13674 extended_remote_ops.to_create_inferior = extended_remote_create_inferior; 13675 extended_remote_ops.to_detach = extended_remote_detach; 13676 extended_remote_ops.to_attach = extended_remote_attach; 13677 extended_remote_ops.to_post_attach = extended_remote_post_attach; 13678 extended_remote_ops.to_supports_disable_randomization 13679 = extended_remote_supports_disable_randomization; 13680} 13681 13682static int 13683remote_can_async_p (struct target_ops *ops) 13684{ 13685 struct remote_state *rs = get_remote_state (); 13686 13687 /* We don't go async if the user has explicitly prevented it with the 13688 "maint set target-async" command. */ 13689 if (!target_async_permitted) 13690 return 0; 13691 13692 /* We're async whenever the serial device is. */ 13693 return serial_can_async_p (rs->remote_desc); 13694} 13695 13696static int 13697remote_is_async_p (struct target_ops *ops) 13698{ 13699 struct remote_state *rs = get_remote_state (); 13700 13701 if (!target_async_permitted) 13702 /* We only enable async when the user specifically asks for it. */ 13703 return 0; 13704 13705 /* We're async whenever the serial device is. */ 13706 return serial_is_async_p (rs->remote_desc); 13707} 13708 13709/* Pass the SERIAL event on and up to the client. One day this code 13710 will be able to delay notifying the client of an event until the 13711 point where an entire packet has been received. */ 13712 13713static serial_event_ftype remote_async_serial_handler; 13714 13715static void 13716remote_async_serial_handler (struct serial *scb, void *context) 13717{ 13718 /* Don't propogate error information up to the client. Instead let 13719 the client find out about the error by querying the target. */ 13720 inferior_event_handler (INF_REG_EVENT, NULL); 13721} 13722 13723static void 13724remote_async_inferior_event_handler (gdb_client_data data) 13725{ 13726 inferior_event_handler (INF_REG_EVENT, NULL); 13727} 13728 13729static void 13730remote_async (struct target_ops *ops, int enable) 13731{ 13732 struct remote_state *rs = get_remote_state (); 13733 13734 if (enable) 13735 { 13736 serial_async (rs->remote_desc, remote_async_serial_handler, rs); 13737 13738 /* If there are pending events in the stop reply queue tell the 13739 event loop to process them. */ 13740 if (!QUEUE_is_empty (stop_reply_p, stop_reply_queue)) 13741 mark_async_event_handler (remote_async_inferior_event_token); 13742 /* For simplicity, below we clear the pending events token 13743 without remembering whether it is marked, so here we always 13744 mark it. If there's actually no pending notification to 13745 process, this ends up being a no-op (other than a spurious 13746 event-loop wakeup). */ 13747 if (target_is_non_stop_p ()) 13748 mark_async_event_handler (rs->notif_state->get_pending_events_token); 13749 } 13750 else 13751 { 13752 serial_async (rs->remote_desc, NULL, NULL); 13753 /* If the core is disabling async, it doesn't want to be 13754 disturbed with target events. Clear all async event sources 13755 too. */ 13756 clear_async_event_handler (remote_async_inferior_event_token); 13757 if (target_is_non_stop_p ()) 13758 clear_async_event_handler (rs->notif_state->get_pending_events_token); 13759 } 13760} 13761 13762/* Implementation of the to_thread_events method. */ 13763 13764static void 13765remote_thread_events (struct target_ops *ops, int enable) 13766{ 13767 struct remote_state *rs = get_remote_state (); 13768 size_t size = get_remote_packet_size (); 13769 13770 if (packet_support (PACKET_QThreadEvents) == PACKET_DISABLE) 13771 return; 13772 13773 xsnprintf (rs->buf, size, "QThreadEvents:%x", enable ? 1 : 0); 13774 putpkt (rs->buf); 13775 getpkt (&rs->buf, &rs->buf_size, 0); 13776 13777 switch (packet_ok (rs->buf, 13778 &remote_protocol_packets[PACKET_QThreadEvents])) 13779 { 13780 case PACKET_OK: 13781 if (strcmp (rs->buf, "OK") != 0) 13782 error (_("Remote refused setting thread events: %s"), rs->buf); 13783 break; 13784 case PACKET_ERROR: 13785 warning (_("Remote failure reply: %s"), rs->buf); 13786 break; 13787 case PACKET_UNKNOWN: 13788 break; 13789 } 13790} 13791 13792static void 13793set_remote_cmd (char *args, int from_tty) 13794{ 13795 help_list (remote_set_cmdlist, "set remote ", all_commands, gdb_stdout); 13796} 13797 13798static void 13799show_remote_cmd (char *args, int from_tty) 13800{ 13801 /* We can't just use cmd_show_list here, because we want to skip 13802 the redundant "show remote Z-packet" and the legacy aliases. */ 13803 struct cleanup *showlist_chain; 13804 struct cmd_list_element *list = remote_show_cmdlist; 13805 struct ui_out *uiout = current_uiout; 13806 13807 showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist"); 13808 for (; list != NULL; list = list->next) 13809 if (strcmp (list->name, "Z-packet") == 0) 13810 continue; 13811 else if (list->type == not_set_cmd) 13812 /* Alias commands are exactly like the original, except they 13813 don't have the normal type. */ 13814 continue; 13815 else 13816 { 13817 struct cleanup *option_chain 13818 = make_cleanup_ui_out_tuple_begin_end (uiout, "option"); 13819 13820 uiout->field_string ("name", list->name); 13821 uiout->text (": "); 13822 if (list->type == show_cmd) 13823 do_show_command (NULL, from_tty, list); 13824 else 13825 cmd_func (list, NULL, from_tty); 13826 /* Close the tuple. */ 13827 do_cleanups (option_chain); 13828 } 13829 13830 /* Close the tuple. */ 13831 do_cleanups (showlist_chain); 13832} 13833 13834 13835/* Function to be called whenever a new objfile (shlib) is detected. */ 13836static void 13837remote_new_objfile (struct objfile *objfile) 13838{ 13839 struct remote_state *rs = get_remote_state (); 13840 13841 if (rs->remote_desc != 0) /* Have a remote connection. */ 13842 remote_check_symbols (); 13843} 13844 13845/* Pull all the tracepoints defined on the target and create local 13846 data structures representing them. We don't want to create real 13847 tracepoints yet, we don't want to mess up the user's existing 13848 collection. */ 13849 13850static int 13851remote_upload_tracepoints (struct target_ops *self, struct uploaded_tp **utpp) 13852{ 13853 struct remote_state *rs = get_remote_state (); 13854 char *p; 13855 13856 /* Ask for a first packet of tracepoint definition. */ 13857 putpkt ("qTfP"); 13858 getpkt (&rs->buf, &rs->buf_size, 0); 13859 p = rs->buf; 13860 while (*p && *p != 'l') 13861 { 13862 parse_tracepoint_definition (p, utpp); 13863 /* Ask for another packet of tracepoint definition. */ 13864 putpkt ("qTsP"); 13865 getpkt (&rs->buf, &rs->buf_size, 0); 13866 p = rs->buf; 13867 } 13868 return 0; 13869} 13870 13871static int 13872remote_upload_trace_state_variables (struct target_ops *self, 13873 struct uploaded_tsv **utsvp) 13874{ 13875 struct remote_state *rs = get_remote_state (); 13876 char *p; 13877 13878 /* Ask for a first packet of variable definition. */ 13879 putpkt ("qTfV"); 13880 getpkt (&rs->buf, &rs->buf_size, 0); 13881 p = rs->buf; 13882 while (*p && *p != 'l') 13883 { 13884 parse_tsv_definition (p, utsvp); 13885 /* Ask for another packet of variable definition. */ 13886 putpkt ("qTsV"); 13887 getpkt (&rs->buf, &rs->buf_size, 0); 13888 p = rs->buf; 13889 } 13890 return 0; 13891} 13892 13893/* The "set/show range-stepping" show hook. */ 13894 13895static void 13896show_range_stepping (struct ui_file *file, int from_tty, 13897 struct cmd_list_element *c, 13898 const char *value) 13899{ 13900 fprintf_filtered (file, 13901 _("Debugger's willingness to use range stepping " 13902 "is %s.\n"), value); 13903} 13904 13905/* The "set/show range-stepping" set hook. */ 13906 13907static void 13908set_range_stepping (char *ignore_args, int from_tty, 13909 struct cmd_list_element *c) 13910{ 13911 struct remote_state *rs = get_remote_state (); 13912 13913 /* Whene enabling, check whether range stepping is actually 13914 supported by the target, and warn if not. */ 13915 if (use_range_stepping) 13916 { 13917 if (rs->remote_desc != NULL) 13918 { 13919 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN) 13920 remote_vcont_probe (rs); 13921 13922 if (packet_support (PACKET_vCont) == PACKET_ENABLE 13923 && rs->supports_vCont.r) 13924 return; 13925 } 13926 13927 warning (_("Range stepping is not supported by the current target")); 13928 } 13929} 13930 13931void 13932_initialize_remote (void) 13933{ 13934 struct cmd_list_element *cmd; 13935 const char *cmd_name; 13936 13937 /* architecture specific data */ 13938 remote_gdbarch_data_handle = 13939 gdbarch_data_register_post_init (init_remote_state); 13940 remote_g_packet_data_handle = 13941 gdbarch_data_register_pre_init (remote_g_packet_data_init); 13942 13943 remote_pspace_data 13944 = register_program_space_data_with_cleanup (NULL, 13945 remote_pspace_data_cleanup); 13946 13947 /* Initialize the per-target state. At the moment there is only one 13948 of these, not one per target. Only one target is active at a 13949 time. */ 13950 remote_state = new_remote_state (); 13951 13952 init_remote_ops (); 13953 add_target (&remote_ops); 13954 13955 init_extended_remote_ops (); 13956 add_target (&extended_remote_ops); 13957 13958 /* Hook into new objfile notification. */ 13959 observer_attach_new_objfile (remote_new_objfile); 13960 /* We're no longer interested in notification events of an inferior 13961 when it exits. */ 13962 observer_attach_inferior_exit (discard_pending_stop_replies); 13963 13964#if 0 13965 init_remote_threadtests (); 13966#endif 13967 13968 stop_reply_queue = QUEUE_alloc (stop_reply_p, stop_reply_xfree); 13969 /* set/show remote ... */ 13970 13971 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\ 13972Remote protocol specific variables\n\ 13973Configure various remote-protocol specific variables such as\n\ 13974the packets being used"), 13975 &remote_set_cmdlist, "set remote ", 13976 0 /* allow-unknown */, &setlist); 13977 add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\ 13978Remote protocol specific variables\n\ 13979Configure various remote-protocol specific variables such as\n\ 13980the packets being used"), 13981 &remote_show_cmdlist, "show remote ", 13982 0 /* allow-unknown */, &showlist); 13983 13984 add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\ 13985Compare section data on target to the exec file.\n\ 13986Argument is a single section name (default: all loaded sections).\n\ 13987To compare only read-only loaded sections, specify the -r option."), 13988 &cmdlist); 13989 13990 add_cmd ("packet", class_maintenance, packet_command, _("\ 13991Send an arbitrary packet to a remote target.\n\ 13992 maintenance packet TEXT\n\ 13993If GDB is talking to an inferior via the GDB serial protocol, then\n\ 13994this command sends the string TEXT to the inferior, and displays the\n\ 13995response packet. GDB supplies the initial `$' character, and the\n\ 13996terminating `#' character and checksum."), 13997 &maintenancelist); 13998 13999 add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\ 14000Set whether to send break if interrupted."), _("\ 14001Show whether to send break if interrupted."), _("\ 14002If set, a break, instead of a cntrl-c, is sent to the remote target."), 14003 set_remotebreak, show_remotebreak, 14004 &setlist, &showlist); 14005 cmd_name = "remotebreak"; 14006 cmd = lookup_cmd (&cmd_name, setlist, "", -1, 1); 14007 deprecate_cmd (cmd, "set remote interrupt-sequence"); 14008 cmd_name = "remotebreak"; /* needed because lookup_cmd updates the pointer */ 14009 cmd = lookup_cmd (&cmd_name, showlist, "", -1, 1); 14010 deprecate_cmd (cmd, "show remote interrupt-sequence"); 14011 14012 add_setshow_enum_cmd ("interrupt-sequence", class_support, 14013 interrupt_sequence_modes, &interrupt_sequence_mode, 14014 _("\ 14015Set interrupt sequence to remote target."), _("\ 14016Show interrupt sequence to remote target."), _("\ 14017Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."), 14018 NULL, show_interrupt_sequence, 14019 &remote_set_cmdlist, 14020 &remote_show_cmdlist); 14021 14022 add_setshow_boolean_cmd ("interrupt-on-connect", class_support, 14023 &interrupt_on_connect, _("\ 14024Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \ 14025Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \ 14026If set, interrupt sequence is sent to remote target."), 14027 NULL, NULL, 14028 &remote_set_cmdlist, &remote_show_cmdlist); 14029 14030 /* Install commands for configuring memory read/write packets. */ 14031 14032 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\ 14033Set the maximum number of bytes per memory write packet (deprecated)."), 14034 &setlist); 14035 add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\ 14036Show the maximum number of bytes per memory write packet (deprecated)."), 14037 &showlist); 14038 add_cmd ("memory-write-packet-size", no_class, 14039 set_memory_write_packet_size, _("\ 14040Set the maximum number of bytes per memory-write packet.\n\ 14041Specify the number of bytes in a packet or 0 (zero) for the\n\ 14042default packet size. The actual limit is further reduced\n\ 14043dependent on the target. Specify ``fixed'' to disable the\n\ 14044further restriction and ``limit'' to enable that restriction."), 14045 &remote_set_cmdlist); 14046 add_cmd ("memory-read-packet-size", no_class, 14047 set_memory_read_packet_size, _("\ 14048Set the maximum number of bytes per memory-read packet.\n\ 14049Specify the number of bytes in a packet or 0 (zero) for the\n\ 14050default packet size. The actual limit is further reduced\n\ 14051dependent on the target. Specify ``fixed'' to disable the\n\ 14052further restriction and ``limit'' to enable that restriction."), 14053 &remote_set_cmdlist); 14054 add_cmd ("memory-write-packet-size", no_class, 14055 show_memory_write_packet_size, 14056 _("Show the maximum number of bytes per memory-write packet."), 14057 &remote_show_cmdlist); 14058 add_cmd ("memory-read-packet-size", no_class, 14059 show_memory_read_packet_size, 14060 _("Show the maximum number of bytes per memory-read packet."), 14061 &remote_show_cmdlist); 14062 14063 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class, 14064 &remote_hw_watchpoint_limit, _("\ 14065Set the maximum number of target hardware watchpoints."), _("\ 14066Show the maximum number of target hardware watchpoints."), _("\ 14067Specify a negative limit for unlimited."), 14068 NULL, NULL, /* FIXME: i18n: The maximum 14069 number of target hardware 14070 watchpoints is %s. */ 14071 &remote_set_cmdlist, &remote_show_cmdlist); 14072 add_setshow_zinteger_cmd ("hardware-watchpoint-length-limit", no_class, 14073 &remote_hw_watchpoint_length_limit, _("\ 14074Set the maximum length (in bytes) of a target hardware watchpoint."), _("\ 14075Show the maximum length (in bytes) of a target hardware watchpoint."), _("\ 14076Specify a negative limit for unlimited."), 14077 NULL, NULL, /* FIXME: i18n: The maximum 14078 length (in bytes) of a target 14079 hardware watchpoint is %s. */ 14080 &remote_set_cmdlist, &remote_show_cmdlist); 14081 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class, 14082 &remote_hw_breakpoint_limit, _("\ 14083Set the maximum number of target hardware breakpoints."), _("\ 14084Show the maximum number of target hardware breakpoints."), _("\ 14085Specify a negative limit for unlimited."), 14086 NULL, NULL, /* FIXME: i18n: The maximum 14087 number of target hardware 14088 breakpoints is %s. */ 14089 &remote_set_cmdlist, &remote_show_cmdlist); 14090 14091 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure, 14092 &remote_address_size, _("\ 14093Set the maximum size of the address (in bits) in a memory packet."), _("\ 14094Show the maximum size of the address (in bits) in a memory packet."), NULL, 14095 NULL, 14096 NULL, /* FIXME: i18n: */ 14097 &setlist, &showlist); 14098 14099 init_all_packet_configs (); 14100 14101 add_packet_config_cmd (&remote_protocol_packets[PACKET_X], 14102 "X", "binary-download", 1); 14103 14104 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont], 14105 "vCont", "verbose-resume", 0); 14106 14107 add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals], 14108 "QPassSignals", "pass-signals", 0); 14109 14110 add_packet_config_cmd (&remote_protocol_packets[PACKET_QCatchSyscalls], 14111 "QCatchSyscalls", "catch-syscalls", 0); 14112 14113 add_packet_config_cmd (&remote_protocol_packets[PACKET_QProgramSignals], 14114 "QProgramSignals", "program-signals", 0); 14115 14116 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol], 14117 "qSymbol", "symbol-lookup", 0); 14118 14119 add_packet_config_cmd (&remote_protocol_packets[PACKET_P], 14120 "P", "set-register", 1); 14121 14122 add_packet_config_cmd (&remote_protocol_packets[PACKET_p], 14123 "p", "fetch-register", 1); 14124 14125 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0], 14126 "Z0", "software-breakpoint", 0); 14127 14128 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1], 14129 "Z1", "hardware-breakpoint", 0); 14130 14131 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2], 14132 "Z2", "write-watchpoint", 0); 14133 14134 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3], 14135 "Z3", "read-watchpoint", 0); 14136 14137 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4], 14138 "Z4", "access-watchpoint", 0); 14139 14140 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv], 14141 "qXfer:auxv:read", "read-aux-vector", 0); 14142 14143 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_exec_file], 14144 "qXfer:exec-file:read", "pid-to-exec-file", 0); 14145 14146 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features], 14147 "qXfer:features:read", "target-features", 0); 14148 14149 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries], 14150 "qXfer:libraries:read", "library-info", 0); 14151 14152 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries_svr4], 14153 "qXfer:libraries-svr4:read", "library-info-svr4", 0); 14154 14155 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map], 14156 "qXfer:memory-map:read", "memory-map", 0); 14157 14158 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read], 14159 "qXfer:spu:read", "read-spu-object", 0); 14160 14161 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write], 14162 "qXfer:spu:write", "write-spu-object", 0); 14163 14164 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata], 14165 "qXfer:osdata:read", "osdata", 0); 14166 14167 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_threads], 14168 "qXfer:threads:read", "threads", 0); 14169 14170 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_read], 14171 "qXfer:siginfo:read", "read-siginfo-object", 0); 14172 14173 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write], 14174 "qXfer:siginfo:write", "write-siginfo-object", 0); 14175 14176 add_packet_config_cmd 14177 (&remote_protocol_packets[PACKET_qXfer_traceframe_info], 14178 "qXfer:traceframe-info:read", "traceframe-info", 0); 14179 14180 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_uib], 14181 "qXfer:uib:read", "unwind-info-block", 0); 14182 14183 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr], 14184 "qGetTLSAddr", "get-thread-local-storage-address", 14185 0); 14186 14187 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTIBAddr], 14188 "qGetTIBAddr", "get-thread-information-block-address", 14189 0); 14190 14191 add_packet_config_cmd (&remote_protocol_packets[PACKET_bc], 14192 "bc", "reverse-continue", 0); 14193 14194 add_packet_config_cmd (&remote_protocol_packets[PACKET_bs], 14195 "bs", "reverse-step", 0); 14196 14197 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported], 14198 "qSupported", "supported-packets", 0); 14199 14200 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSearch_memory], 14201 "qSearch:memory", "search-memory", 0); 14202 14203 add_packet_config_cmd (&remote_protocol_packets[PACKET_qTStatus], 14204 "qTStatus", "trace-status", 0); 14205 14206 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_setfs], 14207 "vFile:setfs", "hostio-setfs", 0); 14208 14209 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_open], 14210 "vFile:open", "hostio-open", 0); 14211 14212 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pread], 14213 "vFile:pread", "hostio-pread", 0); 14214 14215 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pwrite], 14216 "vFile:pwrite", "hostio-pwrite", 0); 14217 14218 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_close], 14219 "vFile:close", "hostio-close", 0); 14220 14221 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink], 14222 "vFile:unlink", "hostio-unlink", 0); 14223 14224 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_readlink], 14225 "vFile:readlink", "hostio-readlink", 0); 14226 14227 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_fstat], 14228 "vFile:fstat", "hostio-fstat", 0); 14229 14230 add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach], 14231 "vAttach", "attach", 0); 14232 14233 add_packet_config_cmd (&remote_protocol_packets[PACKET_vRun], 14234 "vRun", "run", 0); 14235 14236 add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartNoAckMode], 14237 "QStartNoAckMode", "noack", 0); 14238 14239 add_packet_config_cmd (&remote_protocol_packets[PACKET_vKill], 14240 "vKill", "kill", 0); 14241 14242 add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached], 14243 "qAttached", "query-attached", 0); 14244 14245 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints], 14246 "ConditionalTracepoints", 14247 "conditional-tracepoints", 0); 14248 14249 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalBreakpoints], 14250 "ConditionalBreakpoints", 14251 "conditional-breakpoints", 0); 14252 14253 add_packet_config_cmd (&remote_protocol_packets[PACKET_BreakpointCommands], 14254 "BreakpointCommands", 14255 "breakpoint-commands", 0); 14256 14257 add_packet_config_cmd (&remote_protocol_packets[PACKET_FastTracepoints], 14258 "FastTracepoints", "fast-tracepoints", 0); 14259 14260 add_packet_config_cmd (&remote_protocol_packets[PACKET_TracepointSource], 14261 "TracepointSource", "TracepointSource", 0); 14262 14263 add_packet_config_cmd (&remote_protocol_packets[PACKET_QAllow], 14264 "QAllow", "allow", 0); 14265 14266 add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints], 14267 "StaticTracepoints", "static-tracepoints", 0); 14268 14269 add_packet_config_cmd (&remote_protocol_packets[PACKET_InstallInTrace], 14270 "InstallInTrace", "install-in-trace", 0); 14271 14272 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read], 14273 "qXfer:statictrace:read", "read-sdata-object", 0); 14274 14275 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_fdpic], 14276 "qXfer:fdpic:read", "read-fdpic-loadmap", 0); 14277 14278 add_packet_config_cmd (&remote_protocol_packets[PACKET_QDisableRandomization], 14279 "QDisableRandomization", "disable-randomization", 0); 14280 14281 add_packet_config_cmd (&remote_protocol_packets[PACKET_QAgent], 14282 "QAgent", "agent", 0); 14283 14284 add_packet_config_cmd (&remote_protocol_packets[PACKET_QTBuffer_size], 14285 "QTBuffer:size", "trace-buffer-size", 0); 14286 14287 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_off], 14288 "Qbtrace:off", "disable-btrace", 0); 14289 14290 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_bts], 14291 "Qbtrace:bts", "enable-btrace-bts", 0); 14292 14293 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_pt], 14294 "Qbtrace:pt", "enable-btrace-pt", 0); 14295 14296 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace], 14297 "qXfer:btrace", "read-btrace", 0); 14298 14299 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace_conf], 14300 "qXfer:btrace-conf", "read-btrace-conf", 0); 14301 14302 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_bts_size], 14303 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0); 14304 14305 add_packet_config_cmd (&remote_protocol_packets[PACKET_multiprocess_feature], 14306 "multiprocess-feature", "multiprocess-feature", 0); 14307 14308 add_packet_config_cmd (&remote_protocol_packets[PACKET_swbreak_feature], 14309 "swbreak-feature", "swbreak-feature", 0); 14310 14311 add_packet_config_cmd (&remote_protocol_packets[PACKET_hwbreak_feature], 14312 "hwbreak-feature", "hwbreak-feature", 0); 14313 14314 add_packet_config_cmd (&remote_protocol_packets[PACKET_fork_event_feature], 14315 "fork-event-feature", "fork-event-feature", 0); 14316 14317 add_packet_config_cmd (&remote_protocol_packets[PACKET_vfork_event_feature], 14318 "vfork-event-feature", "vfork-event-feature", 0); 14319 14320 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_pt_size], 14321 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0); 14322 14323 add_packet_config_cmd (&remote_protocol_packets[PACKET_vContSupported], 14324 "vContSupported", "verbose-resume-supported", 0); 14325 14326 add_packet_config_cmd (&remote_protocol_packets[PACKET_exec_event_feature], 14327 "exec-event-feature", "exec-event-feature", 0); 14328 14329 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCtrlC], 14330 "vCtrlC", "ctrl-c", 0); 14331 14332 add_packet_config_cmd (&remote_protocol_packets[PACKET_QThreadEvents], 14333 "QThreadEvents", "thread-events", 0); 14334 14335 add_packet_config_cmd (&remote_protocol_packets[PACKET_no_resumed], 14336 "N stop reply", "no-resumed-stop-reply", 0); 14337 14338 /* Assert that we've registered "set remote foo-packet" commands 14339 for all packet configs. */ 14340 { 14341 int i; 14342 14343 for (i = 0; i < PACKET_MAX; i++) 14344 { 14345 /* Ideally all configs would have a command associated. Some 14346 still don't though. */ 14347 int excepted; 14348 14349 switch (i) 14350 { 14351 case PACKET_QNonStop: 14352 case PACKET_EnableDisableTracepoints_feature: 14353 case PACKET_tracenz_feature: 14354 case PACKET_DisconnectedTracing_feature: 14355 case PACKET_augmented_libraries_svr4_read_feature: 14356 case PACKET_qCRC: 14357 /* Additions to this list need to be well justified: 14358 pre-existing packets are OK; new packets are not. */ 14359 excepted = 1; 14360 break; 14361 default: 14362 excepted = 0; 14363 break; 14364 } 14365 14366 /* This catches both forgetting to add a config command, and 14367 forgetting to remove a packet from the exception list. */ 14368 gdb_assert (excepted == (remote_protocol_packets[i].name == NULL)); 14369 } 14370 } 14371 14372 /* Keep the old ``set remote Z-packet ...'' working. Each individual 14373 Z sub-packet has its own set and show commands, but users may 14374 have sets to this variable in their .gdbinit files (or in their 14375 documentation). */ 14376 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure, 14377 &remote_Z_packet_detect, _("\ 14378Set use of remote protocol `Z' packets"), _("\ 14379Show use of remote protocol `Z' packets "), _("\ 14380When set, GDB will attempt to use the remote breakpoint and watchpoint\n\ 14381packets."), 14382 set_remote_protocol_Z_packet_cmd, 14383 show_remote_protocol_Z_packet_cmd, 14384 /* FIXME: i18n: Use of remote protocol 14385 `Z' packets is %s. */ 14386 &remote_set_cmdlist, &remote_show_cmdlist); 14387 14388 add_prefix_cmd ("remote", class_files, remote_command, _("\ 14389Manipulate files on the remote system\n\ 14390Transfer files to and from the remote target system."), 14391 &remote_cmdlist, "remote ", 14392 0 /* allow-unknown */, &cmdlist); 14393 14394 add_cmd ("put", class_files, remote_put_command, 14395 _("Copy a local file to the remote system."), 14396 &remote_cmdlist); 14397 14398 add_cmd ("get", class_files, remote_get_command, 14399 _("Copy a remote file to the local system."), 14400 &remote_cmdlist); 14401 14402 add_cmd ("delete", class_files, remote_delete_command, 14403 _("Delete a remote file."), 14404 &remote_cmdlist); 14405 14406 add_setshow_string_noescape_cmd ("exec-file", class_files, 14407 &remote_exec_file_var, _("\ 14408Set the remote pathname for \"run\""), _("\ 14409Show the remote pathname for \"run\""), NULL, 14410 set_remote_exec_file, 14411 show_remote_exec_file, 14412 &remote_set_cmdlist, 14413 &remote_show_cmdlist); 14414 14415 add_setshow_boolean_cmd ("range-stepping", class_run, 14416 &use_range_stepping, _("\ 14417Enable or disable range stepping."), _("\ 14418Show whether target-assisted range stepping is enabled."), _("\ 14419If on, and the target supports it, when stepping a source line, GDB\n\ 14420tells the target to step the corresponding range of addresses itself instead\n\ 14421of issuing multiple single-steps. This speeds up source level\n\ 14422stepping. If off, GDB always issues single-steps, even if range\n\ 14423stepping is supported by the target. The default is on."), 14424 set_range_stepping, 14425 show_range_stepping, 14426 &setlist, 14427 &showlist); 14428 14429 /* Eventually initialize fileio. See fileio.c */ 14430 initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist); 14431 14432 /* Take advantage of the fact that the TID field is not used, to tag 14433 special ptids with it set to != 0. */ 14434 magic_null_ptid = ptid_build (42000, -1, 1); 14435 not_sent_ptid = ptid_build (42000, -2, 1); 14436 any_thread_ptid = ptid_build (42000, 0, 1); 14437 14438 target_buf_size = 2048; 14439 target_buf = (char *) xmalloc (target_buf_size); 14440} 14441 14442