Fix handling of non-waitable zombie threads. Now they are not

considered running, so WaitStop doesn't lock up and
breakpoints get installed and uninstalled.  We also don't try
to detach from them, since that will fail.

R=rsc
APPROVED=rsc
DELTA=35  (26 added, 2 deleted, 7 changed)
OCL=31683
CL=31731

usr/austin/ptrace/ptrace-nptl.txt

@@ -115,7 +115,8 @@ don't think the process is done until all of the threads have exited.
 Unfortunately, signals cannot be delivered to non-waitable zombies.
 Most notably, SIGSTOP cannot be delivered; as a result, when you
 broadcast SIGSTOP to all of the threads, you must not wait for
-non-waitable zombies to stop.
+non-waitable zombies to stop.  Furthermore, any ptrace command on a
+non-waitable zombie, including PTRACE_DETACH, will return ESRCH.
 
 == Multi-threaded debuggers ==
 

usr/austin/ptrace/ptrace_linux.go

@@ -43,7 +43,21 @@ const (
  */
 
 // Each thread can be in one of the following set of states.
-// Each state satisfies (isRunning() || isStopped() || isTerminal()).
+// Each state satisfies
+//  isRunning() || isStopped() || isZombie() || isTerminal().
+//
+// Running threads can be sent signals and must be waited on, but they
+// cannot be inspected using ptrace.
+//
+// Stopped threads can be inspected and continued, but cannot be
+// meaningfully waited on.  They can be sent signals, but the signals
+// will be queued until they are running again.
+//
+// Zombie threads cannot be inspected, continued, or sent signals (and
+// therefore they cannot be stopped), but they must be waited on.
+//
+// Terminal threads no longer exist in the OS and thus you can't do
+// anything with them.
 type threadState string;
 
 const (
@@ -61,13 +75,17 @@ const (
 )
 
 func (ts threadState) isRunning() bool {
-	return ts == running || ts == singleStepping || ts == stopping || ts == exiting;
+	return ts == running || ts == singleStepping || ts == stopping;
 }
 
 func (ts threadState) isStopped() bool {
 	return ts == stopped || ts == stoppedBreakpoint || ts == stoppedSignal || ts == stoppedThreadCreate || ts == stoppedExiting;
 }
 
+func (ts threadState) isZombie() bool {
+	return ts == exiting;
+}
+
 func (ts threadState) isTerminal() bool {
 	return ts == exited || ts == detached;
 }
@@ -429,7 +447,7 @@ func (t *thread) setState(new threadState) {
 	t.state = new;
 	t.logTrace("state %v -> %v", old, new);
 
-	if !old.isRunning() && new.isRunning() {
+	if !old.isRunning() && (new.isRunning() || new.isZombie()) {
 		// Start waiting on this thread
 		go t.wait();
 	}
@@ -1020,8 +1038,12 @@ func (p *process) Continue() os.Error {
 			if err != nil {
 				return err;
 			}
+			if t.state == stoppedExiting {
+				t.setState(exiting);
+			} else {
 				t.setState(running);
 			}
+		}
 		return nil;
 	});
 	if err != nil {
@@ -1050,8 +1072,6 @@ func (p *process) WaitStop() os.Error {
 		h := &transitionHandler{};
 		h.handle = func (st *thread, old, new threadState) {
 			if !new.isRunning() {
-				// TODO(austin) This gets stuck on
-				// zombie threads.
 				if p.someRunningThread() == nil {
 					ready <- nil;
 					return;
@@ -1094,9 +1114,12 @@ func (p *process) Detach() os.Error {
 		}
 
 		for pid, t := range p.threads {
+			if t.state.isStopped() {
+				// We can't detach from zombies.
 				if err := t.ptraceDetach(); err != nil {
 					return err;
 				}
+			}
 			t.setState(detached);
 			p.threads[pid] = nil, false;
 		}