This is the mail archive of the
gdb-patches@sourceware.cygnus.com
mailing list for the GDB project.
Re: HAVE_POLL is not enough - RFA
- To: ezannoni at cygnus dot com (Elena Zannoni)
- Subject: Re: HAVE_POLL is not enough - RFA
- From: "Philippe De Muyter" <phdm at macqel dot be>
- Date: Sat, 18 Mar 100 11:28:01 +0100 (CET)
- Cc: ac131313 at cygnus dot com, ezannoni at cygnus dot com, gdb-patches at sourceware dot cygnus dot com
I implemented the runtime poll/select selection. The patch seems huge because
of the indentation changes caused by replacing
#if HAVE_POLL
some_code
#else
some_other_code
#endif
by
#if HAVE_POLL
if (!use_select)
{
some_code
}
else
#endif
{
some_other_code
}
I have tested it on m68k-motorola-sysv and powerpc-ibm-aix4.1.5.0
OK to apply ?
Sat Mar 18 11:05:38 2000 Philippe De Muyter <phdm@macqel.be>
* event-loop.c (sys/types.h): File now included unconditionally.
(gdb_notifier): poll- and select-versions merged.
(add_file_handler): If HAVE_POLL, do a runtime check whether poll
is usable, and set `use_select' accordingly.
(create_file_handler): Select poll or select version according to
`use_select'.
(delete_file_handler, handle_file_event): Likewise.
(gdb_wait_for_event, poll_timers): Likewise.
Index: gdb/event-loop.c
===================================================================
RCS file: /cvs/src/src/gdb/event-loop.c,v
retrieving revision 1.3
diff -u -p -r1.3 event-loop.c
--- event-loop.c 2000/03/06 17:07:03 1.3
+++ event-loop.c 2000/03/18 10:06:38
@@ -25,9 +25,8 @@
#include "event-top.h"
#ifdef HAVE_POLL
#include <poll.h>
-#else
-#include <sys/types.h>
#endif
+#include <sys/types.h>
#include <errno.h>
#include <setjmp.h>
#include <sys/time.h>
@@ -159,36 +158,23 @@ event_queue;
/* As of 1999-04-30 only the input file descriptor is registered with the
event loop. */
-#ifdef HAVE_POLL
/* Poll based implementation of the notifier. */
static struct
{
+ /* Do we use poll or select ? */
+ unsigned char use_select;
+
/* Ptr to head of file handler list. */
file_handler *first_file_handler;
+#ifdef HAVE_POLL
/* Ptr to array of pollfd structures. */
struct pollfd *poll_fds;
- /* 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;
-
-#else /* ! HAVE_POLL */
-
-/* Select based implementation of the notifier. */
-
-static struct
- {
- /* Ptr to head of file handler list. */
- file_handler *first_file_handler;
+ int poll_timeout;
+#endif
/* Masks to be used in the next call to select.
Bits are set in response to calls to create_file_handler. */
@@ -197,19 +183,18 @@ static struct
/* What file descriptors were found ready by select. */
fd_mask ready_masks[3 * MASK_SIZE];
- /* Number of valid bits (highest fd value + 1). */
+ /* Number of file descriptors to monitor. (for poll) */
+ /* Number of valid bits (highest fd value + 1). (for select) */
int num_fds;
/* Time structure for calls to select(). */
- struct timeval timeout;
+ struct timeval select_timeout;
- /* Flag to tell whether the timeout struct should be used. */
+ /* Flag to tell whether the timeout 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
@@ -377,7 +362,7 @@ process_event (void)
}
free ((char *) event_ptr);
- /* Now call the procedure associted with the event. */
+ /* Now call the procedure associated with the event. */
(*proc) (fd);
return 1;
}
@@ -466,10 +451,21 @@ void
add_file_handler (int fd, handler_func * proc, gdb_client_data client_data)
{
#ifdef HAVE_POLL
- create_file_handler (fd, POLLIN, proc, client_data);
-#else
- create_file_handler (fd, GDB_READABLE | GDB_EXCEPTION, proc, client_data);
-#endif
+ struct pollfd fds;
+
+ if (!gdb_notifier.use_select)
+ {
+
+ fds.fd = fd;
+ fds.events = POLLIN;
+ if (poll (&fds, 1, 0) == 1 && (fds.revents & POLLNVAL))
+ gdb_notifier.use_select = 1;
+ }
+ if (!gdb_notifier.use_select)
+ create_file_handler (fd, POLLIN, proc, client_data);
+ else
+#endif /* HAVE_POLL */
+ create_file_handler (fd, GDB_READABLE | GDB_EXCEPTION, proc, client_data);
}
/* Add a file handler/descriptor to the list of descriptors we are
@@ -487,9 +483,7 @@ create_file_handler (int fd, int mask, h
{
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). */
@@ -509,9 +503,6 @@ create_file_handler (int fd, int mask, h
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;
@@ -519,41 +510,47 @@ create_file_handler (int fd, int mask, h
#ifdef HAVE_POLL
- if (gdb_notifier.poll_fds)
- gdb_notifier.poll_fds =
- (struct pollfd *) realloc (gdb_notifier.poll_fds,
- (gdb_notifier.num_fds) * sizeof (struct pollfd));
+ if (!gdb_notifier.use_select)
+ {
+ gdb_notifier.num_fds++;
+ if (gdb_notifier.poll_fds)
+ gdb_notifier.poll_fds =
+ (struct pollfd *) realloc (gdb_notifier.poll_fds,
+ (gdb_notifier.num_fds) * sizeof (struct pollfd));
+ else
+ gdb_notifier.poll_fds =
+ (struct pollfd *) xmalloc (sizeof (struct pollfd));
+ (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->fd = fd;
+ (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->events = mask;
+ (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->revents = 0;
+ }
else
- gdb_notifier.poll_fds =
- (struct pollfd *) xmalloc (sizeof (struct pollfd));
- (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->fd = fd;
- (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->events = mask;
- (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->revents = 0;
-#else /* ! HAVE_POLL */
+#endif /* HAVE_POLL */
- index = fd / (NBBY * sizeof (fd_mask));
- bit = 1 << (fd % (NBBY * sizeof (fd_mask)));
+ {
+ index = fd / (NBBY * sizeof (fd_mask));
+ bit = 1 << (fd % (NBBY * sizeof (fd_mask)));
- if (mask & GDB_READABLE)
- gdb_notifier.check_masks[index] |= bit;
- else
- gdb_notifier.check_masks[index] &= ~bit;
+ if (mask & GDB_READABLE)
+ gdb_notifier.check_masks[index] |= bit;
+ else
+ gdb_notifier.check_masks[index] &= ~bit;
- if (mask & GDB_WRITABLE)
- (gdb_notifier.check_masks + MASK_SIZE)[index] |= bit;
- else
- (gdb_notifier.check_masks + MASK_SIZE)[index] &= ~bit;
+ if (mask & GDB_WRITABLE)
+ (gdb_notifier.check_masks + MASK_SIZE)[index] |= bit;
+ else
+ (gdb_notifier.check_masks + MASK_SIZE)[index] &= ~bit;
- if (mask & GDB_EXCEPTION)
- (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] |= bit;
- else
- (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] &= ~bit;
+ if (mask & GDB_EXCEPTION)
+ (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] |= bit;
+ else
+ (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] &= ~bit;
- if (gdb_notifier.num_fds <= fd)
- gdb_notifier.num_fds = fd + 1;
+ if (gdb_notifier.num_fds <= fd)
+ gdb_notifier.num_fds = fd + 1;
+ }
-#endif /* HAVE_POLL */
}
/* Remove the file descriptor FD from the list of monitored fd's:
@@ -564,10 +561,8 @@ delete_file_handler (int fd)
file_handler *file_ptr, *prev_ptr = NULL;
int i, j;
struct pollfd *new_poll_fds;
-#ifndef HAVE_POLL
int index, bit;
unsigned long flags;
-#endif
/* Find the entry for the given file. */
@@ -582,60 +577,65 @@ delete_file_handler (int fd)
return;
#ifdef HAVE_POLL
- /* Create a new poll_fds array by copying every fd's information but the
- one we want to get rid of. */
+ if (!gdb_notifier.use_select)
+ {
+ /* Create a new poll_fds array by copying every fd's information but the
+ one we want to get rid of. */
- new_poll_fds =
- (struct pollfd *) xmalloc ((gdb_notifier.num_fds - 1) * sizeof (struct pollfd));
+ new_poll_fds =
+ (struct pollfd *) xmalloc ((gdb_notifier.num_fds - 1) * sizeof (struct pollfd));
- for (i = 0, j = 0; i < gdb_notifier.num_fds; i++)
- {
- if ((gdb_notifier.poll_fds + i)->fd != fd)
+ for (i = 0, j = 0; i < gdb_notifier.num_fds; i++)
{
- (new_poll_fds + j)->fd = (gdb_notifier.poll_fds + i)->fd;
- (new_poll_fds + j)->events = (gdb_notifier.poll_fds + i)->events;
- (new_poll_fds + j)->revents = (gdb_notifier.poll_fds + i)->revents;
- j++;
+ if ((gdb_notifier.poll_fds + i)->fd != fd)
+ {
+ (new_poll_fds + j)->fd = (gdb_notifier.poll_fds + i)->fd;
+ (new_poll_fds + j)->events = (gdb_notifier.poll_fds + i)->events;
+ (new_poll_fds + j)->revents = (gdb_notifier.poll_fds + i)->revents;
+ j++;
+ }
}
+ free (gdb_notifier.poll_fds);
+ gdb_notifier.poll_fds = new_poll_fds;
+ gdb_notifier.num_fds--;
}
- free (gdb_notifier.poll_fds);
- gdb_notifier.poll_fds = new_poll_fds;
- gdb_notifier.num_fds--;
+ else
-#else /* ! HAVE_POLL */
+#endif /* HAVE_POLL */
- index = fd / (NBBY * sizeof (fd_mask));
- bit = 1 << (fd % (NBBY * sizeof (fd_mask)));
+ {
+ 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;
- if (file_ptr->mask & GDB_WRITABLE)
- (gdb_notifier.check_masks + MASK_SIZE)[index] &= ~bit;
- if (file_ptr->mask & GDB_EXCEPTION)
- (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] &= ~bit;
+ if (file_ptr->mask & GDB_READABLE)
+ gdb_notifier.check_masks[index] &= ~bit;
+ if (file_ptr->mask & GDB_WRITABLE)
+ (gdb_notifier.check_masks + MASK_SIZE)[index] &= ~bit;
+ if (file_ptr->mask & GDB_EXCEPTION)
+ (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] &= ~bit;
- /* Find current max fd. */
+ /* Find current max fd. */
- if ((fd + 1) == gdb_notifier.num_fds)
- {
- for (gdb_notifier.num_fds = 0; index >= 0; index--)
+ if ((fd + 1) == gdb_notifier.num_fds)
{
- flags = gdb_notifier.check_masks[index]
- | (gdb_notifier.check_masks + MASK_SIZE)[index]
- | (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index];
- if (flags)
+ for (gdb_notifier.num_fds = 0; index >= 0; index--)
{
- for (i = (NBBY * sizeof (fd_mask)); i > 0; i--)
+ flags = gdb_notifier.check_masks[index]
+ | (gdb_notifier.check_masks + MASK_SIZE)[index]
+ | (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index];
+ if (flags)
{
- if (flags & (((unsigned long) 1) << (i - 1)))
- break;
+ 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;
}
- gdb_notifier.num_fds = index * (NBBY * sizeof (fd_mask)) + i;
- break;
}
}
}
-#endif /* HAVE_POLL */
/* Deactivate the file descriptor, by clearing its mask,
so that it will not fire again. */
@@ -688,35 +688,40 @@ handle_file_event (int event_file_desc)
events (ready_mask). */
#ifdef HAVE_POLL
- 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)
+ if (!gdb_notifier.use_select)
{
- /* 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 or non-`poll'able fd %d\n", file_ptr->fd);
- file_ptr->error = 1;
+ 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 or non-`poll'able fd %d\n", file_ptr->fd);
+ file_ptr->error = 1;
+ }
+ else
+ file_ptr->error = 0;
}
else
- file_ptr->error = 0;
-#else /* ! HAVE_POLL */
- if (file_ptr->ready_mask & GDB_EXCEPTION)
+#endif /* HAVE_POLL */
{
- printf_unfiltered ("Exception condition detected on fd %d\n", file_ptr->fd);
- file_ptr->error = 1;
+ 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;
}
- else
- file_ptr->error = 0;
- mask = file_ptr->ready_mask & file_ptr->mask;
-#endif /* HAVE_POLL */
/* Clear the received events for next time around. */
file_ptr->ready_mask = 0;
@@ -744,9 +749,7 @@ gdb_wait_for_event (void)
int num_found = 0;
int i;
-#ifndef HAVE_POLL
int mask, bit, index;
-#endif
/* Make sure all output is done before getting another event. */
gdb_flush (gdb_stdout);
@@ -756,103 +759,114 @@ gdb_wait_for_event (void)
return -1;
#ifdef HAVE_POLL
- num_found =
- 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,
- gdb_notifier.check_masks,
- 3 * MASK_SIZE * sizeof (fd_mask));
- 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);
-
- /* Clear the masks after an error from select. */
- if (num_found == -1)
- {
- 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");
+ if (!gdb_notifier.use_select)
+ {
+ num_found =
+ poll (gdb_notifier.poll_fds,
+ (unsigned long) gdb_notifier.num_fds,
+ gdb_notifier.timeout_valid ? gdb_notifier.poll_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
+
#endif /* HAVE_POLL */
+ {
+ memcpy (gdb_notifier.ready_masks,
+ gdb_notifier.check_masks,
+ 3 * MASK_SIZE * sizeof (fd_mask));
+ 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.select_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));
+ /* Dont print anything is we got a signal, let gdb handle it. */
+ if (errno != EINTR)
+ perror_with_name ("Select");
+ }
+ }
+
/* Enqueue all detected file events. */
#ifdef HAVE_POLL
- for (i = 0; (i < gdb_notifier.num_fds) && (num_found > 0); i++)
+ if (!gdb_notifier.use_select)
{
- if ((gdb_notifier.poll_fds + i)->revents)
- num_found--;
- else
- continue;
+ for (i = 0; (i < gdb_notifier.num_fds) && (num_found > 0); i++)
+ {
+ if ((gdb_notifier.poll_fds + i)->revents)
+ num_found--;
+ else
+ continue;
+
+ for (file_ptr = gdb_notifier.first_file_handler;
+ file_ptr != NULL;
+ file_ptr = file_ptr->next_file)
+ {
+ if (file_ptr->fd == (gdb_notifier.poll_fds + i)->fd)
+ break;
+ }
+
+ if (file_ptr)
+ {
+ /* Enqueue an event only if this is still a new event for
+ this fd. */
+ if (file_ptr->ready_mask == 0)
+ {
+ file_event_ptr = create_file_event (file_ptr->fd);
+ async_queue_event (file_event_ptr, TAIL);
+ }
+ }
+
+ file_ptr->ready_mask = (gdb_notifier.poll_fds + i)->revents;
+ }
+ }
+ else
+#endif /* HAVE_POLL */
+ {
for (file_ptr = gdb_notifier.first_file_handler;
- file_ptr != NULL;
+ (file_ptr != NULL) && (num_found > 0);
file_ptr = file_ptr->next_file)
{
- if (file_ptr->fd == (gdb_notifier.poll_fds + i)->fd)
- break;
- }
+ index = file_ptr->fd / (NBBY * sizeof (fd_mask));
+ bit = 1 << (file_ptr->fd % (NBBY * sizeof (fd_mask)));
+ mask = 0;
+
+ if (gdb_notifier.ready_masks[index] & bit)
+ mask |= GDB_READABLE;
+ if ((gdb_notifier.ready_masks + MASK_SIZE)[index] & bit)
+ mask |= GDB_WRITABLE;
+ if ((gdb_notifier.ready_masks + 2 * (MASK_SIZE))[index] & bit)
+ mask |= GDB_EXCEPTION;
- if (file_ptr)
- {
+ if (!mask)
+ continue;
+ else
+ num_found--;
+
/* Enqueue an event only if this is still a new event for
this fd. */
+
if (file_ptr->ready_mask == 0)
{
file_event_ptr = create_file_event (file_ptr->fd);
async_queue_event (file_event_ptr, TAIL);
}
+ file_ptr->ready_mask = mask;
}
-
- file_ptr->ready_mask = (gdb_notifier.poll_fds + i)->revents;
}
-#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;
-
- if (gdb_notifier.ready_masks[index] & bit)
- mask |= GDB_READABLE;
- if ((gdb_notifier.ready_masks + MASK_SIZE)[index] & bit)
- mask |= GDB_WRITABLE;
- if ((gdb_notifier.ready_masks + 2 * (MASK_SIZE))[index] & bit)
- mask |= GDB_EXCEPTION;
-
- if (!mask)
- continue;
- else
- num_found--;
-
- /* Enqueue an event only if this is still a new event for
- this fd. */
-
- if (file_ptr->ready_mask == 0)
- {
- file_event_ptr = create_file_event (file_ptr->fd);
- async_queue_event (file_event_ptr, TAIL);
- }
- file_ptr->ready_mask = mask;
- }
-#endif /* HAVE_POLL */
-
return 0;
}
@@ -1135,11 +1149,14 @@ poll_timers (void)
/* 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.tv_sec = delta.tv_sec;
- gdb_notifier.timeout.tv_usec = delta.tv_usec;
-#endif
+ if (!gdb_notifier.use_select)
+ gdb_notifier.poll_timeout = delta.tv_sec * 1000;
+ else
+#endif /* HAVE_POLL */
+ {
+ gdb_notifier.select_timeout.tv_sec = delta.tv_sec;
+ gdb_notifier.select_timeout.tv_usec = delta.tv_usec;
+ }
gdb_notifier.timeout_valid = 1;
}
else