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.

13 files changed, 2119 insertions, 667 deletions

diff --git a/gdb/gdbserver/ChangeLog b/gdb/gdbserver/ChangeLog
index 208cdf4..a9bbf3a 100644
--- a/gdb/gdbserver/ChangeLog
+++ b/gdb/gdbserver/ChangeLog
@@ -1,5 +1,128 @@
 2009-04-01  Pedro Alves  <pedro@codesourcery.com>
 
+	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.
+
+2009-04-01  Pedro Alves  <pedro@codesourcery.com>
+
 	Decouple target code from remote protocol.
 
 	* target.h (enum target_waitkind): New.
diff --git a/gdb/gdbserver/Makefile.in b/gdb/gdbserver/Makefile.in
index 0d5c66b..a62b25b 100644
--- a/gdb/gdbserver/Makefile.in
+++ b/gdb/gdbserver/Makefile.in
@@ -126,7 +126,7 @@ TAGFILES = $(SOURCES) ${HFILES} ${ALLPARAM} ${POSSLIBS}
 
 OBS = inferiors.o regcache.o remote-utils.o server.o signals.o target.o \
 	utils.o version.o \
-	mem-break.o hostio.o \
+	mem-break.o hostio.o event-loop.o \
 	$(XML_BUILTIN) \
 	$(DEPFILES) $(LIBOBJS)
 GDBREPLAY_OBS = gdbreplay.o version.o
@@ -267,6 +267,7 @@ server_h = $(srcdir)/server.h $(regcache_h) config.h $(srcdir)/target.h \
 
 linux_low_h = $(srcdir)/linux-low.h
 
+event-loop.o: event-loop.c $(server_h)
 hostio.o: hostio.c $(server_h)
 hostio-errno.o: hostio-errno.c $(server_h)
 inferiors.o: inferiors.c $(server_h)
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.  */
+}
diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
index c0b1e53..ba1d7b4 100644
--- a/gdb/gdbserver/linux-low.c
+++ b/gdb/gdbserver/linux-low.c
@@ -118,7 +118,7 @@ static void linux_resume_one_lwp (struct inferior_list_entry *entry,
 				  int step, int signal, siginfo_t *info);
 static void linux_resume (struct thread_resume *resume_info, size_t n);
 static void stop_all_lwps (void);
-static int linux_wait_for_event (struct thread_info *child);
+static int linux_wait_for_event (int pid, int *wstat, int options);
 static int check_removed_breakpoint (struct lwp_info *event_child);
 static void *add_lwp (unsigned long pid);
 static int my_waitpid (int pid, int *status, int flags);
@@ -139,10 +139,30 @@ static char *disabled_regsets;
 static int num_regsets;
 #endif
 
-#define pid_of(proc) ((proc)->head.id)
-
 /* FIXME: Delete eventually.  */
-#define inferior_pid (pid_of (get_thread_lwp (current_inferior)))
+#define inferior_pid (lwpid_of (get_thread_lwp (current_inferior)))
+
+/* The read/write ends of the pipe registered as waitable file in the
+   event loop.  */
+static int linux_event_pipe[2] = { -1, -1 };
+
+/* True if we're currently in async mode.  */
+#define target_is_async_p() (linux_event_pipe[0] != -1)
+
+static void send_sigstop (struct inferior_list_entry *entry);
+static void wait_for_sigstop (struct inferior_list_entry *entry);
+
+static void
+delete_lwp (struct lwp_info *lwp)
+{
+  remove_thread (get_lwp_thread (lwp));
+  remove_inferior (&all_lwps, &lwp->head);
+  free (lwp);
+}
+
+/* Handle a GNU/Linux extended wait response.  If we see a clone
+   event, we need to add the new LWP to our list (and not report the
+   trap to higher layers).  */
 
 static void
 handle_extended_wait (struct lwp_info *event_child, int wstat)
@@ -155,7 +175,7 @@ handle_extended_wait (struct lwp_info *event_child, int wstat)
       unsigned long new_pid;
       int ret, status = W_STOPCODE (SIGSTOP);
 
-      ptrace (PTRACE_GETEVENTMSG, inferior_pid, 0, &new_pid);
+      ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_child), 0, &new_pid);
 
       /* If we haven't already seen the new PID stop, wait for it now.  */
       if (! pull_pid_from_list (&stopped_pids, new_pid))
@@ -177,7 +197,7 @@ handle_extended_wait (struct lwp_info *event_child, int wstat)
 
       new_lwp = (struct lwp_info *) add_lwp (new_pid);
       add_thread (new_pid, new_lwp, new_pid);
-      new_thread_notify (thread_id_to_gdb_id (new_lwp->lwpid));
+      new_thread_notify (thread_id_to_gdb_id (lwpid_of (new_lwp)));
 
       /* Normally we will get the pending SIGSTOP.  But in some cases
 	 we might get another signal delivered to the group first.
@@ -254,7 +274,6 @@ add_lwp (unsigned long pid)
   memset (lwp, 0, sizeof (*lwp));
 
   lwp->head.id = pid;
-  lwp->lwpid = pid;
 
   add_inferior_to_list (&all_lwps, &lwp->head);
 
@@ -323,7 +342,7 @@ linux_attach_lwp (unsigned long pid)
 	}
       else
 	/* If we fail to attach to a process, report an error.  */
-	error ("Cannot attach to process %ld: %s (%d)\n", pid,
+	error ("Cannot attach to lwp %ld: %s (%d)\n", pid,
 	       strerror (errno), errno);
     }
 
@@ -333,7 +352,7 @@ linux_attach_lwp (unsigned long pid)
 
   new_lwp = (struct lwp_info *) add_lwp (pid);
   add_thread (pid, new_lwp, pid);
-  new_thread_notify (thread_id_to_gdb_id (new_lwp->lwpid));
+  new_thread_notify (thread_id_to_gdb_id (lwpid_of (new_lwp)));
 
   /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
      brings it to a halt.
@@ -377,10 +396,13 @@ linux_attach (unsigned long pid)
 
   linux_attach_lwp (pid);
 
-  /* Don't ignore the initial SIGSTOP if we just attached to this process.
-     It will be collected by wait shortly.  */
-  lwp = (struct lwp_info *) find_inferior_id (&all_lwps, pid);
-  lwp->stop_expected = 0;
+  if (!non_stop)
+    {
+      /* Don't ignore the initial SIGSTOP if we just attached to this
+	 process.  It will be collected by wait shortly.  */
+      lwp = (struct lwp_info *) find_inferior_id (&all_lwps, pid);
+      lwp->stop_expected = 0;
+    }
 
   new_inferior = 1;
 
@@ -394,6 +416,7 @@ linux_kill_one_lwp (struct inferior_list_entry *entry)
 {
   struct thread_info *thread = (struct thread_info *) entry;
   struct lwp_info *lwp = get_thread_lwp (thread);
+  int pid;
   int wstat;
 
   /* We avoid killing the first thread here, because of a Linux kernel (at
@@ -403,13 +426,18 @@ linux_kill_one_lwp (struct inferior_list_entry *entry)
   if (entry == all_threads.head)
     return;
 
+  /* If we're killing a running inferior, make sure it is stopped
+     first, as PTRACE_KILL will not work otherwise.  */
+  if (!lwp->stopped)
+    send_sigstop (&lwp->head);
+
   do
     {
-      ptrace (PTRACE_KILL, pid_of (lwp), 0, 0);
+      ptrace (PTRACE_KILL, lwpid_of (lwp), 0, 0);
 
       /* Make sure it died.  The loop is most likely unnecessary.  */
-      wstat = linux_wait_for_event (thread);
-    } while (WIFSTOPPED (wstat));
+      pid = linux_wait_for_event (lwpid_of (lwp), &wstat, __WALL);
+    } while (pid > 0 && WIFSTOPPED (wstat));
 }
 
 static void
@@ -418,6 +446,7 @@ linux_kill (void)
   struct thread_info *thread = (struct thread_info *) all_threads.head;
   struct lwp_info *lwp;
   int wstat;
+  int pid;
 
   if (thread == NULL)
     return;
@@ -427,17 +456,25 @@ linux_kill (void)
   /* See the comment in linux_kill_one_lwp.  We did not kill the first
      thread in the list, so do so now.  */
   lwp = get_thread_lwp (thread);
+
+  if (debug_threads)
+    fprintf (stderr, "lk_1: killing lwp %ld\n", lwpid_of (lwp));
+
+  /* If we're killing a running inferior, make sure it is stopped
+     first, as PTRACE_KILL will not work otherwise.  */
+  if (!lwp->stopped)
+    send_sigstop (&lwp->head);
+
   do
     {
-      ptrace (PTRACE_KILL, pid_of (lwp), 0, 0);
+      ptrace (PTRACE_KILL, lwpid_of (lwp), 0, 0);
 
       /* Make sure it died.  The loop is most likely unnecessary.  */
-      wstat = linux_wait_for_event (thread);
-    } while (WIFSTOPPED (wstat));
+      pid = linux_wait_for_event (lwpid_of (lwp), &wstat, __WALL);
+    } while (pid > 0 && WIFSTOPPED (wstat));
 
+  delete_lwp (lwp);
   clear_inferiors ();
-  free (all_lwps.head);
-  all_lwps.head = all_lwps.tail = NULL;
 }
 
 static void
@@ -446,6 +483,28 @@ linux_detach_one_lwp (struct inferior_list_entry *entry)
   struct thread_info *thread = (struct thread_info *) entry;
   struct lwp_info *lwp = get_thread_lwp (thread);
 
+  /* If we're detaching from a running inferior, make sure it is
+     stopped first, as PTRACE_DETACH will not work otherwise.  */
+  if (!lwp->stopped)
+    {
+      int pid = lwpid_of (lwp);
+
+      stopping_threads = 1;
+      send_sigstop (&lwp->head);
+
+      /* If this detects a new thread through a clone event, the new
+	 thread is appended to the end of the lwp list, so we'll
+	 eventually detach from it.  */
+      wait_for_sigstop (&lwp->head);
+      stopping_threads = 0;
+
+      /* If LWP exits while we're trying to stop it, there's nothing
+	 left to do.  */
+      lwp = (struct lwp_info *) find_inferior_id (&all_lwps, pid);
+      if (lwp == NULL)
+	return;
+    }
+
   /* Make sure the process isn't stopped at a breakpoint that's
      no longer there.  */
   check_removed_breakpoint (lwp);
@@ -455,11 +514,12 @@ linux_detach_one_lwp (struct inferior_list_entry *entry)
      to collect the SIGSTOP, but is fairly likely to.  */
   if (lwp->stop_expected)
     {
+      int wstat;
       /* Clear stop_expected, so that the SIGSTOP will be reported.  */
       lwp->stop_expected = 0;
       if (lwp->stopped)
 	linux_resume_one_lwp (&lwp->head, 0, 0, NULL);
-      linux_wait_for_event (thread);
+      linux_wait_for_event (lwpid_of (lwp), &wstat, __WALL);
     }
 
   /* Flush any pending changes to the process's registers.  */
@@ -467,7 +527,9 @@ linux_detach_one_lwp (struct inferior_list_entry *entry)
 			   get_lwp_thread (lwp));
 
   /* Finally, let it resume.  */
-  ptrace (PTRACE_DETACH, pid_of (lwp), 0, 0);
+  ptrace (PTRACE_DETACH, lwpid_of (lwp), 0, 0);
+
+  delete_lwp (lwp);
 }
 
 static int
@@ -476,19 +538,21 @@ linux_detach (void)
   delete_all_breakpoints ();
   for_each_inferior (&all_threads, linux_detach_one_lwp);
   clear_inferiors ();
-  free (all_lwps.head);
-  all_lwps.head = all_lwps.tail = NULL;
   return 0;
 }
 
 static void
 linux_join (void)
 {
-  extern unsigned long signal_pid;
   int status, ret;
+  struct thread_info *thread;
+  struct lwp_info *lwp;
+
+  thread = (struct thread_info *) all_threads.head;
+  lwp = get_thread_lwp (thread);
 
   do {
-    ret = waitpid (signal_pid, &status, 0);
+    ret = my_waitpid (lwpid_of (lwp), &status, 0);
     if (WIFEXITED (status) || WIFSIGNALED (status))
       break;
   } while (ret != -1 || errno != ECHILD);
@@ -518,7 +582,7 @@ check_removed_breakpoint (struct lwp_info *event_child)
 
   if (debug_threads)
     fprintf (stderr, "Checking for breakpoint in lwp %ld.\n",
-	     event_child->lwpid);
+	     lwpid_of (event_child));
 
   saved_inferior = current_inferior;
   current_inferior = get_lwp_thread (event_child);
