Non-stop mode support.

	* server.h (non_stop): Declare.
	(gdb_client_data, handler_func): Declare.
	(delete_file_handler, add_file_handler, start_event_loop):
	Declare.
	(handle_serial_event, handle_target_event, push_event)
	(putpkt_notif): Declare.
	* target.h (enum resume_kind): New.
	(struct thread_resume): Replace `step' field by `kind' field.
	(TARGET_WNOHANG): Define.
	(struct target_ops) <wait>: Add `options' argument.
	<supports_non_stop, async, start_non_stop>: New fields.
	(target_supports_non_stop, target_async): New.
	(start_non_stop): Declare.
	(mywait): Add `options' argument.
	* target.c (mywait): Add `options' argument.  Print child exit
	notifications here.
	(start_non_stop): New.
	* server.c (non_stop, own_buf, mem_buf): New globals.
	(struct vstop_notif): New.
	(notif_queue): New global.
	(queue_stop_reply, push_event, discard_queued_stop_replies)
	(send_next_stop_reply): New.
	(start_inferior): Adjust to use resume_kind.  Adjust to mywait
	interface changes.
	(attach_inferior): In non-stop mode, don't wait for the target
	here.
	(handle_general_set): Handle QNonStop.
	(handle_query): When handling qC, return the current general
	thread, instead of the first thread of the list.
	(handle_query): If the backend supports non-stop mode, include
	QNonStop+ in the qSupported query response.
	(handle_v_cont): Adjust to use resume_kind.  Handle resume_stop
	and non-stop mode.
	(handle_v_attach, handle_v_run): Handle non-stop mode.
	(handle_v_stopped): New.
	(handle_v_requests): Report support for vCont;t.  Handle vStopped.
	(myresume): Adjust to use resume_kind.  Handle non-stop.
	(queue_stop_reply_callback): New.
	(handle_status): Handle non-stop mode.
	(main): Clear non_stop flag on reconnection.  Use the event-loop.
	Refactor serial protocol handling from here ...
	(process_serial_event): ... to this new function.  When GDB
	selects any thread, select one here.  In non-stop mode, wait until
	GDB acks all pending events before exiting.
	(handle_serial_event, handle_target_event): New.
	* remote-utils.c (remote_open): Install remote_desc in the event
	loop.
	(remote_close): Remove remote_desc from the event loop.
	(putpkt_binary): Rename to...
	(putpkt_binary_1): ... this.  Add `is_notic' argument.  Handle it.
	(putpkt_binary): New as wrapper around putpkt_binary_1.
	(putpkt_notif): New.
	(prepare_resume_reply): In non-stop mode, don't change the
	general_thread.
	* event-loop.c: New.
	* Makefile.in (OBJ): Add event-loop.o.
	(event-loop.o): New rule.

	* linux-low.h (pid_of): Moved here.
	(lwpid_of): New.
	(get_lwp_thread): Use lwpid_of.
	(struct lwp_info): Delete `lwpid' field.  Add `suspended' field.
	* linux-low.c (pid_of): Delete.
	(inferior_pid): Use lwpid_of.
	(linux_event_pipe): New.
	(target_is_async_p): New.
	(delete_lwp): New.
	(handle_extended_wait): Use lwpid_of.
	(add_lwp): Don't set lwpid field.
	(linux_attach_lwp): Adjust debug output.  Use lwpid_of.
	(linux_kill_one_lwp): If killing a running lwp, stop it first.
	Use lwpid_of.  Adjust to linux_wait_for_event interface changes.
	(linux_detach_one_lwp): If detaching from a running lwp, stop it
	first.  Adjust to linux_wait_for_event interface changes.  Use
	lwpid_of.
	(linux_detach): Don't delete the main lwp here.
	(linux_join): Use my_waitpid.  Avoid signal_pid.  Use lwpid_of.
	(status_pending_p): Don't consider explicitly suspended lwps.
	(linux_wait_for_lwp): Take an integer pid instead of a lwp_info
	pointer.  Add OPTIONS argument.  Change return type to int.  Use
	my_waitpid instead of sleeping.  Handle WNOHANG.  Use lwpid_of.
	(linux_wait_for_event): Take an integer pid instead of a lwp_info
	pointer.  Add status pointer argument.  Return a pid instead of a
	status.  Use lwpid_of.  Adjust to linux_wait_for_lwp interface
	changes.  In non-stop mode, don't switch to a random thread.
	(linux_wait): Rename to...
	(linux_wait_1): ... this.  Add target_options argument, and handle
	it.  Adjust to use resume_kind.  Use lwpid_of.  In non-stop mode,
	don't handle the continue thread.  Handle TARGET_WNOHANG.  Merge
	clean exit and signal exit code.  Don't stop all threads in
	non-stop mode.  In all-stop mode, only stop all threads when
	reporting a stop to GDB.  Handle explicit thread stop requests.
	(async_file_flush, async_file_mark): New.
	(linux_wait): New.
	(send_sigstop): Use lwpid_of.
	(wait_for_sigstop): Use lwpid_of.  Adjust to linux_wait_for_event
	interface changes.  In non-stop mode, don't switch to a random
	thread.
	(linux_resume_one_lwp): Use lwpid_of.
	(linux_continue_one_thread, linux_queue_one_thread): Merge into ...
	(linux_resume_one_thread): ... this.  Handle resume_stop.  In
	non-stop mode, don't look for pending flag in all threads.
	(resume_status_pending_p): Don't consider explicitly suspended
	threads.
	(my_waitpid): Reimplement.  Emulate __WALL.
	(linux_request_interrupt, linux_read_offsets, linux_xfer_siginfo):
	Use lwpid_of.
	(sigchld_handler, linux_supports_non_stop, linux_async)
	(linux_start_non_stop): New.
	(linux_target_ops): Register linux_supports_non_stop, linux_async
	and linux_start_non_stop.
	(initialize_low): Install SIGCHLD handler.
	* thread-db.c (thread_db_create_event, find_one_thread)
	(thread_db_get_tls_address): Use lwpid_of.
	* win32-low.c (win32_detach): Adjust to use resume_kind.
	(win32_wait): Add `options' argument.
	* spu-low.c (spu_resume): Adjust to use resume_kind.
	(spu_wait): Add `options' argument.

