2002-06-11 Daniel Jacobowitz <drow@mvista.com>

	* gdbserver/thread-db.c: New file.
	* gdbserver/proc-service.c: New file.
	* gdbserver/acinclude.m4: New file.
	* gdbserver/Makefile.in: Add GDBSERVER_LIBS, gdb_proc_service_h,
	proc-service.o, and thread-db.o.
	(linux-low.o): Add USE_THREAD_DB.
	* gdbserver/acconfig.h: Add HAVE_PRGREGSET_T, HAVE_PRFPREGSET_T,
	HAVE_LWPID_T, HAVE_PSADDR_T, and PRFPREGSET_T_BROKEN.
	* gdbserver/aclocal.m4: Regenerated.
	* gdbserver/config.in: Regenerated.
	* gdbserver/configure: Regenerated.
	* gdbserver/configure.in: Check for proc_service.h, sys/procfs.h,
	thread_db.h, and linux/elf.h headrs.
	Check for lwpid_t, psaddr_t, prgregset_t, prfpregset_t, and
	PRFPREGSET_T_BROKEN.  Introduce srv_thread_depfiles and USE_THREAD_DB.
	Check for -lthread_db and thread support.
	* gdbserver/configure.srv: Enable thread_db support for ARM, i386, MIPS,
	PowerPC, and SuperH.
	* gdbserver/i387-fp.c: Constify arguments.
	* gdbserver/i387-fp.h: Likewise.
	* gdbserver/inferiors.c: (struct thread_info): Renamed from
	`struct inferior_info'.  Remove PID member.  Use generic inferior
	list header.  All uses updated.
	(inferiors, signal_pid): Removed.
	(all_threads): New variable.
	(get_thread): Define.
	(add_inferior_to_list): New function.
	(for_each_inferior): New function.
	(change_inferior_id): New function.
	(add_inferior): Removed.
	(remove_inferior): New function.
	(add_thread): New function.
	(free_one_thread): New function.
	(remove_thread): New function.
	(clear_inferiors): Use for_each_inferior and free_one_thread.
	(find_inferior): New function.
	(find_inferior_id): New function.
	(inferior_target_data): Update argument type.
	(set_inferior_target_data): Likewise.
	(inferior_regcache_data): Likewise.
	(set_inferior_regcache_data): Likewise.
	* gdbserver/linux-low.c (linux_bp_reinsert): Remove.
	(all_processes, stopping_threads, using_thrads)
	(struct pending_signals, debug_threads, pid_of): New.
	(inferior_pid): Replace with macro.
	(struct inferior_linux_data): Remove.
	(get_stop_pc, add_process): New functions.
	(linux_create_inferior): Restore SIGRTMIN+1 before calling exec.
	Use add_process and add_thread.
	(linux_attach_lwp): New function, based on old linux_attach.  Use
	add_process and add_thread.  Set stop_expected for new threads.
	(linux_attach): New function.
	(linux_kill_one_process): New function.
	(linux_kill): Kill all LWPs.
	(linux_thread_alive): Use find_inferior_id.
	(check_removed_breakpoints, status_pending_p): New functions.
	(linux_wait_for_process): Renamed from linux_wait_for_one_inferior.
	Update.  Use WNOHANG.  Wait for cloned processes also.  Update process
	struct for the found process.
	(linux_wait_for_event): New function.
	(linux_wait): Use it.  Support LWPs.
	(send_sigstop, wait_for_sigstop, stop_all_processes)
	(linux_resume_one_process, linux_continue_one_process): New functions.
	(linux_resume): Support LWPs.
	(REGISTER_RAW_SIZE): Remove.
	(fetch_register): Use register_size instead.  Call supply_register.
	(usr_store_inferior_registers): Likewise.  Call collect_register.
	Fix recursive case.
	(regsets_fetch_inferior_registers): Improve error message.
	(regsets_store_inferior_registers): Add debugging.
	(linux_look_up_symbols): Call thread_db_init if USE_THREAD_DB.
	(unstopped_p, linux_signal_pid): New functions.
	(linux_target_ops): Add linux_signal_pid.
	(linux_init_signals): New function.
	(initialize_low): Call it.  Initialize using_threads.
	* gdbserver/regcache.c (inferior_regcache_data): Add valid
	flag.
	(get_regcache): Fetch registers lazily.  Add fetch argument
	and update all callers.
	(regcache_invalidate_one, regcache_invalidate): New
	functions.
	(new_register_cache): Renamed from create_register_cache.
	Return the new regcache.
	(free_register_cache): Change argument to a void *.
	(registers_to_string, registers_from_string): Call get_regcache
	with fetch flag set.
	(register_data): Make static.  Pass fetch flag to get_regcache.
	(supply_register): Call get_regcache with fetch flag clear.
	(collect_register): Call get_regcache with fetch flag set.
	(collect_register_as_string): New function.
	* gdbserver/regcache.h: Update.
	* gdbserver/remote-utils.c (putpkt): Flush after debug output and use
	stderr.
	Handle input interrupts while waiting for an ACK.
	(input_interrupt): Use signal_pid method.
	(getpkt): Flush after debug output and use stderr.
	(outreg): Use collect_register_as_string.
	(new_thread_notify, dead_thread_notify): New functions.
	(prepare_resume_reply): Check using_threads.  Set thread_from_wait
	and general_thread.
	(look_up_one_symbol): Flush after debug output.
	* gdbserver/server.c (step_thread, server_waiting): New variables.
	(start_inferior): Don't use signal_pid.  Update call to mywait.
	(attach_inferior): Update call to mywait.
	(handle_query): Handle qfThreadInfo and qsThreadInfo.
	(main): Don't fetch/store registers explicitly.  Use
	set_desired_inferior.  Support proposed ``Hs'' packet.  Update
	calls to mywait.
	* gdbserver/server.h: Update.
	(struct inferior_list, struct_inferior_list_entry): New.
	* gdbserver/target.c (set_desired_inferior): New.
	(write_inferior_memory): Constify.
	(mywait): New function.
	* gdbserver/target.h: Update.
	(struct target_ops): New signal_pid method.
	(mywait): Removed macro, added prototype.

	* gdbserver/linux-low.h (regset_func): Removed.
	(regset_fill_func, regset_store_func): New.
	(enum regset_type): New.
	(struct regset_info): Add type field.  Use new operation types.
	(struct linux_target_ops): stop_pc renamed to get_pc.
	Add decr_pc_after_break and breakpoint_at.
	(get_process, get_thread_proess, get_process_thread)
	(strut process_info, all_processes, linux_attach_lwp)
	(thread_db_init): New.

	* gdbserver/linux-arm-low.c (arm_get_pc, arm_set_pc,
	arm_breakpoint, arm_breakpoint_len, arm_breakpoint_at): New.
	(the_low_target): Add new members.
	* gdbserver/linux-i386-low.c (i386_store_gregset, i386_store_fpregset)
	(i386_store_fpxregset): Constify.
	(target_regsets): Add new kind identifier.
	(i386_get_pc): Renamed from i386_stop_pc.  Simplify.
	(i386_set_pc): Add debugging.
	(i386_breakpoint_at): New function.
	(the_low_target): Add new members.
	* gdbserver/linux-mips-low.c (mips_get_pc, mips_set_pc)
	(mips_breakpoint, mips_breakpoint_len, mips_reinsert_addr)
	(mips_breakpoint_at): New.
	(the_low_target): Add new members.
	* gdbserver/linux-ppc-low.c (ppc_get_pc, ppc_set_pc)
	(ppc_breakpoint, ppc_breakpoint_len, ppc_breakpoint_at): New.
	(the_low_target): Add new members.
	* gdbserver/linux-sh-low.c (sh_get_pc, sh_set_pc)
	(sh_breakpoint, sh_breakpoint_len, sh_breakpoint_at): New.
	(the_low_target): Add new members.
	* gdbserver/linux-x86-64-low.c (target_regsets): Add new kind
	identifier.

1 files changed, 788 insertions, 87 deletions

diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
index 6cfe0d5..c272fed 100644
--- a/gdb/gdbserver/linux-low.c
+++ b/gdb/gdbserver/linux-low.c
@@ -35,9 +35,32 @@
 #include <stdlib.h>
 #include <unistd.h>
 
-static CORE_ADDR linux_bp_reinsert;
+/* ``all_threads'' is keyed by the LWP ID - it should be the thread ID instead,
+   however.  This requires changing the ID in place when we go from !using_threads
+   to using_threads, immediately.
 
+   ``all_processes'' is keyed by the process ID - which on Linux is (presently)
+   the same as the LWP ID.  */
+
+struct inferior_list all_processes;
+
+/* FIXME this is a bit of a hack, and could be removed.  */
+int stopping_threads;
+
+/* FIXME make into a target method?  */
+int using_threads;
+
+static void linux_resume_one_process (struct inferior_list_entry *entry,
+				      int step, int signal);
 static void linux_resume (int step, int signal);
+static void stop_all_processes (void);
+static int linux_wait_for_event (struct thread_info *child);
+
+struct pending_signals
+{
+  int signal;
+  struct pending_signals *prev;
+};
 
 #define PTRACE_ARG3_TYPE long
 #define PTRACE_XFER_TYPE long
@@ -48,12 +71,64 @@ static int use_regsets_p = 1;
 
 extern int errno;
 
-static int inferior_pid;
+int debug_threads = 0;
+
+#define pid_of(proc) ((proc)->head.id)
+
+/* FIXME: Delete eventually.  */
+#define inferior_pid (pid_of (get_thread_process (current_inferior)))
+
+/* This function should only be called if the process got a SIGTRAP.
+   The SIGTRAP could mean several things.
+
+   On i386, where decr_pc_after_break is non-zero:
+   If we were single-stepping this process using PTRACE_SINGLESTEP,
+   we will get only the one SIGTRAP (even if the instruction we
+   stepped over was a breakpoint).  The value of $eip will be the
+   next instruction.
+   If we continue the process using PTRACE_CONT, we will get a
+   SIGTRAP when we hit a breakpoint.  The value of $eip will be
+   the instruction after the breakpoint (i.e. needs to be
+   decremented).  If we report the SIGTRAP to GDB, we must also
+   report the undecremented PC.  If we cancel the SIGTRAP, we
+   must resume at the decremented PC.
+
+   (Presumably, not yet tested) On a non-decr_pc_after_break machine
+   with hardware or kernel single-step:
+   If we single-step over a breakpoint instruction, our PC will
+   point at the following instruction.  If we continue and hit a
+   breakpoint instruction, our PC will point at the breakpoint
+   instruction.  */
+
+static CORE_ADDR
+get_stop_pc (void)
+{
+  CORE_ADDR stop_pc = (*the_low_target.get_pc) ();
+
+  if (get_thread_process (current_inferior)->stepping)
+    return stop_pc;
+  else
+    return stop_pc - the_low_target.decr_pc_after_break;
+}
 
-struct inferior_linux_data
+static void *
+add_process (int pid)
 {
-  int pid;
-};
+  struct process_info *process;
+
+  process = (struct process_info *) malloc (sizeof (*process));
+  memset (process, 0, sizeof (*process));
+
+  process->head.id = pid;
+
+  /* Default to tid == lwpid == pid.  */
+  process->tid = pid;
+  process->lwpid = pid;
+
+  add_inferior_to_list (&all_processes, &process->head);
+
+  return process;
+}
 
 /* Start an inferior process and returns its pid.
    ALLARGS is a vector of program-name and args. */
@@ -61,7 +136,7 @@ struct inferior_linux_data
 static int
 linux_create_inferior (char *program, char **allargs)
 {
-  struct inferior_linux_data *tdata;
+  void *new_process;
   int pid;
 
   pid = fork ();
@@ -72,6 +147,8 @@ linux_create_inferior (char *program, char **allargs)
     {
       ptrace (PTRACE_TRACEME, 0, 0, 0);
 
+      signal (SIGRTMIN + 1, SIG_DFL);
+
       execv (program, allargs);
 
       fprintf (stderr, "Cannot exec %s: %s.\n", program,
@@ -80,22 +157,18 @@ linux_create_inferior (char *program, char **allargs)
       _exit (0177);
     }
 
-  add_inferior (pid);
-  tdata = (struct inferior_linux_data *) malloc (sizeof (*tdata));
-  tdata->pid = pid;
-  set_inferior_target_data (current_inferior, tdata);
+  new_process = add_process (pid);
+  add_thread (pid, new_process);
 
-  /* FIXME remove */
-  inferior_pid = pid;
   return 0;
 }
 
 /* Attach to an inferior process.  */
 
-static int
-linux_attach (int pid)
+void
+linux_attach_lwp (int pid, int tid)
 {
-  struct inferior_linux_data *tdata;
+  struct process_info *new_process;
 
   if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
     {
@@ -103,143 +176,712 @@ linux_attach (int pid)
 	       errno < sys_nerr ? sys_errlist[errno] : "unknown error",
 	       errno);
       fflush (stderr);
-      _exit (0177);
+
+      /* If we fail to attach to an LWP, just return.  */
+      if (!using_threads)
+	_exit (0177);
+      return;
     }
 
-  add_inferior (pid);
-  tdata = (struct inferior_linux_data *) malloc (sizeof (*tdata));
-  tdata->pid = pid;
-  set_inferior_target_data (current_inferior, tdata);
+  new_process = (struct process_info *) add_process (pid);
+  add_thread (tid, new_process);
+
+  /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
+     brings it to a halt.  We should ignore that SIGSTOP and resume the process
+     (unless this is the first process, in which case the flag will be cleared
+     in linux_attach).
+
+     On the other hand, if we are currently trying to stop all threads, we
+     should treat the new thread as if we had sent it a SIGSTOP.  This works
+     because we are guaranteed that add_process added us to the end of the
+     list, and so the new thread has not yet reached wait_for_sigstop (but
+     will).  */
+  if (! stopping_threads)
+    new_process->stop_expected = 1;
+}
+
+int
+linux_attach (int pid)
+{
+  struct process_info *process;
+
+  linux_attach_lwp (pid, pid);
+
+  /* Don't ignore the initial SIGSTOP if we just attached to this process.  */
+  process = (struct process_info *) find_inferior_id (&all_processes, pid);
+  process->stop_expected = 0;
+
   return 0;
 }
 
 /* Kill the inferior process.  Make us have no inferior.  */
 
 static void
-linux_kill (void)
+linux_kill_one_process (struct inferior_list_entry *entry)
 {
-  if (inferior_pid == 0)
-    return;
-  ptrace (PTRACE_KILL, inferior_pid, 0, 0);
-  wait (0);
-  clear_inferiors ();
+  struct thread_info *thread = (struct thread_info *) entry;
+  struct process_info *process = get_thread_process (thread);
+  int wstat;
+
+  do
+    {
+      ptrace (PTRACE_KILL, pid_of (process), 0, 0);
+
+      /* Make sure it died.  The loop is most likely unnecessary.  */
+      wstat = linux_wait_for_event (thread);
+    } while (WIFSTOPPED (wstat));
 }
 
 /* Return nonzero if the given thread is still alive.  */
+static void
+linux_kill (void)
+{
+  for_each_inferior (&all_threads, linux_kill_one_process);
+}
+
+static int
+linux_thread_alive (int tid)
+{
+  if (find_inferior_id (&all_threads, tid) != NULL)
+    return 1;
+  else
+    return 0;
+}
+
+/* Return nonzero if this process stopped at a breakpoint which
+   no longer appears to be inserted.  Also adjust the PC
+   appropriately to resume where the breakpoint used to be.  */
 static int
-linux_thread_alive (int pid)
+check_removed_breakpoint (struct process_info *event_child)
 {
+  CORE_ADDR stop_pc;
+  struct thread_info *saved_inferior;
+
+  if (event_child->pending_is_breakpoint == 0)
+    return 0;
+
+  if (debug_threads)
+    fprintf (stderr, "Checking for breakpoint.\n");
+
+  saved_inferior = current_inferior;
+  current_inferior = get_process_thread (event_child);
+
+  stop_pc = get_stop_pc ();
+
+  /* If the PC has changed since we stopped, then we shouldn't do
+     anything.  This happens if, for instance, GDB handled the
+     decr_pc_after_break subtraction itself.  */
+  if (stop_pc != event_child->pending_stop_pc)
+    {
+      if (debug_threads)
+	fprintf (stderr, "Ignoring, PC was changed.\n");
+
+      event_child->pending_is_breakpoint = 0;
+      current_inferior = saved_inferior;
+      return 0;
+    }
+
+  /* If the breakpoint is still there, we will report hitting it.  */
+  if ((*the_low_target.breakpoint_at) (stop_pc))
+    {
+      if (debug_threads)
+	fprintf (stderr, "Ignoring, breakpoint is still present.\n");
+      current_inferior = saved_inferior;
+      return 0;
+    }
+
+  if (debug_threads)
+    fprintf (stderr, "Removed breakpoint.\n");
+
+  /* For decr_pc_after_break targets, here is where we perform the
+     decrement.  We go immediately from this function to resuming,
+     and can not safely call get_stop_pc () again.  */
+  if (the_low_target.set_pc != NULL)
+    (*the_low_target.set_pc) (stop_pc);
+
+  /* We consumed the pending SIGTRAP.  */
+  event_child->status_pending_p = 0;
+  event_child->status_pending = 0;
+
+  current_inferior = saved_inferior;
   return 1;
 }
 
+/* Return 1 if this process has an interesting status pending.  This function
+   may silently resume an inferior process.  */
 static int
-linux_wait_for_one_inferior (struct inferior_info *child)
+status_pending_p (struct inferior_list_entry *entry, void *dummy)
+{
+  struct process_info *process = (struct process_info *) entry;
+
+  if (process->status_pending_p)
+    if (check_removed_breakpoint (process))
+      {
+	/* This thread was stopped at a breakpoint, and the breakpoint
+	   is now gone.  We were told to continue (or step...) all threads,
+	   so GDB isn't trying to single-step past this breakpoint.
+	   So instead of reporting the old SIGTRAP, pretend we got to
+	   the breakpoint just after it was removed instead of just
+	   before; resume the process.  */
+	linux_resume_one_process (&process->head, 0, 0);
+	return 0;
+      }
+
+  return process->status_pending_p;
+}
+
+static void
+linux_wait_for_process (struct process_info **childp, int *wstatp)
 {
-  struct inferior_linux_data *child_data = inferior_target_data (child);
-  int pid, wstat;
+  int ret;
+  int to_wait_for = -1;
+
+  if (*childp != NULL)
+    to_wait_for = (*childp)->lwpid;
 
   while (1)
     {
-      pid = waitpid (child_data->pid, &wstat, 0);
+      ret = waitpid (to_wait_for, wstatp, WNOHANG);
+
+      if (ret == -1)
+	{
+	  if (errno != ECHILD)
+	    perror_with_name ("waitpid");
+	}
+      else if (ret > 0)
+	break;
+
+      ret = waitpid (to_wait_for, wstatp, WNOHANG | __WCLONE);
+
+      if (ret == -1)
+	{
+	  if (errno != ECHILD)
+	    perror_with_name ("waitpid (WCLONE)");
+	}
+      else if (ret > 0)
+	break;
+
+      usleep (1000);
+    }
+
+  if (debug_threads
+      && (!WIFSTOPPED (*wstatp)
+	  || (WSTOPSIG (*wstatp) != 32
+	      && WSTOPSIG (*wstatp) != 33)))
+    fprintf (stderr, "Got an event from %d (%x)\n", ret, *wstatp);
+
+  if (to_wait_for == -1)
+    *childp = (struct process_info *) find_inferior_id (&all_processes, ret);
+
+  (*childp)->stopped = 1;
+  (*childp)->pending_is_breakpoint = 0;
+
+  if (debug_threads
+      && WIFSTOPPED (*wstatp))
+    {
+      current_inferior = (struct thread_info *)
+	find_inferior_id (&all_threads, (*childp)->tid);
+      /* For testing only; i386_stop_pc prints out a diagnostic.  */
+      if (the_low_target.get_pc != NULL)
+	get_stop_pc ();
+    }
+}
 
-      if (pid != child_data->pid)
-	perror_with_name ("wait");
+static int
+linux_wait_for_event (struct thread_info *child)
+{
+  CORE_ADDR stop_pc;
+  struct process_info *event_child;
+  int wstat;
+
+  /* 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_breakpoints); signals should be reported anyway.  */
+  if (child == NULL)
+    {
+      event_child = (struct process_info *)
+	find_inferior (&all_processes, status_pending_p, NULL);
+      if (debug_threads && event_child)
+	fprintf (stderr, "Got a pending child %d\n", event_child->lwpid);
+    }
+  else
+    {
+      event_child = get_thread_process (child);
+      if (event_child->status_pending_p
+	  && check_removed_breakpoint (event_child))
+	event_child = NULL;
+    }
 
-      /* If this target supports breakpoints, see if we hit one.  */
-      if (the_low_target.stop_pc != NULL
-	  && WIFSTOPPED (wstat)
-	  && WSTOPSIG (wstat) == SIGTRAP)
+  if (event_child != NULL)
+    {
+      if (event_child->status_pending_p)
 	{
-	  CORE_ADDR stop_pc;
+	  if (debug_threads)
+	    fprintf (stderr, "Got an event from pending child %d (%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_process_thread (event_child);
+	  return wstat;
+	}
+    }
+
+  /* We only enter this loop if no process has a pending wait status.  Thus
+     any action taken in response to a wait status inside this loop is
+     responding as soon as we detect the status, not after any pending
+     events.  */
+  while (1)
+    {
+      if (child == NULL)
+	event_child = NULL;
+      else
+	event_child = get_thread_process (child);
+
+      linux_wait_for_process (&event_child, &wstat);
+
+      if (event_child == NULL)
+	error ("event from unknown child");
 
-	  if (linux_bp_reinsert != 0)
+      current_inferior = (struct thread_info *)
+	find_inferior_id (&all_threads, event_child->tid);
+
+      if (using_threads)
+	{
+	  /* Check for thread exit.  */
+	  if (! WIFSTOPPED (wstat))
 	    {
-	      reinsert_breakpoint (linux_bp_reinsert);
-	      linux_bp_reinsert = 0;
-	      linux_resume (0, 0);
+	      if (debug_threads)
+		fprintf (stderr, "Thread %d (LWP %d) exiting\n",
+			 event_child->tid, event_child->head.id);
+
+	      /* If the last thread is exiting, just return.  */
+	      if (all_threads.head == all_threads.tail)
+		return wstat;
+
+	      dead_thread_notify (event_child->tid);
+
+	      remove_inferior (&all_processes, &event_child->head);
+	      free (event_child);
+	      remove_thread (current_inferior);
+	      current_inferior = (struct thread_info *) all_threads.head;
+
+	      /* If we were waiting for this particular child to do something...
+		 well, it did something.  */
+	      if (child != NULL)
+		return wstat;
+
+	      /* Wait for a more interesting event.  */
 	      continue;
 	    }
 
-	  fetch_inferior_registers (0);
-	  stop_pc = (*the_low_target.stop_pc) ();
+	  if (WIFSTOPPED (wstat)
+	      && WSTOPSIG (wstat) == SIGSTOP
+	      && event_child->stop_expected)
+	    {
+	      if (debug_threads)
+		fprintf (stderr, "Expected stop.\n");
+	      event_child->stop_expected = 0;
+	      linux_resume_one_process (&event_child->head,
+					event_child->stepping, 0);
+	      continue;
+	    }
 
-	  if (check_breakpoints (stop_pc) != 0)
+	  /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
+	     thread library?  */
+	  if (WIFSTOPPED (wstat)
+	      && (WSTOPSIG (wstat) == SIGRTMIN
+		  || WSTOPSIG (wstat) == SIGRTMIN + 1))
 	    {
-	      if (the_low_target.set_pc != NULL)
-		(*the_low_target.set_pc) (stop_pc);
+	      if (debug_threads)
+		fprintf (stderr, "Ignored signal %d for %d (LWP %d).\n",
+			 WSTOPSIG (wstat), event_child->tid,
+			 event_child->head.id);
+	      linux_resume_one_process (&event_child->head,
+					event_child->stepping,
+					WSTOPSIG (wstat));
+	      continue;
+	    }
+	}
 
-	      if (the_low_target.breakpoint_reinsert_addr == NULL)
-		{
-		  linux_bp_reinsert = stop_pc;
-		  uninsert_breakpoint (stop_pc);
-		  linux_resume (1, 0);
-		}
-	      else
-		{
-		  reinsert_breakpoint_by_bp
-		    (stop_pc, (*the_low_target.breakpoint_reinsert_addr) ());
-		  linux_resume (0, 0);
-		}
+      /* If this event was not handled above, and is not a SIGTRAP, report
+	 it.  */
+      if (!WIFSTOPPED (wstat) || WSTOPSIG (wstat) != SIGTRAP)
+	return wstat;
 
-	      continue;
+      /* 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;
+
+      stop_pc = get_stop_pc ();
+
+      /* bp_reinsert will only be set if we were single-stepping.
+	 Notice that we will resume the process after hitting
+	 a gdbserver breakpoint; single-stepping to/over one
+	 is not supported (yet).  */
+      if (event_child->bp_reinsert != 0)
+	{
+	  if (debug_threads)
+	    fprintf (stderr, "Reinserted breakpoint.\n");
+	  reinsert_breakpoint (event_child->bp_reinsert);
+	  event_child->bp_reinsert = 0;
+
+	  /* Clear the single-stepping flag and SIGTRAP as we resume.  */
+	  linux_resume_one_process (&event_child->head, 0, 0);
+	  continue;
+	}
+
+      if (debug_threads)
+	fprintf (stderr, "Hit a (non-reinsert) breakpoint.\n");
+
+      if (check_breakpoints (stop_pc) != 0)
+	{
+	  /* We hit one of our own breakpoints.  We mark it as a pending
+	     breakpoint, so that check_removed_breakpoints () will do the PC
+	     adjustment for us at the appropriate time.  */
+	  event_child->pending_is_breakpoint = 1;
+	  event_child->pending_stop_pc = stop_pc;
+
+	  /* Now we need to put the breakpoint back.  We continue in the event
+	     loop instead of simply replacing the breakpoint right away,
+	     in order to not lose signals sent to the thread that hit the
+	     breakpoint.  Unfortunately this increases the window where another
+	     thread could sneak past the removed breakpoint.  For the current
+	     use of server-side breakpoints (thread creation) this is
+	     acceptable; but it needs to be considered before this breakpoint
+	     mechanism can be used in more general ways.  For some breakpoints
+	     it may be necessary to stop all other threads, but that should
+	     be avoided where possible.
+
+	     If breakpoint_reinsert_addr is NULL, that means that we can
+	     use PTRACE_SINGLESTEP on this platform.  Uninsert the breakpoint,
+	     mark it for reinsertion, and single-step.
+
+	     Otherwise, call the target function to figure out where we need
+	     our temporary breakpoint, create it, and continue executing this
+	     process.  */
+	  if (the_low_target.breakpoint_reinsert_addr == NULL)
+	    {
+	      event_child->bp_reinsert = stop_pc;
+	      uninsert_breakpoint (stop_pc);
+	      linux_resume_one_process (&event_child->head, 1, 0);
+	    }
+	  else
+	    {
+	      reinsert_breakpoint_by_bp
+		(stop_pc, (*the_low_target.breakpoint_reinsert_addr) ());
+	      linux_resume_one_process (&event_child->head, 0, 0);
 	    }
+
+	  continue;
+	}
+
+      /* If we were single-stepping, we definitely want to report the
+	 SIGTRAP.  The single-step operation has completed, so also
+         clear the stepping flag; in general this does not matter, 
+	 because the SIGTRAP will be reported to the client, which
+	 will give us a new action for this thread, but clear it for
+	 consistency anyway.  It's safe to clear the stepping flag
+         because the only consumer of get_stop_pc () after this point
+	 is check_removed_breakpoints, and pending_is_breakpoint is not
+	 set.  It might be wiser to use a step_completed flag instead.  */
+      if (event_child->stepping)
+	{
+	  event_child->stepping = 0;
+	  return wstat;
+	}
+
+      /* 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
+	 accordingly.  This will handle both the necessary fiddling with the
+	 PC on decr_pc_after_break targets and suppressing extra threads
+	 hitting a breakpoint if two hit it at once and then GDB removes it
+	 after the first is reported.  Arguably it would be better to report
+	 multiple threads hitting breakpoints simultaneously, but the current
+	 remote protocol does not allow this.  */
+      if ((*the_low_target.breakpoint_at) (stop_pc))
+	{
+	  event_child->pending_is_breakpoint = 1;
+	  event_child->pending_stop_pc = stop_pc;
 	}
 
       return wstat;
     }
+
   /* NOTREACHED */
   return 0;
 }
 
-/* Wait for process, returns status */
+/* Wait for process, returns status.  */
 
 static unsigned char
 linux_wait (char *status)
 {
   int w;
+  struct thread_info *child = NULL;
+
+retry:
+  /* 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)
+    {
+      child = (struct thread_info *) find_inferior_id (&all_threads,
+						       cont_thread);
+
+      /* No stepping, no signal - unless one is pending already, of course.  */
+      if (child == NULL)
+	linux_resume (0, 0);
+    }
 
   enable_async_io ();
-  w = linux_wait_for_one_inferior (current_inferior);
+  w = linux_wait_for_event (child);
+  stop_all_processes ();
   disable_async_io ();
 
-  if (WIFEXITED (w))
+  /* 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,
+     do not report it as exited until there is a 'thread exited' response
+     available in the remote protocol.  Instead, just wait for another event.
+     This should be safe, because if the thread crashed we will already
+     have reported the termination signal to GDB; that should stop any
+     in-progress stepping operations, etc.
+
+     Report the exit status of the last thread to exit.  This matches
+     LinuxThreads' behavior.  */
+
+  if (all_threads.head == all_threads.tail)
     {
-      fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
-      *status = 'W';
-      clear_inferiors ();
-      return ((unsigned char) WEXITSTATUS (w));
+      if (WIFEXITED (w))
+	{
+	  fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
+	  *status = 'W';
+	  clear_inferiors ();
+	  return ((unsigned char) WEXITSTATUS (w));
+	}
+      else if (!WIFSTOPPED (w))
+	{
+	  fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
+	  clear_inferiors ();
+	  *status = 'X';
+	  return ((unsigned char) WTERMSIG (w));
+	}
     }
-  else if (!WIFSTOPPED (w))
+  else
     {
-      fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
-      clear_inferiors ();
-      *status = 'X';
-      return ((unsigned char) WTERMSIG (w));
+      if (!WIFSTOPPED (w))
+	goto retry;
     }
 
-  fetch_inferior_registers (0);
-
   *status = 'T';
   return ((unsigned char) WSTOPSIG (w));
 }
 
+static void
+send_sigstop (struct inferior_list_entry *entry)
+{
+  struct process_info *process = (struct process_info *) entry;
+
+  if (process->stopped)
+    return;
+
+  /* If we already have a pending stop signal for this process, don't
+     send another.  */
+  if (process->stop_expected)
+    {
+      process->stop_expected = 0;
+      return;
+    }
+
+  if (debug_threads)
+    fprintf (stderr, "Sending sigstop to process %d\n", process->head.id);
+
+  kill (process->head.id, SIGSTOP);
+  process->sigstop_sent = 1;
+}
+
+static void
+wait_for_sigstop (struct inferior_list_entry *entry)
+{
+  struct process_info *process = (struct process_info *) entry;
+  struct thread_info *saved_inferior, *thread;
+  int wstat, saved_tid;
+
+  if (process->stopped)
+    return;
+
+  saved_inferior = current_inferior;
+  saved_tid = ((struct inferior_list_entry *) saved_inferior)->id;
+  thread = (struct thread_info *) find_inferior_id (&all_threads,
+						    process->tid);
+  wstat = linux_wait_for_event (thread);
+
+  /* If we stopped with a non-SIGSTOP signal, save it for later
+     and record the pending SIGSTOP.  If the process exited, just
+     return.  */
+  if (WIFSTOPPED (wstat)
+      && WSTOPSIG (wstat) != SIGSTOP)
+    {
+      if (debug_threads)
+	fprintf (stderr, "Stopped with non-sigstop signal\n");
+      process->status_pending_p = 1;
+      process->status_pending = wstat;
+      process->stop_expected = 1;
+    }
+
+  if (linux_thread_alive (saved_tid))
+    current_inferior = saved_inferior;
+  else
+    {
+      if (debug_threads)
+	fprintf (stderr, "Previously current thread died.\n");
+
+      /* Set a valid thread as current.  */
+      set_desired_inferior (0);
+    }
+}
+
+static void
+stop_all_processes (void)
+{
+  stopping_threads = 1;
+  for_each_inferior (&all_processes, send_sigstop);
+  for_each_inferior (&all_processes, wait_for_sigstop);
+  stopping_threads = 0;
+}
+
 /* Resume execution of the inferior process.
    If STEP is nonzero, single-step it.
    If SIGNAL is nonzero, give it that signal.  */
 
 static void
-linux_resume (int step, int signal)
+linux_resume_one_process (struct inferior_list_entry *entry,
+			  int step, int signal)
 {
+  struct process_info *process = (struct process_info *) entry;
+  struct thread_info *saved_inferior;
+
+  if (process->stopped == 0)
+    return;
+
+  /* If we have pending signals or status, and a new signal, enqueue the
+     signal.  Also enqueue the signal if we are waiting to reinsert a
+     breakpoint; it will be picked up again below.  */
+  if (signal != 0
+      && (process->status_pending_p || process->pending_signals != NULL
+	  || process->bp_reinsert != 0))
+    {
+      struct pending_signals *p_sig;
+      p_sig = malloc (sizeof (*p_sig));
+      p_sig->prev = process->pending_signals;
+      p_sig->signal = signal;
+      process->pending_signals = p_sig;
+    }
+
+  if (process->status_pending_p)
+    return;
+
+  saved_inferior = current_inferior;
+  current_inferior = get_process_thread (process);
+
+  if (debug_threads)
+    fprintf (stderr, "Resuming process %d (%s, signal %d, stop %s)\n", inferior_pid,
+	     step ? "step" : "continue", signal,
+	     process->stop_expected ? "expected" : "not expected");
+
+  /* This bit needs some thinking about.  If we get a signal that
+     we must report while a single-step reinsert is still pending,
+     we often end up resuming the thread.  It might be better to
+     (ew) allow a stack of pending events; then we could be sure that
+     the reinsert happened right away and not lose any signals.
+
+     Making this stack would also shrink the window in which breakpoints are
+     uninserted (see comment in linux_wait_for_process) but not enough for
+     complete correctness, so it won't solve that problem.  It may be
+     worthwhile just to solve this one, however.  */
+  if (process->bp_reinsert != 0)
+    {
+      if (debug_threads)
+	fprintf (stderr, "  pending reinsert at %08lx", (long)process->bp_reinsert);
+      if (step == 0)
+	fprintf (stderr, "BAD - reinserting but not stepping.\n");
+      step = 1;
+
+      /* Postpone any pending signal.  It was enqueued above.  */
+      signal = 0;
+    }
+
+  check_removed_breakpoint (process);
+
+  if (debug_threads && the_low_target.get_pc != NULL) 
+    {
+      fprintf (stderr, "  ");
+      (long) (*the_low_target.get_pc) ();
+    }
+
+  /* If we have pending signals, consume one unless we are trying to reinsert
+     a breakpoint.  */
+  if (process->pending_signals != NULL && process->bp_reinsert == 0)
+    {
+      struct pending_signals **p_sig;
+
+      p_sig = &process->pending_signals;
+      while ((*p_sig)->prev != NULL)
+	p_sig = &(*p_sig)->prev;
+
+      signal = (*p_sig)->signal;
+      free (*p_sig);
+      *p_sig = NULL;
+    }
+
+  regcache_invalidate_one ((struct inferior_list_entry *)
+			   get_process_thread (process));
   errno = 0;
-  ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, inferior_pid, 1, signal);
+  process->stopped = 0;
+  process->stepping = step;
+  ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, process->lwpid, 0, signal);
+
+  current_inferior = saved_inferior;
   if (errno)
     perror_with_name ("ptrace");
 }
 
+/* This function is called once per process other than the first
+   one.  The first process we are told the signal to continue
+   with, and whether to step or continue; for all others, any
+   existing signals will be marked in status_pending_p to be
+   reported momentarily, and we preserve the stepping flag.  */
+static void
+linux_continue_one_process (struct inferior_list_entry *entry)
+{
+  struct process_info *process;
 
-#ifdef HAVE_LINUX_USRREGS
+  process = (struct process_info *) entry;
+  linux_resume_one_process (entry, process->stepping, 0);
+}
+
+static void
+linux_resume (int step, int signal)
+{
+  struct process_info *process;
+
+  process = get_thread_process (current_inferior);
+
+  /* If the current process has a status pending, this signal will
+     be enqueued and sent later.  */
+  linux_resume_one_process (&process->head, step, signal);
 
-#define REGISTER_RAW_SIZE(regno) register_size((regno))
+  if (cont_thread == 0 || cont_thread == -1)
+    for_each_inferior (&all_processes, linux_continue_one_process);
+}
+
+#ifdef HAVE_LINUX_USRREGS
 
 int
 register_addr (int regnum)
@@ -262,6 +904,7 @@ fetch_register (int regno)
 {
   CORE_ADDR regaddr;
   register int i;
+  char *buf;
 
   if (regno >= the_low_target.num_regs)
     return;
@@ -271,10 +914,11 @@ fetch_register (int regno)
   regaddr = register_addr (regno);
   if (regaddr == -1)
     return;
-  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
+  buf = alloca (register_size (regno));
+  for (i = 0; i < register_size (regno); i += sizeof (PTRACE_XFER_TYPE))
     {
       errno = 0;
-      *(PTRACE_XFER_TYPE *) (register_data (regno) + i) =
+      *(PTRACE_XFER_TYPE *) (buf + i) =
 	ptrace (PTRACE_PEEKUSER, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, 0);
       regaddr += sizeof (PTRACE_XFER_TYPE);
       if (errno != 0)
@@ -288,6 +932,8 @@ fetch_register (int regno)
 	  goto error_exit;
 	}
     }
+  supply_register (regno, buf);
+
 error_exit:;
 }
 
@@ -310,6 +956,7 @@ usr_store_inferior_registers (int regno)
 {
   CORE_ADDR regaddr;
   int i;
+  char *buf;
 
   if (regno >= 0)
     {
@@ -323,11 +970,13 @@ usr_store_inferior_registers (int regno)
       if (regaddr == -1)
 	return;
       errno = 0;
-      for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
+      buf = alloca (register_size (regno));
+      collect_register (regno, buf);
+      for (i = 0; i < register_size (regno); i += sizeof (PTRACE_XFER_TYPE))
 	{
 	  errno = 0;
 	  ptrace (PTRACE_POKEUSER, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
-		  *(int *) (register_data (regno) + i));
+		  *(int *) (buf + i));
 	  if (errno != 0)
 	    {
 	      if ((*the_low_target.cannot_store_register) (regno) == 0)
@@ -345,7 +994,7 @@ usr_store_inferior_registers (int regno)
     }
   else
     for (regno = 0; regno < the_low_target.num_regs; regno++)
-      store_inferior_registers (regno);
+      usr_store_inferior_registers (regno);
 }
 #endif /* HAVE_LINUX_USRREGS */
 
@@ -354,7 +1003,7 @@ usr_store_inferior_registers (int regno)
 #ifdef HAVE_LINUX_REGSETS
 
 static int
-regsets_fetch_inferior_registers (void)
+regsets_fetch_inferior_registers ()
 {
   struct regset_info *regset;
 
@@ -392,7 +1041,10 @@ regsets_fetch_inferior_registers (void)
 	    }
 	  else
 	    {
-	      perror ("Warning: ptrace(regsets_fetch_inferior_registers)");
+	      char s[256];
+	      sprintf (s, "ptrace(regsets_fetch_inferior_registers) PID=%d",
+		       inferior_pid);
+	      perror (s);
 	    }
 	}
       regset->store_function (buf);
@@ -402,7 +1054,7 @@ regsets_fetch_inferior_registers (void)
 }
 
 static int
-regsets_store_inferior_registers (void)
+regsets_store_inferior_registers ()
 {
   struct regset_info *regset;
 
@@ -528,6 +1180,11 @@ linux_write_memory (CORE_ADDR memaddr, const char *myaddr, int len)
   register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
   extern int errno;
 
+  if (debug_threads)
+    {
+      fprintf (stderr, "Writing %02x to %08lx\n", (unsigned)myaddr[0], (long)memaddr);
+    }
+
   /* Fill start and end extra bytes of buffer with existing memory data.  */
 
   buffer[0] = ptrace (PTRACE_PEEKTEXT, inferior_pid,
@@ -562,7 +1219,40 @@ linux_write_memory (CORE_ADDR memaddr, const char *myaddr, int len)
 static void
 linux_look_up_symbols (void)
 {
-  /* Don't need to look up any symbols yet.  */
+#ifdef USE_THREAD_DB
+  if (using_threads)
+    return;
+
+  using_threads = thread_db_init ();
+#endif
+}
+
+/* Return 1 if this process is not stopped.  */
+static int
+unstopped_p (struct inferior_list_entry *entry, void *dummy)
+{
+  struct process_info *process = (struct process_info *) entry;
+
+  if (process->stopped)
+    return 0;
+
+  return 1;
+}
+
+static int
+linux_signal_pid ()
+{
+  struct inferior_list_entry *process;
+
+  process = find_inferior (&all_processes, unstopped_p, NULL);
+
+  if (process == NULL)
+    {
+      warning ("no unstopped process");
+      return inferior_pid;
+    }
+
+  return pid_of ((struct process_info *) process);
 }
 
 
@@ -578,13 +1268,24 @@ static struct target_ops linux_target_ops = {
   linux_read_memory,
   linux_write_memory,
   linux_look_up_symbols,
+  linux_signal_pid,
 };
 
+static void
+linux_init_signals ()
+{
+  /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
+     to find what the cancel signal actually is.  */
+  signal (SIGRTMIN+1, SIG_IGN);
+}
+
 void
 initialize_low (void)
 {
+  using_threads = 0;
   set_target_ops (&linux_target_ops);
   set_breakpoint_data (the_low_target.breakpoint,
 		       the_low_target.breakpoint_len);
   init_registers ();
+  linux_init_signals ();
 }