@@ -573,7 +637,7 @@ status_pending_p (struct inferior_list_entry *entry, void *dummy)
 {
   struct lwp_info *lwp = (struct lwp_info *) entry;
 
-  if (lwp->status_pending_p)
+  if (lwp->status_pending_p && !lwp->suspended)
     if (check_removed_breakpoint (lwp))
       {
 	/* This thread was stopped at a breakpoint, and the breakpoint
@@ -586,43 +650,28 @@ status_pending_p (struct inferior_list_entry *entry, void *dummy)
 	return 0;
       }
 
-  return lwp->status_pending_p;
+  return (lwp->status_pending_p && !lwp->suspended);
 }
 
-static void
-linux_wait_for_lwp (struct lwp_info **childp, int *wstatp)
+static struct lwp_info *
+linux_wait_for_lwp (int pid, int *wstatp, int options)
 {
   int ret;
-  int to_wait_for = -1;
-
-  if (*childp != NULL)
-    to_wait_for = (*childp)->lwpid;
-
-retry:
-  while (1)
-    {
-      ret = waitpid (to_wait_for, wstatp, WNOHANG);
+  int to_wait_for = pid;
+  struct lwp_info *child = NULL;
 
-      if (ret == -1)
-	{
-	  if (errno != ECHILD)
-	    perror_with_name ("waitpid");
-	}
-      else if (ret > 0)
-	break;
+  if (debug_threads)
+    fprintf (stderr, "linux_wait_for_lwp: %d\n", pid);
 
-      ret = waitpid (to_wait_for, wstatp, WNOHANG | __WCLONE);
+  options |= __WALL;
 
-      if (ret == -1)
-	{
-	  if (errno != ECHILD)
-	    perror_with_name ("waitpid (WCLONE)");
-	}
-      else if (ret > 0)
-	break;
+retry:
 
-      usleep (1000);
-    }
+  ret = my_waitpid (to_wait_for, wstatp, options);
+  if (ret == 0 || (ret == -1 && errno == ECHILD && (options & WNOHANG)))
+    return NULL;
+  else if (ret == -1)
+    perror_with_name ("waitpid");
 
   if (debug_threads
       && (!WIFSTOPPED (*wstatp)
@@ -630,25 +679,24 @@ retry:
 	      && WSTOPSIG (*wstatp) != 33)))
     fprintf (stderr, "Got an event from %d (%x)\n", ret, *wstatp);
 
-  if (to_wait_for == -1)
-    *childp = (struct lwp_info *) find_inferior_id (&all_lwps, ret);
+  child = (struct lwp_info *) find_inferior_id (&all_lwps, ret);
 
   /* If we didn't find a process, one of two things presumably happened:
      - A process we started and then detached from has exited.  Ignore it.
      - A process we are controlling has forked and the new child's stop
      was reported to us by the kernel.  Save its PID.  */
-  if (*childp == NULL && WIFSTOPPED (*wstatp))
+  if (child == NULL && WIFSTOPPED (*wstatp))
     {
       add_pid_to_list (&stopped_pids, ret);
       goto retry;
     }
-  else if (*childp == NULL)
+  else if (child == NULL)
     goto retry;
 
-  (*childp)->stopped = 1;
-  (*childp)->pending_is_breakpoint = 0;
+  child->stopped = 1;
+  child->pending_is_breakpoint = 0;
 
-  (*childp)->last_status = *wstatp;
+  child->last_status = *wstatp;
 
   /* Architecture-specific setup after inferior is running.
      This needs to happen after we have attached to the inferior
@@ -668,54 +716,61 @@ retry:
     {
       struct thread_info *saved_inferior = current_inferior;
       current_inferior = (struct thread_info *)
-	find_inferior_id (&all_threads, (*childp)->lwpid);
+	find_inferior_id (&all_threads, lwpid_of (child));
       /* For testing only; i386_stop_pc prints out a diagnostic.  */
       if (the_low_target.get_pc != NULL)
 	get_stop_pc ();
       current_inferior = saved_inferior;
     }
+
+  return child;
 }
 
+/* Wait for an event from child PID.  If PID is -1, wait for any
+   child.  Store the stop status through the status pointer WSTAT.
+   OPTIONS is passed to the waitpid call.  Return 0 if no child stop
+   event was found and OPTIONS contains WNOHANG.  Return the PID of
+   the stopped child otherwise.  */
+
 static int
-linux_wait_for_event (struct thread_info *child)
+linux_wait_for_event (int pid, int *wstat, int options)
 {
   CORE_ADDR stop_pc;
-  struct lwp_info *event_child;
-  int wstat;
+  struct lwp_info *event_child = NULL;
   int bp_status;
+  struct lwp_info *requested_child = NULL;
 
   /* Check for a process with a pending status.  */
   /* It is possible that the user changed the pending task's registers since
      it stopped.  We correctly handle the change of PC if we hit a breakpoint
      (in check_removed_breakpoint); signals should be reported anyway.  */
-  if (child == NULL)
+
+  if (pid == -1)
     {
       event_child = (struct lwp_info *)
 	find_inferior (&all_lwps, status_pending_p, NULL);
       if (debug_threads && event_child)
-	fprintf (stderr, "Got a pending child %ld\n", event_child->lwpid);
+	fprintf (stderr, "Got a pending child %ld\n", lwpid_of (event_child));
     }
   else
     {
-      event_child = get_thread_lwp (child);
-      if (event_child->status_pending_p
-	  && check_removed_breakpoint (event_child))
-	event_child = NULL;
+      requested_child = (struct lwp_info *)
+	find_inferior_id (&all_lwps, pid);
+      if (requested_child->status_pending_p
+	  && !check_removed_breakpoint (requested_child))
+	event_child = requested_child;
     }
 
   if (event_child != NULL)
     {
-      if (event_child->status_pending_p)
-	{
-	  if (debug_threads)
-	    fprintf (stderr, "Got an event from pending child %ld (%04x)\n",
-		     event_child->lwpid, event_child->status_pending);
-	  wstat = event_child->status_pending;
-	  event_child->status_pending_p = 0;
-	  event_child->status_pending = 0;
-	  current_inferior = get_lwp_thread (event_child);
-	  return wstat;
-	}
+      if (debug_threads)
+	fprintf (stderr, "Got an event from pending child %ld (%04x)\n",
+		 lwpid_of (event_child), event_child->status_pending);
+      *wstat = event_child->status_pending;
+      event_child->status_pending_p = 0;
+      event_child->status_pending = 0;
+      current_inferior = get_lwp_thread (event_child);
+      return lwpid_of (event_child);
     }
 
   /* We only enter this loop if no process has a pending wait status.  Thus
@@ -724,47 +779,59 @@ linux_wait_for_event (struct thread_info *child)
      events.  */
   while (1)
     {
-      if (child == NULL)
-	event_child = NULL;
-      else
-	event_child = get_thread_lwp (child);
+      event_child = linux_wait_for_lwp (pid, wstat, options);
 
-      linux_wait_for_lwp (&event_child, &wstat);
+      if ((options & WNOHANG) && event_child == NULL)
+	return 0;
 
       if (event_child == NULL)
 	error ("event from unknown child");
 
-      current_inferior = (struct thread_info *)
-	find_inferior_id (&all_threads, event_child->lwpid);
+      current_inferior = get_lwp_thread (event_child);
 
       /* Check for thread exit.  */
-      if (! WIFSTOPPED (wstat))
+      if (! WIFSTOPPED (*wstat))
 	{
+	  int lwpid = lwpid_of (event_child);
 	  if (debug_threads)
-	    fprintf (stderr, "LWP %ld exiting\n", event_child->head.id);
+	    fprintf (stderr, "LWP %d exiting\n", lwpid);
 
 	  /* If the last thread is exiting, just return.  */
 	  if (all_threads.head == all_threads.tail)
-	    return wstat;
+	    {
+	      if (debug_threads)
+		fprintf (stderr, "LWP %d is last lwp of process\n", lwpid);
+	      return lwpid_of (event_child);
+	    }
 
-	  dead_thread_notify (thread_id_to_gdb_id (event_child->lwpid));
+	  dead_thread_notify (thread_id_to_gdb_id (lwpid_of (event_child)));
+	  delete_lwp (event_child);
 
-	  remove_inferior (&all_lwps, &event_child->head);
-	  free (event_child);
-	  remove_thread (current_inferior);
-	  current_inferior = (struct thread_info *) all_threads.head;
+	  if (!non_stop)
+	    {
+	      current_inferior = (struct thread_info *) all_threads.head;
+	      if (debug_threads)
+		fprintf (stderr, "Current inferior is now %ld\n",
+			 lwpid_of (get_thread_lwp (current_inferior)));
+	    }
+	  else
+	    {
+	      current_inferior = NULL;
+	      if (debug_threads)
+		fprintf (stderr, "Current inferior is now <NULL>\n");
+	    }
 
 	  /* If we were waiting for this particular child to do something...
 	     well, it did something.  */
-	  if (child != NULL)
-	    return wstat;
+	  if (requested_child != NULL)
+	    return lwpid;
 
 	  /* Wait for a more interesting event.  */
 	  continue;
 	}
 
-      if (WIFSTOPPED (wstat)
-	  && WSTOPSIG (wstat) == SIGSTOP
+      if (WIFSTOPPED (*wstat)
+	  && WSTOPSIG (*wstat) == SIGSTOP
 	  && event_child->stop_expected)
 	{
 	  if (debug_threads)
@@ -775,10 +842,10 @@ linux_wait_for_event (struct thread_info *child)
 	  continue;
 	}
 
-      if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGTRAP
-	  && wstat >> 16 != 0)
+      if (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) == SIGTRAP
+	  && *wstat >> 16 != 0)
 	{
-	  handle_extended_wait (event_child, wstat);
+	  handle_extended_wait (event_child, *wstat);
 	  continue;
 	}
 
@@ -791,42 +858,43 @@ linux_wait_for_event (struct thread_info *child)
 	 special handling to skip the signal handler.  */
       /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
 	 thread library?  */
-      if (WIFSTOPPED (wstat)
+      if (WIFSTOPPED (*wstat)
 	  && !event_child->stepping
 	  && (
 #ifdef USE_THREAD_DB
-	      (thread_db_active && (WSTOPSIG (wstat) == __SIGRTMIN
-				    || WSTOPSIG (wstat) == __SIGRTMIN + 1))
+	      (thread_db_active
+	       && (WSTOPSIG (*wstat) == __SIGRTMIN
+		   || WSTOPSIG (*wstat) == __SIGRTMIN + 1))
 	      ||
 #endif
-	      (pass_signals[target_signal_from_host (WSTOPSIG (wstat))]
-	       && (WSTOPSIG (wstat) != SIGSTOP || !stopping_threads))))
+	      (pass_signals[target_signal_from_host (WSTOPSIG (*wstat))]
+	       && (WSTOPSIG (*wstat) != SIGSTOP || !stopping_threads))))
 	{
 	  siginfo_t info, *info_p;
 
 	  if (debug_threads)
 	    fprintf (stderr, "Ignored signal %d for LWP %ld.\n",
-		     WSTOPSIG (wstat), event_child->head.id);
+		     WSTOPSIG (*wstat), lwpid_of (event_child));
 
-	  if (ptrace (PTRACE_GETSIGINFO, event_child->lwpid, 0, &info) == 0)
+	  if (ptrace (PTRACE_GETSIGINFO, lwpid_of (event_child), 0, &info) == 0)
 	    info_p = &info;
 	  else
 	    info_p = NULL;
 	  linux_resume_one_lwp (&event_child->head,
 				event_child->stepping,
-				WSTOPSIG (wstat), info_p);
+				WSTOPSIG (*wstat), info_p);
 	  continue;
 	}
 
       /* If this event was not handled above, and is not a SIGTRAP, report
 	 it.  */
-      if (!WIFSTOPPED (wstat) || WSTOPSIG (wstat) != SIGTRAP)
-	return wstat;
+      if (!WIFSTOPPED (*wstat) || WSTOPSIG (*wstat) != SIGTRAP)
+	return lwpid_of (event_child);
 
       /* If this target does not support breakpoints, we simply report the
 	 SIGTRAP; it's of no concern to us.  */
       if (the_low_target.get_pc == NULL)
-	return wstat;
+	return lwpid_of (event_child);
 
       stop_pc = get_stop_pc ();
 
@@ -877,6 +945,11 @@ linux_wait_for_event (struct thread_info *child)
 	     Otherwise, call the target function to figure out where we need
 	     our temporary breakpoint, create it, and continue executing this
 	     process.  */
+
+	  /* NOTE: we're lifting breakpoints in non-stop mode.  This
+	     is currently only used for thread event breakpoints, so
+	     it isn't that bad as long as we have PTRACE_EVENT_CLONE
+	     events.  */
 	  if (bp_status == 2)
 	    /* No need to reinsert.  */
 	    linux_resume_one_lwp (&event_child->head, 0, 0, NULL);
@@ -904,7 +977,7 @@ linux_wait_for_event (struct thread_info *child)
 	 do not clear clear the stepping flag yet; we need to check it
 	 in wait_for_sigstop.  */
       if (event_child->stepping)
-	return wstat;
+	return lwpid_of (event_child);
 
       /* A SIGTRAP that we can't explain.  It may have been a breakpoint.
 	 Check if it is a breakpoint, and if so mark the process information
@@ -920,7 +993,7 @@ linux_wait_for_event (struct thread_info *child)
 	  event_child->pending_stop_pc = stop_pc;
 	}
 
-      return wstat;
+      return lwpid_of (event_child);
     }
 
   /* NOTREACHED */
@@ -930,45 +1003,58 @@ linux_wait_for_event (struct thread_info *child)
 /* Wait for process, returns status.  */
 
 static unsigned long
