Changes from the FSF for Hurd thread support.

[binutils.git] / gdb / gnu-nat.c

diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
index 2d9cbed9f9d1e9edf55d290a21ea855ddc0fd5c0..55953c0f334cc583a032fe1afdbad3842fe37164 100644 (file)
--- a/gdb/gnu-nat.c
+++ b/gdb/gnu-nat.c
@@ -49,6 +49,8 @@
 #include <hurd/interrupt.h>
 #include <hurd/sigpreempt.h>
 
 #include <hurd/interrupt.h>
 #include <hurd/sigpreempt.h>
 

+#include <portinfo.h>
+

 #include "defs.h"
 #include "inferior.h"
 #include "symtab.h"
 #include "defs.h"
 #include "inferior.h"
 #include "symtab.h"


@@ -217,10 +219,14 @@ struct inf
      (pausing individual threads as necessary).  */
   int pause_sc;
 
      (pausing individual threads as necessary).  */
   int pause_sc;
 

+  /* The task suspend count left when detaching from a task.  */
+  int detach_sc;
+

   /* The initial values used for the run_sc and pause_sc of newly discovered
      threads -- see the definition of those fields in struct proc.  */
   int default_thread_run_sc;
   int default_thread_pause_sc;
   /* The initial values used for the run_sc and pause_sc of newly discovered
      threads -- see the definition of those fields in struct proc.  */
   int default_thread_run_sc;
   int default_thread_pause_sc;

+  int default_thread_detach_sc;

 
   /* True if the process should be traced when started/attached.  Newly
      started processes *must* be traced at first to exec them properly, but
 
   /* True if the process should be traced when started/attached.  Newly
      started processes *must* be traced at first to exec them properly, but


@@ -255,7 +261,7 @@ proc_update_sc (struct proc *proc)
       assert (proc_is_thread (proc));
       proc_debug (proc, "storing back changed thread state");
       err = thread_set_state (proc->port, THREAD_STATE_FLAVOR,
       assert (proc_is_thread (proc));
       proc_debug (proc, "storing back changed thread state");
       err = thread_set_state (proc->port, THREAD_STATE_FLAVOR,

-                             &proc->state, THREAD_STATE_SIZE);
+                             (thread_state_t)&proc->state, THREAD_STATE_SIZE);

       if (! err)
        proc->state_changed = 0;
     }
       if (! err)
        proc->state_changed = 0;
     }


@@ -353,7 +359,7 @@ proc_get_state (struct proc *proc, int will_modify)
       mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
       error_t err =
        thread_get_state (proc->port, THREAD_STATE_FLAVOR,
       mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
       error_t err =
        thread_get_state (proc->port, THREAD_STATE_FLAVOR,

-                         &proc->state, &state_size);
+                         (thread_state_t)&proc->state, &state_size);

       proc_debug (proc, "getting thread state");
       proc->state_valid = !err;
     }
       proc_debug (proc, "getting thread state");
       proc->state_valid = !err;
     }


@@ -362,7 +368,7 @@ proc_get_state (struct proc *proc, int will_modify)
     {
       if (will_modify)
        proc->state_changed = 1;
     {
       if (will_modify)
        proc->state_changed = 1;

-      return &proc->state;
+      return (thread_state_t)&proc->state;

     }
   else
     return 0;
     }
   else
     return 0;


@@ -524,12 +530,19 @@ make_proc (struct inf *inf, mach_port_t port, int tid)
   proc->next = 0;
   proc->saved_exc_port = MACH_PORT_NULL;
   proc->exc_port = MACH_PORT_NULL;
   proc->next = 0;
   proc->saved_exc_port = MACH_PORT_NULL;
   proc->exc_port = MACH_PORT_NULL;

+

   proc->sc = 0;
   proc->cur_sc = 0;
   proc->sc = 0;
   proc->cur_sc = 0;

+
+  /* Note that these are all the values for threads; the task simply uses the
+     corresponding field in INF directly.  */

   proc->run_sc = inf->default_thread_run_sc;
   proc->pause_sc = inf->default_thread_pause_sc;
   proc->run_sc = inf->default_thread_run_sc;
   proc->pause_sc = inf->default_thread_pause_sc;

+  proc->detach_sc = inf->default_thread_detach_sc;

   proc->resume_sc = proc->run_sc;
   proc->resume_sc = proc->run_sc;

+

   proc->aborted = 0;
   proc->aborted = 0;

+  proc->dead = 0;

   proc->state_valid = 0;
   proc->state_changed = 0;
 
   proc->state_valid = 0;
   proc->state_changed = 0;
 


@@ -623,8 +636,10 @@ struct inf *make_inf ()
   inf->no_wait = 0;
   inf->pending_execs = 0;
   inf->pause_sc = 1;
   inf->no_wait = 0;
   inf->pending_execs = 0;
   inf->pause_sc = 1;

+  inf->detach_sc = 0;

   inf->default_thread_run_sc = 0;
   inf->default_thread_pause_sc = 0;
   inf->default_thread_run_sc = 0;
   inf->default_thread_pause_sc = 0;

+  inf->default_thread_detach_sc = 0;

   inf->want_signals = 1;       /* By default */
   inf->want_exceptions = 1;    /* By default */
 
   inf->want_signals = 1;       /* By default */
   inf->want_exceptions = 1;    /* By default */
 


@@ -733,8 +748,9 @@ inf_validate_stopped (struct inf *inf)
   mach_msg_type_number_t noise_len = 0;
   struct procinfo *pi;
   mach_msg_type_number_t pi_len = 0;
   mach_msg_type_number_t noise_len = 0;
   struct procinfo *pi;
   mach_msg_type_number_t pi_len = 0;

