#include "defs.h"
#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
#endif
#include <errno.h>
#include <setjmp.h>
+#include <sys/time.h>
+
+/* Type of the mask arguments to select. */
+
+#ifndef NO_FD_SET
+#define SELECT_MASK fd_set
+#else
+#ifndef _AIX
+typedef long fd_mask;
+#endif
+#if defined(_IBMR2)
+#define SELECT_MASK void
+#else
+#define SELECT_MASK int
+#endif
+#endif
+
+/* Define "NBBY" (number of bits per byte) if it's not already defined. */
+
+#ifndef NBBY
+#define NBBY 8
+#endif
+
+
+/* Define the number of fd_masks in an fd_set */
+
+#ifndef FD_SETSIZE
+#ifdef OPEN_MAX
+#define FD_SETSIZE OPEN_MAX
+#else
+#define FD_SETSIZE 256
+#endif
+#endif
+#if !defined(howmany)
+#define howmany(x, y) (((x)+((y)-1))/(y))
+#endif
+#ifndef NFDBITS
+#define NFDBITS NBBY*sizeof(fd_mask)
+#endif
+#define MASK_SIZE howmany(FD_SETSIZE, NFDBITS)
+
+
+typedef struct gdb_event gdb_event;
+typedef void (event_handler_func) (int);
+
+/* Event for the GDB event system. Events are queued by calling
+ async_queue_event and serviced later on by gdb_do_one_event. An
+ event can be, for instance, a file descriptor becoming ready to be
+ read. Servicing an event simply means that the procedure PROC will
+ be called. We have 2 queues, one for file handlers that we listen
+ to in the event loop, and one for the file handlers+events that are
+ ready. The procedure PROC associated with each event is always the
+ same (handle_file_event). Its duty is to invoke the handler
+ associated with the file descriptor whose state change generated
+ the event, plus doing other cleanups adn such. */
+
+struct gdb_event
+ {
+ event_handler_func *proc; /* Procedure to call to service this event. */
+ int fd; /* File descriptor that is ready. */
+ struct gdb_event *next_event; /* Next in list of events or NULL. */
+ };
+
+/* Information about each file descriptor we register with the event
+ loop. */
+
+typedef struct file_handler
+ {
+ int fd; /* File descriptor. */
+ 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. */
+ gdb_client_data client_data; /* Argument to pass to proc. */
+ int error; /* Was an error detected on this fd? */
+ struct file_handler *next_file; /* Next registered file descriptor. */
+ }
+file_handler;
+
+/* PROC is a function to be invoked when the READY flag is set. This
+ happens when there has been a signal and the corresponding signal
+ handler has 'triggered' this async_signal_handler for
+ execution. The actual work to be done in response to a signal will
+ be carried out by PROC at a later time, within process_event. This
+ provides a deferred execution of signal handlers.
+ Async_init_signals takes care of setting up such an
+ asyn_signal_handler for each interesting signal. */
+typedef struct async_signal_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 */
+ gdb_client_data client_data; /* Argument to async_handler_func */
+ }
+async_signal_handler;
+
/* Event queue:
- the first event in the queue is the head of the queue.
/* Number of file descriptors to monitor. */
int num_fds;
+ /* Timeout in milliseconds for calls to poll(). */
+ int timeout;
+
+ /* Flag to tell whether the timeout value shuld be used. */
+ int timeout_valid;
}
gdb_notifier;
/* Number of valid bits (highest fd value + 1). */
int num_fds;
- }
+ /* Time structure for calls to select(). */
+ struct timeval timeout;
+
+ /* Flag to tell whether the timeout struct should be used. */
+ int timeout_valid;
+ }
gdb_notifier;
#endif /* HAVE_POLL */
+/* Structure associated with a timer. PROC will be executed at the
+ first occasion after WHEN. */
+struct gdb_timer
+ {
+ 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 */
+ }
+gdb_timer;
+
+/* List of currently active timers. It is sorted in order of
+ increasing timers.*/
+static struct
+ {
+ /* Pointer to first in timer list. */
+ struct gdb_timer *first_timer;
+
+ /* Length of timer list. */
+ int num_timers;
+ }
+timer_list;
+
/* All the async_signal_handlers gdb is interested in are kept onto
this list. */
static struct
function. */
static int async_handler_ready = 0;
-static void create_file_handler PARAMS ((int, int, handler_func *, gdb_client_data));
-static void invoke_async_signal_handler PARAMS ((void));
-static void handle_file_event PARAMS ((int));
-static int gdb_wait_for_event PARAMS ((void));
-static int gdb_do_one_event PARAMS ((void));
-static int check_async_ready PARAMS ((void));
+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 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 int process_event (void);
+static void handle_timer_event (int dummy);
+static void poll_timers (void);
\f
/* Insert an event object into the gdb event queue at
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 (event_ptr, position)
- gdb_event *event_ptr;
- queue_position position;
+async_queue_event (gdb_event *event_ptr, queue_position position)
{
if (position == TAIL)
{
processing. The procedure associated to this event is always
handle_file_event, which will in turn invoke the one that was
associated to FD when it was registered with the event loop. */
-gdb_event *
-create_file_event (fd)
- int fd;
+static gdb_event *
+create_file_event (int fd)
{
gdb_event *file_event_ptr;
priority events first, by invoking the associated event handler
procedure. */
static int
-process_event ()
+process_event (void)
{
gdb_event *event_ptr, *prev_ptr;
event_handler_func *proc;
it. Returns 1 if something was done otherwise returns 0 (this can
happen if there are no event sources to wait for). */
static int
-gdb_do_one_event ()
+gdb_do_one_event (void)
{
int result = 0;
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,
/* Start up the event loop. This is the entry point to the event loop
from the command loop. */
void
-start_event_loop ()
+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
}
\f
-
/* Wrapper function for create_file_handler, so that the caller
doesn't have to know implementation details about the use of poll
vs. select. */
void
-add_file_handler (fd, proc, client_data)
- int fd;
- void (*proc) (void);
- 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, (handler_func *) proc, client_data);
+ create_file_handler (fd, POLLIN, proc, client_data);
#else
- create_file_handler (fd, GDB_READABLE, (handler_func *) proc, client_data);
+ create_file_handler (fd, GDB_READABLE | GDB_EXCEPTION, proc, client_data);
#endif
}
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 (fd, mask, proc, client_data)
- 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;
break;
}
- /* It is a new file descriptor. */
+ /* It is a new file descriptor. Add it to the list. Otherwise, just
+ change the data associated with it.*/
if (file_ptr == NULL)
{
file_ptr = (file_handler *) xmalloc (sizeof (file_handler));
file_ptr->ready_mask = 0;
file_ptr->next_file = gdb_notifier.first_file_handler;
gdb_notifier.first_file_handler = file_ptr;
+#ifdef HAVE_POLL
+ gdb_notifier.num_fds++;
+#endif
}
file_ptr->proc = proc;
file_ptr->client_data = client_data;
#ifdef HAVE_POLL
- gdb_notifier.num_fds++;
if (gdb_notifier.poll_fds)
gdb_notifier.poll_fds =
(struct pollfd *) realloc (gdb_notifier.poll_fds,
/* Remove the file descriptor FD from the list of monitored fd's:
i.e. we don't care anymore about events on the FD. */
void
-delete_file_handler (fd)
- int fd;
+delete_file_handler (int fd)
{
file_handler *file_ptr, *prev_ptr = NULL;
int i, j;
through event_ptr->proc. EVENT_FILE_DESC is file descriptor of the
event in the front of the event queue. */
static void
-handle_file_event (event_file_desc)
- int event_file_desc;
+handle_file_event (int event_file_desc)
{
file_handler *file_ptr;
- int mask, error_mask;
+ int mask;
+#ifdef HAVE_POLL
+ int error_mask;
+ int error_mask_returned;
+#endif
/* Search the file handler list to find one that matches the fd in
the event. */
error_mask = POLLHUP | POLLERR | POLLNVAL;
mask = (file_ptr->ready_mask & file_ptr->mask) |
(file_ptr->ready_mask & error_mask);
+ error_mask_returned = mask & error_mask;
+ 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)
+ 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);*/
+ file_ptr->error = 1;
+ }
+ else
+ file_ptr->error = 0;
#else /* ! HAVE_POLL */
+ if (file_ptr->ready_mask & GDB_EXCEPTION)
+ {
+ printf_unfiltered ("Exception condition detected on fd %d\n", file_ptr->fd);
+ file_ptr->error = 1;
+ }
+ else
+ file_ptr->error = 0;
mask = file_ptr->ready_mask & file_ptr->mask;
#endif /* HAVE_POLL */
/* If there was a match, then call the handler. */
if (mask != 0)
- (*file_ptr->proc) (file_ptr->client_data);
+ (*file_ptr->proc) (file_ptr->error, file_ptr->fd, file_ptr->client_data);
break;
}
}
Return -1 if there are no files descriptors to monitor,
otherwise return 0. */
static int
-gdb_wait_for_event ()
+gdb_wait_for_event (void)
{
file_handler *file_ptr;
gdb_event *file_event_ptr;
#ifdef HAVE_POLL
num_found =
- poll (gdb_notifier.poll_fds, (unsigned long) gdb_notifier.num_fds, -1);
+ 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.*/
+ if (num_found == -1 && errno != EINTR)
+ perror_with_name ("Poll");
#else /* ! HAVE_POLL */
memcpy (gdb_notifier.ready_masks,
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],
- NULL);
+ (SELECT_MASK *) & gdb_notifier.ready_masks[2 * MASK_SIZE],
+ 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));
-
+ {
+ memset (gdb_notifier.ready_masks,
+ 0, 3 * MASK_SIZE * sizeof (fd_mask));
+ /* Dont print anything is we got a signal, let gdb handle it. */
+ if (errno != EINTR)
+ perror_with_name ("Select");
+ }
#endif /* HAVE_POLL */
/* Enqueue all detected file events. */
PROC is the function to call with CLIENT_DATA argument
whenever the handler is invoked. */
async_signal_handler *
-create_async_signal_handler (proc, client_data)
- 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_handler_ptr)
- 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;
/* Call all the handlers that are ready. */
static void
-invoke_async_signal_handler ()
+invoke_async_signal_handler (void)
{
async_signal_handler *async_handler_ptr;
/* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
Free the space allocated for it. */
void
-delete_async_signal_handler (async_handler_ptr)
- async_signal_handler **async_handler_ptr;
+delete_async_signal_handler (async_signal_handler **async_handler_ptr)
{
async_signal_handler *prev_ptr;
/* Is it necessary to call invoke_async_signal_handler? */
static int
-check_async_ready ()
+check_async_ready (void)
{
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.*/
+int
+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;
+
+ 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 )
+ {
+ 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_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;
+ 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) ||
+ ((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;
+ timer_list.first_timer = timer_ptr;
+
+ }
+ else
+ {
+ 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;
+ }
+
+ gdb_notifier.timeout_valid = 0;
+ return timer_ptr->timer_id;
+}
+
+/* There is a chance that the creator of the timer wants to get rid of
+ it before it expires. */
+void
+delete_timer (int id)
+{
+ struct gdb_timer *timer_ptr, *prev_timer = NULL;
+
+ /* Find the entry for the given timer. */
+
+ for (timer_ptr = timer_list.first_timer; timer_ptr != NULL;
+ timer_ptr = timer_ptr->next)
+ {
+ if (timer_ptr->timer_id == id)
+ break;
+ }
+
+ if (timer_ptr == NULL)
+ return;
+ /* Get rid of the timer in the timer list. */
+ if (timer_ptr == timer_list.first_timer)
+ timer_list.first_timer = timer_ptr->next;
+ else
+ {
+ for (prev_timer = timer_list.first_timer;
+ prev_timer->next != timer_ptr;
+ prev_timer = prev_timer->next)
+ ;
+ prev_timer->next = timer_ptr->next;
+ }
+ free ((char *) timer_ptr);
+
+ gdb_notifier.timeout_valid = 0;
+}
+
+/* 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.*/
+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) &&
+ (timer_ptr->when.tv_usec > time_now.tv_usec)))
+ break;
+
+ /* Get rid of the timer from the beginning of the list. */
+ timer_list.first_timer = timer_ptr->next;
+ saved_timer = timer_ptr;
+ timer_ptr = timer_ptr->next;
+ /* Call the procedure associated with that timer. */
+ (*saved_timer->proc) (timer_ptr->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.*/
+static void
+poll_timers (void)
+{
+ struct timeval time_now, delta;
+ gdb_event *event_ptr;
+
+ if (timer_list.num_timers)
+ {
+ gettimeofday (&time_now, NULL);
+ delta.tv_sec = timer_list.first_timer->when.tv_sec - time_now.tv_sec;
+ delta.tv_usec = timer_list.first_timer->when.tv_usec - time_now.tv_usec;
+ /* borrow? */
+ if (delta.tv_usec < 0)
+ {
+ delta.tv_sec -= 1;
+ delta.tv_usec += 1000000;
+ }
+
+ /* Oops it expired already. Tell select / poll to return
+ immediately. */
+ if (delta.tv_sec < 0)
+ {
+ delta.tv_sec = 0;
+ delta.tv_usec = 0;
+ }
+
+ if (delta.tv_sec == 0 && delta.tv_usec == 0)
+ {
+ event_ptr = (gdb_event *) xmalloc (sizeof (gdb_event));
+ event_ptr->proc = handle_timer_event;
+ event_ptr->fd = timer_list.first_timer->timer_id;
+ async_queue_event (event_ptr, TAIL);
+ }
+
+ /* Now we need to update the timeout for select/ poll, because we
+ don't want to sit there while this timer is expiring. */
+#ifdef HAVE_POLL
+ gdb_notifier.timeout = delta.tv_sec * 1000;
+#else
+ gdb_notifier.timeout.sec = delta.tv_sec;
+ gdb_notifier.timeout.usec = delta.tv_usec;
+#endif
+ gdb_notifier.timeout_valid = 1;
+ }
+ else
+ gdb_notifier.timeout_valid = 0;
+}
projects / deliverable / binutils-gdb.git / blobdiff