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


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[gdbserver/RFA] Add linux non-stop mode support


This patch adds non-stop mode support to linux-gdbserver.

 - Adds an event loop that allows registering waitable on file
   descriptors, based and much simplified from GDB's own
   asynchronous event loop.  Split out the big packet processing
   loop into its own function, and installed that as serial activity
   callback.

 - Implements the non-stop remote protocol extensions.  vStopped event
   queue, the non-acked notifications (%), vCont;t, vKill, qSupported,
   QNonStop:x, etc.

 - Adjusted target_ops->wait to take an extra `options' flags
   argument.  The only argument currently defined is TARGET_WNOHANG,
   which means, "give me any status of a child that has stopped already,
   but don't block", just like waitpid(WNOHANG).  This is used
   in the event-loop callback that calls into mywait -> target_ops->wait.

 - made my_waitpid simulate __WALL itself, so linux_wait_for_lwp has that
   logic out of it, and it's centralized.  The usleep disappears.

 - Replaces the struct thread_resume->step field for an instance of this
   new type:

+/* Ways to "resume" a thread.  */
+
+enum resume_kind
+{
+  /* Thread should be stopped.  */
+  resume_stop,
+
+  /* Thread should continue.  */
+  resume_continue,
+
+  /* Thread should single-step.  */
+  resume_step
+};

   resume_stop is for stop requests from GDB, "(gdb) interrupt" -> vCont;t.

   On linux, this is implemented with SIGSTOP, but, the stop signal reported
   is SIGNAL_0, as per the vCont;t protocol.

 - Implemented async event handling in the linux target using SIGCHLD.
   I've done things differently to the native GDB linux support
   this time.  Actually, it started out as being equal to the native
   GDB, but I progressedly moved away from it.  I think this version
   is much nicer, and simpler, the maintainance burden should be
   much smaller -- the code paths between sync and async modes are almost
   the same, except for WNOHANG handling, and data structures are the same
   for both modes.  I think I'm going to do something similar
   to gdb/linux-nat.c.

   In this version, the SIGCHLD handler doesn't do any waitpid.  It just
   tells the event loop there's something to process.  The event loop then
   calls a callback that flushes events out of the target with the abstracted
   equivalent of waitpid(WNOHANG).

   This means that in this version, the cached wait statuses stored in
   the lwps are used in async/non_stop mode too, one of the biggest
   differences to the GDB implementation, which stores them on the side
   in async mode.

This version is *much* less invasive than the version in the
multiprocess branch, but still paves the way to push multi-process
extensions next.

No regressions against x86_64-unknown-linux-gnu, ppc64-unknown-linux-gnu,
and arm-none-linux-gnueabi.  I've been trying to run this against a
native Cygwin gdbserver, but for some reason, my XP machine isn't being
nice to me.  Preliminary results do look good though.

I'll post a testsuite patch next, that makes the MI non-stop tests
run against remote targets, and pass cleanly against gdbserver, on
archs that already have displaced stepping implemented.

There are a couple of places in the patch that I'll reindent if/when
this is applied.  I've just chosen not to do it yet for better
mergeability (less work for me!), and for ease of review (less work
for you!).

This patches requires the following patches, in this order:

 http://sourceware.org/ml/gdb-patches/2009-03/msg00573.html
 http://sourceware.org/ml/gdb-patches/2009-03/msg00578.html
 http://sourceware.org/ml/gdb-patches/2009-03/msg00579.html

Does it look OK-ish to apply?

-- 
Pedro Alves

2009-03-26  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.

---
 gdb/gdbserver/Makefile.in    |    3 
 gdb/gdbserver/event-loop.c   |  504 ++++++++++++++++++++++++
 gdb/gdbserver/linux-low.c    |  879 ++++++++++++++++++++++++++++++-------------
 gdb/gdbserver/linux-low.h    |   13 
 gdb/gdbserver/remote-utils.c |   38 +
 gdb/gdbserver/server.c       |  504 ++++++++++++++++++++----
 gdb/gdbserver/server.h       |   20 
 gdb/gdbserver/spu-low.c      |    4 
 gdb/gdbserver/target.c       |   31 +
 gdb/gdbserver/target.h       |   52 ++
 gdb/gdbserver/thread-db.c    |   10 
 gdb/gdbserver/win32-low.c    |    6 
 12 files changed, 1699 insertions(+), 365 deletions(-)

Index: src/gdb/gdbserver/Makefile.in
===================================================================
--- src.orig/gdb/gdbserver/Makefile.in	2009-03-25 16:45:52.000000000 +0000
+++ src/gdb/gdbserver/Makefile.in	2009-03-25 16:46:38.000000000 +0000
@@ -126,7 +126,7 @@ TAGFILES = $(SOURCES) ${HFILES} ${ALLPAR
 
 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
 
 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)
Index: src/gdb/gdbserver/linux-low.c
===================================================================
--- src.orig/gdb/gdbserver/linux-low.c	2009-03-25 16:45:52.000000000 +0000
+++ src/gdb/gdbserver/linux-low.c	2009-03-25 20:26:09.000000000 +0000
@@ -118,7 +118,7 @@ static void linux_resume_one_lwp (struct
 				  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 *e
       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 *e
 
       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.
@@ -394,6 +413,7 @@ linux_kill_one_lwp (struct inferior_list
 {
   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 +423,18 @@ linux_kill_one_lwp (struct inferior_list
   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 +443,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 +453,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 +480,28 @@ linux_detach_one_lwp (struct inferior_li
   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 +511,12 @@ linux_detach_one_lwp (struct inferior_li
      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 +524,9 @@ linux_detach_one_lwp (struct inferior_li
 			   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 +535,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 +579,7 @@ check_removed_breakpoint (struct lwp_inf
 
   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 +634,7 @@ status_pending_p (struct inferior_list_e
 {
   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 +647,28 @@ status_pending_p (struct inferior_list_e
 	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;
+  int to_wait_for = pid;
+  struct lwp_info *child = NULL;
 
-  if (*childp != NULL)
-    to_wait_for = (*childp)->lwpid;
-
-retry:
-  while (1)
-    {
-      ret = waitpid (to_wait_for, wstatp, WNOHANG);
-
-      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 +676,26 @@ 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)
-    goto retry;
+  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 +715,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 +778,59 @@ linux_wait_for_event (struct thread_info
      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 +841,10 @@ linux_wait_for_event (struct thread_info
 	  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 +857,43 @@ linux_wait_for_event (struct thread_info
 	 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 +944,11 @@ linux_wait_for_event (struct thread_info
 	     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 +976,7 @@ linux_wait_for_event (struct thread_info
 	 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 +992,7 @@ linux_wait_for_event (struct thread_info
 	  event_child->pending_stop_pc = stop_pc;
 	}
 
-      return wstat;
+      return lwpid_of (event_child);
     }
 
   /* NOTREACHED */
@@ -930,45 +1002,58 @@ linux_wait_for_event (struct thread_info
 /* 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 +1068,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 +1106,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 +1222,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 +1244,29 @@ send_sigstop (struct inferior_list_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);
+
+  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 +1276,7 @@ wait_for_sigstop (struct inferior_list_e
     {
       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
@@ -1132,8 +1305,18 @@ wait_for_sigstop (struct inferior_list_e
       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 +1369,7 @@ linux_resume_one_lwp (struct inferior_li
 
   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 +1414,7 @@ linux_resume_one_lwp (struct inferior_li
 
       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 +1425,7 @@ linux_resume_one_lwp (struct inferior_li
   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 +1482,152 @@ linux_set_resume_request (struct inferio
   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 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);
+      if (!lwp->stopped)
+	{
+	  if (debug_threads)
+	    fprintf (stderr, "running -> suspending %ld\n", lwpid_of (lwp));
 
-      lwp->pending_signals = p_sig;
+	  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));
+	    }
+
+	  /* 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;
+	}
+
+      /* 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 +1642,11 @@ linux_resume (struct thread_resume *resu
   /* 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 +1656,7 @@ linux_resume (struct thread_resume *resu
 	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 +2103,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)
+    {
+      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);
+    }
+  else
     {
-      ret = waitpid (pid, status, flags);
+      do
+	ret = waitpid (pid, status, flags);
+      while (ret == -1 && errno == EINTR);
+      out_errno = errno;
     }
-  while (ret == -1 && errno == EINTR);
 
+  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 +2289,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 +2382,7 @@ linux_read_offsets (CORE_ADDR *text_p, C
 {
 #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 +2524,7 @@ linux_xfer_siginfo (const char *annex, u
   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 +2552,83 @@ linux_xfer_siginfo (const char *annex, u
   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 +2663,9 @@ static struct target_ops linux_target_op
   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 +2679,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 +2692,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);
 }
Index: src/gdb/gdbserver/linux-low.h
===================================================================
--- src.orig/gdb/gdbserver/linux-low.h	2009-03-25 16:45:52.000000000 +0000
+++ src/gdb/gdbserver/linux-low.h	2009-03-25 16:46:38.000000000 +0000
@@ -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
Index: src/gdb/gdbserver/remote-utils.c
===================================================================
--- src.orig/gdb/gdbserver/remote-utils.c	2009-03-25 16:45:52.000000000 +0000
+++ src/gdb/gdbserver/remote-utils.c	2009-03-25 16:46:38.000000000 +0000
@@ -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, unsig
    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, unsigne
 	       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);
 	      }
Index: src/gdb/gdbserver/server.c
===================================================================
--- src.orig/gdb/gdbserver/server.c	2009-03-25 16:45:52.000000000 +0000
+++ src/gdb/gdbserver/server.c	2009-03-25 16:46:38.000000000 +0000
@@ -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);
+  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;
+      /* 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_
   /* 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_
       if (the_target->qxfer_osdata != NULL)
 	strcat (own_buf, ";qXfer:osdata:read+");
 
+      if (target_supports_non_stop ())
+	strcat (own_buf, ";QNonStop+");
+
       return;
     }
 
@@ -1087,9 +1248,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;
 
@@ -1144,20 +1307,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:
@@ -1180,7 +1352,20 @@ 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.  GDB will
+	     query for the current thread, so set it.  */
+	  general_thread = last_ptid;
+
+	  /* 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
@@ -1263,6 +1448,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
@@ -1272,6 +1464,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)
@@ -1287,7 +1501,7 @@ handle_v_requests (char *own_buf, int pa
 
       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;
 	}
     }
@@ -1320,12 +1534,21 @@ handle_v_requests (char *own_buf, int pa
       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)
 {
@@ -1341,7 +1564,10 @@ myresume (char *own_buf, int step, int s
     {
       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++;
     }
@@ -1349,16 +1575,39 @@ myresume (char *own_buf, int step, int s
   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.  */
@@ -1366,11 +1615,32 @@ myresume (char *own_buf, int step, int s
 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
@@ -1425,12 +1695,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;
@@ -1629,9 +1893,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.  */
@@ -1642,8 +1907,51 @@ main (int argc, char *argv[])
 	    }
 	}
 
+      /* 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)
+	{
+	  if (attached)
+	    detach_inferior ();
+	  else
+	    kill_inferior ();
+	  exit (0);
+	}
+      else
+	fprintf (stderr, "Remote side has terminated connection.  "
+		 "GDBserver will reopen the connection.\n");
+    }
+}
+
+/* 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.  */
+
+static void
+process_serial_event (void)
+{
+  char ch;
+  int i = 0;
+  int signal;
+  unsigned int len;
+  CORE_ADDR mem_addr;
+
+  /* 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 ();
-      while (!exit_requested)
 	{
 	  unsigned char sig;
 	  int packet_len;
@@ -1652,7 +1960,11 @@ main (int argc, char *argv[])
 	  response_needed = 0;
 	  packet_len = getpkt (own_buf);
 	  if (packet_len <= 0)
-	    break;
+	    {
+	      target_async (0);
+	      remote_close ();
+	      return;
+	    }
 	  response_needed = 1;
 
 	  i = 0;
@@ -1672,6 +1984,7 @@ main (int argc, char *argv[])
 		write_enn (own_buf);
 	      else
 		{
+		  discard_queued_stop_replies ();
 		  write_ok (own_buf);
 
 		  if (extended_protocol)
@@ -1680,6 +1993,8 @@ main (int argc, char *argv[])
 		      last_status.kind = TARGET_WAITKIND_EXITED;
 		      last_status.value.integer = 0;
 		      last_ptid = signal_pid;
+
+		      current_inferior = NULL;
 		    }
 		  else
 		    {
@@ -1724,6 +2039,19 @@ main (int argc, char *argv[])
 
 		  if (own_buf[1] == 'g')
 		    {
+		      if (thread_id == 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);
 		    }
@@ -1872,10 +2200,11 @@ main (int argc, char *argv[])
 	      if (!target_running ())
 		/* The packet we received doesn't make sense - but we
 		   can't reply to it, either.  */
-		goto restart;
+		return;
 
 	      fprintf (stderr, "Killing inferior\n");
 	      kill_inferior ();
+	      discard_queued_stop_replies ();
 
 	      /* When using the extended protocol, we wait with no
 		 program running.  The traditional protocol will exit
@@ -1884,8 +2213,7 @@ main (int argc, char *argv[])
 		{
 		  last_status.kind = TARGET_WAITKIND_EXITED;
 		  last_status.value.sig = TARGET_SIGNAL_KILL;
-		  was_running = 0;
-		  goto restart;
+		  return;
 		}
 	      else
 		{
@@ -1919,7 +2247,10 @@ main (int argc, char *argv[])
 	      if (extended_protocol)
 		{
 		  if (target_running ())
-		    kill_inferior ();
+		    {
+		      kill_inferior ();
+		      discard_queued_stop_replies ();
+		    }
 		  fprintf (stderr, "GDBserver restarting\n");
 
 		  /* Wait till we are at 1st instruction in prog.  */
@@ -1930,7 +2261,7 @@ main (int argc, char *argv[])
 		      last_status.kind = TARGET_WAITKIND_EXITED;
 		      last_status.value.sig = TARGET_SIGNAL_KILL;
 		    }
-		  goto restart;
+		  return;
 		}
 	      else
 		{
@@ -1960,54 +2291,53 @@ main (int argc, char *argv[])
 
 	  response_needed = 0;
 
-	  if (was_running
-	      && (last_status.kind == TARGET_WAITKIND_EXITED
-		  || last_status.kind == TARGET_WAITKIND_SIGNALLED))
+	  if (!extended_protocol && have_ran && !target_running ())
 	    {
-	      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
+	      /* 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");
 		  exit (0);
 		}
 	    }
-
-	  if (last_status.kind != TARGET_WAITKIND_EXITED
-	      && last_status.kind != TARGET_WAITKIND_SIGNALLED)
-	    was_running = 1;
 	}
+}
 
-      /* 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.  */
+/* Event-loop callback for serial events.  */
 
-      if (exit_requested)
-	{
-	  remote_close ();
-	  if (attached && target_running ())
-	    detach_inferior ();
-	  else if (target_running ())
-	    kill_inferior ();
-	  exit (0);
-	}
-      else
-	{
-	  fprintf (stderr, "Remote side has terminated connection.  "
-			   "GDBserver will reopen the connection.\n");
-	  remote_close ();
-	}
+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);
 }
Index: src/gdb/gdbserver/server.h
===================================================================
--- src.orig/gdb/gdbserver/server.h	2009-03-25 16:45:52.000000000 +0000
+++ src/gdb/gdbserver/server.h	2009-03-25 16:46:38.000000000 +0000
@@ -172,6 +172,25 @@ 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 +206,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);
Index: src/gdb/gdbserver/target.c
===================================================================
--- src.orig/gdb/gdbserver/target.c	2009-03-25 16:45:52.000000000 +0000
+++ src/gdb/gdbserver/target.c	2009-03-25 16:46:38.000000000 +0000
@@ -89,14 +89,27 @@ write_inferior_memory (CORE_ADDR memaddr
 }
 
 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 *oursta
   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)
 {
Index: src/gdb/gdbserver/target.h
===================================================================
--- src.orig/gdb/gdbserver/target.h	2009-03-25 16:46:12.000000000 +0000
+++ src/gdb/gdbserver/target.h	2009-03-25 16:46:38.000000000 +0000
@@ -22,6 +22,20 @@
 #ifndef TARGET_H
 #define TARGET_H
 
+/* Ways to "resume" a thread.  */
+
+enum resume_kind
+{
+  /* Thread should be stopped.  */
+  resume_stop,
+
+  /* Thread should continue.  */
+  resume_continue,
+
+  /* Thread should single-step.  */
+  resume_step
+};
+
 /* 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);
 
Index: src/gdb/gdbserver/thread-db.c
===================================================================
--- src.orig/gdb/gdbserver/thread-db.c	2009-03-25 16:45:52.000000000 +0000
+++ src/gdb/gdbserver/thread-db.c	2009-03-25 16:46:38.000000000 +0000
@@ -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
 
   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;
 
Index: src/gdb/gdbserver/event-loop.c
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/gdbserver/event-loop.c	2009-03-25 16:46:38.000000000 +0000
@@ -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.  */
+}
Index: src/gdb/gdbserver/win32-low.c
===================================================================
--- src.orig/gdb/gdbserver/win32-low.c	2009-03-25 16:46:12.000000000 +0000
+++ src/gdb/gdbserver/win32-low.c	2009-03-25 16:46:38.000000000 +0000
@@ -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 *resu
   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_wai
    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)
     {
Index: src/gdb/gdbserver/spu-low.c
===================================================================
--- src.orig/gdb/gdbserver/spu-low.c	2009-03-25 17:55:15.000000000 +0000
+++ src/gdb/gdbserver/spu-low.c	2009-03-25 17:56:42.000000000 +0000
@@ -359,7 +359,7 @@ spu_resume (struct thread_resume *resume
 
   /* 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
 
 /* 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;


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