-linux_wait (struct target_waitstatus *ourstatus)
+linux_wait_1 (struct target_waitstatus *ourstatus, int target_options)
 {
   int w;
-  struct thread_info *child = NULL;
-  struct lwp_info *lwp;
+  struct thread_info *thread = NULL;
+  struct lwp_info *lwp = NULL;
+  int options;
+  int wait_pid = -1;
+  int pid;
+
+  /* Translate generic target options into linux options.  */
+  options = __WALL;
+  if (target_options & TARGET_WNOHANG)
+    options |= WNOHANG;
 
 retry:
+  ourstatus->kind = TARGET_WAITKIND_IGNORE;
+
   /* If we were only supposed to resume one thread, only wait for
      that thread - if it's still alive.  If it died, however - which
      can happen if we're coming from the thread death case below -
      then we need to make sure we restart the other threads.  We could
      pick a thread at random or restart all; restarting all is less
      arbitrary.  */
-  if (cont_thread != 0 && cont_thread != -1)
+  if (!non_stop && cont_thread != 0 && cont_thread != -1)
     {
-      child = (struct thread_info *) find_inferior_id (&all_threads,
-						       cont_thread);
+      thread = (struct thread_info *) find_inferior_id (&all_threads,
+							cont_thread);
 
       /* No stepping, no signal - unless one is pending already, of course.  */
-      if (child == NULL)
+      if (thread == NULL)
 	{
 	  struct thread_resume resume_info;
 	  resume_info.thread = -1;
-	  resume_info.step = resume_info.sig = 0;
+	  resume_info.kind = resume_continue;
+	  resume_info.sig = 0;
 	  linux_resume (&resume_info, 1);
 	}
+      else
+	wait_pid = cont_thread;
     }
 
-  w = linux_wait_for_event (child);
-  stop_all_lwps ();
+  pid = linux_wait_for_event (wait_pid, &w, options);
+  if (pid == 0) /* only if TARGET_WNOHANG */
+    return pid;
+
+  lwp = get_thread_lwp (current_inferior);
 
   if (must_set_ptrace_flags)
     {
-      ptrace (PTRACE_SETOPTIONS, inferior_pid, 0, PTRACE_O_TRACECLONE);
+      ptrace (PTRACE_SETOPTIONS, lwpid_of (lwp), 0, PTRACE_O_TRACECLONE);
       must_set_ptrace_flags = 0;
     }
-
-  lwp = get_thread_lwp (current_inferior);
-
   /* If we are waiting for a particular child, and it exited,
      linux_wait_for_event will return its exit status.  Similarly if
      the last child exited.  If this is not the last child, however,
@@ -983,32 +1069,34 @@ retry:
 
   if (all_threads.head == all_threads.tail)
     {
-      int pid = pid_of (lwp);
-      if (WIFEXITED (w))
+      if (WIFEXITED (w) || WIFSIGNALED (w))
 	{
-	  if (debug_threads)
-	    fprintf (stderr, "\nChild exited with retcode = %x \n",
-		     WEXITSTATUS (w));
+	  int pid;
+
+	  pid = pid_of (lwp);
 
-	  ourstatus->kind = TARGET_WAITKIND_EXITED;
-	  ourstatus->value.integer = WEXITSTATUS (w);
+	  delete_lwp (lwp);
 	  clear_inferiors ();
-	  free (all_lwps.head);
-	  all_lwps.head = all_lwps.tail = NULL;
 
-	  return pid;
-	}
-      else if (!WIFSTOPPED (w))
-	{
-	  if (debug_threads)
-	    fprintf (stderr, "\nChild terminated with signal = %x \n",
-		     WTERMSIG (w));
+	  current_inferior = NULL;
 
-	  ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
-	  ourstatus->value.sig = target_signal_from_host (WTERMSIG (w));
-	  clear_inferiors ();
-	  free (all_lwps.head);
-	  all_lwps.head = all_lwps.tail = NULL;
+	  if (WIFEXITED (w))
+	    {
+	      ourstatus->kind = TARGET_WAITKIND_EXITED;
+	      ourstatus->value.integer = WEXITSTATUS (w);
+
+	      if (debug_threads)
+		fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
+	    }
+	  else
+	    {
+	      ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
+	      ourstatus->value.sig = target_signal_from_host (WTERMSIG (w));
+
+	      if (debug_threads)
+		fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
+
+	    }
 
 	  return pid;
 	}
@@ -1019,10 +1107,92 @@ retry:
 	goto retry;
     }
 
+  /* In all-stop, stop all threads.  Be careful to only do this if
+     we're about to report an event to GDB.  */
+  if (!non_stop)
+    stop_all_lwps ();
+
   ourstatus->kind = TARGET_WAITKIND_STOPPED;
-  ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
 
-  return lwp->lwpid;
+  if (lwp->suspended && WSTOPSIG (w) == SIGSTOP)
+    {
+      /* A thread that has been requested to stop by GDB with vCont;t,
+	 and it stopped cleanly, so report as SIG0.  The use of
+	 SIGSTOP is an implementation detail.  */
+      ourstatus->value.sig = TARGET_SIGNAL_0;
+    }
+  else if (lwp->suspended && WSTOPSIG (w) != SIGSTOP)
+    {
+      /* A thread that has been requested to stop by GDB with vCont;t,
+	 but, it stopped for other reasons.  Set stop_expected so the
+	 pending SIGSTOP is ignored and the LWP is resumed.  */
+      lwp->stop_expected = 1;
+      ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
+    }
+  else
+    {
+      ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
+    }
+
+  if (debug_threads)
+    fprintf (stderr, "linux_wait ret = %ld, %d, %d\n",
+	     lwpid_of (lwp),
+	     ourstatus->kind,
+	     ourstatus->value.sig);
+
+  return lwpid_of (lwp);
+}
+
+/* Get rid of any pending event in the pipe.  */
+static void
+async_file_flush (void)
+{
+  int ret;
+  char buf;
+
+  do
+    ret = read (linux_event_pipe[0], &buf, 1);
+  while (ret >= 0 || (ret == -1 && errno == EINTR));
+}
+
+/* Put something in the pipe, so the event loop wakes up.  */
+static void
+async_file_mark (void)
+{
+  int ret;
+
+  async_file_flush ();
+
+  do
+    ret = write (linux_event_pipe[1], "+", 1);
+  while (ret == 0 || (ret == -1 && errno == EINTR));
+
+  /* Ignore EAGAIN.  If the pipe is full, the event loop will already
+     be awakened anyway.  */
+}
+
+static unsigned long
+linux_wait (struct target_waitstatus *ourstatus, int target_options)
+{
+  unsigned long event_ptid;
+
+  if (debug_threads)
+    fprintf (stderr, "linux_wait\n");
+
+  /* Flush the async file first.  */
+  if (target_is_async_p ())
+    async_file_flush ();
+
+  event_ptid = linux_wait_1 (ourstatus, target_options);
+
+  /* If at least one stop was reported, there may be more.  A single
+     SIGCHLD can signal more than one child stop.  */
+  if (target_is_async_p ()
+      && (target_options & TARGET_WNOHANG) != 0
+      && event_ptid != 0)
+    async_file_mark ();
+
+  return event_ptid;
 }
 
 /* Send a signal to an LWP.  For LinuxThreads, kill is enough; however, if
@@ -1053,17 +1223,19 @@ static void
 send_sigstop (struct inferior_list_entry *entry)
 {
   struct lwp_info *lwp = (struct lwp_info *) entry;
+  int pid;
 
   if (lwp->stopped)
     return;
 
+  pid = lwpid_of (lwp);
+
   /* If we already have a pending stop signal for this process, don't
      send another.  */
   if (lwp->stop_expected)
     {
       if (debug_threads)
-	fprintf (stderr, "Have pending sigstop for lwp %ld\n",
-		 lwp->lwpid);
+	fprintf (stderr, "Have pending sigstop for lwp %d\n", pid);
 
       /* We clear the stop_expected flag so that wait_for_sigstop
 	 will receive the SIGSTOP event (instead of silently resuming and
@@ -1073,27 +1245,32 @@ send_sigstop (struct inferior_list_entry *entry)
     }
 
   if (debug_threads)
-    fprintf (stderr, "Sending sigstop to lwp %ld\n", lwp->head.id);
+    fprintf (stderr, "Sending sigstop to lwp %d\n", pid);
 
-  kill_lwp (lwp->head.id, SIGSTOP);
+  kill_lwp (pid, SIGSTOP);
 }
 
 static void
 wait_for_sigstop (struct inferior_list_entry *entry)
 {
   struct lwp_info *lwp = (struct lwp_info *) entry;
-  struct thread_info *saved_inferior, *thread;
+  struct thread_info *saved_inferior;
   int wstat;
   unsigned long saved_tid;
+  unsigned long ptid;
 
   if (lwp->stopped)
     return;
 
   saved_inferior = current_inferior;
-  saved_tid = ((struct inferior_list_entry *) saved_inferior)->id;
-  thread = (struct thread_info *) find_inferior_id (&all_threads,
-						    lwp->lwpid);
-  wstat = linux_wait_for_event (thread);
+  if (saved_inferior != NULL)
+    saved_tid = ((struct inferior_list_entry *) saved_inferior)->id;
+  else
+    saved_tid = 0; /* avoid bogus unused warning */
+
+  ptid = lwpid_of (lwp);
+
+  linux_wait_for_event (ptid, &wstat, __WALL);
 
   /* If we stopped with a non-SIGSTOP signal, save it for later
      and record the pending SIGSTOP.  If the process exited, just
@@ -1103,7 +1280,7 @@ wait_for_sigstop (struct inferior_list_entry *entry)
     {
       if (debug_threads)
 	fprintf (stderr, "LWP %ld stopped with non-sigstop status %06x\n",
-		 lwp->lwpid, wstat);
+		 lwpid_of (lwp), wstat);
 
       /* Do not leave a pending single-step finish to be reported to
 	 the client.  The client will give us a new action for this
@@ -1125,15 +1302,25 @@ wait_for_sigstop (struct inferior_list_entry *entry)
       lwp->stop_expected = 1;
     }
 
-  if (linux_thread_alive (saved_tid))
+  if (saved_inferior == NULL || linux_thread_alive (saved_tid))
     current_inferior = saved_inferior;
   else
     {
       if (debug_threads)
 	fprintf (stderr, "Previously current thread died.\n");
 
-      /* Set a valid thread as current.  */
-      set_desired_inferior (0);
+      if (non_stop)
+	{
+	  /* We can't change the current inferior behind GDB's back,
+	     otherwise, a subsequent command may apply to the wrong
+	     process.  */
+	  current_inferior = NULL;
+	}
+      else
+	{
+	  /* Set a valid thread as current.  */
+	  set_desired_inferior (0);
+	}
     }
 }
 
