* pinfo.h (pinfo::operator ==): Add a way to check for _pinfo types.

* sigproc.cc (proc_subproc): Ensure that zombie is removed when SIGCHLD ==
SIG_IGN but still allow wait()ing threads to wake up.

5 files changed, 20 insertions, 8 deletions

diff --git a/winsup/cygwin/ChangeLog b/winsup/cygwin/ChangeLog
index 291d4ac..e44dd1e 100644
--- a/winsup/cygwin/ChangeLog
+++ b/winsup/cygwin/ChangeLog
@@ -1,3 +1,9 @@
+2003-12-17  Christopher Faylor  <cgf@redhat.com>
+
+	* pinfo.h (pinfo::operator ==): Add a way to check for _pinfo types.
+	* sigproc.cc (proc_subproc): Ensure that zombie is removed when SIGCHLD
+	== SIG_IGN but still allow wait()ing threads to wake up.
+
 2003-12-16  Christopher Faylor  <cgf@redhat.com>
 
 	* exceptions.cc (set_signal_mask): Report on input argument rather than
diff --git a/winsup/cygwin/exceptions.cc b/winsup/cygwin/exceptions.cc
index 341ae73..ffa6d4d 100644
--- a/winsup/cygwin/exceptions.cc
+++ b/winsup/cygwin/exceptions.cc
@@ -792,7 +792,7 @@ signal_fixup_after_fork ()
 extern "C" void __stdcall
 set_sig_errno (int e)
 {
-  set_errno (e);
+  *_my_tls.errno_addr = e;
   _my_tls.saved_errno = e;
   // sigproc_printf ("errno %d", e);
 }
diff --git a/winsup/cygwin/pinfo.h b/winsup/cygwin/pinfo.h
index 2795563..b0ddb67 100644
--- a/winsup/cygwin/pinfo.h
+++ b/winsup/cygwin/pinfo.h
@@ -144,6 +144,7 @@ public:
   _pinfo *operator -> () const {return procinfo;}
   int operator == (pinfo *x) const {return x->procinfo == procinfo;}
   int operator == (pinfo &x) const {return x.procinfo == procinfo;}
+  int operator == (_pinfo *x) const {return x == procinfo;}
   int operator == (void *x) const {return procinfo == x;}
   int operator == (int x) const {return (int) procinfo == (int) x;}
   int operator == (char *x) const {return (char *) procinfo == x;}
diff --git a/winsup/cygwin/sigproc.cc b/winsup/cygwin/sigproc.cc
index 5150e54..78e45e6 100644
--- a/winsup/cygwin/sigproc.cc
+++ b/winsup/cygwin/sigproc.cc
@@ -304,6 +304,8 @@ proc_subproc (DWORD what, DWORD val)
   _pinfo *child;
   int clearing;
   waitq *w;
+  int thiszombie;
+  _pinfo *zombie_proc = NULL;
 
 #define wval	 ((waitq *) val)
 
@@ -375,9 +377,8 @@ proc_subproc (DWORD what, DWORD val)
       sigproc_printf ("pid %d[%d] terminated, handle %p, nchildren %d, nzombies %d",
 		  pchildren[val]->pid, val, hchildren[val], nchildren, nzombies);
 
-      int thiszombie;
       thiszombie = nzombies;
-      zombies[nzombies] = pchildren[val];	// Add to zombie array
+      zombie_proc = zombies[nzombies] = pchildren[val];	// Add to zombie array
       zombies[nzombies++]->process_state = PID_ZOMBIE;// Walking dead
 
       sigproc_printf ("zombifying [%d], pid %d, handle %p, nchildren %d",
@@ -391,11 +392,11 @@ proc_subproc (DWORD what, DWORD val)
       /* See if we should care about the this terminated process.  If we've
 	 filled up our table or if we're ignoring SIGCHLD, then we immediately
 	 remove the process and move on. Otherwise, this process becomes a zombie
-	 which must be reaped by a wait() call. */
-      if (nzombies >= NZOMBIES
-	  || global_sigs[SIGCHLD].sa_handler == (void *) SIG_IGN)
+	 which must be reaped by a wait() call.  FIXME:  This is a very inelegant
+	 way to deal with this and could lead to process hangs.  */
+      if (nzombies >= NZOMBIES)
 	{
-	  sigproc_printf ("automatically removing zombie %d", thiszombie);
+	  sigproc_printf ("zombie table overflow %d", thiszombie);
 	  remove_zombie (thiszombie);
 	}
 
@@ -477,6 +478,10 @@ proc_subproc (DWORD what, DWORD val)
 	sigproc_printf ("finished processing terminated/stopped child");
       else
 	{
+	  if (zombie_proc && zombies[thiszombie]
+	      && zombies[thiszombie] == zombie_proc
+	      && global_sigs[SIGCHLD].sa_handler == (void *) SIG_IGN)
+	    remove_zombie (thiszombie);
 	  waitq_head.next = NULL;
 	  sigproc_printf ("finished clearing");
 	}
diff --git a/winsup/cygwin/wait.cc b/winsup/cygwin/wait.cc
index d3c3416..d7dd1f8 100644
--- a/winsup/cygwin/wait.cc
+++ b/winsup/cygwin/wait.cc
@@ -98,8 +98,8 @@ wait4 (int intpid, int *status, int options, struct rusage *r)
 
       if (w->status == -1)
 	{
-	  call_signal_handler_now ();
 	  set_sig_errno (EINTR);
+	  call_signal_handler_now ();
 	  sawsig = true;
 	  res = -1;
 	}