Throughout use "have_execed" macro rather than "hExeced" global handle.

Throughout rename _PROC_* to _CH_*.
* child_info.h: Include "pinfo.h".
(child_info_types): Rename _PROC_* -> _CH_* to avoid confusion with similarly
named constants.
(_PROC_*): Delete unneeded aliases.
(PROC_*): Ditto.
(CURR_CHILD_INFO_MAGIC): Ditto.
(cchildren): Define using "pinfo_minimal".
(child_info::set_saw_ctrl_c): Move to
(child_info_spawn::set_saw_ctrl_c): Here.
(child_info_spawn::lock): New field.
(child_info_spawn::hExeced): Ditto.
(child_info_spawn::ev): Ditto.
(child_info_spawn::~child_info_spawn): Move to sigproc.cc.
(child_info_spawn::child_info_spawn): Ditto.
(child_info_spawn::cleanup): Declare new function.
(child_info_spawn::set_saw_ctrl_c): Move to this class.  Set flag only when
execed and return true when we have set the flag.
(child_info_spawn::child_info_spawn::signal_myself_exited): New function.
(child_info_spawn::wait_for_myself): Ditto.
(child_info_spawn::has_execed_cygwin): Ditto.
(child_info_spawn::has_execed): Ditto.  Replaces "hExeced" test.
(child_info_spawn::operator HANDLE&): New operator.
(child_info_spawn::worker): Define old "spawn_guts" as class member.
(ch_spawn): Declare.
(have_execed): Define.
(have_execed_cygwin): Ditto.
* cygheap.h: Update comment.
* dcrt0.cc (get_cygwin_startup_info): Use _CH_* enums.
(child_info_spawn::handle_spawn): Ditto.
(dll_crt0_0): Ditto.
(multiple_cygwin_problem): Ditto.
* exceptions.cc (chExeced): Delete obsolete declaration.
(ctrl_c_handler): Reference set_saw_ctrl_c via new ch_spawn global.
* globals.cc (hExeced): Delete.
* pinfo.cc (pinfo::thisproc): Refer to cygheap as ::cygheap for consistency in
handle naming when -DDEBUGGING.
(pinfo::init): Accommodate case where myself.h is known but h0 is passed in.
(pinfo::pinfo): New constructor for setting up a pinfo passed in by previous
exec'or.
(pinfo::proc_waiter): Don't handle subprocess if we're in the process of
exiting due to an exec of a cygwin process.  Don't close rd_proc_pipe here.
Close it when we actually are finished with the process.  Use new
ch_spawn.signal_myself_exited function to let exec stub know that subprocess
has exited.
(pinfo::wait): Clarify debugging output.
(pinfo::release): Use "close_h" to close all handles to avoid races.
(winpids::add): Assume that elements of the array do not need to be zeroed and
are properly initialized or suffer problems on pinfo::release.  Don't close
hProcess since release does that now.
* pinfo.h: Update comment.
(pinfo_minimal): Move some elements from pinfo here so that child_info_spawn
can use them.
(pinfo): Inherit from pinfo_minimal.
(pinfo::pinfo): Modify to accommodate new pinfo_minimal.
(pinfo::allow_remove): New function.
* sigproc.cc (proc_subproc): Use boolean values for true/false.  Implement
PROC_EXEC_CLEANUP.
(proc_terminate): Set ppid = 1 since the procs list will only be iterated when
the process has not execed.  Don't do any cleanup here since it is now handled
in pinfo::release.
(sigproc_init): Initialize sync_proc_subproc earlier.
(child_info::child_info): Assume that all important fields are properly
initialized and avoid memset().
(child_info_spawn::child_info_spawn): Specifically test for execing and then
set up appropriate fields in the struct.
(child_info_spawn::cleanup): Define new function.
(child_info_spawn::record_children): Specifically test for being execed here.
Fill in pinfo_minimal part of children array.
(child_info_spawn::reattach_children): Use constructor to duplicate information
for previous exec'or.  Add more debugging output.
(remove_proc): Force deletion of thread when exiting due to exec.  Rely on
pinfo::cleanup in release.
* sigproc.h (PROC_EXEC_CLEANUP): New enum.
(PROC_DETACHED_CHILD): Delete.
* spawn.cc (chExeced): Delete.
(child_info_spawn::worker): Rename from spawn_guts.  Use elements of
child_info_spawn throughout rather than ch.whatever.  Use ::cygheap to refer to
global rather than element of child_info.  Use wait_for_myself() rather than
waitpid().  Call child_info_spawn::cleanup on function return.
(spawnve): Reflect movement of spawn_guts functionality into
child_info_spawn::worker.
* syscalls.cc (popen): Ditto.
* winsup.h (spawn_guts): Delete declaration.