@@ -1186,7 +1373,7 @@ linux_resume_one_lwp (struct inferior_list_entry *entry,
 
   if (debug_threads)
     fprintf (stderr, "Resuming lwp %ld (%s, signal %d, stop %s)\n",
-	     inferior_pid, step ? "step" : "continue", signal,
+	     lwpid_of (lwp), step ? "step" : "continue", signal,
 	     lwp->stop_expected ? "expected" : "not expected");
 
   /* This bit needs some thinking about.  If we get a signal that
@@ -1231,7 +1418,7 @@ linux_resume_one_lwp (struct inferior_list_entry *entry,
 
       signal = (*p_sig)->signal;
       if ((*p_sig)->info.si_signo != 0)
-	ptrace (PTRACE_SETSIGINFO, lwp->lwpid, 0, &(*p_sig)->info);
+	ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), 0, &(*p_sig)->info);
 
       free (*p_sig);
       *p_sig = NULL;
@@ -1242,7 +1429,7 @@ linux_resume_one_lwp (struct inferior_list_entry *entry,
   errno = 0;
   lwp->stopped = 0;
   lwp->stepping = step;
-  ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwp->lwpid, 0, signal);
+  ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (lwp), 0, signal);
 
   current_inferior = saved_inferior;
   if (errno)
@@ -1299,104 +1486,152 @@ linux_set_resume_request (struct inferior_list_entry *entry, void *arg)
   return 0;
 }
 
-/* This function is called once per thread.  We check the thread's resume
-   request, which will tell us whether to resume, step, or leave the thread
-   stopped; and what signal, if any, it should be sent.  For threads which
-   we aren't explicitly told otherwise, we preserve the stepping flag; this
-   is used for stepping over gdbserver-placed breakpoints.  */
 
-static void
-linux_continue_one_thread (struct inferior_list_entry *entry)
+/* Set *FLAG_P if this lwp has an interesting status pending.  */
+static int
+resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
 {
-  struct lwp_info *lwp;
-  struct thread_info *thread;
-  int step;
-
-  thread = (struct thread_info *) entry;
-  lwp = get_thread_lwp (thread);
+  struct lwp_info *lwp = (struct lwp_info *) entry;
 
+  /* LWPs which will not be resumed are not interesting, because
+     we might not wait for them next time through linux_wait.  */
   if (lwp->resume == NULL)
-    return;
+    return 0;
 
-  if (lwp->resume->thread == -1
-      && lwp->stepping
-      && lwp->pending_is_breakpoint)
-    step = 1;
-  else
-    step = lwp->resume->step;
+  /* If this thread has a removed breakpoint, we won't have any
+     events to report later, so check now.  check_removed_breakpoint
+     may clear status_pending_p.  We avoid calling check_removed_breakpoint
+     for any thread that we are not otherwise going to resume - this
+     lets us preserve stopped status when two threads hit a breakpoint.
+     GDB removes the breakpoint to single-step a particular thread
+     past it, then re-inserts it and resumes all threads.  We want
+     to report the second thread without resuming it in the interim.  */
+  if (lwp->status_pending_p)
+    check_removed_breakpoint (lwp);
 
-  linux_resume_one_lwp (&lwp->head, step, lwp->resume->sig, NULL);
+  if (lwp->status_pending_p)
+    * (int *) flag_p = 1;
 
-  lwp->resume = NULL;
+  return 0;
 }
 
 /* This function is called once per thread.  We check the thread's resume
    request, which will tell us whether to resume, step, or leave the thread
-   stopped; and what signal, if any, it should be sent.  We queue any needed
-   signals, since we won't actually resume.  We already have a pending event
-   to report, so we don't need to preserve any step requests; they should
-   be re-issued if necessary.  */
+   stopped; and what signal, if any, it should be sent.
 
-static void
-linux_queue_one_thread (struct inferior_list_entry *entry)
+   For threads which we aren't explicitly told otherwise, we preserve
+   the stepping flag; this is used for stepping over gdbserver-placed
+   breakpoints.
+
+   If pending_flags was set in any thread, we queue any needed
+   signals, since we won't actually resume.  We already have a pending
+   event to report, so we don't need to preserve any step requests;
+   they should be re-issued if necessary.  */
+
+static int
+linux_resume_one_thread (struct inferior_list_entry *entry, void *arg)
 {
   struct lwp_info *lwp;
   struct thread_info *thread;
+  int step;
+  int pending_flag = * (int *) arg;
 
   thread = (struct thread_info *) entry;
   lwp = get_thread_lwp (thread);
 
   if (lwp->resume == NULL)
-    return;
+    return 0;
 
-  /* If we have a new signal, enqueue the signal.  */
-  if (lwp->resume->sig != 0)
+  if (lwp->resume->kind == resume_stop)
     {
-      struct pending_signals *p_sig;
-      p_sig = xmalloc (sizeof (*p_sig));
-      p_sig->prev = lwp->pending_signals;
-      p_sig->signal = lwp->resume->sig;
-      memset (&p_sig->info, 0, sizeof (siginfo_t));
+      if (debug_threads)
+	fprintf (stderr, "suspending LWP %ld\n", lwpid_of (lwp));
+
+      if (!lwp->stopped)
+	{
+	  if (debug_threads)
+	    fprintf (stderr, "running -> suspending %ld\n", lwpid_of (lwp));
+
+	  lwp->suspended = 1;
+	  send_sigstop (&lwp->head);
+	}
+      else
+	{
+	  if (debug_threads)
+	    {
+	      if (lwp->suspended)
+		fprintf (stderr, "already stopped/suspended LWP %ld\n",
+			 lwpid_of (lwp));
+	      else
+		fprintf (stderr, "already stopped/not suspended LWP %ld\n",
+			 lwpid_of (lwp));
+	    }
 
-      /* If this is the same signal we were previously stopped by,
-	 make sure to queue its siginfo.  We can ignore the return
-	 value of ptrace; if it fails, we'll skip
-	 PTRACE_SETSIGINFO.  */
-      if (WIFSTOPPED (lwp->last_status)
-	  && WSTOPSIG (lwp->last_status) == lwp->resume->sig)
-	ptrace (PTRACE_GETSIGINFO, lwp->lwpid, 0, &p_sig->info);
+	  /* Make sure we leave the LWP suspended, so we don't try to
+	     resume it without GDB telling us to.  FIXME: The LWP may
+	     have been stopped in an internal event that was not meant
+	     to be notified back to GDB (e.g., gdbserver breakpoint),
+	     so we should be reporting a stop event in that case
+	     too.  */
+	  lwp->suspended = 1;
+	}
 
-      lwp->pending_signals = p_sig;
+      /* For stop requests, we're done.  */
+      lwp->resume = NULL;
+      return 0;
     }
+  else
+    lwp->suspended = 0;
 
-  lwp->resume = NULL;
-}
+  /* If this thread which is about to be resumed has a pending status,
+     then don't resume any threads - we can just report the pending
+     status.  Make sure to queue any signals that would otherwise be
+     sent.  In all-stop mode, we do this decision based on if *any*
+     thread has a pending status.  */
+  if (non_stop)
+    resume_status_pending_p (&lwp->head, &pending_flag);
 
-/* Set DUMMY if this process has an interesting status pending.  */
-static int
-resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
-{
-  struct lwp_info *lwp = (struct lwp_info *) entry;
+  if (!pending_flag)
+    {
+      if (debug_threads)
+	fprintf (stderr, "resuming LWP %ld\n", lwpid_of (lwp));
 
-  /* Processes which will not be resumed are not interesting, because
-     we might not wait for them next time through linux_wait.  */
-  if (lwp->resume == NULL)
-    return 0;
+      if (lwp->resume->thread == -1
+	  && lwp->stepping
+	  && lwp->pending_is_breakpoint)
+	step = 1;
+      else
+	step = (lwp->resume->kind == resume_step);
 
-  /* If this thread has a removed breakpoint, we won't have any
-     events to report later, so check now.  check_removed_breakpoint
-     may clear status_pending_p.  We avoid calling check_removed_breakpoint
-     for any thread that we are not otherwise going to resume - this
-     lets us preserve stopped status when two threads hit a breakpoint.
-     GDB removes the breakpoint to single-step a particular thread
-     past it, then re-inserts it and resumes all threads.  We want
-     to report the second thread without resuming it in the interim.  */
-  if (lwp->status_pending_p)
-    check_removed_breakpoint (lwp);
+      linux_resume_one_lwp (&lwp->head, step, lwp->resume->sig, NULL);
+    }
+  else
+    {
+      if (debug_threads)
+	fprintf (stderr, "leaving LWP %ld stopped\n", lwpid_of (lwp));
 
-  if (lwp->status_pending_p)
-    * (int *) flag_p = 1;
+      /* If we have a new signal, enqueue the signal.  */
+      if (lwp->resume->sig != 0)
+	{
+	  struct pending_signals *p_sig;
+	  p_sig = xmalloc (sizeof (*p_sig));
+	  p_sig->prev = lwp->pending_signals;
+	  p_sig->signal = lwp->resume->sig;
+	  memset (&p_sig->info, 0, sizeof (siginfo_t));
+
+	  /* If this is the same signal we were previously stopped by,
+	     make sure to queue its siginfo.  We can ignore the return
+	     value of ptrace; if it fails, we'll skip
+	     PTRACE_SETSIGINFO.  */
+	  if (WIFSTOPPED (lwp->last_status)
+	      && WSTOPSIG (lwp->last_status) == lwp->resume->sig)
+	    ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &p_sig->info);
+
+	  lwp->pending_signals = p_sig;
+	}
+    }
 
+  lwp->resume = NULL;
   return 0;
 }
 
@@ -1411,9 +1646,11 @@ linux_resume (struct thread_resume *resume_info, size_t n)
   /* If there is a thread which would otherwise be resumed, which
      has a pending status, then don't resume any threads - we can just
      report the pending status.  Make sure to queue any signals
-     that would otherwise be sent.  */
+     that would otherwise be sent.  In non-stop mode, we'll apply this
+     logic to each thread individually.  */
   pending_flag = 0;
-  find_inferior (&all_lwps, resume_status_pending_p, &pending_flag);
+  if (!non_stop)
+    find_inferior (&all_lwps, resume_status_pending_p, &pending_flag);
 
   if (debug_threads)
     {
@@ -1423,10 +1660,7 @@ linux_resume (struct thread_resume *resume_info, size_t n)
 	fprintf (stderr, "Resuming, no pending status\n");
     }
 
-  if (pending_flag)
-    for_each_inferior (&all_threads, linux_queue_one_thread);
-  else
-    for_each_inferior (&all_threads, linux_continue_one_thread);
+  find_inferior (&all_threads, linux_resume_one_thread, &pending_flag);
 }
 
 #ifdef HAVE_LINUX_USRREGS
@@ -1873,18 +2107,78 @@ linux_tracefork_child (void *arg)
   _exit (0);
 }
 
-/* Wrapper function for waitpid which handles EINTR.  */
+/* Wrapper function for waitpid which handles EINTR, and emulates
+   __WALL for systems where that is not available.  */
 
 static int
 my_waitpid (int pid, int *status, int flags)
 {
-  int ret;
-  do
+  int ret, out_errno;
+
+  if (debug_threads)
+    fprintf (stderr, "my_waitpid (%d, 0x%x)\n", pid, flags);
+
+  if (flags & __WALL)
     {
-      ret = waitpid (pid, status, flags);
+      sigset_t block_mask, org_mask, wake_mask;
+      int wnohang;
+
+      wnohang = (flags & WNOHANG) != 0;
+      flags &= ~(__WALL | __WCLONE);
+      flags |= WNOHANG;
+
+      /* Block all signals while here.  This avoids knowing about
+	 LinuxThread's signals.  */
+      sigfillset (&block_mask);
+      sigprocmask (SIG_BLOCK, &block_mask, &org_mask);
+
+      /* ... except during the sigsuspend below.  */
+      sigemptyset (&wake_mask);
+
+      while (1)
+	{
+	  /* Since all signals are blocked, there's no need to check
+	     for EINTR here.  */
+	  ret = waitpid (pid, status, flags);
+	  out_errno = errno;
+
+	  if (ret == -1 && out_errno != ECHILD)
+	    break;
+	  else if (ret > 0)
+	    break;
+
+	  if (flags & __WCLONE)
+	    {
+	      /* We've tried both flavors now.  If WNOHANG is set,
+		 there's nothing else to do, just bail out.  */
+	      if (wnohang)
+		break;
+
+	      if (debug_threads)
+		fprintf (stderr, "blocking\n");
+
+	      /* Block waiting for signals.  */
+	      sigsuspend (&wake_mask);
+	    }
+
+	  flags ^= __WCLONE;
+	}
+
+      sigprocmask (SIG_SETMASK, &org_mask, NULL);
     }
-  while (ret == -1 && errno == EINTR);
+  else
+    {
+      do
+	ret = waitpid (pid, status, flags);
+      while (ret == -1 && errno == EINTR);
+      out_errno = errno;
+    }
+
+  if (debug_threads)
+    fprintf (stderr, "my_waitpid (%d, 0x%x): status(%x), %d\n",
+	     pid, flags, status ? *status : -1, ret);
 
+  errno = out_errno;
   return ret;
 }
 
@@ -1999,9 +2293,11 @@ linux_request_interrupt (void)
   if (cont_thread != 0 && cont_thread != -1)
     {
       struct lwp_info *lwp;
+      int lwpid;
 
       lwp = get_thread_lwp (current_inferior);
-      kill_lwp (lwp->lwpid, SIGINT);
+      lwpid = lwpid_of (lwp);
+      kill_lwp (lwpid, SIGINT);
     }
   else
     kill_lwp (signal_pid, SIGINT);
