#include "top.h"
#include "event-loop.h"
#include "event-top.h"
-#include "inferior.h" /* For fetch_inferior_event. */
#ifdef HAVE_POLL
#include <poll.h>
#else
#include <sys/types.h>
+#include <string.h>
#endif
#include <errno.h>
#include <setjmp.h>
/* Type of the mask arguments to select. */
-#ifndef NO_FD_SET
-#define SELECT_MASK fd_set
-#else
+#ifndef HAVE_POLL
+#ifdef NO_FD_SET
+/* All this stuff below is not required if select is used as God(tm)
+ intended, with the FD_* macros. Are there any implementations of
+ select which don't have FD_SET and other standard FD_* macros? I
+ don't think there are, but if I'm wrong, we need to catch them. */
+#error FD_SET must be defined if select function is to be used!
+
#ifndef _AIX
typedef long fd_mask;
#endif
#define SELECT_MASK void
#else
#define SELECT_MASK int
-#endif
-#endif
+#endif /* !_IBMR2 */
/* Define "NBBY" (number of bits per byte) if it's not already defined. */
#define NBBY 8
#endif
-
/* Define the number of fd_masks in an fd_set */
#ifndef FD_SETSIZE
#endif
#define MASK_SIZE howmany(FD_SETSIZE, NFDBITS)
+#endif /* NO_FD_SET */
+#endif /* !HAVE_POLL */
+
typedef struct gdb_event gdb_event;
typedef void (event_handler_func) (int);
int mask; /* Events we want to monitor: POLLIN, etc. */
int ready_mask; /* Events that have been seen since
the last time. */
- handler_func *proc; /* Procedure to call when fd is ready. */
+ handler_func *proc; /* Procedure to call when fd is ready. */
gdb_client_data client_data; /* Argument to pass to proc. */
- int error; /* Was an error detected on this fd? */
+ int error; /* Was an error detected on this fd? */
struct file_handler *next_file; /* Next registered file descriptor. */
}
file_handler;
int ready; /* If ready, call this handler from the main event loop,
using invoke_async_handler. */
struct async_signal_handler *next_handler; /* Ptr to next handler */
- sig_handler_func *proc; /* Function to call to do the work */
+ sig_handler_func *proc; /* Function to call to do the work */
gdb_client_data client_data; /* Argument to async_handler_func */
}
async_signal_handler;
/* Masks to be used in the next call to select.
Bits are set in response to calls to create_file_handler. */
- fd_mask check_masks[3 * MASK_SIZE];
+ fd_set check_masks[3];
/* What file descriptors were found ready by select. */
- fd_mask ready_masks[3 * MASK_SIZE];
+ fd_set ready_masks[3];
/* Number of valid bits (highest fd value + 1). */
int num_fds;
/* Flag to tell whether the timeout struct should be used. */
int timeout_valid;
- }
+ }
gdb_notifier;
#endif /* HAVE_POLL */
struct timeval when;
int timer_id;
struct gdb_timer *next;
- timer_handler_func *proc; /* Function to call to do the work */
- gdb_client_data client_data; /* Argument to async_handler_func */
+ timer_handler_func *proc; /* Function to call to do the work */
+ gdb_client_data client_data; /* Argument to async_handler_func */
}
gdb_timer;
/* List of currently active timers. It is sorted in order of
- increasing timers.*/
+ increasing timers. */
static struct
{
/* Pointer to first in timer list. */
struct gdb_timer *first_timer;
- /* Length of timer list. */
+ /* Id of the last timer created. */
int num_timers;
}
timer_list;
function. */
static int async_handler_ready = 0;
-static void create_file_handler (int fd, int mask, handler_func *proc, gdb_client_data client_data);
+static void create_file_handler (int fd, int mask, handler_func * proc, gdb_client_data client_data);
static void invoke_async_signal_handler (void);
static void handle_file_event (int event_file_desc);
static int gdb_wait_for_event (void);
-static int gdb_do_one_event (void);
+static int gdb_do_one_event (void *data);
static int check_async_ready (void);
-static void async_queue_event (gdb_event *event_ptr, queue_position position);
-static gdb_event * create_file_event (int fd);
+static void async_queue_event (gdb_event * event_ptr, queue_position position);
+static gdb_event *create_file_event (int fd);
static int process_event (void);
static void handle_timer_event (int dummy);
static void poll_timers (void);
as last in first out. Event appended at the tail of the queue
will be processed first in first out. */
static void
-async_queue_event (gdb_event *event_ptr, queue_position position)
+async_queue_event (gdb_event * event_ptr, queue_position position)
{
if (position == TAIL)
{
/* Process one high level event. If nothing is ready at this time,
wait for something to happen (via gdb_wait_for_event), then process
- it. Returns 1 if something was done otherwise returns 0 (this can
- happen if there are no event sources to wait for). */
+ it. Returns >0 if something was done otherwise returns <0 (this
+ can happen if there are no event sources to wait for). If an error
+ occures catch_errors() which calls this function returns zero. */
+
static int
-gdb_do_one_event (void)
+gdb_do_one_event (void *data)
{
- int result = 0;
-
- while (1)
+ /* Any events already waiting in the queue? */
+ if (process_event ())
{
- if (!SET_TOP_LEVEL ())
- {
- /* Any events already waiting in the queue? */
- if (process_event ())
- {
- result = 1;
- break;
- }
-
- /* Are any timers that are ready? If so, put an event on the queue.*/
- poll_timers ();
-
- /* Wait for a new event. If gdb_wait_for_event returns -1,
- we should get out because this means that there are no
- event sources left. This will make the event loop stop,
- and the application exit. */
-
- result = gdb_wait_for_event ();
- if (result < 0)
- {
- result = 0;
- break;
- }
+ return 1;
+ }
+
+ /* Are any timers that are ready? If so, put an event on the queue. */
+ poll_timers ();
+
+ /* Wait for a new event. If gdb_wait_for_event returns -1,
+ we should get out because this means that there are no
+ event sources left. This will make the event loop stop,
+ and the application exit. */
+
+ if (gdb_wait_for_event () < 0)
+ {
+ return -1;
+ }
+
+ /* Handle any new events occurred while waiting. */
+ if (process_event ())
+ {
+ return 1;
+ }
+
+ /* If gdb_wait_for_event has returned 1, it means that one
+ event has been handled. We break out of the loop. */
+ return 1;
+}
- /* Handle any new events occurred while waiting. */
- if (process_event ())
- {
- result = 1;
- break;
- }
+/* Start up the event loop. This is the entry point to the event loop
+ from the command loop. */
- /* If gdb_wait_for_event has returned 1, it means that one
- event has been handled. We break out of the loop. */
- if (result)
- break;
- } /* end of if !set_top_level */
- else
+void
+start_event_loop (void)
+{
+ /* Loop until there is nothing to do. This is the entry point to the
+ event loop engine. gdb_do_one_event, called via catch_errors()
+ will process one event for each invocation. It blocks waits for
+ an event and then processes it. >0 when an event is processed, 0
+ when catch_errors() caught an error and <0 when there are no
+ longer any event sources registered. */
+ while (1)
+ {
+ int result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
+ if (result < 0)
+ break;
+ if (result == 0)
{
/* FIXME: this should really be a call to a hook that is
interface specific, because interfaces can display the
whether display the prompt or not. */
}
}
- return result;
-}
-\f
-
-/* Start up the event loop. This is the entry point to the event loop
- from the command loop. */
-void
-start_event_loop (void)
-{
- /* Loop until there is something to do. This is the entry point to
- the event loop engine. gdb_do_one_event will process one event
- for each invocation. It always returns 1, unless there are no
- more event sources registered. In this case it returns 0. */
- while (gdb_do_one_event () != 0)
- ;
/* We are done with the event loop. There are no more event sources
to listen to. So we exit GDB. */
doesn't have to know implementation details about the use of poll
vs. select. */
void
-add_file_handler (int fd, handler_func *proc, gdb_client_data client_data)
+add_file_handler (int fd, handler_func * proc, gdb_client_data client_data)
{
#ifdef HAVE_POLL
create_file_handler (fd, POLLIN, proc, client_data);
PROC is the procedure that will be called when an event occurs for
FD. CLIENT_DATA is the argument to pass to PROC. */
static void
-create_file_handler (int fd, int mask, handler_func *proc, gdb_client_data client_data)
+create_file_handler (int fd, int mask, handler_func * proc, gdb_client_data client_data)
{
file_handler *file_ptr;
-#ifndef HAVE_POLL
- int index, bit;
-#endif
-
/* Do we already have a file handler for this file? (We may be
changing its associated procedure). */
for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
}
/* It is a new file descriptor. Add it to the list. Otherwise, just
- change the data associated with it.*/
+ change the data associated with it. */
if (file_ptr == NULL)
{
file_ptr = (file_handler *) xmalloc (sizeof (file_handler));
#else /* ! HAVE_POLL */
- index = fd / (NBBY * sizeof (fd_mask));
- bit = 1 << (fd % (NBBY * sizeof (fd_mask)));
-
if (mask & GDB_READABLE)
- gdb_notifier.check_masks[index] |= bit;
+ FD_SET (fd, &gdb_notifier.check_masks[0]);
else
- gdb_notifier.check_masks[index] &= ~bit;
+ FD_CLR (fd, &gdb_notifier.check_masks[0]);
if (mask & GDB_WRITABLE)
- (gdb_notifier.check_masks + MASK_SIZE)[index] |= bit;
+ FD_SET (fd, &gdb_notifier.check_masks[1]);
else
- (gdb_notifier.check_masks + MASK_SIZE)[index] &= ~bit;
+ FD_CLR (fd, &gdb_notifier.check_masks[1]);
if (mask & GDB_EXCEPTION)
- (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] |= bit;
+ FD_SET (fd, &gdb_notifier.check_masks[2]);
else
- (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] &= ~bit;
+ FD_CLR (fd, &gdb_notifier.check_masks[2]);
if (gdb_notifier.num_fds <= fd)
gdb_notifier.num_fds = fd + 1;
delete_file_handler (int fd)
{
file_handler *file_ptr, *prev_ptr = NULL;
- int i, j;
+ int i;
+#ifdef HAVE_POLL
+ int j;
struct pollfd *new_poll_fds;
-#ifndef HAVE_POLL
- int index, bit;
- unsigned long flags;
#endif
/* Find the entry for the given file. */
#else /* ! HAVE_POLL */
- index = fd / (NBBY * sizeof (fd_mask));
- bit = 1 << (fd % (NBBY * sizeof (fd_mask)));
-
if (file_ptr->mask & GDB_READABLE)
- gdb_notifier.check_masks[index] &= ~bit;
+ FD_CLR (fd, &gdb_notifier.check_masks[0]);
if (file_ptr->mask & GDB_WRITABLE)
- (gdb_notifier.check_masks + MASK_SIZE)[index] &= ~bit;
+ FD_CLR (fd, &gdb_notifier.check_masks[1]);
if (file_ptr->mask & GDB_EXCEPTION)
- (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] &= ~bit;
+ FD_CLR (fd, &gdb_notifier.check_masks[2]);
/* Find current max fd. */
if ((fd + 1) == gdb_notifier.num_fds)
{
- for (gdb_notifier.num_fds = 0; index >= 0; index--)
+ gdb_notifier.num_fds--;
+ for (i = gdb_notifier.num_fds; i; i--)
{
- flags = gdb_notifier.check_masks[index]
- | (gdb_notifier.check_masks + MASK_SIZE)[index]
- | (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index];
- if (flags)
- {
- for (i = (NBBY * sizeof (fd_mask)); i > 0; i--)
- {
- if (flags & (((unsigned long) 1) << (i - 1)))
- break;
- }
- gdb_notifier.num_fds = index * (NBBY * sizeof (fd_mask)) + i;
- break;
- }
+ if (FD_ISSET (i - 1, &gdb_notifier.check_masks[0])
+ || FD_ISSET (i - 1, &gdb_notifier.check_masks[1])
+ || FD_ISSET (i - 1, &gdb_notifier.check_masks[2]))
+ break;
}
+ gdb_notifier.num_fds = i;
}
#endif /* HAVE_POLL */
if (error_mask_returned != 0)
{
/* Work in progress. We may need to tell somebody what
- kind of error we had. */
- /*if (error_mask_returned & POLLHUP)
+ kind of error we had. */
+ if (error_mask_returned & POLLHUP)
printf_unfiltered ("Hangup detected on fd %d\n", file_ptr->fd);
if (error_mask_returned & POLLERR)
printf_unfiltered ("Error detected on fd %d\n", file_ptr->fd);
if (error_mask_returned & POLLNVAL)
- printf_unfiltered ("Invalid fd %d\n", file_ptr->fd);*/
+ printf_unfiltered ("Invalid or non-`poll'able fd %d\n", file_ptr->fd);
file_ptr->error = 1;
- }
- else
+ }
+ else
file_ptr->error = 0;
#else /* ! HAVE_POLL */
if (file_ptr->ready_mask & GDB_EXCEPTION)
/* If there was a match, then call the handler. */
if (mask != 0)
- (*file_ptr->proc) (file_ptr->error, file_ptr->fd, file_ptr->client_data);
+ (*file_ptr->proc) (file_ptr->error, file_ptr->client_data);
break;
}
}
file_handler *file_ptr;
gdb_event *file_event_ptr;
int num_found = 0;
+#ifdef HAVE_POLL
int i;
-
-#ifndef HAVE_POLL
- int mask, bit, index;
#endif
/* Make sure all output is done before getting another event. */
#ifdef HAVE_POLL
num_found =
- poll (gdb_notifier.poll_fds,
- (unsigned long) gdb_notifier.num_fds,
+ poll (gdb_notifier.poll_fds,
+ (unsigned long) gdb_notifier.num_fds,
gdb_notifier.timeout_valid ? gdb_notifier.timeout : -1);
/* Don't print anything if we get out of poll because of a
- signal.*/
+ signal. */
if (num_found == -1 && errno != EINTR)
perror_with_name ("Poll");
#else /* ! HAVE_POLL */
- memcpy (gdb_notifier.ready_masks,
- gdb_notifier.check_masks,
- 3 * MASK_SIZE * sizeof (fd_mask));
+
+ gdb_notifier.ready_masks[0] = gdb_notifier.check_masks[0];
+ gdb_notifier.ready_masks[1] = gdb_notifier.check_masks[1];
+ gdb_notifier.ready_masks[2] = gdb_notifier.check_masks[2];
+
num_found = select (gdb_notifier.num_fds,
- (SELECT_MASK *) & gdb_notifier.ready_masks[0],
- (SELECT_MASK *) & gdb_notifier.ready_masks[MASK_SIZE],
- (SELECT_MASK *) & gdb_notifier.ready_masks[2 * MASK_SIZE],
- gdb_notifier.timeout_valid ? gdb_notifier.timeout : NULL);
+ & gdb_notifier.ready_masks[0],
+ & gdb_notifier.ready_masks[1],
+ & gdb_notifier.ready_masks[2],
+ gdb_notifier.timeout_valid
+ ? &gdb_notifier.timeout : NULL);
/* Clear the masks after an error from select. */
if (num_found == -1)
{
- memset (gdb_notifier.ready_masks,
- 0, 3 * MASK_SIZE * sizeof (fd_mask));
+ FD_ZERO (&gdb_notifier.ready_masks[0]);
+ FD_ZERO (&gdb_notifier.ready_masks[1]);
+ FD_ZERO (&gdb_notifier.ready_masks[2]);
/* Dont print anything is we got a signal, let gdb handle it. */
if (errno != EINTR)
perror_with_name ("Select");
}
#else /* ! HAVE_POLL */
+
for (file_ptr = gdb_notifier.first_file_handler;
(file_ptr != NULL) && (num_found > 0);
file_ptr = file_ptr->next_file)
{
- index = file_ptr->fd / (NBBY * sizeof (fd_mask));
- bit = 1 << (file_ptr->fd % (NBBY * sizeof (fd_mask)));
- mask = 0;
+ int mask = 0;
- if (gdb_notifier.ready_masks[index] & bit)
+ if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[0]))
mask |= GDB_READABLE;
- if ((gdb_notifier.ready_masks + MASK_SIZE)[index] & bit)
+ if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[1]))
mask |= GDB_WRITABLE;
- if ((gdb_notifier.ready_masks + 2 * (MASK_SIZE))[index] & bit)
+ if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[2]))
mask |= GDB_EXCEPTION;
if (!mask)
}
file_ptr->ready_mask = mask;
}
+
#endif /* HAVE_POLL */
return 0;
PROC is the function to call with CLIENT_DATA argument
whenever the handler is invoked. */
async_signal_handler *
-create_async_signal_handler (sig_handler_func *proc, gdb_client_data client_data)
+create_async_signal_handler (sig_handler_func * proc, gdb_client_data client_data)
{
async_signal_handler *async_handler_ptr;
some event. The caller of this function is the interrupt handler
associated with a signal. */
void
-mark_async_signal_handler (async_signal_handler *async_handler_ptr)
+mark_async_signal_handler (async_signal_handler * async_handler_ptr)
{
((async_signal_handler *) async_handler_ptr)->ready = 1;
async_handler_ready = 1;
/* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
Free the space allocated for it. */
void
-delete_async_signal_handler (async_signal_handler **async_handler_ptr)
+delete_async_signal_handler (async_signal_handler ** async_handler_ptr)
{
async_signal_handler *prev_ptr;
return async_handler_ready;
}
-/* FIXME: where does this function belong? */
-/* General function to handle events in the inferior. So far it just
- takes care of detecting errors reported by select() or poll(),
- otherwise it assumes that all is OK, and goes on reading data from
- the fd. This however may not always be what we want to do. */
-void
-inferior_event_handler (int error, gdb_client_data client_data, int fd)
-{
- if (error == 1)
- {
- printf_unfiltered ("error detected on fd %d\n", fd);
- delete_file_handler (fd);
- discard_all_continuations ();
- }
- else
- fetch_inferior_event (client_data);
-}
-
/* Create a timer that will expire in MILLISECONDS from now. When the
timer is ready, PROC will be executed. At creation, the timer is
aded to the timers queue. This queue is kept sorted in order of
- increasing timers. Return a handle to the timer struct.*/
+ increasing timers. Return a handle to the timer struct. */
int
-create_timer (int milliseconds, timer_handler_func *proc, gdb_client_data client_data)
+create_timer (int milliseconds, timer_handler_func * proc, gdb_client_data client_data)
{
struct gdb_timer *timer_ptr, *timer_index, *prev_timer;
struct timeval time_now, delta;
/* compute seconds */
delta.tv_sec = milliseconds / 1000;
/* compute microseconds */
- delta.tv_usec = (milliseconds % 1000) * 1000;
-
+ delta.tv_usec = (milliseconds % 1000) * 1000;
+
gettimeofday (&time_now, NULL);
timer_ptr = (struct gdb_timer *) xmalloc (sizeof (gdb_timer));
timer_ptr->when.tv_sec = time_now.tv_sec + delta.tv_sec;
timer_ptr->when.tv_usec = time_now.tv_usec + delta.tv_usec;
/* carry? */
- if (timer_ptr->when.tv_usec >= 1000000 )
+ if (timer_ptr->when.tv_usec >= 1000000)
{
timer_ptr->when.tv_sec += 1;
timer_ptr->when.tv_usec -= 1000000;
}
timer_ptr->proc = proc;
timer_ptr->client_data = client_data;
- timer_list.num_timers ++;
+ timer_list.num_timers++;
timer_ptr->timer_id = timer_list.num_timers;
/* Now add the timer to the timer queue, making sure it is sorted in
increasing order of expiration. */
- for (timer_index = timer_list.first_timer;
- timer_index != NULL;
+ for (timer_index = timer_list.first_timer;
+ timer_index != NULL;
timer_index = timer_index->next)
{
/* If the seconds field is greater or if it is the same, but the
microsecond field is greater. */
- if ((timer_index->when.tv_sec > timer_ptr->when.tv_sec) ||
+ if ((timer_index->when.tv_sec > timer_ptr->when.tv_sec) ||
((timer_index->when.tv_sec == timer_ptr->when.tv_sec)
&& (timer_index->when.tv_usec > timer_ptr->when.tv_usec)))
break;
}
-
+
if (timer_index == timer_list.first_timer)
{
timer_ptr->next = timer_list.first_timer;
}
else
{
- for (prev_timer = timer_list.first_timer;
- prev_timer->next != timer_index;
+ for (prev_timer = timer_list.first_timer;
+ prev_timer->next != timer_index;
prev_timer = prev_timer->next)
;
-
+
prev_timer->next = timer_ptr;
timer_ptr->next = timer_index;
}
/* When a timer event is put on the event queue, it will be handled by
this function. Just call the assiciated procedure and delete the
timer event from the event queue. Repeat this for each timer that
- has expired.*/
+ has expired. */
static void
handle_timer_event (int dummy)
{
struct timeval time_now;
struct gdb_timer *timer_ptr, *saved_timer;
-
+
gettimeofday (&time_now, NULL);
timer_ptr = timer_list.first_timer;
while (timer_ptr != NULL)
{
- if ((timer_ptr->when.tv_sec > time_now.tv_sec) ||
- ((timer_ptr->when.tv_sec == time_now.tv_sec) &&
+ if ((timer_ptr->when.tv_sec > time_now.tv_sec) ||
+ ((timer_ptr->when.tv_sec == time_now.tv_sec) &&
(timer_ptr->when.tv_usec > time_now.tv_usec)))
break;
saved_timer = timer_ptr;
timer_ptr = timer_ptr->next;
/* Call the procedure associated with that timer. */
- (*saved_timer->proc) (timer_ptr->client_data);
+ (*saved_timer->proc) (saved_timer->client_data);
free (saved_timer);
}
gdb_notifier.timeout_valid = 0;
}
-
+
/* Check whether any timers in the timers queue are ready. If at least
one timer is ready, stick an event onto the event queue. Even in
case more than one timer is ready, one event is enough, because the
handle_timer_event() will go through the timers list and call the
procedures associated with all that have expired. Update the
- timeout for the select() or poll() as well.*/
+ timeout for the select() or poll() as well. */
static void
poll_timers (void)
{
struct timeval time_now, delta;
gdb_event *event_ptr;
-
- if (timer_list.num_timers)
+
+ if (timer_list.first_timer != NULL)
{
gettimeofday (&time_now, NULL);
delta.tv_sec = timer_list.first_timer->when.tv_sec - time_now.tv_sec;
delta.tv_sec -= 1;
delta.tv_usec += 1000000;
}
-
+
/* Oops it expired already. Tell select / poll to return
- immediately. */
- if (delta.tv_sec < 0)
+ immediately. (Cannot simply test if delta.tv_sec is negative
+ because time_t might be unsigned.) */
+ if (timer_list.first_timer->when.tv_sec < time_now.tv_sec
+ || (timer_list.first_timer->when.tv_sec == time_now.tv_sec
+ && timer_list.first_timer->when.tv_usec < time_now.tv_usec))
{
delta.tv_sec = 0;
delta.tv_usec = 0;
}
/* Now we need to update the timeout for select/ poll, because we
- don't want to sit there while this timer is expiring. */
+ don't want to sit there while this timer is expiring. */
#ifdef HAVE_POLL
- gdb_notifier.timeout = delta.tv_sec * 1000;
+ gdb_notifier.timeout = delta.tv_sec * 1000;
#else
- gdb_notifier.timeout.sec = delta.tv_sec;
- gdb_notifier.timeout.usec = delta.tv_usec;
+ gdb_notifier.timeout.tv_sec = delta.tv_sec;
+ gdb_notifier.timeout.tv_usec = delta.tv_usec;
#endif
gdb_notifier.timeout_valid = 1;
}
- else
+ else
gdb_notifier.timeout_valid = 0;
}
projects / platform / upstream / binutils.git / blobdiff