1 files changed, 50 insertions, 27 deletions

diff --git a/winsup/cygwin/child_info.h b/winsup/cygwin/child_info.h
index 95cb4d6eb..8fc0178d3 100644
--- a/winsup/cygwin/child_info.h
+++ b/winsup/cygwin/child_info.h
@@ -13,10 +13,11 @@ details. */
 
 enum child_info_types
 {
-  _PROC_EXEC,
-  _PROC_SPAWN,
-  _PROC_FORK,
-  _PROC_WHOOPS
+  _CH_NADA = 0,
+  _CH_EXEC = 1,
+  _CH_SPAWN = 2,
+  _CH_FORK = 3,
+  _CH_WHOOPS = 4
 };
 
 enum child_status
@@ -31,21 +32,18 @@ enum child_status
 
 #define PROC_MAGIC_GENERIC 0xaf00fa00
 
-#define PROC_EXEC (_PROC_EXEC)
-#define PROC_SPAWN (_PROC_SPAWN)
-#define PROC_FORK (_PROC_FORK)
-
 #define EXEC_MAGIC_SIZE sizeof(child_info)
 
 /* Change this value if you get a message indicating that it is out-of-sync. */
-#define CURR_CHILD_INFO_MAGIC 0xa049a83aU
+#define CURR_CHILD_INFO_MAGIC 0x941e0a4aU
 
 #define NPROCS	256
 
+#include "pinfo.h"
 struct cchildren
 {
   pid_t pid;
-  HANDLE rd_proc_pipe;
+  pinfo_minimal p;
 };
 
 /* NOTE: Do not make gratuitous changes to the names or organization of the
@@ -80,7 +78,6 @@ public:
   bool isstraced () const {return !!(flag & _CI_STRACED);}
   bool iscygwin () const {return !!(flag & _CI_ISCYGWIN);}
   bool saw_ctrl_c () const {return !!(flag & _CI_SAW_CTRL_C);}
-  void set_saw_ctrl_c () {flag |= _CI_SAW_CTRL_C;}
 };
 
 class mount_info;
@@ -118,6 +115,9 @@ public:
 
 class child_info_spawn: public child_info
 {
+  muto *lock;
+  HANDLE hExeced;
+  HANDLE ev;
 public:
   cygheap_exec_info *moreinfo;
   int __stdin;
@@ -126,30 +126,53 @@ public:
   int nchildren;
   cchildren children[NPROCS];
 
-  ~child_info_spawn ()
-  {
-    if (moreinfo)
-      {
-	if (moreinfo->envp)
-	  {
-	    for (char **e = moreinfo->envp; *e; e++)
-	      cfree (*e);
-	    cfree (moreinfo->envp);
-	  }
-	if (type != _PROC_SPAWN && moreinfo->myself_pinfo)
-	  CloseHandle (moreinfo->myself_pinfo);
-	cfree (moreinfo);
-      }
-  }
-  child_info_spawn (): moreinfo (NULL), nchildren (0) {};
+  void cleanup ();
+  child_info_spawn () {};
   child_info_spawn (child_info_types, bool);
   void record_children ();
   void reattach_children ();
   void *operator new (size_t, void *p) __attribute__ ((nothrow)) {return p;}
   void set (child_info_types ci, bool b) { new (this) child_info_spawn (ci, b);}
   void handle_spawn () __attribute__ ((regparm (1)));
+  bool set_saw_ctrl_c ()
+  {
+    if (!has_execed ())
+      return false;
+    flag |= _CI_SAW_CTRL_C;
+    return true;
+  }
+  bool signal_myself_exited ()
+  {
+    if (!ev)
+      return false;
+    else
+      {
+	SetEvent (ev);
+	return true;
+      }
+  }
+  void wait_for_myself () { WaitForSingleObject (ev, INFINITE); }
+  bool has_execed () const
+  {
+    if (hExeced)
+      return true;
+    if (type != _CH_EXEC)
+      return false;
+    lock->acquire ();
+    lock->release ();
+    return !!hExeced;
+  }
+  bool has_execed_cygwin () const { return iscygwin () && has_execed (); }
+  operator HANDLE& () {return hExeced;}
+  int worker (const char *, const char *const *, const char *const [], int,
+	      int = -1, int = -1) __attribute__ ((regparm (3)));;
 };
 
+extern child_info_spawn ch_spawn;
+
+#define have_execed ch_spawn.has_execed ()
+#define have_execed_cygwin ch_spawn.has_execed_cygwin ()
+
 void __stdcall init_child_info (DWORD, child_info *, HANDLE);
 
 extern "C" {