This is the mail archive of the gdb-patches@sourceware.cygnus.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

Re: HAVE_POLL is not enough - RFA


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

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]