GDB 7.6.50

gdb/gdbserver/event-loop.c

 /* Event loop machinery for the remote server for GDB.
-   Copyright (C) 1999-2002, 2005-2008, 2010-2012 Free Software
-   Foundation, Inc.
+   Copyright (C) 1999-2013 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
 
 /* Based on src/gdb/event-loop.c.  */
 
 #include "server.h"
+#include "queue.h"
 
 #include <sys/types.h>
 #include <string.h>
 #include <sys/time.h>
 
 #ifdef USE_WIN32API
 #include <windows.h>
 #include <io.h>
 #endif
 
 #ifdef HAVE_ERRNO_H
 #include <errno.h>
 #endif
 
-#ifdef HAVE_UNISTD_H
 #include <unistd.h>
-#endif
 
 typedef struct gdb_event gdb_event;
 typedef int (event_handler_func) (gdb_fildes_t);
 
 /* Tell create_file_handler what events we are interested in.  */
 
 #define GDB_READABLE    (1<<1)
 #define GDB_WRITABLE    (1<<2)
 #define GDB_EXCEPTION   (1<<3)
 
-/* Events are queued by calling async_queue_event and serviced later
+/* Events are queued by calling 'QUEUE_enque (gdb_event_p, event_queue,
+   file_event_ptr)' and serviced later
    on by 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 and such.  */
 
-struct gdb_event
+typedef struct gdb_event
   {
     /* Procedure to call to service this event.  */
     event_handler_func *proc;
 
     /* File descriptor that is ready.  */
     gdb_fildes_t fd;
-
-    /* Next in list of events or NULL.  */
-    struct gdb_event *next_event;
-  };
+  } *gdb_event_p;
 
 /* Information about each file descriptor we register with the event
    loop.  */
 
 typedef struct file_handler
   {
     /* File descriptor.  */
     gdb_fildes_t fd;
 
     /* Events we want to monitor.  */
     int mask;
 
     /* Events that have been seen since the last time.  */
     int ready_mask;
 
     /* Procedure to call when fd is ready.  */
     handler_func *proc;
 
     /* Argument to pass to proc.  */
     gdb_client_data client_data;
 
     /* Was an error detected on this fd?  */
     int error;
 
     /* Next registered file descriptor.  */
     struct file_handler *next_file;
   }
 file_handler;
 