1 files changed, 504 insertions, 0 deletions

diff --git a/gdb/gdbserver/event-loop.c b/gdb/gdbserver/event-loop.c
new file mode 100644
index 0000000..a76a178
--- /dev/null
+++ b/gdb/gdbserver/event-loop.c
@@ -0,0 +1,504 @@
+/* Event loop machinery for the remote server for GDB.
+   Copyright (C) 1999, 2000, 2001, 2002, 2005, 2006, 2007, 2008
+   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 <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
+
+typedef struct gdb_event gdb_event;
+typedef void (event_handler_func) (int);
+
+/* 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
+   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
+  {
+    /* Procedure to call to service this event.  */
+    event_handler_func *proc;
+
+    /* File descriptor that is ready.  */
+    int fd;
+
+    /* Next in list of events or NULL.  */
+    struct gdb_event *next_event;
+  };
+
+/* Information about each file descriptor we register with the event
+   loop.  */
+
+typedef struct file_handler
+  {
+    /* File descriptor.  */
+    int 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;
+
+/* 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.  */
+    file_handler *first_file_handler;
+
+    /* Masks to be used in the next call to select.  Bits are set in
+       response to calls to create_file_handler.  */
+    fd_set check_masks[3];
+
+    /* What file descriptors were found ready by select.  */
+    fd_set ready_masks[3];
+
+    /* Number of valid bits (highest fd value + 1). (for select) */
+    int num_fds;
+  }
+gdb_notifier;
+
+/* 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.  */
+
+static void
+async_queue_event (gdb_event *event_ptr)
+{
+  /* The event will become the new last_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;
+}
+
+/* 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;
+  int 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);
+
+      /* Now call the procedure associated with the event.  */
+      (*proc) (fd);
+      return 1;
+    }
+
+  /* This is the case if there are no event on the event queue.  */
+  return 0;
+}
+
+/* Add a file handler/descriptor to the list of descriptors we are
+   interested in.  FD is the file descriptor for the file/stream to be
+   listened to.  MASK is a combination of READABLE, WRITABLE,
+   EXCEPTION.  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)
+{
+  file_handler *file_ptr;
+
+  /* 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;
+       file_ptr = file_ptr->next_file)
+    if (file_ptr->fd == fd)
+      break;
+
+  /* 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 = xmalloc (sizeof (*file_ptr));
+      file_ptr->fd = fd;
+      file_ptr->ready_mask = 0;
+      file_ptr->next_file = gdb_notifier.first_file_handler;
+      gdb_notifier.first_file_handler = file_ptr;
+
+      if (mask & GDB_READABLE)
+	FD_SET (fd, &gdb_notifier.check_masks[0]);
+      else
+	FD_CLR (fd, &gdb_notifier.check_masks[0]);
+
+      if (mask & GDB_WRITABLE)
+	FD_SET (fd, &gdb_notifier.check_masks[1]);
+      else
+	FD_CLR (fd, &gdb_notifier.check_masks[1]);
+
+      if (mask & GDB_EXCEPTION)
+	FD_SET (fd, &gdb_notifier.check_masks[2]);
+      else
+	FD_CLR (fd, &gdb_notifier.check_masks[2]);
+
+      if (gdb_notifier.num_fds <= fd)
+	gdb_notifier.num_fds = fd + 1;
+    }
+
+  file_ptr->proc = proc;
+  file_ptr->client_data = client_data;
+  file_ptr->mask = mask;
+}
+
+/* Wrapper function for create_file_handler.  */
+
+void
+add_file_handler (int fd, handler_func *proc, gdb_client_data client_data)
+{
+  create_file_handler (fd, GDB_READABLE | GDB_EXCEPTION, proc, client_data);
+}
+
+/* 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 (int fd)
+{
+  file_handler *file_ptr, *prev_ptr = NULL;
+  int i;
+
+  /* Find the entry for the given file. */
+
+  for (file_ptr = gdb_notifier.first_file_handler;
+       file_ptr != NULL;
+       file_ptr = file_ptr->next_file)
+    if (file_ptr->fd == fd)
+      break;
+
+  if (file_ptr == NULL)
+    return;
+
+  if (file_ptr->mask & GDB_READABLE)
+    FD_CLR (fd, &gdb_notifier.check_masks[0]);
+  if (file_ptr->mask & GDB_WRITABLE)
+    FD_CLR (fd, &gdb_notifier.check_masks[1]);
+  if (file_ptr->mask & GDB_EXCEPTION)
+    FD_CLR (fd, &gdb_notifier.check_masks[2]);
+
+  /* Find current max fd.  */
+
+  if ((fd + 1) == gdb_notifier.num_fds)
+    {
+      gdb_notifier.num_fds--;
+      for (i = gdb_notifier.num_fds; i; i--)
+	{
+	  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;
+    }
+
+  /* Deactivate the file descriptor, by clearing its mask, so that it
+     will not fire again.  */
+
+  file_ptr->mask = 0;
+
+  /* Get rid of the file handler in the file handler list.  */
+  if (file_ptr == gdb_notifier.first_file_handler)
+    gdb_notifier.first_file_handler = file_ptr->next_file;
+  else
+    {
+      for (prev_ptr = gdb_notifier.first_file_handler;
+	   prev_ptr->next_file != file_ptr;
+	   prev_ptr = prev_ptr->next_file)
+	;
+      prev_ptr->next_file = file_ptr->next_file;
+    }
+  free (file_ptr);
+}
+
+/* Handle the given event by calling the procedure associated to the
+   corresponding file handler.  Called by process_event indirectly,
+   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 (int event_file_desc)
+{
+  file_handler *file_ptr;
+  int mask;
+
+  /* Search the file handler list to find one that matches the fd in
+     the event.  */
+  for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
+       file_ptr = file_ptr->next_file)
+    {
+      if (file_ptr->fd == event_file_desc)
+	{
+	  /* See if the desired events (mask) match the received
+	     events (ready_mask).  */
+
+	  if (file_ptr->ready_mask & GDB_EXCEPTION)
+	    {
+	      fprintf (stderr, "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;
+
+	  /* Clear the received events for next time around.  */
+	  file_ptr->ready_mask = 0;
+
+	  /* If there was a match, then call the handler.  */
+	  if (mask != 0)
+	    (*file_ptr->proc) (file_ptr->error, file_ptr->client_data);
+	  break;
+	}
+    }
+}
+
+/* Create a file event, to be enqueued in the event queue for
+   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.  */
+
+static gdb_event *
+create_file_event (int fd)
+{
+  gdb_event *file_event_ptr;
+
+  file_event_ptr = xmalloc (sizeof (gdb_event));
+  file_event_ptr->proc = handle_file_event;
+  file_event_ptr->fd = fd;
+  return file_event_ptr;
+}
+
+/* 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];
+  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,
+		      &gdb_notifier.ready_masks[0],
+		      &gdb_notifier.ready_masks[1],
+		      &gdb_notifier.ready_masks[2],
+		      NULL);
+
+  /* Clear the masks after an error from select.  */
+  if (num_found == -1)
+    {
+      FD_ZERO (&gdb_notifier.ready_masks[0]);
+      FD_ZERO (&gdb_notifier.ready_masks[1]);
+      FD_ZERO (&gdb_notifier.ready_masks[2]);
+#ifdef EINTR
+      /* Dont print anything if we got a signal, let gdb handle
+	 it.  */
+      if (errno != EINTR)
+	perror_with_name ("select");
+#endif
+    }
+
+  /* Enqueue all detected file events.  */
+
+  for (file_ptr = gdb_notifier.first_file_handler;
+       file_ptr != NULL && num_found > 0;
+       file_ptr = file_ptr->next_file)
+    {
+      int mask = 0;
+
+      if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[0]))
+	mask |= GDB_READABLE;
+      if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[1]))
+	mask |= GDB_WRITABLE;
+      if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[2]))
+	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);
+	}
+      file_ptr->ready_mask = mask;
+    }
+
+  return 0;
+}
+
+/* Start up the event loop.  This is the entry point to the event
+   loop.  */
+
+void
+start_event_loop (void)
+{
+  /* Loop until there is nothing to do.  This is the entry point to
+     the event loop engine.  If nothing is ready at this time, wait
+     for something to happen (via wait_for_event), then process it.
+     Return when there are no longer event sources to wait for.  */
+
+  while (1)
+    {
+      /* Any events already waiting in the queue?  */
+      if (process_event ())
+	continue;
+
+      /* Wait for a new event.  If 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 (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.  */
+}