+  int info_flags = 0;

   error_t err =
   error_t err =

-    proc_getprocinfo (proc_server, inf->pid, 0,
+    proc_getprocinfo (proc_server, inf->pid, &info_flags,

                      (procinfo_t *)&pi, &pi_len, &noise, &noise_len);
 
   if (! err)
                      (procinfo_t *)&pi, &pi_len, &noise, &noise_len);
 
   if (! err)


@@ -746,17 +762,31 @@ inf_validate_stopped (struct inf *inf)
     }
 }
 
     }
 }
 

-/* Validates INF's task suspend count.  */
+/* Validates INF's task suspend count.  If it's higher than we expect, verify
+   with the user before `stealing' the extra count.  */

 static void
 inf_validate_task_sc (struct inf *inf)
 {
   struct task_basic_info info;
   mach_msg_type_number_t info_len = TASK_BASIC_INFO_COUNT;
 static void
 inf_validate_task_sc (struct inf *inf)
 {
   struct task_basic_info info;
   mach_msg_type_number_t info_len = TASK_BASIC_INFO_COUNT;

-  error_t err = task_info (inf->task->port, TASK_BASIC_INFO, &info, &info_len);
-  if (! err)
+  error_t err =
+    task_info (inf->task->port, TASK_BASIC_INFO, (task_info_t)&info, &info_len);
+
+  if (err)
+    inf->task->dead = 1;       /* oh well */
+  else if (inf->task->cur_sc < info.suspend_count)

     {
     {

-      if (inf->task->cur_sc < info.suspend_count)
-       warning ("Pid %d is suspended; continuing will clear existing suspend count.", inf->pid);
+      int abort;
+
+      target_terminal_ours (); /* Allow I/O.  */
+      abort =
+       !query ("Pid %d has an additional task suspend count of %d; clear it? ",
+               inf->pid, info.suspend_count - inf->task->cur_sc);
+      target_terminal_inferior (); /* Give it back to the child.  */
+
+      if (abort)
+       error ("Additional task suspend count left untouched.");
+

       inf->task->cur_sc = info.suspend_count;
     }
 }
       inf->task->cur_sc = info.suspend_count;
     }
 }


@@ -768,16 +798,20 @@ void
 inf_set_traced (struct inf *inf, int on)
 {
   if (on != inf->traced)
 inf_set_traced (struct inf *inf, int on)
 {
   if (on != inf->traced)

-    if (inf->task)
+    if (inf->task && !inf->task->dead)

       /* Make it take effect immediately.  */
       {
       /* Make it take effect immediately.  */
       {

-       error_t (*f)(mach_port_t, mach_port_t, int) =
-         on ? msg_set_some_exec_flags : msg_clear_some_exec_flags;
+       sigset_t mask = on ? ~(sigset_t)0 : 0;

        error_t err =
        error_t err =

-         INF_RESUME_MSGPORT_RPC (inf, (*f)(msgport, refport, EXEC_TRACED));
+         INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
+                                                        INIT_TRACEMASK, mask));

        if (err == EIEIO)
        if (err == EIEIO)

-         warning ("Can't modify tracing state for pid %d: No signal thread",
-                  inf->pid);
+         {
+           if (on)
+             warning ("Can't modify tracing state for pid %d: No signal thread",
+                      inf->pid);
+           inf->traced = on;
+         }

        else if (err)
          warning ("Can't modify tracing state for pid %d: %s",
                   inf->pid, strerror (err));
        else if (err)
          warning ("Can't modify tracing state for pid %d: %s",
                   inf->pid, strerror (err));


@@ -875,7 +909,11 @@ inf_validate_procs (struct inf *inf)
   unsigned num_threads;
   struct proc *task = inf->task;
 
   unsigned num_threads;
   struct proc *task = inf->task;
 

-  inf->threads_up_to_date = !inf->running;
+  /* If no threads are currently running, this function will guarantee that
+     things are up to date.  The exception is if there are zero threads --
+     then it is almost certainly in an odd state, and probably some outside
+     agent will create threads.  */
+  inf->threads_up_to_date = inf->threads ? !inf->running : 0;

 
   if (task)
     {
 
   if (task)
     {


@@ -884,9 +922,8 @@ inf_validate_procs (struct inf *inf)
       if (err)
        /* TASK must be dead.  */
        {
       if (err)
        /* TASK must be dead.  */
        {

-         task->port = MACH_PORT_NULL;
-         _proc_free (task);
-         task = inf->task = 0;
+         task->dead = 1;
+         task = 0;

        }
     }
 
        }
     }
 


@@ -996,7 +1033,14 @@ inf_resume (struct inf *inf)
     thread->sc = thread->resume_sc;
 
   if (inf->task)
     thread->sc = thread->resume_sc;
 
   if (inf->task)

-    inf->task->sc = 0;
+    {
+      if (! inf->pending_execs)
+       /* Try to make sure our task count is correct -- in the case where
+          we're waiting for an exec though, things are too volatile, so just
+          assume things will be reasonable (which they usually will be).  */
+       inf_validate_task_sc (inf);
+      inf->task->sc = 0;
+    }

 
   inf_update_suspends (inf);
 }
 
   inf_update_suspends (inf);
 }


@@ -1087,12 +1131,12 @@ inf_detach (struct inf *inf)
        inf_signal (inf, TARGET_SIGNAL_0);
 
       proc_restore_exc_port (task);
        inf_signal (inf, TARGET_SIGNAL_0);
 
       proc_restore_exc_port (task);