@@ -2090,7 +2386,7 @@ linux_read_offsets (CORE_ADDR *text_p, CORE_ADDR *data_p)
 {
 #if defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) && defined(PT_TEXT_END_ADDR)
   unsigned long text, text_end, data;
-  int pid = get_thread_lwp (current_inferior)->head.id;
+  int pid = lwpid_of (get_thread_lwp (current_inferior));
 
   errno = 0;
 
@@ -2232,7 +2528,7 @@ linux_xfer_siginfo (const char *annex, unsigned char *readbuf,
   if (current_inferior == NULL)
     return -1;
 
-  pid = pid_of (get_thread_lwp (current_inferior));
+  pid = lwpid_of (get_thread_lwp (current_inferior));
 
   if (debug_threads)
     fprintf (stderr, "%s siginfo for lwp %ld.\n",
@@ -2260,6 +2556,83 @@ linux_xfer_siginfo (const char *annex, unsigned char *readbuf,
   return len;
 }
 
+/* SIGCHLD handler that serves two purposes: In non-stop/async mode,
+   so we notice when children change state; as the handler for the
+   sigsuspend in my_waitpid.  */
+
+static void
+sigchld_handler (int signo)
+{
+  int old_errno = errno;
+
+  if (debug_threads)
+    /* fprintf is not async-signal-safe, so call write directly.  */
+    write (2, "sigchld_handler\n", sizeof ("sigchld_handler\n") - 1);
+
+  if (target_is_async_p ())
+    async_file_mark (); /* trigger a linux_wait */
+
+  errno = old_errno;
+}
+
+static int
+linux_supports_non_stop (void)
+{
+  return 1;
+}
+
+static int
+linux_async (int enable)
+{
+  int previous = (linux_event_pipe[0] != -1);
+
+  if (previous != enable)
+    {
+      sigset_t mask;
+      sigemptyset (&mask);
+      sigaddset (&mask, SIGCHLD);
+
+      sigprocmask (SIG_BLOCK, &mask, NULL);
+
+      if (enable)
+	{
+	  if (pipe (linux_event_pipe) == -1)
+	    fatal ("creating event pipe failed.");
+
+	  fcntl (linux_event_pipe[0], F_SETFL, O_NONBLOCK);
+	  fcntl (linux_event_pipe[1], F_SETFL, O_NONBLOCK);
+
+	  /* Register the event loop handler.  */
+	  add_file_handler (linux_event_pipe[0],
+			    handle_target_event, NULL);
+
+	  /* Always trigger a linux_wait.  */
+	  async_file_mark ();
+	}
+      else
+	{
+	  delete_file_handler (linux_event_pipe[0]);
+
+	  close (linux_event_pipe[0]);
+	  close (linux_event_pipe[1]);
+	  linux_event_pipe[0] = -1;
+	  linux_event_pipe[1] = -1;
+	}
+
+      sigprocmask (SIG_UNBLOCK, &mask, NULL);
+    }
+
+  return previous;
+}
+
+static int
+linux_start_non_stop (int nonstop)
+{
+  /* Register or unregister from event-loop accordingly.  */
+  linux_async (nonstop);
+  return 0;
+}
+
 static struct target_ops linux_target_ops = {
   linux_create_inferior,
   linux_attach,
@@ -2294,6 +2667,9 @@ static struct target_ops linux_target_ops = {
   hostio_last_error_from_errno,
   linux_qxfer_osdata,
   linux_xfer_siginfo,
+  linux_supports_non_stop,
+  linux_async,
+  linux_start_non_stop,
 };
 
 static void
@@ -2307,6 +2683,8 @@ linux_init_signals ()
 void
 initialize_low (void)
 {
+  struct sigaction sigchld_action;
+  memset (&sigchld_action, 0, sizeof (sigchld_action));
   thread_db_active = 0;
   set_target_ops (&linux_target_ops);
   set_breakpoint_data (the_low_target.breakpoint,
@@ -2318,4 +2696,9 @@ initialize_low (void)
     ;
   disabled_regsets = xmalloc (num_regsets);
 #endif
+
+  sigchld_action.sa_handler = sigchld_handler;
+  sigemptyset (&sigchld_action.sa_mask);
+  sigchld_action.sa_flags = SA_RESTART;
+  sigaction (SIGCHLD, &sigchld_action, NULL);
 }
diff --git a/gdb/gdbserver/linux-low.h b/gdb/gdbserver/linux-low.h
index 0847f6e..7818452 100644
--- a/gdb/gdbserver/linux-low.h
+++ b/gdb/gdbserver/linux-low.h
@@ -78,16 +78,18 @@ struct linux_target_ops
 
 extern struct linux_target_ops the_low_target;
 
+#define pid_of(proc) ((proc)->head.id)
+#define lwpid_of(proc) ((proc)->head.id)
+
 #define get_lwp(inf) ((struct lwp_info *)(inf))
 #define get_thread_lwp(thr) (get_lwp (inferior_target_data (thr)))
 #define get_lwp_thread(proc) ((struct thread_info *)			\
 			      find_inferior_id (&all_threads,		\
-						get_lwp (proc)->lwpid))
+						lwpid_of (get_lwp (proc))))
 
 struct lwp_info
 {
   struct inferior_list_entry head;
-  unsigned long lwpid;
 
   /* If this flag is set, the next SIGSTOP will be ignored (the
      process will be immediately resumed).  This means that either we
@@ -97,11 +99,14 @@ struct lwp_info
      yet.  */
   int stop_expected;
 
-  /* If this flag is set, the process is known to be stopped right now (stop
+  /* True if this thread was suspended (with vCont;t).  */
+  int suspended;
+
+  /* If this flag is set, the lwp is known to be stopped right now (stop
      event already received in a wait()).  */
   int stopped;
 
-  /* When stopped is set, the last wait status recorded for this process.  */
+  /* When stopped is set, the last wait status recorded for this lwp.  */
   int last_status;
 
   /* If this flag is set, STATUS_PENDING is a waitstatus that has not yet
diff --git a/gdb/gdbserver/remote-utils.c b/gdb/gdbserver/remote-utils.c
index d0967e3..c506bf5 100644
--- a/gdb/gdbserver/remote-utils.c
+++ b/gdb/gdbserver/remote-utils.c
@@ -286,11 +286,16 @@ remote_open (char *name)
   fcntl (remote_desc, F_SETOWN, getpid ());
 #endif
 #endif
+
+  /* Register the event loop handler.  */
+  add_file_handler (remote_desc, handle_serial_event, NULL);
 }
 
 void
 remote_close (void)
 {
+  delete_file_handler (remote_desc);
+
 #ifdef USE_WIN32API
   closesocket (remote_desc);
 #else
@@ -522,8 +527,8 @@ try_rle (char *buf, int remaining, unsigned char *csum, char **p)
    The data of the packet is in BUF, and the length of the
    packet is in CNT.  Returns >= 0 on success, -1 otherwise.  */
 
-int
-putpkt_binary (char *buf, int cnt)
+static int
+putpkt_binary_1 (char *buf, int cnt, int is_notif)
 {
   int i;
   unsigned char csum = 0;
@@ -537,7 +542,10 @@ putpkt_binary (char *buf, int cnt)
      and giving it a checksum.  */
 
   p = buf2;
-  *p++ = '$';
+  if (is_notif)
+    *p++ = '%';
+  else
+    *p++ = '$';
 
   for (i = 0; i < cnt;)
     i += try_rle (buf + i, cnt - i, &csum, &p);
@@ -561,12 +569,15 @@ putpkt_binary (char *buf, int cnt)
 	  return -1;
 	}
 
-      if (noack_mode)
+      if (noack_mode || is_notif)
 	{
 	  /* Don't expect an ack then.  */
 	  if (remote_debug)
 	    {
-	      fprintf (stderr, "putpkt (\"%s\"); [noack mode]\n", buf2);
+	      if (is_notif)
+		fprintf (stderr, "putpkt (\"%s\"); [notif]\n", buf2);
+	      else
+		fprintf (stderr, "putpkt (\"%s\"); [noack mode]\n", buf2);
 	      fflush (stderr);
 	    }
 	  break;
@@ -605,6 +616,12 @@ putpkt_binary (char *buf, int cnt)
   return 1;			/* Success! */
 }
 
+int
+putpkt_binary (char *buf, int cnt)
+{
+  return putpkt_binary_1 (buf, cnt, 0);
+}
+
 /* Send a packet to the remote machine, with error checking.  The data
    of the packet is in BUF, and the packet should be a NUL-terminated
    string.  Returns >= 0 on success, -1 otherwise.  */
@@ -615,6 +632,12 @@ putpkt (char *buf)
   return putpkt_binary (buf, strlen (buf));
 }
 
+int
+putpkt_notif (char *buf)
+{
+  return putpkt_binary_1 (buf, strlen (buf), 1);
+}
+
 /* Come here when we get an input interrupt from the remote side.  This
    interrupt should only be active while we are waiting for the child to do
    something.  About the only thing that should come through is a ^C, which
@@ -1000,7 +1023,10 @@ prepare_resume_reply (char *buf, unsigned long ptid,
 	       gdbserver to know what inferior_ptid is.  */
 	    if (1 || general_thread != ptid)
 	      {
-		general_thread = ptid;
+		/* In non-stop, don't change the general thread behind
+		   GDB's back.  */
+		if (!non_stop)
+		  general_thread = ptid;
 		sprintf (buf, "thread:%lx;", ptid);
 		buf += strlen (buf);
 	      }
diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c
index 1f61c0e..81efecc 100644
--- a/gdb/gdbserver/server.c
+++ b/gdb/gdbserver/server.c
@@ -43,6 +43,8 @@ static int attached;
 static int response_needed;
 static int exit_requested;
 
+int non_stop;
+
 static char **program_argv, **wrapper_argv;
 
 /* Enable miscellaneous debugging output.  The name is historical - it
@@ -90,6 +92,113 @@ int disable_packet_qfThreadInfo;
 static struct target_waitstatus last_status;
 static unsigned long last_ptid;
 
+static char *own_buf;
+static unsigned char *mem_buf;
+
+/* Structure holding information relative to a single stop reply.  We
+   keep a queue of these (really a singly-linked list) to push to GDB
+   in non-stop mode.  */
+struct vstop_notif
+{
+  /* Pointer to next in list.  */
+  struct vstop_notif *next;
+
+  /* Thread or process that got the event.  */
+  unsigned long ptid;
+
+  /* Event info.  */
+  struct target_waitstatus status;
+};
+
+/* The pending stop replies list head.  */
+static struct vstop_notif *notif_queue = NULL;
+
+/* Put a stop reply to the stop reply queue.  */
+
+static void
+queue_stop_reply (unsigned long ptid, struct target_waitstatus *status)
+{
+  struct vstop_notif *new_notif;
+
+  new_notif = malloc (sizeof (*new_notif));
+  new_notif->next = NULL;
+  new_notif->ptid = ptid;
+  new_notif->status = *status;
+
+  if (notif_queue)
+    {
+      struct vstop_notif *tail;
+      for (tail = notif_queue;
+	   tail && tail->next;
+	   tail = tail->next)
+	;
+      tail->next = new_notif;
+    }
+  else
+    notif_queue = new_notif;
+
+  if (remote_debug)
+    {
+      int i = 0;
+      struct vstop_notif *n;
+
+      for (n = notif_queue; n; n = n->next)
+	i++;
+
+      fprintf (stderr, "pending stop replies: %d\n", i);
+    }
+}
+
+/* Place an event in the stop reply queue, and push a notification if
+   we aren't sending one yet.  */
+
+void
+push_event (unsigned long ptid, struct target_waitstatus *status)
+{
+  queue_stop_reply (ptid, status);
+
+  /* If this is the first stop reply in the queue, then inform GDB
+     about it, by sending a Stop notification.  */
+  if (notif_queue->next == NULL)
+    {
+      char *p = own_buf;
+      strcpy (p, "Stop:");
+      p += strlen (p);
+      prepare_resume_reply (p,
+			    notif_queue->ptid, &notif_queue->status);
+      putpkt_notif (own_buf);
+    }
+}
+
+/* Get rid of the currently pending stop replies.  */
+
+static void
+discard_queued_stop_replies (void)
+{
+  struct vstop_notif *next;
+
+  while (notif_queue)
+    {
+      next = notif_queue->next;
+      notif_queue = next;
+
+      free (next);
+    }
+}
+
+/* If there are more stop replies to push, push one now.  */
+
+static void
+send_next_stop_reply (char *own_buf)
+{
+  if (notif_queue)
+    prepare_resume_reply (own_buf,
+			  notif_queue->ptid,
+			  &notif_queue->status);
+  else
+    write_ok (own_buf);
+}
+
 static int
 target_running (void)
 {
@@ -147,10 +256,11 @@ start_inferior (char **argv)
       unsigned long ptid;
 
       resume_info.thread = -1;
-      resume_info.step = 0;
+      resume_info.kind = resume_continue;
       resume_info.sig = 0;
 
-      ptid = mywait (&last_status, 0);
+      ptid = mywait (&last_status, 0, 0);
+
       if (last_status.kind != TARGET_WAITKIND_STOPPED)
 	return signal_pid;
 
@@ -158,7 +268,7 @@ start_inferior (char **argv)
 	{
 	  (*the_target->resume) (&resume_info, 1);
 
- 	  mywait (&last_status, 0);
+ 	  mywait (&last_status, 0, 0);
 	  if (last_status.kind != TARGET_WAITKIND_STOPPED)
 	    return signal_pid;
 	}
@@ -169,7 +279,7 @@ start_inferior (char **argv)
 
   /* Wait till we are at 1st instruction in program, return new pid
      (assuming success).  */
-  last_ptid = mywait (&last_status, 0);
+  last_ptid = mywait (&last_status, 0, 0);
 
   return signal_pid;
 }
@@ -193,14 +303,17 @@ attach_inferior (int pid)
      whichever we were told to attach to.  */
   signal_pid = pid;
 
-  last_ptid = mywait (&last_status, 0);
-
-  /* GDB knows to ignore the first SIGSTOP after attaching to a running
-     process using the "attach" command, but this is different; it's
-     just using "target remote".  Pretend it's just starting up.  */
-  if (last_status.kind == TARGET_WAITKIND_STOPPED
-      && last_status.value.sig == TARGET_SIGNAL_STOP)
-    last_status.value.sig = TARGET_SIGNAL_TRAP;
+  if (!non_stop)
+    {
+      last_ptid = mywait (&last_status, 0, 0);
+
+      /* GDB knows to ignore the first SIGSTOP after attaching to a running
+	 process using the "attach" command, but this is different; it's
+	 just using "target remote".  Pretend it's just starting up.  */
+      if (last_status.kind == TARGET_WAITKIND_STOPPED
+	  && last_status.value.sig == TARGET_SIGNAL_STOP)
+	last_status.value.sig = TARGET_SIGNAL_TRAP;
+    }
 
   return 0;
 }
@@ -288,6 +401,43 @@ handle_general_set (char *own_buf)
       return;
     }
 
+  if (strncmp (own_buf, "QNonStop:", 9) == 0)
+    {
+      char *mode = own_buf + 9;
+      int req = -1;
+      char *req_str;
+
+      if (strcmp (mode, "0") == 0)
+	req = 0;
+      else if (strcmp (mode, "1") == 0)
+	req = 1;
+      else
+	{
+	  /* We don't know what this mode is, so complain to
+	     GDB.  */
+	  fprintf (stderr, "Unknown non-stop mode requested: %s\n",
+		   own_buf);
+	  write_enn (own_buf);
+	  return;
+	}
+
+      req_str = req ? "non-stop" : "all-stop";
+      if (start_non_stop (req) != 0)
+	{
+	  fprintf (stderr, "Setting %s mode failed\n", req_str);
+	  write_enn (own_buf);
+	  return;
+	}
+
+      non_stop = req;
+
+      if (remote_debug)
+	fprintf (stderr, "[%s mode enabled]\n", req_str);
+
+      write_ok (own_buf);
+      return;
+    }
+
   /* Otherwise we didn't know what packet it was.  Say we didn't
      understand it.  */
   own_buf[0] = 0;
@@ -506,10 +656,18 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
   /* Reply the current thread id.  */
   if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC)
     {
+      unsigned long gdb_id;
       require_running (own_buf);
-      thread_ptr = all_threads.head;
-      sprintf (own_buf, "QC%x",
-	       thread_to_gdb_id ((struct thread_info *)thread_ptr));
+
+      if (general_thread != 0 && general_thread != -1)
+	gdb_id = general_thread;
+      else
+	{
+	  thread_ptr = all_threads.head;
+	  gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
+	}
+
+      sprintf (own_buf, "QC%lx", gdb_id);
       return;
     }
 
@@ -915,6 +1073,9 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
       if (the_target->qxfer_osdata != NULL)
 	strcat (own_buf, ";qXfer:osdata:read+");
 
+      if (target_supports_non_stop ())
+	strcat (own_buf, ";QNonStop+");
+
       return;
     }
 
