gdb/remote.c

   1 /* Remote target communications for serial-line targets in custom GDB protocol
   2    Copyright 1988, 1991, 1992, 1993 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 2 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, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /* Remote communication protocol.
  21    All values are encoded in ascii hex digits.
  22
  23         Request         Packet
  24
  25         read registers  g
  26         reply           XX....X         Each byte of register data
  27                                         is described by two hex digits.
  28                                         Registers are in the internal order
  29                                         for GDB, and the bytes in a register
  30                                         are in the same order the machine uses.
  31                         or ENN          for an error.
  32
  33         write regs      GXX..XX         Each byte of register data
  34                                         is described by two hex digits.
  35         reply           OK              for success
  36                         ENN             for an error
  37
  38         read mem        mAA..AA,LLLL    AA..AA is address, LLLL is length.
  39         reply           XX..XX          XX..XX is mem contents
  40                         or ENN          NN is errno
  41
  42         write mem       MAA..AA,LLLL:XX..XX
  43                                         AA..AA is address,
  44                                         LLLL is number of bytes,
  45                                         XX..XX is data
  46         reply           OK              for success
  47                         ENN             for an error
  48
  49         cont            cAA..AA         AA..AA is address to resume
  50                                         If AA..AA is omitted,
  51                                         resume at same address.
  52
  53         step            sAA..AA         AA..AA is address to resume
  54                                         If AA..AA is omitted,
  55                                         resume at same address.
  56
  57         last signal     ?               Reply the current reason for stopping.
  58                                         This is the same reply as is generated
  59                                         for step or cont : SAA where AA is the
  60                                         signal number.
  61
  62         There is no immediate reply to step or cont.
  63         The reply comes when the machine stops.
  64         It is           SAA             AA is the "signal number"
  65
  66         or...           TAAPPPPPPPPFFFFFFFF
  67                                         where AA is the signal number,
  68                                         PPPPPPPP is the PC (PC_REGNUM), and
  69                                         FFFFFFFF is the frame ptr (FP_REGNUM).
  70
  71         kill req        k
  72 */
  73
  74 #include "defs.h"
  75 #include <string.h>
  76 #include <fcntl.h>
  77 #include "frame.h"
  78 #include "inferior.h"
  79 #include "target.h"
  80 #include "wait.h"
  81 #include "terminal.h"
  82 #include "gdbcmd.h"
  83
  84 #if !defined(DONT_USE_REMOTE)
  85 #ifdef USG
  86 #include <sys/types.h>
  87 #endif
  88
  89 #include <signal.h>
  90
  91 /* Prototypes for local functions */
  92
  93 static void
  94 remote_write_bytes PARAMS ((CORE_ADDR, char *, int));
  95
  96 static void
  97 remote_read_bytes PARAMS ((CORE_ADDR, char *, int));
  98
  99 static void
 100 remote_files_info PARAMS ((struct target_ops *));
 101
 102 static int
 103 remote_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
 104
 105 static void
 106 remote_prepare_to_store PARAMS ((void));
 107
 108 static void
 109 remote_fetch_registers PARAMS ((int));
 110
 111 static void
 112 remote_resume PARAMS ((int, int));
 113
 114 static int
 115 remote_start_remote PARAMS ((char *));
 116
 117 static void
 118 remote_open PARAMS ((char *, int));
 119
 120 static void
 121 remote_close PARAMS ((int));
 122
 123 static void
 124 remote_store_registers PARAMS ((int));
 125
 126 static void
 127 getpkt PARAMS ((char *, int));
 128
 129 static void
 130 putpkt PARAMS ((char *));
 131
 132 static void
 133 remote_send PARAMS ((char *));
 134
 135 static int
 136 readchar PARAMS ((void));
 137
 138 static int
 139 remote_wait PARAMS ((WAITTYPE *));
 140
 141 static int
 142 tohex PARAMS ((int));
 143
 144 static int
 145 fromhex PARAMS ((int));
 146
 147 static void
 148 remote_detach PARAMS ((char *, int));
 149
 150
 151 extern struct target_ops remote_ops;    /* Forward decl */
 152
 153 static int kiodebug = 0;
 154 static int timeout = 5;
 155
 156 #if 0
 157 int icache;
 158 #endif
 159
 160 /* Descriptor for I/O to remote machine.  Initialize it to -1 so that
 161    remote_open knows that we don't have a file open when the program
 162    starts.  */
 163 int remote_desc = -1;
 164
 165 #define PBUFSIZ 1024
 166
 167 /* Maximum number of bytes to read/write at once.  The value here
 168    is chosen to fill up a packet (the headers account for the 32).  */
 169 #define MAXBUFBYTES ((PBUFSIZ-32)/2)
 170
 171 /* Round up PBUFSIZ to hold all the registers, at least.  */
 172 #if REGISTER_BYTES > MAXBUFBYTES
 173 #undef  PBUFSIZ
 174 #define PBUFSIZ (REGISTER_BYTES * 2 + 32)
 175 #endif
 176 \f
 177 /* Called when SIGALRM signal sent due to alarm() timeout.  */
 178 #ifndef HAVE_TERMIO
 179 void
 180 remote_timer (signo)
 181      int signo;
 182 {
 183   if (kiodebug)
 184     printf ("remote_timer called\n");
 185
 186   alarm (timeout);
 187 }
 188 #endif
 189
 190 /* Clean up connection to a remote debugger.  */
 191
 192 /* ARGSUSED */
 193 static void
 194 remote_close (quitting)
 195      int quitting;
 196 {
 197   if (remote_desc >= 0)
 198     close (remote_desc);
 199   remote_desc = -1;
 200 }
 201
 202 /* Translate baud rates from integers to damn B_codes.  Unix should
 203    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 204
 205 #ifndef B19200
 206 #define B19200 EXTA
 207 #endif
 208 #ifndef B38400
 209 #define B38400 EXTB
 210 #endif
 211
 212
 213
 214 static struct {int rate, damn_b;} baudtab[] = {
 215         {0, B0},
 216         {50, B50},
 217         {75, B75},
 218         {110, B110},
 219         {134, B134},
 220         {150, B150},
 221         {200, B200},
 222         {300, B300},
 223         {600, B600},
 224         {1200, B1200},
 225         {1800, B1800},
 226         {2400, B2400},
 227         {4800, B4800},
 228         {9600, B9600},
 229         {19200, B19200},
 230         {38400, B38400},
 231         {-1, -1},
 232 };
 233
 234 static int
 235 damn_b (rate)
 236      int rate;
 237 {
 238   int i;
 239
 240   for (i = 0; baudtab[i].rate != -1; i++)
 241     if (rate == baudtab[i].rate) return baudtab[i].damn_b;
 242   return B38400;        /* Random */
 243 }
 244
 245 /* Stub for catch_errors.  */
 246
 247 static int
 248 remote_start_remote (dummy)
 249      char *dummy;
 250 {
 251   /* Ack any packet which the remote side has already sent.  */
 252   write (remote_desc, "+\r", 2);
 253   putpkt ("?");                 /* initiate a query from remote machine */
 254
 255   start_remote ();              /* Initialize gdb process mechanisms */
 256   return 1;
 257 }
 258
 259 /* Open a connection to a remote debugger.
 260    NAME is the filename used for communication.  */
 261
 262 static void
 263 remote_open (name, from_tty)
 264      char *name;
 265      int from_tty;
 266 {
 267   TERMINAL sg;
 268   int a_rate, b_rate = 0;
 269   int baudrate_set = 0;
 270
 271   if (name == 0)
 272     error (
 273 "To open a remote debug connection, you need to specify what serial\n\
 274 device is attached to the remote system (e.g. /dev/ttya).");
 275
 276   target_preopen (from_tty);
 277
 278   remote_close (0);
 279
 280 #if 0
 281   dcache_init ();
 282 #endif
 283
 284   remote_desc = open (name, O_RDWR);
 285   if (remote_desc < 0)
 286     perror_with_name (name);
 287
 288   if (baud_rate)
 289     {
 290       if (sscanf (baud_rate, "%d", &a_rate) == 1)
 291         {
 292           b_rate = damn_b (a_rate);
 293           baudrate_set = 1;
 294         }
 295     }
 296
 297   ioctl (remote_desc, TIOCGETP, &sg);
 298 #ifdef HAVE_TERMIO
 299   sg.c_cc[VMIN] = 0;            /* read with timeout.  */
 300   sg.c_cc[VTIME] = timeout * 10;
 301   sg.c_lflag &= ~(ICANON | ECHO);
 302   sg.c_cflag &= ~PARENB;        /* No parity */
 303   sg.c_cflag |= CS8;            /* 8-bit path */
 304   if (baudrate_set)
 305     sg.c_cflag = (sg.c_cflag & ~CBAUD) | b_rate;
 306 #else
 307   sg.sg_flags |= RAW | ANYP;
 308   sg.sg_flags &= ~ECHO;
 309   if (baudrate_set)
 310     {
 311       sg.sg_ispeed = b_rate;
 312       sg.sg_ospeed = b_rate;
 313     }
 314 #endif
 315   ioctl (remote_desc, TIOCSETP, &sg);
 316
 317   if (from_tty)
 318     {
 319       puts_filtered ("Remote debugging using ");
 320       puts_filtered (name);
 321       puts_filtered ("\n");
 322     }
 323   push_target (&remote_ops);    /* Switch to using remote target now */
 324
 325 #ifndef HAVE_TERMIO
 326 #ifndef NO_SIGINTERRUPT
 327   /* Cause SIGALRM's to make reads fail.  */
 328   if (siginterrupt (SIGALRM, 1) != 0)
 329     perror ("remote_open: error in siginterrupt");
 330 #endif
 331
 332   /* Set up read timeout timer.  */
 333   if ((void (*)()) signal (SIGALRM, remote_timer) == (void (*)()) -1)
 334     perror ("remote_open: error in signal");
 335 #endif
 336
 337   /* Start the remote connection; if error (0), discard this target. */
 338   immediate_quit++;             /* Allow user to interrupt it */
 339   if (!catch_errors (remote_start_remote, (char *)0,
 340         "Couldn't establish connection to remote target\n"))
 341     pop_target();
 342 }
 343
 344 /* remote_detach()
 345    takes a program previously attached to and detaches it.
 346    We better not have left any breakpoints
 347    in the program or it'll die when it hits one.
 348    Close the open connection to the remote debugger.
 349    Use this when you want to detach and do something else
 350    with your gdb.  */
 351
 352 static void
 353 remote_detach (args, from_tty)
 354      char *args;
 355      int from_tty;
 356 {
 357   if (args)
 358     error ("Argument given to \"detach\" when remotely debugging.");
 359
 360   pop_target ();
 361   if (from_tty)
 362     puts_filtered ("Ending remote debugging.\n");
 363 }
 364
 365 /* Convert hex digit A to a number.  */
 366
 367 static int
 368 fromhex (a)
 369      int a;
 370 {
 371   if (a >= '0' && a <= '9')
 372     return a - '0';
 373   else if (a >= 'a' && a <= 'f')
 374     return a - 'a' + 10;
 375   else
 376     error ("Reply contains invalid hex digit");
 377   return -1;
 378 }
 379
 380 /* Convert number NIB to a hex digit.  */
 381
 382 static int
 383 tohex (nib)
 384      int nib;
 385 {
 386   if (nib < 10)
 387     return '0'+nib;
 388   else
 389     return 'a'+nib-10;
 390 }
 391 \f
 392 /* Tell the remote machine to resume.  */
 393
 394 static void
 395 remote_resume (step, siggnal)
 396      int step, siggnal;
 397 {
 398   char buf[PBUFSIZ];
 399
 400   if (siggnal)
 401     error ("Can't send signals to a remote system.  Try `handle %d ignore'.",
 402            siggnal);
 403
 404 #if 0
 405   dcache_flush ();
 406 #endif
 407
 408   strcpy (buf, step ? "s": "c");
 409
 410   putpkt (buf);
 411 }
 412
 413 /* Send ^C to target to halt it.  Target will respond, and send us a
 414    packet.  */
 415
 416 void remote_interrupt(signo)
 417      int signo;
 418 {
 419
 420   if (kiodebug)
 421     printf ("remote_interrupt called\n");
 422
 423   write (remote_desc, "\003", 1);       /* Send a ^C */
 424 }
 425
 426
 427 /* Wait until the remote machine stops, then return,
 428    storing status in STATUS just as `wait' would.
 429    Returns "pid" (though it's not clear what, if anything, that
 430    means in the case of this target).  */
 431
 432 static int
 433 remote_wait (status)
 434      WAITTYPE *status;
 435 {
 436   unsigned char buf[PBUFSIZ];
 437   void (*ofunc)();
 438   unsigned char *p;
 439   int i;
 440   long regno;
 441   char regs[MAX_REGISTER_RAW_SIZE];
 442
 443   WSETEXIT ((*status), 0);
 444
 445   ofunc = (void (*)()) signal (SIGINT, remote_interrupt);
 446   getpkt ((char *) buf, 1);
 447   signal (SIGINT, ofunc);
 448
 449   if (buf[0] == 'E')
 450     error ("Remote failure reply: %s", buf);
 451   if (buf[0] == 'T')
 452     {
 453       /* Expedited reply, containing Signal, {regno, reg} repeat */
 454       /*  format is:  'Tssn...:r...;n...:r...;n...:r...;#cc', where
 455           ss = signal number
 456           n... = register number
 457           r... = register contents
 458           */
 459
 460       p = &buf[3];              /* after Txx */
 461
 462       while (*p)
 463         {
 464           regno = strtol (p, &p, 16); /* Read the register number */
 465
 466           if (*p++ != ':'
 467               || regno >= NUM_REGS)
 468             error ("Remote sent bad register number %s", buf);
 469
 470           for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
 471             {
 472               if (p[0] == 0 || p[1] == 0)
 473                 error ("Remote reply is too short: %s", buf);
 474               regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
 475               p += 2;
 476             }
 477
 478           if (*p++ != ';')
 479             error("Remote register badly formatted: %s", buf);
 480
 481           supply_register (regno, regs);
 482         }
 483     }
 484   else if (buf[0] != 'S')
 485     error ("Invalid remote reply: %s", buf);
 486
 487   WSETSTOP ((*status), (((fromhex (buf[1])) << 4) + (fromhex (buf[2]))));
 488
 489   return 0;
 490 }
 491
 492 /* Read the remote registers into the block REGS.  */
 493 /* Currently we just read all the registers, so we don't use regno.  */
 494 /* ARGSUSED */
 495 static void
 496 remote_fetch_registers (regno)
 497      int regno;
 498 {
 499   char buf[PBUFSIZ];
 500   int i;
 501   char *p;
 502   char regs[REGISTER_BYTES];
 503
 504   sprintf (buf, "g");
 505   remote_send (buf);
 506
 507   /* Reply describes registers byte by byte, each byte encoded as two
 508      hex characters.  Suck them all up, then supply them to the
 509      register cacheing/storage mechanism.  */
 510
 511   p = buf;
 512   for (i = 0; i < REGISTER_BYTES; i++)
 513     {
 514       if (p[0] == 0 || p[1] == 0)
 515         error ("Remote reply is too short: %s", buf);
 516       regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
 517       p += 2;
 518     }
 519   for (i = 0; i < NUM_REGS; i++)
 520     supply_register (i, &regs[REGISTER_BYTE(i)]);
 521 }
 522
 523 /* Prepare to store registers.  Since we send them all, we have to
 524    read out the ones we don't want to change first.  */
 525
 526 static void
 527 remote_prepare_to_store ()
 528 {
 529   /* Make sure the entire registers array is valid.  */
 530   read_register_bytes (0, (char *)NULL, REGISTER_BYTES);
 531 }
 532
 533 /* Store the remote registers from the contents of the block REGISTERS.
 534    FIXME, eventually just store one register if that's all that is needed.  */
 535
 536 /* ARGSUSED */
 537 static void
 538 remote_store_registers (regno)
 539      int regno;
 540 {
 541   char buf[PBUFSIZ];
 542   int i;
 543   char *p;
 544
 545   buf[0] = 'G';
 546
 547   /* Command describes registers byte by byte,
 548      each byte encoded as two hex characters.  */
 549
 550   p = buf + 1;
 551   for (i = 0; i < REGISTER_BYTES; i++)
 552     {
 553       *p++ = tohex ((registers[i] >> 4) & 0xf);
 554       *p++ = tohex (registers[i] & 0xf);
 555     }
 556   *p = '\0';
 557
 558   remote_send (buf);
 559 }
 560
 561 #if 0
 562 /* Read a word from remote address ADDR and return it.
 563    This goes through the data cache.  */
 564
 565 int
 566 remote_fetch_word (addr)
 567      CORE_ADDR addr;
 568 {
 569   if (icache)
 570     {
 571       extern CORE_ADDR text_start, text_end;
 572
 573       if (addr >= text_start && addr < text_end)
 574         {
 575           int buffer;
 576           xfer_core_file (addr, &buffer, sizeof (int));
 577           return buffer;
 578         }
 579     }
 580   return dcache_fetch (addr);
 581 }
 582
 583 /* Write a word WORD into remote address ADDR.
 584    This goes through the data cache.  */
 585
 586 void
 587 remote_store_word (addr, word)
 588      CORE_ADDR addr;
 589      int word;
 590 {
 591   dcache_poke (addr, word);
 592 }
 593 #endif /* 0 */
 594 \f
 595 /* Write memory data directly to the remote machine.
 596    This does not inform the data cache; the data cache uses this.
 597    MEMADDR is the address in the remote memory space.
 598    MYADDR is the address of the buffer in our space.
 599    LEN is the number of bytes.  */
 600
 601 static void
 602 remote_write_bytes (memaddr, myaddr, len)
 603      CORE_ADDR memaddr;
 604      char *myaddr;
 605      int len;
 606 {
 607   char buf[PBUFSIZ];
 608   int i;
 609   char *p;
 610
 611   if (len > PBUFSIZ / 2 - 20)
 612     abort ();
 613
 614   sprintf (buf, "M%x,%x:", memaddr, len);
 615
 616   /* We send target system values byte by byte, in increasing byte addresses,
 617      each byte encoded as two hex characters.  */
 618
 619   p = buf + strlen (buf);
 620   for (i = 0; i < len; i++)
 621     {
 622       *p++ = tohex ((myaddr[i] >> 4) & 0xf);
 623       *p++ = tohex (myaddr[i] & 0xf);
 624     }
 625   *p = '\0';
 626
 627   remote_send (buf);
 628 }
 629
 630 /* Read memory data directly from the remote machine.
 631    This does not use the data cache; the data cache uses this.
 632    MEMADDR is the address in the remote memory space.
 633    MYADDR is the address of the buffer in our space.
 634    LEN is the number of bytes.  */
 635
 636 static void
 637 remote_read_bytes (memaddr, myaddr, len)
 638      CORE_ADDR memaddr;
 639      char *myaddr;
 640      int len;
 641 {
 642   char buf[PBUFSIZ];
 643   int i;
 644   char *p;
 645
 646   if (len > PBUFSIZ / 2 - 1)
 647     abort ();
 648
 649   sprintf (buf, "m%x,%x", memaddr, len);
 650   remote_send (buf);
 651
 652   /* Reply describes memory byte by byte,
 653      each byte encoded as two hex characters.  */
 654
 655   p = buf;
 656   for (i = 0; i < len; i++)
 657     {
 658       if (p[0] == 0 || p[1] == 0)
 659         error ("Remote reply is too short: %s", buf);
 660       myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
 661       p += 2;
 662     }
 663 }
 664 \f
 665 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
 666    to or from debugger address MYADDR.  Write to inferior if SHOULD_WRITE is
 667    nonzero.  Returns length of data written or read; 0 for error.  */
 668
 669 /* ARGSUSED */
 670 static int
 671 remote_xfer_memory(memaddr, myaddr, len, should_write, target)
 672      CORE_ADDR memaddr;
 673      char *myaddr;
 674      int len;
 675      int should_write;
 676      struct target_ops *target;                 /* ignored */
 677 {
 678   int origlen = len;
 679   int xfersize;
 680   while (len > 0)
 681     {
 682       if (len > MAXBUFBYTES)
 683         xfersize = MAXBUFBYTES;
 684       else
 685         xfersize = len;
 686
 687       if (should_write)
 688         remote_write_bytes(memaddr, myaddr, xfersize);
 689       else
 690         remote_read_bytes (memaddr, myaddr, xfersize);
 691       memaddr += xfersize;
 692       myaddr  += xfersize;
 693       len     -= xfersize;
 694     }
 695   return origlen; /* no error possible */
 696 }
 697
 698 static void
 699 remote_files_info (ignore)
 700 struct target_ops *ignore;
 701 {
 702   puts_filtered ("Debugging a target over a serial line.\n");
 703 }
 704 \f
 705 /*
 706
 707 A debug packet whose contents are <data>
 708 is encapsulated for transmission in the form:
 709
 710         $ <data> # CSUM1 CSUM2
 711
 712         <data> must be ASCII alphanumeric and cannot include characters
 713         '$' or '#'
 714
 715         CSUM1 and CSUM2 are ascii hex representation of an 8-bit
 716         checksum of <data>, the most significant nibble is sent first.
 717         the hex digits 0-9,a-f are used.
 718
 719 Receiver responds with:
 720
 721         +       - if CSUM is correct and ready for next packet
 722         -       - if CSUM is incorrect
 723
 724 */
 725
 726 /* Read a single character from the remote end.
 727    (If supported, we actually read many characters and buffer them up.)
 728    Timeouts cause a zero (nul) to be returned.  */
 729
 730 static int
 731 readchar ()
 732 {
 733   static int inbuf_index, inbuf_count;
 734 #define INBUFSIZE       PBUFSIZ
 735   static char inbuf[INBUFSIZE];
 736   struct cleanup *old_chain;
 737
 738   if (inbuf_index >= inbuf_count)
 739     {
 740 #ifndef HAVE_TERMIO
 741       extern int alarm ();
 742 #endif
 743
 744       /* Time to do another read... */
 745       inbuf_index = 0;
 746       inbuf_count = 0;
 747       inbuf[0] = 0;             /* Just in case */
 748 #ifdef HAVE_TERMIO
 749       /* termio does the timeout for us.  */
 750       inbuf_count = read (remote_desc, inbuf, INBUFSIZE);
 751 #else
 752       /* Cancel alarm on error.  */
 753       old_chain = make_cleanup (alarm, (char *)0);
 754       alarm (timeout);
 755       inbuf_count = read (remote_desc, inbuf, INBUFSIZE);
 756       do_cleanups (old_chain);          /* Cancel the alarm now.  */
 757 #endif
 758     }
 759
 760   /* Just return the next character from the buffer (or a zero if we
 761      got an error and no chars were stored in inbuf).  */
 762   return inbuf[inbuf_index++] & 0x7f;
 763 }
 764
 765 /* Send the command in BUF to the remote machine,
 766    and read the reply into BUF.
 767    Report an error if we get an error reply.  */
 768
 769 static void
 770 remote_send (buf)
 771      char *buf;
 772 {
 773
 774   putpkt (buf);
 775   getpkt (buf, 0);
 776
 777   if (buf[0] == 'E')
 778     error ("Remote failure reply: %s", buf);
 779 }
 780
 781 /* Send a packet to the remote machine, with error checking.
 782    The data of the packet is in BUF.  */
 783
 784 static void
 785 putpkt (buf)
 786      char *buf;
 787 {
 788   int i;
 789   unsigned char csum = 0;
 790   char buf2[PBUFSIZ];
 791   int cnt = strlen (buf);
 792   char ch;
 793   char *p;
 794
 795   /* Copy the packet into buffer BUF2, encapsulating it
 796      and giving it a checksum.  */
 797
 798   if (cnt > sizeof(buf2) - 5)           /* Prosanity check */
 799     abort();
 800
 801   p = buf2;
 802   *p++ = '$';
 803
 804   for (i = 0; i < cnt; i++)
 805     {
 806       csum += buf[i];
 807       *p++ = buf[i];
 808     }
 809   *p++ = '#';
 810   *p++ = tohex ((csum >> 4) & 0xf);
 811   *p++ = tohex (csum & 0xf);
 812
 813   /* Send it over and over until we get a positive ack.  */
 814
 815   do {
 816     if (kiodebug)
 817       {
 818         *p = '\0';
 819         printf ("Sending packet: %s...", buf2);  fflush(stdout);
 820       }
 821     write (remote_desc, buf2, p - buf2);
 822
 823     /* read until either a timeout occurs (\0) or '+' is read */
 824     do {
 825       ch = readchar ();
 826       if (kiodebug) {
 827         if (ch == '+')
 828           printf("Ack\n");
 829         else
 830           printf ("%02X%c ", ch&0xFF, ch);
 831       }
 832     } while ((ch != '+') && (ch != '\0'));
 833   } while (ch != '+');
 834 }
 835
 836 /* Read a packet from the remote machine, with error checking,
 837    and store it in BUF.  BUF is expected to be of size PBUFSIZ.
 838    If FOREVER, wait forever rather than timing out; this is used
 839    while the target is executing user code.  */
 840
 841 static void
 842 getpkt (buf, forever)
 843      char *buf;
 844 {
 845   char *bp;
 846   unsigned char csum;
 847   int c = 0;
 848   unsigned char c1, c2;
 849   int retries = 0;
 850 #define MAX_RETRIES     10
 851
 852 #if 0
 853   /* Sorry, this will cause all hell to break loose, i.e. we'll end
 854      up in the command loop with an inferior, but (at least if this
 855      happens in remote_wait or some such place) without a current_frame,
 856      having set up prev_* in wait_for_inferior, etc.
 857
 858      If it is necessary to have such an "emergency exit", seems like
 859      the only plausible thing to do is to say the inferior died, and
 860      make the user reattach if they want to.  Perhaps with a prompt
 861      asking for confirmation.  */
 862
 863   /* allow immediate quit while reading from device, it could be hung */
 864   immediate_quit++;
 865 #endif /* 0 */
 866
 867   while (1)
 868     {
 869       /* This can loop forever if the remote side sends us characters
 870          continuously, but if it pauses, we'll get a zero from readchar
 871          because of timeout.  Then we'll count that as a retry.  */
 872       while (c != '$')
 873         if (0 == (c  = readchar()))
 874           if (!forever)
 875             {
 876               if (++retries >= MAX_RETRIES)
 877                 if (kiodebug) puts_filtered ("Timed out.\n");
 878                 goto out;
 879             }
 880
 881       /* Force csum to be zero here because of possible error retry.  */
 882       csum = 0;
 883       bp = buf;
 884
 885       while (1)
 886         {
 887           c = readchar ();
 888           if (c == '\0')
 889             {
 890               if (kiodebug)
 891                 puts_filtered ("Timeout in mid-packet, retrying\n");
 892               goto whole;               /* Start a new packet, count retries */
 893             }
 894           if (c == '$')
 895             {
 896               if (kiodebug)
 897                 puts_filtered ("Saw new packet start in middle of old one\n");
 898               goto whole;               /* Start a new packet, count retries */
 899             }
 900           if (c == '#')
 901             break;
 902           if (bp >= buf+PBUFSIZ-1)
 903           {
 904             *bp = '\0';
 905             puts_filtered ("Remote packet too long: ");
 906             puts_filtered (buf);
 907             puts_filtered ("\n");
 908             goto whole;
 909           }
 910           *bp++ = c;
 911           csum += c;
 912         }
 913       *bp = 0;
 914
 915       c1 = fromhex (readchar ());
 916       c2 = fromhex (readchar ());
 917       if ((csum & 0xff) == (c1 << 4) + c2)
 918         break;
 919       printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
 920               (c1 << 4) + c2, csum & 0xff);
 921       puts_filtered (buf);
 922       puts_filtered ("\n");
 923
 924       /* Try the whole thing again.  */
 925 whole:
 926       if (++retries < MAX_RETRIES)
 927         {
 928           write (remote_desc, "-", 1);
 929         }
 930       else
 931         {
 932           printf ("Ignoring packet error, continuing...\n");
 933           break;
 934         }
 935     }
 936
 937 out:
 938
 939 #if 0
 940   immediate_quit--;
 941 #endif
 942
 943   write (remote_desc, "+", 1);
 944
 945   if (kiodebug)
 946     fprintf (stderr,"Packet received: %s\n", buf);
 947 }
 948 \f
 949 /* The data cache leads to incorrect results because it doesn't know about
 950    volatile variables, thus making it impossible to debug functions which
 951    use hardware registers.  Therefore it is #if 0'd out.  Effect on
 952    performance is some, for backtraces of functions with a few
 953    arguments each.  For functions with many arguments, the stack
 954    frames don't fit in the cache blocks, which makes the cache less
 955    helpful.  Disabling the cache is a big performance win for fetching
 956    large structures, because the cache code fetched data in 16-byte
 957    chunks.  */
 958 #if 0
 959 /* The data cache records all the data read from the remote machine
 960    since the last time it stopped.
 961
 962    Each cache block holds 16 bytes of data
 963    starting at a multiple-of-16 address.  */
 964
 965 #define DCACHE_SIZE 64          /* Number of cache blocks */
 966
 967 struct dcache_block {
 968         struct dcache_block *next, *last;
 969         unsigned int addr;      /* Address for which data is recorded.  */
 970         int data[4];
 971 };
 972
 973 struct dcache_block dcache_free, dcache_valid;
 974
 975 /* Free all the data cache blocks, thus discarding all cached data.  */
 976
 977 static void
 978 dcache_flush ()
 979 {
 980   register struct dcache_block *db;
 981
 982   while ((db = dcache_valid.next) != &dcache_valid)
 983     {
 984       remque (db);
 985       insque (db, &dcache_free);
 986     }
 987 }
 988
 989 /*
 990  * If addr is present in the dcache, return the address of the block
 991  * containing it.
 992  */
 993
 994 struct dcache_block *
 995 dcache_hit (addr)
 996 {
 997   register struct dcache_block *db;
 998
 999   if (addr & 3)
1000     abort ();
1001
1002   /* Search all cache blocks for one that is at this address.  */
1003   db = dcache_valid.next;
1004   while (db != &dcache_valid)
1005     {
1006       if ((addr & 0xfffffff0) == db->addr)
1007         return db;
1008       db = db->next;
1009     }
1010   return NULL;
1011 }
1012
1013 /*  Return the int data at address ADDR in dcache block DC.  */
1014
1015 int
1016 dcache_value (db, addr)
1017      struct dcache_block *db;
1018      unsigned int addr;
1019 {
1020   if (addr & 3)
1021     abort ();
1022   return (db->data[(addr>>2)&3]);
1023 }
1024
1025 /* Get a free cache block, put it on the valid list,
1026    and return its address.  The caller should store into the block
1027    the address and data that it describes.  */
1028
1029 struct dcache_block *
1030 dcache_alloc ()
1031 {
1032   register struct dcache_block *db;
1033
1034   if ((db = dcache_free.next) == &dcache_free)
1035     /* If we can't get one from the free list, take last valid */
1036     db = dcache_valid.last;
1037
1038   remque (db);
1039   insque (db, &dcache_valid);
1040   return (db);
1041 }
1042
1043 /* Return the contents of the word at address ADDR in the remote machine,
1044    using the data cache.  */
1045
1046 int
1047 dcache_fetch (addr)
1048      CORE_ADDR addr;
1049 {
1050   register struct dcache_block *db;
1051
1052   db = dcache_hit (addr);
1053   if (db == 0)
1054     {
1055       db = dcache_alloc ();
1056       remote_read_bytes (addr & ~0xf, db->data, 16);
1057       db->addr = addr & ~0xf;
1058     }
1059   return (dcache_value (db, addr));
1060 }
1061
1062 /* Write the word at ADDR both in the data cache and in the remote machine.  */
1063
1064 dcache_poke (addr, data)
1065      CORE_ADDR addr;
1066      int data;
1067 {
1068   register struct dcache_block *db;
1069
1070   /* First make sure the word is IN the cache.  DB is its cache block.  */
1071   db = dcache_hit (addr);
1072   if (db == 0)
1073     {
1074       db = dcache_alloc ();
1075       remote_read_bytes (addr & ~0xf, db->data, 16);
1076       db->addr = addr & ~0xf;
1077     }
1078
1079   /* Modify the word in the cache.  */
1080   db->data[(addr>>2)&3] = data;
1081
1082   /* Send the changed word.  */
1083   remote_write_bytes (addr, &data, 4);
1084 }
1085
1086 /* Initialize the data cache.  */
1087
1088 dcache_init ()
1089 {
1090   register i;
1091   register struct dcache_block *db;
1092
1093   db = (struct dcache_block *) xmalloc (sizeof (struct dcache_block) *
1094                                         DCACHE_SIZE);
1095   dcache_free.next = dcache_free.last = &dcache_free;
1096   dcache_valid.next = dcache_valid.last = &dcache_valid;
1097   for (i=0;i<DCACHE_SIZE;i++,db++)
1098     insque (db, &dcache_free);
1099 }
1100 #endif /* 0 */
1101
1102 /* Define the target subroutine names */
1103
1104 struct target_ops remote_ops = {
1105   "remote",                     /* to_shortname */
1106   "Remote serial target in gdb-specific protocol",      /* to_longname */
1107   "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
1108 Specify the serial device it is connected to (e.g. /dev/ttya).",  /* to_doc */
1109   remote_open,                  /* to_open */
1110   remote_close,                 /* to_close */
1111   NULL,                         /* to_attach */
1112   remote_detach,                /* to_detach */
1113   remote_resume,                /* to_resume */
1114   remote_wait,                  /* to_wait */
1115   remote_fetch_registers,       /* to_fetch_registers */
1116   remote_store_registers,       /* to_store_registers */
1117   remote_prepare_to_store,      /* to_prepare_to_store */
1118   remote_xfer_memory,           /* to_xfer_memory */
1119   remote_files_info,            /* to_files_info */
1120   NULL,                         /* to_insert_breakpoint */
1121   NULL,                         /* to_remove_breakpoint */
1122   NULL,                         /* to_terminal_init */
1123   NULL,                         /* to_terminal_inferior */
1124   NULL,                         /* to_terminal_ours_for_output */
1125   NULL,                         /* to_terminal_ours */
1126   NULL,                         /* to_terminal_info */
1127   NULL,                         /* to_kill */
1128   NULL,                         /* to_load */
1129   NULL,                         /* to_lookup_symbol */
1130   NULL,                         /* to_create_inferior */
1131   NULL,                         /* to_mourn_inferior */
1132   0,                            /* to_can_run */
1133   0,                            /* to_notice_signals */
1134   process_stratum,              /* to_stratum */
1135   NULL,                         /* to_next */
1136   1,                            /* to_has_all_memory */
1137   1,                            /* to_has_memory */
1138   1,                            /* to_has_stack */
1139   1,                            /* to_has_registers */
1140   1,                            /* to_has_execution */
1141   NULL,                         /* sections */
1142   NULL,                         /* sections_end */
1143   OPS_MAGIC                     /* to_magic */
1144 };
1145
1146 void
1147 _initialize_remote ()
1148 {
1149   add_target (&remote_ops);
1150
1151   add_show_from_set (
1152     add_set_cmd ("remotedebug", no_class, var_boolean, (char *)&kiodebug,
1153                    "Set debugging of remote serial I/O.\n\
1154 When enabled, each packet sent or received with the remote target\n\
1155 is displayed.", &setlist),
1156         &showlist);
1157 }
1158
1159 #endif