-      task->sc = 0;
+      task->sc = inf->detach_sc;

 
       for (thread = inf->threads; thread; thread = thread->next)
        {
          proc_restore_exc_port (thread);
 
       for (thread = inf->threads; thread; thread = thread->next)
        {
          proc_restore_exc_port (thread);

-         thread->sc = 0;
+         thread->sc = thread->detach_sc;

        }
 
       inf_update_suspends (inf);
        }
 
       inf_update_suspends (inf);


@@ -1188,7 +1232,7 @@ inf_signal (struct inf *inf, enum target_signal sig)
                                     e->exception, e->code, e->subcode);
        }
       else
                                     e->exception, e->code, e->subcode);
        }
       else

-       warning ("Can't forward spontaneous exception (%s).", NAME);
+       error ("Can't forward spontaneous exception (%s).", NAME);

     }
   else
     /* A Unix signal.  */
     }
   else
     /* A Unix signal.  */


@@ -1202,7 +1246,7 @@ inf_signal (struct inf *inf, enum target_signal sig)
                           msg_sig_post_untraced_request (msgport,
                                                          inf->event_port,
                                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,
                           msg_sig_post_untraced_request (msgport,
                                                          inf->event_port,
                                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,

-                                                         host_sig,
+                                                         host_sig, 0,

                                                          refport));
        if (! err)
          /* Posting an untraced signal automatically continues it.
                                                          refport));
        if (! err)
          /* Posting an untraced signal automatically continues it.


@@ -1220,9 +1264,8 @@ inf_signal (struct inf *inf, enum target_signal sig)
       {
        inf_debug (inf, "sending %s to unstopped process (so resuming signal thread)", NAME);
        err = 
       {
        inf_debug (inf, "sending %s to unstopped process (so resuming signal thread)", NAME);
        err = 

-         INF_RESUME_MSGPORT_RPC (inf,
-                                 msg_sig_post_untraced (msgport,
-                                                        host_sig, refport));
+         INF_RESUME_MSGPORT_RPC (inf, msg_sig_post_untraced (msgport,
+                                                             host_sig, 0, refport));

       }
 
   if (err == EIEIO)
       }
 
   if (err == EIEIO)


@@ -1254,6 +1297,18 @@ gnu_wait (int tid, struct target_waitstatus *status)
   struct proc *thread;
   struct inf *inf = current_inferior;
 
   struct proc *thread;
   struct inf *inf = current_inferior;
 

+  assert (inf->task);
+
+  if (!inf->threads && !inf->pending_execs)
+    /* No threads!  Assume that maybe some outside agency is frobbing our
+       task, and really look for new threads.  If we can't find any, just tell
+       the user to try again later.  */
+    {
+      inf_validate_procs (inf);
+      if (!inf->threads && !inf->task->dead)
+       error ("There are no threads; try again later.");
+    }
+

   waiting_inf = inf;
 
   inf_debug (inf, "waiting for: %d", tid);
   waiting_inf = inf;
 
   inf_debug (inf, "waiting for: %d", tid);


@@ -1269,7 +1324,7 @@ gnu_wait (int tid, struct target_waitstatus *status)
           outstanding wait request, so we have to cancel the previous one. */
        {
          inf_debug (inf, "cancelling previous wait on pid %d", proc_wait_pid);
           outstanding wait request, so we have to cancel the previous one. */
        {
          inf_debug (inf, "cancelling previous wait on pid %d", proc_wait_pid);

-         interrupt_operation (proc_server);
+         interrupt_operation (proc_server, 0);

        }
 
       err =
        }
 
       err =


@@ -1294,14 +1349,14 @@ gnu_wait (int tid, struct target_waitstatus *status)
      (3) wait reply from the proc server.  */
 
   inf_debug (inf, "waiting for an event...");
      (3) wait reply from the proc server.  */
 
   inf_debug (inf, "waiting for an event...");

-  err = _hurd_intr_rpc_mach_msg (&msg.hdr, MACH_RCV_MSG, 0,
-                                sizeof (struct msg),
-                                inf->event_port, MACH_PORT_NULL);
+  err = mach_msg (&msg.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT,
+                 0, sizeof (struct msg), inf->event_port,
+                 MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);

 
   /* Re-suspend the task.  */
   inf_suspend (inf);
 
 
   /* Re-suspend the task.  */
   inf_suspend (inf);
 

-  if (err == EINTR)
+  if (err == EMACH_RCV_INTERRUPTED)

     inf_debug (inf, "interrupted");
   else if (err)
     error ("Couldn't wait for an event: %s", strerror (err));
     inf_debug (inf, "interrupted");
   else if (err)
     error ("Couldn't wait for an event: %s", strerror (err));


@@ -1339,17 +1394,25 @@ gnu_wait (int tid, struct target_waitstatus *status)
        /* Since gdb is actually counting the number of times the inferior
           stops, expecting one stop per exec, we only return major events
           while execing.  */
        /* Since gdb is actually counting the number of times the inferior
           stops, expecting one stop per exec, we only return major events
           while execing.  */

-       w->suppress = 1;
+       {
+         w->suppress = 1;
+         inf_debug (inf, "pending_execs = %d, ignoring minor event",
+                    inf->pending_execs);
+       }

       else if (kind == TARGET_WAITKIND_STOPPED
               && w->status.value.sig == TARGET_SIGNAL_TRAP)
        /* Ah hah!  A SIGTRAP from the inferior while starting up probably
           means we've succesfully completed an exec!  */
       else if (kind == TARGET_WAITKIND_STOPPED
               && w->status.value.sig == TARGET_SIGNAL_TRAP)
        /* Ah hah!  A SIGTRAP from the inferior while starting up probably
           means we've succesfully completed an exec!  */

