1 /* Remote target communications for serial-line targets in custom GDB protocol 2 3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 4 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 5 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 /* See the GDB User Guide for details of the GDB remote protocol. */ 23 24 #include "defs.h" 25 #include "gdb_string.h" 26 #include <ctype.h> 27 #include <fcntl.h> 28 #include "inferior.h" 29 #include "bfd.h" 30 #include "symfile.h" 31 #include "exceptions.h" 32 #include "target.h" 33 /*#include "terminal.h" */ 34 #include "gdbcmd.h" 35 #include "objfiles.h" 36 #include "gdb-stabs.h" 37 #include "gdbthread.h" 38 #include "remote.h" 39 #include "regcache.h" 40 #include "value.h" 41 #include "gdb_assert.h" 42 #include "observer.h" 43 #include "solib.h" 44 #include "cli/cli-decode.h" 45 #include "cli/cli-setshow.h" 46 #include "target-descriptions.h" 47 48 #include <ctype.h> 49 #include <sys/time.h> 50 51 #include "event-loop.h" 52 #include "event-top.h" 53 #include "inf-loop.h" 54 55 #include <signal.h> 56 #include "serial.h" 57 58 #include "gdbcore.h" /* for exec_bfd */ 59 60 #include "remote-fileio.h" 61 #include "gdb/fileio.h" 62 #include "gdb_stat.h" 63 64 #include "memory-map.h" 65 66 /* The size to align memory write packets, when practical. The protocol 67 does not guarantee any alignment, and gdb will generate short 68 writes and unaligned writes, but even as a best-effort attempt this 69 can improve bulk transfers. For instance, if a write is misaligned 70 relative to the target's data bus, the stub may need to make an extra 71 round trip fetching data from the target. This doesn't make a 72 huge difference, but it's easy to do, so we try to be helpful. 73 74 The alignment chosen is arbitrary; usually data bus width is 75 important here, not the possibly larger cache line size. */ 76 enum { REMOTE_ALIGN_WRITES = 16 }; 77 78 /* Prototypes for local functions. */ 79 static void cleanup_sigint_signal_handler (void *dummy); 80 static void initialize_sigint_signal_handler (void); 81 static int getpkt_sane (char **buf, long *sizeof_buf, int forever); 82 static int getpkt_or_notif_sane (char **buf, long *sizeof_buf, 83 int forever); 84 85 static void handle_remote_sigint (int); 86 static void handle_remote_sigint_twice (int); 87 static void async_remote_interrupt (gdb_client_data); 88 void async_remote_interrupt_twice (gdb_client_data); 89 90 static void remote_files_info (struct target_ops *ignore); 91 92 static void remote_prepare_to_store (struct regcache *regcache); 93 94 static void remote_open (char *name, int from_tty); 95 96 static void extended_remote_open (char *name, int from_tty); 97 98 static void remote_open_1 (char *, int, struct target_ops *, int extended_p); 99 100 static void remote_close (int quitting); 101 102 static void remote_mourn (struct target_ops *ops); 103 104 static void extended_remote_restart (void); 105 106 static void extended_remote_mourn (struct target_ops *); 107 108 static void remote_mourn_1 (struct target_ops *); 109 110 static void remote_send (char **buf, long *sizeof_buf_p); 111 112 static int readchar (int timeout); 113 114 static void remote_kill (struct target_ops *ops); 115 116 static int tohex (int nib); 117 118 static int remote_can_async_p (void); 119 120 static int remote_is_async_p (void); 121 122 static void remote_async (void (*callback) (enum inferior_event_type event_type, 123 void *context), void *context); 124 125 static int remote_async_mask (int new_mask); 126 127 static void remote_detach (struct target_ops *ops, char *args, int from_tty); 128 129 static void remote_interrupt (int signo); 130 131 static void remote_interrupt_twice (int signo); 132 133 static void interrupt_query (void); 134 135 static void set_general_thread (struct ptid ptid); 136 static void set_continue_thread (struct ptid ptid); 137 138 static void get_offsets (void); 139 140 static void skip_frame (void); 141 142 static long read_frame (char **buf_p, long *sizeof_buf); 143 144 static int hexnumlen (ULONGEST num); 145 146 static void init_remote_ops (void); 147 148 static void init_extended_remote_ops (void); 149 150 static void remote_stop (ptid_t); 151 152 static int ishex (int ch, int *val); 153 154 static int stubhex (int ch); 155 156 static int hexnumstr (char *, ULONGEST); 157 158 static int hexnumnstr (char *, ULONGEST, int); 159 160 static CORE_ADDR remote_address_masked (CORE_ADDR); 161 162 static void print_packet (char *); 163 164 static unsigned long crc32 (unsigned char *, int, unsigned int); 165 166 static void compare_sections_command (char *, int); 167 168 static void packet_command (char *, int); 169 170 static int stub_unpack_int (char *buff, int fieldlength); 171 172 static ptid_t remote_current_thread (ptid_t oldptid); 173 174 static void remote_find_new_threads (void); 175 176 static void record_currthread (ptid_t currthread); 177 178 static int fromhex (int a); 179 180 static int hex2bin (const char *hex, gdb_byte *bin, int count); 181 182 static int bin2hex (const gdb_byte *bin, char *hex, int count); 183 184 static int putpkt_binary (char *buf, int cnt); 185 186 static void check_binary_download (CORE_ADDR addr); 187 188 struct packet_config; 189 190 static void show_packet_config_cmd (struct packet_config *config); 191 192 static void update_packet_config (struct packet_config *config); 193 194 static void set_remote_protocol_packet_cmd (char *args, int from_tty, 195 struct cmd_list_element *c); 196 197 static void show_remote_protocol_packet_cmd (struct ui_file *file, 198 int from_tty, 199 struct cmd_list_element *c, 200 const char *value); 201 202 static char *write_ptid (char *buf, const char *endbuf, ptid_t ptid); 203 static ptid_t read_ptid (char *buf, char **obuf); 204 205 static void remote_query_supported (void); 206 207 static void remote_check_symbols (struct objfile *objfile); 208 209 void _initialize_remote (void); 210 211 struct stop_reply; 212 static struct stop_reply *stop_reply_xmalloc (void); 213 static void stop_reply_xfree (struct stop_reply *); 214 static void do_stop_reply_xfree (void *arg); 215 static void remote_parse_stop_reply (char *buf, struct stop_reply *); 216 static void push_stop_reply (struct stop_reply *); 217 static void remote_get_pending_stop_replies (void); 218 static void discard_pending_stop_replies (int pid); 219 static int peek_stop_reply (ptid_t ptid); 220 221 static void remote_async_inferior_event_handler (gdb_client_data); 222 static void remote_async_get_pending_events_handler (gdb_client_data); 223 224 static void remote_terminal_ours (void); 225 226 static int remote_read_description_p (struct target_ops *target); 227 228 /* The non-stop remote protocol provisions for one pending stop reply. 229 This is where we keep it until it is acknowledged. */ 230 231 static struct stop_reply *pending_stop_reply = NULL; 232 233 /* For "remote". */ 234 235 static struct cmd_list_element *remote_cmdlist; 236 237 /* For "set remote" and "show remote". */ 238 239 static struct cmd_list_element *remote_set_cmdlist; 240 static struct cmd_list_element *remote_show_cmdlist; 241 242 /* Description of the remote protocol state for the currently 243 connected target. This is per-target state, and independent of the 244 selected architecture. */ 245 246 struct remote_state 247 { 248 /* A buffer to use for incoming packets, and its current size. The 249 buffer is grown dynamically for larger incoming packets. 250 Outgoing packets may also be constructed in this buffer. 251 BUF_SIZE is always at least REMOTE_PACKET_SIZE; 252 REMOTE_PACKET_SIZE should be used to limit the length of outgoing 253 packets. */ 254 char *buf; 255 long buf_size; 256 257 /* If we negotiated packet size explicitly (and thus can bypass 258 heuristics for the largest packet size that will not overflow 259 a buffer in the stub), this will be set to that packet size. 260 Otherwise zero, meaning to use the guessed size. */ 261 long explicit_packet_size; 262 263 /* remote_wait is normally called when the target is running and 264 waits for a stop reply packet. But sometimes we need to call it 265 when the target is already stopped. We can send a "?" packet 266 and have remote_wait read the response. Or, if we already have 267 the response, we can stash it in BUF and tell remote_wait to 268 skip calling getpkt. This flag is set when BUF contains a 269 stop reply packet and the target is not waiting. */ 270 int cached_wait_status; 271 272 /* True, if in no ack mode. That is, neither GDB nor the stub will 273 expect acks from each other. The connection is assumed to be 274 reliable. */ 275 int noack_mode; 276 277 /* True if we're connected in extended remote mode. */ 278 int extended; 279 280 /* True if the stub reported support for multi-process 281 extensions. */ 282 int multi_process_aware; 283 284 /* True if we resumed the target and we're waiting for the target to 285 stop. In the mean time, we can't start another command/query. 286 The remote server wouldn't be ready to process it, so we'd 287 timeout waiting for a reply that would never come and eventually 288 we'd close the connection. This can happen in asynchronous mode 289 because we allow GDB commands while the target is running. */ 290 int waiting_for_stop_reply; 291 292 /* True if the stub reports support for non-stop mode. */ 293 int non_stop_aware; 294 295 /* True if the stub reports support for vCont;t. */ 296 int support_vCont_t; 297 298 /* True if the stub reports support for conditional tracepoints. */ 299 int cond_tracepoints; 300 }; 301 302 /* Returns true if the multi-process extensions are in effect. */ 303 static int 304 remote_multi_process_p (struct remote_state *rs) 305 { 306 return rs->extended && rs->multi_process_aware; 307 } 308 309 /* This data could be associated with a target, but we do not always 310 have access to the current target when we need it, so for now it is 311 static. This will be fine for as long as only one target is in use 312 at a time. */ 313 static struct remote_state remote_state; 314 315 static struct remote_state * 316 get_remote_state_raw (void) 317 { 318 return &remote_state; 319 } 320 321 /* Description of the remote protocol for a given architecture. */ 322 323 struct packet_reg 324 { 325 long offset; /* Offset into G packet. */ 326 long regnum; /* GDB's internal register number. */ 327 LONGEST pnum; /* Remote protocol register number. */ 328 int in_g_packet; /* Always part of G packet. */ 329 /* long size in bytes; == register_size (target_gdbarch, regnum); 330 at present. */ 331 /* char *name; == gdbarch_register_name (target_gdbarch, regnum); 332 at present. */ 333 }; 334 335 struct remote_arch_state 336 { 337 /* Description of the remote protocol registers. */ 338 long sizeof_g_packet; 339 340 /* Description of the remote protocol registers indexed by REGNUM 341 (making an array gdbarch_num_regs in size). */ 342 struct packet_reg *regs; 343 344 /* This is the size (in chars) of the first response to the ``g'' 345 packet. It is used as a heuristic when determining the maximum 346 size of memory-read and memory-write packets. A target will 347 typically only reserve a buffer large enough to hold the ``g'' 348 packet. The size does not include packet overhead (headers and 349 trailers). */ 350 long actual_register_packet_size; 351 352 /* This is the maximum size (in chars) of a non read/write packet. 353 It is also used as a cap on the size of read/write packets. */ 354 long remote_packet_size; 355 }; 356 357 358 /* Handle for retreving the remote protocol data from gdbarch. */ 359 static struct gdbarch_data *remote_gdbarch_data_handle; 360 361 static struct remote_arch_state * 362 get_remote_arch_state (void) 363 { 364 return gdbarch_data (target_gdbarch, remote_gdbarch_data_handle); 365 } 366 367 /* Fetch the global remote target state. */ 368 369 static struct remote_state * 370 get_remote_state (void) 371 { 372 /* Make sure that the remote architecture state has been 373 initialized, because doing so might reallocate rs->buf. Any 374 function which calls getpkt also needs to be mindful of changes 375 to rs->buf, but this call limits the number of places which run 376 into trouble. */ 377 get_remote_arch_state (); 378 379 return get_remote_state_raw (); 380 } 381 382 static int 383 compare_pnums (const void *lhs_, const void *rhs_) 384 { 385 const struct packet_reg * const *lhs = lhs_; 386 const struct packet_reg * const *rhs = rhs_; 387 388 if ((*lhs)->pnum < (*rhs)->pnum) 389 return -1; 390 else if ((*lhs)->pnum == (*rhs)->pnum) 391 return 0; 392 else 393 return 1; 394 } 395 396 static void * 397 init_remote_state (struct gdbarch *gdbarch) 398 { 399 int regnum, num_remote_regs, offset; 400 struct remote_state *rs = get_remote_state_raw (); 401 struct remote_arch_state *rsa; 402 struct packet_reg **remote_regs; 403 404 rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state); 405 406 /* Use the architecture to build a regnum<->pnum table, which will be 407 1:1 unless a feature set specifies otherwise. */ 408 rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch, 409 gdbarch_num_regs (gdbarch), 410 struct packet_reg); 411 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++) 412 { 413 struct packet_reg *r = &rsa->regs[regnum]; 414 415 if (register_size (gdbarch, regnum) == 0) 416 /* Do not try to fetch zero-sized (placeholder) registers. */ 417 r->pnum = -1; 418 else 419 r->pnum = gdbarch_remote_register_number (gdbarch, regnum); 420 421 r->regnum = regnum; 422 } 423 424 /* Define the g/G packet format as the contents of each register 425 with a remote protocol number, in order of ascending protocol 426 number. */ 427 428 remote_regs = alloca (gdbarch_num_regs (gdbarch) 429 * sizeof (struct packet_reg *)); 430 for (num_remote_regs = 0, regnum = 0; 431 regnum < gdbarch_num_regs (gdbarch); 432 regnum++) 433 if (rsa->regs[regnum].pnum != -1) 434 remote_regs[num_remote_regs++] = &rsa->regs[regnum]; 435 436 qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *), 437 compare_pnums); 438 439 for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++) 440 { 441 remote_regs[regnum]->in_g_packet = 1; 442 remote_regs[regnum]->offset = offset; 443 offset += register_size (gdbarch, remote_regs[regnum]->regnum); 444 } 445 446 /* Record the maximum possible size of the g packet - it may turn out 447 to be smaller. */ 448 rsa->sizeof_g_packet = offset; 449 450 /* Default maximum number of characters in a packet body. Many 451 remote stubs have a hardwired buffer size of 400 bytes 452 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used 453 as the maximum packet-size to ensure that the packet and an extra 454 NUL character can always fit in the buffer. This stops GDB 455 trashing stubs that try to squeeze an extra NUL into what is 456 already a full buffer (As of 1999-12-04 that was most stubs). */ 457 rsa->remote_packet_size = 400 - 1; 458 459 /* This one is filled in when a ``g'' packet is received. */ 460 rsa->actual_register_packet_size = 0; 461 462 /* Should rsa->sizeof_g_packet needs more space than the 463 default, adjust the size accordingly. Remember that each byte is 464 encoded as two characters. 32 is the overhead for the packet 465 header / footer. NOTE: cagney/1999-10-26: I suspect that 8 466 (``$NN:G...#NN'') is a better guess, the below has been padded a 467 little. */ 468 if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2)) 469 rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32); 470 471 /* Make sure that the packet buffer is plenty big enough for 472 this architecture. */ 473 if (rs->buf_size < rsa->remote_packet_size) 474 { 475 rs->buf_size = 2 * rsa->remote_packet_size; 476 rs->buf = xrealloc (rs->buf, rs->buf_size); 477 } 478 479 return rsa; 480 } 481 482 /* Return the current allowed size of a remote packet. This is 483 inferred from the current architecture, and should be used to 484 limit the length of outgoing packets. */ 485 static long 486 get_remote_packet_size (void) 487 { 488 struct remote_state *rs = get_remote_state (); 489 struct remote_arch_state *rsa = get_remote_arch_state (); 490 491 if (rs->explicit_packet_size) 492 return rs->explicit_packet_size; 493 494 return rsa->remote_packet_size; 495 } 496 497 static struct packet_reg * 498 packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum) 499 { 500 if (regnum < 0 && regnum >= gdbarch_num_regs (target_gdbarch)) 501 return NULL; 502 else 503 { 504 struct packet_reg *r = &rsa->regs[regnum]; 505 gdb_assert (r->regnum == regnum); 506 return r; 507 } 508 } 509 510 static struct packet_reg * 511 packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum) 512 { 513 int i; 514 for (i = 0; i < gdbarch_num_regs (target_gdbarch); i++) 515 { 516 struct packet_reg *r = &rsa->regs[i]; 517 if (r->pnum == pnum) 518 return r; 519 } 520 return NULL; 521 } 522 523 /* FIXME: graces/2002-08-08: These variables should eventually be 524 bound to an instance of the target object (as in gdbarch-tdep()), 525 when such a thing exists. */ 526 527 /* This is set to the data address of the access causing the target 528 to stop for a watchpoint. */ 529 static CORE_ADDR remote_watch_data_address; 530 531 /* This is non-zero if target stopped for a watchpoint. */ 532 static int remote_stopped_by_watchpoint_p; 533 534 static struct target_ops remote_ops; 535 536 static struct target_ops extended_remote_ops; 537 538 static int remote_async_mask_value = 1; 539 540 /* FIXME: cagney/1999-09-23: Even though getpkt was called with 541 ``forever'' still use the normal timeout mechanism. This is 542 currently used by the ASYNC code to guarentee that target reads 543 during the initial connect always time-out. Once getpkt has been 544 modified to return a timeout indication and, in turn 545 remote_wait()/wait_for_inferior() have gained a timeout parameter 546 this can go away. */ 547 static int wait_forever_enabled_p = 1; 548 549 550 /* This variable chooses whether to send a ^C or a break when the user 551 requests program interruption. Although ^C is usually what remote 552 systems expect, and that is the default here, sometimes a break is 553 preferable instead. */ 554 555 static int remote_break; 556 557 /* Descriptor for I/O to remote machine. Initialize it to NULL so that 558 remote_open knows that we don't have a file open when the program 559 starts. */ 560 static struct serial *remote_desc = NULL; 561 562 /* This variable sets the number of bits in an address that are to be 563 sent in a memory ("M" or "m") packet. Normally, after stripping 564 leading zeros, the entire address would be sent. This variable 565 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The 566 initial implementation of remote.c restricted the address sent in 567 memory packets to ``host::sizeof long'' bytes - (typically 32 568 bits). Consequently, for 64 bit targets, the upper 32 bits of an 569 address was never sent. Since fixing this bug may cause a break in 570 some remote targets this variable is principly provided to 571 facilitate backward compatibility. */ 572 573 static int remote_address_size; 574 575 /* Temporary to track who currently owns the terminal. See 576 remote_terminal_* for more details. */ 577 578 static int remote_async_terminal_ours_p; 579 580 /* The executable file to use for "run" on the remote side. */ 581 582 static char *remote_exec_file = ""; 583 584 585 /* User configurable variables for the number of characters in a 586 memory read/write packet. MIN (rsa->remote_packet_size, 587 rsa->sizeof_g_packet) is the default. Some targets need smaller 588 values (fifo overruns, et.al.) and some users need larger values 589 (speed up transfers). The variables ``preferred_*'' (the user 590 request), ``current_*'' (what was actually set) and ``forced_*'' 591 (Positive - a soft limit, negative - a hard limit). */ 592 593 struct memory_packet_config 594 { 595 char *name; 596 long size; 597 int fixed_p; 598 }; 599 600 /* Compute the current size of a read/write packet. Since this makes 601 use of ``actual_register_packet_size'' the computation is dynamic. */ 602 603 static long 604 get_memory_packet_size (struct memory_packet_config *config) 605 { 606 struct remote_state *rs = get_remote_state (); 607 struct remote_arch_state *rsa = get_remote_arch_state (); 608 609 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk 610 law?) that some hosts don't cope very well with large alloca() 611 calls. Eventually the alloca() code will be replaced by calls to 612 xmalloc() and make_cleanups() allowing this restriction to either 613 be lifted or removed. */ 614 #ifndef MAX_REMOTE_PACKET_SIZE 615 #define MAX_REMOTE_PACKET_SIZE 16384 616 #endif 617 /* NOTE: 20 ensures we can write at least one byte. */ 618 #ifndef MIN_REMOTE_PACKET_SIZE 619 #define MIN_REMOTE_PACKET_SIZE 20 620 #endif 621 long what_they_get; 622 if (config->fixed_p) 623 { 624 if (config->size <= 0) 625 what_they_get = MAX_REMOTE_PACKET_SIZE; 626 else 627 what_they_get = config->size; 628 } 629 else 630 { 631 what_they_get = get_remote_packet_size (); 632 /* Limit the packet to the size specified by the user. */ 633 if (config->size > 0 634 && what_they_get > config->size) 635 what_they_get = config->size; 636 637 /* Limit it to the size of the targets ``g'' response unless we have 638 permission from the stub to use a larger packet size. */ 639 if (rs->explicit_packet_size == 0 640 && rsa->actual_register_packet_size > 0 641 && what_they_get > rsa->actual_register_packet_size) 642 what_they_get = rsa->actual_register_packet_size; 643 } 644 if (what_they_get > MAX_REMOTE_PACKET_SIZE) 645 what_they_get = MAX_REMOTE_PACKET_SIZE; 646 if (what_they_get < MIN_REMOTE_PACKET_SIZE) 647 what_they_get = MIN_REMOTE_PACKET_SIZE; 648 649 /* Make sure there is room in the global buffer for this packet 650 (including its trailing NUL byte). */ 651 if (rs->buf_size < what_they_get + 1) 652 { 653 rs->buf_size = 2 * what_they_get; 654 rs->buf = xrealloc (rs->buf, 2 * what_they_get); 655 } 656 657 return what_they_get; 658 } 659 660 /* Update the size of a read/write packet. If they user wants 661 something really big then do a sanity check. */ 662 663 static void 664 set_memory_packet_size (char *args, struct memory_packet_config *config) 665 { 666 int fixed_p = config->fixed_p; 667 long size = config->size; 668 if (args == NULL) 669 error (_("Argument required (integer, `fixed' or `limited').")); 670 else if (strcmp (args, "hard") == 0 671 || strcmp (args, "fixed") == 0) 672 fixed_p = 1; 673 else if (strcmp (args, "soft") == 0 674 || strcmp (args, "limit") == 0) 675 fixed_p = 0; 676 else 677 { 678 char *end; 679 size = strtoul (args, &end, 0); 680 if (args == end) 681 error (_("Invalid %s (bad syntax)."), config->name); 682 #if 0 683 /* Instead of explicitly capping the size of a packet to 684 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is 685 instead allowed to set the size to something arbitrarily 686 large. */ 687 if (size > MAX_REMOTE_PACKET_SIZE) 688 error (_("Invalid %s (too large)."), config->name); 689 #endif 690 } 691 /* Extra checks? */ 692 if (fixed_p && !config->fixed_p) 693 { 694 if (! query (_("The target may not be able to correctly handle a %s\n" 695 "of %ld bytes. Change the packet size? "), 696 config->name, size)) 697 error (_("Packet size not changed.")); 698 } 699 /* Update the config. */ 700 config->fixed_p = fixed_p; 701 config->size = size; 702 } 703 704 static void 705 show_memory_packet_size (struct memory_packet_config *config) 706 { 707 printf_filtered (_("The %s is %ld. "), config->name, config->size); 708 if (config->fixed_p) 709 printf_filtered (_("Packets are fixed at %ld bytes.\n"), 710 get_memory_packet_size (config)); 711 else 712 printf_filtered (_("Packets are limited to %ld bytes.\n"), 713 get_memory_packet_size (config)); 714 } 715 716 static struct memory_packet_config memory_write_packet_config = 717 { 718 "memory-write-packet-size", 719 }; 720 721 static void 722 set_memory_write_packet_size (char *args, int from_tty) 723 { 724 set_memory_packet_size (args, &memory_write_packet_config); 725 } 726 727 static void 728 show_memory_write_packet_size (char *args, int from_tty) 729 { 730 show_memory_packet_size (&memory_write_packet_config); 731 } 732 733 static long 734 get_memory_write_packet_size (void) 735 { 736 return get_memory_packet_size (&memory_write_packet_config); 737 } 738 739 static struct memory_packet_config memory_read_packet_config = 740 { 741 "memory-read-packet-size", 742 }; 743 744 static void 745 set_memory_read_packet_size (char *args, int from_tty) 746 { 747 set_memory_packet_size (args, &memory_read_packet_config); 748 } 749 750 static void 751 show_memory_read_packet_size (char *args, int from_tty) 752 { 753 show_memory_packet_size (&memory_read_packet_config); 754 } 755 756 static long 757 get_memory_read_packet_size (void) 758 { 759 long size = get_memory_packet_size (&memory_read_packet_config); 760 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an 761 extra buffer size argument before the memory read size can be 762 increased beyond this. */ 763 if (size > get_remote_packet_size ()) 764 size = get_remote_packet_size (); 765 return size; 766 } 767 768 769 /* Generic configuration support for packets the stub optionally 770 supports. Allows the user to specify the use of the packet as well 771 as allowing GDB to auto-detect support in the remote stub. */ 772 773 enum packet_support 774 { 775 PACKET_SUPPORT_UNKNOWN = 0, 776 PACKET_ENABLE, 777 PACKET_DISABLE 778 }; 779 780 struct packet_config 781 { 782 const char *name; 783 const char *title; 784 enum auto_boolean detect; 785 enum packet_support support; 786 }; 787 788 /* Analyze a packet's return value and update the packet config 789 accordingly. */ 790 791 enum packet_result 792 { 793 PACKET_ERROR, 794 PACKET_OK, 795 PACKET_UNKNOWN 796 }; 797 798 static void 799 update_packet_config (struct packet_config *config) 800 { 801 switch (config->detect) 802 { 803 case AUTO_BOOLEAN_TRUE: 804 config->support = PACKET_ENABLE; 805 break; 806 case AUTO_BOOLEAN_FALSE: 807 config->support = PACKET_DISABLE; 808 break; 809 case AUTO_BOOLEAN_AUTO: 810 config->support = PACKET_SUPPORT_UNKNOWN; 811 break; 812 } 813 } 814 815 static void 816 show_packet_config_cmd (struct packet_config *config) 817 { 818 char *support = "internal-error"; 819 switch (config->support) 820 { 821 case PACKET_ENABLE: 822 support = "enabled"; 823 break; 824 case PACKET_DISABLE: 825 support = "disabled"; 826 break; 827 case PACKET_SUPPORT_UNKNOWN: 828 support = "unknown"; 829 break; 830 } 831 switch (config->detect) 832 { 833 case AUTO_BOOLEAN_AUTO: 834 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"), 835 config->name, support); 836 break; 837 case AUTO_BOOLEAN_TRUE: 838 case AUTO_BOOLEAN_FALSE: 839 printf_filtered (_("Support for the `%s' packet is currently %s.\n"), 840 config->name, support); 841 break; 842 } 843 } 844 845 static void 846 add_packet_config_cmd (struct packet_config *config, const char *name, 847 const char *title, int legacy) 848 { 849 char *set_doc; 850 char *show_doc; 851 char *cmd_name; 852 853 config->name = name; 854 config->title = title; 855 config->detect = AUTO_BOOLEAN_AUTO; 856 config->support = PACKET_SUPPORT_UNKNOWN; 857 set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet", 858 name, title); 859 show_doc = xstrprintf ("Show current use of remote protocol `%s' (%s) packet", 860 name, title); 861 /* set/show TITLE-packet {auto,on,off} */ 862 cmd_name = xstrprintf ("%s-packet", title); 863 add_setshow_auto_boolean_cmd (cmd_name, class_obscure, 864 &config->detect, set_doc, show_doc, NULL, /* help_doc */ 865 set_remote_protocol_packet_cmd, 866 show_remote_protocol_packet_cmd, 867 &remote_set_cmdlist, &remote_show_cmdlist); 868 /* The command code copies the documentation strings. */ 869 xfree (set_doc); 870 xfree (show_doc); 871 /* set/show remote NAME-packet {auto,on,off} -- legacy. */ 872 if (legacy) 873 { 874 char *legacy_name; 875 legacy_name = xstrprintf ("%s-packet", name); 876 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0, 877 &remote_set_cmdlist); 878 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0, 879 &remote_show_cmdlist); 880 } 881 } 882 883 static enum packet_result 884 packet_check_result (const char *buf) 885 { 886 if (buf[0] != '\0') 887 { 888 /* The stub recognized the packet request. Check that the 889 operation succeeded. */ 890 if (buf[0] == 'E' 891 && isxdigit (buf[1]) && isxdigit (buf[2]) 892 && buf[3] == '\0') 893 /* "Enn" - definitly an error. */ 894 return PACKET_ERROR; 895 896 /* Always treat "E." as an error. This will be used for 897 more verbose error messages, such as E.memtypes. */ 898 if (buf[0] == 'E' && buf[1] == '.') 899 return PACKET_ERROR; 900 901 /* The packet may or may not be OK. Just assume it is. */ 902 return PACKET_OK; 903 } 904 else 905 /* The stub does not support the packet. */ 906 return PACKET_UNKNOWN; 907 } 908 909 static enum packet_result 910 packet_ok (const char *buf, struct packet_config *config) 911 { 912 enum packet_result result; 913 914 result = packet_check_result (buf); 915 switch (result) 916 { 917 case PACKET_OK: 918 case PACKET_ERROR: 919 /* The stub recognized the packet request. */ 920 switch (config->support) 921 { 922 case PACKET_SUPPORT_UNKNOWN: 923 if (remote_debug) 924 fprintf_unfiltered (gdb_stdlog, 925 "Packet %s (%s) is supported\n", 926 config->name, config->title); 927 config->support = PACKET_ENABLE; 928 break; 929 case PACKET_DISABLE: 930 internal_error (__FILE__, __LINE__, 931 _("packet_ok: attempt to use a disabled packet")); 932 break; 933 case PACKET_ENABLE: 934 break; 935 } 936 break; 937 case PACKET_UNKNOWN: 938 /* The stub does not support the packet. */ 939 switch (config->support) 940 { 941 case PACKET_ENABLE: 942 if (config->detect == AUTO_BOOLEAN_AUTO) 943 /* If the stub previously indicated that the packet was 944 supported then there is a protocol error.. */ 945 error (_("Protocol error: %s (%s) conflicting enabled responses."), 946 config->name, config->title); 947 else 948 /* The user set it wrong. */ 949 error (_("Enabled packet %s (%s) not recognized by stub"), 950 config->name, config->title); 951 break; 952 case PACKET_SUPPORT_UNKNOWN: 953 if (remote_debug) 954 fprintf_unfiltered (gdb_stdlog, 955 "Packet %s (%s) is NOT supported\n", 956 config->name, config->title); 957 config->support = PACKET_DISABLE; 958 break; 959 case PACKET_DISABLE: 960 break; 961 } 962 break; 963 } 964 965 return result; 966 } 967 968 enum { 969 PACKET_vCont = 0, 970 PACKET_X, 971 PACKET_qSymbol, 972 PACKET_P, 973 PACKET_p, 974 PACKET_Z0, 975 PACKET_Z1, 976 PACKET_Z2, 977 PACKET_Z3, 978 PACKET_Z4, 979 PACKET_vFile_open, 980 PACKET_vFile_pread, 981 PACKET_vFile_pwrite, 982 PACKET_vFile_close, 983 PACKET_vFile_unlink, 984 PACKET_qXfer_auxv, 985 PACKET_qXfer_features, 986 PACKET_qXfer_libraries, 987 PACKET_qXfer_memory_map, 988 PACKET_qXfer_spu_read, 989 PACKET_qXfer_spu_write, 990 PACKET_qXfer_osdata, 991 PACKET_qGetTLSAddr, 992 PACKET_qSupported, 993 PACKET_QPassSignals, 994 PACKET_qSearch_memory, 995 PACKET_vAttach, 996 PACKET_vRun, 997 PACKET_QStartNoAckMode, 998 PACKET_vKill, 999 PACKET_qXfer_siginfo_read, 1000 PACKET_qXfer_siginfo_write, 1001 PACKET_qAttached, 1002 PACKET_ConditionalTracepoints, 1003 PACKET_bc, 1004 PACKET_bs, 1005 PACKET_MAX 1006 }; 1007 1008 static struct packet_config remote_protocol_packets[PACKET_MAX]; 1009 1010 static void 1011 set_remote_protocol_packet_cmd (char *args, int from_tty, 1012 struct cmd_list_element *c) 1013 { 1014 struct packet_config *packet; 1015 1016 for (packet = remote_protocol_packets; 1017 packet < &remote_protocol_packets[PACKET_MAX]; 1018 packet++) 1019 { 1020 if (&packet->detect == c->var) 1021 { 1022 update_packet_config (packet); 1023 return; 1024 } 1025 } 1026 internal_error (__FILE__, __LINE__, "Could not find config for %s", 1027 c->name); 1028 } 1029 1030 static void 1031 show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty, 1032 struct cmd_list_element *c, 1033 const char *value) 1034 { 1035 struct packet_config *packet; 1036 1037 for (packet = remote_protocol_packets; 1038 packet < &remote_protocol_packets[PACKET_MAX]; 1039 packet++) 1040 { 1041 if (&packet->detect == c->var) 1042 { 1043 show_packet_config_cmd (packet); 1044 return; 1045 } 1046 } 1047 internal_error (__FILE__, __LINE__, "Could not find config for %s", 1048 c->name); 1049 } 1050 1051 /* Should we try one of the 'Z' requests? */ 1052 1053 enum Z_packet_type 1054 { 1055 Z_PACKET_SOFTWARE_BP, 1056 Z_PACKET_HARDWARE_BP, 1057 Z_PACKET_WRITE_WP, 1058 Z_PACKET_READ_WP, 1059 Z_PACKET_ACCESS_WP, 1060 NR_Z_PACKET_TYPES 1061 }; 1062 1063 /* For compatibility with older distributions. Provide a ``set remote 1064 Z-packet ...'' command that updates all the Z packet types. */ 1065 1066 static enum auto_boolean remote_Z_packet_detect; 1067 1068 static void 1069 set_remote_protocol_Z_packet_cmd (char *args, int from_tty, 1070 struct cmd_list_element *c) 1071 { 1072 int i; 1073 for (i = 0; i < NR_Z_PACKET_TYPES; i++) 1074 { 1075 remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect; 1076 update_packet_config (&remote_protocol_packets[PACKET_Z0 + i]); 1077 } 1078 } 1079 1080 static void 1081 show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty, 1082 struct cmd_list_element *c, 1083 const char *value) 1084 { 1085 int i; 1086 for (i = 0; i < NR_Z_PACKET_TYPES; i++) 1087 { 1088 show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]); 1089 } 1090 } 1091 1092 /* Should we try the 'ThreadInfo' query packet? 1093 1094 This variable (NOT available to the user: auto-detect only!) 1095 determines whether GDB will use the new, simpler "ThreadInfo" 1096 query or the older, more complex syntax for thread queries. 1097 This is an auto-detect variable (set to true at each connect, 1098 and set to false when the target fails to recognize it). */ 1099 1100 static int use_threadinfo_query; 1101 static int use_threadextra_query; 1102 1103 /* Tokens for use by the asynchronous signal handlers for SIGINT. */ 1104 static struct async_signal_handler *sigint_remote_twice_token; 1105 static struct async_signal_handler *sigint_remote_token; 1106 1107 1108 /* Asynchronous signal handle registered as event loop source for 1109 when we have pending events ready to be passed to the core. */ 1110 1111 static struct async_event_handler *remote_async_inferior_event_token; 1112 1113 /* Asynchronous signal handle registered as event loop source for when 1114 the remote sent us a %Stop notification. The registered callback 1115 will do a vStopped sequence to pull the rest of the events out of 1116 the remote side into our event queue. */ 1117 1118 static struct async_event_handler *remote_async_get_pending_events_token; 1119 1120 1121 static ptid_t magic_null_ptid; 1122 static ptid_t not_sent_ptid; 1123 static ptid_t any_thread_ptid; 1124 1125 /* These are the threads which we last sent to the remote system. The 1126 TID member will be -1 for all or -2 for not sent yet. */ 1127 1128 static ptid_t general_thread; 1129 static ptid_t continue_thread; 1130 1131 /* Find out if the stub attached to PID (and hence GDB should offer to 1132 detach instead of killing it when bailing out). */ 1133 1134 static int 1135 remote_query_attached (int pid) 1136 { 1137 struct remote_state *rs = get_remote_state (); 1138 1139 if (remote_protocol_packets[PACKET_qAttached].support == PACKET_DISABLE) 1140 return 0; 1141 1142 if (remote_multi_process_p (rs)) 1143 sprintf (rs->buf, "qAttached:%x", pid); 1144 else 1145 sprintf (rs->buf, "qAttached"); 1146 1147 putpkt (rs->buf); 1148 getpkt (&rs->buf, &rs->buf_size, 0); 1149 1150 switch (packet_ok (rs->buf, 1151 &remote_protocol_packets[PACKET_qAttached])) 1152 { 1153 case PACKET_OK: 1154 if (strcmp (rs->buf, "1") == 0) 1155 return 1; 1156 break; 1157 case PACKET_ERROR: 1158 warning (_("Remote failure reply: %s"), rs->buf); 1159 break; 1160 case PACKET_UNKNOWN: 1161 break; 1162 } 1163 1164 return 0; 1165 } 1166 1167 /* Add PID to GDB's inferior table. Since we can be connected to a 1168 remote system before before knowing about any inferior, mark the 1169 target with execution when we find the first inferior. If ATTACHED 1170 is 1, then we had just attached to this inferior. If it is 0, then 1171 we just created this inferior. If it is -1, then try querying the 1172 remote stub to find out if it had attached to the inferior or 1173 not. */ 1174 1175 static struct inferior * 1176 remote_add_inferior (int pid, int attached) 1177 { 1178 struct inferior *inf; 1179 1180 /* Check whether this process we're learning about is to be 1181 considered attached, or if is to be considered to have been 1182 spawned by the stub. */ 1183 if (attached == -1) 1184 attached = remote_query_attached (pid); 1185 1186 inf = add_inferior (pid); 1187 1188 inf->attach_flag = attached; 1189 1190 return inf; 1191 } 1192 1193 /* Add thread PTID to GDB's thread list. Tag it as executing/running 1194 according to RUNNING. */ 1195 1196 static void 1197 remote_add_thread (ptid_t ptid, int running) 1198 { 1199 add_thread (ptid); 1200 1201 set_executing (ptid, running); 1202 set_running (ptid, running); 1203 } 1204 1205 /* Come here when we learn about a thread id from the remote target. 1206 It may be the first time we hear about such thread, so take the 1207 opportunity to add it to GDB's thread list. In case this is the 1208 first time we're noticing its corresponding inferior, add it to 1209 GDB's inferior list as well. */ 1210 1211 static void 1212 remote_notice_new_inferior (ptid_t currthread, int running) 1213 { 1214 /* If this is a new thread, add it to GDB's thread list. 1215 If we leave it up to WFI to do this, bad things will happen. */ 1216 1217 if (in_thread_list (currthread) && is_exited (currthread)) 1218 { 1219 /* We're seeing an event on a thread id we knew had exited. 1220 This has to be a new thread reusing the old id. Add it. */ 1221 remote_add_thread (currthread, running); 1222 return; 1223 } 1224 1225 if (!in_thread_list (currthread)) 1226 { 1227 struct inferior *inf = NULL; 1228 int pid = ptid_get_pid (currthread); 1229 1230 if (ptid_is_pid (inferior_ptid) 1231 && pid == ptid_get_pid (inferior_ptid)) 1232 { 1233 /* inferior_ptid has no thread member yet. This can happen 1234 with the vAttach -> remote_wait,"TAAthread:" path if the 1235 stub doesn't support qC. This is the first stop reported 1236 after an attach, so this is the main thread. Update the 1237 ptid in the thread list. */ 1238 if (in_thread_list (pid_to_ptid (pid))) 1239 thread_change_ptid (inferior_ptid, currthread); 1240 else 1241 { 1242 remote_add_thread (currthread, running); 1243 inferior_ptid = currthread; 1244 } 1245 return; 1246 } 1247 1248 if (ptid_equal (magic_null_ptid, inferior_ptid)) 1249 { 1250 /* inferior_ptid is not set yet. This can happen with the 1251 vRun -> remote_wait,"TAAthread:" path if the stub 1252 doesn't support qC. This is the first stop reported 1253 after an attach, so this is the main thread. Update the 1254 ptid in the thread list. */ 1255 thread_change_ptid (inferior_ptid, currthread); 1256 return; 1257 } 1258 1259 /* When connecting to a target remote, or to a target 1260 extended-remote which already was debugging an inferior, we 1261 may not know about it yet. Add it before adding its child 1262 thread, so notifications are emitted in a sensible order. */ 1263 if (!in_inferior_list (ptid_get_pid (currthread))) 1264 inf = remote_add_inferior (ptid_get_pid (currthread), -1); 1265 1266 /* This is really a new thread. Add it. */ 1267 remote_add_thread (currthread, running); 1268 1269 /* If we found a new inferior, let the common code do whatever 1270 it needs to with it (e.g., read shared libraries, insert 1271 breakpoints). */ 1272 if (inf != NULL) 1273 notice_new_inferior (currthread, running, 0); 1274 } 1275 } 1276 1277 /* Call this function as a result of 1278 1) A halt indication (T packet) containing a thread id 1279 2) A direct query of currthread 1280 3) Successful execution of set thread 1281 */ 1282 1283 static void 1284 record_currthread (ptid_t currthread) 1285 { 1286 general_thread = currthread; 1287 1288 if (ptid_equal (currthread, minus_one_ptid)) 1289 /* We're just invalidating the local thread mirror. */ 1290 return; 1291 1292 remote_notice_new_inferior (currthread, 0); 1293 } 1294 1295 static char *last_pass_packet; 1296 1297 /* If 'QPassSignals' is supported, tell the remote stub what signals 1298 it can simply pass through to the inferior without reporting. */ 1299 1300 static void 1301 remote_pass_signals (void) 1302 { 1303 if (remote_protocol_packets[PACKET_QPassSignals].support != PACKET_DISABLE) 1304 { 1305 char *pass_packet, *p; 1306 int numsigs = (int) TARGET_SIGNAL_LAST; 1307 int count = 0, i; 1308 1309 gdb_assert (numsigs < 256); 1310 for (i = 0; i < numsigs; i++) 1311 { 1312 if (signal_stop_state (i) == 0 1313 && signal_print_state (i) == 0 1314 && signal_pass_state (i) == 1) 1315 count++; 1316 } 1317 pass_packet = xmalloc (count * 3 + strlen ("QPassSignals:") + 1); 1318 strcpy (pass_packet, "QPassSignals:"); 1319 p = pass_packet + strlen (pass_packet); 1320 for (i = 0; i < numsigs; i++) 1321 { 1322 if (signal_stop_state (i) == 0 1323 && signal_print_state (i) == 0 1324 && signal_pass_state (i) == 1) 1325 { 1326 if (i >= 16) 1327 *p++ = tohex (i >> 4); 1328 *p++ = tohex (i & 15); 1329 if (count) 1330 *p++ = ';'; 1331 else 1332 break; 1333 count--; 1334 } 1335 } 1336 *p = 0; 1337 if (!last_pass_packet || strcmp (last_pass_packet, pass_packet)) 1338 { 1339 struct remote_state *rs = get_remote_state (); 1340 char *buf = rs->buf; 1341 1342 putpkt (pass_packet); 1343 getpkt (&rs->buf, &rs->buf_size, 0); 1344 packet_ok (buf, &remote_protocol_packets[PACKET_QPassSignals]); 1345 if (last_pass_packet) 1346 xfree (last_pass_packet); 1347 last_pass_packet = pass_packet; 1348 } 1349 else 1350 xfree (pass_packet); 1351 } 1352 } 1353 1354 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is 1355 MINUS_ONE_PTID, set the thread to -1, so the stub returns the 1356 thread. If GEN is set, set the general thread, if not, then set 1357 the step/continue thread. */ 1358 static void 1359 set_thread (struct ptid ptid, int gen) 1360 { 1361 struct remote_state *rs = get_remote_state (); 1362 ptid_t state = gen ? general_thread : continue_thread; 1363 char *buf = rs->buf; 1364 char *endbuf = rs->buf + get_remote_packet_size (); 1365 1366 if (ptid_equal (state, ptid)) 1367 return; 1368 1369 *buf++ = 'H'; 1370 *buf++ = gen ? 'g' : 'c'; 1371 if (ptid_equal (ptid, magic_null_ptid)) 1372 xsnprintf (buf, endbuf - buf, "0"); 1373 else if (ptid_equal (ptid, any_thread_ptid)) 1374 xsnprintf (buf, endbuf - buf, "0"); 1375 else if (ptid_equal (ptid, minus_one_ptid)) 1376 xsnprintf (buf, endbuf - buf, "-1"); 1377 else 1378 write_ptid (buf, endbuf, ptid); 1379 putpkt (rs->buf); 1380 getpkt (&rs->buf, &rs->buf_size, 0); 1381 if (gen) 1382 general_thread = ptid; 1383 else 1384 continue_thread = ptid; 1385 } 1386 1387 static void 1388 set_general_thread (struct ptid ptid) 1389 { 1390 set_thread (ptid, 1); 1391 } 1392 1393 static void 1394 set_continue_thread (struct ptid ptid) 1395 { 1396 set_thread (ptid, 0); 1397 } 1398 1399 /* Change the remote current process. Which thread within the process 1400 ends up selected isn't important, as long as it is the same process 1401 as what INFERIOR_PTID points to. 1402 1403 This comes from that fact that there is no explicit notion of 1404 "selected process" in the protocol. The selected process for 1405 general operations is the process the selected general thread 1406 belongs to. */ 1407 1408 static void 1409 set_general_process (void) 1410 { 1411 struct remote_state *rs = get_remote_state (); 1412 1413 /* If the remote can't handle multiple processes, don't bother. */ 1414 if (!remote_multi_process_p (rs)) 1415 return; 1416 1417 /* We only need to change the remote current thread if it's pointing 1418 at some other process. */ 1419 if (ptid_get_pid (general_thread) != ptid_get_pid (inferior_ptid)) 1420 set_general_thread (inferior_ptid); 1421 } 1422 1423 1424 /* Return nonzero if the thread PTID is still alive on the remote 1425 system. */ 1426 1427 static int 1428 remote_thread_alive (struct target_ops *ops, ptid_t ptid) 1429 { 1430 struct remote_state *rs = get_remote_state (); 1431 char *p, *endp; 1432 1433 if (ptid_equal (ptid, magic_null_ptid)) 1434 /* The main thread is always alive. */ 1435 return 1; 1436 1437 if (ptid_get_pid (ptid) != 0 && ptid_get_tid (ptid) == 0) 1438 /* The main thread is always alive. This can happen after a 1439 vAttach, if the remote side doesn't support 1440 multi-threading. */ 1441 return 1; 1442 1443 p = rs->buf; 1444 endp = rs->buf + get_remote_packet_size (); 1445 1446 *p++ = 'T'; 1447 write_ptid (p, endp, ptid); 1448 1449 putpkt (rs->buf); 1450 getpkt (&rs->buf, &rs->buf_size, 0); 1451 return (rs->buf[0] == 'O' && rs->buf[1] == 'K'); 1452 } 1453 1454 /* About these extended threadlist and threadinfo packets. They are 1455 variable length packets but, the fields within them are often fixed 1456 length. They are redundent enough to send over UDP as is the 1457 remote protocol in general. There is a matching unit test module 1458 in libstub. */ 1459 1460 #define OPAQUETHREADBYTES 8 1461 1462 /* a 64 bit opaque identifier */ 1463 typedef unsigned char threadref[OPAQUETHREADBYTES]; 1464 1465 /* WARNING: This threadref data structure comes from the remote O.S., 1466 libstub protocol encoding, and remote.c. it is not particularly 1467 changable. */ 1468 1469 /* Right now, the internal structure is int. We want it to be bigger. 1470 Plan to fix this. 1471 */ 1472 1473 typedef int gdb_threadref; /* Internal GDB thread reference. */ 1474 1475 /* gdb_ext_thread_info is an internal GDB data structure which is 1476 equivalent to the reply of the remote threadinfo packet. */ 1477 1478 struct gdb_ext_thread_info 1479 { 1480 threadref threadid; /* External form of thread reference. */ 1481 int active; /* Has state interesting to GDB? 1482 regs, stack. */ 1483 char display[256]; /* Brief state display, name, 1484 blocked/suspended. */ 1485 char shortname[32]; /* To be used to name threads. */ 1486 char more_display[256]; /* Long info, statistics, queue depth, 1487 whatever. */ 1488 }; 1489 1490 /* The volume of remote transfers can be limited by submitting 1491 a mask containing bits specifying the desired information. 1492 Use a union of these values as the 'selection' parameter to 1493 get_thread_info. FIXME: Make these TAG names more thread specific. 1494 */ 1495 1496 #define TAG_THREADID 1 1497 #define TAG_EXISTS 2 1498 #define TAG_DISPLAY 4 1499 #define TAG_THREADNAME 8 1500 #define TAG_MOREDISPLAY 16 1501 1502 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2) 1503 1504 char *unpack_varlen_hex (char *buff, ULONGEST *result); 1505 1506 static char *unpack_nibble (char *buf, int *val); 1507 1508 static char *pack_nibble (char *buf, int nibble); 1509 1510 static char *pack_hex_byte (char *pkt, int /* unsigned char */ byte); 1511 1512 static char *unpack_byte (char *buf, int *value); 1513 1514 static char *pack_int (char *buf, int value); 1515 1516 static char *unpack_int (char *buf, int *value); 1517 1518 static char *unpack_string (char *src, char *dest, int length); 1519 1520 static char *pack_threadid (char *pkt, threadref *id); 1521 1522 static char *unpack_threadid (char *inbuf, threadref *id); 1523 1524 void int_to_threadref (threadref *id, int value); 1525 1526 static int threadref_to_int (threadref *ref); 1527 1528 static void copy_threadref (threadref *dest, threadref *src); 1529 1530 static int threadmatch (threadref *dest, threadref *src); 1531 1532 static char *pack_threadinfo_request (char *pkt, int mode, 1533 threadref *id); 1534 1535 static int remote_unpack_thread_info_response (char *pkt, 1536 threadref *expectedref, 1537 struct gdb_ext_thread_info 1538 *info); 1539 1540 1541 static int remote_get_threadinfo (threadref *threadid, 1542 int fieldset, /*TAG mask */ 1543 struct gdb_ext_thread_info *info); 1544 1545 static char *pack_threadlist_request (char *pkt, int startflag, 1546 int threadcount, 1547 threadref *nextthread); 1548 1549 static int parse_threadlist_response (char *pkt, 1550 int result_limit, 1551 threadref *original_echo, 1552 threadref *resultlist, 1553 int *doneflag); 1554 1555 static int remote_get_threadlist (int startflag, 1556 threadref *nextthread, 1557 int result_limit, 1558 int *done, 1559 int *result_count, 1560 threadref *threadlist); 1561 1562 typedef int (*rmt_thread_action) (threadref *ref, void *context); 1563 1564 static int remote_threadlist_iterator (rmt_thread_action stepfunction, 1565 void *context, int looplimit); 1566 1567 static int remote_newthread_step (threadref *ref, void *context); 1568 1569 1570 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the 1571 buffer we're allowed to write to. Returns 1572 BUF+CHARACTERS_WRITTEN. */ 1573 1574 static char * 1575 write_ptid (char *buf, const char *endbuf, ptid_t ptid) 1576 { 1577 int pid, tid; 1578 struct remote_state *rs = get_remote_state (); 1579 1580 if (remote_multi_process_p (rs)) 1581 { 1582 pid = ptid_get_pid (ptid); 1583 if (pid < 0) 1584 buf += xsnprintf (buf, endbuf - buf, "p-%x.", -pid); 1585 else 1586 buf += xsnprintf (buf, endbuf - buf, "p%x.", pid); 1587 } 1588 tid = ptid_get_tid (ptid); 1589 if (tid < 0) 1590 buf += xsnprintf (buf, endbuf - buf, "-%x", -tid); 1591 else 1592 buf += xsnprintf (buf, endbuf - buf, "%x", tid); 1593 1594 return buf; 1595 } 1596 1597 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one 1598 passed the last parsed char. Returns null_ptid on error. */ 1599 1600 static ptid_t 1601 read_ptid (char *buf, char **obuf) 1602 { 1603 char *p = buf; 1604 char *pp; 1605 ULONGEST pid = 0, tid = 0; 1606 1607 if (*p == 'p') 1608 { 1609 /* Multi-process ptid. */ 1610 pp = unpack_varlen_hex (p + 1, &pid); 1611 if (*pp != '.') 1612 error (_("invalid remote ptid: %s\n"), p); 1613 1614 p = pp; 1615 pp = unpack_varlen_hex (p + 1, &tid); 1616 if (obuf) 1617 *obuf = pp; 1618 return ptid_build (pid, 0, tid); 1619 } 1620 1621 /* No multi-process. Just a tid. */ 1622 pp = unpack_varlen_hex (p, &tid); 1623 1624 /* Since the stub is not sending a process id, then default to 1625 what's in inferior_ptid, unless it's null at this point. If so, 1626 then since there's no way to know the pid of the reported 1627 threads, use the magic number. */ 1628 if (ptid_equal (inferior_ptid, null_ptid)) 1629 pid = ptid_get_pid (magic_null_ptid); 1630 else 1631 pid = ptid_get_pid (inferior_ptid); 1632 1633 if (obuf) 1634 *obuf = pp; 1635 return ptid_build (pid, 0, tid); 1636 } 1637 1638 /* Encode 64 bits in 16 chars of hex. */ 1639 1640 static const char hexchars[] = "0123456789abcdef"; 1641 1642 static int 1643 ishex (int ch, int *val) 1644 { 1645 if ((ch >= 'a') && (ch <= 'f')) 1646 { 1647 *val = ch - 'a' + 10; 1648 return 1; 1649 } 1650 if ((ch >= 'A') && (ch <= 'F')) 1651 { 1652 *val = ch - 'A' + 10; 1653 return 1; 1654 } 1655 if ((ch >= '0') && (ch <= '9')) 1656 { 1657 *val = ch - '0'; 1658 return 1; 1659 } 1660 return 0; 1661 } 1662 1663 static int 1664 stubhex (int ch) 1665 { 1666 if (ch >= 'a' && ch <= 'f') 1667 return ch - 'a' + 10; 1668 if (ch >= '0' && ch <= '9') 1669 return ch - '0'; 1670 if (ch >= 'A' && ch <= 'F') 1671 return ch - 'A' + 10; 1672 return -1; 1673 } 1674 1675 static int 1676 stub_unpack_int (char *buff, int fieldlength) 1677 { 1678 int nibble; 1679 int retval = 0; 1680 1681 while (fieldlength) 1682 { 1683 nibble = stubhex (*buff++); 1684 retval |= nibble; 1685 fieldlength--; 1686 if (fieldlength) 1687 retval = retval << 4; 1688 } 1689 return retval; 1690 } 1691 1692 char * 1693 unpack_varlen_hex (char *buff, /* packet to parse */ 1694 ULONGEST *result) 1695 { 1696 int nibble; 1697 ULONGEST retval = 0; 1698 1699 while (ishex (*buff, &nibble)) 1700 { 1701 buff++; 1702 retval = retval << 4; 1703 retval |= nibble & 0x0f; 1704 } 1705 *result = retval; 1706 return buff; 1707 } 1708 1709 static char * 1710 unpack_nibble (char *buf, int *val) 1711 { 1712 *val = fromhex (*buf++); 1713 return buf; 1714 } 1715 1716 static char * 1717 pack_nibble (char *buf, int nibble) 1718 { 1719 *buf++ = hexchars[(nibble & 0x0f)]; 1720 return buf; 1721 } 1722 1723 static char * 1724 pack_hex_byte (char *pkt, int byte) 1725 { 1726 *pkt++ = hexchars[(byte >> 4) & 0xf]; 1727 *pkt++ = hexchars[(byte & 0xf)]; 1728 return pkt; 1729 } 1730 1731 static char * 1732 unpack_byte (char *buf, int *value) 1733 { 1734 *value = stub_unpack_int (buf, 2); 1735 return buf + 2; 1736 } 1737 1738 static char * 1739 pack_int (char *buf, int value) 1740 { 1741 buf = pack_hex_byte (buf, (value >> 24) & 0xff); 1742 buf = pack_hex_byte (buf, (value >> 16) & 0xff); 1743 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff); 1744 buf = pack_hex_byte (buf, (value & 0xff)); 1745 return buf; 1746 } 1747 1748 static char * 1749 unpack_int (char *buf, int *value) 1750 { 1751 *value = stub_unpack_int (buf, 8); 1752 return buf + 8; 1753 } 1754 1755 #if 0 /* Currently unused, uncomment when needed. */ 1756 static char *pack_string (char *pkt, char *string); 1757 1758 static char * 1759 pack_string (char *pkt, char *string) 1760 { 1761 char ch; 1762 int len; 1763 1764 len = strlen (string); 1765 if (len > 200) 1766 len = 200; /* Bigger than most GDB packets, junk??? */ 1767 pkt = pack_hex_byte (pkt, len); 1768 while (len-- > 0) 1769 { 1770 ch = *string++; 1771 if ((ch == '\0') || (ch == '#')) 1772 ch = '*'; /* Protect encapsulation. */ 1773 *pkt++ = ch; 1774 } 1775 return pkt; 1776 } 1777 #endif /* 0 (unused) */ 1778 1779 static char * 1780 unpack_string (char *src, char *dest, int length) 1781 { 1782 while (length--) 1783 *dest++ = *src++; 1784 *dest = '\0'; 1785 return src; 1786 } 1787 1788 static char * 1789 pack_threadid (char *pkt, threadref *id) 1790 { 1791 char *limit; 1792 unsigned char *altid; 1793 1794 altid = (unsigned char *) id; 1795 limit = pkt + BUF_THREAD_ID_SIZE; 1796 while (pkt < limit) 1797 pkt = pack_hex_byte (pkt, *altid++); 1798 return pkt; 1799 } 1800 1801 1802 static char * 1803 unpack_threadid (char *inbuf, threadref *id) 1804 { 1805 char *altref; 1806 char *limit = inbuf + BUF_THREAD_ID_SIZE; 1807 int x, y; 1808 1809 altref = (char *) id; 1810 1811 while (inbuf < limit) 1812 { 1813 x = stubhex (*inbuf++); 1814 y = stubhex (*inbuf++); 1815 *altref++ = (x << 4) | y; 1816 } 1817 return inbuf; 1818 } 1819 1820 /* Externally, threadrefs are 64 bits but internally, they are still 1821 ints. This is due to a mismatch of specifications. We would like 1822 to use 64bit thread references internally. This is an adapter 1823 function. */ 1824 1825 void 1826 int_to_threadref (threadref *id, int value) 1827 { 1828 unsigned char *scan; 1829 1830 scan = (unsigned char *) id; 1831 { 1832 int i = 4; 1833 while (i--) 1834 *scan++ = 0; 1835 } 1836 *scan++ = (value >> 24) & 0xff; 1837 *scan++ = (value >> 16) & 0xff; 1838 *scan++ = (value >> 8) & 0xff; 1839 *scan++ = (value & 0xff); 1840 } 1841 1842 static int 1843 threadref_to_int (threadref *ref) 1844 { 1845 int i, value = 0; 1846 unsigned char *scan; 1847 1848 scan = *ref; 1849 scan += 4; 1850 i = 4; 1851 while (i-- > 0) 1852 value = (value << 8) | ((*scan++) & 0xff); 1853 return value; 1854 } 1855 1856 static void 1857 copy_threadref (threadref *dest, threadref *src) 1858 { 1859 int i; 1860 unsigned char *csrc, *cdest; 1861 1862 csrc = (unsigned char *) src; 1863 cdest = (unsigned char *) dest; 1864 i = 8; 1865 while (i--) 1866 *cdest++ = *csrc++; 1867 } 1868 1869 static int 1870 threadmatch (threadref *dest, threadref *src) 1871 { 1872 /* Things are broken right now, so just assume we got a match. */ 1873 #if 0 1874 unsigned char *srcp, *destp; 1875 int i, result; 1876 srcp = (char *) src; 1877 destp = (char *) dest; 1878 1879 result = 1; 1880 while (i-- > 0) 1881 result &= (*srcp++ == *destp++) ? 1 : 0; 1882 return result; 1883 #endif 1884 return 1; 1885 } 1886 1887 /* 1888 threadid:1, # always request threadid 1889 context_exists:2, 1890 display:4, 1891 unique_name:8, 1892 more_display:16 1893 */ 1894 1895 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */ 1896 1897 static char * 1898 pack_threadinfo_request (char *pkt, int mode, threadref *id) 1899 { 1900 *pkt++ = 'q'; /* Info Query */ 1901 *pkt++ = 'P'; /* process or thread info */ 1902 pkt = pack_int (pkt, mode); /* mode */ 1903 pkt = pack_threadid (pkt, id); /* threadid */ 1904 *pkt = '\0'; /* terminate */ 1905 return pkt; 1906 } 1907 1908 /* These values tag the fields in a thread info response packet. */ 1909 /* Tagging the fields allows us to request specific fields and to 1910 add more fields as time goes by. */ 1911 1912 #define TAG_THREADID 1 /* Echo the thread identifier. */ 1913 #define TAG_EXISTS 2 /* Is this process defined enough to 1914 fetch registers and its stack? */ 1915 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */ 1916 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */ 1917 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about 1918 the process. */ 1919 1920 static int 1921 remote_unpack_thread_info_response (char *pkt, threadref *expectedref, 1922 struct gdb_ext_thread_info *info) 1923 { 1924 struct remote_state *rs = get_remote_state (); 1925 int mask, length; 1926 int tag; 1927 threadref ref; 1928 char *limit = pkt + rs->buf_size; /* Plausible parsing limit. */ 1929 int retval = 1; 1930 1931 /* info->threadid = 0; FIXME: implement zero_threadref. */ 1932 info->active = 0; 1933 info->display[0] = '\0'; 1934 info->shortname[0] = '\0'; 1935 info->more_display[0] = '\0'; 1936 1937 /* Assume the characters indicating the packet type have been 1938 stripped. */ 1939 pkt = unpack_int (pkt, &mask); /* arg mask */ 1940 pkt = unpack_threadid (pkt, &ref); 1941 1942 if (mask == 0) 1943 warning (_("Incomplete response to threadinfo request.")); 1944 if (!threadmatch (&ref, expectedref)) 1945 { /* This is an answer to a different request. */ 1946 warning (_("ERROR RMT Thread info mismatch.")); 1947 return 0; 1948 } 1949 copy_threadref (&info->threadid, &ref); 1950 1951 /* Loop on tagged fields , try to bail if somthing goes wrong. */ 1952 1953 /* Packets are terminated with nulls. */ 1954 while ((pkt < limit) && mask && *pkt) 1955 { 1956 pkt = unpack_int (pkt, &tag); /* tag */ 1957 pkt = unpack_byte (pkt, &length); /* length */ 1958 if (!(tag & mask)) /* Tags out of synch with mask. */ 1959 { 1960 warning (_("ERROR RMT: threadinfo tag mismatch.")); 1961 retval = 0; 1962 break; 1963 } 1964 if (tag == TAG_THREADID) 1965 { 1966 if (length != 16) 1967 { 1968 warning (_("ERROR RMT: length of threadid is not 16.")); 1969 retval = 0; 1970 break; 1971 } 1972 pkt = unpack_threadid (pkt, &ref); 1973 mask = mask & ~TAG_THREADID; 1974 continue; 1975 } 1976 if (tag == TAG_EXISTS) 1977 { 1978 info->active = stub_unpack_int (pkt, length); 1979 pkt += length; 1980 mask = mask & ~(TAG_EXISTS); 1981 if (length > 8) 1982 { 1983 warning (_("ERROR RMT: 'exists' length too long.")); 1984 retval = 0; 1985 break; 1986 } 1987 continue; 1988 } 1989 if (tag == TAG_THREADNAME) 1990 { 1991 pkt = unpack_string (pkt, &info->shortname[0], length); 1992 mask = mask & ~TAG_THREADNAME; 1993 continue; 1994 } 1995 if (tag == TAG_DISPLAY) 1996 { 1997 pkt = unpack_string (pkt, &info->display[0], length); 1998 mask = mask & ~TAG_DISPLAY; 1999 continue; 2000 } 2001 if (tag == TAG_MOREDISPLAY) 2002 { 2003 pkt = unpack_string (pkt, &info->more_display[0], length); 2004 mask = mask & ~TAG_MOREDISPLAY; 2005 continue; 2006 } 2007 warning (_("ERROR RMT: unknown thread info tag.")); 2008 break; /* Not a tag we know about. */ 2009 } 2010 return retval; 2011 } 2012 2013 static int 2014 remote_get_threadinfo (threadref *threadid, int fieldset, /* TAG mask */ 2015 struct gdb_ext_thread_info *info) 2016 { 2017 struct remote_state *rs = get_remote_state (); 2018 int result; 2019 2020 pack_threadinfo_request (rs->buf, fieldset, threadid); 2021 putpkt (rs->buf); 2022 getpkt (&rs->buf, &rs->buf_size, 0); 2023 2024 if (rs->buf[0] == '\0') 2025 return 0; 2026 2027 result = remote_unpack_thread_info_response (rs->buf + 2, 2028 threadid, info); 2029 return result; 2030 } 2031 2032 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */ 2033 2034 static char * 2035 pack_threadlist_request (char *pkt, int startflag, int threadcount, 2036 threadref *nextthread) 2037 { 2038 *pkt++ = 'q'; /* info query packet */ 2039 *pkt++ = 'L'; /* Process LIST or threadLIST request */ 2040 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */ 2041 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */ 2042 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */ 2043 *pkt = '\0'; 2044 return pkt; 2045 } 2046 2047 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */ 2048 2049 static int 2050 parse_threadlist_response (char *pkt, int result_limit, 2051 threadref *original_echo, threadref *resultlist, 2052 int *doneflag) 2053 { 2054 struct remote_state *rs = get_remote_state (); 2055 char *limit; 2056 int count, resultcount, done; 2057 2058 resultcount = 0; 2059 /* Assume the 'q' and 'M chars have been stripped. */ 2060 limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE); 2061 /* done parse past here */ 2062 pkt = unpack_byte (pkt, &count); /* count field */ 2063 pkt = unpack_nibble (pkt, &done); 2064 /* The first threadid is the argument threadid. */ 2065 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */ 2066 while ((count-- > 0) && (pkt < limit)) 2067 { 2068 pkt = unpack_threadid (pkt, resultlist++); 2069 if (resultcount++ >= result_limit) 2070 break; 2071 } 2072 if (doneflag) 2073 *doneflag = done; 2074 return resultcount; 2075 } 2076 2077 static int 2078 remote_get_threadlist (int startflag, threadref *nextthread, int result_limit, 2079 int *done, int *result_count, threadref *threadlist) 2080 { 2081 struct remote_state *rs = get_remote_state (); 2082 static threadref echo_nextthread; 2083 int result = 1; 2084 2085 /* Trancate result limit to be smaller than the packet size. */ 2086 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= get_remote_packet_size ()) 2087 result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2; 2088 2089 pack_threadlist_request (rs->buf, startflag, result_limit, nextthread); 2090 putpkt (rs->buf); 2091 getpkt (&rs->buf, &rs->buf_size, 0); 2092 2093 if (*rs->buf == '\0') 2094 *result_count = 0; 2095 else 2096 *result_count = 2097 parse_threadlist_response (rs->buf + 2, result_limit, &echo_nextthread, 2098 threadlist, done); 2099 2100 if (!threadmatch (&echo_nextthread, nextthread)) 2101 { 2102 /* FIXME: This is a good reason to drop the packet. */ 2103 /* Possably, there is a duplicate response. */ 2104 /* Possabilities : 2105 retransmit immediatly - race conditions 2106 retransmit after timeout - yes 2107 exit 2108 wait for packet, then exit 2109 */ 2110 warning (_("HMM: threadlist did not echo arg thread, dropping it.")); 2111 return 0; /* I choose simply exiting. */ 2112 } 2113 if (*result_count <= 0) 2114 { 2115 if (*done != 1) 2116 { 2117 warning (_("RMT ERROR : failed to get remote thread list.")); 2118 result = 0; 2119 } 2120 return result; /* break; */ 2121 } 2122 if (*result_count > result_limit) 2123 { 2124 *result_count = 0; 2125 warning (_("RMT ERROR: threadlist response longer than requested.")); 2126 return 0; 2127 } 2128 return result; 2129 } 2130 2131 /* This is the interface between remote and threads, remotes upper 2132 interface. */ 2133 2134 /* remote_find_new_threads retrieves the thread list and for each 2135 thread in the list, looks up the thread in GDB's internal list, 2136 adding the thread if it does not already exist. This involves 2137 getting partial thread lists from the remote target so, polling the 2138 quit_flag is required. */ 2139 2140 2141 /* About this many threadisds fit in a packet. */ 2142 2143 #define MAXTHREADLISTRESULTS 32 2144 2145 static int 2146 remote_threadlist_iterator (rmt_thread_action stepfunction, void *context, 2147 int looplimit) 2148 { 2149 int done, i, result_count; 2150 int startflag = 1; 2151 int result = 1; 2152 int loopcount = 0; 2153 static threadref nextthread; 2154 static threadref resultthreadlist[MAXTHREADLISTRESULTS]; 2155 2156 done = 0; 2157 while (!done) 2158 { 2159 if (loopcount++ > looplimit) 2160 { 2161 result = 0; 2162 warning (_("Remote fetch threadlist -infinite loop-.")); 2163 break; 2164 } 2165 if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS, 2166 &done, &result_count, resultthreadlist)) 2167 { 2168 result = 0; 2169 break; 2170 } 2171 /* Clear for later iterations. */ 2172 startflag = 0; 2173 /* Setup to resume next batch of thread references, set nextthread. */ 2174 if (result_count >= 1) 2175 copy_threadref (&nextthread, &resultthreadlist[result_count - 1]); 2176 i = 0; 2177 while (result_count--) 2178 if (!(result = (*stepfunction) (&resultthreadlist[i++], context))) 2179 break; 2180 } 2181 return result; 2182 } 2183 2184 static int 2185 remote_newthread_step (threadref *ref, void *context) 2186 { 2187 int pid = ptid_get_pid (inferior_ptid); 2188 ptid_t ptid = ptid_build (pid, 0, threadref_to_int (ref)); 2189 2190 if (!in_thread_list (ptid)) 2191 add_thread (ptid); 2192 return 1; /* continue iterator */ 2193 } 2194 2195 #define CRAZY_MAX_THREADS 1000 2196 2197 static ptid_t 2198 remote_current_thread (ptid_t oldpid) 2199 { 2200 struct remote_state *rs = get_remote_state (); 2201 2202 putpkt ("qC"); 2203 getpkt (&rs->buf, &rs->buf_size, 0); 2204 if (rs->buf[0] == 'Q' && rs->buf[1] == 'C') 2205 return read_ptid (&rs->buf[2], NULL); 2206 else 2207 return oldpid; 2208 } 2209 2210 /* Find new threads for info threads command. 2211 * Original version, using John Metzler's thread protocol. 2212 */ 2213 2214 static void 2215 remote_find_new_threads (void) 2216 { 2217 remote_threadlist_iterator (remote_newthread_step, 0, 2218 CRAZY_MAX_THREADS); 2219 } 2220 2221 /* 2222 * Find all threads for info threads command. 2223 * Uses new thread protocol contributed by Cisco. 2224 * Falls back and attempts to use the older method (above) 2225 * if the target doesn't respond to the new method. 2226 */ 2227 2228 static void 2229 remote_threads_info (struct target_ops *ops) 2230 { 2231 struct remote_state *rs = get_remote_state (); 2232 char *bufp; 2233 ptid_t new_thread; 2234 2235 if (remote_desc == 0) /* paranoia */ 2236 error (_("Command can only be used when connected to the remote target.")); 2237 2238 if (use_threadinfo_query) 2239 { 2240 putpkt ("qfThreadInfo"); 2241 getpkt (&rs->buf, &rs->buf_size, 0); 2242 bufp = rs->buf; 2243 if (bufp[0] != '\0') /* q packet recognized */ 2244 { 2245 while (*bufp++ == 'm') /* reply contains one or more TID */ 2246 { 2247 do 2248 { 2249 new_thread = read_ptid (bufp, &bufp); 2250 if (!ptid_equal (new_thread, null_ptid)) 2251 { 2252 /* In non-stop mode, we assume new found threads 2253 are running until proven otherwise with a 2254 stop reply. In all-stop, we can only get 2255 here if all threads are stopped. */ 2256 int running = non_stop ? 1 : 0; 2257 2258 remote_notice_new_inferior (new_thread, running); 2259 } 2260 } 2261 while (*bufp++ == ','); /* comma-separated list */ 2262 putpkt ("qsThreadInfo"); 2263 getpkt (&rs->buf, &rs->buf_size, 0); 2264 bufp = rs->buf; 2265 } 2266 return; /* done */ 2267 } 2268 } 2269 2270 /* Only qfThreadInfo is supported in non-stop mode. */ 2271 if (non_stop) 2272 return; 2273 2274 /* Else fall back to old method based on jmetzler protocol. */ 2275 use_threadinfo_query = 0; 2276 remote_find_new_threads (); 2277 return; 2278 } 2279 2280 /* 2281 * Collect a descriptive string about the given thread. 2282 * The target may say anything it wants to about the thread 2283 * (typically info about its blocked / runnable state, name, etc.). 2284 * This string will appear in the info threads display. 2285 * 2286 * Optional: targets are not required to implement this function. 2287 */ 2288 2289 static char * 2290 remote_threads_extra_info (struct thread_info *tp) 2291 { 2292 struct remote_state *rs = get_remote_state (); 2293 int result; 2294 int set; 2295 threadref id; 2296 struct gdb_ext_thread_info threadinfo; 2297 static char display_buf[100]; /* arbitrary... */ 2298 int n = 0; /* position in display_buf */ 2299 2300 if (remote_desc == 0) /* paranoia */ 2301 internal_error (__FILE__, __LINE__, 2302 _("remote_threads_extra_info")); 2303 2304 if (ptid_equal (tp->ptid, magic_null_ptid) 2305 || (ptid_get_pid (tp->ptid) != 0 && ptid_get_tid (tp->ptid) == 0)) 2306 /* This is the main thread which was added by GDB. The remote 2307 server doesn't know about it. */ 2308 return NULL; 2309 2310 if (use_threadextra_query) 2311 { 2312 char *b = rs->buf; 2313 char *endb = rs->buf + get_remote_packet_size (); 2314 2315 xsnprintf (b, endb - b, "qThreadExtraInfo,"); 2316 b += strlen (b); 2317 write_ptid (b, endb, tp->ptid); 2318 2319 putpkt (rs->buf); 2320 getpkt (&rs->buf, &rs->buf_size, 0); 2321 if (rs->buf[0] != 0) 2322 { 2323 n = min (strlen (rs->buf) / 2, sizeof (display_buf)); 2324 result = hex2bin (rs->buf, (gdb_byte *) display_buf, n); 2325 display_buf [result] = '\0'; 2326 return display_buf; 2327 } 2328 } 2329 2330 /* If the above query fails, fall back to the old method. */ 2331 use_threadextra_query = 0; 2332 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME 2333 | TAG_MOREDISPLAY | TAG_DISPLAY; 2334 int_to_threadref (&id, ptid_get_tid (tp->ptid)); 2335 if (remote_get_threadinfo (&id, set, &threadinfo)) 2336 if (threadinfo.active) 2337 { 2338 if (*threadinfo.shortname) 2339 n += xsnprintf (&display_buf[0], sizeof (display_buf) - n, 2340 " Name: %s,", threadinfo.shortname); 2341 if (*threadinfo.display) 2342 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n, 2343 " State: %s,", threadinfo.display); 2344 if (*threadinfo.more_display) 2345 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n, 2346 " Priority: %s", threadinfo.more_display); 2347 2348 if (n > 0) 2349 { 2350 /* For purely cosmetic reasons, clear up trailing commas. */ 2351 if (',' == display_buf[n-1]) 2352 display_buf[n-1] = ' '; 2353 return display_buf; 2354 } 2355 } 2356 return NULL; 2357 } 2358 2359 2360 /* Restart the remote side; this is an extended protocol operation. */ 2361 2362 static void 2363 extended_remote_restart (void) 2364 { 2365 struct remote_state *rs = get_remote_state (); 2366 2367 /* Send the restart command; for reasons I don't understand the 2368 remote side really expects a number after the "R". */ 2369 xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0); 2370 putpkt (rs->buf); 2371 2372 remote_fileio_reset (); 2373 } 2374 2375 /* Clean up connection to a remote debugger. */ 2376 2377 static void 2378 remote_close (int quitting) 2379 { 2380 if (remote_desc == NULL) 2381 return; /* already closed */ 2382 2383 /* Make sure we leave stdin registered in the event loop, and we 2384 don't leave the async SIGINT signal handler installed. */ 2385 remote_terminal_ours (); 2386 2387 serial_close (remote_desc); 2388 remote_desc = NULL; 2389 2390 /* We don't have a connection to the remote stub anymore. Get rid 2391 of all the inferiors and their threads we were controlling. */ 2392 discard_all_inferiors (); 2393 2394 /* We're no longer interested in any of these events. */ 2395 discard_pending_stop_replies (-1); 2396 2397 if (remote_async_inferior_event_token) 2398 delete_async_event_handler (&remote_async_inferior_event_token); 2399 if (remote_async_get_pending_events_token) 2400 delete_async_event_handler (&remote_async_get_pending_events_token); 2401 } 2402 2403 /* Query the remote side for the text, data and bss offsets. */ 2404 2405 static void 2406 get_offsets (void) 2407 { 2408 struct remote_state *rs = get_remote_state (); 2409 char *buf; 2410 char *ptr; 2411 int lose, num_segments = 0, do_sections, do_segments; 2412 CORE_ADDR text_addr, data_addr, bss_addr, segments[2]; 2413 struct section_offsets *offs; 2414 struct symfile_segment_data *data; 2415 2416 if (symfile_objfile == NULL) 2417 return; 2418 2419 putpkt ("qOffsets"); 2420 getpkt (&rs->buf, &rs->buf_size, 0); 2421 buf = rs->buf; 2422 2423 if (buf[0] == '\000') 2424 return; /* Return silently. Stub doesn't support 2425 this command. */ 2426 if (buf[0] == 'E') 2427 { 2428 warning (_("Remote failure reply: %s"), buf); 2429 return; 2430 } 2431 2432 /* Pick up each field in turn. This used to be done with scanf, but 2433 scanf will make trouble if CORE_ADDR size doesn't match 2434 conversion directives correctly. The following code will work 2435 with any size of CORE_ADDR. */ 2436 text_addr = data_addr = bss_addr = 0; 2437 ptr = buf; 2438 lose = 0; 2439 2440 if (strncmp (ptr, "Text=", 5) == 0) 2441 { 2442 ptr += 5; 2443 /* Don't use strtol, could lose on big values. */ 2444 while (*ptr && *ptr != ';') 2445 text_addr = (text_addr << 4) + fromhex (*ptr++); 2446 2447 if (strncmp (ptr, ";Data=", 6) == 0) 2448 { 2449 ptr += 6; 2450 while (*ptr && *ptr != ';') 2451 data_addr = (data_addr << 4) + fromhex (*ptr++); 2452 } 2453 else 2454 lose = 1; 2455 2456 if (!lose && strncmp (ptr, ";Bss=", 5) == 0) 2457 { 2458 ptr += 5; 2459 while (*ptr && *ptr != ';') 2460 bss_addr = (bss_addr << 4) + fromhex (*ptr++); 2461 2462 if (bss_addr != data_addr) 2463 warning (_("Target reported unsupported offsets: %s"), buf); 2464 } 2465 else 2466 lose = 1; 2467 } 2468 else if (strncmp (ptr, "TextSeg=", 8) == 0) 2469 { 2470 ptr += 8; 2471 /* Don't use strtol, could lose on big values. */ 2472 while (*ptr && *ptr != ';') 2473 text_addr = (text_addr << 4) + fromhex (*ptr++); 2474 num_segments = 1; 2475 2476 if (strncmp (ptr, ";DataSeg=", 9) == 0) 2477 { 2478 ptr += 9; 2479 while (*ptr && *ptr != ';') 2480 data_addr = (data_addr << 4) + fromhex (*ptr++); 2481 num_segments++; 2482 } 2483 } 2484 else 2485 lose = 1; 2486 2487 if (lose) 2488 error (_("Malformed response to offset query, %s"), buf); 2489 else if (*ptr != '\0') 2490 warning (_("Target reported unsupported offsets: %s"), buf); 2491 2492 offs = ((struct section_offsets *) 2493 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections))); 2494 memcpy (offs, symfile_objfile->section_offsets, 2495 SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)); 2496 2497 data = get_symfile_segment_data (symfile_objfile->obfd); 2498 do_segments = (data != NULL); 2499 do_sections = num_segments == 0; 2500 2501 if (num_segments > 0) 2502 { 2503 segments[0] = text_addr; 2504 segments[1] = data_addr; 2505 } 2506 /* If we have two segments, we can still try to relocate everything 2507 by assuming that the .text and .data offsets apply to the whole 2508 text and data segments. Convert the offsets given in the packet 2509 to base addresses for symfile_map_offsets_to_segments. */ 2510 else if (data && data->num_segments == 2) 2511 { 2512 segments[0] = data->segment_bases[0] + text_addr; 2513 segments[1] = data->segment_bases[1] + data_addr; 2514 num_segments = 2; 2515 } 2516 /* If the object file has only one segment, assume that it is text 2517 rather than data; main programs with no writable data are rare, 2518 but programs with no code are useless. Of course the code might 2519 have ended up in the data segment... to detect that we would need 2520 the permissions here. */ 2521 else if (data && data->num_segments == 1) 2522 { 2523 segments[0] = data->segment_bases[0] + text_addr; 2524 num_segments = 1; 2525 } 2526 /* There's no way to relocate by segment. */ 2527 else 2528 do_segments = 0; 2529 2530 if (do_segments) 2531 { 2532 int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data, 2533 offs, num_segments, segments); 2534 2535 if (ret == 0 && !do_sections) 2536 error (_("Can not handle qOffsets TextSeg response with this symbol file")); 2537 2538 if (ret > 0) 2539 do_sections = 0; 2540 } 2541 2542 if (data) 2543 free_symfile_segment_data (data); 2544 2545 if (do_sections) 2546 { 2547 offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr; 2548 2549 /* This is a temporary kludge to force data and bss to use the same offsets 2550 because that's what nlmconv does now. The real solution requires changes 2551 to the stub and remote.c that I don't have time to do right now. */ 2552 2553 offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr; 2554 offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr; 2555 } 2556 2557 objfile_relocate (symfile_objfile, offs); 2558 } 2559 2560 /* Callback for iterate_over_threads. Set the STOP_REQUESTED flags in 2561 threads we know are stopped already. This is used during the 2562 initial remote connection in non-stop mode --- threads that are 2563 reported as already being stopped are left stopped. */ 2564 2565 static int 2566 set_stop_requested_callback (struct thread_info *thread, void *data) 2567 { 2568 /* If we have a stop reply for this thread, it must be stopped. */ 2569 if (peek_stop_reply (thread->ptid)) 2570 set_stop_requested (thread->ptid, 1); 2571 2572 return 0; 2573 } 2574 2575 /* Stub for catch_exception. */ 2576 2577 struct start_remote_args 2578 { 2579 int from_tty; 2580 2581 /* The current target. */ 2582 struct target_ops *target; 2583 2584 /* Non-zero if this is an extended-remote target. */ 2585 int extended_p; 2586 }; 2587 2588 static void 2589 remote_start_remote (struct ui_out *uiout, void *opaque) 2590 { 2591 struct start_remote_args *args = opaque; 2592 struct remote_state *rs = get_remote_state (); 2593 struct packet_config *noack_config; 2594 char *wait_status = NULL; 2595 2596 immediate_quit++; /* Allow user to interrupt it. */ 2597 2598 /* Ack any packet which the remote side has already sent. */ 2599 serial_write (remote_desc, "+", 1); 2600 2601 /* The first packet we send to the target is the optional "supported 2602 packets" request. If the target can answer this, it will tell us 2603 which later probes to skip. */ 2604 remote_query_supported (); 2605 2606 /* Next, we possibly activate noack mode. 2607 2608 If the QStartNoAckMode packet configuration is set to AUTO, 2609 enable noack mode if the stub reported a wish for it with 2610 qSupported. 2611 2612 If set to TRUE, then enable noack mode even if the stub didn't 2613 report it in qSupported. If the stub doesn't reply OK, the 2614 session ends with an error. 2615 2616 If FALSE, then don't activate noack mode, regardless of what the 2617 stub claimed should be the default with qSupported. */ 2618 2619 noack_config = &remote_protocol_packets[PACKET_QStartNoAckMode]; 2620 2621 if (noack_config->detect == AUTO_BOOLEAN_TRUE 2622 || (noack_config->detect == AUTO_BOOLEAN_AUTO 2623 && noack_config->support == PACKET_ENABLE)) 2624 { 2625 putpkt ("QStartNoAckMode"); 2626 getpkt (&rs->buf, &rs->buf_size, 0); 2627 if (packet_ok (rs->buf, noack_config) == PACKET_OK) 2628 rs->noack_mode = 1; 2629 } 2630 2631 if (args->extended_p) 2632 { 2633 /* Tell the remote that we are using the extended protocol. */ 2634 putpkt ("!"); 2635 getpkt (&rs->buf, &rs->buf_size, 0); 2636 } 2637 2638 /* Next, if the target can specify a description, read it. We do 2639 this before anything involving memory or registers. */ 2640 target_find_description (); 2641 2642 /* On OSs where the list of libraries is global to all 2643 processes, we fetch them early. */ 2644 if (gdbarch_has_global_solist (target_gdbarch)) 2645 solib_add (NULL, args->from_tty, args->target, auto_solib_add); 2646 2647 if (non_stop) 2648 { 2649 if (!rs->non_stop_aware) 2650 error (_("Non-stop mode requested, but remote does not support non-stop")); 2651 2652 putpkt ("QNonStop:1"); 2653 getpkt (&rs->buf, &rs->buf_size, 0); 2654 2655 if (strcmp (rs->buf, "OK") != 0) 2656 error ("Remote refused setting non-stop mode with: %s", rs->buf); 2657 2658 /* Find about threads and processes the stub is already 2659 controlling. We default to adding them in the running state. 2660 The '?' query below will then tell us about which threads are 2661 stopped. */ 2662 remote_threads_info (args->target); 2663 } 2664 else if (rs->non_stop_aware) 2665 { 2666 /* Don't assume that the stub can operate in all-stop mode. 2667 Request it explicitely. */ 2668 putpkt ("QNonStop:0"); 2669 getpkt (&rs->buf, &rs->buf_size, 0); 2670 2671 if (strcmp (rs->buf, "OK") != 0) 2672 error ("Remote refused setting all-stop mode with: %s", rs->buf); 2673 } 2674 2675 /* Check whether the target is running now. */ 2676 putpkt ("?"); 2677 getpkt (&rs->buf, &rs->buf_size, 0); 2678 2679 if (!non_stop) 2680 { 2681 if (rs->buf[0] == 'W' || rs->buf[0] == 'X') 2682 { 2683 if (!args->extended_p) 2684 error (_("The target is not running (try extended-remote?)")); 2685 2686 /* We're connected, but not running. Drop out before we 2687 call start_remote. */ 2688 return; 2689 } 2690 else 2691 { 2692 /* Save the reply for later. */ 2693 wait_status = alloca (strlen (rs->buf) + 1); 2694 strcpy (wait_status, rs->buf); 2695 } 2696 2697 /* Let the stub know that we want it to return the thread. */ 2698 set_continue_thread (minus_one_ptid); 2699 2700 /* Without this, some commands which require an active target 2701 (such as kill) won't work. This variable serves (at least) 2702 double duty as both the pid of the target process (if it has 2703 such), and as a flag indicating that a target is active. 2704 These functions should be split out into seperate variables, 2705 especially since GDB will someday have a notion of debugging 2706 several processes. */ 2707 inferior_ptid = magic_null_ptid; 2708 2709 /* Now, if we have thread information, update inferior_ptid. */ 2710 inferior_ptid = remote_current_thread (inferior_ptid); 2711 2712 remote_add_inferior (ptid_get_pid (inferior_ptid), -1); 2713 2714 /* Always add the main thread. */ 2715 add_thread_silent (inferior_ptid); 2716 2717 get_offsets (); /* Get text, data & bss offsets. */ 2718 2719 /* If we could not find a description using qXfer, and we know 2720 how to do it some other way, try again. This is not 2721 supported for non-stop; it could be, but it is tricky if 2722 there are no stopped threads when we connect. */ 2723 if (remote_read_description_p (args->target) 2724 && gdbarch_target_desc (target_gdbarch) == NULL) 2725 { 2726 target_clear_description (); 2727 target_find_description (); 2728 } 2729 2730 /* Use the previously fetched status. */ 2731 gdb_assert (wait_status != NULL); 2732 strcpy (rs->buf, wait_status); 2733 rs->cached_wait_status = 1; 2734 2735 immediate_quit--; 2736 start_remote (args->from_tty); /* Initialize gdb process mechanisms. */ 2737 } 2738 else 2739 { 2740 /* Clear WFI global state. Do this before finding about new 2741 threads and inferiors, and setting the current inferior. 2742 Otherwise we would clear the proceed status of the current 2743 inferior when we want its stop_soon state to be preserved 2744 (see notice_new_inferior). */ 2745 init_wait_for_inferior (); 2746 2747 /* In non-stop, we will either get an "OK", meaning that there 2748 are no stopped threads at this time; or, a regular stop 2749 reply. In the latter case, there may be more than one thread 2750 stopped --- we pull them all out using the vStopped 2751 mechanism. */ 2752 if (strcmp (rs->buf, "OK") != 0) 2753 { 2754 struct stop_reply *stop_reply; 2755 struct cleanup *old_chain; 2756 2757 stop_reply = stop_reply_xmalloc (); 2758 old_chain = make_cleanup (do_stop_reply_xfree, stop_reply); 2759 2760 remote_parse_stop_reply (rs->buf, stop_reply); 2761 discard_cleanups (old_chain); 2762 2763 /* get_pending_stop_replies acks this one, and gets the rest 2764 out. */ 2765 pending_stop_reply = stop_reply; 2766 remote_get_pending_stop_replies (); 2767 2768 /* Make sure that threads that were stopped remain 2769 stopped. */ 2770 iterate_over_threads (set_stop_requested_callback, NULL); 2771 } 2772 2773 if (target_can_async_p ()) 2774 target_async (inferior_event_handler, 0); 2775 2776 if (thread_count () == 0) 2777 { 2778 if (!args->extended_p) 2779 error (_("The target is not running (try extended-remote?)")); 2780 2781 /* We're connected, but not running. Drop out before we 2782 call start_remote. */ 2783 return; 2784 } 2785 2786 /* Let the stub know that we want it to return the thread. */ 2787 2788 /* Force the stub to choose a thread. */ 2789 set_general_thread (null_ptid); 2790 2791 /* Query it. */ 2792 inferior_ptid = remote_current_thread (minus_one_ptid); 2793 if (ptid_equal (inferior_ptid, minus_one_ptid)) 2794 error (_("remote didn't report the current thread in non-stop mode")); 2795 2796 get_offsets (); /* Get text, data & bss offsets. */ 2797 2798 /* In non-stop mode, any cached wait status will be stored in 2799 the stop reply queue. */ 2800 gdb_assert (wait_status == NULL); 2801 } 2802 2803 /* If we connected to a live target, do some additional setup. */ 2804 if (target_has_execution) 2805 { 2806 if (exec_bfd) /* No use without an exec file. */ 2807 remote_check_symbols (symfile_objfile); 2808 } 2809 2810 /* If breakpoints are global, insert them now. */ 2811 if (gdbarch_has_global_breakpoints (target_gdbarch) 2812 && breakpoints_always_inserted_mode ()) 2813 insert_breakpoints (); 2814 } 2815 2816 /* Open a connection to a remote debugger. 2817 NAME is the filename used for communication. */ 2818 2819 static void 2820 remote_open (char *name, int from_tty) 2821 { 2822 remote_open_1 (name, from_tty, &remote_ops, 0); 2823 } 2824 2825 /* Open a connection to a remote debugger using the extended 2826 remote gdb protocol. NAME is the filename used for communication. */ 2827 2828 static void 2829 extended_remote_open (char *name, int from_tty) 2830 { 2831 remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */); 2832 } 2833 2834 /* Generic code for opening a connection to a remote target. */ 2835 2836 static void 2837 init_all_packet_configs (void) 2838 { 2839 int i; 2840 for (i = 0; i < PACKET_MAX; i++) 2841 update_packet_config (&remote_protocol_packets[i]); 2842 } 2843 2844 /* Symbol look-up. */ 2845 2846 static void 2847 remote_check_symbols (struct objfile *objfile) 2848 { 2849 struct remote_state *rs = get_remote_state (); 2850 char *msg, *reply, *tmp; 2851 struct minimal_symbol *sym; 2852 int end; 2853 2854 if (remote_protocol_packets[PACKET_qSymbol].support == PACKET_DISABLE) 2855 return; 2856 2857 /* Make sure the remote is pointing at the right process. */ 2858 set_general_process (); 2859 2860 /* Allocate a message buffer. We can't reuse the input buffer in RS, 2861 because we need both at the same time. */ 2862 msg = alloca (get_remote_packet_size ()); 2863 2864 /* Invite target to request symbol lookups. */ 2865 2866 putpkt ("qSymbol::"); 2867 getpkt (&rs->buf, &rs->buf_size, 0); 2868 packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSymbol]); 2869 reply = rs->buf; 2870 2871 while (strncmp (reply, "qSymbol:", 8) == 0) 2872 { 2873 tmp = &reply[8]; 2874 end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2); 2875 msg[end] = '\0'; 2876 sym = lookup_minimal_symbol (msg, NULL, NULL); 2877 if (sym == NULL) 2878 xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]); 2879 else 2880 { 2881 int addr_size = gdbarch_addr_bit (target_gdbarch) / 8; 2882 CORE_ADDR sym_addr = SYMBOL_VALUE_ADDRESS (sym); 2883 2884 /* If this is a function address, return the start of code 2885 instead of any data function descriptor. */ 2886 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch, 2887 sym_addr, 2888 ¤t_target); 2889 2890 xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s", 2891 phex_nz (sym_addr, addr_size), &reply[8]); 2892 } 2893 2894 putpkt (msg); 2895 getpkt (&rs->buf, &rs->buf_size, 0); 2896 reply = rs->buf; 2897 } 2898 } 2899 2900 static struct serial * 2901 remote_serial_open (char *name) 2902 { 2903 static int udp_warning = 0; 2904 2905 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead 2906 of in ser-tcp.c, because it is the remote protocol assuming that the 2907 serial connection is reliable and not the serial connection promising 2908 to be. */ 2909 if (!udp_warning && strncmp (name, "udp:", 4) == 0) 2910 { 2911 warning (_("\ 2912 The remote protocol may be unreliable over UDP.\n\ 2913 Some events may be lost, rendering further debugging impossible.")); 2914 udp_warning = 1; 2915 } 2916 2917 return serial_open (name); 2918 } 2919 2920 /* This type describes each known response to the qSupported 2921 packet. */ 2922 struct protocol_feature 2923 { 2924 /* The name of this protocol feature. */ 2925 const char *name; 2926 2927 /* The default for this protocol feature. */ 2928 enum packet_support default_support; 2929 2930 /* The function to call when this feature is reported, or after 2931 qSupported processing if the feature is not supported. 2932 The first argument points to this structure. The second 2933 argument indicates whether the packet requested support be 2934 enabled, disabled, or probed (or the default, if this function 2935 is being called at the end of processing and this feature was 2936 not reported). The third argument may be NULL; if not NULL, it 2937 is a NUL-terminated string taken from the packet following 2938 this feature's name and an equals sign. */ 2939 void (*func) (const struct protocol_feature *, enum packet_support, 2940 const char *); 2941 2942 /* The corresponding packet for this feature. Only used if 2943 FUNC is remote_supported_packet. */ 2944 int packet; 2945 }; 2946 2947 static void 2948 remote_supported_packet (const struct protocol_feature *feature, 2949 enum packet_support support, 2950 const char *argument) 2951 { 2952 if (argument) 2953 { 2954 warning (_("Remote qSupported response supplied an unexpected value for" 2955 " \"%s\"."), feature->name); 2956 return; 2957 } 2958 2959 if (remote_protocol_packets[feature->packet].support 2960 == PACKET_SUPPORT_UNKNOWN) 2961 remote_protocol_packets[feature->packet].support = support; 2962 } 2963 2964 static void 2965 remote_packet_size (const struct protocol_feature *feature, 2966 enum packet_support support, const char *value) 2967 { 2968 struct remote_state *rs = get_remote_state (); 2969 2970 int packet_size; 2971 char *value_end; 2972 2973 if (support != PACKET_ENABLE) 2974 return; 2975 2976 if (value == NULL || *value == '\0') 2977 { 2978 warning (_("Remote target reported \"%s\" without a size."), 2979 feature->name); 2980 return; 2981 } 2982 2983 errno = 0; 2984 packet_size = strtol (value, &value_end, 16); 2985 if (errno != 0 || *value_end != '\0' || packet_size < 0) 2986 { 2987 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."), 2988 feature->name, value); 2989 return; 2990 } 2991 2992 if (packet_size > MAX_REMOTE_PACKET_SIZE) 2993 { 2994 warning (_("limiting remote suggested packet size (%d bytes) to %d"), 2995 packet_size, MAX_REMOTE_PACKET_SIZE); 2996 packet_size = MAX_REMOTE_PACKET_SIZE; 2997 } 2998 2999 /* Record the new maximum packet size. */ 3000 rs->explicit_packet_size = packet_size; 3001 } 3002 3003 static void 3004 remote_multi_process_feature (const struct protocol_feature *feature, 3005 enum packet_support support, const char *value) 3006 { 3007 struct remote_state *rs = get_remote_state (); 3008 rs->multi_process_aware = (support == PACKET_ENABLE); 3009 } 3010 3011 static void 3012 remote_non_stop_feature (const struct protocol_feature *feature, 3013 enum packet_support support, const char *value) 3014 { 3015 struct remote_state *rs = get_remote_state (); 3016 rs->non_stop_aware = (support == PACKET_ENABLE); 3017 } 3018 3019 static void 3020 remote_cond_tracepoint_feature (const struct protocol_feature *feature, 3021 enum packet_support support, 3022 const char *value) 3023 { 3024 struct remote_state *rs = get_remote_state (); 3025 rs->cond_tracepoints = (support == PACKET_ENABLE); 3026 } 3027 3028 static struct protocol_feature remote_protocol_features[] = { 3029 { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 }, 3030 { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet, 3031 PACKET_qXfer_auxv }, 3032 { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet, 3033 PACKET_qXfer_features }, 3034 { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet, 3035 PACKET_qXfer_libraries }, 3036 { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet, 3037 PACKET_qXfer_memory_map }, 3038 { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet, 3039 PACKET_qXfer_spu_read }, 3040 { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet, 3041 PACKET_qXfer_spu_write }, 3042 { "qXfer:osdata:read", PACKET_DISABLE, remote_supported_packet, 3043 PACKET_qXfer_osdata }, 3044 { "QPassSignals", PACKET_DISABLE, remote_supported_packet, 3045 PACKET_QPassSignals }, 3046 { "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet, 3047 PACKET_QStartNoAckMode }, 3048 { "multiprocess", PACKET_DISABLE, remote_multi_process_feature, -1 }, 3049 { "QNonStop", PACKET_DISABLE, remote_non_stop_feature, -1 }, 3050 { "qXfer:siginfo:read", PACKET_DISABLE, remote_supported_packet, 3051 PACKET_qXfer_siginfo_read }, 3052 { "qXfer:siginfo:write", PACKET_DISABLE, remote_supported_packet, 3053 PACKET_qXfer_siginfo_write }, 3054 { "ConditionalTracepoints", PACKET_DISABLE, remote_cond_tracepoint_feature, 3055 PACKET_ConditionalTracepoints }, 3056 { "ReverseContinue", PACKET_DISABLE, remote_supported_packet, 3057 PACKET_bc }, 3058 { "ReverseStep", PACKET_DISABLE, remote_supported_packet, 3059 PACKET_bs }, 3060 }; 3061 3062 static void 3063 remote_query_supported (void) 3064 { 3065 struct remote_state *rs = get_remote_state (); 3066 char *next; 3067 int i; 3068 unsigned char seen [ARRAY_SIZE (remote_protocol_features)]; 3069 3070 /* The packet support flags are handled differently for this packet 3071 than for most others. We treat an error, a disabled packet, and 3072 an empty response identically: any features which must be reported 3073 to be used will be automatically disabled. An empty buffer 3074 accomplishes this, since that is also the representation for a list 3075 containing no features. */ 3076 3077 rs->buf[0] = 0; 3078 if (remote_protocol_packets[PACKET_qSupported].support != PACKET_DISABLE) 3079 { 3080 if (rs->extended) 3081 putpkt ("qSupported:multiprocess+"); 3082 else 3083 putpkt ("qSupported"); 3084 3085 getpkt (&rs->buf, &rs->buf_size, 0); 3086 3087 /* If an error occured, warn, but do not return - just reset the 3088 buffer to empty and go on to disable features. */ 3089 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported]) 3090 == PACKET_ERROR) 3091 { 3092 warning (_("Remote failure reply: %s"), rs->buf); 3093 rs->buf[0] = 0; 3094 } 3095 } 3096 3097 memset (seen, 0, sizeof (seen)); 3098 3099 next = rs->buf; 3100 while (*next) 3101 { 3102 enum packet_support is_supported; 3103 char *p, *end, *name_end, *value; 3104 3105 /* First separate out this item from the rest of the packet. If 3106 there's another item after this, we overwrite the separator 3107 (terminated strings are much easier to work with). */ 3108 p = next; 3109 end = strchr (p, ';'); 3110 if (end == NULL) 3111 { 3112 end = p + strlen (p); 3113 next = end; 3114 } 3115 else 3116 { 3117 *end = '\0'; 3118 next = end + 1; 3119 3120 if (end == p) 3121 { 3122 warning (_("empty item in \"qSupported\" response")); 3123 continue; 3124 } 3125 } 3126 3127 name_end = strchr (p, '='); 3128 if (name_end) 3129 { 3130 /* This is a name=value entry. */ 3131 is_supported = PACKET_ENABLE; 3132 value = name_end + 1; 3133 *name_end = '\0'; 3134 } 3135 else 3136 { 3137 value = NULL; 3138 switch (end[-1]) 3139 { 3140 case '+': 3141 is_supported = PACKET_ENABLE; 3142 break; 3143 3144 case '-': 3145 is_supported = PACKET_DISABLE; 3146 break; 3147 3148 case '?': 3149 is_supported = PACKET_SUPPORT_UNKNOWN; 3150 break; 3151 3152 default: 3153 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p); 3154 continue; 3155 } 3156 end[-1] = '\0'; 3157 } 3158 3159 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++) 3160 if (strcmp (remote_protocol_features[i].name, p) == 0) 3161 { 3162 const struct protocol_feature *feature; 3163 3164 seen[i] = 1; 3165 feature = &remote_protocol_features[i]; 3166 feature->func (feature, is_supported, value); 3167 break; 3168 } 3169 } 3170 3171 /* If we increased the packet size, make sure to increase the global 3172 buffer size also. We delay this until after parsing the entire 3173 qSupported packet, because this is the same buffer we were 3174 parsing. */ 3175 if (rs->buf_size < rs->explicit_packet_size) 3176 { 3177 rs->buf_size = rs->explicit_packet_size; 3178 rs->buf = xrealloc (rs->buf, rs->buf_size); 3179 } 3180 3181 /* Handle the defaults for unmentioned features. */ 3182 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++) 3183 if (!seen[i]) 3184 { 3185 const struct protocol_feature *feature; 3186 3187 feature = &remote_protocol_features[i]; 3188 feature->func (feature, feature->default_support, NULL); 3189 } 3190 } 3191 3192 3193 static void 3194 remote_open_1 (char *name, int from_tty, struct target_ops *target, int extended_p) 3195 { 3196 struct remote_state *rs = get_remote_state (); 3197 3198 if (name == 0) 3199 error (_("To open a remote debug connection, you need to specify what\n" 3200 "serial device is attached to the remote system\n" 3201 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).")); 3202 3203 /* See FIXME above. */ 3204 if (!target_async_permitted) 3205 wait_forever_enabled_p = 1; 3206 3207 /* If we're connected to a running target, target_preopen will kill it. 3208 But if we're connected to a target system with no running process, 3209 then we will still be connected when it returns. Ask this question 3210 first, before target_preopen has a chance to kill anything. */ 3211 if (remote_desc != NULL && !have_inferiors ()) 3212 { 3213 if (!from_tty 3214 || query (_("Already connected to a remote target. Disconnect? "))) 3215 pop_target (); 3216 else 3217 error (_("Still connected.")); 3218 } 3219 3220 target_preopen (from_tty); 3221 3222 unpush_target (target); 3223 3224 /* This time without a query. If we were connected to an 3225 extended-remote target and target_preopen killed the running 3226 process, we may still be connected. If we are starting "target 3227 remote" now, the extended-remote target will not have been 3228 removed by unpush_target. */ 3229 if (remote_desc != NULL && !have_inferiors ()) 3230 pop_target (); 3231 3232 /* Make sure we send the passed signals list the next time we resume. */ 3233 xfree (last_pass_packet); 3234 last_pass_packet = NULL; 3235 3236 remote_fileio_reset (); 3237 reopen_exec_file (); 3238 reread_symbols (); 3239 3240 remote_desc = remote_serial_open (name); 3241 if (!remote_desc) 3242 perror_with_name (name); 3243 3244 if (baud_rate != -1) 3245 { 3246 if (serial_setbaudrate (remote_desc, baud_rate)) 3247 { 3248 /* The requested speed could not be set. Error out to 3249 top level after closing remote_desc. Take care to 3250 set remote_desc to NULL to avoid closing remote_desc 3251 more than once. */ 3252 serial_close (remote_desc); 3253 remote_desc = NULL; 3254 perror_with_name (name); 3255 } 3256 } 3257 3258 serial_raw (remote_desc); 3259 3260 /* If there is something sitting in the buffer we might take it as a 3261 response to a command, which would be bad. */ 3262 serial_flush_input (remote_desc); 3263 3264 if (from_tty) 3265 { 3266 puts_filtered ("Remote debugging using "); 3267 puts_filtered (name); 3268 puts_filtered ("\n"); 3269 } 3270 push_target (target); /* Switch to using remote target now. */ 3271 3272 /* Register extra event sources in the event loop. */ 3273 remote_async_inferior_event_token 3274 = create_async_event_handler (remote_async_inferior_event_handler, 3275 NULL); 3276 remote_async_get_pending_events_token 3277 = create_async_event_handler (remote_async_get_pending_events_handler, 3278 NULL); 3279 3280 /* Reset the target state; these things will be queried either by 3281 remote_query_supported or as they are needed. */ 3282 init_all_packet_configs (); 3283 rs->cached_wait_status = 0; 3284 rs->explicit_packet_size = 0; 3285 rs->noack_mode = 0; 3286 rs->multi_process_aware = 0; 3287 rs->extended = extended_p; 3288 rs->non_stop_aware = 0; 3289 rs->waiting_for_stop_reply = 0; 3290 3291 general_thread = not_sent_ptid; 3292 continue_thread = not_sent_ptid; 3293 3294 /* Probe for ability to use "ThreadInfo" query, as required. */ 3295 use_threadinfo_query = 1; 3296 use_threadextra_query = 1; 3297 3298 if (target_async_permitted) 3299 { 3300 /* With this target we start out by owning the terminal. */ 3301 remote_async_terminal_ours_p = 1; 3302 3303 /* FIXME: cagney/1999-09-23: During the initial connection it is 3304 assumed that the target is already ready and able to respond to 3305 requests. Unfortunately remote_start_remote() eventually calls 3306 wait_for_inferior() with no timeout. wait_forever_enabled_p gets 3307 around this. Eventually a mechanism that allows 3308 wait_for_inferior() to expect/get timeouts will be 3309 implemented. */ 3310 wait_forever_enabled_p = 0; 3311 } 3312 3313 /* First delete any symbols previously loaded from shared libraries. */ 3314 no_shared_libraries (NULL, 0); 3315 3316 /* Start afresh. */ 3317 init_thread_list (); 3318 3319 /* Start the remote connection. If error() or QUIT, discard this 3320 target (we'd otherwise be in an inconsistent state) and then 3321 propogate the error on up the exception chain. This ensures that 3322 the caller doesn't stumble along blindly assuming that the 3323 function succeeded. The CLI doesn't have this problem but other 3324 UI's, such as MI do. 3325 3326 FIXME: cagney/2002-05-19: Instead of re-throwing the exception, 3327 this function should return an error indication letting the 3328 caller restore the previous state. Unfortunately the command 3329 ``target remote'' is directly wired to this function making that 3330 impossible. On a positive note, the CLI side of this problem has 3331 been fixed - the function set_cmd_context() makes it possible for 3332 all the ``target ....'' commands to share a common callback 3333 function. See cli-dump.c. */ 3334 { 3335 struct gdb_exception ex; 3336 struct start_remote_args args; 3337 3338 args.from_tty = from_tty; 3339 args.target = target; 3340 args.extended_p = extended_p; 3341 3342 ex = catch_exception (uiout, remote_start_remote, &args, RETURN_MASK_ALL); 3343 if (ex.reason < 0) 3344 { 3345 /* Pop the partially set up target - unless something else did 3346 already before throwing the exception. */ 3347 if (remote_desc != NULL) 3348 pop_target (); 3349 if (target_async_permitted) 3350 wait_forever_enabled_p = 1; 3351 throw_exception (ex); 3352 } 3353 } 3354 3355 if (target_async_permitted) 3356 wait_forever_enabled_p = 1; 3357 } 3358 3359 /* This takes a program previously attached to and detaches it. After 3360 this is done, GDB can be used to debug some other program. We 3361 better not have left any breakpoints in the target program or it'll 3362 die when it hits one. */ 3363 3364 static void 3365 remote_detach_1 (char *args, int from_tty, int extended) 3366 { 3367 int pid = ptid_get_pid (inferior_ptid); 3368 struct remote_state *rs = get_remote_state (); 3369 3370 if (args) 3371 error (_("Argument given to \"detach\" when remotely debugging.")); 3372 3373 if (!target_has_execution) 3374 error (_("No process to detach from.")); 3375 3376 /* Tell the remote target to detach. */ 3377 if (remote_multi_process_p (rs)) 3378 sprintf (rs->buf, "D;%x", pid); 3379 else 3380 strcpy (rs->buf, "D"); 3381 3382 putpkt (rs->buf); 3383 getpkt (&rs->buf, &rs->buf_size, 0); 3384 3385 if (rs->buf[0] == 'O' && rs->buf[1] == 'K') 3386 ; 3387 else if (rs->buf[0] == '\0') 3388 error (_("Remote doesn't know how to detach")); 3389 else 3390 error (_("Can't detach process.")); 3391 3392 if (from_tty) 3393 { 3394 if (remote_multi_process_p (rs)) 3395 printf_filtered (_("Detached from remote %s.\n"), 3396 target_pid_to_str (pid_to_ptid (pid))); 3397 else 3398 { 3399 if (extended) 3400 puts_filtered (_("Detached from remote process.\n")); 3401 else 3402 puts_filtered (_("Ending remote debugging.\n")); 3403 } 3404 } 3405 3406 discard_pending_stop_replies (pid); 3407 target_mourn_inferior (); 3408 } 3409 3410 static void 3411 remote_detach (struct target_ops *ops, char *args, int from_tty) 3412 { 3413 remote_detach_1 (args, from_tty, 0); 3414 } 3415 3416 static void 3417 extended_remote_detach (struct target_ops *ops, char *args, int from_tty) 3418 { 3419 remote_detach_1 (args, from_tty, 1); 3420 } 3421 3422 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */ 3423 3424 static void 3425 remote_disconnect (struct target_ops *target, char *args, int from_tty) 3426 { 3427 if (args) 3428 error (_("Argument given to \"disconnect\" when remotely debugging.")); 3429 3430 /* Make sure we unpush even the extended remote targets; mourn 3431 won't do it. So call remote_mourn_1 directly instead of 3432 target_mourn_inferior. */ 3433 remote_mourn_1 (target); 3434 3435 if (from_tty) 3436 puts_filtered ("Ending remote debugging.\n"); 3437 } 3438 3439 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero, 3440 be chatty about it. */ 3441 3442 static void 3443 extended_remote_attach_1 (struct target_ops *target, char *args, int from_tty) 3444 { 3445 struct remote_state *rs = get_remote_state (); 3446 int pid; 3447 char *dummy; 3448 char *wait_status = NULL; 3449 3450 if (!args) 3451 error_no_arg (_("process-id to attach")); 3452 3453 dummy = args; 3454 pid = strtol (args, &dummy, 0); 3455 /* Some targets don't set errno on errors, grrr! */ 3456 if (pid == 0 && args == dummy) 3457 error (_("Illegal process-id: %s."), args); 3458 3459 if (remote_protocol_packets[PACKET_vAttach].support == PACKET_DISABLE) 3460 error (_("This target does not support attaching to a process")); 3461 3462 sprintf (rs->buf, "vAttach;%x", pid); 3463 putpkt (rs->buf); 3464 getpkt (&rs->buf, &rs->buf_size, 0); 3465 3466 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vAttach]) == PACKET_OK) 3467 { 3468 if (from_tty) 3469 printf_unfiltered (_("Attached to %s\n"), 3470 target_pid_to_str (pid_to_ptid (pid))); 3471 3472 if (!non_stop) 3473 { 3474 /* Save the reply for later. */ 3475 wait_status = alloca (strlen (rs->buf) + 1); 3476 strcpy (wait_status, rs->buf); 3477 } 3478 else if (strcmp (rs->buf, "OK") != 0) 3479 error (_("Attaching to %s failed with: %s"), 3480 target_pid_to_str (pid_to_ptid (pid)), 3481 rs->buf); 3482 } 3483 else if (remote_protocol_packets[PACKET_vAttach].support == PACKET_DISABLE) 3484 error (_("This target does not support attaching to a process")); 3485 else 3486 error (_("Attaching to %s failed"), 3487 target_pid_to_str (pid_to_ptid (pid))); 3488 3489 remote_add_inferior (pid, 1); 3490 3491 inferior_ptid = pid_to_ptid (pid); 3492 3493 if (non_stop) 3494 { 3495 struct thread_info *thread; 3496 3497 /* Get list of threads. */ 3498 remote_threads_info (target); 3499 3500 thread = first_thread_of_process (pid); 3501 if (thread) 3502 inferior_ptid = thread->ptid; 3503 else 3504 inferior_ptid = pid_to_ptid (pid); 3505 3506 /* Invalidate our notion of the remote current thread. */ 3507 record_currthread (minus_one_ptid); 3508 } 3509 else 3510 { 3511 /* Now, if we have thread information, update inferior_ptid. */ 3512 inferior_ptid = remote_current_thread (inferior_ptid); 3513 3514 /* Add the main thread to the thread list. */ 3515 add_thread_silent (inferior_ptid); 3516 } 3517 3518 /* Next, if the target can specify a description, read it. We do 3519 this before anything involving memory or registers. */ 3520 target_find_description (); 3521 3522 if (!non_stop) 3523 { 3524 /* Use the previously fetched status. */ 3525 gdb_assert (wait_status != NULL); 3526 3527 if (target_can_async_p ()) 3528 { 3529 struct stop_reply *stop_reply; 3530 struct cleanup *old_chain; 3531 3532 stop_reply = stop_reply_xmalloc (); 3533 old_chain = make_cleanup (do_stop_reply_xfree, stop_reply); 3534 remote_parse_stop_reply (wait_status, stop_reply); 3535 discard_cleanups (old_chain); 3536 push_stop_reply (stop_reply); 3537 3538 target_async (inferior_event_handler, 0); 3539 } 3540 else 3541 { 3542 gdb_assert (wait_status != NULL); 3543 strcpy (rs->buf, wait_status); 3544 rs->cached_wait_status = 1; 3545 } 3546 } 3547 else 3548 gdb_assert (wait_status == NULL); 3549 } 3550 3551 static void 3552 extended_remote_attach (struct target_ops *ops, char *args, int from_tty) 3553 { 3554 extended_remote_attach_1 (ops, args, from_tty); 3555 } 3556 3557 /* Convert hex digit A to a number. */ 3558 3559 static int 3560 fromhex (int a) 3561 { 3562 if (a >= '0' && a <= '9') 3563 return a - '0'; 3564 else if (a >= 'a' && a <= 'f') 3565 return a - 'a' + 10; 3566 else if (a >= 'A' && a <= 'F') 3567 return a - 'A' + 10; 3568 else 3569 error (_("Reply contains invalid hex digit %d"), a); 3570 } 3571 3572 static int 3573 hex2bin (const char *hex, gdb_byte *bin, int count) 3574 { 3575 int i; 3576 3577 for (i = 0; i < count; i++) 3578 { 3579 if (hex[0] == 0 || hex[1] == 0) 3580 { 3581 /* Hex string is short, or of uneven length. 3582 Return the count that has been converted so far. */ 3583 return i; 3584 } 3585 *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]); 3586 hex += 2; 3587 } 3588 return i; 3589 } 3590 3591 /* Convert number NIB to a hex digit. */ 3592 3593 static int 3594 tohex (int nib) 3595 { 3596 if (nib < 10) 3597 return '0' + nib; 3598 else 3599 return 'a' + nib - 10; 3600 } 3601 3602 static int 3603 bin2hex (const gdb_byte *bin, char *hex, int count) 3604 { 3605 int i; 3606 /* May use a length, or a nul-terminated string as input. */ 3607 if (count == 0) 3608 count = strlen ((char *) bin); 3609 3610 for (i = 0; i < count; i++) 3611 { 3612 *hex++ = tohex ((*bin >> 4) & 0xf); 3613 *hex++ = tohex (*bin++ & 0xf); 3614 } 3615 *hex = 0; 3616 return i; 3617 } 3618 3619 /* Check for the availability of vCont. This function should also check 3620 the response. */ 3621 3622 static void 3623 remote_vcont_probe (struct remote_state *rs) 3624 { 3625 char *buf; 3626 3627 strcpy (rs->buf, "vCont?"); 3628 putpkt (rs->buf); 3629 getpkt (&rs->buf, &rs->buf_size, 0); 3630 buf = rs->buf; 3631 3632 /* Make sure that the features we assume are supported. */ 3633 if (strncmp (buf, "vCont", 5) == 0) 3634 { 3635 char *p = &buf[5]; 3636 int support_s, support_S, support_c, support_C; 3637 3638 support_s = 0; 3639 support_S = 0; 3640 support_c = 0; 3641 support_C = 0; 3642 rs->support_vCont_t = 0; 3643 while (p && *p == ';') 3644 { 3645 p++; 3646 if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0)) 3647 support_s = 1; 3648 else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0)) 3649 support_S = 1; 3650 else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0)) 3651 support_c = 1; 3652 else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0)) 3653 support_C = 1; 3654 else if (*p == 't' && (*(p + 1) == ';' || *(p + 1) == 0)) 3655 rs->support_vCont_t = 1; 3656 3657 p = strchr (p, ';'); 3658 } 3659 3660 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing 3661 BUF will make packet_ok disable the packet. */ 3662 if (!support_s || !support_S || !support_c || !support_C) 3663 buf[0] = 0; 3664 } 3665 3666 packet_ok (buf, &remote_protocol_packets[PACKET_vCont]); 3667 } 3668 3669 /* Helper function for building "vCont" resumptions. Write a 3670 resumption to P. ENDP points to one-passed-the-end of the buffer 3671 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The 3672 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the 3673 resumed thread should be single-stepped and/or signalled. If PTID 3674 equals minus_one_ptid, then all threads are resumed; if PTID 3675 represents a process, then all threads of the process are resumed; 3676 the thread to be stepped and/or signalled is given in the global 3677 INFERIOR_PTID. */ 3678 3679 static char * 3680 append_resumption (char *p, char *endp, 3681 ptid_t ptid, int step, enum target_signal siggnal) 3682 { 3683 struct remote_state *rs = get_remote_state (); 3684 3685 if (step && siggnal != TARGET_SIGNAL_0) 3686 p += xsnprintf (p, endp - p, ";S%02x", siggnal); 3687 else if (step) 3688 p += xsnprintf (p, endp - p, ";s"); 3689 else if (siggnal != TARGET_SIGNAL_0) 3690 p += xsnprintf (p, endp - p, ";C%02x", siggnal); 3691 else 3692 p += xsnprintf (p, endp - p, ";c"); 3693 3694 if (remote_multi_process_p (rs) && ptid_is_pid (ptid)) 3695 { 3696 ptid_t nptid; 3697 3698 /* All (-1) threads of process. */ 3699 nptid = ptid_build (ptid_get_pid (ptid), 0, -1); 3700 3701 p += xsnprintf (p, endp - p, ":"); 3702 p = write_ptid (p, endp, nptid); 3703 } 3704 else if (!ptid_equal (ptid, minus_one_ptid)) 3705 { 3706 p += xsnprintf (p, endp - p, ":"); 3707 p = write_ptid (p, endp, ptid); 3708 } 3709 3710 return p; 3711 } 3712 3713 /* Resume the remote inferior by using a "vCont" packet. The thread 3714 to be resumed is PTID; STEP and SIGGNAL indicate whether the 3715 resumed thread should be single-stepped and/or signalled. If PTID 3716 equals minus_one_ptid, then all threads are resumed; the thread to 3717 be stepped and/or signalled is given in the global INFERIOR_PTID. 3718 This function returns non-zero iff it resumes the inferior. 3719 3720 This function issues a strict subset of all possible vCont commands at the 3721 moment. */ 3722 3723 static int 3724 remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal) 3725 { 3726 struct remote_state *rs = get_remote_state (); 3727 char *p; 3728 char *endp; 3729 3730 if (remote_protocol_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN) 3731 remote_vcont_probe (rs); 3732 3733 if (remote_protocol_packets[PACKET_vCont].support == PACKET_DISABLE) 3734 return 0; 3735 3736 p = rs->buf; 3737 endp = rs->buf + get_remote_packet_size (); 3738 3739 /* If we could generate a wider range of packets, we'd have to worry 3740 about overflowing BUF. Should there be a generic 3741 "multi-part-packet" packet? */ 3742 3743 p += xsnprintf (p, endp - p, "vCont"); 3744 3745 if (ptid_equal (ptid, magic_null_ptid)) 3746 { 3747 /* MAGIC_NULL_PTID means that we don't have any active threads, 3748 so we don't have any TID numbers the inferior will 3749 understand. Make sure to only send forms that do not specify 3750 a TID. */ 3751 p = append_resumption (p, endp, minus_one_ptid, step, siggnal); 3752 } 3753 else if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid)) 3754 { 3755 /* Resume all threads (of all processes, or of a single 3756 process), with preference for INFERIOR_PTID. This assumes 3757 inferior_ptid belongs to the set of all threads we are about 3758 to resume. */ 3759 if (step || siggnal != TARGET_SIGNAL_0) 3760 { 3761 /* Step inferior_ptid, with or without signal. */ 3762 p = append_resumption (p, endp, inferior_ptid, step, siggnal); 3763 } 3764 3765 /* And continue others without a signal. */ 3766 p = append_resumption (p, endp, ptid, /*step=*/ 0, TARGET_SIGNAL_0); 3767 } 3768 else 3769 { 3770 /* Scheduler locking; resume only PTID. */ 3771 p = append_resumption (p, endp, ptid, step, siggnal); 3772 } 3773 3774 gdb_assert (strlen (rs->buf) < get_remote_packet_size ()); 3775 putpkt (rs->buf); 3776 3777 if (non_stop) 3778 { 3779 /* In non-stop, the stub replies to vCont with "OK". The stop 3780 reply will be reported asynchronously by means of a `%Stop' 3781 notification. */ 3782 getpkt (&rs->buf, &rs->buf_size, 0); 3783 if (strcmp (rs->buf, "OK") != 0) 3784 error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf); 3785 } 3786 3787 return 1; 3788 } 3789 3790 /* Tell the remote machine to resume. */ 3791 3792 static enum target_signal last_sent_signal = TARGET_SIGNAL_0; 3793 3794 static int last_sent_step; 3795 3796 static void 3797 remote_resume (struct target_ops *ops, 3798 ptid_t ptid, int step, enum target_signal siggnal) 3799 { 3800 struct remote_state *rs = get_remote_state (); 3801 char *buf; 3802 3803 last_sent_signal = siggnal; 3804 last_sent_step = step; 3805 3806 /* Update the inferior on signals to silently pass, if they've changed. */ 3807 remote_pass_signals (); 3808 3809 /* The vCont packet doesn't need to specify threads via Hc. */ 3810 /* No reverse support (yet) for vCont. */ 3811 if (execution_direction != EXEC_REVERSE) 3812 if (remote_vcont_resume (ptid, step, siggnal)) 3813 goto done; 3814 3815 /* All other supported resume packets do use Hc, so set the continue 3816 thread. */ 3817 if (ptid_equal (ptid, minus_one_ptid)) 3818 set_continue_thread (any_thread_ptid); 3819 else 3820 set_continue_thread (ptid); 3821 3822 buf = rs->buf; 3823 if (execution_direction == EXEC_REVERSE) 3824 { 3825 /* We don't pass signals to the target in reverse exec mode. */ 3826 if (info_verbose && siggnal != TARGET_SIGNAL_0) 3827 warning (" - Can't pass signal %d to target in reverse: ignored.\n", 3828 siggnal); 3829 3830 if (step 3831 && remote_protocol_packets[PACKET_bs].support == PACKET_DISABLE) 3832 error (_("Remote reverse-step not supported.")); 3833 if (!step 3834 && remote_protocol_packets[PACKET_bc].support == PACKET_DISABLE) 3835 error (_("Remote reverse-continue not supported.")); 3836 3837 strcpy (buf, step ? "bs" : "bc"); 3838 } 3839 else if (siggnal != TARGET_SIGNAL_0) 3840 { 3841 buf[0] = step ? 'S' : 'C'; 3842 buf[1] = tohex (((int) siggnal >> 4) & 0xf); 3843 buf[2] = tohex (((int) siggnal) & 0xf); 3844 buf[3] = '\0'; 3845 } 3846 else 3847 strcpy (buf, step ? "s" : "c"); 3848 3849 putpkt (buf); 3850 3851 done: 3852 /* We are about to start executing the inferior, let's register it 3853 with the event loop. NOTE: this is the one place where all the 3854 execution commands end up. We could alternatively do this in each 3855 of the execution commands in infcmd.c. */ 3856 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here 3857 into infcmd.c in order to allow inferior function calls to work 3858 NOT asynchronously. */ 3859 if (target_can_async_p ()) 3860 target_async (inferior_event_handler, 0); 3861 3862 /* We've just told the target to resume. The remote server will 3863 wait for the inferior to stop, and then send a stop reply. In 3864 the mean time, we can't start another command/query ourselves 3865 because the stub wouldn't be ready to process it. This applies 3866 only to the base all-stop protocol, however. In non-stop (which 3867 only supports vCont), the stub replies with an "OK", and is 3868 immediate able to process further serial input. */ 3869 if (!non_stop) 3870 rs->waiting_for_stop_reply = 1; 3871 } 3872 3873 3874 /* Set up the signal handler for SIGINT, while the target is 3875 executing, ovewriting the 'regular' SIGINT signal handler. */ 3876 static void 3877 initialize_sigint_signal_handler (void) 3878 { 3879 signal (SIGINT, handle_remote_sigint); 3880 } 3881 3882 /* Signal handler for SIGINT, while the target is executing. */ 3883 static void 3884 handle_remote_sigint (int sig) 3885 { 3886 signal (sig, handle_remote_sigint_twice); 3887 mark_async_signal_handler_wrapper (sigint_remote_token); 3888 } 3889 3890 /* Signal handler for SIGINT, installed after SIGINT has already been 3891 sent once. It will take effect the second time that the user sends 3892 a ^C. */ 3893 static void 3894 handle_remote_sigint_twice (int sig) 3895 { 3896 signal (sig, handle_remote_sigint); 3897 mark_async_signal_handler_wrapper (sigint_remote_twice_token); 3898 } 3899 3900 /* Perform the real interruption of the target execution, in response 3901 to a ^C. */ 3902 static void 3903 async_remote_interrupt (gdb_client_data arg) 3904 { 3905 if (remote_debug) 3906 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n"); 3907 3908 target_stop (inferior_ptid); 3909 } 3910 3911 /* Perform interrupt, if the first attempt did not succeed. Just give 3912 up on the target alltogether. */ 3913 void 3914 async_remote_interrupt_twice (gdb_client_data arg) 3915 { 3916 if (remote_debug) 3917 fprintf_unfiltered (gdb_stdlog, "remote_interrupt_twice called\n"); 3918 3919 interrupt_query (); 3920 } 3921 3922 /* Reinstall the usual SIGINT handlers, after the target has 3923 stopped. */ 3924 static void 3925 cleanup_sigint_signal_handler (void *dummy) 3926 { 3927 signal (SIGINT, handle_sigint); 3928 } 3929 3930 /* Send ^C to target to halt it. Target will respond, and send us a 3931 packet. */ 3932 static void (*ofunc) (int); 3933 3934 /* The command line interface's stop routine. This function is installed 3935 as a signal handler for SIGINT. The first time a user requests a 3936 stop, we call remote_stop to send a break or ^C. If there is no 3937 response from the target (it didn't stop when the user requested it), 3938 we ask the user if he'd like to detach from the target. */ 3939 static void 3940 remote_interrupt (int signo) 3941 { 3942 /* If this doesn't work, try more severe steps. */ 3943 signal (signo, remote_interrupt_twice); 3944 3945 gdb_call_async_signal_handler (sigint_remote_token, 1); 3946 } 3947 3948 /* The user typed ^C twice. */ 3949 3950 static void 3951 remote_interrupt_twice (int signo) 3952 { 3953 signal (signo, ofunc); 3954 gdb_call_async_signal_handler (sigint_remote_twice_token, 1); 3955 signal (signo, remote_interrupt); 3956 } 3957 3958 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote 3959 thread, all threads of a remote process, or all threads of all 3960 processes. */ 3961 3962 static void 3963 remote_stop_ns (ptid_t ptid) 3964 { 3965 struct remote_state *rs = get_remote_state (); 3966 char *p = rs->buf; 3967 char *endp = rs->buf + get_remote_packet_size (); 3968 3969 if (remote_protocol_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN) 3970 remote_vcont_probe (rs); 3971 3972 if (!rs->support_vCont_t) 3973 error (_("Remote server does not support stopping threads")); 3974 3975 if (ptid_equal (ptid, minus_one_ptid) 3976 || (!remote_multi_process_p (rs) && ptid_is_pid (ptid))) 3977 p += xsnprintf (p, endp - p, "vCont;t"); 3978 else 3979 { 3980 ptid_t nptid; 3981 3982 p += xsnprintf (p, endp - p, "vCont;t:"); 3983 3984 if (ptid_is_pid (ptid)) 3985 /* All (-1) threads of process. */ 3986 nptid = ptid_build (ptid_get_pid (ptid), 0, -1); 3987 else 3988 { 3989 /* Small optimization: if we already have a stop reply for 3990 this thread, no use in telling the stub we want this 3991 stopped. */ 3992 if (peek_stop_reply (ptid)) 3993 return; 3994 3995 nptid = ptid; 3996 } 3997 3998 p = write_ptid (p, endp, nptid); 3999 } 4000 4001 /* In non-stop, we get an immediate OK reply. The stop reply will 4002 come in asynchronously by notification. */ 4003 putpkt (rs->buf); 4004 getpkt (&rs->buf, &rs->buf_size, 0); 4005 if (strcmp (rs->buf, "OK") != 0) 4006 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid), rs->buf); 4007 } 4008 4009 /* All-stop version of target_stop. Sends a break or a ^C to stop the 4010 remote target. It is undefined which thread of which process 4011 reports the stop. */ 4012 4013 static void 4014 remote_stop_as (ptid_t ptid) 4015 { 4016 struct remote_state *rs = get_remote_state (); 4017 4018 /* If the inferior is stopped already, but the core didn't know 4019 about it yet, just ignore the request. The cached wait status 4020 will be collected in remote_wait. */ 4021 if (rs->cached_wait_status) 4022 return; 4023 4024 /* Send a break or a ^C, depending on user preference. */ 4025 4026 if (remote_break) 4027 serial_send_break (remote_desc); 4028 else 4029 serial_write (remote_desc, "\003", 1); 4030 } 4031 4032 /* This is the generic stop called via the target vector. When a target 4033 interrupt is requested, either by the command line or the GUI, we 4034 will eventually end up here. */ 4035 4036 static void 4037 remote_stop (ptid_t ptid) 4038 { 4039 if (remote_debug) 4040 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n"); 4041 4042 if (non_stop) 4043 remote_stop_ns (ptid); 4044 else 4045 remote_stop_as (ptid); 4046 } 4047 4048 /* Ask the user what to do when an interrupt is received. */ 4049 4050 static void 4051 interrupt_query (void) 4052 { 4053 target_terminal_ours (); 4054 4055 if (target_can_async_p ()) 4056 { 4057 signal (SIGINT, handle_sigint); 4058 deprecated_throw_reason (RETURN_QUIT); 4059 } 4060 else 4061 { 4062 if (query (_("Interrupted while waiting for the program.\n\ 4063 Give up (and stop debugging it)? "))) 4064 { 4065 pop_target (); 4066 deprecated_throw_reason (RETURN_QUIT); 4067 } 4068 } 4069 4070 target_terminal_inferior (); 4071 } 4072 4073 /* Enable/disable target terminal ownership. Most targets can use 4074 terminal groups to control terminal ownership. Remote targets are 4075 different in that explicit transfer of ownership to/from GDB/target 4076 is required. */ 4077 4078 static void 4079 remote_terminal_inferior (void) 4080 { 4081 if (!target_async_permitted) 4082 /* Nothing to do. */ 4083 return; 4084 4085 /* FIXME: cagney/1999-09-27: Make calls to target_terminal_*() 4086 idempotent. The event-loop GDB talking to an asynchronous target 4087 with a synchronous command calls this function from both 4088 event-top.c and infrun.c/infcmd.c. Once GDB stops trying to 4089 transfer the terminal to the target when it shouldn't this guard 4090 can go away. */ 4091 if (!remote_async_terminal_ours_p) 4092 return; 4093 delete_file_handler (input_fd); 4094 remote_async_terminal_ours_p = 0; 4095 initialize_sigint_signal_handler (); 4096 /* NOTE: At this point we could also register our selves as the 4097 recipient of all input. Any characters typed could then be 4098 passed on down to the target. */ 4099 } 4100 4101 static void 4102 remote_terminal_ours (void) 4103 { 4104 if (!target_async_permitted) 4105 /* Nothing to do. */ 4106 return; 4107 4108 /* See FIXME in remote_terminal_inferior. */ 4109 if (remote_async_terminal_ours_p) 4110 return; 4111 cleanup_sigint_signal_handler (NULL); 4112 add_file_handler (input_fd, stdin_event_handler, 0); 4113 remote_async_terminal_ours_p = 1; 4114 } 4115 4116 void 4117 remote_console_output (char *msg) 4118 { 4119 char *p; 4120 4121 for (p = msg; p[0] && p[1]; p += 2) 4122 { 4123 char tb[2]; 4124 char c = fromhex (p[0]) * 16 + fromhex (p[1]); 4125 tb[0] = c; 4126 tb[1] = 0; 4127 fputs_unfiltered (tb, gdb_stdtarg); 4128 } 4129 gdb_flush (gdb_stdtarg); 4130 } 4131 4132 typedef struct cached_reg 4133 { 4134 int num; 4135 gdb_byte data[MAX_REGISTER_SIZE]; 4136 } cached_reg_t; 4137 4138 DEF_VEC_O(cached_reg_t); 4139 4140 struct stop_reply 4141 { 4142 struct stop_reply *next; 4143 4144 ptid_t ptid; 4145 4146 struct target_waitstatus ws; 4147 4148 VEC(cached_reg_t) *regcache; 4149 4150 int stopped_by_watchpoint_p; 4151 CORE_ADDR watch_data_address; 4152 4153 int solibs_changed; 4154 int replay_event; 4155 }; 4156 4157 /* The list of already fetched and acknowledged stop events. */ 4158 static struct stop_reply *stop_reply_queue; 4159 4160 static struct stop_reply * 4161 stop_reply_xmalloc (void) 4162 { 4163 struct stop_reply *r = XMALLOC (struct stop_reply); 4164 r->next = NULL; 4165 return r; 4166 } 4167 4168 static void 4169 stop_reply_xfree (struct stop_reply *r) 4170 { 4171 if (r != NULL) 4172 { 4173 VEC_free (cached_reg_t, r->regcache); 4174 xfree (r); 4175 } 4176 } 4177 4178 /* Discard all pending stop replies of inferior PID. If PID is -1, 4179 discard everything. */ 4180 4181 static void 4182 discard_pending_stop_replies (int pid) 4183 { 4184 struct stop_reply *prev = NULL, *reply, *next; 4185 4186 /* Discard the in-flight notification. */ 4187 if (pending_stop_reply != NULL 4188 && (pid == -1 4189 || ptid_get_pid (pending_stop_reply->ptid) == pid)) 4190 { 4191 stop_reply_xfree (pending_stop_reply); 4192 pending_stop_reply = NULL; 4193 } 4194 4195 /* Discard the stop replies we have already pulled with 4196 vStopped. */ 4197 for (reply = stop_reply_queue; reply; reply = next) 4198 { 4199 next = reply->next; 4200 if (pid == -1 4201 || ptid_get_pid (reply->ptid) == pid) 4202 { 4203 if (reply == stop_reply_queue) 4204 stop_reply_queue = reply->next; 4205 else 4206 prev->next = reply->next; 4207 4208 stop_reply_xfree (reply); 4209 } 4210 else 4211 prev = reply; 4212 } 4213 } 4214 4215 /* Cleanup wrapper. */ 4216 4217 static void 4218 do_stop_reply_xfree (void *arg) 4219 { 4220 struct stop_reply *r = arg; 4221 stop_reply_xfree (r); 4222 } 4223 4224 /* Look for a queued stop reply belonging to PTID. If one is found, 4225 remove it from the queue, and return it. Returns NULL if none is 4226 found. If there are still queued events left to process, tell the 4227 event loop to get back to target_wait soon. */ 4228 4229 static struct stop_reply * 4230 queued_stop_reply (ptid_t ptid) 4231 { 4232 struct stop_reply *it, *prev; 4233 struct stop_reply head; 4234 4235 head.next = stop_reply_queue; 4236 prev = &head; 4237 4238 it = head.next; 4239 4240 if (!ptid_equal (ptid, minus_one_ptid)) 4241 for (; it; prev = it, it = it->next) 4242 if (ptid_equal (ptid, it->ptid)) 4243 break; 4244 4245 if (it) 4246 { 4247 prev->next = it->next; 4248 it->next = NULL; 4249 } 4250 4251 stop_reply_queue = head.next; 4252 4253 if (stop_reply_queue) 4254 /* There's still at least an event left. */ 4255 mark_async_event_handler (remote_async_inferior_event_token); 4256 4257 return it; 4258 } 4259 4260 /* Push a fully parsed stop reply in the stop reply queue. Since we 4261 know that we now have at least one queued event left to pass to the 4262 core side, tell the event loop to get back to target_wait soon. */ 4263 4264 static void 4265 push_stop_reply (struct stop_reply *new_event) 4266 { 4267 struct stop_reply *event; 4268 4269 if (stop_reply_queue) 4270 { 4271 for (event = stop_reply_queue; 4272 event && event->next; 4273 event = event->next) 4274 ; 4275 4276 event->next = new_event; 4277 } 4278 else 4279 stop_reply_queue = new_event; 4280 4281 mark_async_event_handler (remote_async_inferior_event_token); 4282 } 4283 4284 /* Returns true if we have a stop reply for PTID. */ 4285 4286 static int 4287 peek_stop_reply (ptid_t ptid) 4288 { 4289 struct stop_reply *it; 4290 4291 for (it = stop_reply_queue; it; it = it->next) 4292 if (ptid_equal (ptid, it->ptid)) 4293 { 4294 if (it->ws.kind == TARGET_WAITKIND_STOPPED) 4295 return 1; 4296 } 4297 4298 return 0; 4299 } 4300 4301 /* Parse the stop reply in BUF. Either the function succeeds, and the 4302 result is stored in EVENT, or throws an error. */ 4303 4304 static void 4305 remote_parse_stop_reply (char *buf, struct stop_reply *event) 4306 { 4307 struct remote_arch_state *rsa = get_remote_arch_state (); 4308 ULONGEST addr; 4309 char *p; 4310 4311 event->ptid = null_ptid; 4312 event->ws.kind = TARGET_WAITKIND_IGNORE; 4313 event->ws.value.integer = 0; 4314 event->solibs_changed = 0; 4315 event->replay_event = 0; 4316 event->stopped_by_watchpoint_p = 0; 4317 event->regcache = NULL; 4318 4319 switch (buf[0]) 4320 { 4321 case 'T': /* Status with PC, SP, FP, ... */ 4322 /* Expedited reply, containing Signal, {regno, reg} repeat. */ 4323 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where 4324 ss = signal number 4325 n... = register number 4326 r... = register contents 4327 */ 4328 4329 p = &buf[3]; /* after Txx */ 4330 while (*p) 4331 { 4332 char *p1; 4333 char *p_temp; 4334 int fieldsize; 4335 LONGEST pnum = 0; 4336 4337 /* If the packet contains a register number, save it in 4338 pnum and set p1 to point to the character following it. 4339 Otherwise p1 points to p. */ 4340 4341 /* If this packet is an awatch packet, don't parse the 'a' 4342 as a register number. */ 4343 4344 if (strncmp (p, "awatch", strlen("awatch")) != 0) 4345 { 4346 /* Read the ``P'' register number. */ 4347 pnum = strtol (p, &p_temp, 16); 4348 p1 = p_temp; 4349 } 4350 else 4351 p1 = p; 4352 4353 if (p1 == p) /* No register number present here. */ 4354 { 4355 p1 = strchr (p, ':'); 4356 if (p1 == NULL) 4357 error (_("Malformed packet(a) (missing colon): %s\n\ 4358 Packet: '%s'\n"), 4359 p, buf); 4360 if (strncmp (p, "thread", p1 - p) == 0) 4361 event->ptid = read_ptid (++p1, &p); 4362 else if ((strncmp (p, "watch", p1 - p) == 0) 4363 || (strncmp (p, "rwatch", p1 - p) == 0) 4364 || (strncmp (p, "awatch", p1 - p) == 0)) 4365 { 4366 event->stopped_by_watchpoint_p = 1; 4367 p = unpack_varlen_hex (++p1, &addr); 4368 event->watch_data_address = (CORE_ADDR) addr; 4369 } 4370 else if (strncmp (p, "library", p1 - p) == 0) 4371 { 4372 p1++; 4373 p_temp = p1; 4374 while (*p_temp && *p_temp != ';') 4375 p_temp++; 4376 4377 event->solibs_changed = 1; 4378 p = p_temp; 4379 } 4380 else if (strncmp (p, "replaylog", p1 - p) == 0) 4381 { 4382 /* NO_HISTORY event. 4383 p1 will indicate "begin" or "end", but 4384 it makes no difference for now, so ignore it. */ 4385 event->replay_event = 1; 4386 p_temp = strchr (p1 + 1, ';'); 4387 if (p_temp) 4388 p = p_temp; 4389 } 4390 else 4391 { 4392 /* Silently skip unknown optional info. */ 4393 p_temp = strchr (p1 + 1, ';'); 4394 if (p_temp) 4395 p = p_temp; 4396 } 4397 } 4398 else 4399 { 4400 struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum); 4401 cached_reg_t cached_reg; 4402 4403 p = p1; 4404 4405 if (*p != ':') 4406 error (_("Malformed packet(b) (missing colon): %s\n\ 4407 Packet: '%s'\n"), 4408 p, buf); 4409 ++p; 4410 4411 if (reg == NULL) 4412 error (_("Remote sent bad register number %s: %s\n\ 4413 Packet: '%s'\n"), 4414 phex_nz (pnum, 0), p, buf); 4415 4416 cached_reg.num = reg->regnum; 4417 4418 fieldsize = hex2bin (p, cached_reg.data, 4419 register_size (target_gdbarch, 4420 reg->regnum)); 4421 p += 2 * fieldsize; 4422 if (fieldsize < register_size (target_gdbarch, 4423 reg->regnum)) 4424 warning (_("Remote reply is too short: %s"), buf); 4425 4426 VEC_safe_push (cached_reg_t, event->regcache, &cached_reg); 4427 } 4428 4429 if (*p != ';') 4430 error (_("Remote register badly formatted: %s\nhere: %s"), 4431 buf, p); 4432 ++p; 4433 } 4434 /* fall through */ 4435 case 'S': /* Old style status, just signal only. */ 4436 if (event->solibs_changed) 4437 event->ws.kind = TARGET_WAITKIND_LOADED; 4438 else if (event->replay_event) 4439 event->ws.kind = TARGET_WAITKIND_NO_HISTORY; 4440 else 4441 { 4442 event->ws.kind = TARGET_WAITKIND_STOPPED; 4443 event->ws.value.sig = (enum target_signal) 4444 (((fromhex (buf[1])) << 4) + (fromhex (buf[2]))); 4445 } 4446 break; 4447 case 'W': /* Target exited. */ 4448 case 'X': 4449 { 4450 char *p; 4451 int pid; 4452 ULONGEST value; 4453 4454 /* GDB used to accept only 2 hex chars here. Stubs should 4455 only send more if they detect GDB supports multi-process 4456 support. */ 4457 p = unpack_varlen_hex (&buf[1], &value); 4458 4459 if (buf[0] == 'W') 4460 { 4461 /* The remote process exited. */ 4462 event->ws.kind = TARGET_WAITKIND_EXITED; 4463 event->ws.value.integer = value; 4464 } 4465 else 4466 { 4467 /* The remote process exited with a signal. */ 4468 event->ws.kind = TARGET_WAITKIND_SIGNALLED; 4469 event->ws.value.sig = (enum target_signal) value; 4470 } 4471 4472 /* If no process is specified, assume inferior_ptid. */ 4473 pid = ptid_get_pid (inferior_ptid); 4474 if (*p == '\0') 4475 ; 4476 else if (*p == ';') 4477 { 4478 p++; 4479 4480 if (p == '\0') 4481 ; 4482 else if (strncmp (p, 4483 "process:", sizeof ("process:") - 1) == 0) 4484 { 4485 ULONGEST upid; 4486 p += sizeof ("process:") - 1; 4487 unpack_varlen_hex (p, &upid); 4488 pid = upid; 4489 } 4490 else 4491 error (_("unknown stop reply packet: %s"), buf); 4492 } 4493 else 4494 error (_("unknown stop reply packet: %s"), buf); 4495 event->ptid = pid_to_ptid (pid); 4496 } 4497 break; 4498 } 4499 4500 if (non_stop && ptid_equal (event->ptid, null_ptid)) 4501 error (_("No process or thread specified in stop reply: %s"), buf); 4502 } 4503 4504 /* When the stub wants to tell GDB about a new stop reply, it sends a 4505 stop notification (%Stop). Those can come it at any time, hence, 4506 we have to make sure that any pending putpkt/getpkt sequence we're 4507 making is finished, before querying the stub for more events with 4508 vStopped. E.g., if we started a vStopped sequence immediatelly 4509 upon receiving the %Stop notification, something like this could 4510 happen: 4511 4512 1.1) --> Hg 1 4513 1.2) <-- OK 4514 1.3) --> g 4515 1.4) <-- %Stop 4516 1.5) --> vStopped 4517 1.6) <-- (registers reply to step #1.3) 4518 4519 Obviously, the reply in step #1.6 would be unexpected to a vStopped 4520 query. 4521 4522 To solve this, whenever we parse a %Stop notification sucessfully, 4523 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on 4524 doing whatever we were doing: 4525 4526 2.1) --> Hg 1 4527 2.2) <-- OK 4528 2.3) --> g 4529 2.4) <-- %Stop 4530 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN> 4531 2.5) <-- (registers reply to step #2.3) 4532 4533 Eventualy after step #2.5, we return to the event loop, which 4534 notices there's an event on the 4535 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the 4536 associated callback --- the function below. At this point, we're 4537 always safe to start a vStopped sequence. : 4538 4539 2.6) --> vStopped 4540 2.7) <-- T05 thread:2 4541 2.8) --> vStopped 4542 2.9) --> OK 4543 */ 4544 4545 static void 4546 remote_get_pending_stop_replies (void) 4547 { 4548 struct remote_state *rs = get_remote_state (); 4549 4550 if (pending_stop_reply) 4551 { 4552 /* acknowledge */ 4553 putpkt ("vStopped"); 4554 4555 /* Now we can rely on it. */ 4556 push_stop_reply (pending_stop_reply); 4557 pending_stop_reply = NULL; 4558 4559 while (1) 4560 { 4561 getpkt (&rs->buf, &rs->buf_size, 0); 4562 if (strcmp (rs->buf, "OK") == 0) 4563 break; 4564 else 4565 { 4566 struct cleanup *old_chain; 4567 struct stop_reply *stop_reply = stop_reply_xmalloc (); 4568 4569 old_chain = make_cleanup (do_stop_reply_xfree, stop_reply); 4570 remote_parse_stop_reply (rs->buf, stop_reply); 4571 4572 /* acknowledge */ 4573 putpkt ("vStopped"); 4574 4575 if (stop_reply->ws.kind != TARGET_WAITKIND_IGNORE) 4576 { 4577 /* Now we can rely on it. */ 4578 discard_cleanups (old_chain); 4579 push_stop_reply (stop_reply); 4580 } 4581 else 4582 /* We got an unknown stop reply. */ 4583 do_cleanups (old_chain); 4584 } 4585 } 4586 } 4587 } 4588 4589 4590 /* Called when it is decided that STOP_REPLY holds the info of the 4591 event that is to be returned to the core. This function always 4592 destroys STOP_REPLY. */ 4593 4594 static ptid_t 4595 process_stop_reply (struct stop_reply *stop_reply, 4596 struct target_waitstatus *status) 4597 { 4598 ptid_t ptid; 4599 4600 *status = stop_reply->ws; 4601 ptid = stop_reply->ptid; 4602 4603 /* If no thread/process was reported by the stub, assume the current 4604 inferior. */ 4605 if (ptid_equal (ptid, null_ptid)) 4606 ptid = inferior_ptid; 4607 4608 if (status->kind != TARGET_WAITKIND_EXITED 4609 && status->kind != TARGET_WAITKIND_SIGNALLED) 4610 { 4611 /* Expedited registers. */ 4612 if (stop_reply->regcache) 4613 { 4614 struct regcache *regcache 4615 = get_thread_arch_regcache (ptid, target_gdbarch); 4616 cached_reg_t *reg; 4617 int ix; 4618 4619 for (ix = 0; 4620 VEC_iterate(cached_reg_t, stop_reply->regcache, ix, reg); 4621 ix++) 4622 regcache_raw_supply (regcache, reg->num, reg->data); 4623 VEC_free (cached_reg_t, stop_reply->regcache); 4624 } 4625 4626 remote_stopped_by_watchpoint_p = stop_reply->stopped_by_watchpoint_p; 4627 remote_watch_data_address = stop_reply->watch_data_address; 4628 4629 remote_notice_new_inferior (ptid, 0); 4630 } 4631 4632 stop_reply_xfree (stop_reply); 4633 return ptid; 4634 } 4635 4636 /* The non-stop mode version of target_wait. */ 4637 4638 static ptid_t 4639 remote_wait_ns (ptid_t ptid, struct target_waitstatus *status, int options) 4640 { 4641 struct remote_state *rs = get_remote_state (); 4642 struct stop_reply *stop_reply; 4643 int ret; 4644 4645 /* If in non-stop mode, get out of getpkt even if a 4646 notification is received. */ 4647 4648 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size, 4649 0 /* forever */); 4650 while (1) 4651 { 4652 if (ret != -1) 4653 switch (rs->buf[0]) 4654 { 4655 case 'E': /* Error of some sort. */ 4656 /* We're out of sync with the target now. Did it continue 4657 or not? We can't tell which thread it was in non-stop, 4658 so just ignore this. */ 4659 warning (_("Remote failure reply: %s"), rs->buf); 4660 break; 4661 case 'O': /* Console output. */ 4662 remote_console_output (rs->buf + 1); 4663 break; 4664 default: 4665 warning (_("Invalid remote reply: %s"), rs->buf); 4666 break; 4667 } 4668 4669 /* Acknowledge a pending stop reply that may have arrived in the 4670 mean time. */ 4671 if (pending_stop_reply != NULL) 4672 remote_get_pending_stop_replies (); 4673 4674 /* If indeed we noticed a stop reply, we're done. */ 4675 stop_reply = queued_stop_reply (ptid); 4676 if (stop_reply != NULL) 4677 return process_stop_reply (stop_reply, status); 4678 4679 /* Still no event. If we're just polling for an event, then 4680 return to the event loop. */ 4681 if (options & TARGET_WNOHANG) 4682 { 4683 status->kind = TARGET_WAITKIND_IGNORE; 4684 return minus_one_ptid; 4685 } 4686 4687 /* Otherwise do a blocking wait. */ 4688 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size, 4689 1 /* forever */); 4690 } 4691 } 4692 4693 /* Wait until the remote machine stops, then return, storing status in 4694 STATUS just as `wait' would. */ 4695 4696 static ptid_t 4697 remote_wait_as (ptid_t ptid, struct target_waitstatus *status, int options) 4698 { 4699 struct remote_state *rs = get_remote_state (); 4700 ptid_t event_ptid = null_ptid; 4701 char *buf; 4702 struct stop_reply *stop_reply; 4703 4704 again: 4705 4706 status->kind = TARGET_WAITKIND_IGNORE; 4707 status->value.integer = 0; 4708 4709 stop_reply = queued_stop_reply (ptid); 4710 if (stop_reply != NULL) 4711 return process_stop_reply (stop_reply, status); 4712 4713 if (rs->cached_wait_status) 4714 /* Use the cached wait status, but only once. */ 4715 rs->cached_wait_status = 0; 4716 else 4717 { 4718 int ret; 4719 4720 if (!target_is_async_p ()) 4721 { 4722 ofunc = signal (SIGINT, remote_interrupt); 4723 /* If the user hit C-c before this packet, or between packets, 4724 pretend that it was hit right here. */ 4725 if (quit_flag) 4726 { 4727 quit_flag = 0; 4728 remote_interrupt (SIGINT); 4729 } 4730 } 4731 4732 /* FIXME: cagney/1999-09-27: If we're in async mode we should 4733 _never_ wait for ever -> test on target_is_async_p(). 4734 However, before we do that we need to ensure that the caller 4735 knows how to take the target into/out of async mode. */ 4736 ret = getpkt_sane (&rs->buf, &rs->buf_size, wait_forever_enabled_p); 4737 if (!target_is_async_p ()) 4738 signal (SIGINT, ofunc); 4739 } 4740 4741 buf = rs->buf; 4742 4743 remote_stopped_by_watchpoint_p = 0; 4744 4745 /* We got something. */ 4746 rs->waiting_for_stop_reply = 0; 4747 4748 switch (buf[0]) 4749 { 4750 case 'E': /* Error of some sort. */ 4751 /* We're out of sync with the target now. Did it continue or 4752 not? Not is more likely, so report a stop. */ 4753 warning (_("Remote failure reply: %s"), buf); 4754 status->kind = TARGET_WAITKIND_STOPPED; 4755 status->value.sig = TARGET_SIGNAL_0; 4756 break; 4757 case 'F': /* File-I/O request. */ 4758 remote_fileio_request (buf); 4759 break; 4760 case 'T': case 'S': case 'X': case 'W': 4761 { 4762 struct stop_reply *stop_reply; 4763 struct cleanup *old_chain; 4764 4765 stop_reply = stop_reply_xmalloc (); 4766 old_chain = make_cleanup (do_stop_reply_xfree, stop_reply); 4767 remote_parse_stop_reply (buf, stop_reply); 4768 discard_cleanups (old_chain); 4769 event_ptid = process_stop_reply (stop_reply, status); 4770 break; 4771 } 4772 case 'O': /* Console output. */ 4773 remote_console_output (buf + 1); 4774 4775 /* The target didn't really stop; keep waiting. */ 4776 rs->waiting_for_stop_reply = 1; 4777 4778 break; 4779 case '\0': 4780 if (last_sent_signal != TARGET_SIGNAL_0) 4781 { 4782 /* Zero length reply means that we tried 'S' or 'C' and the 4783 remote system doesn't support it. */ 4784 target_terminal_ours_for_output (); 4785 printf_filtered 4786 ("Can't send signals to this remote system. %s not sent.\n", 4787 target_signal_to_name (last_sent_signal)); 4788 last_sent_signal = TARGET_SIGNAL_0; 4789 target_terminal_inferior (); 4790 4791 strcpy ((char *) buf, last_sent_step ? "s" : "c"); 4792 putpkt ((char *) buf); 4793 4794 /* We just told the target to resume, so a stop reply is in 4795 order. */ 4796 rs->waiting_for_stop_reply = 1; 4797 break; 4798 } 4799 /* else fallthrough */ 4800 default: 4801 warning (_("Invalid remote reply: %s"), buf); 4802 /* Keep waiting. */ 4803 rs->waiting_for_stop_reply = 1; 4804 break; 4805 } 4806 4807 if (status->kind == TARGET_WAITKIND_IGNORE) 4808 { 4809 /* Nothing interesting happened. If we're doing a non-blocking 4810 poll, we're done. Otherwise, go back to waiting. */ 4811 if (options & TARGET_WNOHANG) 4812 return minus_one_ptid; 4813 else 4814 goto again; 4815 } 4816 else if (status->kind != TARGET_WAITKIND_EXITED 4817 && status->kind != TARGET_WAITKIND_SIGNALLED) 4818 { 4819 if (!ptid_equal (event_ptid, null_ptid)) 4820 record_currthread (event_ptid); 4821 else 4822 event_ptid = inferior_ptid; 4823 } 4824 else 4825 /* A process exit. Invalidate our notion of current thread. */ 4826 record_currthread (minus_one_ptid); 4827 4828 return event_ptid; 4829 } 4830 4831 /* Wait until the remote machine stops, then return, storing status in 4832 STATUS just as `wait' would. */ 4833 4834 static ptid_t 4835 remote_wait (struct target_ops *ops, 4836 ptid_t ptid, struct target_waitstatus *status, int options) 4837 { 4838 ptid_t event_ptid; 4839 4840 if (non_stop) 4841 event_ptid = remote_wait_ns (ptid, status, options); 4842 else 4843 event_ptid = remote_wait_as (ptid, status, options); 4844 4845 if (target_can_async_p ()) 4846 { 4847 /* If there are are events left in the queue tell the event loop 4848 to return here. */ 4849 if (stop_reply_queue) 4850 mark_async_event_handler (remote_async_inferior_event_token); 4851 } 4852 4853 return event_ptid; 4854 } 4855 4856 /* Fetch a single register using a 'p' packet. */ 4857 4858 static int 4859 fetch_register_using_p (struct regcache *regcache, struct packet_reg *reg) 4860 { 4861 struct remote_state *rs = get_remote_state (); 4862 char *buf, *p; 4863 char regp[MAX_REGISTER_SIZE]; 4864 int i; 4865 4866 if (remote_protocol_packets[PACKET_p].support == PACKET_DISABLE) 4867 return 0; 4868 4869 if (reg->pnum == -1) 4870 return 0; 4871 4872 p = rs->buf; 4873 *p++ = 'p'; 4874 p += hexnumstr (p, reg->pnum); 4875 *p++ = '\0'; 4876 putpkt (rs->buf); 4877 getpkt (&rs->buf, &rs->buf_size, 0); 4878 4879 buf = rs->buf; 4880 4881 switch (packet_ok (buf, &remote_protocol_packets[PACKET_p])) 4882 { 4883 case PACKET_OK: 4884 break; 4885 case PACKET_UNKNOWN: 4886 return 0; 4887 case PACKET_ERROR: 4888 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"), 4889 gdbarch_register_name (get_regcache_arch (regcache), 4890 reg->regnum), 4891 buf); 4892 } 4893 4894 /* If this register is unfetchable, tell the regcache. */ 4895 if (buf[0] == 'x') 4896 { 4897 regcache_raw_supply (regcache, reg->regnum, NULL); 4898 return 1; 4899 } 4900 4901 /* Otherwise, parse and supply the value. */ 4902 p = buf; 4903 i = 0; 4904 while (p[0] != 0) 4905 { 4906 if (p[1] == 0) 4907 error (_("fetch_register_using_p: early buf termination")); 4908 4909 regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]); 4910 p += 2; 4911 } 4912 regcache_raw_supply (regcache, reg->regnum, regp); 4913 return 1; 4914 } 4915 4916 /* Fetch the registers included in the target's 'g' packet. */ 4917 4918 static int 4919 send_g_packet (void) 4920 { 4921 struct remote_state *rs = get_remote_state (); 4922 int buf_len; 4923 4924 sprintf (rs->buf, "g"); 4925 remote_send (&rs->buf, &rs->buf_size); 4926 4927 /* We can get out of synch in various cases. If the first character 4928 in the buffer is not a hex character, assume that has happened 4929 and try to fetch another packet to read. */ 4930 while ((rs->buf[0] < '0' || rs->buf[0] > '9') 4931 && (rs->buf[0] < 'A' || rs->buf[0] > 'F') 4932 && (rs->buf[0] < 'a' || rs->buf[0] > 'f') 4933 && rs->buf[0] != 'x') /* New: unavailable register value. */ 4934 { 4935 if (remote_debug) 4936 fprintf_unfiltered (gdb_stdlog, 4937 "Bad register packet; fetching a new packet\n"); 4938 getpkt (&rs->buf, &rs->buf_size, 0); 4939 } 4940 4941 buf_len = strlen (rs->buf); 4942 4943 /* Sanity check the received packet. */ 4944 if (buf_len % 2 != 0) 4945 error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf); 4946 4947 return buf_len / 2; 4948 } 4949 4950 static void 4951 process_g_packet (struct regcache *regcache) 4952 { 4953 struct gdbarch *gdbarch = get_regcache_arch (regcache); 4954 struct remote_state *rs = get_remote_state (); 4955 struct remote_arch_state *rsa = get_remote_arch_state (); 4956 int i, buf_len; 4957 char *p; 4958 char *regs; 4959 4960 buf_len = strlen (rs->buf); 4961 4962 /* Further sanity checks, with knowledge of the architecture. */ 4963 if (buf_len > 2 * rsa->sizeof_g_packet) 4964 error (_("Remote 'g' packet reply is too long: %s"), rs->buf); 4965 4966 /* Save the size of the packet sent to us by the target. It is used 4967 as a heuristic when determining the max size of packets that the 4968 target can safely receive. */ 4969 if (rsa->actual_register_packet_size == 0) 4970 rsa->actual_register_packet_size = buf_len; 4971 4972 /* If this is smaller than we guessed the 'g' packet would be, 4973 update our records. A 'g' reply that doesn't include a register's 4974 value implies either that the register is not available, or that 4975 the 'p' packet must be used. */ 4976 if (buf_len < 2 * rsa->sizeof_g_packet) 4977 { 4978 rsa->sizeof_g_packet = buf_len / 2; 4979 4980 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 4981 { 4982 if (rsa->regs[i].pnum == -1) 4983 continue; 4984 4985 if (rsa->regs[i].offset >= rsa->sizeof_g_packet) 4986 rsa->regs[i].in_g_packet = 0; 4987 else 4988 rsa->regs[i].in_g_packet = 1; 4989 } 4990 } 4991 4992 regs = alloca (rsa->sizeof_g_packet); 4993 4994 /* Unimplemented registers read as all bits zero. */ 4995 memset (regs, 0, rsa->sizeof_g_packet); 4996 4997 /* Reply describes registers byte by byte, each byte encoded as two 4998 hex characters. Suck them all up, then supply them to the 4999 register cacheing/storage mechanism. */ 5000 5001 p = rs->buf; 5002 for (i = 0; i < rsa->sizeof_g_packet; i++) 5003 { 5004 if (p[0] == 0 || p[1] == 0) 5005 /* This shouldn't happen - we adjusted sizeof_g_packet above. */ 5006 internal_error (__FILE__, __LINE__, 5007 "unexpected end of 'g' packet reply"); 5008 5009 if (p[0] == 'x' && p[1] == 'x') 5010 regs[i] = 0; /* 'x' */ 5011 else 5012 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]); 5013 p += 2; 5014 } 5015 5016 { 5017 int i; 5018 for (i = 0; i < gdbarch_num_regs (gdbarch); i++) 5019 { 5020 struct packet_reg *r = &rsa->regs[i]; 5021 if (r->in_g_packet) 5022 { 5023 if (r->offset * 2 >= strlen (rs->buf)) 5024 /* This shouldn't happen - we adjusted in_g_packet above. */ 5025 internal_error (__FILE__, __LINE__, 5026 "unexpected end of 'g' packet reply"); 5027 else if (rs->buf[r->offset * 2] == 'x') 5028 { 5029 gdb_assert (r->offset * 2 < strlen (rs->buf)); 5030 /* The register isn't available, mark it as such (at 5031 the same time setting the value to zero). */ 5032 regcache_raw_supply (regcache, r->regnum, NULL); 5033 } 5034 else 5035 regcache_raw_supply (regcache, r->regnum, 5036 regs + r->offset); 5037 } 5038 } 5039 } 5040 } 5041 5042 static void 5043 fetch_registers_using_g (struct regcache *regcache) 5044 { 5045 send_g_packet (); 5046 process_g_packet (regcache); 5047 } 5048 5049 static void 5050 remote_fetch_registers (struct target_ops *ops, 5051 struct regcache *regcache, int regnum) 5052 { 5053 struct remote_arch_state *rsa = get_remote_arch_state (); 5054 int i; 5055 5056 set_general_thread (inferior_ptid); 5057 5058 if (regnum >= 0) 5059 { 5060 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum); 5061 gdb_assert (reg != NULL); 5062 5063 /* If this register might be in the 'g' packet, try that first - 5064 we are likely to read more than one register. If this is the 5065 first 'g' packet, we might be overly optimistic about its 5066 contents, so fall back to 'p'. */ 5067 if (reg->in_g_packet) 5068 { 5069 fetch_registers_using_g (regcache); 5070 if (reg->in_g_packet) 5071 return; 5072 } 5073 5074 if (fetch_register_using_p (regcache, reg)) 5075 return; 5076 5077 /* This register is not available. */ 5078 regcache_raw_supply (regcache, reg->regnum, NULL); 5079 5080 return; 5081 } 5082 5083 fetch_registers_using_g (regcache); 5084 5085 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++) 5086 if (!rsa->regs[i].in_g_packet) 5087 if (!fetch_register_using_p (regcache, &rsa->regs[i])) 5088 { 5089 /* This register is not available. */ 5090 regcache_raw_supply (regcache, i, NULL); 5091 } 5092 } 5093 5094 /* Prepare to store registers. Since we may send them all (using a 5095 'G' request), we have to read out the ones we don't want to change 5096 first. */ 5097 5098 static void 5099 remote_prepare_to_store (struct regcache *regcache) 5100 { 5101 struct remote_arch_state *rsa = get_remote_arch_state (); 5102 int i; 5103 gdb_byte buf[MAX_REGISTER_SIZE]; 5104 5105 /* Make sure the entire registers array is valid. */ 5106 switch (remote_protocol_packets[PACKET_P].support) 5107 { 5108 case PACKET_DISABLE: 5109 case PACKET_SUPPORT_UNKNOWN: 5110 /* Make sure all the necessary registers are cached. */ 5111 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++) 5112 if (rsa->regs[i].in_g_packet) 5113 regcache_raw_read (regcache, rsa->regs[i].regnum, buf); 5114 break; 5115 case PACKET_ENABLE: 5116 break; 5117 } 5118 } 5119 5120 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF 5121 packet was not recognized. */ 5122 5123 static int 5124 store_register_using_P (const struct regcache *regcache, 5125 struct packet_reg *reg) 5126 { 5127 struct gdbarch *gdbarch = get_regcache_arch (regcache); 5128 struct remote_state *rs = get_remote_state (); 5129 /* Try storing a single register. */ 5130 char *buf = rs->buf; 5131 gdb_byte regp[MAX_REGISTER_SIZE]; 5132 char *p; 5133 5134 if (remote_protocol_packets[PACKET_P].support == PACKET_DISABLE) 5135 return 0; 5136 5137 if (reg->pnum == -1) 5138 return 0; 5139 5140 xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0)); 5141 p = buf + strlen (buf); 5142 regcache_raw_collect (regcache, reg->regnum, regp); 5143 bin2hex (regp, p, register_size (gdbarch, reg->regnum)); 5144 putpkt (rs->buf); 5145 getpkt (&rs->buf, &rs->buf_size, 0); 5146 5147 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P])) 5148 { 5149 case PACKET_OK: 5150 return 1; 5151 case PACKET_ERROR: 5152 error (_("Could not write register \"%s\"; remote failure reply '%s'"), 5153 gdbarch_register_name (gdbarch, reg->regnum), rs->buf); 5154 case PACKET_UNKNOWN: 5155 return 0; 5156 default: 5157 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok")); 5158 } 5159 } 5160 5161 /* Store register REGNUM, or all registers if REGNUM == -1, from the 5162 contents of the register cache buffer. FIXME: ignores errors. */ 5163 5164 static void 5165 store_registers_using_G (const struct regcache *regcache) 5166 { 5167 struct remote_state *rs = get_remote_state (); 5168 struct remote_arch_state *rsa = get_remote_arch_state (); 5169 gdb_byte *regs; 5170 char *p; 5171 5172 /* Extract all the registers in the regcache copying them into a 5173 local buffer. */ 5174 { 5175 int i; 5176 regs = alloca (rsa->sizeof_g_packet); 5177 memset (regs, 0, rsa->sizeof_g_packet); 5178 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++) 5179 { 5180 struct packet_reg *r = &rsa->regs[i]; 5181 if (r->in_g_packet) 5182 regcache_raw_collect (regcache, r->regnum, regs + r->offset); 5183 } 5184 } 5185 5186 /* Command describes registers byte by byte, 5187 each byte encoded as two hex characters. */ 5188 p = rs->buf; 5189 *p++ = 'G'; 5190 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets 5191 updated. */ 5192 bin2hex (regs, p, rsa->sizeof_g_packet); 5193 putpkt (rs->buf); 5194 getpkt (&rs->buf, &rs->buf_size, 0); 5195 if (packet_check_result (rs->buf) == PACKET_ERROR) 5196 error (_("Could not write registers; remote failure reply '%s'"), 5197 rs->buf); 5198 } 5199 5200 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents 5201 of the register cache buffer. FIXME: ignores errors. */ 5202 5203 static void 5204 remote_store_registers (struct target_ops *ops, 5205 struct regcache *regcache, int regnum) 5206 { 5207 struct remote_arch_state *rsa = get_remote_arch_state (); 5208 int i; 5209 5210 set_general_thread (inferior_ptid); 5211 5212 if (regnum >= 0) 5213 { 5214 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum); 5215 gdb_assert (reg != NULL); 5216 5217 /* Always prefer to store registers using the 'P' packet if 5218 possible; we often change only a small number of registers. 5219 Sometimes we change a larger number; we'd need help from a 5220 higher layer to know to use 'G'. */ 5221 if (store_register_using_P (regcache, reg)) 5222 return; 5223 5224 /* For now, don't complain if we have no way to write the 5225 register. GDB loses track of unavailable registers too 5226 easily. Some day, this may be an error. We don't have 5227 any way to read the register, either... */ 5228 if (!reg->in_g_packet) 5229 return; 5230 5231 store_registers_using_G (regcache); 5232 return; 5233 } 5234 5235 store_registers_using_G (regcache); 5236 5237 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++) 5238 if (!rsa->regs[i].in_g_packet) 5239 if (!store_register_using_P (regcache, &rsa->regs[i])) 5240 /* See above for why we do not issue an error here. */ 5241 continue; 5242 } 5243 5244 5245 /* Return the number of hex digits in num. */ 5246 5247 static int 5248 hexnumlen (ULONGEST num) 5249 { 5250 int i; 5251 5252 for (i = 0; num != 0; i++) 5253 num >>= 4; 5254 5255 return max (i, 1); 5256 } 5257 5258 /* Set BUF to the minimum number of hex digits representing NUM. */ 5259 5260 static int 5261 hexnumstr (char *buf, ULONGEST num) 5262 { 5263 int len = hexnumlen (num); 5264 return hexnumnstr (buf, num, len); 5265 } 5266 5267 5268 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */ 5269 5270 static int 5271 hexnumnstr (char *buf, ULONGEST num, int width) 5272 { 5273 int i; 5274 5275 buf[width] = '\0'; 5276 5277 for (i = width - 1; i >= 0; i--) 5278 { 5279 buf[i] = "0123456789abcdef"[(num & 0xf)]; 5280 num >>= 4; 5281 } 5282 5283 return width; 5284 } 5285 5286 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */ 5287 5288 static CORE_ADDR 5289 remote_address_masked (CORE_ADDR addr) 5290 { 5291 int address_size = remote_address_size; 5292 /* If "remoteaddresssize" was not set, default to target address size. */ 5293 if (!address_size) 5294 address_size = gdbarch_addr_bit (target_gdbarch); 5295 5296 if (address_size > 0 5297 && address_size < (sizeof (ULONGEST) * 8)) 5298 { 5299 /* Only create a mask when that mask can safely be constructed 5300 in a ULONGEST variable. */ 5301 ULONGEST mask = 1; 5302 mask = (mask << address_size) - 1; 5303 addr &= mask; 5304 } 5305 return addr; 5306 } 5307 5308 /* Convert BUFFER, binary data at least LEN bytes long, into escaped 5309 binary data in OUT_BUF. Set *OUT_LEN to the length of the data 5310 encoded in OUT_BUF, and return the number of bytes in OUT_BUF 5311 (which may be more than *OUT_LEN due to escape characters). The 5312 total number of bytes in the output buffer will be at most 5313 OUT_MAXLEN. */ 5314 5315 static int 5316 remote_escape_output (const gdb_byte *buffer, int len, 5317 gdb_byte *out_buf, int *out_len, 5318 int out_maxlen) 5319 { 5320 int input_index, output_index; 5321 5322 output_index = 0; 5323 for (input_index = 0; input_index < len; input_index++) 5324 { 5325 gdb_byte b = buffer[input_index]; 5326 5327 if (b == '$' || b == '#' || b == '}') 5328 { 5329 /* These must be escaped. */ 5330 if (output_index + 2 > out_maxlen) 5331 break; 5332 out_buf[output_index++] = '}'; 5333 out_buf[output_index++] = b ^ 0x20; 5334 } 5335 else 5336 { 5337 if (output_index + 1 > out_maxlen) 5338 break; 5339 out_buf[output_index++] = b; 5340 } 5341 } 5342 5343 *out_len = input_index; 5344 return output_index; 5345 } 5346 5347 /* Convert BUFFER, escaped data LEN bytes long, into binary data 5348 in OUT_BUF. Return the number of bytes written to OUT_BUF. 5349 Raise an error if the total number of bytes exceeds OUT_MAXLEN. 5350 5351 This function reverses remote_escape_output. It allows more 5352 escaped characters than that function does, in particular because 5353 '*' must be escaped to avoid the run-length encoding processing 5354 in reading packets. */ 5355 5356 static int 5357 remote_unescape_input (const gdb_byte *buffer, int len, 5358 gdb_byte *out_buf, int out_maxlen) 5359 { 5360 int input_index, output_index; 5361 int escaped; 5362 5363 output_index = 0; 5364 escaped = 0; 5365 for (input_index = 0; input_index < len; input_index++) 5366 { 5367 gdb_byte b = buffer[input_index]; 5368 5369 if (output_index + 1 > out_maxlen) 5370 { 5371 warning (_("Received too much data from remote target;" 5372 " ignoring overflow.")); 5373 return output_index; 5374 } 5375 5376 if (escaped) 5377 { 5378 out_buf[output_index++] = b ^ 0x20; 5379 escaped = 0; 5380 } 5381 else if (b == '}') 5382 escaped = 1; 5383 else 5384 out_buf[output_index++] = b; 5385 } 5386 5387 if (escaped) 5388 error (_("Unmatched escape character in target response.")); 5389 5390 return output_index; 5391 } 5392 5393 /* Determine whether the remote target supports binary downloading. 5394 This is accomplished by sending a no-op memory write of zero length 5395 to the target at the specified address. It does not suffice to send 5396 the whole packet, since many stubs strip the eighth bit and 5397 subsequently compute a wrong checksum, which causes real havoc with 5398 remote_write_bytes. 5399 5400 NOTE: This can still lose if the serial line is not eight-bit 5401 clean. In cases like this, the user should clear "remote 5402 X-packet". */ 5403 5404 static void 5405 check_binary_download (CORE_ADDR addr) 5406 { 5407 struct remote_state *rs = get_remote_state (); 5408 5409 switch (remote_protocol_packets[PACKET_X].support) 5410 { 5411 case PACKET_DISABLE: 5412 break; 5413 case PACKET_ENABLE: 5414 break; 5415 case PACKET_SUPPORT_UNKNOWN: 5416 { 5417 char *p; 5418 5419 p = rs->buf; 5420 *p++ = 'X'; 5421 p += hexnumstr (p, (ULONGEST) addr); 5422 *p++ = ','; 5423 p += hexnumstr (p, (ULONGEST) 0); 5424 *p++ = ':'; 5425 *p = '\0'; 5426 5427 putpkt_binary (rs->buf, (int) (p - rs->buf)); 5428 getpkt (&rs->buf, &rs->buf_size, 0); 5429 5430 if (rs->buf[0] == '\0') 5431 { 5432 if (remote_debug) 5433 fprintf_unfiltered (gdb_stdlog, 5434 "binary downloading NOT suppported by target\n"); 5435 remote_protocol_packets[PACKET_X].support = PACKET_DISABLE; 5436 } 5437 else 5438 { 5439 if (remote_debug) 5440 fprintf_unfiltered (gdb_stdlog, 5441 "binary downloading suppported by target\n"); 5442 remote_protocol_packets[PACKET_X].support = PACKET_ENABLE; 5443 } 5444 break; 5445 } 5446 } 5447 } 5448 5449 /* Write memory data directly to the remote machine. 5450 This does not inform the data cache; the data cache uses this. 5451 HEADER is the starting part of the packet. 5452 MEMADDR is the address in the remote memory space. 5453 MYADDR is the address of the buffer in our space. 5454 LEN is the number of bytes. 5455 PACKET_FORMAT should be either 'X' or 'M', and indicates if we 5456 should send data as binary ('X'), or hex-encoded ('M'). 5457 5458 The function creates packet of the form 5459 <HEADER><ADDRESS>,<LENGTH>:<DATA> 5460 5461 where encoding of <DATA> is termined by PACKET_FORMAT. 5462 5463 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma 5464 are omitted. 5465 5466 Returns the number of bytes transferred, or 0 (setting errno) for 5467 error. Only transfer a single packet. */ 5468 5469 static int 5470 remote_write_bytes_aux (const char *header, CORE_ADDR memaddr, 5471 const gdb_byte *myaddr, int len, 5472 char packet_format, int use_length) 5473 { 5474 struct remote_state *rs = get_remote_state (); 5475 char *p; 5476 char *plen = NULL; 5477 int plenlen = 0; 5478 int todo; 5479 int nr_bytes; 5480 int payload_size; 5481 int payload_length; 5482 int header_length; 5483 5484 if (packet_format != 'X' && packet_format != 'M') 5485 internal_error (__FILE__, __LINE__, 5486 "remote_write_bytes_aux: bad packet format"); 5487 5488 if (len <= 0) 5489 return 0; 5490 5491 payload_size = get_memory_write_packet_size (); 5492 5493 /* The packet buffer will be large enough for the payload; 5494 get_memory_packet_size ensures this. */ 5495 rs->buf[0] = '\0'; 5496 5497 /* Compute the size of the actual payload by subtracting out the 5498 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". 5499 */ 5500 payload_size -= strlen ("$,:#NN"); 5501 if (!use_length) 5502 /* The comma won't be used. */ 5503 payload_size += 1; 5504 header_length = strlen (header); 5505 payload_size -= header_length; 5506 payload_size -= hexnumlen (memaddr); 5507 5508 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */ 5509 5510 strcat (rs->buf, header); 5511 p = rs->buf + strlen (header); 5512 5513 /* Compute a best guess of the number of bytes actually transfered. */ 5514 if (packet_format == 'X') 5515 { 5516 /* Best guess at number of bytes that will fit. */ 5517 todo = min (len, payload_size); 5518 if (use_length) 5519 payload_size -= hexnumlen (todo); 5520 todo = min (todo, payload_size); 5521 } 5522 else 5523 { 5524 /* Num bytes that will fit. */ 5525 todo = min (len, payload_size / 2); 5526 if (use_length) 5527 payload_size -= hexnumlen (todo); 5528 todo = min (todo, payload_size / 2); 5529 } 5530 5531 if (todo <= 0) 5532 internal_error (__FILE__, __LINE__, 5533 _("minumum packet size too small to write data")); 5534 5535 /* If we already need another packet, then try to align the end 5536 of this packet to a useful boundary. */ 5537 if (todo > 2 * REMOTE_ALIGN_WRITES && todo < len) 5538 todo = ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr; 5539 5540 /* Append "<memaddr>". */ 5541 memaddr = remote_address_masked (memaddr); 5542 p += hexnumstr (p, (ULONGEST) memaddr); 5543 5544 if (use_length) 5545 { 5546 /* Append ",". */ 5547 *p++ = ','; 5548 5549 /* Append <len>. Retain the location/size of <len>. It may need to 5550 be adjusted once the packet body has been created. */ 5551 plen = p; 5552 plenlen = hexnumstr (p, (ULONGEST) todo); 5553 p += plenlen; 5554 } 5555 5556 /* Append ":". */ 5557 *p++ = ':'; 5558 *p = '\0'; 5559 5560 /* Append the packet body. */ 5561 if (packet_format == 'X') 5562 { 5563 /* Binary mode. Send target system values byte by byte, in 5564 increasing byte addresses. Only escape certain critical 5565 characters. */ 5566 payload_length = remote_escape_output (myaddr, todo, p, &nr_bytes, 5567 payload_size); 5568 5569 /* If not all TODO bytes fit, then we'll need another packet. Make 5570 a second try to keep the end of the packet aligned. Don't do 5571 this if the packet is tiny. */ 5572 if (nr_bytes < todo && nr_bytes > 2 * REMOTE_ALIGN_WRITES) 5573 { 5574 int new_nr_bytes; 5575 5576 new_nr_bytes = (((memaddr + nr_bytes) & ~(REMOTE_ALIGN_WRITES - 1)) 5577 - memaddr); 5578 if (new_nr_bytes != nr_bytes) 5579 payload_length = remote_escape_output (myaddr, new_nr_bytes, 5580 p, &nr_bytes, 5581 payload_size); 5582 } 5583 5584 p += payload_length; 5585 if (use_length && nr_bytes < todo) 5586 { 5587 /* Escape chars have filled up the buffer prematurely, 5588 and we have actually sent fewer bytes than planned. 5589 Fix-up the length field of the packet. Use the same 5590 number of characters as before. */ 5591 plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen); 5592 *plen = ':'; /* overwrite \0 from hexnumnstr() */ 5593 } 5594 } 5595 else 5596 { 5597 /* Normal mode: Send target system values byte by byte, in 5598 increasing byte addresses. Each byte is encoded as a two hex 5599 value. */ 5600 nr_bytes = bin2hex (myaddr, p, todo); 5601 p += 2 * nr_bytes; 5602 } 5603 5604 putpkt_binary (rs->buf, (int) (p - rs->buf)); 5605 getpkt (&rs->buf, &rs->buf_size, 0); 5606 5607 if (rs->buf[0] == 'E') 5608 { 5609 /* There is no correspondance between what the remote protocol 5610 uses for errors and errno codes. We would like a cleaner way 5611 of representing errors (big enough to include errno codes, 5612 bfd_error codes, and others). But for now just return EIO. */ 5613 errno = EIO; 5614 return 0; 5615 } 5616 5617 /* Return NR_BYTES, not TODO, in case escape chars caused us to send 5618 fewer bytes than we'd planned. */ 5619 return nr_bytes; 5620 } 5621 5622 /* Write memory data directly to the remote machine. 5623 This does not inform the data cache; the data cache uses this. 5624 MEMADDR is the address in the remote memory space. 5625 MYADDR is the address of the buffer in our space. 5626 LEN is the number of bytes. 5627 5628 Returns number of bytes transferred, or 0 (setting errno) for 5629 error. Only transfer a single packet. */ 5630 5631 int 5632 remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len) 5633 { 5634 char *packet_format = 0; 5635 5636 /* Check whether the target supports binary download. */ 5637 check_binary_download (memaddr); 5638 5639 switch (remote_protocol_packets[PACKET_X].support) 5640 { 5641 case PACKET_ENABLE: 5642 packet_format = "X"; 5643 break; 5644 case PACKET_DISABLE: 5645 packet_format = "M"; 5646 break; 5647 case PACKET_SUPPORT_UNKNOWN: 5648 internal_error (__FILE__, __LINE__, 5649 _("remote_write_bytes: bad internal state")); 5650 default: 5651 internal_error (__FILE__, __LINE__, _("bad switch")); 5652 } 5653 5654 return remote_write_bytes_aux (packet_format, 5655 memaddr, myaddr, len, packet_format[0], 1); 5656 } 5657 5658 /* Read memory data directly from the remote machine. 5659 This does not use the data cache; the data cache uses this. 5660 MEMADDR is the address in the remote memory space. 5661 MYADDR is the address of the buffer in our space. 5662 LEN is the number of bytes. 5663 5664 Returns number of bytes transferred, or 0 for error. */ 5665 5666 /* NOTE: cagney/1999-10-18: This function (and its siblings in other 5667 remote targets) shouldn't attempt to read the entire buffer. 5668 Instead it should read a single packet worth of data and then 5669 return the byte size of that packet to the caller. The caller (its 5670 caller and its callers caller ;-) already contains code for 5671 handling partial reads. */ 5672 5673 int 5674 remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len) 5675 { 5676 struct remote_state *rs = get_remote_state (); 5677 int max_buf_size; /* Max size of packet output buffer. */ 5678 int origlen; 5679 5680 if (len <= 0) 5681 return 0; 5682 5683 max_buf_size = get_memory_read_packet_size (); 5684 /* The packet buffer will be large enough for the payload; 5685 get_memory_packet_size ensures this. */ 5686 5687 origlen = len; 5688 while (len > 0) 5689 { 5690 char *p; 5691 int todo; 5692 int i; 5693 5694 todo = min (len, max_buf_size / 2); /* num bytes that will fit */ 5695 5696 /* construct "m"<memaddr>","<len>" */ 5697 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */ 5698 memaddr = remote_address_masked (memaddr); 5699 p = rs->buf; 5700 *p++ = 'm'; 5701 p += hexnumstr (p, (ULONGEST) memaddr); 5702 *p++ = ','; 5703 p += hexnumstr (p, (ULONGEST) todo); 5704 *p = '\0'; 5705 5706 putpkt (rs->buf); 5707 getpkt (&rs->buf, &rs->buf_size, 0); 5708 5709 if (rs->buf[0] == 'E' 5710 && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2]) 5711 && rs->buf[3] == '\0') 5712 { 5713 /* There is no correspondance between what the remote 5714 protocol uses for errors and errno codes. We would like 5715 a cleaner way of representing errors (big enough to 5716 include errno codes, bfd_error codes, and others). But 5717 for now just return EIO. */ 5718 errno = EIO; 5719 return 0; 5720 } 5721 5722 /* Reply describes memory byte by byte, 5723 each byte encoded as two hex characters. */ 5724 5725 p = rs->buf; 5726 if ((i = hex2bin (p, myaddr, todo)) < todo) 5727 { 5728 /* Reply is short. This means that we were able to read 5729 only part of what we wanted to. */ 5730 return i + (origlen - len); 5731 } 5732 myaddr += todo; 5733 memaddr += todo; 5734 len -= todo; 5735 } 5736 return origlen; 5737 } 5738 5739 5740 /* Remote notification handler. */ 5741 5742 static void 5743 handle_notification (char *buf, size_t length) 5744 { 5745 if (strncmp (buf, "Stop:", 5) == 0) 5746 { 5747 if (pending_stop_reply) 5748 /* We've already parsed the in-flight stop-reply, but the stub 5749 for some reason thought we didn't, possibly due to timeout 5750 on its side. Just ignore it. */ 5751 ; 5752 else 5753 { 5754 struct cleanup *old_chain; 5755 struct stop_reply *reply = stop_reply_xmalloc (); 5756 old_chain = make_cleanup (do_stop_reply_xfree, reply); 5757 5758 remote_parse_stop_reply (buf + 5, reply); 5759 5760 discard_cleanups (old_chain); 5761 5762 /* Be careful to only set it after parsing, since an error 5763 may be thrown then. */ 5764 pending_stop_reply = reply; 5765 5766 /* Notify the event loop there's a stop reply to acknowledge 5767 and that there may be more events to fetch. */ 5768 mark_async_event_handler (remote_async_get_pending_events_token); 5769 } 5770 } 5771 else 5772 /* We ignore notifications we don't recognize, for compatibility 5773 with newer stubs. */ 5774 ; 5775 } 5776 5777 5778 /* Read or write LEN bytes from inferior memory at MEMADDR, 5779 transferring to or from debugger address BUFFER. Write to inferior 5780 if SHOULD_WRITE is nonzero. Returns length of data written or 5781 read; 0 for error. TARGET is unused. */ 5782 5783 static int 5784 remote_xfer_memory (CORE_ADDR mem_addr, gdb_byte *buffer, int mem_len, 5785 int should_write, struct mem_attrib *attrib, 5786 struct target_ops *target) 5787 { 5788 int res; 5789 5790 set_general_thread (inferior_ptid); 5791 5792 if (should_write) 5793 res = remote_write_bytes (mem_addr, buffer, mem_len); 5794 else 5795 res = remote_read_bytes (mem_addr, buffer, mem_len); 5796 5797 return res; 5798 } 5799 5800 /* Sends a packet with content determined by the printf format string 5801 FORMAT and the remaining arguments, then gets the reply. Returns 5802 whether the packet was a success, a failure, or unknown. */ 5803 5804 static enum packet_result 5805 remote_send_printf (const char *format, ...) 5806 { 5807 struct remote_state *rs = get_remote_state (); 5808 int max_size = get_remote_packet_size (); 5809 5810 va_list ap; 5811 va_start (ap, format); 5812 5813 rs->buf[0] = '\0'; 5814 if (vsnprintf (rs->buf, max_size, format, ap) >= max_size) 5815 internal_error (__FILE__, __LINE__, "Too long remote packet."); 5816 5817 if (putpkt (rs->buf) < 0) 5818 error (_("Communication problem with target.")); 5819 5820 rs->buf[0] = '\0'; 5821 getpkt (&rs->buf, &rs->buf_size, 0); 5822 5823 return packet_check_result (rs->buf); 5824 } 5825 5826 static void 5827 restore_remote_timeout (void *p) 5828 { 5829 int value = *(int *)p; 5830 remote_timeout = value; 5831 } 5832 5833 /* Flash writing can take quite some time. We'll set 5834 effectively infinite timeout for flash operations. 5835 In future, we'll need to decide on a better approach. */ 5836 static const int remote_flash_timeout = 1000; 5837 5838 static void 5839 remote_flash_erase (struct target_ops *ops, 5840 ULONGEST address, LONGEST length) 5841 { 5842 int addr_size = gdbarch_addr_bit (target_gdbarch) / 8; 5843 int saved_remote_timeout = remote_timeout; 5844 enum packet_result ret; 5845 5846 struct cleanup *back_to = make_cleanup (restore_remote_timeout, 5847 &saved_remote_timeout); 5848 remote_timeout = remote_flash_timeout; 5849 5850 ret = remote_send_printf ("vFlashErase:%s,%s", 5851 phex (address, addr_size), 5852 phex (length, 4)); 5853 switch (ret) 5854 { 5855 case PACKET_UNKNOWN: 5856 error (_("Remote target does not support flash erase")); 5857 case PACKET_ERROR: 5858 error (_("Error erasing flash with vFlashErase packet")); 5859 default: 5860 break; 5861 } 5862 5863 do_cleanups (back_to); 5864 } 5865 5866 static LONGEST 5867 remote_flash_write (struct target_ops *ops, 5868 ULONGEST address, LONGEST length, 5869 const gdb_byte *data) 5870 { 5871 int saved_remote_timeout = remote_timeout; 5872 int ret; 5873 struct cleanup *back_to = make_cleanup (restore_remote_timeout, 5874 &saved_remote_timeout); 5875 5876 remote_timeout = remote_flash_timeout; 5877 ret = remote_write_bytes_aux ("vFlashWrite:", address, data, length, 'X', 0); 5878 do_cleanups (back_to); 5879 5880 return ret; 5881 } 5882 5883 static void 5884 remote_flash_done (struct target_ops *ops) 5885 { 5886 int saved_remote_timeout = remote_timeout; 5887 int ret; 5888 struct cleanup *back_to = make_cleanup (restore_remote_timeout, 5889 &saved_remote_timeout); 5890 5891 remote_timeout = remote_flash_timeout; 5892 ret = remote_send_printf ("vFlashDone"); 5893 do_cleanups (back_to); 5894 5895 switch (ret) 5896 { 5897 case PACKET_UNKNOWN: 5898 error (_("Remote target does not support vFlashDone")); 5899 case PACKET_ERROR: 5900 error (_("Error finishing flash operation")); 5901 default: 5902 break; 5903 } 5904 } 5905 5906 static void 5907 remote_files_info (struct target_ops *ignore) 5908 { 5909 puts_filtered ("Debugging a target over a serial line.\n"); 5910 } 5911 5912 /* Stuff for dealing with the packets which are part of this protocol. 5913 See comment at top of file for details. */ 5914 5915 /* Read a single character from the remote end. */ 5916 5917 static int 5918 readchar (int timeout) 5919 { 5920 int ch; 5921 5922 ch = serial_readchar (remote_desc, timeout); 5923 5924 if (ch >= 0) 5925 return ch; 5926 5927 switch ((enum serial_rc) ch) 5928 { 5929 case SERIAL_EOF: 5930 pop_target (); 5931 error (_("Remote connection closed")); 5932 /* no return */ 5933 case SERIAL_ERROR: 5934 perror_with_name (_("Remote communication error")); 5935 /* no return */ 5936 case SERIAL_TIMEOUT: 5937 break; 5938 } 5939 return ch; 5940 } 5941 5942 /* Send the command in *BUF to the remote machine, and read the reply 5943 into *BUF. Report an error if we get an error reply. Resize 5944 *BUF using xrealloc if necessary to hold the result, and update 5945 *SIZEOF_BUF. */ 5946 5947 static void 5948 remote_send (char **buf, 5949 long *sizeof_buf) 5950 { 5951 putpkt (*buf); 5952 getpkt (buf, sizeof_buf, 0); 5953 5954 if ((*buf)[0] == 'E') 5955 error (_("Remote failure reply: %s"), *buf); 5956 } 5957 5958 /* Return a pointer to an xmalloc'ed string representing an escaped 5959 version of BUF, of len N. E.g. \n is converted to \\n, \t to \\t, 5960 etc. The caller is responsible for releasing the returned 5961 memory. */ 5962 5963 static char * 5964 escape_buffer (const char *buf, int n) 5965 { 5966 struct cleanup *old_chain; 5967 struct ui_file *stb; 5968 char *str; 5969 5970 stb = mem_fileopen (); 5971 old_chain = make_cleanup_ui_file_delete (stb); 5972 5973 fputstrn_unfiltered (buf, n, 0, stb); 5974 str = ui_file_xstrdup (stb, NULL); 5975 do_cleanups (old_chain); 5976 return str; 5977 } 5978 5979 /* Display a null-terminated packet on stdout, for debugging, using C 5980 string notation. */ 5981 5982 static void 5983 print_packet (char *buf) 5984 { 5985 puts_filtered ("\""); 5986 fputstr_filtered (buf, '"', gdb_stdout); 5987 puts_filtered ("\""); 5988 } 5989 5990 int 5991 putpkt (char *buf) 5992 { 5993 return putpkt_binary (buf, strlen (buf)); 5994 } 5995 5996 /* Send a packet to the remote machine, with error checking. The data 5997 of the packet is in BUF. The string in BUF can be at most 5998 get_remote_packet_size () - 5 to account for the $, # and checksum, 5999 and for a possible /0 if we are debugging (remote_debug) and want 6000 to print the sent packet as a string. */ 6001 6002 static int 6003 putpkt_binary (char *buf, int cnt) 6004 { 6005 struct remote_state *rs = get_remote_state (); 6006 int i; 6007 unsigned char csum = 0; 6008 char *buf2 = alloca (cnt + 6); 6009 6010 int ch; 6011 int tcount = 0; 6012 char *p; 6013 6014 /* Catch cases like trying to read memory or listing threads while 6015 we're waiting for a stop reply. The remote server wouldn't be 6016 ready to handle this request, so we'd hang and timeout. We don't 6017 have to worry about this in synchronous mode, because in that 6018 case it's not possible to issue a command while the target is 6019 running. This is not a problem in non-stop mode, because in that 6020 case, the stub is always ready to process serial input. */ 6021 if (!non_stop && target_can_async_p () && rs->waiting_for_stop_reply) 6022 error (_("Cannot execute this command while the target is running.")); 6023 6024 /* We're sending out a new packet. Make sure we don't look at a 6025 stale cached response. */ 6026 rs->cached_wait_status = 0; 6027 6028 /* Copy the packet into buffer BUF2, encapsulating it 6029 and giving it a checksum. */ 6030 6031 p = buf2; 6032 *p++ = '$'; 6033 6034 for (i = 0; i < cnt; i++) 6035 { 6036 csum += buf[i]; 6037 *p++ = buf[i]; 6038 } 6039 *p++ = '#'; 6040 *p++ = tohex ((csum >> 4) & 0xf); 6041 *p++ = tohex (csum & 0xf); 6042 6043 /* Send it over and over until we get a positive ack. */ 6044 6045 while (1) 6046 { 6047 int started_error_output = 0; 6048 6049 if (remote_debug) 6050 { 6051 struct cleanup *old_chain; 6052 char *str; 6053 6054 *p = '\0'; 6055 str = escape_buffer (buf2, p - buf2); 6056 old_chain = make_cleanup (xfree, str); 6057 fprintf_unfiltered (gdb_stdlog, "Sending packet: %s...", str); 6058 gdb_flush (gdb_stdlog); 6059 do_cleanups (old_chain); 6060 } 6061 if (serial_write (remote_desc, buf2, p - buf2)) 6062 perror_with_name (_("putpkt: write failed")); 6063 6064 /* If this is a no acks version of the remote protocol, send the 6065 packet and move on. */ 6066 if (rs->noack_mode) 6067 break; 6068 6069 /* Read until either a timeout occurs (-2) or '+' is read. 6070 Handle any notification that arrives in the mean time. */ 6071 while (1) 6072 { 6073 ch = readchar (remote_timeout); 6074 6075 if (remote_debug) 6076 { 6077 switch (ch) 6078 { 6079 case '+': 6080 case '-': 6081 case SERIAL_TIMEOUT: 6082 case '$': 6083 case '%': 6084 if (started_error_output) 6085 { 6086 putchar_unfiltered ('\n'); 6087 started_error_output = 0; 6088 } 6089 } 6090 } 6091 6092 switch (ch) 6093 { 6094 case '+': 6095 if (remote_debug) 6096 fprintf_unfiltered (gdb_stdlog, "Ack\n"); 6097 return 1; 6098 case '-': 6099 if (remote_debug) 6100 fprintf_unfiltered (gdb_stdlog, "Nak\n"); 6101 case SERIAL_TIMEOUT: 6102 tcount++; 6103 if (tcount > 3) 6104 return 0; 6105 break; /* Retransmit buffer. */ 6106 case '$': 6107 { 6108 if (remote_debug) 6109 fprintf_unfiltered (gdb_stdlog, 6110 "Packet instead of Ack, ignoring it\n"); 6111 /* It's probably an old response sent because an ACK 6112 was lost. Gobble up the packet and ack it so it 6113 doesn't get retransmitted when we resend this 6114 packet. */ 6115 skip_frame (); 6116 serial_write (remote_desc, "+", 1); 6117 continue; /* Now, go look for +. */ 6118 } 6119 6120 case '%': 6121 { 6122 int val; 6123 6124 /* If we got a notification, handle it, and go back to looking 6125 for an ack. */ 6126 /* We've found the start of a notification. Now 6127 collect the data. */ 6128 val = read_frame (&rs->buf, &rs->buf_size); 6129 if (val >= 0) 6130 { 6131 if (remote_debug) 6132 { 6133 struct cleanup *old_chain; 6134 char *str; 6135 6136 str = escape_buffer (rs->buf, val); 6137 old_chain = make_cleanup (xfree, str); 6138 fprintf_unfiltered (gdb_stdlog, 6139 " Notification received: %s\n", 6140 str); 6141 do_cleanups (old_chain); 6142 } 6143 handle_notification (rs->buf, val); 6144 /* We're in sync now, rewait for the ack. */ 6145 tcount = 0; 6146 } 6147 else 6148 { 6149 if (remote_debug) 6150 { 6151 if (!started_error_output) 6152 { 6153 started_error_output = 1; 6154 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: "); 6155 } 6156 fputc_unfiltered (ch & 0177, gdb_stdlog); 6157 fprintf_unfiltered (gdb_stdlog, "%s", rs->buf); 6158 } 6159 } 6160 continue; 6161 } 6162 /* fall-through */ 6163 default: 6164 if (remote_debug) 6165 { 6166 if (!started_error_output) 6167 { 6168 started_error_output = 1; 6169 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: "); 6170 } 6171 fputc_unfiltered (ch & 0177, gdb_stdlog); 6172 } 6173 continue; 6174 } 6175 break; /* Here to retransmit. */ 6176 } 6177 6178 #if 0 6179 /* This is wrong. If doing a long backtrace, the user should be 6180 able to get out next time we call QUIT, without anything as 6181 violent as interrupt_query. If we want to provide a way out of 6182 here without getting to the next QUIT, it should be based on 6183 hitting ^C twice as in remote_wait. */ 6184 if (quit_flag) 6185 { 6186 quit_flag = 0; 6187 interrupt_query (); 6188 } 6189 #endif 6190 } 6191 return 0; 6192 } 6193 6194 /* Come here after finding the start of a frame when we expected an 6195 ack. Do our best to discard the rest of this packet. */ 6196 6197 static void 6198 skip_frame (void) 6199 { 6200 int c; 6201 6202 while (1) 6203 { 6204 c = readchar (remote_timeout); 6205 switch (c) 6206 { 6207 case SERIAL_TIMEOUT: 6208 /* Nothing we can do. */ 6209 return; 6210 case '#': 6211 /* Discard the two bytes of checksum and stop. */ 6212 c = readchar (remote_timeout); 6213 if (c >= 0) 6214 c = readchar (remote_timeout); 6215 6216 return; 6217 case '*': /* Run length encoding. */ 6218 /* Discard the repeat count. */ 6219 c = readchar (remote_timeout); 6220 if (c < 0) 6221 return; 6222 break; 6223 default: 6224 /* A regular character. */ 6225 break; 6226 } 6227 } 6228 } 6229 6230 /* Come here after finding the start of the frame. Collect the rest 6231 into *BUF, verifying the checksum, length, and handling run-length 6232 compression. NUL terminate the buffer. If there is not enough room, 6233 expand *BUF using xrealloc. 6234 6235 Returns -1 on error, number of characters in buffer (ignoring the 6236 trailing NULL) on success. (could be extended to return one of the 6237 SERIAL status indications). */ 6238 6239 static long 6240 read_frame (char **buf_p, 6241 long *sizeof_buf) 6242 { 6243 unsigned char csum; 6244 long bc; 6245 int c; 6246 char *buf = *buf_p; 6247 struct remote_state *rs = get_remote_state (); 6248 6249 csum = 0; 6250 bc = 0; 6251 6252 while (1) 6253 { 6254 c = readchar (remote_timeout); 6255 switch (c) 6256 { 6257 case SERIAL_TIMEOUT: 6258 if (remote_debug) 6259 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog); 6260 return -1; 6261 case '$': 6262 if (remote_debug) 6263 fputs_filtered ("Saw new packet start in middle of old one\n", 6264 gdb_stdlog); 6265 return -1; /* Start a new packet, count retries. */ 6266 case '#': 6267 { 6268 unsigned char pktcsum; 6269 int check_0 = 0; 6270 int check_1 = 0; 6271 6272 buf[bc] = '\0'; 6273 6274 check_0 = readchar (remote_timeout); 6275 if (check_0 >= 0) 6276 check_1 = readchar (remote_timeout); 6277 6278 if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT) 6279 { 6280 if (remote_debug) 6281 fputs_filtered ("Timeout in checksum, retrying\n", 6282 gdb_stdlog); 6283 return -1; 6284 } 6285 else if (check_0 < 0 || check_1 < 0) 6286 { 6287 if (remote_debug) 6288 fputs_filtered ("Communication error in checksum\n", 6289 gdb_stdlog); 6290 return -1; 6291 } 6292 6293 /* Don't recompute the checksum; with no ack packets we 6294 don't have any way to indicate a packet retransmission 6295 is necessary. */ 6296 if (rs->noack_mode) 6297 return bc; 6298 6299 pktcsum = (fromhex (check_0) << 4) | fromhex (check_1); 6300 if (csum == pktcsum) 6301 return bc; 6302 6303 if (remote_debug) 6304 { 6305 struct cleanup *old_chain; 6306 char *str; 6307 6308 str = escape_buffer (buf, bc); 6309 old_chain = make_cleanup (xfree, str); 6310 fprintf_unfiltered (gdb_stdlog, 6311 "\ 6312 Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n", 6313 pktcsum, csum, str); 6314 do_cleanups (old_chain); 6315 } 6316 /* Number of characters in buffer ignoring trailing 6317 NULL. */ 6318 return -1; 6319 } 6320 case '*': /* Run length encoding. */ 6321 { 6322 int repeat; 6323 csum += c; 6324 6325 c = readchar (remote_timeout); 6326 csum += c; 6327 repeat = c - ' ' + 3; /* Compute repeat count. */ 6328 6329 /* The character before ``*'' is repeated. */ 6330 6331 if (repeat > 0 && repeat <= 255 && bc > 0) 6332 { 6333 if (bc + repeat - 1 >= *sizeof_buf - 1) 6334 { 6335 /* Make some more room in the buffer. */ 6336 *sizeof_buf += repeat; 6337 *buf_p = xrealloc (*buf_p, *sizeof_buf); 6338 buf = *buf_p; 6339 } 6340 6341 memset (&buf[bc], buf[bc - 1], repeat); 6342 bc += repeat; 6343 continue; 6344 } 6345 6346 buf[bc] = '\0'; 6347 printf_filtered (_("Invalid run length encoding: %s\n"), buf); 6348 return -1; 6349 } 6350 default: 6351 if (bc >= *sizeof_buf - 1) 6352 { 6353 /* Make some more room in the buffer. */ 6354 *sizeof_buf *= 2; 6355 *buf_p = xrealloc (*buf_p, *sizeof_buf); 6356 buf = *buf_p; 6357 } 6358 6359 buf[bc++] = c; 6360 csum += c; 6361 continue; 6362 } 6363 } 6364 } 6365 6366 /* Read a packet from the remote machine, with error checking, and 6367 store it in *BUF. Resize *BUF using xrealloc if necessary to hold 6368 the result, and update *SIZEOF_BUF. If FOREVER, wait forever 6369 rather than timing out; this is used (in synchronous mode) to wait 6370 for a target that is is executing user code to stop. */ 6371 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we 6372 don't have to change all the calls to getpkt to deal with the 6373 return value, because at the moment I don't know what the right 6374 thing to do it for those. */ 6375 void 6376 getpkt (char **buf, 6377 long *sizeof_buf, 6378 int forever) 6379 { 6380 int timed_out; 6381 6382 timed_out = getpkt_sane (buf, sizeof_buf, forever); 6383 } 6384 6385 6386 /* Read a packet from the remote machine, with error checking, and 6387 store it in *BUF. Resize *BUF using xrealloc if necessary to hold 6388 the result, and update *SIZEOF_BUF. If FOREVER, wait forever 6389 rather than timing out; this is used (in synchronous mode) to wait 6390 for a target that is is executing user code to stop. If FOREVER == 6391 0, this function is allowed to time out gracefully and return an 6392 indication of this to the caller. Otherwise return the number of 6393 bytes read. If EXPECTING_NOTIF, consider receiving a notification 6394 enough reason to return to the caller. */ 6395 6396 static int 6397 getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, int forever, 6398 int expecting_notif) 6399 { 6400 struct remote_state *rs = get_remote_state (); 6401 int c; 6402 int tries; 6403 int timeout; 6404 int val = -1; 6405 6406 /* We're reading a new response. Make sure we don't look at a 6407 previously cached response. */ 6408 rs->cached_wait_status = 0; 6409 6410 strcpy (*buf, "timeout"); 6411 6412 if (forever) 6413 timeout = watchdog > 0 ? watchdog : -1; 6414 else if (expecting_notif) 6415 timeout = 0; /* There should already be a char in the buffer. If 6416 not, bail out. */ 6417 else 6418 timeout = remote_timeout; 6419 6420 #define MAX_TRIES 3 6421 6422 /* Process any number of notifications, and then return when 6423 we get a packet. */ 6424 for (;;) 6425 { 6426 /* If we get a timeout or bad checksm, retry up to MAX_TRIES 6427 times. */ 6428 for (tries = 1; tries <= MAX_TRIES; tries++) 6429 { 6430 /* This can loop forever if the remote side sends us 6431 characters continuously, but if it pauses, we'll get 6432 SERIAL_TIMEOUT from readchar because of timeout. Then 6433 we'll count that as a retry. 6434 6435 Note that even when forever is set, we will only wait 6436 forever prior to the start of a packet. After that, we 6437 expect characters to arrive at a brisk pace. They should 6438 show up within remote_timeout intervals. */ 6439 do 6440 c = readchar (timeout); 6441 while (c != SERIAL_TIMEOUT && c != '$' && c != '%'); 6442 6443 if (c == SERIAL_TIMEOUT) 6444 { 6445 if (expecting_notif) 6446 return -1; /* Don't complain, it's normal to not get 6447 anything in this case. */ 6448 6449 if (forever) /* Watchdog went off? Kill the target. */ 6450 { 6451 QUIT; 6452 pop_target (); 6453 error (_("Watchdog timeout has expired. Target detached.")); 6454 } 6455 if (remote_debug) 6456 fputs_filtered ("Timed out.\n", gdb_stdlog); 6457 } 6458 else 6459 { 6460 /* We've found the start of a packet or notification. 6461 Now collect the data. */ 6462 val = read_frame (buf, sizeof_buf); 6463 if (val >= 0) 6464 break; 6465 } 6466 6467 serial_write (remote_desc, "-", 1); 6468 } 6469 6470 if (tries > MAX_TRIES) 6471 { 6472 /* We have tried hard enough, and just can't receive the 6473 packet/notification. Give up. */ 6474 printf_unfiltered (_("Ignoring packet error, continuing...\n")); 6475 6476 /* Skip the ack char if we're in no-ack mode. */ 6477 if (!rs->noack_mode) 6478 serial_write (remote_desc, "+", 1); 6479 return -1; 6480 } 6481 6482 /* If we got an ordinary packet, return that to our caller. */ 6483 if (c == '$') 6484 { 6485 if (remote_debug) 6486 { 6487 struct cleanup *old_chain; 6488 char *str; 6489 6490 str = escape_buffer (*buf, val); 6491 old_chain = make_cleanup (xfree, str); 6492 fprintf_unfiltered (gdb_stdlog, "Packet received: %s\n", str); 6493 do_cleanups (old_chain); 6494 } 6495 6496 /* Skip the ack char if we're in no-ack mode. */ 6497 if (!rs->noack_mode) 6498 serial_write (remote_desc, "+", 1); 6499 return val; 6500 } 6501 6502 /* If we got a notification, handle it, and go back to looking 6503 for a packet. */ 6504 else 6505 { 6506 gdb_assert (c == '%'); 6507 6508 if (remote_debug) 6509 { 6510 struct cleanup *old_chain; 6511 char *str; 6512 6513 str = escape_buffer (*buf, val); 6514 old_chain = make_cleanup (xfree, str); 6515 fprintf_unfiltered (gdb_stdlog, 6516 " Notification received: %s\n", 6517 str); 6518 do_cleanups (old_chain); 6519 } 6520 6521 handle_notification (*buf, val); 6522 6523 /* Notifications require no acknowledgement. */ 6524 6525 if (expecting_notif) 6526 return -1; 6527 } 6528 } 6529 } 6530 6531 static int 6532 getpkt_sane (char **buf, long *sizeof_buf, int forever) 6533 { 6534 return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 0); 6535 } 6536 6537 static int 6538 getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever) 6539 { 6540 return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 1); 6541 } 6542 6543 6544 static void 6545 remote_kill (struct target_ops *ops) 6546 { 6547 /* Use catch_errors so the user can quit from gdb even when we 6548 aren't on speaking terms with the remote system. */ 6549 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR); 6550 6551 /* Don't wait for it to die. I'm not really sure it matters whether 6552 we do or not. For the existing stubs, kill is a noop. */ 6553 target_mourn_inferior (); 6554 } 6555 6556 static int 6557 remote_vkill (int pid, struct remote_state *rs) 6558 { 6559 if (remote_protocol_packets[PACKET_vKill].support == PACKET_DISABLE) 6560 return -1; 6561 6562 /* Tell the remote target to detach. */ 6563 sprintf (rs->buf, "vKill;%x", pid); 6564 putpkt (rs->buf); 6565 getpkt (&rs->buf, &rs->buf_size, 0); 6566 6567 if (packet_ok (rs->buf, 6568 &remote_protocol_packets[PACKET_vKill]) == PACKET_OK) 6569 return 0; 6570 else if (remote_protocol_packets[PACKET_vKill].support == PACKET_DISABLE) 6571 return -1; 6572 else 6573 return 1; 6574 } 6575 6576 static void 6577 extended_remote_kill (struct target_ops *ops) 6578 { 6579 int res; 6580 int pid = ptid_get_pid (inferior_ptid); 6581 struct remote_state *rs = get_remote_state (); 6582 6583 res = remote_vkill (pid, rs); 6584 if (res == -1 && !remote_multi_process_p (rs)) 6585 { 6586 /* Don't try 'k' on a multi-process aware stub -- it has no way 6587 to specify the pid. */ 6588 6589 putpkt ("k"); 6590 #if 0 6591 getpkt (&rs->buf, &rs->buf_size, 0); 6592 if (rs->buf[0] != 'O' || rs->buf[0] != 'K') 6593 res = 1; 6594 #else 6595 /* Don't wait for it to die. I'm not really sure it matters whether 6596 we do or not. For the existing stubs, kill is a noop. */ 6597 res = 0; 6598 #endif 6599 } 6600 6601 if (res != 0) 6602 error (_("Can't kill process")); 6603 6604 target_mourn_inferior (); 6605 } 6606 6607 static void 6608 remote_mourn (struct target_ops *ops) 6609 { 6610 remote_mourn_1 (ops); 6611 } 6612 6613 /* Worker function for remote_mourn. */ 6614 static void 6615 remote_mourn_1 (struct target_ops *target) 6616 { 6617 unpush_target (target); 6618 6619 /* remote_close takes care of doing most of the clean up. */ 6620 generic_mourn_inferior (); 6621 } 6622 6623 static void 6624 extended_remote_mourn_1 (struct target_ops *target) 6625 { 6626 struct remote_state *rs = get_remote_state (); 6627 6628 /* In case we got here due to an error, but we're going to stay 6629 connected. */ 6630 rs->waiting_for_stop_reply = 0; 6631 6632 /* We're no longer interested in these events. */ 6633 discard_pending_stop_replies (ptid_get_pid (inferior_ptid)); 6634 6635 /* If the current general thread belonged to the process we just 6636 detached from or has exited, the remote side current general 6637 thread becomes undefined. Considering a case like this: 6638 6639 - We just got here due to a detach. 6640 - The process that we're detaching from happens to immediately 6641 report a global breakpoint being hit in non-stop mode, in the 6642 same thread we had selected before. 6643 - GDB attaches to this process again. 6644 - This event happens to be the next event we handle. 6645 6646 GDB would consider that the current general thread didn't need to 6647 be set on the stub side (with Hg), since for all it knew, 6648 GENERAL_THREAD hadn't changed. 6649 6650 Notice that although in all-stop mode, the remote server always 6651 sets the current thread to the thread reporting the stop event, 6652 that doesn't happen in non-stop mode; in non-stop, the stub *must 6653 not* change the current thread when reporting a breakpoint hit, 6654 due to the decoupling of event reporting and event handling. 6655 6656 To keep things simple, we always invalidate our notion of the 6657 current thread. */ 6658 record_currthread (minus_one_ptid); 6659 6660 /* Unlike "target remote", we do not want to unpush the target; then 6661 the next time the user says "run", we won't be connected. */ 6662 6663 /* Call common code to mark the inferior as not running. */ 6664 generic_mourn_inferior (); 6665 6666 if (!have_inferiors ()) 6667 { 6668 if (!remote_multi_process_p (rs)) 6669 { 6670 /* Check whether the target is running now - some remote stubs 6671 automatically restart after kill. */ 6672 putpkt ("?"); 6673 getpkt (&rs->buf, &rs->buf_size, 0); 6674 6675 if (rs->buf[0] == 'S' || rs->buf[0] == 'T') 6676 { 6677 /* Assume that the target has been restarted. Set inferior_ptid 6678 so that bits of core GDB realizes there's something here, e.g., 6679 so that the user can say "kill" again. */ 6680 inferior_ptid = magic_null_ptid; 6681 } 6682 } 6683 } 6684 } 6685 6686 static void 6687 extended_remote_mourn (struct target_ops *ops) 6688 { 6689 extended_remote_mourn_1 (ops); 6690 } 6691 6692 static int 6693 extended_remote_run (char *args) 6694 { 6695 struct remote_state *rs = get_remote_state (); 6696 int len; 6697 6698 /* If the user has disabled vRun support, or we have detected that 6699 support is not available, do not try it. */ 6700 if (remote_protocol_packets[PACKET_vRun].support == PACKET_DISABLE) 6701 return -1; 6702 6703 strcpy (rs->buf, "vRun;"); 6704 len = strlen (rs->buf); 6705 6706 if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ()) 6707 error (_("Remote file name too long for run packet")); 6708 len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf + len, 0); 6709 6710 gdb_assert (args != NULL); 6711 if (*args) 6712 { 6713 struct cleanup *back_to; 6714 int i; 6715 char **argv; 6716 6717 argv = gdb_buildargv (args); 6718 back_to = make_cleanup ((void (*) (void *)) freeargv, argv); 6719 for (i = 0; argv[i] != NULL; i++) 6720 { 6721 if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ()) 6722 error (_("Argument list too long for run packet")); 6723 rs->buf[len++] = ';'; 6724 len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf + len, 0); 6725 } 6726 do_cleanups (back_to); 6727 } 6728 6729 rs->buf[len++] = '\0'; 6730 6731 putpkt (rs->buf); 6732 getpkt (&rs->buf, &rs->buf_size, 0); 6733 6734 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun]) == PACKET_OK) 6735 { 6736 /* We have a wait response; we don't need it, though. All is well. */ 6737 return 0; 6738 } 6739 else if (remote_protocol_packets[PACKET_vRun].support == PACKET_DISABLE) 6740 /* It wasn't disabled before, but it is now. */ 6741 return -1; 6742 else 6743 { 6744 if (remote_exec_file[0] == '\0') 6745 error (_("Running the default executable on the remote target failed; " 6746 "try \"set remote exec-file\"?")); 6747 else 6748 error (_("Running \"%s\" on the remote target failed"), 6749 remote_exec_file); 6750 } 6751 } 6752 6753 /* In the extended protocol we want to be able to do things like 6754 "run" and have them basically work as expected. So we need 6755 a special create_inferior function. We support changing the 6756 executable file and the command line arguments, but not the 6757 environment. */ 6758 6759 static void 6760 extended_remote_create_inferior_1 (char *exec_file, char *args, 6761 char **env, int from_tty) 6762 { 6763 /* If running asynchronously, register the target file descriptor 6764 with the event loop. */ 6765 if (target_can_async_p ()) 6766 target_async (inferior_event_handler, 0); 6767 6768 /* Now restart the remote server. */ 6769 if (extended_remote_run (args) == -1) 6770 { 6771 /* vRun was not supported. Fail if we need it to do what the 6772 user requested. */ 6773 if (remote_exec_file[0]) 6774 error (_("Remote target does not support \"set remote exec-file\"")); 6775 if (args[0]) 6776 error (_("Remote target does not support \"set args\" or run <ARGS>")); 6777 6778 /* Fall back to "R". */ 6779 extended_remote_restart (); 6780 } 6781 6782 /* Clean up from the last time we ran, before we mark the target 6783 running again. This will mark breakpoints uninserted, and 6784 get_offsets may insert breakpoints. */ 6785 init_thread_list (); 6786 init_wait_for_inferior (); 6787 6788 /* Now mark the inferior as running before we do anything else. */ 6789 inferior_ptid = magic_null_ptid; 6790 6791 /* Now, if we have thread information, update inferior_ptid. */ 6792 inferior_ptid = remote_current_thread (inferior_ptid); 6793 6794 remote_add_inferior (ptid_get_pid (inferior_ptid), 0); 6795 add_thread_silent (inferior_ptid); 6796 6797 /* Get updated offsets, if the stub uses qOffsets. */ 6798 get_offsets (); 6799 } 6800 6801 static void 6802 extended_remote_create_inferior (struct target_ops *ops, 6803 char *exec_file, char *args, 6804 char **env, int from_tty) 6805 { 6806 extended_remote_create_inferior_1 (exec_file, args, env, from_tty); 6807 } 6808 6809 6810 /* Insert a breakpoint. On targets that have software breakpoint 6811 support, we ask the remote target to do the work; on targets 6812 which don't, we insert a traditional memory breakpoint. */ 6813 6814 static int 6815 remote_insert_breakpoint (struct gdbarch *gdbarch, 6816 struct bp_target_info *bp_tgt) 6817 { 6818 /* Try the "Z" s/w breakpoint packet if it is not already disabled. 6819 If it succeeds, then set the support to PACKET_ENABLE. If it 6820 fails, and the user has explicitly requested the Z support then 6821 report an error, otherwise, mark it disabled and go on. */ 6822 6823 if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE) 6824 { 6825 CORE_ADDR addr = bp_tgt->placed_address; 6826 struct remote_state *rs; 6827 char *p; 6828 int bpsize; 6829 6830 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bpsize); 6831 6832 rs = get_remote_state (); 6833 p = rs->buf; 6834 6835 *(p++) = 'Z'; 6836 *(p++) = '0'; 6837 *(p++) = ','; 6838 addr = (ULONGEST) remote_address_masked (addr); 6839 p += hexnumstr (p, addr); 6840 sprintf (p, ",%d", bpsize); 6841 6842 putpkt (rs->buf); 6843 getpkt (&rs->buf, &rs->buf_size, 0); 6844 6845 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0])) 6846 { 6847 case PACKET_ERROR: 6848 return -1; 6849 case PACKET_OK: 6850 bp_tgt->placed_address = addr; 6851 bp_tgt->placed_size = bpsize; 6852 return 0; 6853 case PACKET_UNKNOWN: 6854 break; 6855 } 6856 } 6857 6858 return memory_insert_breakpoint (gdbarch, bp_tgt); 6859 } 6860 6861 static int 6862 remote_remove_breakpoint (struct gdbarch *gdbarch, 6863 struct bp_target_info *bp_tgt) 6864 { 6865 CORE_ADDR addr = bp_tgt->placed_address; 6866 struct remote_state *rs = get_remote_state (); 6867 6868 if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE) 6869 { 6870 char *p = rs->buf; 6871 6872 *(p++) = 'z'; 6873 *(p++) = '0'; 6874 *(p++) = ','; 6875 6876 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address); 6877 p += hexnumstr (p, addr); 6878 sprintf (p, ",%d", bp_tgt->placed_size); 6879 6880 putpkt (rs->buf); 6881 getpkt (&rs->buf, &rs->buf_size, 0); 6882 6883 return (rs->buf[0] == 'E'); 6884 } 6885 6886 return memory_remove_breakpoint (gdbarch, bp_tgt); 6887 } 6888 6889 static int 6890 watchpoint_to_Z_packet (int type) 6891 { 6892 switch (type) 6893 { 6894 case hw_write: 6895 return Z_PACKET_WRITE_WP; 6896 break; 6897 case hw_read: 6898 return Z_PACKET_READ_WP; 6899 break; 6900 case hw_access: 6901 return Z_PACKET_ACCESS_WP; 6902 break; 6903 default: 6904 internal_error (__FILE__, __LINE__, 6905 _("hw_bp_to_z: bad watchpoint type %d"), type); 6906 } 6907 } 6908 6909 static int 6910 remote_insert_watchpoint (CORE_ADDR addr, int len, int type) 6911 { 6912 struct remote_state *rs = get_remote_state (); 6913 char *p; 6914 enum Z_packet_type packet = watchpoint_to_Z_packet (type); 6915 6916 if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE) 6917 return -1; 6918 6919 sprintf (rs->buf, "Z%x,", packet); 6920 p = strchr (rs->buf, '\0'); 6921 addr = remote_address_masked (addr); 6922 p += hexnumstr (p, (ULONGEST) addr); 6923 sprintf (p, ",%x", len); 6924 6925 putpkt (rs->buf); 6926 getpkt (&rs->buf, &rs->buf_size, 0); 6927 6928 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet])) 6929 { 6930 case PACKET_ERROR: 6931 case PACKET_UNKNOWN: 6932 return -1; 6933 case PACKET_OK: 6934 return 0; 6935 } 6936 internal_error (__FILE__, __LINE__, 6937 _("remote_insert_watchpoint: reached end of function")); 6938 } 6939 6940 6941 static int 6942 remote_remove_watchpoint (CORE_ADDR addr, int len, int type) 6943 { 6944 struct remote_state *rs = get_remote_state (); 6945 char *p; 6946 enum Z_packet_type packet = watchpoint_to_Z_packet (type); 6947 6948 if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE) 6949 return -1; 6950 6951 sprintf (rs->buf, "z%x,", packet); 6952 p = strchr (rs->buf, '\0'); 6953 addr = remote_address_masked (addr); 6954 p += hexnumstr (p, (ULONGEST) addr); 6955 sprintf (p, ",%x", len); 6956 putpkt (rs->buf); 6957 getpkt (&rs->buf, &rs->buf_size, 0); 6958 6959 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet])) 6960 { 6961 case PACKET_ERROR: 6962 case PACKET_UNKNOWN: 6963 return -1; 6964 case PACKET_OK: 6965 return 0; 6966 } 6967 internal_error (__FILE__, __LINE__, 6968 _("remote_remove_watchpoint: reached end of function")); 6969 } 6970 6971 6972 int remote_hw_watchpoint_limit = -1; 6973 int remote_hw_breakpoint_limit = -1; 6974 6975 static int 6976 remote_check_watch_resources (int type, int cnt, int ot) 6977 { 6978 if (type == bp_hardware_breakpoint) 6979 { 6980 if (remote_hw_breakpoint_limit == 0) 6981 return 0; 6982 else if (remote_hw_breakpoint_limit < 0) 6983 return 1; 6984 else if (cnt <= remote_hw_breakpoint_limit) 6985 return 1; 6986 } 6987 else 6988 { 6989 if (remote_hw_watchpoint_limit == 0) 6990 return 0; 6991 else if (remote_hw_watchpoint_limit < 0) 6992 return 1; 6993 else if (ot) 6994 return -1; 6995 else if (cnt <= remote_hw_watchpoint_limit) 6996 return 1; 6997 } 6998 return -1; 6999 } 7000 7001 static int 7002 remote_stopped_by_watchpoint (void) 7003 { 7004 return remote_stopped_by_watchpoint_p; 7005 } 7006 7007 static int 7008 remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p) 7009 { 7010 int rc = 0; 7011 if (remote_stopped_by_watchpoint ()) 7012 { 7013 *addr_p = remote_watch_data_address; 7014 rc = 1; 7015 } 7016 7017 return rc; 7018 } 7019 7020 7021 static int 7022 remote_insert_hw_breakpoint (struct gdbarch *gdbarch, 7023 struct bp_target_info *bp_tgt) 7024 { 7025 CORE_ADDR addr; 7026 struct remote_state *rs; 7027 char *p; 7028 7029 /* The length field should be set to the size of a breakpoint 7030 instruction, even though we aren't inserting one ourselves. */ 7031 7032 gdbarch_breakpoint_from_pc 7033 (gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size); 7034 7035 if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE) 7036 return -1; 7037 7038 rs = get_remote_state (); 7039 p = rs->buf; 7040 7041 *(p++) = 'Z'; 7042 *(p++) = '1'; 7043 *(p++) = ','; 7044 7045 addr = remote_address_masked (bp_tgt->placed_address); 7046 p += hexnumstr (p, (ULONGEST) addr); 7047 sprintf (p, ",%x", bp_tgt->placed_size); 7048 7049 putpkt (rs->buf); 7050 getpkt (&rs->buf, &rs->buf_size, 0); 7051 7052 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1])) 7053 { 7054 case PACKET_ERROR: 7055 case PACKET_UNKNOWN: 7056 return -1; 7057 case PACKET_OK: 7058 return 0; 7059 } 7060 internal_error (__FILE__, __LINE__, 7061 _("remote_insert_hw_breakpoint: reached end of function")); 7062 } 7063 7064 7065 static int 7066 remote_remove_hw_breakpoint (struct gdbarch *gdbarch, 7067 struct bp_target_info *bp_tgt) 7068 { 7069 CORE_ADDR addr; 7070 struct remote_state *rs = get_remote_state (); 7071 char *p = rs->buf; 7072 7073 if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE) 7074 return -1; 7075 7076 *(p++) = 'z'; 7077 *(p++) = '1'; 7078 *(p++) = ','; 7079 7080 addr = remote_address_masked (bp_tgt->placed_address); 7081 p += hexnumstr (p, (ULONGEST) addr); 7082 sprintf (p, ",%x", bp_tgt->placed_size); 7083 7084 putpkt (rs->buf); 7085 getpkt (&rs->buf, &rs->buf_size, 0); 7086 7087 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1])) 7088 { 7089 case PACKET_ERROR: 7090 case PACKET_UNKNOWN: 7091 return -1; 7092 case PACKET_OK: 7093 return 0; 7094 } 7095 internal_error (__FILE__, __LINE__, 7096 _("remote_remove_hw_breakpoint: reached end of function")); 7097 } 7098 7099 /* Table used by the crc32 function to calcuate the checksum. */ 7100 7101 static unsigned long crc32_table[256] = 7102 {0, 0}; 7103 7104 static unsigned long 7105 crc32 (unsigned char *buf, int len, unsigned int crc) 7106 { 7107 if (!crc32_table[1]) 7108 { 7109 /* Initialize the CRC table and the decoding table. */ 7110 int i, j; 7111 unsigned int c; 7112 7113 for (i = 0; i < 256; i++) 7114 { 7115 for (c = i << 24, j = 8; j > 0; --j) 7116 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1); 7117 crc32_table[i] = c; 7118 } 7119 } 7120 7121 while (len--) 7122 { 7123 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255]; 7124 buf++; 7125 } 7126 return crc; 7127 } 7128 7129 /* compare-sections command 7130 7131 With no arguments, compares each loadable section in the exec bfd 7132 with the same memory range on the target, and reports mismatches. 7133 Useful for verifying the image on the target against the exec file. 7134 Depends on the target understanding the new "qCRC:" request. */ 7135 7136 /* FIXME: cagney/1999-10-26: This command should be broken down into a 7137 target method (target verify memory) and generic version of the 7138 actual command. This will allow other high-level code (especially 7139 generic_load()) to make use of this target functionality. */ 7140 7141 static void 7142 compare_sections_command (char *args, int from_tty) 7143 { 7144 struct remote_state *rs = get_remote_state (); 7145 asection *s; 7146 unsigned long host_crc, target_crc; 7147 struct cleanup *old_chain; 7148 char *tmp; 7149 char *sectdata; 7150 const char *sectname; 7151 bfd_size_type size; 7152 bfd_vma lma; 7153 int matched = 0; 7154 int mismatched = 0; 7155 7156 if (!exec_bfd) 7157 error (_("command cannot be used without an exec file")); 7158 if (!current_target.to_shortname || 7159 strcmp (current_target.to_shortname, "remote") != 0) 7160 error (_("command can only be used with remote target")); 7161 7162 for (s = exec_bfd->sections; s; s = s->next) 7163 { 7164 if (!(s->flags & SEC_LOAD)) 7165 continue; /* skip non-loadable section */ 7166 7167 size = bfd_get_section_size (s); 7168 if (size == 0) 7169 continue; /* skip zero-length section */ 7170 7171 sectname = bfd_get_section_name (exec_bfd, s); 7172 if (args && strcmp (args, sectname) != 0) 7173 continue; /* not the section selected by user */ 7174 7175 matched = 1; /* do this section */ 7176 lma = s->lma; 7177 /* FIXME: assumes lma can fit into long. */ 7178 xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx", 7179 (long) lma, (long) size); 7180 putpkt (rs->buf); 7181 7182 /* Be clever; compute the host_crc before waiting for target 7183 reply. */ 7184 sectdata = xmalloc (size); 7185 old_chain = make_cleanup (xfree, sectdata); 7186 bfd_get_section_contents (exec_bfd, s, sectdata, 0, size); 7187 host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff); 7188 7189 getpkt (&rs->buf, &rs->buf_size, 0); 7190 if (rs->buf[0] == 'E') 7191 error (_("target memory fault, section %s, range %s -- %s"), sectname, 7192 paddress (target_gdbarch, lma), 7193 paddress (target_gdbarch, lma + size)); 7194 if (rs->buf[0] != 'C') 7195 error (_("remote target does not support this operation")); 7196 7197 for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++) 7198 target_crc = target_crc * 16 + fromhex (*tmp); 7199 7200 printf_filtered ("Section %s, range %s -- %s: ", sectname, 7201 paddress (target_gdbarch, lma), 7202 paddress (target_gdbarch, lma + size)); 7203 if (host_crc == target_crc) 7204 printf_filtered ("matched.\n"); 7205 else 7206 { 7207 printf_filtered ("MIS-MATCHED!\n"); 7208 mismatched++; 7209 } 7210 7211 do_cleanups (old_chain); 7212 } 7213 if (mismatched > 0) 7214 warning (_("One or more sections of the remote executable does not match\n\ 7215 the loaded file\n")); 7216 if (args && !matched) 7217 printf_filtered (_("No loaded section named '%s'.\n"), args); 7218 } 7219 7220 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET 7221 into remote target. The number of bytes written to the remote 7222 target is returned, or -1 for error. */ 7223 7224 static LONGEST 7225 remote_write_qxfer (struct target_ops *ops, const char *object_name, 7226 const char *annex, const gdb_byte *writebuf, 7227 ULONGEST offset, LONGEST len, 7228 struct packet_config *packet) 7229 { 7230 int i, buf_len; 7231 ULONGEST n; 7232 struct remote_state *rs = get_remote_state (); 7233 int max_size = get_memory_write_packet_size (); 7234 7235 if (packet->support == PACKET_DISABLE) 7236 return -1; 7237 7238 /* Insert header. */ 7239 i = snprintf (rs->buf, max_size, 7240 "qXfer:%s:write:%s:%s:", 7241 object_name, annex ? annex : "", 7242 phex_nz (offset, sizeof offset)); 7243 max_size -= (i + 1); 7244 7245 /* Escape as much data as fits into rs->buf. */ 7246 buf_len = remote_escape_output 7247 (writebuf, len, (rs->buf + i), &max_size, max_size); 7248 7249 if (putpkt_binary (rs->buf, i + buf_len) < 0 7250 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0 7251 || packet_ok (rs->buf, packet) != PACKET_OK) 7252 return -1; 7253 7254 unpack_varlen_hex (rs->buf, &n); 7255 return n; 7256 } 7257 7258 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet. 7259 Data at OFFSET, of up to LEN bytes, is read into READBUF; the 7260 number of bytes read is returned, or 0 for EOF, or -1 for error. 7261 The number of bytes read may be less than LEN without indicating an 7262 EOF. PACKET is checked and updated to indicate whether the remote 7263 target supports this object. */ 7264 7265 static LONGEST 7266 remote_read_qxfer (struct target_ops *ops, const char *object_name, 7267 const char *annex, 7268 gdb_byte *readbuf, ULONGEST offset, LONGEST len, 7269 struct packet_config *packet) 7270 { 7271 static char *finished_object; 7272 static char *finished_annex; 7273 static ULONGEST finished_offset; 7274 7275 struct remote_state *rs = get_remote_state (); 7276 LONGEST i, n, packet_len; 7277 7278 if (packet->support == PACKET_DISABLE) 7279 return -1; 7280 7281 /* Check whether we've cached an end-of-object packet that matches 7282 this request. */ 7283 if (finished_object) 7284 { 7285 if (strcmp (object_name, finished_object) == 0 7286 && strcmp (annex ? annex : "", finished_annex) == 0 7287 && offset == finished_offset) 7288 return 0; 7289 7290 /* Otherwise, we're now reading something different. Discard 7291 the cache. */ 7292 xfree (finished_object); 7293 xfree (finished_annex); 7294 finished_object = NULL; 7295 finished_annex = NULL; 7296 } 7297 7298 /* Request only enough to fit in a single packet. The actual data 7299 may not, since we don't know how much of it will need to be escaped; 7300 the target is free to respond with slightly less data. We subtract 7301 five to account for the response type and the protocol frame. */ 7302 n = min (get_remote_packet_size () - 5, len); 7303 snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s", 7304 object_name, annex ? annex : "", 7305 phex_nz (offset, sizeof offset), 7306 phex_nz (n, sizeof n)); 7307 i = putpkt (rs->buf); 7308 if (i < 0) 7309 return -1; 7310 7311 rs->buf[0] = '\0'; 7312 packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0); 7313 if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK) 7314 return -1; 7315 7316 if (rs->buf[0] != 'l' && rs->buf[0] != 'm') 7317 error (_("Unknown remote qXfer reply: %s"), rs->buf); 7318 7319 /* 'm' means there is (or at least might be) more data after this 7320 batch. That does not make sense unless there's at least one byte 7321 of data in this reply. */ 7322 if (rs->buf[0] == 'm' && packet_len == 1) 7323 error (_("Remote qXfer reply contained no data.")); 7324 7325 /* Got some data. */ 7326 i = remote_unescape_input (rs->buf + 1, packet_len - 1, readbuf, n); 7327 7328 /* 'l' is an EOF marker, possibly including a final block of data, 7329 or possibly empty. If we have the final block of a non-empty 7330 object, record this fact to bypass a subsequent partial read. */ 7331 if (rs->buf[0] == 'l' && offset + i > 0) 7332 { 7333 finished_object = xstrdup (object_name); 7334 finished_annex = xstrdup (annex ? annex : ""); 7335 finished_offset = offset + i; 7336 } 7337 7338 return i; 7339 } 7340 7341 static LONGEST 7342 remote_xfer_partial (struct target_ops *ops, enum target_object object, 7343 const char *annex, gdb_byte *readbuf, 7344 const gdb_byte *writebuf, ULONGEST offset, LONGEST len) 7345 { 7346 struct remote_state *rs; 7347 int i; 7348 char *p2; 7349 char query_type; 7350 7351 set_general_thread (inferior_ptid); 7352 7353 rs = get_remote_state (); 7354 7355 /* Handle memory using the standard memory routines. */ 7356 if (object == TARGET_OBJECT_MEMORY) 7357 { 7358 int xfered; 7359 errno = 0; 7360 7361 /* If the remote target is connected but not running, we should 7362 pass this request down to a lower stratum (e.g. the executable 7363 file). */ 7364 if (!target_has_execution) 7365 return 0; 7366 7367 if (writebuf != NULL) 7368 xfered = remote_write_bytes (offset, writebuf, len); 7369 else 7370 xfered = remote_read_bytes (offset, readbuf, len); 7371 7372 if (xfered > 0) 7373 return xfered; 7374 else if (xfered == 0 && errno == 0) 7375 return 0; 7376 else 7377 return -1; 7378 } 7379 7380 /* Handle SPU memory using qxfer packets. */ 7381 if (object == TARGET_OBJECT_SPU) 7382 { 7383 if (readbuf) 7384 return remote_read_qxfer (ops, "spu", annex, readbuf, offset, len, 7385 &remote_protocol_packets 7386 [PACKET_qXfer_spu_read]); 7387 else 7388 return remote_write_qxfer (ops, "spu", annex, writebuf, offset, len, 7389 &remote_protocol_packets 7390 [PACKET_qXfer_spu_write]); 7391 } 7392 7393 /* Handle extra signal info using qxfer packets. */ 7394 if (object == TARGET_OBJECT_SIGNAL_INFO) 7395 { 7396 if (readbuf) 7397 return remote_read_qxfer (ops, "siginfo", annex, readbuf, offset, len, 7398 &remote_protocol_packets 7399 [PACKET_qXfer_siginfo_read]); 7400 else 7401 return remote_write_qxfer (ops, "siginfo", annex, writebuf, offset, len, 7402 &remote_protocol_packets 7403 [PACKET_qXfer_siginfo_write]); 7404 } 7405 7406 /* Only handle flash writes. */ 7407 if (writebuf != NULL) 7408 { 7409 LONGEST xfered; 7410 7411 switch (object) 7412 { 7413 case TARGET_OBJECT_FLASH: 7414 xfered = remote_flash_write (ops, offset, len, writebuf); 7415 7416 if (xfered > 0) 7417 return xfered; 7418 else if (xfered == 0 && errno == 0) 7419 return 0; 7420 else 7421 return -1; 7422 7423 default: 7424 return -1; 7425 } 7426 } 7427 7428 /* Map pre-existing objects onto letters. DO NOT do this for new 7429 objects!!! Instead specify new query packets. */ 7430 switch (object) 7431 { 7432 case TARGET_OBJECT_AVR: 7433 query_type = 'R'; 7434 break; 7435 7436 case TARGET_OBJECT_AUXV: 7437 gdb_assert (annex == NULL); 7438 return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len, 7439 &remote_protocol_packets[PACKET_qXfer_auxv]); 7440 7441 case TARGET_OBJECT_AVAILABLE_FEATURES: 7442 return remote_read_qxfer 7443 (ops, "features", annex, readbuf, offset, len, 7444 &remote_protocol_packets[PACKET_qXfer_features]); 7445 7446 case TARGET_OBJECT_LIBRARIES: 7447 return remote_read_qxfer 7448 (ops, "libraries", annex, readbuf, offset, len, 7449 &remote_protocol_packets[PACKET_qXfer_libraries]); 7450 7451 case TARGET_OBJECT_MEMORY_MAP: 7452 gdb_assert (annex == NULL); 7453 return remote_read_qxfer (ops, "memory-map", annex, readbuf, offset, len, 7454 &remote_protocol_packets[PACKET_qXfer_memory_map]); 7455 7456 case TARGET_OBJECT_OSDATA: 7457 /* Should only get here if we're connected. */ 7458 gdb_assert (remote_desc); 7459 return remote_read_qxfer 7460 (ops, "osdata", annex, readbuf, offset, len, 7461 &remote_protocol_packets[PACKET_qXfer_osdata]); 7462 7463 default: 7464 return -1; 7465 } 7466 7467 /* Note: a zero OFFSET and LEN can be used to query the minimum 7468 buffer size. */ 7469 if (offset == 0 && len == 0) 7470 return (get_remote_packet_size ()); 7471 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not 7472 large enough let the caller deal with it. */ 7473 if (len < get_remote_packet_size ()) 7474 return -1; 7475 len = get_remote_packet_size (); 7476 7477 /* Except for querying the minimum buffer size, target must be open. */ 7478 if (!remote_desc) 7479 error (_("remote query is only available after target open")); 7480 7481 gdb_assert (annex != NULL); 7482 gdb_assert (readbuf != NULL); 7483 7484 p2 = rs->buf; 7485 *p2++ = 'q'; 7486 *p2++ = query_type; 7487 7488 /* We used one buffer char for the remote protocol q command and 7489 another for the query type. As the remote protocol encapsulation 7490 uses 4 chars plus one extra in case we are debugging 7491 (remote_debug), we have PBUFZIZ - 7 left to pack the query 7492 string. */ 7493 i = 0; 7494 while (annex[i] && (i < (get_remote_packet_size () - 8))) 7495 { 7496 /* Bad caller may have sent forbidden characters. */ 7497 gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#'); 7498 *p2++ = annex[i]; 7499 i++; 7500 } 7501 *p2 = '\0'; 7502 gdb_assert (annex[i] == '\0'); 7503 7504 i = putpkt (rs->buf); 7505 if (i < 0) 7506 return i; 7507 7508 getpkt (&rs->buf, &rs->buf_size, 0); 7509 strcpy ((char *) readbuf, rs->buf); 7510 7511 return strlen ((char *) readbuf); 7512 } 7513 7514 static int 7515 remote_search_memory (struct target_ops* ops, 7516 CORE_ADDR start_addr, ULONGEST search_space_len, 7517 const gdb_byte *pattern, ULONGEST pattern_len, 7518 CORE_ADDR *found_addrp) 7519 { 7520 int addr_size = gdbarch_addr_bit (target_gdbarch) / 8; 7521 struct remote_state *rs = get_remote_state (); 7522 int max_size = get_memory_write_packet_size (); 7523 struct packet_config *packet = 7524 &remote_protocol_packets[PACKET_qSearch_memory]; 7525 /* number of packet bytes used to encode the pattern, 7526 this could be more than PATTERN_LEN due to escape characters */ 7527 int escaped_pattern_len; 7528 /* amount of pattern that was encodable in the packet */ 7529 int used_pattern_len; 7530 int i; 7531 int found; 7532 ULONGEST found_addr; 7533 7534 /* Don't go to the target if we don't have to. 7535 This is done before checking packet->support to avoid the possibility that 7536 a success for this edge case means the facility works in general. */ 7537 if (pattern_len > search_space_len) 7538 return 0; 7539 if (pattern_len == 0) 7540 { 7541 *found_addrp = start_addr; 7542 return 1; 7543 } 7544 7545 /* If we already know the packet isn't supported, fall back to the simple 7546 way of searching memory. */ 7547 7548 if (packet->support == PACKET_DISABLE) 7549 { 7550 /* Target doesn't provided special support, fall back and use the 7551 standard support (copy memory and do the search here). */ 7552 return simple_search_memory (ops, start_addr, search_space_len, 7553 pattern, pattern_len, found_addrp); 7554 } 7555 7556 /* Insert header. */ 7557 i = snprintf (rs->buf, max_size, 7558 "qSearch:memory:%s;%s;", 7559 phex_nz (start_addr, addr_size), 7560 phex_nz (search_space_len, sizeof (search_space_len))); 7561 max_size -= (i + 1); 7562 7563 /* Escape as much data as fits into rs->buf. */ 7564 escaped_pattern_len = 7565 remote_escape_output (pattern, pattern_len, (rs->buf + i), 7566 &used_pattern_len, max_size); 7567 7568 /* Bail if the pattern is too large. */ 7569 if (used_pattern_len != pattern_len) 7570 error ("Pattern is too large to transmit to remote target."); 7571 7572 if (putpkt_binary (rs->buf, i + escaped_pattern_len) < 0 7573 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0 7574 || packet_ok (rs->buf, packet) != PACKET_OK) 7575 { 7576 /* The request may not have worked because the command is not 7577 supported. If so, fall back to the simple way. */ 7578 if (packet->support == PACKET_DISABLE) 7579 { 7580 return simple_search_memory (ops, start_addr, search_space_len, 7581 pattern, pattern_len, found_addrp); 7582 } 7583 return -1; 7584 } 7585 7586 if (rs->buf[0] == '0') 7587 found = 0; 7588 else if (rs->buf[0] == '1') 7589 { 7590 found = 1; 7591 if (rs->buf[1] != ',') 7592 error (_("Unknown qSearch:memory reply: %s"), rs->buf); 7593 unpack_varlen_hex (rs->buf + 2, &found_addr); 7594 *found_addrp = found_addr; 7595 } 7596 else 7597 error (_("Unknown qSearch:memory reply: %s"), rs->buf); 7598 7599 return found; 7600 } 7601 7602 static void 7603 remote_rcmd (char *command, 7604 struct ui_file *outbuf) 7605 { 7606 struct remote_state *rs = get_remote_state (); 7607 char *p = rs->buf; 7608 7609 if (!remote_desc) 7610 error (_("remote rcmd is only available after target open")); 7611 7612 /* Send a NULL command across as an empty command. */ 7613 if (command == NULL) 7614 command = ""; 7615 7616 /* The query prefix. */ 7617 strcpy (rs->buf, "qRcmd,"); 7618 p = strchr (rs->buf, '\0'); 7619 7620 if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ()) 7621 error (_("\"monitor\" command ``%s'' is too long."), command); 7622 7623 /* Encode the actual command. */ 7624 bin2hex ((gdb_byte *) command, p, 0); 7625 7626 if (putpkt (rs->buf) < 0) 7627 error (_("Communication problem with target.")); 7628 7629 /* get/display the response */ 7630 while (1) 7631 { 7632 char *buf; 7633 7634 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */ 7635 rs->buf[0] = '\0'; 7636 getpkt (&rs->buf, &rs->buf_size, 0); 7637 buf = rs->buf; 7638 if (buf[0] == '\0') 7639 error (_("Target does not support this command.")); 7640 if (buf[0] == 'O' && buf[1] != 'K') 7641 { 7642 remote_console_output (buf + 1); /* 'O' message from stub. */ 7643 continue; 7644 } 7645 if (strcmp (buf, "OK") == 0) 7646 break; 7647 if (strlen (buf) == 3 && buf[0] == 'E' 7648 && isdigit (buf[1]) && isdigit (buf[2])) 7649 { 7650 error (_("Protocol error with Rcmd")); 7651 } 7652 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2) 7653 { 7654 char c = (fromhex (p[0]) << 4) + fromhex (p[1]); 7655 fputc_unfiltered (c, outbuf); 7656 } 7657 break; 7658 } 7659 } 7660 7661 static VEC(mem_region_s) * 7662 remote_memory_map (struct target_ops *ops) 7663 { 7664 VEC(mem_region_s) *result = NULL; 7665 char *text = target_read_stralloc (¤t_target, 7666 TARGET_OBJECT_MEMORY_MAP, NULL); 7667 7668 if (text) 7669 { 7670 struct cleanup *back_to = make_cleanup (xfree, text); 7671 result = parse_memory_map (text); 7672 do_cleanups (back_to); 7673 } 7674 7675 return result; 7676 } 7677 7678 static void 7679 packet_command (char *args, int from_tty) 7680 { 7681 struct remote_state *rs = get_remote_state (); 7682 7683 if (!remote_desc) 7684 error (_("command can only be used with remote target")); 7685 7686 if (!args) 7687 error (_("remote-packet command requires packet text as argument")); 7688 7689 puts_filtered ("sending: "); 7690 print_packet (args); 7691 puts_filtered ("\n"); 7692 putpkt (args); 7693 7694 getpkt (&rs->buf, &rs->buf_size, 0); 7695 puts_filtered ("received: "); 7696 print_packet (rs->buf); 7697 puts_filtered ("\n"); 7698 } 7699 7700 #if 0 7701 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */ 7702 7703 static void display_thread_info (struct gdb_ext_thread_info *info); 7704 7705 static void threadset_test_cmd (char *cmd, int tty); 7706 7707 static void threadalive_test (char *cmd, int tty); 7708 7709 static void threadlist_test_cmd (char *cmd, int tty); 7710 7711 int get_and_display_threadinfo (threadref *ref); 7712 7713 static void threadinfo_test_cmd (char *cmd, int tty); 7714 7715 static int thread_display_step (threadref *ref, void *context); 7716 7717 static void threadlist_update_test_cmd (char *cmd, int tty); 7718 7719 static void init_remote_threadtests (void); 7720 7721 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */ 7722 7723 static void 7724 threadset_test_cmd (char *cmd, int tty) 7725 { 7726 int sample_thread = SAMPLE_THREAD; 7727 7728 printf_filtered (_("Remote threadset test\n")); 7729 set_general_thread (sample_thread); 7730 } 7731 7732 7733 static void 7734 threadalive_test (char *cmd, int tty) 7735 { 7736 int sample_thread = SAMPLE_THREAD; 7737 int pid = ptid_get_pid (inferior_ptid); 7738 ptid_t ptid = ptid_build (pid, 0, sample_thread); 7739 7740 if (remote_thread_alive (ptid)) 7741 printf_filtered ("PASS: Thread alive test\n"); 7742 else 7743 printf_filtered ("FAIL: Thread alive test\n"); 7744 } 7745 7746 void output_threadid (char *title, threadref *ref); 7747 7748 void 7749 output_threadid (char *title, threadref *ref) 7750 { 7751 char hexid[20]; 7752 7753 pack_threadid (&hexid[0], ref); /* Convert threead id into hex. */ 7754 hexid[16] = 0; 7755 printf_filtered ("%s %s\n", title, (&hexid[0])); 7756 } 7757 7758 static void 7759 threadlist_test_cmd (char *cmd, int tty) 7760 { 7761 int startflag = 1; 7762 threadref nextthread; 7763 int done, result_count; 7764 threadref threadlist[3]; 7765 7766 printf_filtered ("Remote Threadlist test\n"); 7767 if (!remote_get_threadlist (startflag, &nextthread, 3, &done, 7768 &result_count, &threadlist[0])) 7769 printf_filtered ("FAIL: threadlist test\n"); 7770 else 7771 { 7772 threadref *scan = threadlist; 7773 threadref *limit = scan + result_count; 7774 7775 while (scan < limit) 7776 output_threadid (" thread ", scan++); 7777 } 7778 } 7779 7780 void 7781 display_thread_info (struct gdb_ext_thread_info *info) 7782 { 7783 output_threadid ("Threadid: ", &info->threadid); 7784 printf_filtered ("Name: %s\n ", info->shortname); 7785 printf_filtered ("State: %s\n", info->display); 7786 printf_filtered ("other: %s\n\n", info->more_display); 7787 } 7788 7789 int 7790 get_and_display_threadinfo (threadref *ref) 7791 { 7792 int result; 7793 int set; 7794 struct gdb_ext_thread_info threadinfo; 7795 7796 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME 7797 | TAG_MOREDISPLAY | TAG_DISPLAY; 7798 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo))) 7799 display_thread_info (&threadinfo); 7800 return result; 7801 } 7802 7803 static void 7804 threadinfo_test_cmd (char *cmd, int tty) 7805 { 7806 int athread = SAMPLE_THREAD; 7807 threadref thread; 7808 int set; 7809 7810 int_to_threadref (&thread, athread); 7811 printf_filtered ("Remote Threadinfo test\n"); 7812 if (!get_and_display_threadinfo (&thread)) 7813 printf_filtered ("FAIL cannot get thread info\n"); 7814 } 7815 7816 static int 7817 thread_display_step (threadref *ref, void *context) 7818 { 7819 /* output_threadid(" threadstep ",ref); *//* simple test */ 7820 return get_and_display_threadinfo (ref); 7821 } 7822 7823 static void 7824 threadlist_update_test_cmd (char *cmd, int tty) 7825 { 7826 printf_filtered ("Remote Threadlist update test\n"); 7827 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS); 7828 } 7829 7830 static void 7831 init_remote_threadtests (void) 7832 { 7833 add_com ("tlist", class_obscure, threadlist_test_cmd, _("\ 7834 Fetch and print the remote list of thread identifiers, one pkt only")); 7835 add_com ("tinfo", class_obscure, threadinfo_test_cmd, 7836 _("Fetch and display info about one thread")); 7837 add_com ("tset", class_obscure, threadset_test_cmd, 7838 _("Test setting to a different thread")); 7839 add_com ("tupd", class_obscure, threadlist_update_test_cmd, 7840 _("Iterate through updating all remote thread info")); 7841 add_com ("talive", class_obscure, threadalive_test, 7842 _(" Remote thread alive test ")); 7843 } 7844 7845 #endif /* 0 */ 7846 7847 /* Convert a thread ID to a string. Returns the string in a static 7848 buffer. */ 7849 7850 static char * 7851 remote_pid_to_str (struct target_ops *ops, ptid_t ptid) 7852 { 7853 static char buf[64]; 7854 struct remote_state *rs = get_remote_state (); 7855 7856 if (ptid_is_pid (ptid)) 7857 { 7858 /* Printing an inferior target id. */ 7859 7860 /* When multi-process extensions are off, there's no way in the 7861 remote protocol to know the remote process id, if there's any 7862 at all. There's one exception --- when we're connected with 7863 target extended-remote, and we manually attached to a process 7864 with "attach PID". We don't record anywhere a flag that 7865 allows us to distinguish that case from the case of 7866 connecting with extended-remote and the stub already being 7867 attached to a process, and reporting yes to qAttached, hence 7868 no smart special casing here. */ 7869 if (!remote_multi_process_p (rs)) 7870 { 7871 xsnprintf (buf, sizeof buf, "Remote target"); 7872 return buf; 7873 } 7874 7875 return normal_pid_to_str (ptid); 7876 } 7877 else 7878 { 7879 if (ptid_equal (magic_null_ptid, ptid)) 7880 xsnprintf (buf, sizeof buf, "Thread <main>"); 7881 else if (remote_multi_process_p (rs)) 7882 xsnprintf (buf, sizeof buf, "Thread %d.%ld", 7883 ptid_get_pid (ptid), ptid_get_tid (ptid)); 7884 else 7885 xsnprintf (buf, sizeof buf, "Thread %ld", 7886 ptid_get_tid (ptid)); 7887 return buf; 7888 } 7889 } 7890 7891 /* Get the address of the thread local variable in OBJFILE which is 7892 stored at OFFSET within the thread local storage for thread PTID. */ 7893 7894 static CORE_ADDR 7895 remote_get_thread_local_address (struct target_ops *ops, 7896 ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset) 7897 { 7898 if (remote_protocol_packets[PACKET_qGetTLSAddr].support != PACKET_DISABLE) 7899 { 7900 struct remote_state *rs = get_remote_state (); 7901 char *p = rs->buf; 7902 char *endp = rs->buf + get_remote_packet_size (); 7903 enum packet_result result; 7904 7905 strcpy (p, "qGetTLSAddr:"); 7906 p += strlen (p); 7907 p = write_ptid (p, endp, ptid); 7908 *p++ = ','; 7909 p += hexnumstr (p, offset); 7910 *p++ = ','; 7911 p += hexnumstr (p, lm); 7912 *p++ = '\0'; 7913 7914 putpkt (rs->buf); 7915 getpkt (&rs->buf, &rs->buf_size, 0); 7916 result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_qGetTLSAddr]); 7917 if (result == PACKET_OK) 7918 { 7919 ULONGEST result; 7920 7921 unpack_varlen_hex (rs->buf, &result); 7922 return result; 7923 } 7924 else if (result == PACKET_UNKNOWN) 7925 throw_error (TLS_GENERIC_ERROR, 7926 _("Remote target doesn't support qGetTLSAddr packet")); 7927 else 7928 throw_error (TLS_GENERIC_ERROR, 7929 _("Remote target failed to process qGetTLSAddr request")); 7930 } 7931 else 7932 throw_error (TLS_GENERIC_ERROR, 7933 _("TLS not supported or disabled on this target")); 7934 /* Not reached. */ 7935 return 0; 7936 } 7937 7938 /* Support for inferring a target description based on the current 7939 architecture and the size of a 'g' packet. While the 'g' packet 7940 can have any size (since optional registers can be left off the 7941 end), some sizes are easily recognizable given knowledge of the 7942 approximate architecture. */ 7943 7944 struct remote_g_packet_guess 7945 { 7946 int bytes; 7947 const struct target_desc *tdesc; 7948 }; 7949 typedef struct remote_g_packet_guess remote_g_packet_guess_s; 7950 DEF_VEC_O(remote_g_packet_guess_s); 7951 7952 struct remote_g_packet_data 7953 { 7954 VEC(remote_g_packet_guess_s) *guesses; 7955 }; 7956 7957 static struct gdbarch_data *remote_g_packet_data_handle; 7958 7959 static void * 7960 remote_g_packet_data_init (struct obstack *obstack) 7961 { 7962 return OBSTACK_ZALLOC (obstack, struct remote_g_packet_data); 7963 } 7964 7965 void 7966 register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes, 7967 const struct target_desc *tdesc) 7968 { 7969 struct remote_g_packet_data *data 7970 = gdbarch_data (gdbarch, remote_g_packet_data_handle); 7971 struct remote_g_packet_guess new_guess, *guess; 7972 int ix; 7973 7974 gdb_assert (tdesc != NULL); 7975 7976 for (ix = 0; 7977 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess); 7978 ix++) 7979 if (guess->bytes == bytes) 7980 internal_error (__FILE__, __LINE__, 7981 "Duplicate g packet description added for size %d", 7982 bytes); 7983 7984 new_guess.bytes = bytes; 7985 new_guess.tdesc = tdesc; 7986 VEC_safe_push (remote_g_packet_guess_s, data->guesses, &new_guess); 7987 } 7988 7989 /* Return 1 if remote_read_description would do anything on this target 7990 and architecture, 0 otherwise. */ 7991 7992 static int 7993 remote_read_description_p (struct target_ops *target) 7994 { 7995 struct remote_g_packet_data *data 7996 = gdbarch_data (target_gdbarch, remote_g_packet_data_handle); 7997 7998 if (!VEC_empty (remote_g_packet_guess_s, data->guesses)) 7999 return 1; 8000 8001 return 0; 8002 } 8003 8004 static const struct target_desc * 8005 remote_read_description (struct target_ops *target) 8006 { 8007 struct remote_g_packet_data *data 8008 = gdbarch_data (target_gdbarch, remote_g_packet_data_handle); 8009 8010 /* Do not try this during initial connection, when we do not know 8011 whether there is a running but stopped thread. */ 8012 if (!target_has_execution || ptid_equal (inferior_ptid, null_ptid)) 8013 return NULL; 8014 8015 if (!VEC_empty (remote_g_packet_guess_s, data->guesses)) 8016 { 8017 struct remote_g_packet_guess *guess; 8018 int ix; 8019 int bytes = send_g_packet (); 8020 8021 for (ix = 0; 8022 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess); 8023 ix++) 8024 if (guess->bytes == bytes) 8025 return guess->tdesc; 8026 8027 /* We discard the g packet. A minor optimization would be to 8028 hold on to it, and fill the register cache once we have selected 8029 an architecture, but it's too tricky to do safely. */ 8030 } 8031 8032 return NULL; 8033 } 8034 8035 /* Remote file transfer support. This is host-initiated I/O, not 8036 target-initiated; for target-initiated, see remote-fileio.c. */ 8037 8038 /* If *LEFT is at least the length of STRING, copy STRING to 8039 *BUFFER, update *BUFFER to point to the new end of the buffer, and 8040 decrease *LEFT. Otherwise raise an error. */ 8041 8042 static void 8043 remote_buffer_add_string (char **buffer, int *left, char *string) 8044 { 8045 int len = strlen (string); 8046 8047 if (len > *left) 8048 error (_("Packet too long for target.")); 8049 8050 memcpy (*buffer, string, len); 8051 *buffer += len; 8052 *left -= len; 8053 8054 /* NUL-terminate the buffer as a convenience, if there is 8055 room. */ 8056 if (*left) 8057 **buffer = '\0'; 8058 } 8059 8060 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into 8061 *BUFFER, update *BUFFER to point to the new end of the buffer, and 8062 decrease *LEFT. Otherwise raise an error. */ 8063 8064 static void 8065 remote_buffer_add_bytes (char **buffer, int *left, const gdb_byte *bytes, 8066 int len) 8067 { 8068 if (2 * len > *left) 8069 error (_("Packet too long for target.")); 8070 8071 bin2hex (bytes, *buffer, len); 8072 *buffer += 2 * len; 8073 *left -= 2 * len; 8074 8075 /* NUL-terminate the buffer as a convenience, if there is 8076 room. */ 8077 if (*left) 8078 **buffer = '\0'; 8079 } 8080 8081 /* If *LEFT is large enough, convert VALUE to hex and add it to 8082 *BUFFER, update *BUFFER to point to the new end of the buffer, and 8083 decrease *LEFT. Otherwise raise an error. */ 8084 8085 static void 8086 remote_buffer_add_int (char **buffer, int *left, ULONGEST value) 8087 { 8088 int len = hexnumlen (value); 8089 8090 if (len > *left) 8091 error (_("Packet too long for target.")); 8092 8093 hexnumstr (*buffer, value); 8094 *buffer += len; 8095 *left -= len; 8096 8097 /* NUL-terminate the buffer as a convenience, if there is 8098 room. */ 8099 if (*left) 8100 **buffer = '\0'; 8101 } 8102 8103 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return 8104 value, *REMOTE_ERRNO to the remote error number or zero if none 8105 was included, and *ATTACHMENT to point to the start of the annex 8106 if any. The length of the packet isn't needed here; there may 8107 be NUL bytes in BUFFER, but they will be after *ATTACHMENT. 8108 8109 Return 0 if the packet could be parsed, -1 if it could not. If 8110 -1 is returned, the other variables may not be initialized. */ 8111 8112 static int 8113 remote_hostio_parse_result (char *buffer, int *retcode, 8114 int *remote_errno, char **attachment) 8115 { 8116 char *p, *p2; 8117 8118 *remote_errno = 0; 8119 *attachment = NULL; 8120 8121 if (buffer[0] != 'F') 8122 return -1; 8123 8124 errno = 0; 8125 *retcode = strtol (&buffer[1], &p, 16); 8126 if (errno != 0 || p == &buffer[1]) 8127 return -1; 8128 8129 /* Check for ",errno". */ 8130 if (*p == ',') 8131 { 8132 errno = 0; 8133 *remote_errno = strtol (p + 1, &p2, 16); 8134 if (errno != 0 || p + 1 == p2) 8135 return -1; 8136 p = p2; 8137 } 8138 8139 /* Check for ";attachment". If there is no attachment, the 8140 packet should end here. */ 8141 if (*p == ';') 8142 { 8143 *attachment = p + 1; 8144 return 0; 8145 } 8146 else if (*p == '\0') 8147 return 0; 8148 else 8149 return -1; 8150 } 8151 8152 /* Send a prepared I/O packet to the target and read its response. 8153 The prepared packet is in the global RS->BUF before this function 8154 is called, and the answer is there when we return. 8155 8156 COMMAND_BYTES is the length of the request to send, which may include 8157 binary data. WHICH_PACKET is the packet configuration to check 8158 before attempting a packet. If an error occurs, *REMOTE_ERRNO 8159 is set to the error number and -1 is returned. Otherwise the value 8160 returned by the function is returned. 8161 8162 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an 8163 attachment is expected; an error will be reported if there's a 8164 mismatch. If one is found, *ATTACHMENT will be set to point into 8165 the packet buffer and *ATTACHMENT_LEN will be set to the 8166 attachment's length. */ 8167 8168 static int 8169 remote_hostio_send_command (int command_bytes, int which_packet, 8170 int *remote_errno, char **attachment, 8171 int *attachment_len) 8172 { 8173 struct remote_state *rs = get_remote_state (); 8174 int ret, bytes_read; 8175 char *attachment_tmp; 8176 8177 if (!remote_desc 8178 || remote_protocol_packets[which_packet].support == PACKET_DISABLE) 8179 { 8180 *remote_errno = FILEIO_ENOSYS; 8181 return -1; 8182 } 8183 8184 putpkt_binary (rs->buf, command_bytes); 8185 bytes_read = getpkt_sane (&rs->buf, &rs->buf_size, 0); 8186 8187 /* If it timed out, something is wrong. Don't try to parse the 8188 buffer. */ 8189 if (bytes_read < 0) 8190 { 8191 *remote_errno = FILEIO_EINVAL; 8192 return -1; 8193 } 8194 8195 switch (packet_ok (rs->buf, &remote_protocol_packets[which_packet])) 8196 { 8197 case PACKET_ERROR: 8198 *remote_errno = FILEIO_EINVAL; 8199 return -1; 8200 case PACKET_UNKNOWN: 8201 *remote_errno = FILEIO_ENOSYS; 8202 return -1; 8203 case PACKET_OK: 8204 break; 8205 } 8206 8207 if (remote_hostio_parse_result (rs->buf, &ret, remote_errno, 8208 &attachment_tmp)) 8209 { 8210 *remote_errno = FILEIO_EINVAL; 8211 return -1; 8212 } 8213 8214 /* Make sure we saw an attachment if and only if we expected one. */ 8215 if ((attachment_tmp == NULL && attachment != NULL) 8216 || (attachment_tmp != NULL && attachment == NULL)) 8217 { 8218 *remote_errno = FILEIO_EINVAL; 8219 return -1; 8220 } 8221 8222 /* If an attachment was found, it must point into the packet buffer; 8223 work out how many bytes there were. */ 8224 if (attachment_tmp != NULL) 8225 { 8226 *attachment = attachment_tmp; 8227 *attachment_len = bytes_read - (*attachment - rs->buf); 8228 } 8229 8230 return ret; 8231 } 8232 8233 /* Open FILENAME on the remote target, using FLAGS and MODE. Return a 8234 remote file descriptor, or -1 if an error occurs (and set 8235 *REMOTE_ERRNO). */ 8236 8237 static int 8238 remote_hostio_open (const char *filename, int flags, int mode, 8239 int *remote_errno) 8240 { 8241 struct remote_state *rs = get_remote_state (); 8242 char *p = rs->buf; 8243 int left = get_remote_packet_size () - 1; 8244 8245 remote_buffer_add_string (&p, &left, "vFile:open:"); 8246 8247 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, 8248 strlen (filename)); 8249 remote_buffer_add_string (&p, &left, ","); 8250 8251 remote_buffer_add_int (&p, &left, flags); 8252 remote_buffer_add_string (&p, &left, ","); 8253 8254 remote_buffer_add_int (&p, &left, mode); 8255 8256 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_open, 8257 remote_errno, NULL, NULL); 8258 } 8259 8260 /* Write up to LEN bytes from WRITE_BUF to FD on the remote target. 8261 Return the number of bytes written, or -1 if an error occurs (and 8262 set *REMOTE_ERRNO). */ 8263 8264 static int 8265 remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len, 8266 ULONGEST offset, int *remote_errno) 8267 { 8268 struct remote_state *rs = get_remote_state (); 8269 char *p = rs->buf; 8270 int left = get_remote_packet_size (); 8271 int out_len; 8272 8273 remote_buffer_add_string (&p, &left, "vFile:pwrite:"); 8274 8275 remote_buffer_add_int (&p, &left, fd); 8276 remote_buffer_add_string (&p, &left, ","); 8277 8278 remote_buffer_add_int (&p, &left, offset); 8279 remote_buffer_add_string (&p, &left, ","); 8280 8281 p += remote_escape_output (write_buf, len, p, &out_len, 8282 get_remote_packet_size () - (p - rs->buf)); 8283 8284 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_pwrite, 8285 remote_errno, NULL, NULL); 8286 } 8287 8288 /* Read up to LEN bytes FD on the remote target into READ_BUF 8289 Return the number of bytes read, or -1 if an error occurs (and 8290 set *REMOTE_ERRNO). */ 8291 8292 static int 8293 remote_hostio_pread (int fd, gdb_byte *read_buf, int len, 8294 ULONGEST offset, int *remote_errno) 8295 { 8296 struct remote_state *rs = get_remote_state (); 8297 char *p = rs->buf; 8298 char *attachment; 8299 int left = get_remote_packet_size (); 8300 int ret, attachment_len; 8301 int read_len; 8302 8303 remote_buffer_add_string (&p, &left, "vFile:pread:"); 8304 8305 remote_buffer_add_int (&p, &left, fd); 8306 remote_buffer_add_string (&p, &left, ","); 8307 8308 remote_buffer_add_int (&p, &left, len); 8309 remote_buffer_add_string (&p, &left, ","); 8310 8311 remote_buffer_add_int (&p, &left, offset); 8312 8313 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_pread, 8314 remote_errno, &attachment, 8315 &attachment_len); 8316 8317 if (ret < 0) 8318 return ret; 8319 8320 read_len = remote_unescape_input (attachment, attachment_len, 8321 read_buf, len); 8322 if (read_len != ret) 8323 error (_("Read returned %d, but %d bytes."), ret, (int) read_len); 8324 8325 return ret; 8326 } 8327 8328 /* Close FD on the remote target. Return 0, or -1 if an error occurs 8329 (and set *REMOTE_ERRNO). */ 8330 8331 static int 8332 remote_hostio_close (int fd, int *remote_errno) 8333 { 8334 struct remote_state *rs = get_remote_state (); 8335 char *p = rs->buf; 8336 int left = get_remote_packet_size () - 1; 8337 8338 remote_buffer_add_string (&p, &left, "vFile:close:"); 8339 8340 remote_buffer_add_int (&p, &left, fd); 8341 8342 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_close, 8343 remote_errno, NULL, NULL); 8344 } 8345 8346 /* Unlink FILENAME on the remote target. Return 0, or -1 if an error 8347 occurs (and set *REMOTE_ERRNO). */ 8348 8349 static int 8350 remote_hostio_unlink (const char *filename, int *remote_errno) 8351 { 8352 struct remote_state *rs = get_remote_state (); 8353 char *p = rs->buf; 8354 int left = get_remote_packet_size () - 1; 8355 8356 remote_buffer_add_string (&p, &left, "vFile:unlink:"); 8357 8358 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, 8359 strlen (filename)); 8360 8361 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_unlink, 8362 remote_errno, NULL, NULL); 8363 } 8364 8365 static int 8366 remote_fileio_errno_to_host (int errnum) 8367 { 8368 switch (errnum) 8369 { 8370 case FILEIO_EPERM: 8371 return EPERM; 8372 case FILEIO_ENOENT: 8373 return ENOENT; 8374 case FILEIO_EINTR: 8375 return EINTR; 8376 case FILEIO_EIO: 8377 return EIO; 8378 case FILEIO_EBADF: 8379 return EBADF; 8380 case FILEIO_EACCES: 8381 return EACCES; 8382 case FILEIO_EFAULT: 8383 return EFAULT; 8384 case FILEIO_EBUSY: 8385 return EBUSY; 8386 case FILEIO_EEXIST: 8387 return EEXIST; 8388 case FILEIO_ENODEV: 8389 return ENODEV; 8390 case FILEIO_ENOTDIR: 8391 return ENOTDIR; 8392 case FILEIO_EISDIR: 8393 return EISDIR; 8394 case FILEIO_EINVAL: 8395 return EINVAL; 8396 case FILEIO_ENFILE: 8397 return ENFILE; 8398 case FILEIO_EMFILE: 8399 return EMFILE; 8400 case FILEIO_EFBIG: 8401 return EFBIG; 8402 case FILEIO_ENOSPC: 8403 return ENOSPC; 8404 case FILEIO_ESPIPE: 8405 return ESPIPE; 8406 case FILEIO_EROFS: 8407 return EROFS; 8408 case FILEIO_ENOSYS: 8409 return ENOSYS; 8410 case FILEIO_ENAMETOOLONG: 8411 return ENAMETOOLONG; 8412 } 8413 return -1; 8414 } 8415 8416 static char * 8417 remote_hostio_error (int errnum) 8418 { 8419 int host_error = remote_fileio_errno_to_host (errnum); 8420 8421 if (host_error == -1) 8422 error (_("Unknown remote I/O error %d"), errnum); 8423 else 8424 error (_("Remote I/O error: %s"), safe_strerror (host_error)); 8425 } 8426 8427 static void 8428 remote_hostio_close_cleanup (void *opaque) 8429 { 8430 int fd = *(int *) opaque; 8431 int remote_errno; 8432 8433 remote_hostio_close (fd, &remote_errno); 8434 } 8435 8436 8437 static void * 8438 remote_bfd_iovec_open (struct bfd *abfd, void *open_closure) 8439 { 8440 const char *filename = bfd_get_filename (abfd); 8441 int fd, remote_errno; 8442 int *stream; 8443 8444 gdb_assert (remote_filename_p (filename)); 8445 8446 fd = remote_hostio_open (filename + 7, FILEIO_O_RDONLY, 0, &remote_errno); 8447 if (fd == -1) 8448 { 8449 errno = remote_fileio_errno_to_host (remote_errno); 8450 bfd_set_error (bfd_error_system_call); 8451 return NULL; 8452 } 8453 8454 stream = xmalloc (sizeof (int)); 8455 *stream = fd; 8456 return stream; 8457 } 8458 8459 static int 8460 remote_bfd_iovec_close (struct bfd *abfd, void *stream) 8461 { 8462 int fd = *(int *)stream; 8463 int remote_errno; 8464 8465 xfree (stream); 8466 8467 /* Ignore errors on close; these may happen if the remote 8468 connection was already torn down. */ 8469 remote_hostio_close (fd, &remote_errno); 8470 8471 return 1; 8472 } 8473 8474 static file_ptr 8475 remote_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf, 8476 file_ptr nbytes, file_ptr offset) 8477 { 8478 int fd = *(int *)stream; 8479 int remote_errno; 8480 file_ptr pos, bytes; 8481 8482 pos = 0; 8483 while (nbytes > pos) 8484 { 8485 bytes = remote_hostio_pread (fd, (char *)buf + pos, nbytes - pos, 8486 offset + pos, &remote_errno); 8487 if (bytes == 0) 8488 /* Success, but no bytes, means end-of-file. */ 8489 break; 8490 if (bytes == -1) 8491 { 8492 errno = remote_fileio_errno_to_host (remote_errno); 8493 bfd_set_error (bfd_error_system_call); 8494 return -1; 8495 } 8496 8497 pos += bytes; 8498 } 8499 8500 return pos; 8501 } 8502 8503 static int 8504 remote_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb) 8505 { 8506 /* FIXME: We should probably implement remote_hostio_stat. */ 8507 sb->st_size = INT_MAX; 8508 return 0; 8509 } 8510 8511 int 8512 remote_filename_p (const char *filename) 8513 { 8514 return strncmp (filename, "remote:", 7) == 0; 8515 } 8516 8517 bfd * 8518 remote_bfd_open (const char *remote_file, const char *target) 8519 { 8520 return bfd_openr_iovec (remote_file, target, 8521 remote_bfd_iovec_open, NULL, 8522 remote_bfd_iovec_pread, 8523 remote_bfd_iovec_close, 8524 remote_bfd_iovec_stat); 8525 } 8526 8527 void 8528 remote_file_put (const char *local_file, const char *remote_file, int from_tty) 8529 { 8530 struct cleanup *back_to, *close_cleanup; 8531 int retcode, fd, remote_errno, bytes, io_size; 8532 FILE *file; 8533 gdb_byte *buffer; 8534 int bytes_in_buffer; 8535 int saw_eof; 8536 ULONGEST offset; 8537 8538 if (!remote_desc) 8539 error (_("command can only be used with remote target")); 8540 8541 file = fopen (local_file, "rb"); 8542 if (file == NULL) 8543 perror_with_name (local_file); 8544 back_to = make_cleanup_fclose (file); 8545 8546 fd = remote_hostio_open (remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT 8547 | FILEIO_O_TRUNC), 8548 0700, &remote_errno); 8549 if (fd == -1) 8550 remote_hostio_error (remote_errno); 8551 8552 /* Send up to this many bytes at once. They won't all fit in the 8553 remote packet limit, so we'll transfer slightly fewer. */ 8554 io_size = get_remote_packet_size (); 8555 buffer = xmalloc (io_size); 8556 make_cleanup (xfree, buffer); 8557 8558 close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd); 8559 8560 bytes_in_buffer = 0; 8561 saw_eof = 0; 8562 offset = 0; 8563 while (bytes_in_buffer || !saw_eof) 8564 { 8565 if (!saw_eof) 8566 { 8567 bytes = fread (buffer + bytes_in_buffer, 1, io_size - bytes_in_buffer, 8568 file); 8569 if (bytes == 0) 8570 { 8571 if (ferror (file)) 8572 error (_("Error reading %s."), local_file); 8573 else 8574 { 8575 /* EOF. Unless there is something still in the 8576 buffer from the last iteration, we are done. */ 8577 saw_eof = 1; 8578 if (bytes_in_buffer == 0) 8579 break; 8580 } 8581 } 8582 } 8583 else 8584 bytes = 0; 8585 8586 bytes += bytes_in_buffer; 8587 bytes_in_buffer = 0; 8588 8589 retcode = remote_hostio_pwrite (fd, buffer, bytes, offset, &remote_errno); 8590 8591 if (retcode < 0) 8592 remote_hostio_error (remote_errno); 8593 else if (retcode == 0) 8594 error (_("Remote write of %d bytes returned 0!"), bytes); 8595 else if (retcode < bytes) 8596 { 8597 /* Short write. Save the rest of the read data for the next 8598 write. */ 8599 bytes_in_buffer = bytes - retcode; 8600 memmove (buffer, buffer + retcode, bytes_in_buffer); 8601 } 8602 8603 offset += retcode; 8604 } 8605 8606 discard_cleanups (close_cleanup); 8607 if (remote_hostio_close (fd, &remote_errno)) 8608 remote_hostio_error (remote_errno); 8609 8610 if (from_tty) 8611 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file); 8612 do_cleanups (back_to); 8613 } 8614 8615 void 8616 remote_file_get (const char *remote_file, const char *local_file, int from_tty) 8617 { 8618 struct cleanup *back_to, *close_cleanup; 8619 int fd, remote_errno, bytes, io_size; 8620 FILE *file; 8621 gdb_byte *buffer; 8622 ULONGEST offset; 8623 8624 if (!remote_desc) 8625 error (_("command can only be used with remote target")); 8626 8627 fd = remote_hostio_open (remote_file, FILEIO_O_RDONLY, 0, &remote_errno); 8628 if (fd == -1) 8629 remote_hostio_error (remote_errno); 8630 8631 file = fopen (local_file, "wb"); 8632 if (file == NULL) 8633 perror_with_name (local_file); 8634 back_to = make_cleanup_fclose (file); 8635 8636 /* Send up to this many bytes at once. They won't all fit in the 8637 remote packet limit, so we'll transfer slightly fewer. */ 8638 io_size = get_remote_packet_size (); 8639 buffer = xmalloc (io_size); 8640 make_cleanup (xfree, buffer); 8641 8642 close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd); 8643 8644 offset = 0; 8645 while (1) 8646 { 8647 bytes = remote_hostio_pread (fd, buffer, io_size, offset, &remote_errno); 8648 if (bytes == 0) 8649 /* Success, but no bytes, means end-of-file. */ 8650 break; 8651 if (bytes == -1) 8652 remote_hostio_error (remote_errno); 8653 8654 offset += bytes; 8655 8656 bytes = fwrite (buffer, 1, bytes, file); 8657 if (bytes == 0) 8658 perror_with_name (local_file); 8659 } 8660 8661 discard_cleanups (close_cleanup); 8662 if (remote_hostio_close (fd, &remote_errno)) 8663 remote_hostio_error (remote_errno); 8664 8665 if (from_tty) 8666 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file); 8667 do_cleanups (back_to); 8668 } 8669 8670 void 8671 remote_file_delete (const char *remote_file, int from_tty) 8672 { 8673 int retcode, remote_errno; 8674 8675 if (!remote_desc) 8676 error (_("command can only be used with remote target")); 8677 8678 retcode = remote_hostio_unlink (remote_file, &remote_errno); 8679 if (retcode == -1) 8680 remote_hostio_error (remote_errno); 8681 8682 if (from_tty) 8683 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file); 8684 } 8685 8686 static void 8687 remote_put_command (char *args, int from_tty) 8688 { 8689 struct cleanup *back_to; 8690 char **argv; 8691 8692 if (args == NULL) 8693 error_no_arg (_("file to put")); 8694 8695 argv = gdb_buildargv (args); 8696 back_to = make_cleanup_freeargv (argv); 8697 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL) 8698 error (_("Invalid parameters to remote put")); 8699 8700 remote_file_put (argv[0], argv[1], from_tty); 8701 8702 do_cleanups (back_to); 8703 } 8704 8705 static void 8706 remote_get_command (char *args, int from_tty) 8707 { 8708 struct cleanup *back_to; 8709 char **argv; 8710 8711 if (args == NULL) 8712 error_no_arg (_("file to get")); 8713 8714 argv = gdb_buildargv (args); 8715 back_to = make_cleanup_freeargv (argv); 8716 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL) 8717 error (_("Invalid parameters to remote get")); 8718 8719 remote_file_get (argv[0], argv[1], from_tty); 8720 8721 do_cleanups (back_to); 8722 } 8723 8724 static void 8725 remote_delete_command (char *args, int from_tty) 8726 { 8727 struct cleanup *back_to; 8728 char **argv; 8729 8730 if (args == NULL) 8731 error_no_arg (_("file to delete")); 8732 8733 argv = gdb_buildargv (args); 8734 back_to = make_cleanup_freeargv (argv); 8735 if (argv[0] == NULL || argv[1] != NULL) 8736 error (_("Invalid parameters to remote delete")); 8737 8738 remote_file_delete (argv[0], from_tty); 8739 8740 do_cleanups (back_to); 8741 } 8742 8743 static void 8744 remote_command (char *args, int from_tty) 8745 { 8746 help_list (remote_cmdlist, "remote ", -1, gdb_stdout); 8747 } 8748 8749 static int 8750 remote_can_execute_reverse (void) 8751 { 8752 if (remote_protocol_packets[PACKET_bs].support == PACKET_ENABLE 8753 || remote_protocol_packets[PACKET_bc].support == PACKET_ENABLE) 8754 return 1; 8755 else 8756 return 0; 8757 } 8758 8759 static int 8760 remote_supports_non_stop (void) 8761 { 8762 return 1; 8763 } 8764 8765 static int 8766 remote_supports_multi_process (void) 8767 { 8768 struct remote_state *rs = get_remote_state (); 8769 return remote_multi_process_p (rs); 8770 } 8771 8772 int 8773 remote_supports_cond_tracepoints (void) 8774 { 8775 struct remote_state *rs = get_remote_state (); 8776 return rs->cond_tracepoints; 8777 } 8778 8779 static void 8780 init_remote_ops (void) 8781 { 8782 remote_ops.to_shortname = "remote"; 8783 remote_ops.to_longname = "Remote serial target in gdb-specific protocol"; 8784 remote_ops.to_doc = 8785 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\ 8786 Specify the serial device it is connected to\n\ 8787 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."; 8788 remote_ops.to_open = remote_open; 8789 remote_ops.to_close = remote_close; 8790 remote_ops.to_detach = remote_detach; 8791 remote_ops.to_disconnect = remote_disconnect; 8792 remote_ops.to_resume = remote_resume; 8793 remote_ops.to_wait = remote_wait; 8794 remote_ops.to_fetch_registers = remote_fetch_registers; 8795 remote_ops.to_store_registers = remote_store_registers; 8796 remote_ops.to_prepare_to_store = remote_prepare_to_store; 8797 remote_ops.deprecated_xfer_memory = remote_xfer_memory; 8798 remote_ops.to_files_info = remote_files_info; 8799 remote_ops.to_insert_breakpoint = remote_insert_breakpoint; 8800 remote_ops.to_remove_breakpoint = remote_remove_breakpoint; 8801 remote_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint; 8802 remote_ops.to_stopped_data_address = remote_stopped_data_address; 8803 remote_ops.to_can_use_hw_breakpoint = remote_check_watch_resources; 8804 remote_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint; 8805 remote_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint; 8806 remote_ops.to_insert_watchpoint = remote_insert_watchpoint; 8807 remote_ops.to_remove_watchpoint = remote_remove_watchpoint; 8808 remote_ops.to_kill = remote_kill; 8809 remote_ops.to_load = generic_load; 8810 remote_ops.to_mourn_inferior = remote_mourn; 8811 remote_ops.to_thread_alive = remote_thread_alive; 8812 remote_ops.to_find_new_threads = remote_threads_info; 8813 remote_ops.to_pid_to_str = remote_pid_to_str; 8814 remote_ops.to_extra_thread_info = remote_threads_extra_info; 8815 remote_ops.to_stop = remote_stop; 8816 remote_ops.to_xfer_partial = remote_xfer_partial; 8817 remote_ops.to_rcmd = remote_rcmd; 8818 remote_ops.to_log_command = serial_log_command; 8819 remote_ops.to_get_thread_local_address = remote_get_thread_local_address; 8820 remote_ops.to_stratum = process_stratum; 8821 remote_ops.to_has_all_memory = default_child_has_all_memory; 8822 remote_ops.to_has_memory = default_child_has_memory; 8823 remote_ops.to_has_stack = default_child_has_stack; 8824 remote_ops.to_has_registers = default_child_has_registers; 8825 remote_ops.to_has_execution = default_child_has_execution; 8826 remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */ 8827 remote_ops.to_can_execute_reverse = remote_can_execute_reverse; 8828 remote_ops.to_magic = OPS_MAGIC; 8829 remote_ops.to_memory_map = remote_memory_map; 8830 remote_ops.to_flash_erase = remote_flash_erase; 8831 remote_ops.to_flash_done = remote_flash_done; 8832 remote_ops.to_read_description = remote_read_description; 8833 remote_ops.to_search_memory = remote_search_memory; 8834 remote_ops.to_can_async_p = remote_can_async_p; 8835 remote_ops.to_is_async_p = remote_is_async_p; 8836 remote_ops.to_async = remote_async; 8837 remote_ops.to_async_mask = remote_async_mask; 8838 remote_ops.to_terminal_inferior = remote_terminal_inferior; 8839 remote_ops.to_terminal_ours = remote_terminal_ours; 8840 remote_ops.to_supports_non_stop = remote_supports_non_stop; 8841 remote_ops.to_supports_multi_process = remote_supports_multi_process; 8842 } 8843 8844 /* Set up the extended remote vector by making a copy of the standard 8845 remote vector and adding to it. */ 8846 8847 static void 8848 init_extended_remote_ops (void) 8849 { 8850 extended_remote_ops = remote_ops; 8851 8852 extended_remote_ops.to_shortname = "extended-remote"; 8853 extended_remote_ops.to_longname = 8854 "Extended remote serial target in gdb-specific protocol"; 8855 extended_remote_ops.to_doc = 8856 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\ 8857 Specify the serial device it is connected to (e.g. /dev/ttya)."; 8858 extended_remote_ops.to_open = extended_remote_open; 8859 extended_remote_ops.to_create_inferior = extended_remote_create_inferior; 8860 extended_remote_ops.to_mourn_inferior = extended_remote_mourn; 8861 extended_remote_ops.to_detach = extended_remote_detach; 8862 extended_remote_ops.to_attach = extended_remote_attach; 8863 extended_remote_ops.to_kill = extended_remote_kill; 8864 } 8865 8866 static int 8867 remote_can_async_p (void) 8868 { 8869 if (!target_async_permitted) 8870 /* We only enable async when the user specifically asks for it. */ 8871 return 0; 8872 8873 /* We're async whenever the serial device is. */ 8874 return remote_async_mask_value && serial_can_async_p (remote_desc); 8875 } 8876 8877 static int 8878 remote_is_async_p (void) 8879 { 8880 if (!target_async_permitted) 8881 /* We only enable async when the user specifically asks for it. */ 8882 return 0; 8883 8884 /* We're async whenever the serial device is. */ 8885 return remote_async_mask_value && serial_is_async_p (remote_desc); 8886 } 8887 8888 /* Pass the SERIAL event on and up to the client. One day this code 8889 will be able to delay notifying the client of an event until the 8890 point where an entire packet has been received. */ 8891 8892 static void (*async_client_callback) (enum inferior_event_type event_type, 8893 void *context); 8894 static void *async_client_context; 8895 static serial_event_ftype remote_async_serial_handler; 8896 8897 static void 8898 remote_async_serial_handler (struct serial *scb, void *context) 8899 { 8900 /* Don't propogate error information up to the client. Instead let 8901 the client find out about the error by querying the target. */ 8902 async_client_callback (INF_REG_EVENT, async_client_context); 8903 } 8904 8905 static void 8906 remote_async_inferior_event_handler (gdb_client_data data) 8907 { 8908 inferior_event_handler (INF_REG_EVENT, NULL); 8909 } 8910 8911 static void 8912 remote_async_get_pending_events_handler (gdb_client_data data) 8913 { 8914 remote_get_pending_stop_replies (); 8915 } 8916 8917 static void 8918 remote_async (void (*callback) (enum inferior_event_type event_type, 8919 void *context), void *context) 8920 { 8921 if (remote_async_mask_value == 0) 8922 internal_error (__FILE__, __LINE__, 8923 _("Calling remote_async when async is masked")); 8924 8925 if (callback != NULL) 8926 { 8927 serial_async (remote_desc, remote_async_serial_handler, NULL); 8928 async_client_callback = callback; 8929 async_client_context = context; 8930 } 8931 else 8932 serial_async (remote_desc, NULL, NULL); 8933 } 8934 8935 static int 8936 remote_async_mask (int new_mask) 8937 { 8938 int curr_mask = remote_async_mask_value; 8939 remote_async_mask_value = new_mask; 8940 return curr_mask; 8941 } 8942 8943 static void 8944 set_remote_cmd (char *args, int from_tty) 8945 { 8946 help_list (remote_set_cmdlist, "set remote ", -1, gdb_stdout); 8947 } 8948 8949 static void 8950 show_remote_cmd (char *args, int from_tty) 8951 { 8952 /* We can't just use cmd_show_list here, because we want to skip 8953 the redundant "show remote Z-packet" and the legacy aliases. */ 8954 struct cleanup *showlist_chain; 8955 struct cmd_list_element *list = remote_show_cmdlist; 8956 8957 showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist"); 8958 for (; list != NULL; list = list->next) 8959 if (strcmp (list->name, "Z-packet") == 0) 8960 continue; 8961 else if (list->type == not_set_cmd) 8962 /* Alias commands are exactly like the original, except they 8963 don't have the normal type. */ 8964 continue; 8965 else 8966 { 8967 struct cleanup *option_chain 8968 = make_cleanup_ui_out_tuple_begin_end (uiout, "option"); 8969 ui_out_field_string (uiout, "name", list->name); 8970 ui_out_text (uiout, ": "); 8971 if (list->type == show_cmd) 8972 do_setshow_command ((char *) NULL, from_tty, list); 8973 else 8974 cmd_func (list, NULL, from_tty); 8975 /* Close the tuple. */ 8976 do_cleanups (option_chain); 8977 } 8978 8979 /* Close the tuple. */ 8980 do_cleanups (showlist_chain); 8981 } 8982 8983 8984 /* Function to be called whenever a new objfile (shlib) is detected. */ 8985 static void 8986 remote_new_objfile (struct objfile *objfile) 8987 { 8988 if (remote_desc != 0) /* Have a remote connection. */ 8989 remote_check_symbols (objfile); 8990 } 8991 8992 void 8993 _initialize_remote (void) 8994 { 8995 struct remote_state *rs; 8996 8997 /* architecture specific data */ 8998 remote_gdbarch_data_handle = 8999 gdbarch_data_register_post_init (init_remote_state); 9000 remote_g_packet_data_handle = 9001 gdbarch_data_register_pre_init (remote_g_packet_data_init); 9002 9003 /* Initialize the per-target state. At the moment there is only one 9004 of these, not one per target. Only one target is active at a 9005 time. The default buffer size is unimportant; it will be expanded 9006 whenever a larger buffer is needed. */ 9007 rs = get_remote_state_raw (); 9008 rs->buf_size = 400; 9009 rs->buf = xmalloc (rs->buf_size); 9010 9011 init_remote_ops (); 9012 add_target (&remote_ops); 9013 9014 init_extended_remote_ops (); 9015 add_target (&extended_remote_ops); 9016 9017 /* Hook into new objfile notification. */ 9018 observer_attach_new_objfile (remote_new_objfile); 9019 9020 /* Set up signal handlers. */ 9021 sigint_remote_token = 9022 create_async_signal_handler (async_remote_interrupt, NULL); 9023 sigint_remote_twice_token = 9024 create_async_signal_handler (inferior_event_handler_wrapper, NULL); 9025 9026 #if 0 9027 init_remote_threadtests (); 9028 #endif 9029 9030 /* set/show remote ... */ 9031 9032 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\ 9033 Remote protocol specific variables\n\ 9034 Configure various remote-protocol specific variables such as\n\ 9035 the packets being used"), 9036 &remote_set_cmdlist, "set remote ", 9037 0 /* allow-unknown */, &setlist); 9038 add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\ 9039 Remote protocol specific variables\n\ 9040 Configure various remote-protocol specific variables such as\n\ 9041 the packets being used"), 9042 &remote_show_cmdlist, "show remote ", 9043 0 /* allow-unknown */, &showlist); 9044 9045 add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\ 9046 Compare section data on target to the exec file.\n\ 9047 Argument is a single section name (default: all loaded sections)."), 9048 &cmdlist); 9049 9050 add_cmd ("packet", class_maintenance, packet_command, _("\ 9051 Send an arbitrary packet to a remote target.\n\ 9052 maintenance packet TEXT\n\ 9053 If GDB is talking to an inferior via the GDB serial protocol, then\n\ 9054 this command sends the string TEXT to the inferior, and displays the\n\ 9055 response packet. GDB supplies the initial `$' character, and the\n\ 9056 terminating `#' character and checksum."), 9057 &maintenancelist); 9058 9059 add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\ 9060 Set whether to send break if interrupted."), _("\ 9061 Show whether to send break if interrupted."), _("\ 9062 If set, a break, instead of a cntrl-c, is sent to the remote target."), 9063 NULL, NULL, /* FIXME: i18n: Whether to send break if interrupted is %s. */ 9064 &setlist, &showlist); 9065 9066 /* Install commands for configuring memory read/write packets. */ 9067 9068 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\ 9069 Set the maximum number of bytes per memory write packet (deprecated)."), 9070 &setlist); 9071 add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\ 9072 Show the maximum number of bytes per memory write packet (deprecated)."), 9073 &showlist); 9074 add_cmd ("memory-write-packet-size", no_class, 9075 set_memory_write_packet_size, _("\ 9076 Set the maximum number of bytes per memory-write packet.\n\ 9077 Specify the number of bytes in a packet or 0 (zero) for the\n\ 9078 default packet size. The actual limit is further reduced\n\ 9079 dependent on the target. Specify ``fixed'' to disable the\n\ 9080 further restriction and ``limit'' to enable that restriction."), 9081 &remote_set_cmdlist); 9082 add_cmd ("memory-read-packet-size", no_class, 9083 set_memory_read_packet_size, _("\ 9084 Set the maximum number of bytes per memory-read packet.\n\ 9085 Specify the number of bytes in a packet or 0 (zero) for the\n\ 9086 default packet size. The actual limit is further reduced\n\ 9087 dependent on the target. Specify ``fixed'' to disable the\n\ 9088 further restriction and ``limit'' to enable that restriction."), 9089 &remote_set_cmdlist); 9090 add_cmd ("memory-write-packet-size", no_class, 9091 show_memory_write_packet_size, 9092 _("Show the maximum number of bytes per memory-write packet."), 9093 &remote_show_cmdlist); 9094 add_cmd ("memory-read-packet-size", no_class, 9095 show_memory_read_packet_size, 9096 _("Show the maximum number of bytes per memory-read packet."), 9097 &remote_show_cmdlist); 9098 9099 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class, 9100 &remote_hw_watchpoint_limit, _("\ 9101 Set the maximum number of target hardware watchpoints."), _("\ 9102 Show the maximum number of target hardware watchpoints."), _("\ 9103 Specify a negative limit for unlimited."), 9104 NULL, NULL, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */ 9105 &remote_set_cmdlist, &remote_show_cmdlist); 9106 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class, 9107 &remote_hw_breakpoint_limit, _("\ 9108 Set the maximum number of target hardware breakpoints."), _("\ 9109 Show the maximum number of target hardware breakpoints."), _("\ 9110 Specify a negative limit for unlimited."), 9111 NULL, NULL, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */ 9112 &remote_set_cmdlist, &remote_show_cmdlist); 9113 9114 add_setshow_integer_cmd ("remoteaddresssize", class_obscure, 9115 &remote_address_size, _("\ 9116 Set the maximum size of the address (in bits) in a memory packet."), _("\ 9117 Show the maximum size of the address (in bits) in a memory packet."), NULL, 9118 NULL, 9119 NULL, /* FIXME: i18n: */ 9120 &setlist, &showlist); 9121 9122 add_packet_config_cmd (&remote_protocol_packets[PACKET_X], 9123 "X", "binary-download", 1); 9124 9125 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont], 9126 "vCont", "verbose-resume", 0); 9127 9128 add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals], 9129 "QPassSignals", "pass-signals", 0); 9130 9131 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol], 9132 "qSymbol", "symbol-lookup", 0); 9133 9134 add_packet_config_cmd (&remote_protocol_packets[PACKET_P], 9135 "P", "set-register", 1); 9136 9137 add_packet_config_cmd (&remote_protocol_packets[PACKET_p], 9138 "p", "fetch-register", 1); 9139 9140 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0], 9141 "Z0", "software-breakpoint", 0); 9142 9143 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1], 9144 "Z1", "hardware-breakpoint", 0); 9145 9146 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2], 9147 "Z2", "write-watchpoint", 0); 9148 9149 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3], 9150 "Z3", "read-watchpoint", 0); 9151 9152 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4], 9153 "Z4", "access-watchpoint", 0); 9154 9155 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv], 9156 "qXfer:auxv:read", "read-aux-vector", 0); 9157 9158 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features], 9159 "qXfer:features:read", "target-features", 0); 9160 9161 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries], 9162 "qXfer:libraries:read", "library-info", 0); 9163 9164 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map], 9165 "qXfer:memory-map:read", "memory-map", 0); 9166 9167 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read], 9168 "qXfer:spu:read", "read-spu-object", 0); 9169 9170 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write], 9171 "qXfer:spu:write", "write-spu-object", 0); 9172 9173 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata], 9174 "qXfer:osdata:read", "osdata", 0); 9175 9176 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_read], 9177 "qXfer:siginfo:read", "read-siginfo-object", 0); 9178 9179 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write], 9180 "qXfer:siginfo:write", "write-siginfo-object", 0); 9181 9182 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr], 9183 "qGetTLSAddr", "get-thread-local-storage-address", 9184 0); 9185 9186 add_packet_config_cmd (&remote_protocol_packets[PACKET_bc], 9187 "bc", "reverse-continue", 0); 9188 9189 add_packet_config_cmd (&remote_protocol_packets[PACKET_bs], 9190 "bs", "reverse-step", 0); 9191 9192 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported], 9193 "qSupported", "supported-packets", 0); 9194 9195 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSearch_memory], 9196 "qSearch:memory", "search-memory", 0); 9197 9198 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_open], 9199 "vFile:open", "hostio-open", 0); 9200 9201 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pread], 9202 "vFile:pread", "hostio-pread", 0); 9203 9204 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pwrite], 9205 "vFile:pwrite", "hostio-pwrite", 0); 9206 9207 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_close], 9208 "vFile:close", "hostio-close", 0); 9209 9210 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink], 9211 "vFile:unlink", "hostio-unlink", 0); 9212 9213 add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach], 9214 "vAttach", "attach", 0); 9215 9216 add_packet_config_cmd (&remote_protocol_packets[PACKET_vRun], 9217 "vRun", "run", 0); 9218 9219 add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartNoAckMode], 9220 "QStartNoAckMode", "noack", 0); 9221 9222 add_packet_config_cmd (&remote_protocol_packets[PACKET_vKill], 9223 "vKill", "kill", 0); 9224 9225 add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached], 9226 "qAttached", "query-attached", 0); 9227 9228 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints], 9229 "ConditionalTracepoints", "conditional-tracepoints", 0); 9230 9231 /* Keep the old ``set remote Z-packet ...'' working. Each individual 9232 Z sub-packet has its own set and show commands, but users may 9233 have sets to this variable in their .gdbinit files (or in their 9234 documentation). */ 9235 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure, 9236 &remote_Z_packet_detect, _("\ 9237 Set use of remote protocol `Z' packets"), _("\ 9238 Show use of remote protocol `Z' packets "), _("\ 9239 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\ 9240 packets."), 9241 set_remote_protocol_Z_packet_cmd, 9242 show_remote_protocol_Z_packet_cmd, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */ 9243 &remote_set_cmdlist, &remote_show_cmdlist); 9244 9245 add_prefix_cmd ("remote", class_files, remote_command, _("\ 9246 Manipulate files on the remote system\n\ 9247 Transfer files to and from the remote target system."), 9248 &remote_cmdlist, "remote ", 9249 0 /* allow-unknown */, &cmdlist); 9250 9251 add_cmd ("put", class_files, remote_put_command, 9252 _("Copy a local file to the remote system."), 9253 &remote_cmdlist); 9254 9255 add_cmd ("get", class_files, remote_get_command, 9256 _("Copy a remote file to the local system."), 9257 &remote_cmdlist); 9258 9259 add_cmd ("delete", class_files, remote_delete_command, 9260 _("Delete a remote file."), 9261 &remote_cmdlist); 9262 9263 remote_exec_file = xstrdup (""); 9264 add_setshow_string_noescape_cmd ("exec-file", class_files, 9265 &remote_exec_file, _("\ 9266 Set the remote pathname for \"run\""), _("\ 9267 Show the remote pathname for \"run\""), NULL, NULL, NULL, 9268 &remote_set_cmdlist, &remote_show_cmdlist); 9269 9270 /* Eventually initialize fileio. See fileio.c */ 9271 initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist); 9272 9273 /* Take advantage of the fact that the LWP field is not used, to tag 9274 special ptids with it set to != 0. */ 9275 magic_null_ptid = ptid_build (42000, 1, -1); 9276 not_sent_ptid = ptid_build (42000, 1, -2); 9277 any_thread_ptid = ptid_build (42000, 1, 0); 9278 } 9279