gdb/remote-utils.c

   1 /* Generic support for remote debugging interfaces.
   2
   3    Copyright 1993, 1994, 1998 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 /*  This file actually contains two distinct logical "packages".  They
  23    are packaged together in this one file because they are typically
  24    used together.
  25
  26    The first package is an addition to the serial package.  The
  27    addition provides reading and writing with debugging output and
  28    timeouts based on user settable variables.  These routines are
  29    intended to support serial port based remote backends.  These
  30    functions are prefixed with sr_.
  31
  32    The second package is a collection of more or less generic
  33    functions for use by remote backends.  They support user settable
  34    variables for debugging, retries, and the like.
  35
  36    Todo:
  37
  38    * a pass through mode a la kermit or telnet.
  39    * autobaud.
  40    * ask remote to change his baud rate.
  41  */
  42
  43 #include <ctype.h>
  44
  45 #include "defs.h"
  46 #include "gdb_string.h"
  47 #include "gdbcmd.h"
  48 #include "target.h"
  49 #include "serial.h"
  50 #include "gdbcore.h"            /* for exec_bfd */
  51 #include "inferior.h"           /* for generic_mourn_inferior */
  52 #include "remote-utils.h"
  53
  54
  55 void _initialize_sr_support (void);
  56
  57 struct _sr_settings sr_settings =
  58 {
  59   4,                            /* timeout:
  60                                    remote-hms.c had 2
  61                                    remote-bug.c had "with a timeout of 2, we time out waiting for
  62                                    the prompt after an s-record dump."
  63
  64                                    remote.c had (2): This was 5 seconds, which is a long time to
  65                                    sit and wait. Unless this is going though some terminal server
  66                                    or multiplexer or other form of hairy serial connection, I
  67                                    would think 2 seconds would be plenty.
  68                                  */
  69
  70   10,                           /* retries */
  71   NULL,                         /* device */
  72   NULL,                         /* descriptor */
  73 };
  74
  75 struct gr_settings *gr_settings = NULL;
  76
  77 static void usage (char *, char *);
  78 static void sr_com (char *, int);
  79
  80 static void
  81 usage (char *proto, char *junk)
  82 {
  83   if (junk != NULL)
  84     fprintf_unfiltered (gdb_stderr, "Unrecognized arguments: `%s'.\n", junk);
  85
  86   error ("Usage: target %s [DEVICE [SPEED [DEBUG]]]\n\
  87 where DEVICE is the name of a device or HOST:PORT", proto, proto);
  88
  89   return;
  90 }
  91
  92 #define CHECKDONE(p, q) \
  93 { \
  94   if (q == p) \
  95     { \
  96       if (*p == '\0') \
  97         return; \
  98       else \
  99         usage(proto, p); \
 100     } \
 101 }
 102
 103 void
 104 sr_scan_args (char *proto, char *args)
 105 {
 106   int n;
 107   char *p, *q;
 108
 109   /* if no args, then nothing to do. */
 110   if (args == NULL || *args == '\0')
 111     return;
 112
 113   /* scan off white space.  */
 114   for (p = args; isspace (*p); ++p);;
 115
 116   /* find end of device name.  */
 117   for (q = p; *q != '\0' && !isspace (*q); ++q);;
 118
 119   /* check for missing or empty device name.  */
 120   CHECKDONE (p, q);
 121   sr_set_device (savestring (p, q - p));
 122
 123   /* look for baud rate.  */
 124   n = strtol (q, &p, 10);
 125
 126   /* check for missing or empty baud rate.  */
 127   CHECKDONE (p, q);
 128   baud_rate = n;
 129
 130   /* look for debug value.  */
 131   n = strtol (p, &q, 10);
 132
 133   /* check for missing or empty debug value.  */
 134   CHECKDONE (p, q);
 135   sr_set_debug (n);
 136
 137   /* scan off remaining white space.  */
 138   for (p = q; isspace (*p); ++p);;
 139
 140   /* if not end of string, then there's unrecognized junk. */
 141   if (*p != '\0')
 142     usage (proto, p);
 143
 144   return;
 145 }
 146
 147 void
 148 gr_generic_checkin (void)
 149 {
 150   sr_write_cr ("");
 151   gr_expect_prompt ();
 152 }
 153
 154 void
 155 gr_open (char *args, int from_tty, struct gr_settings *gr)
 156 {
 157   DCACHE *dcache;
 158
 159   target_preopen (from_tty);
 160   sr_scan_args (gr->ops->to_shortname, args);
 161   unpush_target (gr->ops);
 162
 163   gr_settings = gr;
 164
 165   if ((dcache = gr_get_dcache()) == NULL)
 166     gr_set_dcache (dcache_init (gr->readfunc, gr->writefunc));
 167   else
 168     dcache_invd (dcache);
 169
 170   if (sr_get_desc () != NULL)
 171     gr_close (0);
 172
 173   /* If no args are specified, then we use the device specified by a
 174      previous command or "set remotedevice".  But if there is no
 175      device, better stop now, not dump core.  */
 176
 177   if (sr_get_device () == NULL)
 178     usage (gr->ops->to_shortname, NULL);
 179
 180   sr_set_desc (SERIAL_OPEN (sr_get_device ()));
 181   if (!sr_get_desc ())
 182     perror_with_name ((char *) sr_get_device ());
 183
 184   if (baud_rate != -1)
 185     {
 186       if (SERIAL_SETBAUDRATE (sr_get_desc (), baud_rate) != 0)
 187         {
 188           SERIAL_CLOSE (sr_get_desc ());
 189           perror_with_name (sr_get_device ());
 190         }
 191     }
 192
 193   SERIAL_RAW (sr_get_desc ());
 194
 195   /* If there is something sitting in the buffer we might take it as a
 196      response to a command, which would be bad.  */
 197   SERIAL_FLUSH_INPUT (sr_get_desc ());
 198
 199   /* default retries */
 200   if (sr_get_retries () == 0)
 201     sr_set_retries (1);
 202
 203   /* default clear breakpoint function */
 204   if (gr_settings->clear_all_breakpoints == NULL)
 205     gr_settings->clear_all_breakpoints = remove_breakpoints;
 206
 207   if (from_tty)
 208     {
 209       printf_filtered ("Remote debugging using `%s'", sr_get_device ());
 210       if (baud_rate != -1)
 211         printf_filtered (" at baud rate of %d",
 212                          baud_rate);
 213       printf_filtered ("\n");
 214     }
 215
 216   push_target (gr->ops);
 217   gr_checkin ();
 218   gr_clear_all_breakpoints ();
 219   return;
 220 }
 221
 222 /* Read a character from the remote system masking it down to 7 bits
 223    and doing all the fancy timeout stuff.  */
 224
 225 int
 226 sr_readchar (void)
 227 {
 228   int buf;
 229
 230   buf = SERIAL_READCHAR (sr_get_desc (), sr_get_timeout ());
 231
 232   if (buf == SERIAL_TIMEOUT)
 233     error ("Timeout reading from remote system.");
 234
 235   if (sr_get_debug () > 0)
 236     printf_unfiltered ("%c", buf);
 237
 238   return buf & 0x7f;
 239 }
 240
 241 int
 242 sr_pollchar (void)
 243 {
 244   int buf;
 245
 246   buf = SERIAL_READCHAR (sr_get_desc (), 0);
 247   if (buf == SERIAL_TIMEOUT)
 248     buf = 0;
 249   if (sr_get_debug () > 0)
 250     {
 251       if (buf)
 252         printf_unfiltered ("%c", buf);
 253       else
 254         printf_unfiltered ("<empty character poll>");
 255     }
 256
 257   return buf & 0x7f;
 258 }
 259
 260 /* Keep discarding input from the remote system, until STRING is found.
 261    Let the user break out immediately.  */
 262 void
 263 sr_expect (char *string)
 264 {
 265   char *p = string;
 266
 267   immediate_quit = 1;
 268   while (1)
 269     {
 270       if (sr_readchar () == *p)
 271         {
 272           p++;
 273           if (*p == '\0')
 274             {
 275               immediate_quit = 0;
 276               return;
 277             }
 278         }
 279       else
 280         p = string;
 281     }
 282 }
 283
 284 void
 285 sr_write (char *a, int l)
 286 {
 287   int i;
 288
 289   if (SERIAL_WRITE (sr_get_desc (), a, l) != 0)
 290     perror_with_name ("sr_write: Error writing to remote");
 291
 292   if (sr_get_debug () > 0)
 293     for (i = 0; i < l; i++)
 294       printf_unfiltered ("%c", a[i]);
 295
 296   return;
 297 }
 298
 299 void
 300 sr_write_cr (char *s)
 301 {
 302   sr_write (s, strlen (s));
 303   sr_write ("\r", 1);
 304   return;
 305 }
 306
 307 int
 308 sr_timed_read (char *buf, int n)
 309 {
 310   int i;
 311   char c;
 312
 313   i = 0;
 314   while (i < n)
 315     {
 316       c = sr_readchar ();
 317
 318       if (c == 0)
 319         return i;
 320       buf[i] = c;
 321       i++;
 322
 323     }
 324   return i;
 325 }
 326
 327 /* Get a hex digit from the remote system & return its value. If
 328    ignore_space is nonzero, ignore spaces (not newline, tab, etc).  */
 329
 330 int
 331 sr_get_hex_digit (int ignore_space)
 332 {
 333   int ch;
 334
 335   while (1)
 336     {
 337       ch = sr_readchar ();
 338       if (ch >= '0' && ch <= '9')
 339         return ch - '0';
 340       else if (ch >= 'A' && ch <= 'F')
 341         return ch - 'A' + 10;
 342       else if (ch >= 'a' && ch <= 'f')
 343         return ch - 'a' + 10;
 344       else if (ch != ' ' || !ignore_space)
 345         {
 346           gr_expect_prompt ();
 347           error ("Invalid hex digit from remote system.");
 348         }
 349     }
 350 }
 351
 352 /* Get a byte from the remote and put it in *BYT.  Accept any number
 353    leading spaces.  */
 354 void
 355 sr_get_hex_byte (char *byt)
 356 {
 357   int val;
 358
 359   val = sr_get_hex_digit (1) << 4;
 360   val |= sr_get_hex_digit (0);
 361   *byt = val;
 362 }
 363
 364 /* Read a 32-bit hex word from the remote, preceded by a space  */
 365 long
 366 sr_get_hex_word (void)
 367 {
 368   long val;
 369   int j;
 370
 371   val = 0;
 372   for (j = 0; j < 8; j++)
 373     val = (val << 4) + sr_get_hex_digit (j == 0);
 374   return val;
 375 }
 376
 377 /* Put a command string, in args, out to the remote.  The remote is assumed to
 378    be in raw mode, all writing/reading done through desc.
 379    Ouput from the remote is placed on the users terminal until the
 380    prompt from the remote is seen.
 381    FIXME: Can't handle commands that take input.  */
 382
 383 static void
 384 sr_com (char *args, int fromtty)
 385 {
 386   sr_check_open ();
 387
 388   if (!args)
 389     return;
 390
 391   /* Clear all input so only command relative output is displayed */
 392
 393   sr_write_cr (args);
 394   sr_write ("\030", 1);
 395   registers_changed ();
 396   gr_expect_prompt ();
 397 }
 398
 399 void
 400 gr_close (int quitting)
 401 {
 402   gr_clear_all_breakpoints ();
 403
 404   if (sr_is_open ())
 405     {
 406       SERIAL_CLOSE (sr_get_desc ());
 407       sr_set_desc (NULL);
 408     }
 409
 410   return;
 411 }
 412
 413 /* gr_detach()
 414    takes a program previously attached to and detaches it.
 415    We better not have left any breakpoints
 416    in the program or it'll die when it hits one.
 417    Close the open connection to the remote debugger.
 418    Use this when you want to detach and do something else
 419    with your gdb.  */
 420
 421 void
 422 gr_detach (char *args, int from_tty)
 423 {
 424   if (args)
 425     error ("Argument given to \"detach\" when remotely debugging.");
 426
 427   if (sr_is_open ())
 428     gr_clear_all_breakpoints ();
 429
 430   pop_target ();
 431   if (from_tty)
 432     puts_filtered ("Ending remote debugging.\n");
 433
 434   return;
 435 }
 436
 437 void
 438 gr_files_info (struct target_ops *ops)
 439 {
 440 #ifdef __GO32__
 441   printf_filtered ("\tAttached to DOS asynctsr\n");
 442 #else
 443   printf_filtered ("\tAttached to %s", sr_get_device ());
 444   if (baud_rate != -1)
 445     printf_filtered ("at %d baud", baud_rate);
 446   printf_filtered ("\n");
 447 #endif
 448
 449   if (exec_bfd)
 450     {
 451       printf_filtered ("\tand running program %s\n",
 452                        bfd_get_filename (exec_bfd));
 453     }
 454   printf_filtered ("\tusing the %s protocol.\n", ops->to_shortname);
 455 }
 456
 457 void
 458 gr_mourn (void)
 459 {
 460   gr_clear_all_breakpoints ();
 461   unpush_target (gr_get_ops ());
 462   generic_mourn_inferior ();
 463 }
 464
 465 void
 466 gr_kill (void)
 467 {
 468   return;
 469 }
 470
 471 /* This is called not only when we first attach, but also when the
 472    user types "run" after having attached.  */
 473 void
 474 gr_create_inferior (char *execfile, char *args, char **env)
 475 {
 476   int entry_pt;
 477
 478   if (args && *args)
 479     error ("Can't pass arguments to remote process.");
 480
 481   if (execfile == 0 || exec_bfd == 0)
 482     error ("No executable file specified");
 483
 484   entry_pt = (int) bfd_get_start_address (exec_bfd);
 485   sr_check_open ();
 486
 487   gr_kill ();
 488   gr_clear_all_breakpoints ();
 489
 490   init_wait_for_inferior ();
 491   gr_checkin ();
 492
 493   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 494   proceed (entry_pt, -1, 0);
 495 }
 496
 497 /* Given a null terminated list of strings LIST, read the input until we find one of
 498    them.  Return the index of the string found or -1 on error.  '?' means match
 499    any single character. Note that with the algorithm we use, the initial
 500    character of the string cannot recur in the string, or we will not find some
 501    cases of the string in the input.  If PASSTHROUGH is non-zero, then
 502    pass non-matching data on.  */
 503
 504 int
 505 gr_multi_scan (list, passthrough)
 506      char *list[];
 507      int passthrough;
 508 {
 509   char *swallowed = NULL;       /* holding area */
 510   char *swallowed_p = swallowed;        /* Current position in swallowed.  */
 511   int ch;
 512   int ch_handled;
 513   int i;
 514   int string_count;
 515   int max_length;
 516   char **plist;
 517
 518   /* Look through the strings.  Count them.  Find the largest one so we can
 519      allocate a holding area.  */
 520
 521   for (max_length = string_count = i = 0;
 522        list[i] != NULL;
 523        ++i, ++string_count)
 524     {
 525       int length = strlen (list[i]);
 526
 527       if (length > max_length)
 528         max_length = length;
 529     }
 530
 531   /* if we have no strings, then something is wrong. */
 532   if (string_count == 0)
 533     return (-1);
 534
 535   /* otherwise, we will need a holding area big enough to hold almost two
 536      copies of our largest string.  */
 537   swallowed_p = swallowed = alloca (max_length << 1);
 538
 539   /* and a list of pointers to current scan points. */
 540   plist = (char **) alloca (string_count * sizeof (*plist));
 541
 542   /* and initialize */
 543   for (i = 0; i < string_count; ++i)
 544     plist[i] = list[i];
 545
 546   for (ch = sr_readchar (); /* loop forever */ ; ch = sr_readchar ())
 547     {
 548       QUIT;                     /* Let user quit and leave process running */
 549       ch_handled = 0;
 550
 551       for (i = 0; i < string_count; ++i)
 552         {
 553           if (ch == *plist[i] || *plist[i] == '?')
 554             {
 555               ++plist[i];
 556               if (*plist[i] == '\0')
 557                 return (i);
 558
 559               if (!ch_handled)
 560                 *swallowed_p++ = ch;
 561
 562               ch_handled = 1;
 563             }
 564           else
 565             plist[i] = list[i];
 566         }
 567
 568       if (!ch_handled)
 569         {
 570           char *p;
 571
 572           /* Print out any characters which have been swallowed.  */
 573           if (passthrough)
 574             {
 575               for (p = swallowed; p < swallowed_p; ++p)
 576                 fputc_unfiltered (*p, gdb_stdout);
 577
 578               fputc_unfiltered (ch, gdb_stdout);
 579             }
 580
 581           swallowed_p = swallowed;
 582         }
 583     }
 584 #if 0
 585   /* Never reached.  */
 586   return (-1);
 587 #endif
 588 }
 589
 590 /* Get ready to modify the registers array.  On machines which store
 591    individual registers, this doesn't need to do anything.  On machines
 592    which store all the registers in one fell swoop, this makes sure
 593    that registers contains all the registers from the program being
 594    debugged.  */
 595
 596 void
 597 gr_prepare_to_store (void)
 598 {
 599   /* Do nothing, since we assume we can store individual regs */
 600 }
 601
 602 void
 603 _initialize_sr_support (void)
 604 {
 605 /* FIXME-now: if target is open... */
 606   add_show_from_set (add_set_cmd ("remotedevice", no_class,
 607                                   var_filename, (char *) &sr_settings.device,
 608                                   "Set device for remote serial I/O.\n\
 609 This device is used as the serial port when debugging using remote\n\
 610 targets.", &setlist),
 611                      &showlist);
 612
 613   add_com ("remote <command>", class_obscure, sr_com,
 614            "Send a command to the remote monitor.");
 615
 616 }