-       if (--inf->pending_execs == 0)
-         /* We're done!  */
-         {
-           prune_threads (1);  /* Get rid of the old shell threads */
-           renumber_threads (0); /* Give our threads reasonable names. */
-         }
+       {
+         if (--inf->pending_execs == 0)
+           /* We're done!  */
+           {
+             prune_threads (1);        /* Get rid of the old shell threads */
+             renumber_threads (0); /* Give our threads reasonable names. */
+           }
+         inf_debug (inf, "pending exec completed, pending_execs => %d",
+                    inf->pending_execs);
+       }

     }
 
   if (inf->wait.suppress)
     }
 
   if (inf->wait.suppress)


@@ -1442,9 +1505,15 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
        /* Record the exception so that we can forward it later.  */
        {
          if (thread->exc_port == port)
        /* Record the exception so that we can forward it later.  */
        {
          if (thread->exc_port == port)

-           inf->wait.exc.handler = thread->saved_exc_port;
+           {
+             inf_debug (waiting_inf, "Handler is thread exeption port <%d>",
+                        thread->saved_exc_port);
+             inf->wait.exc.handler = thread->saved_exc_port;
+           }

          else
            {
          else
            {

+             inf_debug (waiting_inf, "Handler is task exeption port <%d>",
+                        inf->task->saved_exc_port);

              inf->wait.exc.handler = inf->task->saved_exc_port;
              assert (inf->task->exc_port == port);
            }
              inf->wait.exc.handler = inf->task->saved_exc_port;
              assert (inf->task->exc_port == port);
            }


@@ -1484,9 +1553,8 @@ inf_task_died_status (struct inf *inf)
   inf->wait.status.kind = TARGET_WAITKIND_SIGNALLED;
   inf->wait.status.value.sig = TARGET_SIGNAL_KILL;
 }
   inf->wait.status.kind = TARGET_WAITKIND_SIGNALLED;
   inf->wait.status.value.sig = TARGET_SIGNAL_KILL;
 }

-\f
-/* Notify server routines.  The only real one is dead name notification.  */

 
 

+/* Notify server routines.  The only real one is dead name notification.  */

 error_t
 do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
 {
 error_t
 do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
 {


@@ -1522,7 +1590,7 @@ do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
 
   return 0;
 }
 
   return 0;
 }

-
+\f

 static error_t
 ill_rpc (char *fun)
 {
 static error_t
 ill_rpc (char *fun)
 {


@@ -1564,12 +1632,12 @@ do_mach_notify_send_once (mach_port_t notify)
 
 error_t
 S_proc_wait_reply (mach_port_t reply, error_t err,
 
 error_t
 S_proc_wait_reply (mach_port_t reply, error_t err,

-                int status, rusage_t rusage, pid_t pid)
+                  int status, int sigcode, rusage_t rusage, pid_t pid)

 {
   struct inf *inf = waiting_inf;
 
 {
   struct inf *inf = waiting_inf;
 

-  inf_debug (inf, "err = %s, pid = %d, status = 0x%x",
-            err ? strerror (err) : "0", pid, status);
+  inf_debug (inf, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
+            err ? strerror (err) : "0", pid, status, sigcode);

 
   if (err && proc_wait_pid && (!inf->task || !inf->task->port))
     /* Ack.  The task has died, but the task-died notification code didn't
 
   if (err && proc_wait_pid && (!inf->task || !inf->task->port))
     /* Ack.  The task has died, but the task-died notification code didn't


@@ -1606,10 +1674,6 @@ S_proc_wait_reply (mach_port_t reply, error_t err,
        {
          inf_debug (inf, "process has stopped itself");
          inf->stopped = 1;
        {
          inf_debug (inf, "process has stopped itself");
          inf->stopped = 1;

-
-         /* We recheck the task suspend count here because the crash server
-            messes with it in an unfriendly way, right before `stopping'.  */
-         inf_validate_task_sc (inf);

        }
     }
   else
        }
     }
   else


@@ -1724,6 +1788,8 @@ gnu_resume (int tid, int step, enum target_signal sig)
        the process, as we're just going to stop it right away anyway. */
     return;
 
        the process, as we're just going to stop it right away anyway. */
     return;
 

+  inf_update_procs (inf);
+

   if (tid < 0)
     /* Allow all threads to run, except perhaps single-stepping one.  */
     {
   if (tid < 0)
     /* Allow all threads to run, except perhaps single-stepping one.  */
     {


@@ -1735,8 +1801,8 @@ gnu_resume (int tid, int step, enum target_signal sig)
     /* Just allow a single thread to run.  */
     {
       struct proc *thread = inf_tid_to_thread (inf, tid);
     /* Just allow a single thread to run.  */
     {
       struct proc *thread = inf_tid_to_thread (inf, tid);

-      assert (thread);
-
+      if (! thread)
+       error ("Can't run single thread id %d: no such thread!");

       inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid);
       inf_set_threads_resume_sc (inf, thread, 0);
     }
       inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid);
       inf_set_threads_resume_sc (inf, thread, 0);
     }


@@ -1744,8 +1810,10 @@ gnu_resume (int tid, int step, enum target_signal sig)
   if (step)
     {
       step_thread = inf_tid_to_thread (inf, tid);
   if (step)
     {
       step_thread = inf_tid_to_thread (inf, tid);

-      assert (step_thread);
-      inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid);
+      if (! step_thread)
+       warning ("Can't step thread id %d: no such thread.", tid);
+      else
+       inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid);

     }
   if (step_thread != inf->step_thread)
     inf_set_step_thread (inf, step_thread);
     }
   if (step_thread != inf->step_thread)
     inf_set_step_thread (inf, step_thread);


