1/* Remote utility routines for the remote server for GDB. 2 Copyright (C) 1986-2023 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19#include "server.h" 20#if HAVE_TERMIOS_H 21#include <termios.h> 22#endif 23#include "target.h" 24#include "gdbthread.h" 25#include "tdesc.h" 26#include "debug.h" 27#include "dll.h" 28#include "gdbsupport/rsp-low.h" 29#include "gdbsupport/netstuff.h" 30#include "gdbsupport/filestuff.h" 31#include "gdbsupport/gdb-sigmask.h" 32#include <ctype.h> 33#if HAVE_SYS_IOCTL_H 34#include <sys/ioctl.h> 35#endif 36#if HAVE_SYS_FILE_H 37#include <sys/file.h> 38#endif 39#if HAVE_NETINET_IN_H 40#include <netinet/in.h> 41#endif 42#if HAVE_SYS_SOCKET_H 43#include <sys/socket.h> 44#endif 45#if HAVE_NETDB_H 46#include <netdb.h> 47#endif 48#if HAVE_NETINET_TCP_H 49#include <netinet/tcp.h> 50#endif 51#if HAVE_SYS_IOCTL_H 52#include <sys/ioctl.h> 53#endif 54#if HAVE_SIGNAL_H 55#include <signal.h> 56#endif 57#if HAVE_FCNTL_H 58#include <fcntl.h> 59#endif 60#include "gdbsupport/gdb_sys_time.h" 61#include <unistd.h> 62#if HAVE_ARPA_INET_H 63#include <arpa/inet.h> 64#endif 65#include <sys/stat.h> 66 67#if USE_WIN32API 68#include <ws2tcpip.h> 69#endif 70 71#ifndef HAVE_SOCKLEN_T 72typedef int socklen_t; 73#endif 74 75#ifndef IN_PROCESS_AGENT 76 77/* Extra value for readchar_callback. */ 78enum { 79 /* The callback is currently not scheduled. */ 80 NOT_SCHEDULED = -1 81}; 82 83/* Status of the readchar callback. 84 Either NOT_SCHEDULED or the callback id. */ 85static int readchar_callback = NOT_SCHEDULED; 86 87static int readchar (void); 88static void reset_readchar (void); 89static void reschedule (void); 90 91/* A cache entry for a successfully looked-up symbol. */ 92struct sym_cache 93{ 94 char *name; 95 CORE_ADDR addr; 96 struct sym_cache *next; 97}; 98 99static int remote_is_stdio = 0; 100 101static int remote_desc = -1; 102static int listen_desc = -1; 103 104#ifdef USE_WIN32API 105/* gnulib wraps these as macros, undo them. */ 106# undef read 107# undef write 108 109# define read(fd, buf, len) recv (fd, (char *) buf, len, 0) 110# define write(fd, buf, len) send (fd, (char *) buf, len, 0) 111#endif 112 113int 114gdb_connected (void) 115{ 116 return remote_desc != -1; 117} 118 119/* Return true if the remote connection is over stdio. */ 120 121int 122remote_connection_is_stdio (void) 123{ 124 return remote_is_stdio; 125} 126 127static void 128enable_async_notification (int fd) 129{ 130#if defined(F_SETFL) && defined (FASYNC) 131 int save_fcntl_flags; 132 133 save_fcntl_flags = fcntl (fd, F_GETFL, 0); 134 fcntl (fd, F_SETFL, save_fcntl_flags | FASYNC); 135#if defined (F_SETOWN) 136 fcntl (fd, F_SETOWN, getpid ()); 137#endif 138#endif 139} 140 141static void 142handle_accept_event (int err, gdb_client_data client_data) 143{ 144 struct sockaddr_storage sockaddr; 145 socklen_t len = sizeof (sockaddr); 146 147 threads_debug_printf ("handling possible accept event"); 148 149 remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &len); 150 if (remote_desc == -1) 151 perror_with_name ("Accept failed"); 152 153 /* Enable TCP keep alive process. */ 154 socklen_t tmp = 1; 155 setsockopt (remote_desc, SOL_SOCKET, SO_KEEPALIVE, 156 (char *) &tmp, sizeof (tmp)); 157 158 /* Tell TCP not to delay small packets. This greatly speeds up 159 interactive response. */ 160 tmp = 1; 161 setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY, 162 (char *) &tmp, sizeof (tmp)); 163 164#ifndef USE_WIN32API 165 signal (SIGPIPE, SIG_IGN); /* If we don't do this, then gdbserver simply 166 exits when the remote side dies. */ 167#endif 168 169 if (run_once) 170 { 171#ifndef USE_WIN32API 172 close (listen_desc); /* No longer need this */ 173#else 174 closesocket (listen_desc); /* No longer need this */ 175#endif 176 } 177 178 /* Even if !RUN_ONCE no longer notice new connections. Still keep the 179 descriptor open for add_file_handler to wait for a new connection. */ 180 delete_file_handler (listen_desc); 181 182 /* Convert IP address to string. */ 183 char orig_host[GDB_NI_MAX_ADDR], orig_port[GDB_NI_MAX_PORT]; 184 185 int r = getnameinfo ((struct sockaddr *) &sockaddr, len, 186 orig_host, sizeof (orig_host), 187 orig_port, sizeof (orig_port), 188 NI_NUMERICHOST | NI_NUMERICSERV); 189 190 if (r != 0) 191 fprintf (stderr, _("Could not obtain remote address: %s\n"), 192 gai_strerror (r)); 193 else 194 fprintf (stderr, _("Remote debugging from host %s, port %s\n"), 195 orig_host, orig_port); 196 197 enable_async_notification (remote_desc); 198 199 /* Register the event loop handler. */ 200 add_file_handler (remote_desc, handle_serial_event, NULL, "remote-net"); 201 202 /* We have a new GDB connection now. If we were disconnected 203 tracing, there's a window where the target could report a stop 204 event to the event loop, and since we have a connection now, we'd 205 try to send vStopped notifications to GDB. But, don't do that 206 until GDB as selected all-stop/non-stop, and has queried the 207 threads' status ('?'). */ 208 target_async (0); 209} 210 211/* Prepare for a later connection to a remote debugger. 212 NAME is the filename used for communication. */ 213 214void 215remote_prepare (const char *name) 216{ 217 client_state &cs = get_client_state (); 218#ifdef USE_WIN32API 219 static int winsock_initialized; 220#endif 221 socklen_t tmp; 222 223 remote_is_stdio = 0; 224 if (strcmp (name, STDIO_CONNECTION_NAME) == 0) 225 { 226 /* We need to record fact that we're using stdio sooner than the 227 call to remote_open so start_inferior knows the connection is 228 via stdio. */ 229 remote_is_stdio = 1; 230 cs.transport_is_reliable = 1; 231 return; 232 } 233 234 struct addrinfo hint; 235 struct addrinfo *ainfo; 236 237 memset (&hint, 0, sizeof (hint)); 238 /* Assume no prefix will be passed, therefore we should use 239 AF_UNSPEC. */ 240 hint.ai_family = AF_UNSPEC; 241 hint.ai_socktype = SOCK_STREAM; 242 hint.ai_protocol = IPPROTO_TCP; 243 244 parsed_connection_spec parsed 245 = parse_connection_spec_without_prefix (name, &hint); 246 247 if (parsed.port_str.empty ()) 248 { 249 cs.transport_is_reliable = 0; 250 return; 251 } 252 253#ifdef USE_WIN32API 254 if (!winsock_initialized) 255 { 256 WSADATA wsad; 257 258 WSAStartup (MAKEWORD (1, 0), &wsad); 259 winsock_initialized = 1; 260 } 261#endif 262 263 int r = getaddrinfo (parsed.host_str.c_str (), parsed.port_str.c_str (), 264 &hint, &ainfo); 265 266 if (r != 0) 267 error (_("%s: cannot resolve name: %s"), name, gai_strerror (r)); 268 269 scoped_free_addrinfo freeaddrinfo (ainfo); 270 271 struct addrinfo *iter; 272 273 for (iter = ainfo; iter != NULL; iter = iter->ai_next) 274 { 275 listen_desc = gdb_socket_cloexec (iter->ai_family, iter->ai_socktype, 276 iter->ai_protocol); 277 278 if (listen_desc >= 0) 279 break; 280 } 281 282 if (iter == NULL) 283 perror_with_name ("Can't open socket"); 284 285 /* Allow rapid reuse of this port. */ 286 tmp = 1; 287 setsockopt (listen_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp, 288 sizeof (tmp)); 289 290 switch (iter->ai_family) 291 { 292 case AF_INET: 293 ((struct sockaddr_in *) iter->ai_addr)->sin_addr.s_addr = INADDR_ANY; 294 break; 295 case AF_INET6: 296 ((struct sockaddr_in6 *) iter->ai_addr)->sin6_addr = in6addr_any; 297 break; 298 default: 299 internal_error (_("Invalid 'ai_family' %d\n"), iter->ai_family); 300 } 301 302 if (bind (listen_desc, iter->ai_addr, iter->ai_addrlen) != 0) 303 perror_with_name ("Can't bind address"); 304 305 if (listen (listen_desc, 1) != 0) 306 perror_with_name ("Can't listen on socket"); 307 308 cs.transport_is_reliable = 1; 309} 310 311/* Open a connection to a remote debugger. 312 NAME is the filename used for communication. */ 313 314void 315remote_open (const char *name) 316{ 317 const char *port_str; 318 319 port_str = strchr (name, ':'); 320#ifdef USE_WIN32API 321 if (port_str == NULL) 322 error ("Only HOST:PORT is supported on this platform."); 323#endif 324 325 if (strcmp (name, STDIO_CONNECTION_NAME) == 0) 326 { 327 fprintf (stderr, "Remote debugging using stdio\n"); 328 329 /* Use stdin as the handle of the connection. 330 We only select on reads, for example. */ 331 remote_desc = fileno (stdin); 332 333 enable_async_notification (remote_desc); 334 335 /* Register the event loop handler. */ 336 add_file_handler (remote_desc, handle_serial_event, NULL, "remote-stdio"); 337 } 338#ifndef USE_WIN32API 339 else if (port_str == NULL) 340 { 341 struct stat statbuf; 342 343 if (stat (name, &statbuf) == 0 344 && (S_ISCHR (statbuf.st_mode) || S_ISFIFO (statbuf.st_mode))) 345 remote_desc = open (name, O_RDWR); 346 else 347 { 348 errno = EINVAL; 349 remote_desc = -1; 350 } 351 352 if (remote_desc < 0) 353 perror_with_name ("Could not open remote device"); 354 355#if HAVE_TERMIOS_H 356 { 357 struct termios termios; 358 tcgetattr (remote_desc, &termios); 359 360 termios.c_iflag = 0; 361 termios.c_oflag = 0; 362 termios.c_lflag = 0; 363 termios.c_cflag &= ~(CSIZE | PARENB); 364 termios.c_cflag |= CLOCAL | CS8; 365 termios.c_cc[VMIN] = 1; 366 termios.c_cc[VTIME] = 0; 367 368 tcsetattr (remote_desc, TCSANOW, &termios); 369 } 370#endif 371 372 fprintf (stderr, "Remote debugging using %s\n", name); 373 374 enable_async_notification (remote_desc); 375 376 /* Register the event loop handler. */ 377 add_file_handler (remote_desc, handle_serial_event, NULL, 378 "remote-device"); 379 } 380#endif /* USE_WIN32API */ 381 else 382 { 383 char listen_port[GDB_NI_MAX_PORT]; 384 struct sockaddr_storage sockaddr; 385 socklen_t len = sizeof (sockaddr); 386 387 if (getsockname (listen_desc, (struct sockaddr *) &sockaddr, &len) < 0) 388 perror_with_name ("Can't determine port"); 389 390 int r = getnameinfo ((struct sockaddr *) &sockaddr, len, 391 NULL, 0, 392 listen_port, sizeof (listen_port), 393 NI_NUMERICSERV); 394 395 if (r != 0) 396 fprintf (stderr, _("Can't obtain port where we are listening: %s"), 397 gai_strerror (r)); 398 else 399 fprintf (stderr, _("Listening on port %s\n"), listen_port); 400 401 fflush (stderr); 402 403 /* Register the event loop handler. */ 404 add_file_handler (listen_desc, handle_accept_event, NULL, 405 "remote-listen"); 406 } 407} 408 409void 410remote_close (void) 411{ 412 delete_file_handler (remote_desc); 413 414 disable_async_io (); 415 416#ifdef USE_WIN32API 417 closesocket (remote_desc); 418#else 419 if (! remote_connection_is_stdio ()) 420 close (remote_desc); 421#endif 422 remote_desc = -1; 423 424 reset_readchar (); 425} 426 427#endif 428 429#ifndef IN_PROCESS_AGENT 430 431void 432decode_address (CORE_ADDR *addrp, const char *start, int len) 433{ 434 CORE_ADDR addr; 435 char ch; 436 int i; 437 438 addr = 0; 439 for (i = 0; i < len; i++) 440 { 441 ch = start[i]; 442 addr = addr << 4; 443 addr = addr | (fromhex (ch) & 0x0f); 444 } 445 *addrp = addr; 446} 447 448const char * 449decode_address_to_semicolon (CORE_ADDR *addrp, const char *start) 450{ 451 const char *end; 452 453 end = start; 454 while (*end != '\0' && *end != ';') 455 end++; 456 457 decode_address (addrp, start, end - start); 458 459 if (*end == ';') 460 end++; 461 return end; 462} 463 464#endif 465 466#ifndef IN_PROCESS_AGENT 467 468/* Look for a sequence of characters which can be run-length encoded. 469 If there are any, update *CSUM and *P. Otherwise, output the 470 single character. Return the number of characters consumed. */ 471 472static int 473try_rle (char *buf, int remaining, unsigned char *csum, char **p) 474{ 475 int n; 476 477 /* Always output the character. */ 478 *csum += buf[0]; 479 *(*p)++ = buf[0]; 480 481 /* Don't go past '~'. */ 482 if (remaining > 97) 483 remaining = 97; 484 485 for (n = 1; n < remaining; n++) 486 if (buf[n] != buf[0]) 487 break; 488 489 /* N is the index of the first character not the same as buf[0]. 490 buf[0] is counted twice, so by decrementing N, we get the number 491 of characters the RLE sequence will replace. */ 492 n--; 493 494 if (n < 3) 495 return 1; 496 497 /* Skip the frame characters. The manual says to skip '+' and '-' 498 also, but there's no reason to. Unfortunately these two unusable 499 characters double the encoded length of a four byte zero 500 value. */ 501 while (n + 29 == '$' || n + 29 == '#') 502 n--; 503 504 *csum += '*'; 505 *(*p)++ = '*'; 506 *csum += n + 29; 507 *(*p)++ = n + 29; 508 509 return n + 1; 510} 511 512#endif 513 514#ifndef IN_PROCESS_AGENT 515 516/* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */ 517 518char * 519write_ptid (char *buf, ptid_t ptid) 520{ 521 client_state &cs = get_client_state (); 522 int pid, tid; 523 524 if (cs.multi_process) 525 { 526 pid = ptid.pid (); 527 if (pid < 0) 528 buf += sprintf (buf, "p-%x.", -pid); 529 else 530 buf += sprintf (buf, "p%x.", pid); 531 } 532 tid = ptid.lwp (); 533 if (tid < 0) 534 buf += sprintf (buf, "-%x", -tid); 535 else 536 buf += sprintf (buf, "%x", tid); 537 538 return buf; 539} 540 541static ULONGEST 542hex_or_minus_one (const char *buf, const char **obuf) 543{ 544 ULONGEST ret; 545 546 if (startswith (buf, "-1")) 547 { 548 ret = (ULONGEST) -1; 549 buf += 2; 550 } 551 else 552 buf = unpack_varlen_hex (buf, &ret); 553 554 if (obuf) 555 *obuf = buf; 556 557 return ret; 558} 559 560/* Extract a PTID from BUF. If non-null, OBUF is set to the to one 561 passed the last parsed char. Returns null_ptid on error. */ 562ptid_t 563read_ptid (const char *buf, const char **obuf) 564{ 565 const char *p = buf; 566 const char *pp; 567 ULONGEST pid = 0, tid = 0; 568 569 if (*p == 'p') 570 { 571 /* Multi-process ptid. */ 572 pp = unpack_varlen_hex (p + 1, &pid); 573 if (*pp != '.') 574 error ("invalid remote ptid: %s\n", p); 575 576 p = pp + 1; 577 578 tid = hex_or_minus_one (p, &pp); 579 580 if (obuf) 581 *obuf = pp; 582 return ptid_t (pid, tid); 583 } 584 585 /* No multi-process. Just a tid. */ 586 tid = hex_or_minus_one (p, &pp); 587 588 /* Since GDB is not sending a process id (multi-process extensions 589 are off), then there's only one process. Default to the first in 590 the list. */ 591 pid = pid_of (get_first_process ()); 592 593 if (obuf) 594 *obuf = pp; 595 return ptid_t (pid, tid); 596} 597 598/* Write COUNT bytes in BUF to the client. 599 The result is the number of bytes written or -1 if error. 600 This may return less than COUNT. */ 601 602static int 603write_prim (const void *buf, int count) 604{ 605 if (remote_connection_is_stdio ()) 606 return write (fileno (stdout), buf, count); 607 else 608 return write (remote_desc, buf, count); 609} 610 611/* Read COUNT bytes from the client and store in BUF. 612 The result is the number of bytes read or -1 if error. 613 This may return less than COUNT. */ 614 615static int 616read_prim (void *buf, int count) 617{ 618 if (remote_connection_is_stdio ()) 619 return read (fileno (stdin), buf, count); 620 else 621 return read (remote_desc, buf, count); 622} 623 624/* Send a packet to the remote machine, with error checking. 625 The data of the packet is in BUF, and the length of the 626 packet is in CNT. Returns >= 0 on success, -1 otherwise. */ 627 628static int 629putpkt_binary_1 (char *buf, int cnt, int is_notif) 630{ 631 client_state &cs = get_client_state (); 632 int i; 633 unsigned char csum = 0; 634 char *buf2; 635 char *p; 636 int cc; 637 638 buf2 = (char *) xmalloc (strlen ("$") + cnt + strlen ("#nn") + 1); 639 640 /* Copy the packet into buffer BUF2, encapsulating it 641 and giving it a checksum. */ 642 643 p = buf2; 644 if (is_notif) 645 *p++ = '%'; 646 else 647 *p++ = '$'; 648 649 for (i = 0; i < cnt;) 650 i += try_rle (buf + i, cnt - i, &csum, &p); 651 652 *p++ = '#'; 653 *p++ = tohex ((csum >> 4) & 0xf); 654 *p++ = tohex (csum & 0xf); 655 656 *p = '\0'; 657 658 /* Send it over and over until we get a positive ack. */ 659 660 do 661 { 662 if (write_prim (buf2, p - buf2) != p - buf2) 663 { 664 perror ("putpkt(write)"); 665 free (buf2); 666 return -1; 667 } 668 669 if (cs.noack_mode || is_notif) 670 { 671 /* Don't expect an ack then. */ 672 if (is_notif) 673 remote_debug_printf ("putpkt (\"%s\"); [notif]", buf2); 674 else 675 remote_debug_printf ("putpkt (\"%s\"); [noack mode]", buf2); 676 677 break; 678 } 679 680 remote_debug_printf ("putpkt (\"%s\"); [looking for ack]", buf2); 681 682 cc = readchar (); 683 684 if (cc < 0) 685 { 686 free (buf2); 687 return -1; 688 } 689 690 remote_debug_printf ("[received '%c' (0x%x)]", cc, cc); 691 692 /* Check for an input interrupt while we're here. */ 693 if (cc == '\003' && current_thread != NULL) 694 the_target->request_interrupt (); 695 } 696 while (cc != '+'); 697 698 free (buf2); 699 return 1; /* Success! */ 700} 701 702int 703putpkt_binary (char *buf, int cnt) 704{ 705 return putpkt_binary_1 (buf, cnt, 0); 706} 707 708/* Send a packet to the remote machine, with error checking. The data 709 of the packet is in BUF, and the packet should be a NUL-terminated 710 string. Returns >= 0 on success, -1 otherwise. */ 711 712int 713putpkt (char *buf) 714{ 715 return putpkt_binary (buf, strlen (buf)); 716} 717 718int 719putpkt_notif (char *buf) 720{ 721 return putpkt_binary_1 (buf, strlen (buf), 1); 722} 723 724/* Come here when we get an input interrupt from the remote side. This 725 interrupt should only be active while we are waiting for the child to do 726 something. Thus this assumes readchar:bufcnt is 0. 727 About the only thing that should come through is a ^C, which 728 will cause us to request child interruption. */ 729 730static void 731input_interrupt (int unused) 732{ 733 fd_set readset; 734 struct timeval immediate = { 0, 0 }; 735 736 /* Protect against spurious interrupts. This has been observed to 737 be a problem under NetBSD 1.4 and 1.5. */ 738 739 FD_ZERO (&readset); 740 FD_SET (remote_desc, &readset); 741 if (select (remote_desc + 1, &readset, 0, 0, &immediate) > 0) 742 { 743 int cc; 744 char c = 0; 745 746 cc = read_prim (&c, 1); 747 748 if (cc == 0) 749 { 750 fprintf (stderr, "client connection closed\n"); 751 return; 752 } 753 else if (cc != 1 || c != '\003') 754 { 755 fprintf (stderr, "input_interrupt, count = %d c = %d ", cc, c); 756 if (isprint (c)) 757 fprintf (stderr, "('%c')\n", c); 758 else 759 fprintf (stderr, "('\\x%02x')\n", c & 0xff); 760 return; 761 } 762 763 the_target->request_interrupt (); 764 } 765} 766 767/* Check if the remote side sent us an interrupt request (^C). */ 768void 769check_remote_input_interrupt_request (void) 770{ 771 /* This function may be called before establishing communications, 772 therefore we need to validate the remote descriptor. */ 773 774 if (remote_desc == -1) 775 return; 776 777 input_interrupt (0); 778} 779 780/* Asynchronous I/O support. SIGIO must be unblocked when waiting, 781 in order to accept Control-C from the client, and must be blocked 782 when talking to the client. */ 783 784static void 785block_unblock_async_io (int block) 786{ 787#ifndef USE_WIN32API 788 sigset_t sigio_set; 789 790 sigemptyset (&sigio_set); 791 sigaddset (&sigio_set, SIGIO); 792 gdb_sigmask (block ? SIG_BLOCK : SIG_UNBLOCK, &sigio_set, NULL); 793#endif 794} 795 796/* Current state of asynchronous I/O. */ 797static int async_io_enabled; 798 799/* Enable asynchronous I/O. */ 800void 801enable_async_io (void) 802{ 803 if (async_io_enabled) 804 return; 805 806 block_unblock_async_io (0); 807 808 async_io_enabled = 1; 809} 810 811/* Disable asynchronous I/O. */ 812void 813disable_async_io (void) 814{ 815 if (!async_io_enabled) 816 return; 817 818 block_unblock_async_io (1); 819 820 async_io_enabled = 0; 821} 822 823void 824initialize_async_io (void) 825{ 826 /* Make sure that async I/O starts blocked. */ 827 async_io_enabled = 1; 828 disable_async_io (); 829 830 /* Install the signal handler. */ 831#ifndef USE_WIN32API 832 signal (SIGIO, input_interrupt); 833#endif 834} 835 836/* Internal buffer used by readchar. 837 These are global to readchar because reschedule_remote needs to be 838 able to tell whether the buffer is empty. */ 839 840static unsigned char readchar_buf[BUFSIZ]; 841static int readchar_bufcnt = 0; 842static unsigned char *readchar_bufp; 843 844/* Returns next char from remote GDB. -1 if error. */ 845 846static int 847readchar (void) 848{ 849 int ch; 850 851 if (readchar_bufcnt == 0) 852 { 853 readchar_bufcnt = read_prim (readchar_buf, sizeof (readchar_buf)); 854 855 if (readchar_bufcnt <= 0) 856 { 857 if (readchar_bufcnt == 0) 858 { 859 remote_debug_printf ("readchar: Got EOF"); 860 } 861 else 862 perror ("readchar"); 863 864 return -1; 865 } 866 867 readchar_bufp = readchar_buf; 868 } 869 870 readchar_bufcnt--; 871 ch = *readchar_bufp++; 872 reschedule (); 873 return ch; 874} 875 876/* Reset the readchar state machine. */ 877 878static void 879reset_readchar (void) 880{ 881 readchar_bufcnt = 0; 882 if (readchar_callback != NOT_SCHEDULED) 883 { 884 delete_timer (readchar_callback); 885 readchar_callback = NOT_SCHEDULED; 886 } 887} 888 889/* Process remaining data in readchar_buf. */ 890 891static void 892process_remaining (void *context) 893{ 894 /* This is a one-shot event. */ 895 readchar_callback = NOT_SCHEDULED; 896 897 if (readchar_bufcnt > 0) 898 handle_serial_event (0, NULL); 899} 900 901/* If there is still data in the buffer, queue another event to process it, 902 we can't sleep in select yet. */ 903 904static void 905reschedule (void) 906{ 907 if (readchar_bufcnt > 0 && readchar_callback == NOT_SCHEDULED) 908 readchar_callback = create_timer (0, process_remaining, NULL); 909} 910 911/* Read a packet from the remote machine, with error checking, 912 and store it in BUF. Returns length of packet, or negative if error. */ 913 914int 915getpkt (char *buf) 916{ 917 client_state &cs = get_client_state (); 918 char *bp; 919 unsigned char csum, c1, c2; 920 int c; 921 922 while (1) 923 { 924 csum = 0; 925 926 while (1) 927 { 928 c = readchar (); 929 930 /* The '\003' may appear before or after each packet, so 931 check for an input interrupt. */ 932 if (c == '\003') 933 { 934 the_target->request_interrupt (); 935 continue; 936 } 937 938 if (c == '$') 939 break; 940 941 remote_debug_printf ("[getpkt: discarding char '%c']", c); 942 943 if (c < 0) 944 return -1; 945 } 946 947 bp = buf; 948 while (1) 949 { 950 c = readchar (); 951 if (c < 0) 952 return -1; 953 if (c == '#') 954 break; 955 *bp++ = c; 956 csum += c; 957 } 958 *bp = 0; 959 960 c1 = fromhex (readchar ()); 961 c2 = fromhex (readchar ()); 962 963 if (csum == (c1 << 4) + c2) 964 break; 965 966 if (cs.noack_mode) 967 { 968 fprintf (stderr, 969 "Bad checksum, sentsum=0x%x, csum=0x%x, " 970 "buf=%s [no-ack-mode, Bad medium?]\n", 971 (c1 << 4) + c2, csum, buf); 972 /* Not much we can do, GDB wasn't expecting an ack/nac. */ 973 break; 974 } 975 976 fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n", 977 (c1 << 4) + c2, csum, buf); 978 if (write_prim ("-", 1) != 1) 979 return -1; 980 } 981 982 if (!cs.noack_mode) 983 { 984 remote_debug_printf ("getpkt (\"%s\"); [sending ack]", buf); 985 986 if (write_prim ("+", 1) != 1) 987 return -1; 988 989 remote_debug_printf ("[sent ack]"); 990 } 991 else 992 remote_debug_printf ("getpkt (\"%s\"); [no ack sent]", buf); 993 994 /* The readchar above may have already read a '\003' out of the socket 995 and moved it to the local buffer. For example, when GDB sends 996 vCont;c immediately followed by interrupt (see 997 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll 998 resume the inferior and wait. Since we've already moved the '\003' 999 to the local buffer, SIGIO won't help. In that case, if we don't 1000 check for interrupt after the vCont;c packet, the interrupt character 1001 would stay in the buffer unattended until after the next (unrelated) 1002 stop. */ 1003 while (readchar_bufcnt > 0 && *readchar_bufp == '\003') 1004 { 1005 /* Consume the interrupt character in the buffer. */ 1006 readchar (); 1007 the_target->request_interrupt (); 1008 } 1009 1010 return bp - buf; 1011} 1012 1013void 1014write_ok (char *buf) 1015{ 1016 buf[0] = 'O'; 1017 buf[1] = 'K'; 1018 buf[2] = '\0'; 1019} 1020 1021void 1022write_enn (char *buf) 1023{ 1024 /* Some day, we should define the meanings of the error codes... */ 1025 buf[0] = 'E'; 1026 buf[1] = '0'; 1027 buf[2] = '1'; 1028 buf[3] = '\0'; 1029} 1030 1031#endif 1032 1033#ifndef IN_PROCESS_AGENT 1034 1035static char * 1036outreg (struct regcache *regcache, int regno, char *buf) 1037{ 1038 if ((regno >> 12) != 0) 1039 *buf++ = tohex ((regno >> 12) & 0xf); 1040 if ((regno >> 8) != 0) 1041 *buf++ = tohex ((regno >> 8) & 0xf); 1042 *buf++ = tohex ((regno >> 4) & 0xf); 1043 *buf++ = tohex (regno & 0xf); 1044 *buf++ = ':'; 1045 collect_register_as_string (regcache, regno, buf); 1046 buf += 2 * register_size (regcache->tdesc, regno); 1047 *buf++ = ';'; 1048 1049 return buf; 1050} 1051 1052void 1053prepare_resume_reply (char *buf, ptid_t ptid, const target_waitstatus &status) 1054{ 1055 client_state &cs = get_client_state (); 1056 threads_debug_printf ("Writing resume reply for %s:%d", 1057 target_pid_to_str (ptid).c_str (), status.kind ()); 1058 1059 switch (status.kind ()) 1060 { 1061 case TARGET_WAITKIND_STOPPED: 1062 case TARGET_WAITKIND_FORKED: 1063 case TARGET_WAITKIND_VFORKED: 1064 case TARGET_WAITKIND_VFORK_DONE: 1065 case TARGET_WAITKIND_EXECD: 1066 case TARGET_WAITKIND_THREAD_CREATED: 1067 case TARGET_WAITKIND_SYSCALL_ENTRY: 1068 case TARGET_WAITKIND_SYSCALL_RETURN: 1069 { 1070 const char **regp; 1071 struct regcache *regcache; 1072 char *buf_start = buf; 1073 1074 if ((status.kind () == TARGET_WAITKIND_FORKED && cs.report_fork_events) 1075 || (status.kind () == TARGET_WAITKIND_VFORKED 1076 && cs.report_vfork_events)) 1077 { 1078 enum gdb_signal signal = GDB_SIGNAL_TRAP; 1079 const char *event = (status.kind () == TARGET_WAITKIND_FORKED 1080 ? "fork" : "vfork"); 1081 1082 sprintf (buf, "T%02x%s:", signal, event); 1083 buf += strlen (buf); 1084 buf = write_ptid (buf, status.child_ptid ()); 1085 strcat (buf, ";"); 1086 } 1087 else if (status.kind () == TARGET_WAITKIND_VFORK_DONE 1088 && cs.report_vfork_events) 1089 { 1090 enum gdb_signal signal = GDB_SIGNAL_TRAP; 1091 1092 sprintf (buf, "T%02xvforkdone:;", signal); 1093 } 1094 else if (status.kind () == TARGET_WAITKIND_EXECD && cs.report_exec_events) 1095 { 1096 enum gdb_signal signal = GDB_SIGNAL_TRAP; 1097 const char *event = "exec"; 1098 char hexified_pathname[PATH_MAX * 2]; 1099 1100 sprintf (buf, "T%02x%s:", signal, event); 1101 buf += strlen (buf); 1102 1103 /* Encode pathname to hexified format. */ 1104 bin2hex ((const gdb_byte *) status.execd_pathname (), 1105 hexified_pathname, 1106 strlen (status.execd_pathname ())); 1107 1108 sprintf (buf, "%s;", hexified_pathname); 1109 buf += strlen (buf); 1110 } 1111 else if (status.kind () == TARGET_WAITKIND_THREAD_CREATED 1112 && cs.report_thread_events) 1113 { 1114 enum gdb_signal signal = GDB_SIGNAL_TRAP; 1115 1116 sprintf (buf, "T%02xcreate:;", signal); 1117 } 1118 else if (status.kind () == TARGET_WAITKIND_SYSCALL_ENTRY 1119 || status.kind () == TARGET_WAITKIND_SYSCALL_RETURN) 1120 { 1121 enum gdb_signal signal = GDB_SIGNAL_TRAP; 1122 const char *event = (status.kind () == TARGET_WAITKIND_SYSCALL_ENTRY 1123 ? "syscall_entry" : "syscall_return"); 1124 1125 sprintf (buf, "T%02x%s:%x;", signal, event, 1126 status.syscall_number ()); 1127 } 1128 else 1129 sprintf (buf, "T%02x", status.sig ()); 1130 1131 if (disable_packet_T) 1132 { 1133 /* This is a bit (OK, a lot) of a kludge, however, this isn't 1134 really a user feature, but exists only so GDB can use the 1135 gdbserver to test handling of the 'S' stop reply packet, so 1136 we would rather this code be as simple as possible. 1137 1138 By this point we've started to build the 'T' stop packet, 1139 and it should look like 'Txx....' where 'x' is a hex digit. 1140 An 'S' stop packet always looks like 'Sxx', so all we do 1141 here is convert the buffer from a T packet to an S packet 1142 and the avoid adding any extra content by breaking out. */ 1143 gdb_assert (buf_start[0] == 'T'); 1144 gdb_assert (isxdigit (buf_start[1])); 1145 gdb_assert (isxdigit (buf_start[2])); 1146 buf_start[0] = 'S'; 1147 buf_start[3] = '\0'; 1148 break; 1149 } 1150 1151 buf += strlen (buf); 1152 1153 scoped_restore_current_thread restore_thread; 1154 1155 switch_to_thread (the_target, ptid); 1156 1157 regp = current_target_desc ()->expedite_regs; 1158 1159 regcache = get_thread_regcache (current_thread, 1); 1160 1161 if (the_target->stopped_by_watchpoint ()) 1162 { 1163 CORE_ADDR addr; 1164 int i; 1165 1166 memcpy (buf, "watch:", 6); 1167 buf += 6; 1168 1169 addr = the_target->stopped_data_address (); 1170 1171 /* Convert each byte of the address into two hexadecimal 1172 chars. Note that we take sizeof (void *) instead of 1173 sizeof (addr); this is to avoid sending a 64-bit 1174 address to a 32-bit GDB. */ 1175 for (i = sizeof (void *) * 2; i > 0; i--) 1176 *buf++ = tohex ((addr >> (i - 1) * 4) & 0xf); 1177 *buf++ = ';'; 1178 } 1179 else if (cs.swbreak_feature && target_stopped_by_sw_breakpoint ()) 1180 { 1181 sprintf (buf, "swbreak:;"); 1182 buf += strlen (buf); 1183 } 1184 else if (cs.hwbreak_feature && target_stopped_by_hw_breakpoint ()) 1185 { 1186 sprintf (buf, "hwbreak:;"); 1187 buf += strlen (buf); 1188 } 1189 1190 while (*regp) 1191 { 1192 buf = outreg (regcache, find_regno (regcache->tdesc, *regp), buf); 1193 regp ++; 1194 } 1195 *buf = '\0'; 1196 1197 /* Formerly, if the debugger had not used any thread features 1198 we would not burden it with a thread status response. This 1199 was for the benefit of GDB 4.13 and older. However, in 1200 recent GDB versions the check (``if (cont_thread != 0)'') 1201 does not have the desired effect because of sillyness in 1202 the way that the remote protocol handles specifying a 1203 thread. Since thread support relies on qSymbol support 1204 anyway, assume GDB can handle threads. */ 1205 1206 if (using_threads && !disable_packet_Tthread) 1207 { 1208 /* This if (1) ought to be unnecessary. But remote_wait 1209 in GDB will claim this event belongs to inferior_ptid 1210 if we do not specify a thread, and there's no way for 1211 gdbserver to know what inferior_ptid is. */ 1212 if (1 || cs.general_thread != ptid) 1213 { 1214 int core = -1; 1215 /* In non-stop, don't change the general thread behind 1216 GDB's back. */ 1217 if (!non_stop) 1218 cs.general_thread = ptid; 1219 sprintf (buf, "thread:"); 1220 buf += strlen (buf); 1221 buf = write_ptid (buf, ptid); 1222 strcat (buf, ";"); 1223 buf += strlen (buf); 1224 1225 core = target_core_of_thread (ptid); 1226 1227 if (core != -1) 1228 { 1229 sprintf (buf, "core:"); 1230 buf += strlen (buf); 1231 sprintf (buf, "%x", core); 1232 strcat (buf, ";"); 1233 buf += strlen (buf); 1234 } 1235 } 1236 } 1237 1238 if (current_process ()->dlls_changed) 1239 { 1240 strcpy (buf, "library:;"); 1241 buf += strlen (buf); 1242 current_process ()->dlls_changed = false; 1243 } 1244 } 1245 break; 1246 case TARGET_WAITKIND_EXITED: 1247 if (cs.multi_process) 1248 sprintf (buf, "W%x;process:%x", 1249 status.exit_status (), ptid.pid ()); 1250 else 1251 sprintf (buf, "W%02x", status.exit_status ()); 1252 break; 1253 case TARGET_WAITKIND_SIGNALLED: 1254 if (cs.multi_process) 1255 sprintf (buf, "X%x;process:%x", 1256 status.sig (), ptid.pid ()); 1257 else 1258 sprintf (buf, "X%02x", status.sig ()); 1259 break; 1260 case TARGET_WAITKIND_THREAD_EXITED: 1261 sprintf (buf, "w%x;", status.exit_status ()); 1262 buf += strlen (buf); 1263 buf = write_ptid (buf, ptid); 1264 break; 1265 case TARGET_WAITKIND_NO_RESUMED: 1266 sprintf (buf, "N"); 1267 break; 1268 default: 1269 error ("unhandled waitkind"); 1270 break; 1271 } 1272} 1273 1274/* See remote-utils.h. */ 1275 1276const char * 1277decode_m_packet_params (const char *from, CORE_ADDR *mem_addr_ptr, 1278 unsigned int *len_ptr, const char end_marker) 1279{ 1280 int i = 0; 1281 char ch; 1282 *mem_addr_ptr = *len_ptr = 0; 1283 1284 while ((ch = from[i++]) != ',') 1285 { 1286 *mem_addr_ptr = *mem_addr_ptr << 4; 1287 *mem_addr_ptr |= fromhex (ch) & 0x0f; 1288 } 1289 1290 while ((ch = from[i++]) != end_marker) 1291 { 1292 *len_ptr = *len_ptr << 4; 1293 *len_ptr |= fromhex (ch) & 0x0f; 1294 } 1295 1296 return from + i; 1297} 1298 1299void 1300decode_m_packet (const char *from, CORE_ADDR *mem_addr_ptr, 1301 unsigned int *len_ptr) 1302{ 1303 decode_m_packet_params (from, mem_addr_ptr, len_ptr, '\0'); 1304} 1305 1306void 1307decode_M_packet (const char *from, CORE_ADDR *mem_addr_ptr, 1308 unsigned int *len_ptr, unsigned char **to_p) 1309{ 1310 from = decode_m_packet_params (from, mem_addr_ptr, len_ptr, ':'); 1311 1312 if (*to_p == NULL) 1313 *to_p = (unsigned char *) xmalloc (*len_ptr); 1314 1315 hex2bin (from, *to_p, *len_ptr); 1316} 1317 1318int 1319decode_X_packet (char *from, int packet_len, CORE_ADDR *mem_addr_ptr, 1320 unsigned int *len_ptr, unsigned char **to_p) 1321{ 1322 int i = 0; 1323 char ch; 1324 *mem_addr_ptr = *len_ptr = 0; 1325 1326 while ((ch = from[i++]) != ',') 1327 { 1328 *mem_addr_ptr = *mem_addr_ptr << 4; 1329 *mem_addr_ptr |= fromhex (ch) & 0x0f; 1330 } 1331 1332 while ((ch = from[i++]) != ':') 1333 { 1334 *len_ptr = *len_ptr << 4; 1335 *len_ptr |= fromhex (ch) & 0x0f; 1336 } 1337 1338 if (*to_p == NULL) 1339 *to_p = (unsigned char *) xmalloc (*len_ptr); 1340 1341 if (remote_unescape_input ((const gdb_byte *) &from[i], packet_len - i, 1342 *to_p, *len_ptr) != *len_ptr) 1343 return -1; 1344 1345 return 0; 1346} 1347 1348/* Decode a qXfer write request. */ 1349 1350int 1351decode_xfer_write (char *buf, int packet_len, CORE_ADDR *offset, 1352 unsigned int *len, unsigned char *data) 1353{ 1354 char ch; 1355 char *b = buf; 1356 1357 /* Extract the offset. */ 1358 *offset = 0; 1359 while ((ch = *buf++) != ':') 1360 { 1361 *offset = *offset << 4; 1362 *offset |= fromhex (ch) & 0x0f; 1363 } 1364 1365 /* Get encoded data. */ 1366 packet_len -= buf - b; 1367 *len = remote_unescape_input ((const gdb_byte *) buf, packet_len, 1368 data, packet_len); 1369 return 0; 1370} 1371 1372/* Decode the parameters of a qSearch:memory packet. */ 1373 1374int 1375decode_search_memory_packet (const char *buf, int packet_len, 1376 CORE_ADDR *start_addrp, 1377 CORE_ADDR *search_space_lenp, 1378 gdb_byte *pattern, unsigned int *pattern_lenp) 1379{ 1380 const char *p = buf; 1381 1382 p = decode_address_to_semicolon (start_addrp, p); 1383 p = decode_address_to_semicolon (search_space_lenp, p); 1384 packet_len -= p - buf; 1385 *pattern_lenp = remote_unescape_input ((const gdb_byte *) p, packet_len, 1386 pattern, packet_len); 1387 return 0; 1388} 1389 1390static void 1391free_sym_cache (struct sym_cache *sym) 1392{ 1393 if (sym != NULL) 1394 { 1395 free (sym->name); 1396 free (sym); 1397 } 1398} 1399 1400void 1401clear_symbol_cache (struct sym_cache **symcache_p) 1402{ 1403 struct sym_cache *sym, *next; 1404 1405 /* Check the cache first. */ 1406 for (sym = *symcache_p; sym; sym = next) 1407 { 1408 next = sym->next; 1409 free_sym_cache (sym); 1410 } 1411 1412 *symcache_p = NULL; 1413} 1414 1415/* Get the address of NAME, and return it in ADDRP if found. if 1416 MAY_ASK_GDB is false, assume symbol cache misses are failures. 1417 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */ 1418 1419int 1420look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb) 1421{ 1422 client_state &cs = get_client_state (); 1423 char *p, *q; 1424 int len; 1425 struct sym_cache *sym; 1426 struct process_info *proc; 1427 1428 proc = current_process (); 1429 1430 /* Check the cache first. */ 1431 for (sym = proc->symbol_cache; sym; sym = sym->next) 1432 if (strcmp (name, sym->name) == 0) 1433 { 1434 *addrp = sym->addr; 1435 return 1; 1436 } 1437 1438 /* It might not be an appropriate time to look up a symbol, 1439 e.g. while we're trying to fetch registers. */ 1440 if (!may_ask_gdb) 1441 return 0; 1442 1443 /* Send the request. */ 1444 strcpy (cs.own_buf, "qSymbol:"); 1445 bin2hex ((const gdb_byte *) name, cs.own_buf + strlen ("qSymbol:"), 1446 strlen (name)); 1447 if (putpkt (cs.own_buf) < 0) 1448 return -1; 1449 1450 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */ 1451 len = getpkt (cs.own_buf); 1452 if (len < 0) 1453 return -1; 1454 1455 /* We ought to handle pretty much any packet at this point while we 1456 wait for the qSymbol "response". That requires re-entering the 1457 main loop. For now, this is an adequate approximation; allow 1458 GDB to read from memory and handle 'v' packets (for vFile transfers) 1459 while it figures out the address of the symbol. */ 1460 while (1) 1461 { 1462 if (cs.own_buf[0] == 'm') 1463 { 1464 CORE_ADDR mem_addr; 1465 unsigned char *mem_buf; 1466 unsigned int mem_len; 1467 1468 decode_m_packet (&cs.own_buf[1], &mem_addr, &mem_len); 1469 mem_buf = (unsigned char *) xmalloc (mem_len); 1470 if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0) 1471 bin2hex (mem_buf, cs.own_buf, mem_len); 1472 else 1473 write_enn (cs.own_buf); 1474 free (mem_buf); 1475 if (putpkt (cs.own_buf) < 0) 1476 return -1; 1477 } 1478 else if (cs.own_buf[0] == 'v') 1479 { 1480 int new_len = -1; 1481 handle_v_requests (cs.own_buf, len, &new_len); 1482 if (new_len != -1) 1483 putpkt_binary (cs.own_buf, new_len); 1484 else 1485 putpkt (cs.own_buf); 1486 } 1487 else 1488 break; 1489 len = getpkt (cs.own_buf); 1490 if (len < 0) 1491 return -1; 1492 } 1493 1494 if (!startswith (cs.own_buf, "qSymbol:")) 1495 { 1496 warning ("Malformed response to qSymbol, ignoring: %s", cs.own_buf); 1497 return -1; 1498 } 1499 1500 p = cs.own_buf + strlen ("qSymbol:"); 1501 q = p; 1502 while (*q && *q != ':') 1503 q++; 1504 1505 /* Make sure we found a value for the symbol. */ 1506 if (p == q || *q == '\0') 1507 return 0; 1508 1509 decode_address (addrp, p, q - p); 1510 1511 /* Save the symbol in our cache. */ 1512 sym = XNEW (struct sym_cache); 1513 sym->name = xstrdup (name); 1514 sym->addr = *addrp; 1515 sym->next = proc->symbol_cache; 1516 proc->symbol_cache = sym; 1517 1518 return 1; 1519} 1520 1521/* Relocate an instruction to execute at a different address. OLDLOC 1522 is the address in the inferior memory where the instruction to 1523 relocate is currently at. On input, TO points to the destination 1524 where we want the instruction to be copied (and possibly adjusted) 1525 to. On output, it points to one past the end of the resulting 1526 instruction(s). The effect of executing the instruction at TO 1527 shall be the same as if executing it at OLDLOC. For example, call 1528 instructions that implicitly push the return address on the stack 1529 should be adjusted to return to the instruction after OLDLOC; 1530 relative branches, and other PC-relative instructions need the 1531 offset adjusted; etc. Returns 0 on success, -1 on failure. */ 1532 1533int 1534relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc) 1535{ 1536 client_state &cs = get_client_state (); 1537 int len; 1538 ULONGEST written = 0; 1539 1540 /* Send the request. */ 1541 sprintf (cs.own_buf, "qRelocInsn:%s;%s", paddress (oldloc), 1542 paddress (*to)); 1543 if (putpkt (cs.own_buf) < 0) 1544 return -1; 1545 1546 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */ 1547 len = getpkt (cs.own_buf); 1548 if (len < 0) 1549 return -1; 1550 1551 /* We ought to handle pretty much any packet at this point while we 1552 wait for the qRelocInsn "response". That requires re-entering 1553 the main loop. For now, this is an adequate approximation; allow 1554 GDB to access memory. */ 1555 while (cs.own_buf[0] == 'm' || cs.own_buf[0] == 'M' || cs.own_buf[0] == 'X') 1556 { 1557 CORE_ADDR mem_addr; 1558 unsigned char *mem_buf = NULL; 1559 unsigned int mem_len; 1560 1561 if (cs.own_buf[0] == 'm') 1562 { 1563 decode_m_packet (&cs.own_buf[1], &mem_addr, &mem_len); 1564 mem_buf = (unsigned char *) xmalloc (mem_len); 1565 if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0) 1566 bin2hex (mem_buf, cs.own_buf, mem_len); 1567 else 1568 write_enn (cs.own_buf); 1569 } 1570 else if (cs.own_buf[0] == 'X') 1571 { 1572 if (decode_X_packet (&cs.own_buf[1], len - 1, &mem_addr, 1573 &mem_len, &mem_buf) < 0 1574 || target_write_memory (mem_addr, mem_buf, mem_len) != 0) 1575 write_enn (cs.own_buf); 1576 else 1577 write_ok (cs.own_buf); 1578 } 1579 else 1580 { 1581 decode_M_packet (&cs.own_buf[1], &mem_addr, &mem_len, &mem_buf); 1582 if (target_write_memory (mem_addr, mem_buf, mem_len) == 0) 1583 write_ok (cs.own_buf); 1584 else 1585 write_enn (cs.own_buf); 1586 } 1587 free (mem_buf); 1588 if (putpkt (cs.own_buf) < 0) 1589 return -1; 1590 len = getpkt (cs.own_buf); 1591 if (len < 0) 1592 return -1; 1593 } 1594 1595 if (cs.own_buf[0] == 'E') 1596 { 1597 warning ("An error occurred while relocating an instruction: %s", 1598 cs.own_buf); 1599 return -1; 1600 } 1601 1602 if (!startswith (cs.own_buf, "qRelocInsn:")) 1603 { 1604 warning ("Malformed response to qRelocInsn, ignoring: %s", 1605 cs.own_buf); 1606 return -1; 1607 } 1608 1609 unpack_varlen_hex (cs.own_buf + strlen ("qRelocInsn:"), &written); 1610 1611 *to += written; 1612 return 0; 1613} 1614 1615void 1616monitor_output (const char *msg) 1617{ 1618 int len = strlen (msg); 1619 char *buf = (char *) xmalloc (len * 2 + 2); 1620 1621 buf[0] = 'O'; 1622 bin2hex ((const gdb_byte *) msg, buf + 1, len); 1623 1624 putpkt (buf); 1625 free (buf); 1626} 1627 1628#endif 1629