-/* Event queue:
-
-   Events can be inserted at the front of the queue or at the end of
-   the queue.  Events will be extracted from the queue for processing
-   starting from the head.  Therefore, events inserted at the head of
-   the queue will be processed in a last in first out fashion, while
-   those inserted at the tail of the queue will be processed in a
-   first in first out manner.  All the fields are NULL if the queue is
-   empty.  */
-
-static struct
-  {
-    /* The first pending event.  */
-    gdb_event *first_event;
-
-    /* The last pending event.  */
-    gdb_event *last_event;
-  }
-event_queue;
+DECLARE_QUEUE_P(gdb_event_p);
+static QUEUE(gdb_event_p) *event_queue = NULL;
+DEFINE_QUEUE_P(gdb_event_p);
 
 /* Gdb_notifier is just a list of file descriptors gdb is interested
    in.  These are the input file descriptor, and the target file
    descriptor.  Each of the elements in the gdb_notifier list is
    basically a description of what kind of events gdb is interested
    in, for each fd.  */
 
 static struct
   {
     /* Ptr to head of file handler list.  */
@@ skipping 34 matching lines @@
 static struct
   {
     struct callback_event *first;
     struct callback_event *last;
 
     /* Id of the last callback created.  */
     int num_callbacks;
   }
 callback_list;
 
-/* Insert an event object into the gdb event queue.
-
-   EVENT_PTR points to the event to be inserted into the queue.  The
-   caller must allocate memory for the event.  It is freed after the
-   event has ben handled.  Events in the queue will be processed head
-   to tail, therefore, events will be processed first in first
-   out.  */
+/* Free EVENT.  */
 
 static void
-async_queue_event (gdb_event *event_ptr)
+gdb_event_xfree (struct gdb_event *event)
 {
-  /* The event will become the new last_event.  */
+  xfree (event);
+}
 
-  event_ptr->next_event = NULL;
-  if (event_queue.first_event == NULL)
-    event_queue.first_event = event_ptr;
-  else
-    event_queue.last_event->next_event = event_ptr;
-  event_queue.last_event = event_ptr;
+void
+initialize_event_loop (void)
+{
+  event_queue = QUEUE_alloc (gdb_event_p, gdb_event_xfree);
 }
 
 /* Process one event.  If an event was processed, 1 is returned
    otherwise 0 is returned.  Scan the queue from head to tail,
    processing therefore the high priority events first, by invoking
    the associated event handler procedure.  */
 
 static int
 process_event (void)
 {
-  gdb_event *event_ptr, *prev_ptr;
-  event_handler_func *proc;
-  gdb_fildes_t fd;
+  /* Let's get rid of the event from the event queue.  We need to
+     do this now because while processing the event, since the
+     proc function could end up jumping out to the caller of this
+     function.  In that case, we would have on the event queue an
+     event which has been processed, but not deleted.  */
+  if (!QUEUE_is_empty (gdb_event_p, event_queue))
+    {
+      gdb_event *event_ptr = QUEUE_deque (gdb_event_p, event_queue);
+      event_handler_func *proc = event_ptr->proc;
+      gdb_fildes_t fd = event_ptr->fd;
 
-  /* Look in the event queue to find an event that is ready
-     to be processed.  */
-
-  for (event_ptr = event_queue.first_event;
-       event_ptr != NULL;
-       event_ptr = event_ptr->next_event)
-    {
-      /* Call the handler for the event.  */
-
-      proc = event_ptr->proc;
-      fd = event_ptr->fd;
-
-      /* Let's get rid of the event from the event queue.  We need to
-         do this now because while processing the event, since the
-         proc function could end up jumping out to the caller of this
-         function.  In that case, we would have on the event queue an
-         event which has been processed, but not deleted.  */
-
-      if (event_queue.first_event == event_ptr)
-        {
-          event_queue.first_event = event_ptr->next_event;
-          if (event_ptr->next_event == NULL)
-            event_queue.last_event = NULL;
-        }
-      else
-        {
-          prev_ptr = event_queue.first_event;
-          while (prev_ptr->next_event != event_ptr)
-            prev_ptr = prev_ptr->next_event;
-
-          prev_ptr->next_event = event_ptr->next_event;
-          if (event_ptr->next_event == NULL)
-            event_queue.last_event = prev_ptr;
-        }
-      free (event_ptr);
-
+      gdb_event_xfree (event_ptr);
       /* Now call the procedure associated with the event.  */
       if ((*proc) (fd))
         return -1;
       return 1;
     }
 
   /* This is the case if there are no event on the event queue.  */
   return 0;
 }
 
@@ skipping 263 matching lines @@
 /* Called by do_one_event to wait for new events on the monitored file
    descriptors.  Queue file events as they are detected by the poll.
    If there are no events, this function will block in the call to
    select.  Return -1 if there are no files descriptors to monitor,
    otherwise return 0.  */
 
 static int
 wait_for_event (void)
 {
   file_handler *file_ptr;
-  gdb_event *file_event_ptr;
   int num_found = 0;
 
   /* Make sure all output is done before getting another event.  */
   fflush (stdout);
   fflush (stderr);
 
   if (gdb_notifier.num_fds == 0)
     return -1;
 
   gdb_notifier.ready_masks[0] = gdb_notifier.check_masks[0];
@@ skipping 37 matching lines @@
       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);
+          gdb_event *file_event_ptr = create_file_event (file_ptr->fd);
+
+          QUEUE_enque (gdb_event_p, event_queue, file_event_ptr);
         }
       file_ptr->ready_mask = mask;
     }
 
   return 0;
 }
 
 /* Start up the event loop.  This is the entry point to the event
    loop.  */
 
@@ skipping 32 matching lines @@
          sources left.  This will make the event loop stop, and the
          application exit.  */
 
       if (wait_for_event () < 0)
         return;
     }
 
   /* We are done with the event loop.  There are no more event sources
      to listen to.  So we exit gdbserver.  */
 }