@@ -1762,8 +1830,7 @@ gnu_kill_inferior ()
     {
       proc_debug (task, "terminating...");
       task_terminate (task->port);
     {
       proc_debug (task, "terminating...");
       task_terminate (task->port);

-      task->port = MACH_PORT_NULL;
-      inf_validate_procs (current_inferior); /* Clear out the thread list &c */
+      inf_set_task (current_inferior, MACH_PORT_NULL);

     }
   target_mourn_inferior ();
 }
     }
   target_mourn_inferior ();
 }


@@ -1813,9 +1880,10 @@ gnu_create_inferior (exec_file, allargs, env)
     {
       /* We're in the child; make this process stop as soon as it execs.  */
       inf_debug (inf, "tracing self");
     {
       /* We're in the child; make this process stop as soon as it execs.  */
       inf_debug (inf, "tracing self");

-      ptrace (PTRACE_TRACEME, 0, 0, 0);
+      if (ptrace (PTRACE_TRACEME) != 0)
+       error ("ptrace (PTRACE_TRACEME) failed!");

     }
     }

-  void attach_to_child (int pid)
+  int attach_to_child (int pid)

     {
       /* Attach to the now stopped child, which is actually a shell...  */
       inf_debug (inf, "attaching to child: %d", pid);
     {
       /* Attach to the now stopped child, which is actually a shell...  */
       inf_debug (inf, "attaching to child: %d", pid);


@@ -1834,6 +1902,8 @@ gnu_create_inferior (exec_file, allargs, env)
       inf_resume (inf);
 
       startup_inferior (pid, inf->pending_execs);
       inf_resume (inf);
 
       startup_inferior (pid, inf->pending_execs);

+
+      return pid;

     }
 
   inf_debug (inf, "creating inferior");
     }
 
   inf_debug (inf, "creating inferior");


@@ -1912,7 +1982,8 @@ gnu_attach (args, from_tty)
   /* If the process was stopped before we attached, make it continue the next
      time the user does a continue.  */
   inf_validate_stopped (inf);
   /* If the process was stopped before we attached, make it continue the next
      time the user does a continue.  */
   inf_validate_stopped (inf);

-  inf_validate_task_sc (inf);
+
+  renumber_threads (0);                /* Give our threads reasonable names. */

 }
 \f
 /* Take a program previously attached to and detaches it.
 }
 \f
 /* Take a program previously attached to and detaches it.


@@ -2319,6 +2390,19 @@ struct cmd_list_element *show_task_cmd_list = 0;
 extern struct cmd_list_element *set_thread_default_cmd_list;
 extern struct cmd_list_element *show_thread_default_cmd_list;
 
 extern struct cmd_list_element *set_thread_default_cmd_list;
 extern struct cmd_list_element *show_thread_default_cmd_list;
 

+static int
+parse_int_arg (char *args, char *cmd_prefix)
+{
+  if (args)
+    {
+      char *arg_end;
+      int val = strtoul (args, &arg_end, 10);
+      if (*args && *arg_end == '\0')
+       return val;
+    }
+  error ("Illegal argument for \"%s\" command, should be an integer.", cmd_prefix);
+}
+

 static int
 _parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix)
 {
 static int
 _parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix)
 {


@@ -2352,6 +2436,16 @@ cur_thread ()
   return thread;
 }
 
   return thread;
 }
 

+/* Returns the current inferior, but signals an error if it has no task.  */
+static struct inf *
+active_inf ()
+{
+  struct inf *inf = cur_inf ();
+  if (! inf->task)
+    error ("No current process.");
+  return inf;
+}
+\f

 static void
 set_task_pause_cmd (char *args, int from_tty)
 {
 static void
 set_task_pause_cmd (char *args, int from_tty)
 {


@@ -2377,6 +2471,20 @@ show_task_pause_cmd (char *args, int from_tty)
                     : (inf->pause_sc == 0 ? "won't be" : "will be"));
 }
 
                     : (inf->pause_sc == 0 ? "won't be" : "will be"));
 }
 

+static void
+set_task_detach_sc_cmd (char *args, int from_tty)
+{
+  cur_inf ()->detach_sc = parse_int_arg (args, "set task detach-suspend-count");
+}
+
+static void
+show_task_detach_sc_cmd (char *args, int from_tty)
+{
+  check_empty (args, "show task detach-suspend-count");
+  printf_unfiltered ("The inferior task will be left with a suspend count of %d when detaching.\n",
+                    cur_inf ()->detach_sc);
+}
+\f

 static void
 set_thread_default_pause_cmd (char *args, int from_tty)
 {
 static void
 set_thread_default_pause_cmd (char *args, int from_tty)
 {


@@ -2393,7 +2501,7 @@ show_thread_default_pause_cmd (char *args, int from_tty)
   check_empty (args, "show thread default pause");
   printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
                     sc ? "are" : "aren't",
   check_empty (args, "show thread default pause");
   printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
                     sc ? "are" : "aren't",

-                    !sc && inf->pause_sc ? "(but the task is)" : "");
+                    !sc && inf->pause_sc ? " (but the task is)" : "");

 }
 
 static void
 }
 
 static void


@@ -2413,6 +2521,21 @@ show_thread_default_run_cmd (char *args, int from_tty)
                     inf->default_thread_run_sc == 0 ? "are" : "aren't");
 }
 
                     inf->default_thread_run_sc == 0 ? "are" : "aren't");
 }
 

+static void
+set_thread_default_detach_sc_cmd (char *args, int from_tty)
+{
+  cur_inf ()->default_thread_detach_sc =
+    parse_int_arg (args, "set thread default detach-suspend-count");
+}
+
+static void
+show_thread_default_detach_sc_cmd (char *args, int from_tty)
+{
+  check_empty (args, "show thread default detach-suspend-count");
+  printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
+                    cur_inf ()->default_thread_detach_sc);
+}
+\f

 /* Steal a send right called NAME in the inferior task, and make it PROC's
    saved exception port.  */
 static void
 /* Steal a send right called NAME in the inferior task, and make it PROC's
    saved exception port.  */
 static void


