/* Generic serial interface functions.
- Copyright (C) 1992-1996, 1998-2001, 2003-2012 Free Software
- Foundation, Inc.
+ Copyright (C) 1992-2016 Free Software Foundation, Inc.
This file is part of GDB.
#include "event-loop.h"
#include "gdb_select.h"
-#include "gdb_string.h"
-#include <sys/time.h>
+#include "gdb_sys_time.h"
#ifdef USE_WIN32API
#include <winsock2.h>
#endif
}
}
+/* Run the SCB's async handle, and reschedule, if the handler doesn't
+ close SCB. */
+
+static void
+run_async_handler_and_reschedule (struct serial *scb)
+{
+ int is_open;
+
+ /* Take a reference, so a serial_close call within the handler
+ doesn't make SCB a dangling pointer. */
+ serial_ref (scb);
+
+ /* Run the handler. */
+ scb->async_handler (scb, scb->async_context);
+
+ is_open = serial_is_open (scb);
+ serial_unref (scb);
+
+ /* Get ready for more, if not already closed. */
+ if (is_open)
+ reschedule (scb);
+}
+
/* FD_EVENT: This is scheduled when the input FIFO is empty (and there
is no pending error). As soon as data arrives, it is read into the
input FIFO and the client notified. The client should then drain
static void
fd_event (int error, void *context)
{
- struct serial *scb = context;
+ struct serial *scb = (struct serial *) context;
if (error != 0)
{
scb->bufcnt = SERIAL_ERROR;
pull characters out of the buffer. See also
generic_readchar(). */
int nr;
- nr = scb->ops->read_prim (scb, BUFSIZ);
+
+ do
+ {
+ nr = scb->ops->read_prim (scb, BUFSIZ);
+ }
+ while (nr < 0 && errno == EINTR);
+
if (nr == 0)
{
scb->bufcnt = SERIAL_EOF;
scb->bufcnt = SERIAL_ERROR;
}
}
- scb->async_handler (scb, scb->async_context);
- reschedule (scb);
+ run_async_handler_and_reschedule (scb);
}
/* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
static void
push_event (void *context)
{
- struct serial *scb = context;
+ struct serial *scb = (struct serial *) context;
scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */
- scb->async_handler (scb, scb->async_context);
- /* re-schedule */
- reschedule (scb);
+ run_async_handler_and_reschedule (scb);
}
/* Wait for input on scb, with timeout seconds. Returns 0 on success,
int numfds;
struct timeval tv;
fd_set readfds, exceptfds;
+ int nfds;
/* NOTE: Some OS's can scramble the READFDS when the select()
call fails (ex the kernel with Red Hat 5.2). Initialize all
FD_SET (scb->fd, &readfds);
FD_SET (scb->fd, &exceptfds);
+ QUIT;
+
+ nfds = scb->fd + 1;
if (timeout >= 0)
- numfds = gdb_select (scb->fd + 1, &readfds, 0, &exceptfds, &tv);
+ numfds = interruptible_select (nfds, &readfds, 0, &exceptfds, &tv);
else
- numfds = gdb_select (scb->fd + 1, &readfds, 0, &exceptfds, 0);
+ numfds = interruptible_select (nfds, &readfds, 0, &exceptfds, 0);
if (numfds <= 0)
{
}
}
+/* Read any error output we might have. */
+
+static void
+ser_base_read_error_fd (struct serial *scb, int close_fd)
+{
+ if (scb->error_fd != -1)
+ {
+ ssize_t s;
+ char buf[GDB_MI_MSG_WIDTH + 1];
+
+ for (;;)
+ {
+ char *current;
+ char *newline;
+ int to_read = GDB_MI_MSG_WIDTH;
+ int num_bytes = -1;
+
+ if (scb->ops->avail)
+ num_bytes = (scb->ops->avail)(scb, scb->error_fd);
+
+ if (num_bytes != -1)
+ to_read = (num_bytes < to_read) ? num_bytes : to_read;
+
+ if (to_read == 0)
+ break;
+
+ s = read (scb->error_fd, &buf, to_read);
+ if ((s == -1) || (s == 0 && !close_fd))
+ break;
+
+ if (s == 0 && close_fd)
+ {
+ /* End of file. */
+ close (scb->error_fd);
+ scb->error_fd = -1;
+ break;
+ }
+
+ /* In theory, embedded newlines are not a problem.
+ But for MI, we want each output line to have just
+ one newline for legibility. So output things
+ in newline chunks. */
+ gdb_assert (s > 0 && s <= GDB_MI_MSG_WIDTH);
+ buf[s] = '\0';
+ current = buf;
+ while ((newline = strstr (current, "\n")) != NULL)
+ {
+ *newline = '\0';
+ fputs_unfiltered (current, gdb_stderr);
+ fputs_unfiltered ("\n", gdb_stderr);
+ current = newline + 1;
+ }
+
+ fputs_unfiltered (current, gdb_stderr);
+ }
+ }
+}
+
/* Read a character with user-specified timeout. TIMEOUT is number of seconds
to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
char if successful. Returns -2 if timeout expired, EOF if line dropped
status = SERIAL_TIMEOUT;
break;
}
+
+ /* We also need to check and consume the stderr because it could
+ come before the stdout for some stubs. If we just sit and wait
+ for stdout, we would hit a deadlock for that case. */
+ ser_base_read_error_fd (scb, 0);
}
if (status < 0)
return status;
- status = scb->ops->read_prim (scb, BUFSIZ);
+ do
+ {
+ status = scb->ops->read_prim (scb, BUFSIZ);
+ }
+ while (status < 0 && errno == EINTR);
if (status <= 0)
{
}
}
}
- /* Read any error output we might have. */
- if (scb->error_fd != -1)
- {
- ssize_t s;
- char buf[81];
-
- for (;;)
- {
- char *current;
- char *newline;
- int to_read = 80;
- int num_bytes = -1;
- if (scb->ops->avail)
- num_bytes = (scb->ops->avail)(scb, scb->error_fd);
- if (num_bytes != -1)
- to_read = (num_bytes < to_read) ? num_bytes : to_read;
-
- if (to_read == 0)
- break;
-
- s = read (scb->error_fd, &buf, to_read);
- if (s == -1)
- break;
- if (s == 0)
- {
- /* EOF */
- close (scb->error_fd);
- scb->error_fd = -1;
- break;
- }
-
- /* In theory, embedded newlines are not a problem.
- But for MI, we want each output line to have just
- one newline for legibility. So output things
- in newline chunks. */
- buf[s] = '\0';
- current = buf;
- while ((newline = strstr (current, "\n")) != NULL)
- {
- *newline = '\0';
- fputs_unfiltered (current, gdb_stderr);
- fputs_unfiltered ("\n", gdb_stderr);
- current = newline + 1;
- }
- fputs_unfiltered (current, gdb_stderr);
- }
- }
+ /* Read any error output we might have. */
+ ser_base_read_error_fd (scb, 1);
reschedule (scb);
return ch;
}
int
-ser_base_write (struct serial *scb, const char *str, int len)
+ser_base_write (struct serial *scb, const void *buf, size_t count)
{
+ const char *str = (const char *) buf;
int cc;
- while (len > 0)
+ while (count > 0)
{
- cc = scb->ops->write_prim (scb, str, len);
+ QUIT;
+
+ cc = scb->ops->write_prim (scb, str, count);
if (cc < 0)
- return 1;
- len -= cc;
+ {
+ if (errno == EINTR)
+ continue;
+ return 1;
+ }
+ count -= cc;
str += cc;
}
return 0;
ser_base_get_tty_state (struct serial *scb)
{
/* Allocate a dummy. */
- return (serial_ttystate) XMALLOC (int);
+ return (serial_ttystate) XNEW (int);
}
serial_ttystate
ser_base_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
{
/* Allocate another dummy. */
- return (serial_ttystate) XMALLOC (int);
+ return (serial_ttystate) XNEW (int);
}
int
return 0; /* Never fails! */
}
+/* Implement the "setparity" serial_ops callback. */
+
+int
+ser_base_setparity (struct serial *scb, int parity)
+{
+ return 0; /* Never fails! */
+}
+
/* Put the SERIAL device into/out-of ASYNC mode. */
void
projects / deliverable / binutils-gdb.git / blobdiff