1/* Remote target communications for serial-line targets using SDS' protocol. 2 3 Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2004 Free Software 4 Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, 21 Boston, MA 02111-1307, USA. */ 22 23/* This interface was written by studying the behavior of the SDS 24 monitor on an ADS 821/860 board, and by consulting the 25 documentation of the monitor that is available on Motorola's web 26 site. -sts 8/13/97 */ 27 28#include "defs.h" 29#include "gdb_string.h" 30#include <fcntl.h> 31#include "frame.h" 32#include "inferior.h" 33#include "bfd.h" 34#include "symfile.h" 35#include "target.h" 36#include "gdbcmd.h" 37#include "objfiles.h" 38#include "gdb-stabs.h" 39#include "gdbthread.h" 40#include "gdbcore.h" 41#include "regcache.h" 42 43#ifdef USG 44#include <sys/types.h> 45#endif 46 47#include <signal.h> 48#include "serial.h" 49 50extern void _initialize_remote_sds (void); 51 52/* Declarations of local functions. */ 53 54static int sds_write_bytes (CORE_ADDR, char *, int); 55 56static int sds_read_bytes (CORE_ADDR, char *, int); 57 58static void sds_files_info (struct target_ops *ignore); 59 60static int sds_xfer_memory (CORE_ADDR, char *, int, int, 61 struct mem_attrib *, struct target_ops *); 62 63static void sds_prepare_to_store (void); 64 65static void sds_fetch_registers (int); 66 67static void sds_resume (ptid_t, int, enum target_signal); 68 69static int sds_start_remote (void *); 70 71static void sds_open (char *, int); 72 73static void sds_close (int); 74 75static void sds_store_registers (int); 76 77static void sds_mourn (void); 78 79static void sds_create_inferior (char *, char *, char **); 80 81static void sds_load (char *, int); 82 83static int getmessage (unsigned char *, int); 84 85static int putmessage (unsigned char *, int); 86 87static int sds_send (unsigned char *, int); 88 89static int readchar (int); 90 91static ptid_t sds_wait (ptid_t, struct target_waitstatus *); 92 93static void sds_kill (void); 94 95static int fromhex (int); 96 97static void sds_detach (char *, int); 98 99static void sds_interrupt (int); 100 101static void sds_interrupt_twice (int); 102 103static void interrupt_query (void); 104 105static int read_frame (char *); 106 107static int sds_insert_breakpoint (CORE_ADDR, char *); 108 109static int sds_remove_breakpoint (CORE_ADDR, char *); 110 111static void init_sds_ops (void); 112 113static void sds_command (char *args, int from_tty); 114 115/* Define the target operations vector. */ 116 117static struct target_ops sds_ops; 118 119/* This was 5 seconds, which is a long time to sit and wait. 120 Unless this is going though some terminal server or multiplexer or 121 other form of hairy serial connection, I would think 2 seconds would 122 be plenty. */ 123 124static int sds_timeout = 2; 125 126/* Descriptor for I/O to remote machine. Initialize it to NULL so 127 that sds_open knows that we don't have a file open when the program 128 starts. */ 129 130static struct serial *sds_desc = NULL; 131 132/* This limit comes from the monitor. */ 133 134#define PBUFSIZ 250 135 136/* Maximum number of bytes to read/write at once. The value here 137 is chosen to fill up a packet (the headers account for the 32). */ 138#define MAXBUFBYTES ((PBUFSIZ-32)/2) 139 140static int next_msg_id; 141 142static int just_started; 143 144static int message_pending; 145 146 147/* Clean up connection to a remote debugger. */ 148 149static void 150sds_close (int quitting) 151{ 152 if (sds_desc) 153 serial_close (sds_desc); 154 sds_desc = NULL; 155} 156 157/* Stub for catch_errors. */ 158 159static int 160sds_start_remote (void *dummy) 161{ 162 int c; 163 unsigned char buf[200]; 164 165 immediate_quit++; /* Allow user to interrupt it */ 166 167 /* Ack any packet which the remote side has already sent. */ 168 serial_write (sds_desc, "{#*\r\n", 5); 169 serial_write (sds_desc, "{#}\r\n", 5); 170 171 while ((c = readchar (1)) >= 0) 172 printf_unfiltered ("%c", c); 173 printf_unfiltered ("\n"); 174 175 next_msg_id = 251; 176 177 buf[0] = 26; 178 sds_send (buf, 1); 179 180 buf[0] = 0; 181 sds_send (buf, 1); 182 183 immediate_quit--; 184 185 start_remote (); /* Initialize gdb process mechanisms */ 186 return 1; 187} 188 189/* Open a connection to a remote debugger. 190 NAME is the filename used for communication. */ 191 192static void 193sds_open (char *name, int from_tty) 194{ 195 if (name == 0) 196 error ("To open a remote debug connection, you need to specify what serial\n\ 197device is attached to the remote system (e.g. /dev/ttya)."); 198 199 target_preopen (from_tty); 200 201 unpush_target (&sds_ops); 202 203 sds_desc = serial_open (name); 204 if (!sds_desc) 205 perror_with_name (name); 206 207 if (baud_rate != -1) 208 { 209 if (serial_setbaudrate (sds_desc, baud_rate)) 210 { 211 serial_close (sds_desc); 212 perror_with_name (name); 213 } 214 } 215 216 217 serial_raw (sds_desc); 218 219 /* If there is something sitting in the buffer we might take it as a 220 response to a command, which would be bad. */ 221 serial_flush_input (sds_desc); 222 223 if (from_tty) 224 { 225 puts_filtered ("Remote debugging using "); 226 puts_filtered (name); 227 puts_filtered ("\n"); 228 } 229 push_target (&sds_ops); /* Switch to using remote target now */ 230 231 just_started = 1; 232 233 /* Start the remote connection; if error (0), discard this target. 234 In particular, if the user quits, be sure to discard it (we'd be 235 in an inconsistent state otherwise). */ 236 if (!catch_errors (sds_start_remote, NULL, 237 "Couldn't establish connection to remote target\n", 238 RETURN_MASK_ALL)) 239 pop_target (); 240} 241 242/* This takes a program previously attached to and detaches it. After 243 this is done, GDB can be used to debug some other program. We 244 better not have left any breakpoints in the target program or it'll 245 die when it hits one. */ 246 247static void 248sds_detach (char *args, int from_tty) 249{ 250 char buf[PBUFSIZ]; 251 252 if (args) 253 error ("Argument given to \"detach\" when remotely debugging."); 254 255#if 0 256 /* Tell the remote target to detach. */ 257 strcpy (buf, "D"); 258 sds_send (buf, 1); 259#endif 260 261 pop_target (); 262 if (from_tty) 263 puts_filtered ("Ending remote debugging.\n"); 264} 265 266/* Convert hex digit A to a number. */ 267 268static int 269fromhex (int a) 270{ 271 if (a >= '0' && a <= '9') 272 return a - '0'; 273 else if (a >= 'a' && a <= 'f') 274 return a - 'a' + 10; 275 else 276 error ("Reply contains invalid hex digit %d", a); 277} 278 279static int 280tob64 (unsigned char *inbuf, char *outbuf, int len) 281{ 282 int i, sum; 283 char *p; 284 285 if (len % 3 != 0) 286 error ("bad length"); 287 288 p = outbuf; 289 for (i = 0; i < len; i += 3) 290 { 291 /* Collect the next three bytes into a number. */ 292 sum = ((long) *inbuf++) << 16; 293 sum |= ((long) *inbuf++) << 8; 294 sum |= ((long) *inbuf++); 295 296 /* Spit out 4 6-bit encodings. */ 297 *p++ = ((sum >> 18) & 0x3f) + '0'; 298 *p++ = ((sum >> 12) & 0x3f) + '0'; 299 *p++ = ((sum >> 6) & 0x3f) + '0'; 300 *p++ = (sum & 0x3f) + '0'; 301 } 302 return (p - outbuf); 303} 304 305static int 306fromb64 (char *inbuf, char *outbuf, int len) 307{ 308 int i, sum; 309 310 if (len % 4 != 0) 311 error ("bad length"); 312 313 for (i = 0; i < len; i += 4) 314 { 315 /* Collect 4 6-bit digits. */ 316 sum = (*inbuf++ - '0') << 18; 317 sum |= (*inbuf++ - '0') << 12; 318 sum |= (*inbuf++ - '0') << 6; 319 sum |= (*inbuf++ - '0'); 320 321 /* Now take the resulting 24-bit number and get three bytes out 322 of it. */ 323 *outbuf++ = (sum >> 16) & 0xff; 324 *outbuf++ = (sum >> 8) & 0xff; 325 *outbuf++ = sum & 0xff; 326 } 327 328 return (len / 4) * 3; 329} 330 331 332/* Tell the remote machine to resume. */ 333 334static enum target_signal last_sent_signal = TARGET_SIGNAL_0; 335int last_sent_step; 336 337static void 338sds_resume (ptid_t ptid, int step, enum target_signal siggnal) 339{ 340 unsigned char buf[PBUFSIZ]; 341 342 last_sent_signal = siggnal; 343 last_sent_step = step; 344 345 buf[0] = (step ? 21 : 20); 346 buf[1] = 0; /* (should be signal?) */ 347 348 sds_send (buf, 2); 349} 350 351/* Send a message to target to halt it. Target will respond, and send 352 us a message pending notice. */ 353 354static void 355sds_interrupt (int signo) 356{ 357 unsigned char buf[PBUFSIZ]; 358 359 /* If this doesn't work, try more severe steps. */ 360 signal (signo, sds_interrupt_twice); 361 362 if (remote_debug) 363 fprintf_unfiltered (gdb_stdlog, "sds_interrupt called\n"); 364 365 buf[0] = 25; 366 sds_send (buf, 1); 367} 368 369static void (*ofunc) (); 370 371/* The user typed ^C twice. */ 372 373static void 374sds_interrupt_twice (int signo) 375{ 376 signal (signo, ofunc); 377 378 interrupt_query (); 379 380 signal (signo, sds_interrupt); 381} 382 383/* Ask the user what to do when an interrupt is received. */ 384 385static void 386interrupt_query (void) 387{ 388 target_terminal_ours (); 389 390 if (query ("Interrupted while waiting for the program.\n\ 391Give up (and stop debugging it)? ")) 392 { 393 target_mourn_inferior (); 394 throw_exception (RETURN_QUIT); 395 } 396 397 target_terminal_inferior (); 398} 399 400/* If nonzero, ignore the next kill. */ 401int kill_kludge; 402 403/* Wait until the remote machine stops, then return, storing status in 404 STATUS just as `wait' would. Returns "pid" (though it's not clear 405 what, if anything, that means in the case of this target). */ 406 407static ptid_t 408sds_wait (ptid_t ptid, struct target_waitstatus *status) 409{ 410 unsigned char buf[PBUFSIZ]; 411 int retlen; 412 413 status->kind = TARGET_WAITKIND_EXITED; 414 status->value.integer = 0; 415 416 ofunc = (void (*)()) signal (SIGINT, sds_interrupt); 417 418 signal (SIGINT, ofunc); 419 420 if (just_started) 421 { 422 just_started = 0; 423 status->kind = TARGET_WAITKIND_STOPPED; 424 return inferior_ptid; 425 } 426 427 while (1) 428 { 429 getmessage (buf, 1); 430 431 if (message_pending) 432 { 433 buf[0] = 26; 434 retlen = sds_send (buf, 1); 435 if (remote_debug) 436 { 437 fprintf_unfiltered (gdb_stdlog, "Signals: %02x%02x %02x %02x\n", 438 buf[0], buf[1], 439 buf[2], buf[3]); 440 } 441 message_pending = 0; 442 status->kind = TARGET_WAITKIND_STOPPED; 443 status->value.sig = TARGET_SIGNAL_TRAP; 444 goto got_status; 445 } 446 } 447got_status: 448 return inferior_ptid; 449} 450 451static unsigned char sprs[16]; 452 453/* Read the remote registers into the block REGS. */ 454/* Currently we just read all the registers, so we don't use regno. */ 455 456static void 457sds_fetch_registers (int regno) 458{ 459 unsigned char buf[PBUFSIZ]; 460 int i, retlen; 461 char *regs = alloca (DEPRECATED_REGISTER_BYTES); 462 463 /* Unimplemented registers read as all bits zero. */ 464 memset (regs, 0, DEPRECATED_REGISTER_BYTES); 465 466 buf[0] = 18; 467 buf[1] = 1; 468 buf[2] = 0; 469 retlen = sds_send (buf, 3); 470 471 for (i = 0; i < 4 * 6; ++i) 472 regs[i + 4 * 32 + 8 * 32] = buf[i]; 473 for (i = 0; i < 4 * 4; ++i) 474 sprs[i] = buf[i + 4 * 7]; 475 476 buf[0] = 18; 477 buf[1] = 2; 478 buf[2] = 0; 479 retlen = sds_send (buf, 3); 480 481 for (i = 0; i < retlen; i++) 482 regs[i] = buf[i]; 483 484 /* (should warn about reply too short) */ 485 486 for (i = 0; i < NUM_REGS; i++) 487 supply_register (i, ®s[DEPRECATED_REGISTER_BYTE (i)]); 488} 489 490/* Prepare to store registers. Since we may send them all, we have to 491 read out the ones we don't want to change first. */ 492 493static void 494sds_prepare_to_store (void) 495{ 496 /* Make sure the entire registers array is valid. */ 497 deprecated_read_register_bytes (0, (char *) NULL, DEPRECATED_REGISTER_BYTES); 498} 499 500/* Store register REGNO, or all registers if REGNO == -1, from the contents 501 of REGISTERS. FIXME: ignores errors. */ 502 503static void 504sds_store_registers (int regno) 505{ 506 unsigned char *p, buf[PBUFSIZ]; 507 int i; 508 509 /* Store all the special-purpose registers. */ 510 p = buf; 511 *p++ = 19; 512 *p++ = 1; 513 *p++ = 0; 514 *p++ = 0; 515 for (i = 0; i < 4 * 6; i++) 516 *p++ = deprecated_registers[i + 4 * 32 + 8 * 32]; 517 for (i = 0; i < 4 * 1; i++) 518 *p++ = 0; 519 for (i = 0; i < 4 * 4; i++) 520 *p++ = sprs[i]; 521 522 sds_send (buf, p - buf); 523 524 /* Store all the general-purpose registers. */ 525 p = buf; 526 *p++ = 19; 527 *p++ = 2; 528 *p++ = 0; 529 *p++ = 0; 530 for (i = 0; i < 4 * 32; i++) 531 *p++ = deprecated_registers[i]; 532 533 sds_send (buf, p - buf); 534 535} 536 537/* Write memory data directly to the remote machine. This does not 538 inform the data cache; the data cache uses this. MEMADDR is the 539 address in the remote memory space. MYADDR is the address of the 540 buffer in our space. LEN is the number of bytes. 541 542 Returns number of bytes transferred, or 0 for error. */ 543 544static int 545sds_write_bytes (CORE_ADDR memaddr, char *myaddr, int len) 546{ 547 int max_buf_size; /* Max size of packet output buffer */ 548 int origlen; 549 unsigned char buf[PBUFSIZ]; 550 int todo; 551 int i; 552 553 /* Chop the transfer down if necessary */ 554 555 max_buf_size = 150; 556 557 origlen = len; 558 while (len > 0) 559 { 560 todo = min (len, max_buf_size); 561 562 buf[0] = 13; 563 buf[1] = 0; 564 buf[2] = (int) (memaddr >> 24) & 0xff; 565 buf[3] = (int) (memaddr >> 16) & 0xff; 566 buf[4] = (int) (memaddr >> 8) & 0xff; 567 buf[5] = (int) (memaddr) & 0xff; 568 buf[6] = 1; 569 buf[7] = 0; 570 571 for (i = 0; i < todo; i++) 572 buf[i + 8] = myaddr[i]; 573 574 sds_send (buf, 8 + todo); 575 576 /* (should look at result) */ 577 578 myaddr += todo; 579 memaddr += todo; 580 len -= todo; 581 } 582 return origlen; 583} 584 585/* Read memory data directly from the remote machine. This does not 586 use the data cache; the data cache uses this. MEMADDR is the 587 address in the remote memory space. MYADDR is the address of the 588 buffer in our space. LEN is the number of bytes. 589 590 Returns number of bytes transferred, or 0 for error. */ 591 592static int 593sds_read_bytes (CORE_ADDR memaddr, char *myaddr, int len) 594{ 595 int max_buf_size; /* Max size of packet output buffer */ 596 int origlen, retlen; 597 unsigned char buf[PBUFSIZ]; 598 int todo; 599 int i; 600 601 /* Chop the transfer down if necessary */ 602 603 max_buf_size = 150; 604 605 origlen = len; 606 while (len > 0) 607 { 608 todo = min (len, max_buf_size); 609 610 buf[0] = 12; 611 buf[1] = 0; 612 buf[2] = (int) (memaddr >> 24) & 0xff; 613 buf[3] = (int) (memaddr >> 16) & 0xff; 614 buf[4] = (int) (memaddr >> 8) & 0xff; 615 buf[5] = (int) (memaddr) & 0xff; 616 buf[6] = (int) (todo >> 8) & 0xff; 617 buf[7] = (int) (todo) & 0xff; 618 buf[8] = 1; 619 620 retlen = sds_send (buf, 9); 621 622 if (retlen - 2 != todo) 623 { 624 return 0; 625 } 626 627 /* Reply describes memory byte by byte. */ 628 629 for (i = 0; i < todo; i++) 630 myaddr[i] = buf[i + 2]; 631 632 myaddr += todo; 633 memaddr += todo; 634 len -= todo; 635 } 636 637 return origlen; 638} 639 640/* Read or write LEN bytes from inferior memory at MEMADDR, 641 transferring to or from debugger address MYADDR. Write to inferior 642 if SHOULD_WRITE is nonzero. Returns length of data written or 643 read; 0 for error. TARGET is unused. */ 644 645static int 646sds_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int should_write, 647 struct mem_attrib *attrib, struct target_ops *target) 648{ 649 int res; 650 651 if (should_write) 652 res = sds_write_bytes (memaddr, myaddr, len); 653 else 654 res = sds_read_bytes (memaddr, myaddr, len); 655 656 return res; 657} 658 659 660static void 661sds_files_info (struct target_ops *ignore) 662{ 663 puts_filtered ("Debugging over a serial connection, using SDS protocol.\n"); 664} 665 666/* Stuff for dealing with the packets which are part of this protocol. 667 See comment at top of file for details. */ 668 669/* Read a single character from the remote end, masking it down to 7 bits. */ 670 671static int 672readchar (int timeout) 673{ 674 int ch; 675 676 ch = serial_readchar (sds_desc, timeout); 677 678 if (remote_debug > 1 && ch >= 0) 679 fprintf_unfiltered (gdb_stdlog, "%c(%x)", ch, ch); 680 681 switch (ch) 682 { 683 case SERIAL_EOF: 684 error ("Remote connection closed"); 685 case SERIAL_ERROR: 686 perror_with_name ("Remote communication error"); 687 case SERIAL_TIMEOUT: 688 return ch; 689 default: 690 return ch & 0x7f; 691 } 692} 693 694/* An SDS-style checksum is a sum of the bytes modulo 253. (Presumably 695 because 253, 254, and 255 are special flags in the protocol.) */ 696 697static int 698compute_checksum (int csum, char *buf, int len) 699{ 700 int i; 701 702 for (i = 0; i < len; ++i) 703 csum += (unsigned char) buf[i]; 704 705 csum %= 253; 706 return csum; 707} 708 709/* Send the command in BUF to the remote machine, and read the reply 710 into BUF also. */ 711 712static int 713sds_send (unsigned char *buf, int len) 714{ 715 putmessage (buf, len); 716 717 return getmessage (buf, 0); 718} 719 720/* Send a message to the remote machine. */ 721 722static int 723putmessage (unsigned char *buf, int len) 724{ 725 int i, enclen; 726 unsigned char csum = 0; 727 char buf2[PBUFSIZ], buf3[PBUFSIZ]; 728 unsigned char header[3]; 729 char *p; 730 731 /* Copy the packet into buffer BUF2, encapsulating it 732 and giving it a checksum. */ 733 734 if (len > 170) /* Prosanity check */ 735 internal_error (__FILE__, __LINE__, "failed internal consistency check"); 736 737 if (remote_debug) 738 { 739 fprintf_unfiltered (gdb_stdlog, "Message to send: \""); 740 for (i = 0; i < len; ++i) 741 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]); 742 fprintf_unfiltered (gdb_stdlog, "\"\n"); 743 } 744 745 p = buf2; 746 *p++ = '$'; 747 748 if (len % 3 != 0) 749 { 750 buf[len] = '\0'; 751 buf[len + 1] = '\0'; 752 } 753 754 header[1] = next_msg_id; 755 756 header[2] = len; 757 758 csum = compute_checksum (csum, buf, len); 759 csum = compute_checksum (csum, header + 1, 2); 760 761 header[0] = csum; 762 763 tob64 (header, p, 3); 764 p += 4; 765 enclen = tob64 (buf, buf3, ((len + 2) / 3) * 3); 766 767 for (i = 0; i < enclen; ++i) 768 *p++ = buf3[i]; 769 *p++ = '\r'; 770 *p++ = '\n'; 771 772 next_msg_id = (next_msg_id + 3) % 245; 773 774 /* Send it over and over until we get a positive ack. */ 775 776 while (1) 777 { 778 if (remote_debug) 779 { 780 *p = '\0'; 781 fprintf_unfiltered (gdb_stdlog, "Sending encoded: \"%s\"", buf2); 782 fprintf_unfiltered (gdb_stdlog, 783 " (Checksum %d, id %d, length %d)\n", 784 header[0], header[1], header[2]); 785 gdb_flush (gdb_stdlog); 786 } 787 if (serial_write (sds_desc, buf2, p - buf2)) 788 perror_with_name ("putmessage: write failed"); 789 790 return 1; 791 } 792} 793 794/* Come here after finding the start of the frame. Collect the rest 795 into BUF. Returns 0 on any error, 1 on success. */ 796 797static int 798read_frame (char *buf) 799{ 800 char *bp; 801 int c; 802 803 bp = buf; 804 805 while (1) 806 { 807 c = readchar (sds_timeout); 808 809 switch (c) 810 { 811 case SERIAL_TIMEOUT: 812 if (remote_debug) 813 fputs_filtered ("Timeout in mid-message, retrying\n", gdb_stdlog); 814 return 0; 815 case '$': 816 if (remote_debug) 817 fputs_filtered ("Saw new packet start in middle of old one\n", 818 gdb_stdlog); 819 return 0; /* Start a new packet, count retries */ 820 case '\r': 821 break; 822 823 case '\n': 824 { 825 *bp = '\000'; 826 if (remote_debug) 827 fprintf_unfiltered (gdb_stdlog, "Received encoded: \"%s\"\n", 828 buf); 829 return 1; 830 } 831 832 default: 833 if (bp < buf + PBUFSIZ - 1) 834 { 835 *bp++ = c; 836 continue; 837 } 838 839 *bp = '\0'; 840 puts_filtered ("Message too long: "); 841 puts_filtered (buf); 842 puts_filtered ("\n"); 843 844 return 0; 845 } 846 } 847} 848 849/* Read a packet from the remote machine, with error checking, 850 and store it in BUF. BUF is expected to be of size PBUFSIZ. 851 If FOREVER, wait forever rather than timing out; this is used 852 while the target is executing user code. */ 853 854static int 855getmessage (unsigned char *buf, int forever) 856{ 857 int c, c2, c3; 858 int tries; 859 int timeout; 860 int val, i, len, csum; 861 unsigned char header[3]; 862 unsigned char inbuf[500]; 863 864 strcpy (buf, "timeout"); 865 866 if (forever) 867 { 868 timeout = watchdog > 0 ? watchdog : -1; 869 } 870 871 else 872 timeout = sds_timeout; 873 874#define MAX_TRIES 3 875 876 for (tries = 1; tries <= MAX_TRIES; tries++) 877 { 878 /* This can loop forever if the remote side sends us characters 879 continuously, but if it pauses, we'll get a zero from readchar 880 because of timeout. Then we'll count that as a retry. */ 881 882 /* Note that we will only wait forever prior to the start of a packet. 883 After that, we expect characters to arrive at a brisk pace. They 884 should show up within sds_timeout intervals. */ 885 886 do 887 { 888 c = readchar (timeout); 889 890 if (c == SERIAL_TIMEOUT) 891 { 892 if (forever) /* Watchdog went off. Kill the target. */ 893 { 894 target_mourn_inferior (); 895 error ("Watchdog has expired. Target detached.\n"); 896 } 897 if (remote_debug) 898 fputs_filtered ("Timed out.\n", gdb_stdlog); 899 goto retry; 900 } 901 } 902 while (c != '$' && c != '{'); 903 904 /* We might have seen a "trigraph", a sequence of three characters 905 that indicate various sorts of communication state. */ 906 907 if (c == '{') 908 { 909 /* Read the other two chars of the trigraph. */ 910 c2 = readchar (timeout); 911 c3 = readchar (timeout); 912 if (remote_debug) 913 fprintf_unfiltered (gdb_stdlog, "Trigraph %c%c%c received\n", 914 c, c2, c3); 915 if (c3 == '+') 916 { 917 message_pending = 1; 918 return 0; /*???? */ 919 } 920 continue; 921 } 922 923 val = read_frame (inbuf); 924 925 if (val == 1) 926 { 927 fromb64 (inbuf, header, 4); 928 /* (should check out other bits) */ 929 fromb64 (inbuf + 4, buf, strlen (inbuf) - 4); 930 931 len = header[2]; 932 933 csum = 0; 934 csum = compute_checksum (csum, buf, len); 935 csum = compute_checksum (csum, header + 1, 2); 936 937 if (csum != header[0]) 938 fprintf_unfiltered (gdb_stderr, 939 "Checksum mismatch: computed %d, received %d\n", 940 csum, header[0]); 941 942 if (header[2] == 0xff) 943 fprintf_unfiltered (gdb_stderr, "Requesting resend...\n"); 944 945 if (remote_debug) 946 { 947 fprintf_unfiltered (gdb_stdlog, 948 "... (Got checksum %d, id %d, length %d)\n", 949 header[0], header[1], header[2]); 950 fprintf_unfiltered (gdb_stdlog, "Message received: \""); 951 for (i = 0; i < len; ++i) 952 { 953 fprintf_unfiltered (gdb_stdlog, "%02x", (unsigned char) buf[i]); 954 } 955 fprintf_unfiltered (gdb_stdlog, "\"\n"); 956 } 957 958 /* no ack required? */ 959 return len; 960 } 961 962 /* Try the whole thing again. */ 963 retry: 964 /* need to do something here */ 965 ; 966 } 967 968 /* We have tried hard enough, and just can't receive the packet. Give up. */ 969 970 printf_unfiltered ("Ignoring packet error, continuing...\n"); 971 return 0; 972} 973 974static void 975sds_kill (void) 976{ 977 /* Don't try to do anything to the target. */ 978} 979 980static void 981sds_mourn (void) 982{ 983 unpush_target (&sds_ops); 984 generic_mourn_inferior (); 985} 986 987static void 988sds_create_inferior (char *exec_file, char *args, char **env) 989{ 990 inferior_ptid = pid_to_ptid (42000); 991 992 /* Clean up from the last time we were running. */ 993 clear_proceed_status (); 994 995 /* Let the remote process run. */ 996 proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0); 997} 998 999static void 1000sds_load (char *filename, int from_tty) 1001{ 1002 generic_load (filename, from_tty); 1003 1004 inferior_ptid = null_ptid; 1005} 1006 1007/* The SDS monitor has commands for breakpoint insertion, although it 1008 it doesn't actually manage the breakpoints, it just returns the 1009 replaced instruction back to the debugger. */ 1010 1011static int 1012sds_insert_breakpoint (CORE_ADDR addr, char *contents_cache) 1013{ 1014 int i, retlen; 1015 unsigned char *p, buf[PBUFSIZ]; 1016 1017 p = buf; 1018 *p++ = 16; 1019 *p++ = 0; 1020 *p++ = (int) (addr >> 24) & 0xff; 1021 *p++ = (int) (addr >> 16) & 0xff; 1022 *p++ = (int) (addr >> 8) & 0xff; 1023 *p++ = (int) (addr) & 0xff; 1024 1025 retlen = sds_send (buf, p - buf); 1026 1027 for (i = 0; i < 4; ++i) 1028 contents_cache[i] = buf[i + 2]; 1029 1030 return 0; 1031} 1032 1033static int 1034sds_remove_breakpoint (CORE_ADDR addr, char *contents_cache) 1035{ 1036 int i, retlen; 1037 unsigned char *p, buf[PBUFSIZ]; 1038 1039 p = buf; 1040 *p++ = 17; 1041 *p++ = 0; 1042 *p++ = (int) (addr >> 24) & 0xff; 1043 *p++ = (int) (addr >> 16) & 0xff; 1044 *p++ = (int) (addr >> 8) & 0xff; 1045 *p++ = (int) (addr) & 0xff; 1046 for (i = 0; i < 4; ++i) 1047 *p++ = contents_cache[i]; 1048 1049 retlen = sds_send (buf, p - buf); 1050 1051 return 0; 1052} 1053 1054static void 1055init_sds_ops (void) 1056{ 1057 sds_ops.to_shortname = "sds"; 1058 sds_ops.to_longname = "Remote serial target with SDS protocol"; 1059 sds_ops.to_doc = "Use a remote computer via a serial line; using the SDS protocol.\n\ 1060Specify the serial device it is connected to (e.g. /dev/ttya)."; 1061 sds_ops.to_open = sds_open; 1062 sds_ops.to_close = sds_close; 1063 sds_ops.to_detach = sds_detach; 1064 sds_ops.to_resume = sds_resume; 1065 sds_ops.to_wait = sds_wait; 1066 sds_ops.to_fetch_registers = sds_fetch_registers; 1067 sds_ops.to_store_registers = sds_store_registers; 1068 sds_ops.to_prepare_to_store = sds_prepare_to_store; 1069 sds_ops.to_xfer_memory = sds_xfer_memory; 1070 sds_ops.to_files_info = sds_files_info; 1071 sds_ops.to_insert_breakpoint = sds_insert_breakpoint; 1072 sds_ops.to_remove_breakpoint = sds_remove_breakpoint; 1073 sds_ops.to_kill = sds_kill; 1074 sds_ops.to_load = sds_load; 1075 sds_ops.to_create_inferior = sds_create_inferior; 1076 sds_ops.to_mourn_inferior = sds_mourn; 1077 sds_ops.to_stratum = process_stratum; 1078 sds_ops.to_has_all_memory = 1; 1079 sds_ops.to_has_memory = 1; 1080 sds_ops.to_has_stack = 1; 1081 sds_ops.to_has_registers = 1; 1082 sds_ops.to_has_execution = 1; 1083 sds_ops.to_magic = OPS_MAGIC; 1084} 1085 1086/* Put a command string, in args, out to the monitor and display the 1087 reply message. */ 1088 1089static void 1090sds_command (char *args, int from_tty) 1091{ 1092 char *p; 1093 int i, len, retlen; 1094 unsigned char buf[1000]; 1095 1096 /* Convert hexadecimal chars into a byte buffer. */ 1097 p = args; 1098 len = 0; 1099 while (*p != '\0') 1100 { 1101 buf[len++] = fromhex (p[0]) * 16 + fromhex (p[1]); 1102 if (p[1] == '\0') 1103 break; 1104 p += 2; 1105 } 1106 1107 retlen = sds_send (buf, len); 1108 1109 printf_filtered ("Reply is "); 1110 for (i = 0; i < retlen; ++i) 1111 { 1112 printf_filtered ("%02x", buf[i]); 1113 } 1114 printf_filtered ("\n"); 1115} 1116 1117void 1118_initialize_remote_sds (void) 1119{ 1120 init_sds_ops (); 1121 add_target (&sds_ops); 1122 1123 add_show_from_set (add_set_cmd ("sdstimeout", no_class, 1124 var_integer, (char *) &sds_timeout, 1125 "Set timeout value for sds read.\n", &setlist), 1126 &showlist); 1127 1128 add_com ("sds", class_obscure, sds_command, 1129 "Send a command to the SDS monitor."); 1130} 1131