@@ -2448,7 +2571,7 @@ steal_exc_port (struct proc *proc, mach_port_t name)
              proc_string (proc), strerror (err));
     }
 }
              proc_string (proc), strerror (err));
     }
 }

-
+\f

 static void
 set_task_exc_port_cmd (char *args, int from_tty)
 {
 static void
 set_task_exc_port_cmd (char *args, int from_tty)
 {


@@ -2458,30 +2581,6 @@ set_task_exc_port_cmd (char *args, int from_tty)
   steal_exc_port (inf->task, parse_and_eval_address (args));
 }
 
   steal_exc_port (inf->task, parse_and_eval_address (args));
 }
 

-static void 
-set_signals_cmd (char *args, int from_tty)
-{
-  int trace;
-  struct inf *inf = cur_inf ();
-
-  inf->want_signals = parse_bool_arg (args, "set signals");
-
-  if (inf->task && inf->want_signals != inf->traced)
-    /* Make this take effect immediately in a running process.  */
-    inf_set_traced (inf, inf->want_signals);
-}
-
-static void
-show_signals_cmd (char *args, int from_tty)
-{
-  struct inf *inf = cur_inf ();
-  check_empty (args, "show signals");
-  printf_unfiltered ("The inferior process's signals %s intercepted.\n",
-                    inf->task
-                    ? (inf->traced ? "are" : "aren't")
-                    : (inf->want_signals ? "will be" : "won't be"));
-}
-

 static void 
 set_stopped_cmd (char *args, int from_tty)
 {
 static void 
 set_stopped_cmd (char *args, int from_tty)
 {


@@ -2491,10 +2590,8 @@ set_stopped_cmd (char *args, int from_tty)
 static void
 show_stopped_cmd (char *args, int from_tty)
 {
 static void
 show_stopped_cmd (char *args, int from_tty)
 {

-  struct inf *inf = cur_inf ();
+  struct inf *inf = active_inf ();

   check_empty (args, "show stopped");
   check_empty (args, "show stopped");

-  if (! inf->task)
-    error ("No current process.");

   printf_unfiltered ("The inferior process %s stopped.\n",
                     inf->stopped ? "is" : "isn't");
 }
   printf_unfiltered ("The inferior process %s stopped.\n",
                     inf->stopped ? "is" : "isn't");
 }


@@ -2524,16 +2621,38 @@ set_sig_thread_cmd (char *args, int from_tty)
 static void
 show_sig_thread_cmd (char *args, int from_tty)
 {
 static void
 show_sig_thread_cmd (char *args, int from_tty)
 {

-  struct inf *inf = cur_inf ();
+  struct inf *inf = active_inf ();

   check_empty (args, "show signal-thread");
   check_empty (args, "show signal-thread");

-  if (! inf->task)
-    error ("No current process.");

   if (inf->signal_thread)
     printf_unfiltered ("The signal thread is %s.\n",
                       proc_string (inf->signal_thread));
   else
     printf_unfiltered ("There is no signal thread.\n");
 }
   if (inf->signal_thread)
     printf_unfiltered ("The signal thread is %s.\n",
                       proc_string (inf->signal_thread));
   else
     printf_unfiltered ("There is no signal thread.\n");
 }

+\f
+static void 
+set_signals_cmd (char *args, int from_tty)
+{
+  int trace;
+  struct inf *inf = cur_inf ();
+
+  inf->want_signals = parse_bool_arg (args, "set signals");
+
+  if (inf->task && inf->want_signals != inf->traced)
+    /* Make this take effect immediately in a running process.  */
+    inf_set_traced (inf, inf->want_signals);
+}
+
+static void
+show_signals_cmd (char *args, int from_tty)
+{
+  struct inf *inf = cur_inf ();
+  check_empty (args, "show signals");
+  printf_unfiltered ("The inferior process's signals %s intercepted.\n",
+                    inf->task
+                    ? (inf->traced ? "are" : "aren't")
+                    : (inf->want_signals ? "will be" : "won't be"));
+}

 
 static void 
 set_exceptions_cmd (char *args, int from_tty)
 
 static void 
 set_exceptions_cmd (char *args, int from_tty)


@@ -2558,7 +2677,7 @@ show_exceptions_cmd (char *args, int from_tty)
                     ? (inf->want_exceptions ? "are" : "aren't")
                     : (inf->want_exceptions ? "will be" : "won't be"));
 }
                     ? (inf->want_exceptions ? "are" : "aren't")
                     : (inf->want_exceptions ? "will be" : "won't be"));
 }

-
+\f

 static void
 set_task_cmd (char *args, int from_tty)
 {
 static void
 set_task_cmd (char *args, int from_tty)
 {


@@ -2585,8 +2704,83 @@ show_task_cmd (char *args, int from_tty)
       show_stopped_cmd (0, from_tty);
       show_sig_thread_cmd (0, from_tty);
     }
       show_stopped_cmd (0, from_tty);
       show_sig_thread_cmd (0, from_tty);
     }