@@ -925,7 +1086,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
       char *p = own_buf + 12;
       CORE_ADDR parts[2], address = 0;
       int i, err;
-      unsigned long ptid;
+      unsigned long ptid = 0;
 
       require_running (own_buf);
 
@@ -1088,9 +1249,11 @@ handle_v_cont (char *own_buf)
       p++;
 
       if (p[0] == 's' || p[0] == 'S')
-	resume_info[i].step = 1;
+	resume_info[i].kind = resume_step;
       else if (p[0] == 'c' || p[0] == 'C')
-	resume_info[i].step = 0;
+	resume_info[i].kind = resume_continue;
+      else if (p[0] == 't')
+	resume_info[i].kind = resume_stop;
       else
 	goto err;
 
@@ -1145,20 +1308,29 @@ handle_v_cont (char *own_buf)
     resume_info[i] = default_action;
 
   /* Still used in occasional places in the backend.  */
-  if (n == 1 && resume_info[0].thread != -1)
+  if (n == 1
+      && resume_info[0].thread != -1
+      && resume_info[0].kind != resume_stop)
     cont_thread = resume_info[0].thread;
   else
     cont_thread = -1;
   set_desired_inferior (0);
 
-  enable_async_io ();
+  if (!non_stop)
+    enable_async_io ();
+
   (*the_target->resume) (resume_info, n);
 
   free (resume_info);
 
-  last_ptid = mywait (&last_status, 1);
-  prepare_resume_reply (own_buf, last_ptid, &last_status);
-  disable_async_io ();
+  if (non_stop)
+    write_ok (own_buf);
+  else
+    {
+      last_ptid = mywait (&last_status, 0, 1);
+      prepare_resume_reply (own_buf, last_ptid, &last_status);
+      disable_async_io ();
+    }
   return;
 
 err:
@@ -1181,7 +1353,17 @@ handle_v_attach (char *own_buf)
 	 library list.  Avoids the "stopped by shared library event"
 	 notice on the GDB side.  */
       dlls_changed = 0;
-      prepare_resume_reply (own_buf, last_ptid, &last_status);
+
+      if (non_stop)
+	{
+	  /* In non-stop, we don't send a resume reply.  Stop events
+	     will follow up using the normal notification
+	     mechanism.  */
+	  write_ok (own_buf);
+	}
+      else
+	prepare_resume_reply (own_buf, last_ptid, &last_status);
+
       return 1;
     }
   else
@@ -1264,6 +1446,13 @@ handle_v_run (char *own_buf)
   if (last_status.kind == TARGET_WAITKIND_STOPPED)
     {
       prepare_resume_reply (own_buf, last_ptid, &last_status);
+
+      /* In non-stop, sending a resume reply doesn't set the general
+	 thread, but GDB assumes a vRun sets it (this is so GDB can
+	 query which is the main thread of the new inferior.  */
+      if (non_stop)
+	general_thread = last_ptid;
+
       return 1;
     }
   else
@@ -1273,6 +1462,28 @@ handle_v_run (char *own_buf)
     }
 }
 
+/* Handle a 'vStopped' packet.  */
+static void
+handle_v_stopped (char *own_buf)
+{
+  /* If we're waiting for GDB to acknowledge a pending stop reply,
+     consider that done.  */
+  if (notif_queue)
+    {
+      struct vstop_notif *head;
+
+      if (remote_debug)
+	fprintf (stderr, "vStopped: acking %ld\n", notif_queue->ptid);
+
+      head = notif_queue;
+      notif_queue = notif_queue->next;
+      free (head);
+    }
+
+  /* Push another stop reply, or if there are no more left, an OK.  */
+  send_next_stop_reply (own_buf);
+}
+
 /* Handle all of the extended 'v' packets.  */
 void
 handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
@@ -1288,7 +1499,7 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
 
       if (strncmp (own_buf, "vCont?", 6) == 0)
 	{
-	  strcpy (own_buf, "vCont;c;C;s;S");
+	  strcpy (own_buf, "vCont;c;C;s;S;t");
 	  return;
 	}
     }
@@ -1321,12 +1532,21 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
       return;
     }
 
+  if (strncmp (own_buf, "vStopped", 8) == 0)
+    {
+      handle_v_stopped (own_buf);
+      return;
+    }
+
   /* Otherwise we didn't know what packet it was.  Say we didn't
      understand it.  */
   own_buf[0] = 0;
   return;
 }
 
+/* Resume inferior and wait for another event.  In non-stop mode,
+   don't really wait here, but return immediatelly to the event
+   loop.  */
 void
 myresume (char *own_buf, int step, int sig)
 {
@@ -1342,7 +1562,10 @@ myresume (char *own_buf, int step, int sig)
     {
       resume_info[0].thread
 	= ((struct inferior_list_entry *) current_inferior)->id;
-      resume_info[0].step = step;
+      if (step)
+	resume_info[0].kind = resume_step;
+      else
+	resume_info[0].kind = resume_continue;
       resume_info[0].sig = sig;
       n++;
     }
@@ -1350,16 +1573,39 @@ myresume (char *own_buf, int step, int sig)
   if (!valid_cont_thread)
     {
       resume_info[n].thread = -1;
-      resume_info[n].step = 0;
+      resume_info[n].kind = resume_continue;
       resume_info[n].sig = 0;
       n++;
     }
 
-  enable_async_io ();
+  if (!non_stop)
+    enable_async_io ();
+
   (*the_target->resume) (resume_info, n);
-  last_ptid = mywait (&last_status, 1);
-  prepare_resume_reply (own_buf, last_ptid, &last_status);
-  disable_async_io ();
+
+  if (non_stop)
+    write_ok (own_buf);
+  else
+    {
+      last_ptid = mywait (&last_status, 0, 1);
+      prepare_resume_reply (own_buf, last_ptid, &last_status);
+      disable_async_io ();
+    }
+}
+
+/* Callback for for_each_inferior.  Make a new stop reply for each
+   stopped thread.  */
+
+static void
+queue_stop_reply_callback (struct inferior_list_entry *entry)
+{
+  struct target_waitstatus status;
+
+  status.kind = TARGET_WAITKIND_STOPPED;
+  status.value.sig = TARGET_SIGNAL_TRAP;
+
+  /* Pass the last stop reply back to GDB, but don't notify.  */
+  queue_stop_reply (entry->id, &status);
 }
 
 /* Status handler for the '?' packet.  */
@@ -1367,11 +1613,32 @@ myresume (char *own_buf, int step, int sig)
 static void
 handle_status (char *own_buf)
 {
-  if (all_threads.head)
-    prepare_resume_reply (own_buf,
-			  all_threads.head->id, &last_status);
+  struct target_waitstatus status;
+  status.kind = TARGET_WAITKIND_STOPPED;
+  status.value.sig = TARGET_SIGNAL_TRAP;
+
+  /* In non-stop mode, we must send a stop reply for each stopped
+     thread.  In all-stop mode, just send one for the first stopped
+     thread we find.  */
+
+  if (non_stop)
+    {
+      discard_queued_stop_replies ();
+      for_each_inferior (&all_threads, queue_stop_reply_callback);
+
+      /* The first is sent immediatly.  OK is sent if there is no
+	 stopped thread, which is the same handling of the vStopped
+	 packet (by design).  */
+      send_next_stop_reply (own_buf);
+    }
   else
-    strcpy (own_buf, "W00");
+    {
+      if (all_threads.head)
+	prepare_resume_reply (own_buf,
+			      all_threads.head->id, &status);
+      else
+	strcpy (own_buf, "W00");
+    }
 }
 
 static void
@@ -1426,12 +1693,6 @@ gdbserver_show_disableable (FILE *stream)
 int
 main (int argc, char *argv[])
 {
-  char ch, *own_buf;
-  unsigned char *mem_buf;
-  int i = 0;
-  int signal;
-  unsigned int len;
-  CORE_ADDR mem_addr;
   int bad_attach;
   int pid;
   char *arg_end, *port;
@@ -1630,9 +1891,10 @@ main (int argc, char *argv[])
   while (1)
     {
       noack_mode = 0;
+      non_stop = 0;
+
       remote_open (port);
 
-    restart:
       if (setjmp (toplevel) != 0)
 	{
 	  /* An error occurred.  */
@@ -1643,373 +1905,433 @@ main (int argc, char *argv[])
 	    }
 	}
 
-      disable_async_io ();
-      while (!exit_requested)
+      /* Wait for events.  This will return when all event sources are
+	 removed from the event loop. */
+      start_event_loop ();
+
+      /* If an exit was requested (using the "monitor exit" command),
+	 terminate now.  The only other way to get here is for
+	 getpkt to fail; close the connection and reopen it at the
+	 top of the loop.  */
+
+      if (exit_requested)
 	{
-	  unsigned char sig;
-	  int packet_len;
-	  int new_packet_len = -1;
+	  if (attached)
+	    detach_inferior ();
+	  else
+	    kill_inferior ();
+	  exit (0);
+	}
+      else
+	fprintf (stderr, "Remote side has terminated connection.  "
+		 "GDBserver will reopen the connection.\n");
+    }
+}
 
-	  response_needed = 0;
-	  packet_len = getpkt (own_buf);
-	  if (packet_len <= 0)
-	    break;
-	  response_needed = 1;
+/* Event loop callback that handles a serial event.  The first byte in
+   the serial buffer gets us here.  We expect characters to arrive at
+   a brisk pace, so we read the rest of the packet with a blocking
+   getpkt call.  */
 
