/* Remote target communications for serial-line targets in custom GDB protocol
- Copyright 1988, 1991, 1992 Free Software Foundation, Inc.
+ Copyright 1988, 1991, 1992, 1993 Free Software Foundation, Inc.
This file is part of GDB.
#endif
#include <signal.h>
+#include "serial.h"
/* Prototypes for local functions */
static void
remote_resume PARAMS ((int, int));
+static int
+remote_start_remote PARAMS ((char *));
+
static void
remote_open PARAMS ((char *, int));
remote_store_registers PARAMS ((int));
static void
-getpkt PARAMS ((char *));
+getpkt PARAMS ((char *, int));
static void
putpkt PARAMS ((char *));
static void
remote_detach PARAMS ((char *, int));
-
extern struct target_ops remote_ops; /* Forward decl */
static int kiodebug = 0;
-static int timeout = 5;
+/* This was 5 seconds, which is a long time to sit and wait.
+ Unless this is going though some terminal server or multiplexer or
+ other form of hairy serial connection, I would think 2 seconds would
+ be plenty. */
+static int timeout = 2;
#if 0
int icache;
/* Descriptor for I/O to remote machine. Initialize it to -1 so that
remote_open knows that we don't have a file open when the program
starts. */
-int remote_desc = -1;
+serial_t remote_desc = NULL;
#define PBUFSIZ 1024
#define PBUFSIZ (REGISTER_BYTES * 2 + 32)
#endif
\f
-/* Called when SIGALRM signal sent due to alarm() timeout. */
-#ifndef HAVE_TERMIO
-void
-remote_timer (signo)
- int signo;
-{
- if (kiodebug)
- printf ("remote_timer called\n");
-
- alarm (timeout);
-}
-#endif
-
/* Clean up connection to a remote debugger. */
/* ARGSUSED */
remote_close (quitting)
int quitting;
{
- if (remote_desc >= 0)
- close (remote_desc);
- remote_desc = -1;
+ if (remote_desc)
+ SERIAL_CLOSE (remote_desc);
+ remote_desc = NULL;
}
-/* Translate baud rates from integers to damn B_codes. Unix should
- have outgrown this crap years ago, but even POSIX wouldn't buck it. */
-
-#ifndef B19200
-#define B19200 EXTA
-#endif
-#ifndef B38400
-#define B38400 EXTB
-#endif
-
-
-
-static struct {int rate, damn_b;} baudtab[] = {
- {0, B0},
- {50, B50},
- {75, B75},
- {110, B110},
- {134, B134},
- {150, B150},
- {200, B200},
- {300, B300},
- {600, B600},
- {1200, B1200},
- {1800, B1800},
- {2400, B2400},
- {4800, B4800},
- {9600, B9600},
- {19200, B19200},
- {38400, B38400},
- {-1, -1},
-};
+/* Stub for catch_errors. */
static int
-damn_b (rate)
- int rate;
+remote_start_remote (dummy)
+ char *dummy;
{
- int i;
+ /* Ack any packet which the remote side has already sent. */
+ SERIAL_WRITE (remote_desc, "+\r", 2);
+ putpkt ("?"); /* initiate a query from remote machine */
- for (i = 0; baudtab[i].rate != -1; i++)
- if (rate == baudtab[i].rate) return baudtab[i].damn_b;
- return B38400; /* Random */
+ start_remote (); /* Initialize gdb process mechanisms */
+ return 1;
}
/* Open a connection to a remote debugger.
char *name;
int from_tty;
{
- TERMINAL sg;
- int a_rate, b_rate = 0;
- int baudrate_set = 0;
-
if (name == 0)
error (
"To open a remote debug connection, you need to specify what serial\n\
target_preopen (from_tty);
- remote_close (0);
+ unpush_target (&remote_ops);
#if 0
dcache_init ();
#endif
- remote_desc = open (name, O_RDWR);
- if (remote_desc < 0)
+ remote_desc = SERIAL_OPEN (name);
+ if (!remote_desc)
perror_with_name (name);
if (baud_rate)
{
- if (sscanf (baud_rate, "%d", &a_rate) == 1)
- {
- b_rate = damn_b (a_rate);
- baudrate_set = 1;
- }
- }
+ int rate;
- ioctl (remote_desc, TIOCGETP, &sg);
-#ifdef HAVE_TERMIO
- sg.c_cc[VMIN] = 0; /* read with timeout. */
- sg.c_cc[VTIME] = timeout * 10;
- sg.c_lflag &= ~(ICANON | ECHO);
- sg.c_cflag &= ~PARENB; /* No parity */
- sg.c_cflag |= CS8; /* 8-bit path */
- if (baudrate_set)
- sg.c_cflag = (sg.c_cflag & ~CBAUD) | b_rate;
-#else
- sg.sg_flags |= RAW | ANYP;
- sg.sg_flags &= ~ECHO;
- if (baudrate_set)
- {
- sg.sg_ispeed = b_rate;
- sg.sg_ospeed = b_rate;
+ if (sscanf (baud_rate, "%d", &rate) == 1)
+ if (SERIAL_SETBAUDRATE (remote_desc, rate))
+ {
+ SERIAL_CLOSE (remote_desc);
+ perror_with_name (name);
+ }
}
-#endif
- ioctl (remote_desc, TIOCSETP, &sg);
+
+ SERIAL_RAW (remote_desc);
if (from_tty)
- printf ("Remote debugging using %s\n", name);
+ {
+ puts_filtered ("Remote debugging using ");
+ puts_filtered (name);
+ puts_filtered ("\n");
+ }
push_target (&remote_ops); /* Switch to using remote target now */
-#ifndef HAVE_TERMIO
-#ifndef NO_SIGINTERRUPT
- /* Cause SIGALRM's to make reads fail. */
- if (siginterrupt (SIGALRM, 1) != 0)
- perror ("remote_open: error in siginterrupt");
-#endif
-
- /* Set up read timeout timer. */
- if ((void (*)()) signal (SIGALRM, remote_timer) == (void (*)()) -1)
- perror ("remote_open: error in signal");
-#endif
-
- /* Ack any packet which the remote side has already sent. */
- write (remote_desc, "+\r", 2);
- putpkt ("?"); /* initiate a query from remote machine */
-
- start_remote (); /* Initialize gdb process mechanisms */
+ /* Start the remote connection; if error (0), discard this target. */
+ immediate_quit++; /* Allow user to interrupt it */
+ if (!catch_errors (remote_start_remote, (char *)0,
+ "Couldn't establish connection to remote target\n"))
+ pop_target();
}
/* remote_detach()
pop_target ();
if (from_tty)
- printf ("Ending remote debugging.\n");
+ puts_filtered ("Ending remote debugging.\n");
}
/* Convert hex digit A to a number. */
char buf[PBUFSIZ];
if (siggnal)
- error ("Can't send signals to a remote system. Try `handle %d ignore'.",
- siggnal);
+ {
+ char *name;
+ target_terminal_ours_for_output ();
+ printf_filtered ("Can't send signals to a remote system. ");
+ name = strsigno (siggnal);
+ if (name)
+ printf_filtered (name);
+ else
+ printf_filtered ("Signal %d", siggnal);
+ printf_filtered (" not sent.\n");
+ target_terminal_inferior ();
+ }
#if 0
dcache_flush ();
putpkt (buf);
}
+\f
+static void remote_interrupt_twice PARAMS ((int));
+static void (*ofunc)();
/* Send ^C to target to halt it. Target will respond, and send us a
packet. */
void remote_interrupt(signo)
int signo;
{
+ /* If this doesn't work, try more severe steps. */
+ signal (signo, remote_interrupt_twice);
if (kiodebug)
printf ("remote_interrupt called\n");
- write (remote_desc, "\003", 1); /* Send a ^C */
+ SERIAL_WRITE (remote_desc, "\003", 1); /* Send a ^C */
}
+/* The user typed ^C twice. */
+static void
+remote_interrupt_twice (signo)
+ int signo;
+{
+ signal (signo, ofunc);
+
+ target_terminal_ours ();
+ if (query ("Interrupted while waiting for the inferior.\n\
+Give up (and stop debugging it)? "))
+ {
+ target_mourn_inferior ();
+ return_to_top_level ();
+ }
+ else
+ {
+ signal (signo, remote_interrupt);
+ target_terminal_inferior ();
+ }
+}
/* Wait until the remote machine stops, then return,
storing status in STATUS just as `wait' would.
WAITTYPE *status;
{
unsigned char buf[PBUFSIZ];
- void (*ofunc)();
unsigned char *p;
int i;
long regno;
WSETEXIT ((*status), 0);
ofunc = (void (*)()) signal (SIGINT, remote_interrupt);
- getpkt ((char *) buf);
+ getpkt ((char *) buf, 1);
signal (SIGINT, ofunc);
if (buf[0] == 'E')
remote_files_info (ignore)
struct target_ops *ignore;
{
- printf ("Debugging a target over a serial line.\n");
+ puts_filtered ("Debugging a target over a serial line.\n");
}
\f
/*
*/
-/* Read a single character from the remote end.
- (If supported, we actually read many characters and buffer them up.) */
+/* Read a single character from the remote end, masking it down to 7 bits. */
static int
readchar ()
{
- static int inbuf_index, inbuf_count;
-#define INBUFSIZE PBUFSIZ
- static char inbuf[INBUFSIZE];
+ int ch;
- if (inbuf_index >= inbuf_count)
- {
- /* Time to do another read... */
- inbuf_index = 0;
- inbuf_count = 0;
- inbuf[0] = 0; /* Just in case */
-#ifdef HAVE_TERMIO
- /* termio does the timeout for us. */
- inbuf_count = read (remote_desc, inbuf, INBUFSIZE);
-#else
- alarm (timeout);
- inbuf_count = read (remote_desc, inbuf, INBUFSIZE);
- alarm (0);
-#endif
- }
+ ch = SERIAL_READCHAR (remote_desc, timeout);
- /* Just return the next character from the buffer. */
- return inbuf[inbuf_index++] & 0x7f;
+ if (ch < 0)
+ return ch;
+
+ return ch & 0x7f;
}
/* Send the command in BUF to the remote machine,
{
putpkt (buf);
- getpkt (buf);
+ getpkt (buf, 0);
if (buf[0] == 'E')
error ("Remote failure reply: %s", buf);
unsigned char csum = 0;
char buf2[PBUFSIZ];
int cnt = strlen (buf);
- char ch;
+ int ch;
char *p;
/* Copy the packet into buffer BUF2, encapsulating it
*p = '\0';
printf ("Sending packet: %s...", buf2); fflush(stdout);
}
- write (remote_desc, buf2, p - buf2);
+ SERIAL_WRITE (remote_desc, buf2, p - buf2);
- /* read until either a timeout occurs (\0) or '+' is read */
+ /* read until either a timeout occurs (-2) or '+' is read */
do {
ch = readchar ();
if (kiodebug) {
else
printf ("%02X%c ", ch&0xFF, ch);
}
- } while ((ch != '+') && (ch != '\0'));
+ } while ((ch != '+') && (ch != SERIAL_TIMEOUT));
} while (ch != '+');
}
/* Read a packet from the remote machine, with error checking,
- and store it in BUF. BUF is expected to be of size PBUFSIZ. */
+ and store it in BUF. BUF is expected to be of size PBUFSIZ.
+ If FOREVER, wait forever rather than timing out; this is used
+ while the target is executing user code. */
static void
-getpkt (buf)
+getpkt (buf, forever)
char *buf;
+ int forever;
{
char *bp;
unsigned char csum;
- int c;
+ int c = 0;
unsigned char c1, c2;
int retries = 0;
#define MAX_RETRIES 10
-#if 0
- /* Sorry, this will cause all hell to break loose, i.e. we'll end
- up in the command loop with an inferior, but (at least if this
- happens in remote_wait or some such place) without a current_frame,
- having set up prev_* in wait_for_inferior, etc.
-
- If it is necessary to have such an "emergency exit", seems like
- the only plausible thing to do is to say the inferior died, and
- make the user reattach if they want to. Perhaps with a prompt
- asking for confirmation. */
-
- /* allow immediate quit while reading from device, it could be hung */
- immediate_quit++;
-#endif /* 0 */
-
while (1)
{
+ /* This can loop forever if the remote side sends us characters
+ continuously, but if it pauses, we'll get a zero from readchar
+ because of timeout. Then we'll count that as a retry. */
+ while (c != '$')
+ if ((c = readchar()) == SERIAL_TIMEOUT)
+ if (!forever)
+ {
+ if (++retries >= MAX_RETRIES)
+ if (kiodebug) puts_filtered ("Timed out.\n");
+ goto out;
+ }
+
/* Force csum to be zero here because of possible error retry. */
csum = 0;
-
- while ((c = readchar()) != '$');
-
bp = buf;
+
while (1)
{
c = readchar ();
+ if (c == SERIAL_TIMEOUT)
+ {
+ if (kiodebug)
+ puts_filtered ("Timeout in mid-packet, retrying\n");
+ goto whole; /* Start a new packet, count retries */
+ }
+ if (c == '$')
+ {
+ if (kiodebug)
+ puts_filtered ("Saw new packet start in middle of old one\n");
+ goto whole; /* Start a new packet, count retries */
+ }
if (c == '#')
break;
if (bp >= buf+PBUFSIZ-1)
{
*bp = '\0';
- printf_filtered ("Remote packet too long: %s\n", buf);
+ puts_filtered ("Remote packet too long: ");
+ puts_filtered (buf);
+ puts_filtered ("\n");
goto whole;
}
*bp++ = c;
c2 = fromhex (readchar ());
if ((csum & 0xff) == (c1 << 4) + c2)
break;
- printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
- (c1 << 4) + c2, csum & 0xff, buf);
+ printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
+ (c1 << 4) + c2, csum & 0xff);
+ puts_filtered (buf);
+ puts_filtered ("\n");
/* Try the whole thing again. */
whole:
if (++retries < MAX_RETRIES)
{
- write (remote_desc, "-", 1);
+ SERIAL_WRITE (remote_desc, "-", 1);
}
else
{
}
}
-#if 0
- immediate_quit--;
-#endif
+out:
- write (remote_desc, "+", 1);
+ SERIAL_WRITE (remote_desc, "+", 1);
if (kiodebug)
fprintf (stderr,"Packet received: %s\n", buf);
insque (db, &dcache_free);
}
#endif /* 0 */
+\f
+static void
+remote_kill ()
+{
+ putpkt ("k");
+ /* Don't wait for it to die. I'm not really sure it matters whether
+ we do or not. For the existing stubs, kill is a noop. */
+ target_mourn_inferior ();
+}
+static void
+remote_mourn ()
+{
+ unpush_target (&remote_ops);
+ generic_mourn_inferior ();
+}
+\f
/* Define the target subroutine names */
struct target_ops remote_ops = {
NULL, /* to_terminal_ours_for_output */
NULL, /* to_terminal_ours */
NULL, /* to_terminal_info */
- NULL, /* to_kill */
+ remote_kill, /* to_kill */
NULL, /* to_load */
NULL, /* to_lookup_symbol */
NULL, /* to_create_inferior */
- NULL, /* to_mourn_inferior */
+ remote_mourn, /* to_mourn_inferior */
0, /* to_can_run */
+ 0, /* to_notice_signals */
process_stratum, /* to_stratum */
NULL, /* to_next */
1, /* to_has_all_memory */
projects / binutils.git / blobdiff