+
+  if (inf->detach_sc != 0)
+    show_task_detach_sc_cmd (0, from_tty);
+  if (inf->default_thread_detach_sc != 0)
+    show_thread_default_detach_sc_cmd (0, from_tty);
+}
+\f
+static void
+set_noninvasive_cmd (char *args, int from_tty)
+{
+  /* Invert the sense of the arg for each component.  */
+  char *inv_args = parse_bool_arg (args, "set noninvasive") ? "off" : "on";
+
+  set_task_pause_cmd (inv_args, from_tty);
+  set_signals_cmd (inv_args, from_tty);
+  set_exceptions_cmd (inv_args, from_tty);
+}
+\f
+static void
+info_port_rights (char *args, mach_port_type_t only)
+{
+  struct inf *inf = active_inf ();
+  value_ptr vmark = value_mark ();
+
+  if (args)
+    /* Explicit list of port rights.  */
+    {
+      while (*args)
+       {
+         value_ptr val = parse_to_comma_and_eval (&args);
+         long right = value_as_long (val);
+         error_t err =
+           print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS,
+                            stdout);
+         if (err)
+           error ("%ld: %s.", right, strerror (err));
+       }
+    }
+  else
+    /* Print all of them.  */
+    {
+      error_t err =
+       print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS,
+                              stdout);
+      if (err)
+       error ("%s.", strerror (err));
+    }
+
+  value_free_to_mark (vmark);

 }
 
 }
 

+static void
+info_send_rights_cmd (char *args, int from_tty)
+{
+  info_port_rights (args, MACH_PORT_TYPE_SEND);
+}
+static void
+info_recv_rights_cmd (char *args, int from_tty)
+{
+  info_port_rights (args, MACH_PORT_TYPE_RECEIVE);
+}
+static void
+info_port_sets_cmd (char *args, int from_tty)
+{
+  info_port_rights (args, MACH_PORT_TYPE_PORT_SET);
+}
+static void
+info_dead_names_cmd (char *args, int from_tty)
+{
+  info_port_rights (args, MACH_PORT_TYPE_DEAD_NAME);
+}
+static void
+info_port_rights_cmd (char *args, int from_tty)
+{
+  info_port_rights (args, ~0);
+}
+\f

 static void add_task_commands ()
 {
   add_cmd ("pause", class_run, set_thread_default_pause_cmd,
 static void add_task_commands ()
 {
   add_cmd ("pause", class_run, set_thread_default_pause_cmd,


@@ -2605,6 +2799,12 @@ static void add_task_commands ()
           "Show whether new threads are allowed to run (once gdb has noticed
 them).",
           &show_thread_default_cmd_list);
           "Show whether new threads are allowed to run (once gdb has noticed
 them).",
           &show_thread_default_cmd_list);

+  add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd,
+          "Set the default detach-suspend-count value for new threads.",
+          &set_thread_default_cmd_list);
+  add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd,
+          "Show the default detach-suspend-count value for new threads.",
+          &show_thread_default_cmd_list);

 
   add_cmd ("signals", class_run, set_signals_cmd,
           "Set whether the inferior process's signals will be intercepted.\n"
 
   add_cmd ("signals", class_run, set_signals_cmd,
           "Set whether the inferior process's signals will be intercepted.\n"


@@ -2645,8 +2845,6 @@ them).",
           "Show whether exceptions in the inferior process will be trapped.",
           &showlist);
 
           "Show whether exceptions in the inferior process will be trapped.",
           &showlist);
 

-  
-

   add_prefix_cmd ("task", no_class, set_task_cmd,
                  "Command prefix for setting task attributes.",
                  &set_task_cmd_list, "set task ", 0, &setlist);
   add_prefix_cmd ("task", no_class, set_task_cmd,
                  "Command prefix for setting task attributes.",
                  &set_task_cmd_list, "set task ", 0, &setlist);


@@ -2664,6 +2862,12 @@ them).",
   add_cmd ("pause", no_class, show_task_pause_cmd,
           "Show whether the task is suspended while gdb has control.",
           &show_task_cmd_list);
   add_cmd ("pause", no_class, show_task_pause_cmd,
           "Show whether the task is suspended while gdb has control.",
           &show_task_cmd_list);

+  add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd,
+          "Set the suspend count will leave on the thread when detaching.",
+          &set_task_cmd_list);
+  add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd,
+          "Show the suspend count will leave on the thread when detaching.",
+          &show_task_cmd_list);

 
   add_cmd ("exception-port", no_class, set_task_exc_port_cmd,
           "Set the task exception port to which we forward exceptions.\n"
 
   add_cmd ("exception-port", no_class, set_task_exc_port_cmd,
           "Set the task exception port to which we forward exceptions.\n"


@@ -2671,12 +2875,41 @@ them).",
           &set_task_cmd_list);
   add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list);
   add_alias_cmd ("exc-port", "exception-port", no_class, 1, &set_task_cmd_list);
           &set_task_cmd_list);
   add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list);
   add_alias_cmd ("exc-port", "exception-port", no_class, 1, &set_task_cmd_list);

+
+  /* A convenient way of turning on all options require to noninvasively
+     debug running tasks.  */
+  add_cmd ("noninvasive", no_class, set_noninvasive_cmd,
+          "Set task options so that we interfere as little as possible.\n"
+          "This is the same as setting `task pause', `exceptions', and"
+          "`signals' to the opposite value.",
+          &setlist);
+
+  /* Commands to show information about the task's ports.  */
+  add_cmd ("send-rights", class_info, info_send_rights_cmd,
+          "Show information about the task's send rights",
+          &infolist);
+  add_cmd ("receive-rights", class_info, info_recv_rights_cmd,
+          "Show information about the task's receive rights",
+          &infolist);
+  add_cmd ("port-rights", class_info, info_send_rights_cmd,
+          "Show information about the task's port rights",
+          &infolist);
+  add_cmd ("port-sets", class_info, info_port_sets_cmd,
+          "Show information about the task's port sets",
+          &infolist);
+  add_cmd ("dead-names", class_info, info_dead_names_cmd,
+          "Show information about the task's dead names",
+          &infolist);
+  add_info_alias ("ports", "port-rights", 1);
+  add_info_alias ("port", "port-rights", 1);
+  add_info_alias ("psets", "port-sets", 1);

 }
 \f
 /* User thread commands.  */
 
 extern struct cmd_list_element *set_thread_cmd_list;
 extern struct cmd_list_element *show_thread_cmd_list;
 }
 \f
 /* User thread commands.  */
 
 extern struct cmd_list_element *set_thread_cmd_list;
 extern struct cmd_list_element *show_thread_cmd_list;