-	  i = 0;
-	  ch = own_buf[i++];
-	  switch (ch)
+static void
+process_serial_event (void)
+{
+  char ch;
+  int i = 0;
+  int signal;
+  unsigned int len;
+  CORE_ADDR mem_addr;
+  unsigned char sig;
+  int packet_len;
+  int new_packet_len = -1;
+
+  /* Used to decide when gdbserver should exit in
+     multi-mode/remote.  */
+  static int have_ran = 0;
+
+  if (!have_ran)
+    have_ran = target_running ();
+
+  disable_async_io ();
+
+  response_needed = 0;
+  packet_len = getpkt (own_buf);
+  if (packet_len <= 0)
+    {
+      target_async (0);
+      remote_close ();
+      return;
+    }
+  response_needed = 1;
+
+  i = 0;
+  ch = own_buf[i++];
+  switch (ch)
+    {
+    case 'q':
+      handle_query (own_buf, packet_len, &new_packet_len);
+      break;
+    case 'Q':
+      handle_general_set (own_buf);
+      break;
+    case 'D':
+      require_running (own_buf);
+      fprintf (stderr, "Detaching from inferior\n");
+      if (detach_inferior () != 0)
+	write_enn (own_buf);
+      else
+	{
+	  discard_queued_stop_replies ();
+	  write_ok (own_buf);
+
+	  if (extended_protocol)
 	    {
-	    case 'q':
-	      handle_query (own_buf, packet_len, &new_packet_len);
-	      break;
-	    case 'Q':
-	      handle_general_set (own_buf);
-	      break;
-	    case 'D':
-	      require_running (own_buf);
-	      fprintf (stderr, "Detaching from inferior\n");
-	      if (detach_inferior () != 0)
-		write_enn (own_buf);
-	      else
-		{
-		  write_ok (own_buf);
-
-		  if (extended_protocol)
-		    {
-		      /* Treat this like a normal program exit.  */
-		      last_status.kind = TARGET_WAITKIND_EXITED;
-		      last_status.value.integer = 0;
-		      last_ptid = signal_pid;
-		    }
-		  else
-		    {
-		      putpkt (own_buf);
-		      remote_close ();
-
-		      /* If we are attached, then we can exit.  Otherwise, we
-			 need to hang around doing nothing, until the child
-			 is gone.  */
-		      if (!attached)
-			join_inferior ();
-
-		      exit (0);
-		    }
-		}
-	      break;
-	    case '!':
-	      extended_protocol = 1;
-	      write_ok (own_buf);
-	      break;
-	    case '?':
-	      handle_status (own_buf);
-	      break;
-	    case 'H':
-	      if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
-		{
-		  unsigned long gdb_id, thread_id;
-
-		  require_running (own_buf);
-		  gdb_id = strtoul (&own_buf[2], NULL, 16);
-		  if (gdb_id == 0 || gdb_id == -1)
-		    thread_id = gdb_id;
-		  else
-		    {
-		      thread_id = gdb_id_to_thread_id (gdb_id);
-		      if (thread_id == 0)
-			{
-			  write_enn (own_buf);
-			  break;
-			}
-		    }
-
-		  if (own_buf[1] == 'g')
-		    {
-		      general_thread = thread_id;
-		      set_desired_inferior (1);
-		    }
-		  else if (own_buf[1] == 'c')
-		    cont_thread = thread_id;
-		  else if (own_buf[1] == 's')
-		    step_thread = thread_id;
-
-		  write_ok (own_buf);
-		}
-	      else
-		{
-		  /* Silently ignore it so that gdb can extend the protocol
-		     without compatibility headaches.  */
-		  own_buf[0] = '\0';
-		}
-	      break;
-	    case 'g':
-	      require_running (own_buf);
-	      set_desired_inferior (1);
-	      registers_to_string (own_buf);
-	      break;
-	    case 'G':
-	      require_running (own_buf);
-	      set_desired_inferior (1);
-	      registers_from_string (&own_buf[1]);
-	      write_ok (own_buf);
-	      break;
-	    case 'm':
-	      require_running (own_buf);
-	      decode_m_packet (&own_buf[1], &mem_addr, &len);
-	      if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
-		convert_int_to_ascii (mem_buf, own_buf, len);
-	      else
-		write_enn (own_buf);
-	      break;
-	    case 'M':
-	      require_running (own_buf);
-	      decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
-	      if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
-		write_ok (own_buf);
-	      else
-		write_enn (own_buf);
-	      break;
-	    case 'X':
-	      require_running (own_buf);
-	      if (decode_X_packet (&own_buf[1], packet_len - 1,
-				   &mem_addr, &len, mem_buf) < 0
-		  || write_inferior_memory (mem_addr, mem_buf, len) != 0)
-		write_enn (own_buf);
-	      else
-		write_ok (own_buf);
-	      break;
-	    case 'C':
-	      require_running (own_buf);
-	      convert_ascii_to_int (own_buf + 1, &sig, 1);
-	      if (target_signal_to_host_p (sig))
-		signal = target_signal_to_host (sig);
-	      else
-		signal = 0;
-	      myresume (own_buf, 0, signal);
-	      break;
-	    case 'S':
-	      require_running (own_buf);
-	      convert_ascii_to_int (own_buf + 1, &sig, 1);
-	      if (target_signal_to_host_p (sig))
-		signal = target_signal_to_host (sig);
-	      else
-		signal = 0;
-	      myresume (own_buf, 1, signal);
-	      break;
-	    case 'c':
-	      require_running (own_buf);
-	      signal = 0;
-	      myresume (own_buf, 0, signal);
-	      break;
-	    case 's':
-	      require_running (own_buf);
-	      signal = 0;
-	      myresume (own_buf, 1, signal);
-	      break;
-	    case 'Z':
-	      {
-		char *lenptr;
-		char *dataptr;
-		CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
-		int len = strtol (lenptr + 1, &dataptr, 16);
-		char type = own_buf[1];
-
-		if (the_target->insert_watchpoint == NULL
-		    || (type < '2' || type > '4'))
-		  {
-		    /* No watchpoint support or not a watchpoint command;
-		       unrecognized either way.  */
-		    own_buf[0] = '\0';
-		  }
-		else
-		  {
-		    int res;
-
-		    require_running (own_buf);
-		    res = (*the_target->insert_watchpoint) (type, addr, len);
-		    if (res == 0)
-		      write_ok (own_buf);
-		    else if (res == 1)
-		      /* Unsupported.  */
-		      own_buf[0] = '\0';
-		    else
-		      write_enn (own_buf);
-		  }
-		break;
-	      }
-	    case 'z':
-	      {
-		char *lenptr;
-		char *dataptr;
-		CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
-		int len = strtol (lenptr + 1, &dataptr, 16);
-		char type = own_buf[1];
-
-		if (the_target->remove_watchpoint == NULL
-		    || (type < '2' || type > '4'))
-		  {
-		    /* No watchpoint support or not a watchpoint command;
-		       unrecognized either way.  */
-		    own_buf[0] = '\0';
-		  }
-		else
-		  {
-		    int res;
-
-		    require_running (own_buf);
-		    res = (*the_target->remove_watchpoint) (type, addr, len);
-		    if (res == 0)
-		      write_ok (own_buf);
-		    else if (res == 1)
-		      /* Unsupported.  */
-		      own_buf[0] = '\0';
-		    else
-		      write_enn (own_buf);
-		  }
-		break;
-	      }
-	    case 'k':
-	      response_needed = 0;
-	      if (!target_running ())
-		/* The packet we received doesn't make sense - but we
-		   can't reply to it, either.  */
-		goto restart;
-
-	      fprintf (stderr, "Killing inferior\n");
-	      kill_inferior ();
+	      /* Treat this like a normal program exit.  */
+	      last_status.kind = TARGET_WAITKIND_EXITED;
+	      last_status.value.integer = 0;
+	      last_ptid = signal_pid;
 
-	      /* When using the extended protocol, we wait with no
-		 program running.  The traditional protocol will exit
-		 instead.  */
-	      if (extended_protocol)
-		{
-		  last_status.kind = TARGET_WAITKIND_EXITED;
-		  last_status.value.sig = TARGET_SIGNAL_KILL;
-		  was_running = 0;
-		  goto restart;
-		}
-	      else
+	      current_inferior = NULL;
+	    }
+	  else
+	    {
+	      putpkt (own_buf);
+	      remote_close ();
+
+	      /* If we are attached, then we can exit.  Otherwise, we
+		 need to hang around doing nothing, until the child is
+		 gone.  */
+	      if (!attached)
+		join_inferior ();
+
+	      exit (0);
+	    }
+	}
+      break;
+    case '!':
+      extended_protocol = 1;
+      write_ok (own_buf);
+      break;
+    case '?':
+      handle_status (own_buf);
+      break;
+    case 'H':
+      if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
+	{
+	  unsigned long gdb_id, thread_id;
+
+	  require_running (own_buf);
+	  gdb_id = strtoul (&own_buf[2], NULL, 16);
+	  if (gdb_id == 0 || gdb_id == -1)
+	    thread_id = gdb_id;
+	  else
+	    {
+	      thread_id = gdb_id_to_thread_id (gdb_id);
+	      if (thread_id == 0)
 		{
-		  exit (0);
-		  break;
-		}
-	    case 'T':
-	      {
-		unsigned long gdb_id, thread_id;
-
-		require_running (own_buf);
-		gdb_id = strtoul (&own_buf[1], NULL, 16);
-		thread_id = gdb_id_to_thread_id (gdb_id);
-		if (thread_id == 0)
-		  {
-		    write_enn (own_buf);
-		    break;
-		  }
-
-		if (mythread_alive (thread_id))
-		  write_ok (own_buf);
-		else
 		  write_enn (own_buf);
-	      }
-	      break;
-	    case 'R':
-	      response_needed = 0;
-
-	      /* Restarting the inferior is only supported in the
-		 extended protocol.  */
-	      if (extended_protocol)
-		{
-		  if (target_running ())
-		    kill_inferior ();
-		  fprintf (stderr, "GDBserver restarting\n");
-
-		  /* Wait till we are at 1st instruction in prog.  */
-		  if (program_argv != NULL)
-		    start_inferior (program_argv);
-		  else
-		    {
-		      last_status.kind = TARGET_WAITKIND_EXITED;
-		      last_status.value.sig = TARGET_SIGNAL_KILL;
-		    }
-		  goto restart;
-		}
-	      else
-		{
-		  /* It is a request we don't understand.  Respond with an
-		     empty packet so that gdb knows that we don't support this
-		     request.  */
-		  own_buf[0] = '\0';
 		  break;
 		}
-	    case 'v':
-	      /* Extended (long) request.  */
-	      handle_v_requests (own_buf, packet_len, &new_packet_len);
-	      break;
-
-	    default:
-	      /* It is a request we don't understand.  Respond with an
-		 empty packet so that gdb knows that we don't support this
-		 request.  */
-	      own_buf[0] = '\0';
-	      break;
 	    }
 
-	  if (new_packet_len != -1)
-	    putpkt_binary (own_buf, new_packet_len);
-	  else
-	    putpkt (own_buf);
-
-	  response_needed = 0;
-
-	  if (was_running
-	      && (last_status.kind == TARGET_WAITKIND_EXITED
-		  || last_status.kind == TARGET_WAITKIND_SIGNALLED))
+	  if (own_buf[1] == 'g')
 	    {
-	      was_running = 0;
-
-	      if (last_status.kind == TARGET_WAITKIND_EXITED)
-		fprintf (stderr,
-			 "\nChild exited with status %d\n",
-			 last_status.value.integer);
-	      else if (last_status.kind == TARGET_WAITKIND_SIGNALLED)
-		fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
-			 target_signal_to_host (last_status.value.sig),
-			 target_signal_to_name (last_status.value.sig));
-
-	      if (extended_protocol)
-		goto restart;
-	      else
+	      if (thread_id == 0)
 		{
-		  fprintf (stderr, "GDBserver exiting\n");
-		  remote_close ();
-		  exit (0);
+		  /* GDB is telling us to choose any thread.  Check if
+		     the currently selected thread is still valid. If
+		     it is not, select the first available.  */
+		  struct thread_info *thread =
+		    (struct thread_info *) find_inferior_id (&all_threads,
+							     general_thread);
+		  if (thread == NULL)
+		    thread_id = all_threads.head->id;
 		}
+
+	      general_thread = thread_id;
+	      set_desired_inferior (1);
 	    }
+	  else if (own_buf[1] == 'c')
+	    cont_thread = thread_id;
+	  else if (own_buf[1] == 's')
+	    step_thread = thread_id;
 
-	  if (last_status.kind != TARGET_WAITKIND_EXITED
-	      && last_status.kind != TARGET_WAITKIND_SIGNALLED)
-	    was_running = 1;
+	  write_ok (own_buf);
+	}
+      else
+	{
+	  /* Silently ignore it so that gdb can extend the protocol
+	     without compatibility headaches.  */
+	  own_buf[0] = '\0';
 	}
+      break;
+    case 'g':
+      require_running (own_buf);
+      set_desired_inferior (1);
+      registers_to_string (own_buf);
+      break;
+    case 'G':
+      require_running (own_buf);
+      set_desired_inferior (1);
+      registers_from_string (&own_buf[1]);
+      write_ok (own_buf);
+      break;
+    case 'm':
+      require_running (own_buf);
+      decode_m_packet (&own_buf[1], &mem_addr, &len);
+      if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
+	convert_int_to_ascii (mem_buf, own_buf, len);
+      else
+	write_enn (own_buf);
+      break;
+    case 'M':
+      require_running (own_buf);
+      decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
+      if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
+	write_ok (own_buf);
+      else
+	write_enn (own_buf);
+      break;
+    case 'X':
+      require_running (own_buf);
+      if (decode_X_packet (&own_buf[1], packet_len - 1,
+			   &mem_addr, &len, mem_buf) < 0
+	  || write_inferior_memory (mem_addr, mem_buf, len) != 0)
+	write_enn (own_buf);
+      else
+	write_ok (own_buf);
+      break;
+    case 'C':
+      require_running (own_buf);
+      convert_ascii_to_int (own_buf + 1, &sig, 1);
+      if (target_signal_to_host_p (sig))
+	signal = target_signal_to_host (sig);
+      else
+	signal = 0;
+      myresume (own_buf, 0, signal);
+      break;
+    case 'S':
+      require_running (own_buf);
+      convert_ascii_to_int (own_buf + 1, &sig, 1);
+      if (target_signal_to_host_p (sig))
+	signal = target_signal_to_host (sig);
+      else
+	signal = 0;
+      myresume (own_buf, 1, signal);
+      break;
+    case 'c':
+      require_running (own_buf);
+      signal = 0;
+      myresume (own_buf, 0, signal);
+      break;
+    case 's':
+      require_running (own_buf);
+      signal = 0;
+      myresume (own_buf, 1, signal);
+      break;
+    case 'Z':
+      {
+	char *lenptr;
+	char *dataptr;
+	CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
+	int len = strtol (lenptr + 1, &dataptr, 16);
+	char type = own_buf[1];
+
+	if (the_target->insert_watchpoint == NULL
+	    || (type < '2' || type > '4'))
+	  {
+	    /* No watchpoint support or not a watchpoint command;
+	       unrecognized either way.  */
+	    own_buf[0] = '\0';
+	  }
+	else
+	  {
+	    int res;
+
+	    require_running (own_buf);
+	    res = (*the_target->insert_watchpoint) (type, addr, len);
+	    if (res == 0)
+	      write_ok (own_buf);
+	    else if (res == 1)
+	      /* Unsupported.  */
+	      own_buf[0] = '\0';
+	    else
+	      write_enn (own_buf);
+	  }
+	break;
+      }
+    case 'z':
+      {
+	char *lenptr;
+	char *dataptr;
+	CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
+	int len = strtol (lenptr + 1, &dataptr, 16);
+	char type = own_buf[1];
+
+	if (the_target->remove_watchpoint == NULL
+	    || (type < '2' || type > '4'))
+	  {
+	    /* No watchpoint support or not a watchpoint command;
+	       unrecognized either way.  */
+	    own_buf[0] = '\0';
+	  }
+	else
+	  {
+	    int res;
+
+	    require_running (own_buf);
+	    res = (*the_target->remove_watchpoint) (type, addr, len);
+	    if (res == 0)
+	      write_ok (own_buf);
+	    else if (res == 1)
+	      /* Unsupported.  */
+	      own_buf[0] = '\0';
+	    else
+	      write_enn (own_buf);
+	  }
+	break;
+      }
+    case 'k':
+      response_needed = 0;
+      if (!target_running ())
+	/* The packet we received doesn't make sense - but we
+	   can't reply to it, either.  */
+	return;
 
-      /* If an exit was requested (using the "monitor exit" command),
-	 terminate now.  The only other way to get here is for
-	 getpkt to fail; close the connection and reopen it at the
-	 top of the loop.  */
+      fprintf (stderr, "Killing inferior\n");
+      kill_inferior ();
+      discard_queued_stop_replies ();
 
-      if (exit_requested)
+      /* When using the extended protocol, we wait with no program
+	 running.  The traditional protocol will exit instead.  */
+      if (extended_protocol)
+	{
+	  last_status.kind = TARGET_WAITKIND_EXITED;
+	  last_status.value.sig = TARGET_SIGNAL_KILL;
+	  return;
+	}
+      else
 	{
-	  remote_close ();
-	  if (attached && target_running ())
-	    detach_inferior ();
-	  else if (target_running ())
-	    kill_inferior ();
 	  exit (0);
+	  break;
+	}
+    case 'T':
+      {
+	unsigned long gdb_id, thread_id;
+
+	require_running (own_buf);
+	gdb_id = strtoul (&own_buf[1], NULL, 16);
+	thread_id = gdb_id_to_thread_id (gdb_id);
+	if (thread_id == 0)
+	  {
+	    write_enn (own_buf);
+	    break;
+	  }
+
+	if (mythread_alive (thread_id))
+	  write_ok (own_buf);
+	else
+	  write_enn (own_buf);
+      }
+      break;
+    case 'R':
+      response_needed = 0;
+
+      /* Restarting the inferior is only supported in the extended
+	 protocol.  */
+      if (extended_protocol)
+	{
+	  if (target_running ())
+	    {
+	      kill_inferior ();
+	      discard_queued_stop_replies ();
+	    }
+	  fprintf (stderr, "GDBserver restarting\n");
+
+	  /* Wait till we are at 1st instruction in prog.  */
+	  if (program_argv != NULL)
+	    start_inferior (program_argv);
+	  else
+	    {
+	      last_status.kind = TARGET_WAITKIND_EXITED;
+	      last_status.value.sig = TARGET_SIGNAL_KILL;
+	    }
+	  return;
 	}
       else
 	{
-	  fprintf (stderr, "Remote side has terminated connection.  "
-			   "GDBserver will reopen the connection.\n");
+	  /* It is a request we don't understand.  Respond with an
+	     empty packet so that gdb knows that we don't support this
+	     request.  */
+	  own_buf[0] = '\0';
+	  break;
+	}
+    case 'v':
+      /* Extended (long) request.  */
+      handle_v_requests (own_buf, packet_len, &new_packet_len);
+      break;
+
+    default:
+      /* It is a request we don't understand.  Respond with an empty
+	 packet so that gdb knows that we don't support this
+	 request.  */
+      own_buf[0] = '\0';
+      break;
+    }
+
+  if (new_packet_len != -1)
+    putpkt_binary (own_buf, new_packet_len);
+  else
+    putpkt (own_buf);
+
+  response_needed = 0;
+
+  if (!extended_protocol && have_ran && !target_running ())
+    {
+      /* In non-stop, defer exiting until GDB had a chance to query
+	 the whole vStopped list (until it gets an OK).  */
+      if (!notif_queue)
+	{
+	  fprintf (stderr, "GDBserver exiting\n");
 	  remote_close ();
+	  exit (0);
 	}
     }
 }
