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
  22    A debug packet whose contents are <data>
  23    is encapsulated for transmission in the form:
  24
  25         $ <data> # CSUM1 CSUM2
  26
  27         <data> must be ASCII alphanumeric and cannot include characters
  28         '$' or '#'
  29
  30         CSUM1 and CSUM2 are ascii hex representation of an 8-bit
  31         checksum of <data>, the most significant nibble is sent first.
  32         the hex digits 0-9,a-f are used.
  33
  34    Receiver responds with:
  35
  36         +       - if CSUM is correct and ready for next packet
  37         -       - if CSUM is incorrect
  38
  39    <data> is as follows:
  40    All values are encoded in ascii hex digits.
  41
  42         Request         Packet
  43
  44         read registers  g
  45         reply           XX....X         Each byte of register data
  46                                         is described by two hex digits.
  47                                         Registers are in the internal order
  48                                         for GDB, and the bytes in a register
  49                                         are in the same order the machine uses.
  50                         or ENN          for an error.
  51
  52         write regs      GXX..XX         Each byte of register data
  53                                         is described by two hex digits.
  54         reply           OK              for success
  55                         ENN             for an error
  56
  57         read mem        mAA..AA,LLLL    AA..AA is address, LLLL is length.
  58         reply           XX..XX          XX..XX is mem contents
  59                                         Can be fewer bytes than requested
  60                                         if able to read only part of the data.
  61                         or ENN          NN is errno
  62
  63         write mem       MAA..AA,LLLL:XX..XX
  64                                         AA..AA is address,
  65                                         LLLL is number of bytes,
  66                                         XX..XX is data
  67         reply           OK              for success
  68                         ENN             for an error (this includes the case
  69                                         where only part of the data was
  70                                         written).
  71
  72         cont            cAA..AA         AA..AA is address to resume
  73                                         If AA..AA is omitted,
  74                                         resume at same address.
  75
  76         step            sAA..AA         AA..AA is address to resume
  77                                         If AA..AA is omitted,
  78                                         resume at same address.
  79
  80         last signal     ?               Reply the current reason for stopping.
  81                                         This is the same reply as is generated
  82                                         for step or cont : SAA where AA is the
  83                                         signal number.
  84
  85         There is no immediate reply to step or cont.
  86         The reply comes when the machine stops.
  87         It is           SAA             AA is the "signal number"
  88
  89         or...           TAAn...:r...;n:r...;n...:r...;
  90                                         AA = signal number
  91                                         n... = register number
  92                                         r... = register contents
  93         or...           WAA             The process extited, and AA is
  94                                         the exit status.  This is only
  95                                         applicable for certains sorts of
  96                                         targets.
  97         or...           NAATT;DD;BB     Relocate the object file.
  98                                         AA = signal number
  99                                         TT = text address
 100                                         DD = data address
 101                                         BB = bss address
 102                                         This is used by the NLM stub,
 103                                         which is why it only has three
 104                                         addresses rather than one per
 105                                         section: the NLM stub always
 106                                         sees only three sections, even
 107                                         though gdb may see more.
 108
 109         kill request    k
 110
 111         toggle debug    d               toggle debug flag (see 386 & 68k stubs)
 112         reset           r               reset -- see sparc stub.
 113         reserved        <other>         On other requests, the stub should
 114                                         ignore the request and send an empty
 115                                         response ($#<checksum>).  This way
 116                                         we can extend the protocol and GDB
 117                                         can tell whether the stub it is
 118                                         talking to uses the old or the new.
 119 */
 120
 121 #include "defs.h"
 122 #include <string.h>
 123 #include <fcntl.h>
 124 #include "frame.h"
 125 #include "inferior.h"
 126 #include "bfd.h"
 127 #include "symfile.h"
 128 #include "target.h"
 129 #include "wait.h"
 130 #include "terminal.h"
 131 #include "gdbcmd.h"
 132 #include "objfiles.h"
 133 #include "gdb-stabs.h"
 134
 135 #include "dcache.h"
 136
 137 #if !defined(DONT_USE_REMOTE)
 138 #ifdef USG
 139 #include <sys/types.h>
 140 #endif
 141
 142 #include <signal.h>
 143 #include "serial.h"
 144
 145 /* Prototypes for local functions */
 146
 147 static int
 148 remote_write_bytes PARAMS ((CORE_ADDR memaddr, unsigned char *myaddr, int len));
 149
 150 static int
 151 remote_read_bytes PARAMS ((CORE_ADDR memaddr, unsigned char *myaddr, int len));
 152
 153 static void
 154 remote_files_info PARAMS ((struct target_ops *ignore));
 155
 156 static int
 157 remote_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len,
 158                             int should_write, struct target_ops *target));
 159
 160 static void
 161 remote_prepare_to_store PARAMS ((void));
 162
 163 static void
 164 remote_fetch_registers PARAMS ((int regno));
 165
 166 static void
 167 remote_resume PARAMS ((int pid, int step, int siggnal));
 168
 169 static int
 170 remote_start_remote PARAMS ((char *dummy));
 171
 172 static void
 173 remote_open PARAMS ((char *name, int from_tty));
 174
 175 static void
 176 remote_close PARAMS ((int quitting));
 177
 178 static void
 179 remote_store_registers PARAMS ((int regno));
 180
 181 static void
 182 getpkt PARAMS ((char *buf, int forever));
 183
 184 static void
 185 putpkt PARAMS ((char *buf));
 186
 187 static void
 188 remote_send PARAMS ((char *buf));
 189
 190 static int
 191 readchar PARAMS ((void));
 192
 193 static int
 194 remote_wait PARAMS ((WAITTYPE *status));
 195
 196 static int
 197 tohex PARAMS ((int nib));
 198
 199 static int
 200 fromhex PARAMS ((int a));
 201
 202 static void
 203 remote_detach PARAMS ((char *args, int from_tty));
 204
 205 static void
 206 remote_interrupt PARAMS ((int signo));
 207
 208 static void
 209 remote_interrupt_twice PARAMS ((int signo));
 210
 211 extern struct target_ops remote_ops;    /* Forward decl */
 212
 213 /* This was 5 seconds, which is a long time to sit and wait.
 214    Unless this is going though some terminal server or multiplexer or
 215    other form of hairy serial connection, I would think 2 seconds would
 216    be plenty.  */
 217 static int timeout = 2;
 218
 219 #if 0
 220 int icache;
 221 #endif
 222
 223 /* FIXME: This is a hack which lets this file compile.  It should be getting
 224    this setting from remote-utils.c.  */
 225 #define remote_debug (0)
 226
 227 /* Descriptor for I/O to remote machine.  Initialize it to NULL so that
 228    remote_open knows that we don't have a file open when the program
 229    starts.  */
 230 serial_t remote_desc = NULL;
 231
 232 #define PBUFSIZ 1024
 233
 234 /* Maximum number of bytes to read/write at once.  The value here
 235    is chosen to fill up a packet (the headers account for the 32).  */
 236 #define MAXBUFBYTES ((PBUFSIZ-32)/2)
 237
 238 /* Round up PBUFSIZ to hold all the registers, at least.  */
 239 #if REGISTER_BYTES > MAXBUFBYTES
 240 #undef  PBUFSIZ
 241 #define PBUFSIZ (REGISTER_BYTES * 2 + 32)
 242 #endif
 243 \f
 244 /* Clean up connection to a remote debugger.  */
 245
 246 /* ARGSUSED */
 247 static void
 248 remote_close (quitting)
 249      int quitting;
 250 {
 251   if (remote_desc)
 252     SERIAL_CLOSE (remote_desc);
 253   remote_desc = NULL;
 254 }
 255
 256 /* Stub for catch_errors.  */
 257
 258 static int
 259 remote_start_remote (dummy)
 260      char *dummy;
 261 {
 262   immediate_quit = 1;           /* Allow user to interrupt it */
 263
 264   /* Ack any packet which the remote side has already sent.  */
 265   /* I'm not sure this \r is needed; we don't use it any other time we
 266      send an ack.  */
 267   SERIAL_WRITE (remote_desc, "+\r", 2);
 268   putpkt ("?");                 /* initiate a query from remote machine */
 269   immediate_quit = 0;
 270
 271   start_remote ();              /* Initialize gdb process mechanisms */
 272   return 1;
 273 }
 274
 275 /* Open a connection to a remote debugger.
 276    NAME is the filename used for communication.  */
 277
 278 static DCACHE *remote_dcache;
 279
 280 static void
 281 remote_open (name, from_tty)
 282      char *name;
 283      int from_tty;
 284 {
 285   if (name == 0)
 286     error (
 287 "To open a remote debug connection, you need to specify what serial\n\
 288 device is attached to the remote system (e.g. /dev/ttya).");
 289
 290   target_preopen (from_tty);
 291
 292   unpush_target (&remote_ops);
 293
 294   remote_dcache = dcache_init (remote_read_bytes, remote_write_bytes);
 295
 296   remote_desc = SERIAL_OPEN (name);
 297   if (!remote_desc)
 298     perror_with_name (name);
 299
 300 #if 0
 301   /* FIXME: This should be using remote-utils.c.  */
 302   if (baud_rate)
 303     {
 304       int rate;
 305
 306       if (sscanf (baud_rate, "%d", &rate) == 1)
 307         if (SERIAL_SETBAUDRATE (remote_desc, rate))
 308           {
 309             SERIAL_CLOSE (remote_desc);
 310             perror_with_name (name);
 311           }
 312     }
 313 #endif
 314
 315   SERIAL_RAW (remote_desc);
 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   /* Start the remote connection; if error (0), discard this target.
 326      In particular, if the user quits, be sure to discard it
 327      (we'd be in an inconsistent state otherwise).  */
 328   if (!catch_errors (remote_start_remote, (char *)0,
 329         "Couldn't establish connection to remote target\n", RETURN_MASK_ALL))
 330     pop_target();
 331 }
 332
 333 /* remote_detach()
 334    takes a program previously attached to and detaches it.
 335    We better not have left any breakpoints
 336    in the program or it'll die when it hits one.
 337    Close the open connection to the remote debugger.
 338    Use this when you want to detach and do something else
 339    with your gdb.  */
 340
 341 static void
 342 remote_detach (args, from_tty)
 343      char *args;
 344      int from_tty;
 345 {
 346   if (args)
 347     error ("Argument given to \"detach\" when remotely debugging.");
 348
 349   pop_target ();
 350   if (from_tty)
 351     puts_filtered ("Ending remote debugging.\n");
 352 }
 353
 354 /* Convert hex digit A to a number.  */
 355
 356 static int
 357 fromhex (a)
 358      int a;
 359 {
 360   if (a >= '0' && a <= '9')
 361     return a - '0';
 362   else if (a >= 'a' && a <= 'f')
 363     return a - 'a' + 10;
 364   else
 365     error ("Reply contains invalid hex digit");
 366   return -1;
 367 }
 368
 369 /* Convert number NIB to a hex digit.  */
 370
 371 static int
 372 tohex (nib)
 373      int nib;
 374 {
 375   if (nib < 10)
 376     return '0'+nib;
 377   else
 378     return 'a'+nib-10;
 379 }
 380 \f
 381 /* Tell the remote machine to resume.  */
 382
 383 static void
 384 remote_resume (pid, step, siggnal)
 385      int pid, step, siggnal;
 386 {
 387   char buf[PBUFSIZ];
 388
 389   if (siggnal)
 390     {
 391       char *name;
 392       target_terminal_ours_for_output ();
 393       printf_filtered ("Can't send signals to a remote system.  ");
 394       name = strsigno (siggnal);
 395       if (name)
 396         printf_filtered (name);
 397       else
 398         printf_filtered ("Signal %d", siggnal);
 399       printf_filtered (" not sent.\n");
 400       target_terminal_inferior ();
 401     }
 402
 403   dcache_flush (remote_dcache);
 404
 405   strcpy (buf, step ? "s": "c");
 406
 407   putpkt (buf);
 408 }
 409 \f
 410 /* Send ^C to target to halt it.  Target will respond, and send us a
 411    packet.  */
 412
 413 static void
 414 remote_interrupt (signo)
 415      int signo;
 416 {
 417   /* If this doesn't work, try more severe steps.  */
 418   signal (signo, remote_interrupt_twice);
 419
 420   if (remote_debug)
 421     printf ("remote_interrupt called\n");
 422
 423   SERIAL_WRITE (remote_desc, "\003", 1); /* Send a ^C */
 424 }
 425
 426 static void (*ofunc)();
 427
 428 /* The user typed ^C twice.  */
 429 static void
 430 remote_interrupt_twice (signo)
 431      int signo;
 432 {
 433   signal (signo, ofunc);
 434
 435   target_terminal_ours ();
 436   if (query ("Interrupted while waiting for the program.\n\
 437 Give up (and stop debugging it)? "))
 438     {
 439       target_mourn_inferior ();
 440       return_to_top_level (RETURN_QUIT);
 441     }
 442   else
 443     {
 444       signal (signo, remote_interrupt);
 445       target_terminal_inferior ();
 446     }
 447 }
 448
 449 /* Wait until the remote machine stops, then return,
 450    storing status in STATUS just as `wait' would.
 451    Returns "pid" (though it's not clear what, if anything, that
 452    means in the case of this target).  */
 453
 454 static int
 455 remote_wait (status)
 456      WAITTYPE *status;
 457 {
 458   unsigned char buf[PBUFSIZ];
 459
 460   WSETEXIT ((*status), 0);
 461
 462   while (1)
 463     {
 464       unsigned char *p;
 465
 466       ofunc = (void (*)()) signal (SIGINT, remote_interrupt);
 467       getpkt ((char *) buf, 1);
 468       signal (SIGINT, ofunc);
 469
 470       if (buf[0] == 'E')
 471         warning ("Remote failure reply: %s", buf);
 472       else if (buf[0] == 'T')
 473         {
 474           int i;
 475           long regno;
 476           char regs[MAX_REGISTER_RAW_SIZE];
 477
 478           /* Expedited reply, containing Signal, {regno, reg} repeat */
 479           /*  format is:  'Tssn...:r...;n...:r...;n...:r...;#cc', where
 480               ss = signal number
 481               n... = register number
 482               r... = register contents
 483               */
 484
 485           p = &buf[3];          /* after Txx */
 486
 487           while (*p)
 488             {
 489               unsigned char *p1;
 490
 491               regno = strtol (p, &p1, 16); /* Read the register number */
 492
 493               if (p1 == p)
 494                 warning ("Remote sent badly formed register number: %s\nPacket: '%s'\n",
 495                          p1, buf);
 496
 497               p = p1;
 498
 499               if (*p++ != ':')
 500                 warning ("Malformed packet (missing colon): %s\nPacket: '%s'\n",
 501                          p, buf);
 502
 503               if (regno >= NUM_REGS)
 504                 warning ("Remote sent bad register number %d: %s\nPacket: '%s'\n",
 505                          regno, p, buf);
 506
 507               for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
 508                 {
 509                   if (p[0] == 0 || p[1] == 0)
 510                     warning ("Remote reply is too short: %s", buf);
 511                   regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
 512                   p += 2;
 513                 }
 514
 515               if (*p++ != ';')
 516                 warning ("Remote register badly formatted: %s", buf);
 517
 518               supply_register (regno, regs);
 519             }
 520           break;
 521         }
 522       else if (buf[0] == 'N')
 523         {
 524           unsigned char *p1;
 525           bfd_vma text_addr, data_addr, bss_addr;
 526
 527           /* Relocate object file.  Format is NAATT;DD;BB where AA is
 528              the signal number, TT is the new text address, DD is the
 529              new data address, and BB is the new bss address.  This is
 530              used by the NLM stub; gdb may see more sections.  */
 531           p = &buf[3];
 532           text_addr = strtol (p, &p1, 16);
 533           if (p1 == p || *p1 != ';')
 534             warning ("Malformed relocation packet: Packet '%s'", buf);
 535           p = p1 + 1;
 536           data_addr = strtol (p, &p1, 16);
 537           if (p1 == p || *p1 != ';')
 538             warning ("Malformed relocation packet: Packet '%s'", buf);
 539           p = p1 + 1;
 540           bss_addr = strtol (p, &p1, 16);
 541           if (p1 == p)
 542             warning ("Malformed relocation packet: Packet '%s'", buf);
 543
 544           if (symfile_objfile != NULL)
 545             {
 546               struct section_offsets *offs;
 547
 548               /* FIXME: Why don't the various symfile_offsets routines
 549                  in the sym_fns vectors set this?  */
 550               if (symfile_objfile->num_sections == 0)
 551                 symfile_objfile->num_sections = SECT_OFF_MAX;
 552
 553               offs = ((struct section_offsets *)
 554                       alloca (sizeof (struct section_offsets)
 555                               + (symfile_objfile->num_sections
 556                                  * sizeof (offs->offsets))));
 557               memcpy (offs, symfile_objfile->section_offsets,
 558                       (sizeof (struct section_offsets)
 559                        + (symfile_objfile->num_sections
 560                           * sizeof (offs->offsets))));
 561               ANOFFSET (offs, SECT_OFF_TEXT) = text_addr;
 562               ANOFFSET (offs, SECT_OFF_DATA) = data_addr;
 563               ANOFFSET (offs, SECT_OFF_BSS) = bss_addr;
 564
 565               objfile_relocate (symfile_objfile, offs);
 566             }
 567           break;
 568         }
 569       else if (buf[0] == 'W')
 570         {
 571           /* The remote process exited.  */
 572           WSETEXIT (*status, (fromhex (buf[1]) << 4) + fromhex (buf[2]));
 573           return 0;
 574         }
 575       else if (buf[0] == 'S')
 576         break;
 577       else
 578         warning ("Invalid remote reply: %s", buf);
 579     }
 580
 581   WSETSTOP ((*status), (((fromhex (buf[1])) << 4) + (fromhex (buf[2]))));
 582
 583   return 0;
 584 }
 585
 586 /* Number of bytes of registers this stub implements.  */
 587 static int register_bytes_found;
 588
 589 /* Read the remote registers into the block REGS.  */
 590 /* Currently we just read all the registers, so we don't use regno.  */
 591 /* ARGSUSED */
 592 static void
 593 remote_fetch_registers (regno)
 594      int regno;
 595 {
 596   char buf[PBUFSIZ];
 597   int i;
 598   char *p;
 599   char regs[REGISTER_BYTES];
 600
 601   sprintf (buf, "g");
 602   remote_send (buf);
 603
 604   /* Unimplemented registers read as all bits zero.  */
 605   memset (regs, 0, REGISTER_BYTES);
 606
 607   /* Reply describes registers byte by byte, each byte encoded as two
 608      hex characters.  Suck them all up, then supply them to the
 609      register cacheing/storage mechanism.  */
 610
 611   p = buf;
 612   for (i = 0; i < REGISTER_BYTES; i++)
 613     {
 614       if (p[0] == 0)
 615         break;
 616       if (p[1] == 0)
 617         {
 618           warning ("Remote reply is of odd length: %s", buf);
 619           /* Don't change register_bytes_found in this case, and don't
 620              print a second warning.  */
 621           goto supply_them;
 622         }
 623       regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
 624       p += 2;
 625     }
 626
 627   if (i != register_bytes_found)
 628     {
 629       register_bytes_found = i;
 630 #ifdef REGISTER_BYTES_OK
 631       if (!REGISTER_BYTES_OK (i))
 632         warning ("Remote reply is too short: %s", buf);
 633 #endif
 634     }
 635
 636  supply_them:
 637   for (i = 0; i < NUM_REGS; i++)
 638     supply_register (i, &regs[REGISTER_BYTE(i)]);
 639 }
 640
 641 /* Prepare to store registers.  Since we send them all, we have to
 642    read out the ones we don't want to change first.  */
 643
 644 static void
 645 remote_prepare_to_store ()
 646 {
 647   /* Make sure the entire registers array is valid.  */
 648   read_register_bytes (0, (char *)NULL, REGISTER_BYTES);
 649 }
 650
 651 /* Store the remote registers from the contents of the block REGISTERS.
 652    FIXME, eventually just store one register if that's all that is needed.  */
 653
 654 /* ARGSUSED */
 655 static void
 656 remote_store_registers (regno)
 657      int regno;
 658 {
 659   char buf[PBUFSIZ];
 660   int i;
 661   char *p;
 662
 663   buf[0] = 'G';
 664
 665   /* Command describes registers byte by byte,
 666      each byte encoded as two hex characters.  */
 667
 668   p = buf + 1;
 669   /* remote_prepare_to_store insures that register_bytes_found gets set.  */
 670   for (i = 0; i < register_bytes_found; i++)
 671     {
 672       *p++ = tohex ((registers[i] >> 4) & 0xf);
 673       *p++ = tohex (registers[i] & 0xf);
 674     }
 675   *p = '\0';
 676
 677   remote_send (buf);
 678 }
 679
 680 #if 0
 681
 682 /* Use of the data cache is disabled because it loses for looking at
 683    and changing hardware I/O ports and the like.  Accepting `volatile'
 684    would perhaps be one way to fix it, but a better way which would
 685    win for more cases would be to use the executable file for the text
 686    segment, like the `icache' code below but done cleanly (in some
 687    target-independent place, perhaps in target_xfer_memory, perhaps
 688    based on assigning each target a speed or perhaps by some simpler
 689    mechanism).  */
 690
 691 /* Read a word from remote address ADDR and return it.
 692    This goes through the data cache.  */
 693
 694 static int
 695 remote_fetch_word (addr)
 696      CORE_ADDR addr;
 697 {
 698 #if 0
 699   if (icache)
 700     {
 701       extern CORE_ADDR text_start, text_end;
 702
 703       if (addr >= text_start && addr < text_end)
 704         {
 705           int buffer;
 706           xfer_core_file (addr, &buffer, sizeof (int));
 707           return buffer;
 708         }
 709     }
 710 #endif
 711   return dcache_fetch (remote_dcache, addr);
 712 }
 713
 714 /* Write a word WORD into remote address ADDR.
 715    This goes through the data cache.  */
 716
 717 static void
 718 remote_store_word (addr, word)
 719      CORE_ADDR addr;
 720      int word;
 721 {
 722   dcache_poke (remote_dcache, addr, word);
 723 }
 724 #endif /* 0 */
 725 \f
 726 /* Write memory data directly to the remote machine.
 727    This does not inform the data cache; the data cache uses this.
 728    MEMADDR is the address in the remote memory space.
 729    MYADDR is the address of the buffer in our space.
 730    LEN is the number of bytes.
 731
 732    Returns number of bytes transferred, or 0 for error.  */
 733
 734 static int
 735 remote_write_bytes (memaddr, myaddr, len)
 736      CORE_ADDR memaddr;
 737      unsigned char *myaddr;
 738      int len;
 739 {
 740   char buf[PBUFSIZ];
 741   int i;
 742   char *p;
 743
 744   if (len > PBUFSIZ / 2 - 20)
 745     abort ();
 746
 747   sprintf (buf, "M%x,%x:", memaddr, len);
 748
 749   /* We send target system values byte by byte, in increasing byte addresses,
 750      each byte encoded as two hex characters.  */
 751
 752   p = buf + strlen (buf);
 753   for (i = 0; i < len; i++)
 754     {
 755       *p++ = tohex ((myaddr[i] >> 4) & 0xf);
 756       *p++ = tohex (myaddr[i] & 0xf);
 757     }
 758   *p = '\0';
 759
 760   putpkt (buf);
 761   getpkt (buf, 0);
 762
 763   if (buf[0] == 'E')
 764     {
 765       /* There is no correspondance between what the remote protocol uses
 766          for errors and errno codes.  We would like a cleaner way of
 767          representing errors (big enough to include errno codes, bfd_error
 768          codes, and others).  But for now just return EIO.  */
 769       errno = EIO;
 770       return 0;
 771     }
 772   return len;
 773 }
 774
 775 /* Read memory data directly from the remote machine.
 776    This does not use the data cache; the data cache uses this.
 777    MEMADDR is the address in the remote memory space.
 778    MYADDR is the address of the buffer in our space.
 779    LEN is the number of bytes.
 780
 781    Returns number of bytes transferred, or 0 for error.  */
 782
 783 static int
 784 remote_read_bytes (memaddr, myaddr, len)
 785      CORE_ADDR memaddr;
 786      unsigned char *myaddr;
 787      int len;
 788 {
 789   char buf[PBUFSIZ];
 790   int i;
 791   char *p;
 792
 793   if (len > PBUFSIZ / 2 - 1)
 794     abort ();
 795
 796   sprintf (buf, "m%x,%x", memaddr, len);
 797   putpkt (buf);
 798   getpkt (buf, 0);
 799
 800   if (buf[0] == 'E')
 801     {
 802       /* There is no correspondance between what the remote protocol uses
 803          for errors and errno codes.  We would like a cleaner way of
 804          representing errors (big enough to include errno codes, bfd_error
 805          codes, and others).  But for now just return EIO.  */
 806       errno = EIO;
 807       return 0;
 808     }
 809
 810   /* Reply describes memory byte by byte,
 811      each byte encoded as two hex characters.  */
 812
 813   p = buf;
 814   for (i = 0; i < len; i++)
 815     {
 816       if (p[0] == 0 || p[1] == 0)
 817         /* Reply is short.  This means that we were able to read only part
 818            of what we wanted to.  */
 819         break;
 820       myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
 821       p += 2;
 822     }
 823   return i;
 824 }
 825 \f
 826 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
 827    to or from debugger address MYADDR.  Write to inferior if SHOULD_WRITE is
 828    nonzero.  Returns length of data written or read; 0 for error.  */
 829
 830 /* ARGSUSED */
 831 static int
 832 remote_xfer_memory(memaddr, myaddr, len, should_write, target)
 833      CORE_ADDR memaddr;
 834      char *myaddr;
 835      int len;
 836      int should_write;
 837      struct target_ops *target;                 /* ignored */
 838 {
 839   int xfersize;
 840   int bytes_xferred;
 841   int total_xferred = 0;
 842
 843   while (len > 0)
 844     {
 845       if (len > MAXBUFBYTES)
 846         xfersize = MAXBUFBYTES;
 847       else
 848         xfersize = len;
 849
 850       if (should_write)
 851         bytes_xferred = remote_write_bytes (memaddr, myaddr, xfersize);
 852       else
 853         bytes_xferred = remote_read_bytes (memaddr, myaddr, xfersize);
 854
 855       /* If we get an error, we are done xferring.  */
 856       if (bytes_xferred == 0)
 857         break;
 858
 859       memaddr += bytes_xferred;
 860       myaddr  += bytes_xferred;
 861       len     -= bytes_xferred;
 862       total_xferred += bytes_xferred;
 863     }
 864   return total_xferred;
 865 }
 866
 867 static void
 868 remote_files_info (ignore)
 869      struct target_ops *ignore;
 870 {
 871   puts_filtered ("Debugging a target over a serial line.\n");
 872 }
 873 \f
 874 /* Stuff for dealing with the packets which are part of this protocol.
 875    See comment at top of file for details.  */
 876
 877 /* Read a single character from the remote end, masking it down to 7 bits. */
 878
 879 static int
 880 readchar ()
 881 {
 882   int ch;
 883
 884   ch = SERIAL_READCHAR (remote_desc, timeout);
 885
 886   if (ch < 0)
 887     return ch;
 888
 889   return ch & 0x7f;
 890 }
 891
 892 /* Send the command in BUF to the remote machine,
 893    and read the reply into BUF.
 894    Report an error if we get an error reply.  */
 895
 896 static void
 897 remote_send (buf)
 898      char *buf;
 899 {
 900
 901   putpkt (buf);
 902   getpkt (buf, 0);
 903
 904   if (buf[0] == 'E')
 905     error ("Remote failure reply: %s", buf);
 906 }
 907
 908 /* Send a packet to the remote machine, with error checking.
 909    The data of the packet is in BUF.  */
 910
 911 static void
 912 putpkt (buf)
 913      char *buf;
 914 {
 915   int i;
 916   unsigned char csum = 0;
 917   char buf2[PBUFSIZ];
 918   int cnt = strlen (buf);
 919   int ch;
 920   char *p;
 921
 922   /* Copy the packet into buffer BUF2, encapsulating it
 923      and giving it a checksum.  */
 924
 925   if (cnt > sizeof(buf2) - 5)           /* Prosanity check */
 926     abort();
 927
 928   p = buf2;
 929   *p++ = '$';
 930
 931   for (i = 0; i < cnt; i++)
 932     {
 933       csum += buf[i];
 934       *p++ = buf[i];
 935     }
 936   *p++ = '#';
 937   *p++ = tohex ((csum >> 4) & 0xf);
 938   *p++ = tohex (csum & 0xf);
 939
 940   /* Send it over and over until we get a positive ack.  */
 941
 942   while (1)
 943     {
 944       if (remote_debug)
 945         {
 946           *p = '\0';
 947           printf ("Sending packet: %s...", buf2);  fflush(stdout);
 948         }
 949       if (SERIAL_WRITE (remote_desc, buf2, p - buf2))
 950         perror_with_name ("putpkt: write failed");
 951
 952       /* read until either a timeout occurs (-2) or '+' is read */
 953       while (1)
 954         {
 955           ch = readchar ();
 956
 957           switch (ch)
 958             {
 959             case '+':
 960               if (remote_debug)
 961                 printf("Ack\n");
 962               return;
 963             case SERIAL_TIMEOUT:
 964               break;            /* Retransmit buffer */
 965             case SERIAL_ERROR:
 966               perror_with_name ("putpkt: couldn't read ACK");
 967             case SERIAL_EOF:
 968               error ("putpkt: EOF while trying to read ACK");
 969             default:
 970               if (remote_debug)
 971                 printf ("%02X %c ", ch&0xFF, ch);
 972               continue;
 973             }
 974           break;                /* Here to retransmit */
 975         }
 976     }
 977 }
 978
 979 /* Read a packet from the remote machine, with error checking,
 980    and store it in BUF.  BUF is expected to be of size PBUFSIZ.
 981    If FOREVER, wait forever rather than timing out; this is used
 982    while the target is executing user code.  */
 983
 984 static void
 985 getpkt (buf, forever)
 986      char *buf;
 987      int forever;
 988 {
 989   char *bp;
 990   unsigned char csum;
 991   int c = 0;
 992   unsigned char c1, c2;
 993   int retries = 0;
 994 #define MAX_RETRIES     10
 995
 996   while (1)
 997     {
 998       /* This can loop forever if the remote side sends us characters
 999          continuously, but if it pauses, we'll get a zero from readchar
1000          because of timeout.  Then we'll count that as a retry.  */
1001
1002       c = readchar();
1003       if (c > 0 && c != '$')
1004         continue;
1005
1006       if (c == SERIAL_TIMEOUT)
1007         {
1008           if (forever)
1009             continue;
1010           if (++retries >= MAX_RETRIES)
1011             if (remote_debug) puts_filtered ("Timed out.\n");
1012           goto out;
1013         }
1014
1015       if (c == SERIAL_EOF)
1016         error ("Remote connection closed");
1017       if (c == SERIAL_ERROR)
1018         perror_with_name ("Remote communication error");
1019
1020       /* Force csum to be zero here because of possible error retry.  */
1021       csum = 0;
1022       bp = buf;
1023
1024       while (1)
1025         {
1026           c = readchar ();
1027           if (c == SERIAL_TIMEOUT)
1028             {
1029               if (remote_debug)
1030                 puts_filtered ("Timeout in mid-packet, retrying\n");
1031               goto whole;               /* Start a new packet, count retries */
1032             }
1033           if (c == '$')
1034             {
1035               if (remote_debug)
1036                 puts_filtered ("Saw new packet start in middle of old one\n");
1037               goto whole;               /* Start a new packet, count retries */
1038             }
1039           if (c == '#')
1040             break;
1041           if (bp >= buf+PBUFSIZ-1)
1042           {
1043             *bp = '\0';
1044             puts_filtered ("Remote packet too long: ");
1045             puts_filtered (buf);
1046             puts_filtered ("\n");
1047             goto whole;
1048           }
1049           *bp++ = c;
1050           csum += c;
1051         }
1052       *bp = 0;
1053
1054       c1 = fromhex (readchar ());
1055       c2 = fromhex (readchar ());
1056       if ((csum & 0xff) == (c1 << 4) + c2)
1057         break;
1058       printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
1059               (c1 << 4) + c2, csum & 0xff);
1060       puts_filtered (buf);
1061       puts_filtered ("\n");
1062
1063       /* Try the whole thing again.  */
1064 whole:
1065       if (++retries < MAX_RETRIES)
1066         {
1067           SERIAL_WRITE (remote_desc, "-", 1);
1068         }
1069       else
1070         {
1071           printf ("Ignoring packet error, continuing...\n");
1072           break;
1073         }
1074     }
1075
1076 out:
1077
1078   SERIAL_WRITE (remote_desc, "+", 1);
1079
1080   if (remote_debug)
1081     fprintf (stderr,"Packet received: %s\n", buf);
1082 }
1083 \f
1084 static void
1085 remote_kill ()
1086 {
1087   putpkt ("k");
1088   /* Don't wait for it to die.  I'm not really sure it matters whether
1089      we do or not.  For the existing stubs, kill is a noop.  */
1090   target_mourn_inferior ();
1091 }
1092
1093 static void
1094 remote_mourn ()
1095 {
1096   unpush_target (&remote_ops);
1097   generic_mourn_inferior ();
1098 }
1099 \f
1100 #ifdef REMOTE_BREAKPOINT
1101
1102 /* On some machines, e.g. 68k, we may use a different breakpoint instruction
1103    than other targets.  */
1104 static unsigned char break_insn[] = REMOTE_BREAKPOINT;
1105
1106 /* Check that it fits in BREAKPOINT_MAX bytes.  */
1107 static unsigned char check_break_insn_size[BREAKPOINT_MAX] = REMOTE_BREAKPOINT;
1108
1109 #else /* No REMOTE_BREAKPOINT.  */
1110
1111 /* Same old breakpoint instruction.  This code does nothing different
1112    than mem-break.c.  */
1113 static unsigned char break_insn[] = BREAKPOINT;
1114
1115 #endif /* No REMOTE_BREAKPOINT.  */
1116
1117 /* Insert a breakpoint on targets that don't have any better breakpoint
1118    support.  We read the contents of the target location and stash it,
1119    then overwrite it with a breakpoint instruction.  ADDR is the target
1120    location in the target machine.  CONTENTS_CACHE is a pointer to
1121    memory allocated for saving the target contents.  It is guaranteed
1122    by the caller to be long enough to save sizeof BREAKPOINT bytes (this
1123    is accomplished via BREAKPOINT_MAX).  */
1124
1125 static int
1126 remote_insert_breakpoint (addr, contents_cache)
1127      CORE_ADDR addr;
1128      char *contents_cache;
1129 {
1130   int val;
1131
1132   val = target_read_memory (addr, contents_cache, sizeof break_insn);
1133
1134   if (val == 0)
1135     val = target_write_memory (addr, (char *)break_insn, sizeof break_insn);
1136
1137   return val;
1138 }
1139
1140 static int
1141 remote_remove_breakpoint (addr, contents_cache)
1142      CORE_ADDR addr;
1143      char *contents_cache;
1144 {
1145   return target_write_memory (addr, contents_cache, sizeof break_insn);
1146 }
1147 \f
1148 /* Define the target subroutine names */
1149
1150 struct target_ops remote_ops = {
1151   "remote",                     /* to_shortname */
1152   "Remote serial target in gdb-specific protocol",      /* to_longname */
1153   "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
1154 Specify the serial device it is connected to (e.g. /dev/ttya).",  /* to_doc */
1155   remote_open,                  /* to_open */
1156   remote_close,                 /* to_close */
1157   NULL,                         /* to_attach */
1158   remote_detach,                /* to_detach */
1159   remote_resume,                /* to_resume */
1160   remote_wait,                  /* to_wait */
1161   remote_fetch_registers,       /* to_fetch_registers */
1162   remote_store_registers,       /* to_store_registers */
1163   remote_prepare_to_store,      /* to_prepare_to_store */
1164   remote_xfer_memory,           /* to_xfer_memory */
1165   remote_files_info,            /* to_files_info */
1166
1167   remote_insert_breakpoint,     /* to_insert_breakpoint */
1168   remote_remove_breakpoint,     /* to_remove_breakpoint */
1169
1170   NULL,                         /* to_terminal_init */
1171   NULL,                         /* to_terminal_inferior */
1172   NULL,                         /* to_terminal_ours_for_output */
1173   NULL,                         /* to_terminal_ours */
1174   NULL,                         /* to_terminal_info */
1175   remote_kill,                  /* to_kill */
1176   generic_load,                 /* to_load */
1177   NULL,                         /* to_lookup_symbol */
1178   NULL,                         /* to_create_inferior */
1179   remote_mourn,                 /* to_mourn_inferior */
1180   0,                            /* to_can_run */
1181   0,                            /* to_notice_signals */
1182   process_stratum,              /* to_stratum */
1183   NULL,                         /* to_next */
1184   1,                            /* to_has_all_memory */
1185   1,                            /* to_has_memory */
1186   1,                            /* to_has_stack */
1187   1,                            /* to_has_registers */
1188   1,                            /* to_has_execution */
1189   NULL,                         /* sections */
1190   NULL,                         /* sections_end */
1191   OPS_MAGIC                     /* to_magic */
1192 };
1193
1194 void
1195 _initialize_remote ()
1196 {
1197   add_target (&remote_ops);
1198 }
1199 #endif