+extern struct cmd_list_element *thread_cmd_list;

 
 static void
 set_thread_pause_cmd (char *args, int from_tty)
 
 static void
 set_thread_pause_cmd (char *args, int from_tty)


@@ -2699,7 +2932,7 @@ show_thread_pause_cmd (char *args, int from_tty)
   printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
                     proc_string (thread),
                     sc ? "is" : "isn't",
   printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
                     proc_string (thread),
                     sc ? "is" : "isn't",

-                    !sc && thread->inf->pause_sc ? "(but the task is)" : "");
+                    !sc && thread->inf->pause_sc ? " (but the task is)" : "");

 }
 
 static void
 }
 
 static void


@@ -2714,11 +2947,27 @@ show_thread_run_cmd (char *args, int from_tty)
 {
   struct proc *thread = cur_thread ();
   check_empty (args, "show thread run");
 {
   struct proc *thread = cur_thread ();
   check_empty (args, "show thread run");

-  printf_unfiltered ("Thread %s allowed to run.",
+  printf_unfiltered ("Thread %s %s allowed to run.",

                     proc_string (thread),
                     thread->run_sc == 0 ? "is" : "isn't");
 }
 
                     proc_string (thread),
                     thread->run_sc == 0 ? "is" : "isn't");
 }
 

+static void
+set_thread_detach_sc_cmd (char *args, int from_tty)
+{
+  cur_thread ()->detach_sc = parse_int_arg (args, "set thread detach-suspend-count");
+}
+
+static void
+show_thread_detach_sc_cmd (char *args, int from_tty)
+{
+  struct proc *thread = cur_thread ();
+  check_empty (args, "show thread detach-suspend-count");
+  printf_unfiltered ("Thread %s will be left with a suspend count of %d when detaching.\n",
+                    proc_string (thread),
+                    thread->detach_sc);
+}
+

 static void
 set_thread_exc_port_cmd (char *args, int from_tty)
 {
 static void
 set_thread_exc_port_cmd (char *args, int from_tty)
 {


@@ -2737,9 +2986,30 @@ set_thread_cmd (char *args, int from_tty)
 static void
 show_thread_cmd (char *args, int from_tty)
 {
 static void
 show_thread_cmd (char *args, int from_tty)
 {

+  struct proc *thread = cur_thread ();

   check_empty (args, "show thread");
   show_thread_run_cmd (0, from_tty);
   show_thread_pause_cmd (0, from_tty);
   check_empty (args, "show thread");
   show_thread_run_cmd (0, from_tty);
   show_thread_pause_cmd (0, from_tty);

+  if (thread->detach_sc != 0)
+    show_thread_detach_sc_cmd (0, from_tty);
+}
+
+static void
+thread_takeover_sc_cmd (char *args, int from_tty)
+{
+  struct proc *thread = cur_thread ();
+  thread_basic_info_data_t _info;
+  thread_basic_info_t info = &_info;
+  mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
+  error_t err =
+    thread_info (thread->port, THREAD_BASIC_INFO, (int *)&info, &info_len);
+  if (err)
+    error ("%s.", strerror (err));
+  thread->sc = info->suspend_count;
+  if (from_tty)
+    printf_unfiltered ("Suspend count was %d.\n", thread->sc);
+  if (info != &_info)
+    vm_deallocate (mach_task_self (), (vm_address_t)info, info_len * sizeof (int));

 }
 
 add_thread_commands ()
 }
 
 add_thread_commands ()


@@ -2763,6 +3033,17 @@ add_thread_commands ()
           "Show whether the current thread is allowed to run.",
           &show_thread_cmd_list);
 
           "Show whether the current thread is allowed to run.",
           &show_thread_cmd_list);
 

+  add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd,
+          "Set the suspend count will leave on the thread when detaching.\n"
+          "Note that this is relative to suspend count when gdb noticed the thread;\n"
+          "use the `thread takeover-suspend-count' to force it to an absolute value.",
+          &set_thread_cmd_list);
+  add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd,
+          "Show the suspend count will leave on the thread when detaching."
+          "Note that this is relative to suspend count when gdb noticed the thread;\n"
+          "use the `thread takeover-suspend-count' to force it to an absolute value.",
+          &show_thread_cmd_list);
+

   add_cmd ("exception-port", no_class, set_thread_exc_port_cmd,
           "Set the exception port to which we forward exceptions for the\n"
           "current thread, overriding the task exception port.\n"
   add_cmd ("exception-port", no_class, set_thread_exc_port_cmd,
           "Set the exception port to which we forward exceptions for the\n"
           "current thread, overriding the task exception port.\n"


@@ -2770,6 +3051,12 @@ add_thread_commands ()
           &set_thread_cmd_list);
   add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list);
   add_alias_cmd ("exc-port", "exception-port", no_class, 1, &set_thread_cmd_list);
           &set_thread_cmd_list);
   add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list);
   add_alias_cmd ("exc-port", "exception-port", no_class, 1, &set_thread_cmd_list);

+
+  add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd,
+          "Force the threads absolute suspend-count to be gdb's.\n"
+          "Prior to giving this command, gdb's thread suspend-counts are relative to\n"
+          "the thread's initial suspend-count when gdb notices the threads.",
+          &thread_cmd_list);

 }
 \f
 void
 }
 \f
 void