+
+/* Event-loop callback for serial events.  */
+
+void
+handle_serial_event (int err, gdb_client_data client_data)
+{
+  if (debug_threads)
+    fprintf (stderr, "handling possible serial event\n");
+
+  /* Really handle it.  */
+  process_serial_event ();
+
+  /* Be sure to not change the selected inferior behind GDB's back.
+     Important in the non-stop mode asynchronous protocol.  */
+  set_desired_inferior (1);
+}
+
+/* Event-loop callback for target events.  */
+
+void
+handle_target_event (int err, gdb_client_data client_data)
+{
+  if (debug_threads)
+    fprintf (stderr, "handling possible target event\n");
+
+  last_ptid = mywait (&last_status, TARGET_WNOHANG, 1);
+
+  if (last_status.kind != TARGET_WAITKIND_IGNORE)
+    {
+      /* Something interesting.  Tell GDB about it.  */
+      push_event (last_ptid, &last_status);
+    }
+
+  /* Be sure to not change the selected inferior behind GDB's back.
+     Important in the non-stop mode asynchronous protocol.  */
+  set_desired_inferior (1);
+}
diff --git a/gdb/gdbserver/server.h b/gdb/gdbserver/server.h
index 7727e55..12fef0f 100644
--- a/gdb/gdbserver/server.h
+++ b/gdb/gdbserver/server.h
@@ -172,6 +172,24 @@ extern int disable_packet_Tthread;
 extern int disable_packet_qC;
 extern int disable_packet_qfThreadInfo;
 
+extern int non_stop;
+
+/* Functions from event-loop.c.  */
+typedef void *gdb_client_data;
+typedef void (handler_func) (int, gdb_client_data);
+
+extern void delete_file_handler (int fd);
+extern void add_file_handler (int fd, handler_func *proc,
+			      gdb_client_data client_data);
+
+extern void start_event_loop (void);
+
+/* Functions from server.c.  */
+extern void handle_serial_event (int err, gdb_client_data client_data);
+extern void handle_target_event (int err, gdb_client_data client_data);
+
+extern void push_event (unsigned long ptid, struct target_waitstatus *status);
+
 /* Functions from hostio.c.  */
 extern int handle_vFile (char *, int, int *);
 
@@ -187,6 +205,7 @@ extern int transport_is_reliable;
 
 int putpkt (char *buf);
 int putpkt_binary (char *buf, int len);
+int putpkt_notif (char *buf);
 int getpkt (char *buf);
 void remote_open (char *name);
 void remote_close (void);
diff --git a/gdb/gdbserver/spu-low.c b/gdb/gdbserver/spu-low.c
index d0ff22c..ba27beb 100644
--- a/gdb/gdbserver/spu-low.c
+++ b/gdb/gdbserver/spu-low.c
@@ -359,7 +359,7 @@ spu_resume (struct thread_resume *resume_info, size_t n)
 
   /* We don't support hardware single-stepping right now, assume
      GDB knows to use software single-stepping.  */
-  if (resume_info[i].step)
+  if (resume_info[i].kind == resume_step)
     fprintf (stderr, "Hardware single-step not supported.\n");
 
   regcache_invalidate ();
@@ -372,7 +372,7 @@ spu_resume (struct thread_resume *resume_info, size_t n)
 
 /* Wait for process, returns status.  */
 static unsigned long
-spu_wait (struct target_waitstatus *ourstatus)
+spu_wait (struct target_waitstatus *ourstatus, int options)
 {
   int tid = current_tid;
   int w;
diff --git a/gdb/gdbserver/target.c b/gdb/gdbserver/target.c
index 3bdc469..b570b6c 100644
--- a/gdb/gdbserver/target.c
+++ b/gdb/gdbserver/target.c
@@ -89,14 +89,27 @@ write_inferior_memory (CORE_ADDR memaddr, const unsigned char *myaddr,
 }
 
 unsigned long
-mywait (struct target_waitstatus *ourstatus, int connected_wait)
+mywait (struct target_waitstatus *ourstatus, int options,
+	int connected_wait)
 {
   unsigned long ret;
 
   if (connected_wait)
     server_waiting = 1;
 
-  ret = (*the_target->wait) (ourstatus);
+  ret = (*the_target->wait) (ourstatus, options);
+
+  if (ourstatus->kind == TARGET_WAITKIND_EXITED
+      || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
+    {
+      if (ourstatus->kind == TARGET_WAITKIND_EXITED)
+	fprintf (stderr,
+		 "\nChild exited with status %d\n", ourstatus->value.sig);
+      if (ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
+	fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
+		 target_signal_to_host (ourstatus->value.sig),
+		 target_signal_to_name (ourstatus->value.sig));
+    }
 
   if (connected_wait)
     server_waiting = 0;
@@ -104,6 +117,20 @@ mywait (struct target_waitstatus *ourstatus, int connected_wait)
   return ret;
 }
 
+int
+start_non_stop (int nonstop)
+{
+  if (the_target->start_non_stop == NULL)
+    {
+      if (nonstop)
+	return -1;
+      else
+	return 0;
+    }
+
+  return (*the_target->start_non_stop) (nonstop);
+}
+
 void
 set_target_ops (struct target_ops *target)
 {
diff --git a/gdb/gdbserver/target.h b/gdb/gdbserver/target.h
index 27f57ea..b7156fd 100644
--- a/gdb/gdbserver/target.h
+++ b/gdb/gdbserver/target.h
@@ -22,6 +22,20 @@
 #ifndef TARGET_H
 #define TARGET_H
 
+/* Ways to "resume" a thread.  */
+
+enum resume_kind
+{
+  /* Thread should continue.  */
+  resume_continue,
+
+  /* Thread should single-step.  */
+  resume_step,
+
+  /* Thread should be stopped.  */
+  resume_stop
+};
+
 /* This structure describes how to resume a particular thread (or all
    threads) based on the client's request.  If thread is -1, then this
    entry applies to all threads.  These are passed around as an
@@ -31,10 +45,13 @@ struct thread_resume
 {
   unsigned long thread;
 
-  /* If non-zero, we want to single-step.  */
-  int step;
+  /* How to "resume".  */
+  enum resume_kind kind;
 
-  /* If non-zero, send this signal when we resume.  */
+  /* If non-zero, send this signal when we resume, or to stop the
+     thread.  If stopping a thread, and this is 0, the target should
+     stop the thread however it best decides to (e.g., SIGSTOP on
+     linux; SuspendThread on win32).  */
   int sig;
 };
 
@@ -85,6 +102,10 @@ struct target_waitstatus
     value;
   };
 
+/* Options that can be passed to target_ops->wait.  */
+
+#define TARGET_WNOHANG 1
+
 struct target_ops
 {
   /* Start a new process.
@@ -132,7 +153,7 @@ struct target_ops
   /* Wait for the inferior process or thread to change state.  Store
      status through argument pointer STATUS.  */
 
-  unsigned long (*wait) (struct target_waitstatus *status);
+  unsigned long (*wait) (struct target_waitstatus *status, int options);
 
   /* Fetch registers from the inferior process.
 
@@ -237,6 +258,16 @@ struct target_ops
   int (*qxfer_siginfo) (const char *annex, unsigned char *readbuf,
 			unsigned const char *writebuf,
 			CORE_ADDR offset, int len);
+
+  int (*supports_non_stop) (void);
+
+  /* Enables async target events.  Returns the previous enable
+     state.  */
+  int (*async) (int enable);
+
+  /* Switch to non-stop (1) or all-stop (0) mode.  Return 0 on
+     success, -1 otherwise.  */
+  int (*start_non_stop) (int);
 };
 
 extern struct target_ops *the_target;
@@ -267,7 +298,18 @@ void set_target_ops (struct target_ops *);
 #define join_inferior() \
   (*the_target->join) ()
 
-unsigned long mywait (struct target_waitstatus *ourstatus, int connected_wait);
+#define target_supports_non_stop() \
+  (the_target->supports_non_stop ? (*the_target->supports_non_stop ) () : 0)
+
+#define target_async(enable) \
+  (the_target->async ? (*the_target->async) (enable) : 0)
+
+/* Start non-stop mode, returns 0 on success, -1 on failure.   */
+
+int start_non_stop (int nonstop);
+
+unsigned long mywait (struct target_waitstatus *ourstatus, int options,
+		      int connected_wait);
 
 int read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len);
 
diff --git a/gdb/gdbserver/thread-db.c b/gdb/gdbserver/thread-db.c
index 3443472..adafb2c 100644
--- a/gdb/gdbserver/thread-db.c
+++ b/gdb/gdbserver/thread-db.c
@@ -155,7 +155,7 @@ thread_db_create_event (CORE_ADDR where)
      created threads.  */
   lwp = get_thread_lwp (current_inferior);
   if (lwp->thread_known == 0)
-    find_one_thread (lwp->lwpid);
+    find_one_thread (lwpid_of (lwp));
 
   /* msg.event == TD_EVENT_CREATE */
 
@@ -245,7 +245,7 @@ find_one_thread (int lwpid)
     return 1;
 
   /* Get information about this thread.  */
-  err = td_ta_map_lwp2thr (thread_agent, lwp->lwpid, &th);
+  err = td_ta_map_lwp2thr (thread_agent, lwpid_of (lwp), &th);
   if (err != TD_OK)
     error ("Cannot get thread handle for LWP %d: %s",
 	   lwpid, thread_db_err_str (err));
@@ -259,10 +259,10 @@ find_one_thread (int lwpid)
     fprintf (stderr, "Found thread %ld (LWP %d)\n",
 	     ti.ti_tid, ti.ti_lid);
 
-  if (lwp->lwpid != ti.ti_lid)
+  if (lwpid_of (lwp) != ti.ti_lid)
     {
       warning ("PID mismatch!  Expected %ld, got %ld",
-	       (long) lwp->lwpid, (long) ti.ti_lid);
+	       (long) lwpid_of (lwp), (long) ti.ti_lid);
       return 0;
     }
 
@@ -388,7 +388,7 @@ thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
 
   lwp = get_thread_lwp (thread);
   if (!lwp->thread_known)
-    find_one_thread (lwp->lwpid);
+    find_one_thread (lwpid_of (lwp));
   if (!lwp->thread_known)
     return TD_NOTHR;
 
diff --git a/gdb/gdbserver/win32-low.c b/gdb/gdbserver/win32-low.c
index 2fed73c..1d7c203 100644
--- a/gdb/gdbserver/win32-low.c
+++ b/gdb/gdbserver/win32-low.c
@@ -685,7 +685,7 @@ win32_detach (void)
   {
     struct thread_resume resume;
     resume.thread = -1;
-    resume.step = 0;
+    resume.kind = resume_continue;
     resume.sig = 0;
     win32_resume (&resume, 1);
   }
@@ -754,7 +754,7 @@ win32_resume (struct thread_resume *resume_info, size_t n)
   if (resume_info[0].thread != -1)
     {
       sig = resume_info[0].sig;
-      step = resume_info[0].step;
+      step = resume_info[0].kind == resume_step;
     }
   else
     {
@@ -1476,7 +1476,7 @@ get_child_debug_event (struct target_waitstatus *ourstatus)
    STATUS will be filled in with a response code to send to GDB.
    Returns the signal which caused the process to stop. */
 static unsigned long
-win32_wait (struct target_waitstatus *ourstatus)
+win32_wait (struct target_waitstatus *ourstatus, int options)
 {
   while (1)
     {