drew
/
acadia-newlib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* sigproc.cc (mychild): Reimplement as list scan. 

(proc_subproc): Don't mess with pinfo if it's myself.
* child_info.h (child_info_types): Label enum for _PROC constants.
(child_info::child_info): New constructor.
(child_info::~child_info): New destructor.
(child_info::sync): Declare new function.
(child_info_fork::child_info_fork): New constructor.
(child_info_spawn::child_info_spawn): Remove old constructor.
(child_info_spawn::child_info_spawn): New constructor.
* dcrt0.cc (dll_crt0_0): Use correct sizeof when doing sanity check on passed
in child_info.  Signal readiness to parent when not forking (and not spawning).
* fork.cc (sync_with_child): Delete.
(resume_child): Remove extra argument.
(sync_with_parent): Use child_info method to sync with parent.
(fork_child): Don't close fork_info->subproc_ready since that is now handled by
the destructor.
(fork_parent): Remove subproc_ready stuff.  Use child_info sync method for
waiting..  Set start time here for child.  Rename "forked" to "child".
(fork): Check ch.subproc_ready for validity here.
* pinfo.h (_pinfo::exec_sendsig): Temp storage for exec stub which may be
staying around to handle non-cygwin captive process.
(_pinfo::exec_dwProcessId): Ditto.
(_pinfo::_lock): Renamed from lock.
(_pinfo::lock): New method.
(_pinfo::unlock): Ditto.
(_pinfo::initialize_lock): Ditto.
* pinfo.cc (set_myself): Use initialize_lock method to initialize myself lock.
Set "exec" fields in _pinfo to zero to indicate that we've started
successfully.  Set start time here when appropriate.
(_pinfo::commune_send): Use pinfo lock/unlock methods.
(proc_waiter): Remove special case for non-cywin processes.  Reinstitute
handling for PID_NOCLDSTOP.
* sigproc.cc (proc_subproc): Set proper EAGAIN errno when process table is
filled.
(sig_send): Use exec_* fields from _pinfo for sending signals if the the _pinfo
sendsig never materializes.
(child_info::child_info): New constructor, renamed from init_child_info.
Zeroes child_info structure and sets appropriate fields in structure based on
chtype.
(child_info::~child_info): New destructor.  Closes subproc_ready if it exists.
(child_info_fork::child_info_fork): New constructor.
(child_info_spawn::child_info_spawn): New constructor.
(child_info::ready): New function.  Signals parent when child is ready.
(child_info::sync): New function.  Wait for child to signal us or process to
die.
(remove_proc): Remove closing of hProcess since this should now be handled
shortly after process creation.
* spawn.cc (spawn_guts): Use child_info_spawn constructor rather than
init_child_info.  Save exec_sendsig and exec_dwProcessId in execing _pinfo.
Rely on child_info constructor to properly set parent_wr_proc_pipe in ciresrv.
Revert to previous determination on whether to start a process in suspended
mode.  Remove reparenting stuff.  Just keep a stub around if starting a
non-cygwin process.
This commit is contained in:
Christopher Faylor 2004-12-05 19:41:26 +00:00
parent d54b79d351
commit 54dd79bb44
9 changed files with 501 additions and 376 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
winsup/cygwin/ChangeLog
View File

@ -1,3 +1,65 @@
2004-12-05 Christopher Faylor <cgf@timesys.com>
* sigproc.cc (mychild): Reimplement as list scan.
(proc_subproc): Don't mess with pinfo if it's myself.
2004-12-05 Christopher Faylor <cgf@timesys.com>
* child_info.h (child_info_types): Label enum for _PROC constants.
(child_info::child_info): New constructor.
(child_info::~child_info): New destructor.
(child_info::sync): Declare new function.
(child_info_fork::child_info_fork): New constructor.
(child_info_spawn::child_info_spawn): Remove old constructor.
(child_info_spawn::child_info_spawn): New constructor.
* dcrt0.cc (dll_crt0_0): Use correct sizeof when doing sanity check on
passed in child_info. Signal readiness to parent when not forking (and
not spawning).
* fork.cc (sync_with_child): Delete.
(resume_child): Remove extra argument.
(sync_with_parent): Use child_info method to sync with parent.
(fork_child): Don't close fork_info->subproc_ready since that is now
handled by the destructor.
(fork_parent): Remove subproc_ready stuff. Use child_info sync method
for waiting.. Set start time here for child. Rename "forked" to
"child".
(fork): Check ch.subproc_ready for validity here.
* pinfo.h (_pinfo::exec_sendsig): Temp storage for exec stub which may
be staying around to handle non-cygwin captive process.
(_pinfo::exec_dwProcessId): Ditto.
(_pinfo::_lock): Renamed from lock.
(_pinfo::lock): New method.
(_pinfo::unlock): Ditto.
(_pinfo::initialize_lock): Ditto.
* pinfo.cc (set_myself): Use initialize_lock method to initialize
myself lock. Set "exec" fields in _pinfo to zero to indicate that
we've started successfully. Set start time here when appropriate.
(_pinfo::commune_send): Use pinfo lock/unlock methods.
(proc_waiter): Remove special case for non-cywin processes.
Reinstitute handling for PID_NOCLDSTOP.
* sigproc.cc (proc_subproc): Set proper EAGAIN errno when process table
is filled.
(sig_send): Use exec_* fields from _pinfo for sending signals if the
the _pinfo sendsig never materializes.
(child_info::child_info): New constructor, renamed from init_child_info.
Zeroes child_info structure and sets appropriate fields in structure
based on chtype.
(child_info::~child_info): New destructor. Closes subproc_ready if it
exists.
(child_info_fork::child_info_fork): New constructor.
(child_info_spawn::child_info_spawn): New constructor.
(child_info::ready): New function. Signals parent when child is ready.
(child_info::sync): New function. Wait for child to signal us or
process to die.
(remove_proc): Remove closing of hProcess since this should now be
handled shortly after process creation.
* spawn.cc (spawn_guts): Use child_info_spawn constructor rather than
init_child_info. Save exec_sendsig and exec_dwProcessId in execing
_pinfo. Rely on child_info constructor to properly set
parent_wr_proc_pipe in ciresrv. Revert to previous determination on
whether to start a process in suspended mode. Remove reparenting
stuff. Just keep a stub around if starting a non-cygwin process.
2004-12-05 Bas van Gompel <cygwin-patch@bavag.tmfweb.nl> 2004-12-05 Bas van Gompel <cygwin-patch@bavag.tmfweb.nl>
* fhandler.cc (fhandler_base::read): Remove superfluous check in * fhandler.cc (fhandler_base::read): Remove superfluous check in

9
winsup/cygwin/child_info.h
View File

@ -10,7 +10,7 @@ details. */
#include <setjmp.h> #include <setjmp.h>
enum enum child_info_types
{ {
_PROC_EXEC, _PROC_EXEC,
_PROC_SPAWN, _PROC_SPAWN,
@ -51,6 +51,10 @@ public:
HANDLE cygheap_h; HANDLE cygheap_h;
HANDLE parent_wr_proc_pipe; HANDLE parent_wr_proc_pipe;
unsigned fhandler_union_cb; unsigned fhandler_union_cb;
child_info (unsigned, child_info_types);
~child_info ();
void ready (bool);
bool sync (pinfo&, DWORD);
}; };
class mount_info; class mount_info;
@ -64,6 +68,7 @@ public:
jmp_buf jmp; // where child will jump to jmp_buf jmp; // where child will jump to
void *stacktop; // location of top of parent stack void *stacktop; // location of top of parent stack
void *stackbottom; // location of bottom of parent stack void *stackbottom; // location of bottom of parent stack
child_info_fork ();
}; };
class fhandler_base; class fhandler_base;
@ -84,7 +89,6 @@ class child_info_spawn: public child_info
public: public:
cygheap_exec_info *moreinfo; cygheap_exec_info *moreinfo;
child_info_spawn (): moreinfo (NULL) {}
~child_info_spawn () ~child_info_spawn ()
{ {
if (moreinfo) if (moreinfo)
@ -101,6 +105,7 @@ public:
cfree (moreinfo); cfree (moreinfo);
} }
} }
child_info_spawn (child_info_types);
}; };
void __stdcall init_child_info (DWORD, child_info *, HANDLE); void __stdcall init_child_info (DWORD, child_info *, HANDLE);

4
winsup/cygwin/dcrt0.cc
View File

@ -618,13 +618,15 @@ dll_crt0_0 ()
case _PROC_SPAWN: case _PROC_SPAWN:
case _PROC_EXEC: case _PROC_EXEC:
if (!should_be_cb) if (!should_be_cb)
should_be_cb = sizeof (child_info); should_be_cb = sizeof (child_info_spawn);
if (should_be_cb != child_proc_info->cb) if (should_be_cb != child_proc_info->cb)
multiple_cygwin_problem ("proc size", child_proc_info->cb, should_be_cb); multiple_cygwin_problem ("proc size", child_proc_info->cb, should_be_cb);
else if (sizeof (fhandler_union) != child_proc_info->fhandler_union_cb) else if (sizeof (fhandler_union) != child_proc_info->fhandler_union_cb)
multiple_cygwin_problem ("fhandler size", child_proc_info->fhandler_union_cb, sizeof (fhandler_union)); multiple_cygwin_problem ("fhandler size", child_proc_info->fhandler_union_cb, sizeof (fhandler_union));
else else
{ {
if (child_proc_info->type != _PROC_FORK)
child_proc_info->ready (true);
cygwin_user_h = child_proc_info->user_h; cygwin_user_h = child_proc_info->user_h;
break; break;
} }

128
winsup/cygwin/fork.cc
View File

@ -107,68 +107,8 @@ fork_copy (PROCESS_INFORMATION &pi, const char *what, ...)
return 0; return 0;
} }
/* Wait for child to finish what it's doing and signal us.
We don't want to wait forever here.If there's a problem somewhere
it'll hang the entire system (since all forks are mutex'd). If we
time out, set errno = EAGAIN and hope the app tries again. */
static int static int
sync_with_child (PROCESS_INFORMATION &pi, HANDLE subproc_ready, resume_child (HANDLE forker_finished)
bool hang_child, const char *s)
{
/* We also add the child process handle to the wait. If the child fails
to initialize (eg. because of a missing dll). Then this
handle will become signalled. This stops a *looong* timeout wait.
*/
HANDLE w4[2];
debug_printf ("waiting for child. reason: %s, hang_child %d", s,
hang_child);
w4[1] = pi.hProcess;
w4[0] = subproc_ready;
DWORD rc = WaitForMultipleObjects (2, w4, FALSE, FORK_WAIT_TIMEOUT);
if (rc == WAIT_OBJECT_0 ||
WaitForSingleObject (subproc_ready, 0) == WAIT_OBJECT_0)
/* That's ok */;
else if (rc == WAIT_FAILED || rc == WAIT_TIMEOUT)
{
if (rc != WAIT_FAILED)
system_printf ("WaitForMultipleObjects timed out");
else
system_printf ("WaitForMultipleObjects failed, %E");
set_errno (EAGAIN);
syscall_printf ("-1 = fork(), WaitForMultipleObjects failed");
TerminateProcess (pi.hProcess, 1);
return 0;
}
else
{
/* Child died. Clean up and exit. */
DWORD errcode;
GetExitCodeProcess (pi.hProcess, &errcode);
/* Fix me. This is not enough. The fork should not be considered
* to have failed if the process was essentially killed by a signal.
*/
if (errcode != STATUS_CONTROL_C_EXIT)
{
system_printf ("child %u(%p) died before initialization with status code %p",
cygwin_pid (pi.dwProcessId), pi.hProcess, errcode);
system_printf ("*** child state %s", s);
#ifdef DEBUGGING
try_to_debug ();
#endif
}
set_errno (EAGAIN);
syscall_printf ("Child died before subproc_ready signalled");
return 0;
}
debug_printf ("child signalled me");
return 1;
}
static int
resume_child (PROCESS_INFORMATION &pi, HANDLE forker_finished)
{ {
SetEvent (forker_finished); SetEvent (forker_finished);
debug_printf ("signalled child"); debug_printf ("signalled child");
@ -182,9 +122,7 @@ static void __stdcall
sync_with_parent (const char *s, bool hang_self) sync_with_parent (const char *s, bool hang_self)
{ {
debug_printf ("signalling parent: %s", s); debug_printf ("signalling parent: %s", s);
/* Tell our parent we're waiting. */ fork_info->ready (false);
if (!SetEvent (fork_info->subproc_ready))
api_fatal ("fork child - SetEvent for %s failed, %E", s);
if (hang_self) if (hang_self)
{ {
HANDLE h = fork_info->forker_finished; HANDLE h = fork_info->forker_finished;
@ -281,7 +219,6 @@ fork_child (HANDLE& hParent, dll *&first_dll, bool& load_dlls)
} }
ForceCloseHandle (hParent); ForceCloseHandle (hParent);
(void) ForceCloseHandle1 (fork_info->subproc_ready, subproc_ready);
(void) ForceCloseHandle1 (fork_info->forker_finished, forker_finished); (void) ForceCloseHandle1 (fork_info->forker_finished, forker_finished);
_my_tls.fixup_after_fork (); _my_tls.fixup_after_fork ();
@ -308,7 +245,7 @@ slow_pid_reuse (HANDLE h)
if (nfork_procs >= (sizeof (last_fork_procs) / sizeof (last_fork_procs [0]))) if (nfork_procs >= (sizeof (last_fork_procs) / sizeof (last_fork_procs [0])))
nfork_procs = 0; nfork_procs = 0;
/* Keep a list of handles to forked processes sitting around to prevent /* Keep a list of handles to child processes sitting around to prevent
Windows from reusing the same pid n times in a row. Having the same pids Windows from reusing the same pid n times in a row. Having the same pids
close in succesion confuses bash. Keeping a handle open will stop close in succesion confuses bash. Keeping a handle open will stop
windows from reusing the same pid. */ windows from reusing the same pid. */
@ -330,7 +267,7 @@ static int __stdcall
fork_parent (HANDLE& hParent, dll *&first_dll, fork_parent (HANDLE& hParent, dll *&first_dll,
bool& load_dlls, void *stack_here, child_info_fork &ch) bool& load_dlls, void *stack_here, child_info_fork &ch)
{ {
HANDLE subproc_ready, forker_finished; HANDLE forker_finished;
DWORD rc; DWORD rc;
PROCESS_INFORMATION pi = {0, NULL, 0, 0}; PROCESS_INFORMATION pi = {0, NULL, 0, 0};
@ -379,30 +316,17 @@ fork_parent (HANDLE& hParent, dll *&first_dll,
/* This will help some of the confusion. */ /* This will help some of the confusion. */
fflush (stdout); fflush (stdout);
subproc_ready = CreateEvent (&sec_all, FALSE, FALSE, NULL);
if (subproc_ready == NULL)
{
CloseHandle (hParent);
system_printf ("unable to allocate subproc_ready event, %E");
return -1;
}
forker_finished = CreateEvent (&sec_all, FALSE, FALSE, NULL); forker_finished = CreateEvent (&sec_all, FALSE, FALSE, NULL);
if (forker_finished == NULL) if (forker_finished == NULL)
{ {
CloseHandle (hParent); CloseHandle (hParent);
CloseHandle (subproc_ready);
system_printf ("unable to allocate forker_finished event, %E"); system_printf ("unable to allocate forker_finished event, %E");
return -1; return -1;
} }
ProtectHandleINH (subproc_ready);
ProtectHandleINH (forker_finished); ProtectHandleINH (forker_finished);
init_child_info (PROC_FORK, &ch, subproc_ready);
ch.forker_finished = forker_finished; ch.forker_finished = forker_finished;
ch.parent_wr_proc_pipe = myself->wr_proc_pipe == INVALID_HANDLE_VALUE
? NULL : myself->wr_proc_pipe;
stack_base (ch); stack_base (ch);
@ -437,7 +361,6 @@ fork_parent (HANDLE& hParent, dll *&first_dll,
{ {
__seterrno (); __seterrno ();
syscall_printf ("CreateProcessA failed, %E"); syscall_printf ("CreateProcessA failed, %E");
ForceCloseHandle (subproc_ready);
ForceCloseHandle (forker_finished); ForceCloseHandle (forker_finished);
/* Restore impersonation */ /* Restore impersonation */
cygheap->user.reimpersonate (); cygheap->user.reimpersonate ();
@ -457,10 +380,11 @@ fork_parent (HANDLE& hParent, dll *&first_dll,
ResumeThread (pi.hThread); ResumeThread (pi.hThread);
} }
int forked_pid = cygwin_pid (pi.dwProcessId); int child_pid = cygwin_pid (pi.dwProcessId);
pinfo forked (forked_pid, 1); pinfo child (child_pid, 1);
child->start_time = time (NULL); /* Register child's starting time. */
if (!forked) if (!child)
{ {
syscall_printf ("pinfo failed"); syscall_printf ("pinfo failed");
if (get_errno () != ENOMEM) if (get_errno () != ENOMEM)
@ -470,7 +394,7 @@ fork_parent (HANDLE& hParent, dll *&first_dll,
/* Initialize things that are done later in dll_crt0_1 that aren't done /* Initialize things that are done later in dll_crt0_1 that aren't done
for the forkee. */ for the forkee. */
strcpy (forked->progname, myself->progname); strcpy (child->progname, myself->progname);
/* Restore impersonation */ /* Restore impersonation */
cygheap->user.reimpersonate (); cygheap->user.reimpersonate ();
@ -478,18 +402,18 @@ fork_parent (HANDLE& hParent, dll *&first_dll,
ProtectHandle (pi.hThread); ProtectHandle (pi.hThread);
/* Protect the handle but name it similarly to the way it will /* Protect the handle but name it similarly to the way it will
be called in subproc handling. */ be called in subproc handling. */
ProtectHandle1 (pi.hProcess, childhProc); ProtectHandle (pi.hProcess);
/* Fill in fields in the child's process table entry. */ /* Fill in fields in the child's process table entry. */
forked->dwProcessId = pi.dwProcessId; child->dwProcessId = pi.dwProcessId;
forked.hProcess = pi.hProcess; child.hProcess = pi.hProcess;
/* Hopefully, this will succeed. The alternative to doing things this /* Hopefully, this will succeed. The alternative to doing things this
way is to reserve space prior to calling CreateProcess and then fill way is to reserve space prior to calling CreateProcess and then fill
it in afterwards. This requires more bookkeeping than I like, though, it in afterwards. This requires more bookkeeping than I like, though,
so we'll just do it the easy way. So, terminate any child process if so we'll just do it the easy way. So, terminate any child process if
we can't actually record the pid in the internal table. */ we can't actually record the pid in the internal table. */
if (!forked.remember ()) if (!child.remember ())
{ {
TerminateProcess (pi.hProcess, 1); TerminateProcess (pi.hProcess, 1);
set_errno (EAGAIN); set_errno (EAGAIN);
@ -501,8 +425,11 @@ fork_parent (HANDLE& hParent, dll *&first_dll,
#endif #endif
/* Wait for subproc to initialize itself. */ /* Wait for subproc to initialize itself. */
if (!sync_with_child (pi, subproc_ready, true, "waiting for longjmp")) if (!ch.sync (child, FORK_WAIT_TIMEOUT))
{
system_printf ("child %d died waiting for longjmp before initialization", child_pid);
goto cleanup; goto cleanup;
}
/* CHILD IS STOPPED */ /* CHILD IS STOPPED */
debug_printf ("child is alive (but stopped)"); debug_printf ("child is alive (but stopped)");
@ -547,9 +474,13 @@ fork_parent (HANDLE& hParent, dll *&first_dll,
} }
/* Start thread, and wait for it to reload dlls. */ /* Start thread, and wait for it to reload dlls. */
if (!resume_child (pi, forker_finished) || if (!resume_child (forker_finished))
!sync_with_child (pi, subproc_ready, load_dlls, "child loading dlls"))
goto cleanup; goto cleanup;
else if (!ch.sync (child, FORK_WAIT_TIMEOUT))
{
system_printf ("child %d died waiting for dll loading", child_pid);
goto cleanup;
}
/* If DLLs were loaded in the parent, then the child has reloaded all /* If DLLs were loaded in the parent, then the child has reloaded all
of them and is now waiting to have all of the individual data and of them and is now waiting to have all of the individual data and
@ -567,17 +498,17 @@ fork_parent (HANDLE& hParent, dll *&first_dll,
goto cleanup; goto cleanup;
} }
/* Start the child up again. */ /* Start the child up again. */
(void) resume_child (pi, forker_finished); (void) resume_child (forker_finished);
} }
ForceCloseHandle (subproc_ready); ForceCloseHandle (pi.hProcess);
ForceCloseHandle (pi.hThread); ForceCloseHandle (pi.hThread);
ForceCloseHandle (forker_finished); ForceCloseHandle (forker_finished);
forker_finished = NULL; forker_finished = NULL;
pi.hThread = NULL; pi.hThread = NULL;
pthread::atforkparent (); pthread::atforkparent ();
return forked_pid; return child_pid;
/* Common cleanup code for failure cases */ /* Common cleanup code for failure cases */
cleanup: cleanup:
@ -589,8 +520,6 @@ fork_parent (HANDLE& hParent, dll *&first_dll,
ForceCloseHandle1 (pi.hProcess, childhProc); ForceCloseHandle1 (pi.hProcess, childhProc);
if (pi.hThread) if (pi.hThread)
ForceCloseHandle (pi.hThread); ForceCloseHandle (pi.hThread);
if (subproc_ready)
ForceCloseHandle (subproc_ready);
if (forker_finished) if (forker_finished)
ForceCloseHandle (forker_finished); ForceCloseHandle (forker_finished);
return -1; return -1;
@ -618,6 +547,11 @@ fork ()
myself->set_has_pgid_children (); myself->set_has_pgid_children ();
child_info_fork ch; child_info_fork ch;
if (ch.subproc_ready == NULL)
{
system_printf ("unable to allocate subproc_ready event, %E");
return -1;
}
sig_send (NULL, __SIGHOLD); sig_send (NULL, __SIGHOLD);
int res = setjmp (ch.jmp); int res = setjmp (ch.jmp);

36
winsup/cygwin/include/sys/cygwin.h
View File

@ -87,24 +87,24 @@ unsigned long cygwin_internal (cygwin_getinfo_types, ...);
/* Flags associated with process_state */ /* Flags associated with process_state */
enum enum
{ {
PID_IN_USE = 0x0001, /* Entry in use. */ PID_IN_USE = 0x00001, /* Entry in use. */
PID_ZOMBIE = 0x0002, /* Child exited: no parent wait. */ PID_ZOMBIE = 0x00002, /* Child exited: no parent wait. */
PID_STOPPED = 0x0004, /* Waiting for SIGCONT. */ PID_STOPPED = 0x00004, /* Waiting for SIGCONT. */
PID_TTYIN = 0x0008, /* Waiting for terminal input. */ PID_TTYIN = 0x00008, /* Waiting for terminal input. */
PID_TTYOU = 0x0010, /* Waiting for terminal output. */ PID_TTYOU = 0x00010, /* Waiting for terminal output. */
PID_ORPHANED = 0x0020, /* Member of an orphaned process group. */ PID_ORPHANED = 0x00020, /* Member of an orphaned process group. */
PID_ACTIVE = 0x0040, /* Pid accepts signals. */ PID_ACTIVE = 0x00040, /* Pid accepts signals. */
PID_CYGPARENT = 0x0080, /* Set if parent was a cygwin app. */ PID_CYGPARENT = 0x00080, /* Set if parent was a cygwin app. */
PID_MAP_RW = 0x0100, /* Flag to open map rw. */ PID_MAP_RW = 0x00100, /* Flag to open map rw. */
PID_MYSELF = 0x0200, /* Flag that pid is me. */ PID_MYSELF = 0x00200, /* Flag that pid is me. */
PID_NOCLDSTOP = 0x0400, /* Set if no SIGCHLD signal on stop. */ PID_NOCLDSTOP = 0x00400, /* Set if no SIGCHLD signal on stop. */
PID_INITIALIZING = 0x0800, /* Set until ready to receive signals. */ PID_INITIALIZING = 0x00800, /* Set until ready to receive signals. */
PID_USETTY = 0x1000, /* Setting this enables or disables cygwin's */ PID_USETTY = 0x01000, /* Setting this enables or disables cygwin's
/* tty support. This is inherited by */ tty support. This is inherited by
/* all execed or forked processes. */ all execed or forked processes. */
PID_ALLPIDS = 0x2000, /* child has execed */ PID_ALLPIDS = 0x02000, /* used by pinfo scanner */
PID_EXECED = 0x4000, /* redirect to original pid info block */ PID_EXECED = 0x04000, /* redirect to original pid info block */
PID_NOREDIR = 0x8000, /* don't redirect if execed */ PID_NOREDIR = 0x08000, /* don't redirect if execed */
PID_EXITED = 0x80000000 /* Free entry. */ PID_EXITED = 0x80000000 /* Free entry. */
}; };

81
winsup/cygwin/pinfo.cc
View File

@ -50,21 +50,25 @@ set_myself (HANDLE h)
cygheap->pid = cygwin_pid (GetCurrentProcessId ()); cygheap->pid = cygwin_pid (GetCurrentProcessId ());
myself.init (cygheap->pid, PID_IN_USE | PID_MYSELF, h); myself.init (cygheap->pid, PID_IN_USE | PID_MYSELF, h);
myself->process_state |= PID_IN_USE; myself->process_state |= PID_IN_USE;
myself->start_time = time (NULL); /* Register our starting time. */ myself->dwProcessId = GetCurrentProcessId ();
(void) GetModuleFileName (NULL, myself->progname, sizeof (myself->progname)); (void) GetModuleFileName (NULL, myself->progname, sizeof (myself->progname));
if (!strace.active) if (!strace.active)
strace.hello (); strace.hello ();
debug_printf ("myself->dwProcessId %u", myself->dwProcessId); debug_printf ("myself->dwProcessId %u", myself->dwProcessId);
InitializeCriticalSection (&myself.lock); myself.initialize_lock ();
myself->dwProcessId = GetCurrentProcessId ();
if (h) if (h)
{ {
/* here if execed */ /* here if execed */
static pinfo NO_COPY myself_identity; static pinfo NO_COPY myself_identity;
myself_identity.init (cygwin_pid (myself->dwProcessId), PID_EXECED); myself_identity.init (cygwin_pid (myself->dwProcessId), PID_EXECED);
myself->start_time = time (NULL); /* Register our starting time. */
myself->exec_sendsig = NULL;
myself->exec_dwProcessId = 0;
} }
else if (myself->wr_proc_pipe) else if (!myself->wr_proc_pipe)
myself->start_time = time (NULL); /* Register our starting time. */
else
{ {
/* We've inherited the parent's wr_proc_pipe. We don't need it, /* We've inherited the parent's wr_proc_pipe. We don't need it,
so close it. */ so close it. */
@ -522,7 +526,7 @@ _pinfo::commune_send (DWORD code, ...)
__seterrno (); __seterrno ();
goto err; goto err;
} }
EnterCriticalSection (&myself.lock); myself.lock ();
myself->tothem = tome; myself->tothem = tome;
myself->fromthem = fromme; myself->fromthem = fromme;
myself->hello_pid = pid; myself->hello_pid = pid;
@ -626,7 +630,7 @@ err:
out: out:
myself->hello_pid = 0; myself->hello_pid = 0;
LeaveCriticalSection (&myself.lock); myself.unlock ();
return res; return res;
} }
@ -710,13 +714,6 @@ proc_waiter (void *arg)
/* Child exited. Do some cleanup and signal myself. */ /* Child exited. Do some cleanup and signal myself. */
CloseHandle (vchild.rd_proc_pipe); CloseHandle (vchild.rd_proc_pipe);
vchild.rd_proc_pipe = NULL; vchild.rd_proc_pipe = NULL;
if (vchild->process_state != PID_EXITED && vchild.hProcess)
{
DWORD exit_code;
if (GetExitCodeProcess (vchild.hProcess, &exit_code))
vchild->exitcode = (exit_code & 0xff) << 8;
}
if (WIFEXITED (vchild->exitcode)) if (WIFEXITED (vchild->exitcode))
si.si_sigval.sival_int = CLD_EXITED; si.si_sigval.sival_int = CLD_EXITED;
else if (WCOREDUMP (vchild->exitcode)) else if (WCOREDUMP (vchild->exitcode))
@ -730,33 +727,13 @@ proc_waiter (void *arg)
case SIGTTOU: case SIGTTOU:
case SIGTSTP: case SIGTSTP:
case SIGSTOP: case SIGSTOP:
if (ISSTATE (myself, PID_NOCLDSTOP)) // FIXME: No need for this flag to be in _pinfo any longer
continue;
/* Child stopped. Signal myself. */ /* Child stopped. Signal myself. */
si.si_sigval.sival_int = CLD_STOPPED; si.si_sigval.sival_int = CLD_STOPPED;
break; break;
case SIGCONT: case SIGCONT:
continue; continue;
case __ALERT_REPARENT: /* sigh */
/* spawn_guts has signalled us that it has just started a new
subprocess which will take over this cygwin pid. */
/* We need to keep a handle to the original windows process which
represents the cygwin process around to make sure that the
windows pid is not reused before we are through with it.
So, detect the first time that a subprocess calls exec
and save the current hprocess in the pid_handle field.
On subsequent execs just close the handle. */
if (!vchild.hProcess)
/* something went wrong. oh well. */;
else if (vchild.pid_handle)
ForceCloseHandle1 (vchild.hProcess, childhProc);
else
vchild.pid_handle = vchild.hProcess;
vchild.hProcess = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE,
vchild->dwProcessId);
vchild->cygstarted++;
if (vchild.hProcess)
ProtectHandle1 (vchild.hProcess, childhProc);
continue;
default: default:
system_printf ("unknown value %d on proc pipe", buf); system_printf ("unknown value %d on proc pipe", buf);
continue; continue;
@ -790,6 +767,40 @@ proc_waiter (void *arg)
return 0; return 0;
} }
void
proc_pipe::set (bool closeem)
{
myself.lock ();
if (!CreatePipe (&in, &out, &sec_none_nih, 16))
{
system_printf ("couldn't create pipe, %E");
return;
}
/* Duplicate the write end of the pipe into the subprocess. Make it inheritable
so that all of the execed children get it. */
if (!DuplicateHandle (hMainProc, out, hMainProc, &out, 0, TRUE,
DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE))
{
CloseHandle (in);
in = out = NULL;
system_printf ("couldn't make handle %p noninheritable, %E", out);
return;
}
_closeem = closeem;
}
proc_pipe::~proc_pipe ()
{
if (_closeem)
{
if (in)
CloseHandle (in);
if (out)
CloseHandle (out);
}
myself.unlock ();
}
/* function to set up the process pipe and kick off proc_waiter */ /* function to set up the process pipe and kick off proc_waiter */
int int
pinfo::wait () pinfo::wait ()

22
winsup/cygwin/pinfo.h
View File

@ -111,6 +111,8 @@ public:
/* signals */ /* signals */
HANDLE sendsig; HANDLE sendsig;
HANDLE exec_sendsig;
DWORD exec_dwProcessId;
private: private:
sigset_t sig_mask; sigset_t sig_mask;
public: public:
@ -132,7 +134,7 @@ class pinfo
public: public:
HANDLE rd_proc_pipe; HANDLE rd_proc_pipe;
HANDLE hProcess; HANDLE hProcess;
CRITICAL_SECTION lock; CRITICAL_SECTION _lock;
/* Handle associated with initial Windows pid which started it all. */ /* Handle associated with initial Windows pid which started it all. */
HANDLE pid_handle; HANDLE pid_handle;
void init (pid_t, DWORD, HANDLE = NULL) __attribute__ ((regparm(3))); void init (pid_t, DWORD, HANDLE = NULL) __attribute__ ((regparm(3)));
@ -147,7 +149,9 @@ public:
if (destroy && procinfo) if (destroy && procinfo)
release (); release ();
} }
void initialize_lock () {InitializeCriticalSection (&_lock);}
void lock () {EnterCriticalSection (&_lock);}
void unlock () {LeaveCriticalSection (&_lock);}
_pinfo *operator -> () const {return procinfo;} _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 == procinfo;} int operator == (pinfo &x) const {return x.procinfo == procinfo;}
@ -175,6 +179,20 @@ public:
void set_acl(); void set_acl();
}; };
class proc_pipe
{
bool _closeem;
public:
HANDLE in;
HANDLE out;
void set (bool);
proc_pipe (bool closeem) {set (closeem);}
proc_pipe () : _closeem (false), in (NULL), out (NULL) {};
void close () {_closeem = true;}
~proc_pipe ();
int operator == (int x) {return (int) in == x;}
};
#define ISSTATE(p, f) (!!((p)->process_state & f)) #define ISSTATE(p, f) (!!((p)->process_state & f))
#define NOTSTATE(p, f) (!((p)->process_state & f)) #define NOTSTATE(p, f) (!((p)->process_state & f))

152
winsup/cygwin/sigproc.cc
View File

@ -200,19 +200,18 @@ proc_exists (_pinfo *p)
return p && !(p->process_state & (PID_EXITED | PID_ZOMBIE)); return p && !(p->process_state & (PID_EXITED | PID_ZOMBIE));
} }
/* Return 1 if this is one of our children, zero otherwise. /* Return true if this is one of our children, false otherwise. */
FIXME: This really should be integrated with the rest of the proc_subproc static inline bool __stdcall
testing. Scanning these lists twice is inefficient. */
bool __stdcall
mychild (int pid) mychild (int pid)
{ {
pinfo p (pid); for (int i = 0; i < nprocs; i++)
return p && p->ppid == myself->pid; if (procs[i]->pid == pid)
return true;
return false;
} }
/* Handle all subprocess requests /* Handle all subprocess requests
*/ */
#define vchild (*((pinfo *) val))
int __stdcall int __stdcall
proc_subproc (DWORD what, DWORD val) proc_subproc (DWORD what, DWORD val)
{ {
@ -223,6 +222,7 @@ proc_subproc (DWORD what, DWORD val)
waitq *w; waitq *w;
#define wval ((waitq *) val) #define wval ((waitq *) val)
#define vchild (*((pinfo *) val))
sigproc_printf ("args: %x, %d", what, val); sigproc_printf ("args: %x, %d", what, val);
@ -244,10 +244,12 @@ proc_subproc (DWORD what, DWORD val)
sigproc_printf ("proc table overflow: hit %d processes, pid %d\n", sigproc_printf ("proc table overflow: hit %d processes, pid %d\n",
nprocs, vchild->pid); nprocs, vchild->pid);
rc = 0; rc = 0;
set_errno (EMFILE); // FIXMENOW - what's the right errno? set_errno (EAGAIN);
break; break;
} }
if (vchild != myself)
{
vchild->ppid = myself->pid; vchild->ppid = myself->pid;
vchild->uid = myself->uid; vchild->uid = myself->uid;
vchild->gid = myself->gid; vchild->gid = myself->gid;
@ -256,6 +258,7 @@ proc_subproc (DWORD what, DWORD val)
vchild->ctty = myself->ctty; vchild->ctty = myself->ctty;
vchild->cygstarted = true; vchild->cygstarted = true;
vchild->process_state |= PID_INITIALIZING | (myself->process_state & PID_USETTY); vchild->process_state |= PID_INITIALIZING | (myself->process_state & PID_USETTY);
}
procs[nprocs] = vchild; procs[nprocs] = vchild;
rc = procs[nprocs].wait (); rc = procs[nprocs].wait ();
if (rc) if (rc)
@ -353,6 +356,8 @@ out:
out1: out1:
sigproc_printf ("returning %d", rc); sigproc_printf ("returning %d", rc);
return rc; return rc;
#undef wval
#undef vchild
} }
// FIXME: This is inelegant // FIXME: This is inelegant
@ -566,9 +571,27 @@ sig_send (_pinfo *p, siginfo_t& si, _cygtls *tls)
sendsig = myself->sendsig; sendsig = myself->sendsig;
else else
{ {
for (int i = 0; !p->dwProcessId && i < 10000; i++) HANDLE dupsig;
DWORD dwProcessId;
for (int i = 0; !p->sendsig && i < 10000; i++)
low_priority_sleep (0); low_priority_sleep (0);
HANDLE hp = OpenProcess (PROCESS_DUP_HANDLE, false, p->dwProcessId); if (p->sendsig)
{
dupsig = p->sendsig;
dwProcessId = p->dwProcessId;
}
else
{
dupsig = p->exec_sendsig;
dwProcessId = p->exec_dwProcessId;
}
if (!dupsig)
{
set_errno (EAGAIN);
sigproc_printf ("sendsig handle never materialized");
goto out;
}
HANDLE hp = OpenProcess (PROCESS_DUP_HANDLE, false, dwProcessId);
if (!hp) if (!hp)
{ {
sigproc_printf ("OpenProcess failed, %E"); sigproc_printf ("OpenProcess failed, %E");
@ -576,14 +599,12 @@ sig_send (_pinfo *p, siginfo_t& si, _cygtls *tls)
goto out; goto out;
} }
VerifyHandle (hp); VerifyHandle (hp);
for (int i = 0; !p->sendsig && i < 10000; i++) if (!DuplicateHandle (hp, dupsig, hMainProc, &sendsig, false, 0,
low_priority_sleep (0);
if (!DuplicateHandle (hp, p->sendsig, hMainProc, &sendsig, false, 0,
DUPLICATE_SAME_ACCESS) || !sendsig) DUPLICATE_SAME_ACCESS) || !sendsig)
{ {
CloseHandle (hp);
sigproc_printf ("DuplicateHandle failed, %E");
__seterrno (); __seterrno ();
sigproc_printf ("DuplicateHandle failed, %E");
CloseHandle (hp);
goto out; goto out;
} }
CloseHandle (hp); CloseHandle (hp);
@ -695,17 +716,98 @@ out:
/* Initialize some of the memory block passed to child processes /* Initialize some of the memory block passed to child processes
by fork/spawn/exec. */ by fork/spawn/exec. */
void __stdcall child_info::child_info (unsigned in_cb, child_info_types chtype)
init_child_info (DWORD chtype, child_info *ch, HANDLE subproc_ready)
{ {
memset (ch, 0, sizeof *ch); memset (this, 0, in_cb);
ch->cb = chtype == PROC_FORK ? sizeof (child_info_fork) : sizeof (child_info); cb = in_cb;
ch->intro = PROC_MAGIC_GENERIC; intro = PROC_MAGIC_GENERIC;
ch->magic = CHILD_INFO_MAGIC; magic = CHILD_INFO_MAGIC;
ch->type = chtype; type = chtype;
ch->subproc_ready = subproc_ready; fhandler_union_cb = sizeof (fhandler_union);
ch->fhandler_union_cb = sizeof (fhandler_union); user_h = cygwin_user_h;
ch->user_h = cygwin_user_h; if (chtype != PROC_SPAWN)
subproc_ready = CreateEvent (&sec_all, FALSE, FALSE, NULL);
sigproc_printf ("subproc_ready %p", subproc_ready);
if (chtype != PROC_EXEC && myself->wr_proc_pipe != INVALID_HANDLE_VALUE)
parent_wr_proc_pipe = myself->wr_proc_pipe;
}
child_info::~child_info ()
{
if (subproc_ready)
CloseHandle (subproc_ready);
}
child_info_fork::child_info_fork () :
child_info (sizeof *this, _PROC_FORK)
{
}
child_info_spawn::child_info_spawn (child_info_types chtype) :
child_info (sizeof *this, chtype)
{
}
void
child_info::ready (bool execed)
{
if (!subproc_ready)
{
sigproc_printf ("subproc_ready not set");
return;
}
if (!SetEvent (subproc_ready))
api_fatal ("SetEvent failed");
else
sigproc_printf ("signalled %p that I was ready", subproc_ready);
if (execed)
{
CloseHandle (subproc_ready);
subproc_ready = NULL;
}
}
bool
child_info::sync (pinfo& vchild, DWORD howlong)
{
if (!subproc_ready)
{
sigproc_printf ("not waiting. subproc_ready is NULL");
return false;
}
HANDLE w4[2];
w4[0] = subproc_ready;
w4[1] = vchild.hProcess;
bool res;
sigproc_printf ("waiting for subproc_ready(%p) and child process(%p)", w4[0], w4[1]);
switch (WaitForMultipleObjects (2, w4, FALSE, howlong))
{
case WAIT_OBJECT_0:
sigproc_printf ("got subproc_ready for pid %d", vchild->pid);
res = true;
break;
case WAIT_OBJECT_0 + 1:
if (WaitForSingleObject (subproc_ready, 0) == WAIT_OBJECT_0)
sigproc_printf ("should never happen. noticed subproc_ready after process exit");
else
{
DWORD exitcode = 0;
(void) GetExitCodeProcess (vchild.hProcess, &exitcode);
vchild->exitcode = (exitcode & 0xff) << 8;
sigproc_printf ("non-cygwin exit value is %p", exitcode);
}
res = false;
break;
default:
system_printf ("wait failed, pid %d, %E", vchild->pid);
res = false;
break;
}
return res;
} }
/* Check the state of all of our children to see if any are stopped or /* Check the state of all of our children to see if any are stopped or

85
winsup/cygwin/spawn.cc
View File

@ -372,17 +372,15 @@ spawn_guts (const char * prog_arg, const char *const *argv,
STARTUPINFO si = {0, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL}; STARTUPINFO si = {0, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL};
child_info_spawn ciresrv; child_info_types chtype;
si.lpReserved2 = (LPBYTE) &ciresrv;
si.cbReserved2 = sizeof (ciresrv);
DWORD chtype;
if (mode != _P_OVERLAY) if (mode != _P_OVERLAY)
chtype = PROC_SPAWN; chtype = PROC_SPAWN;
else else
chtype = PROC_EXEC; chtype = PROC_EXEC;
init_child_info (chtype, &ciresrv, NULL); child_info_spawn ciresrv (chtype);
si.lpReserved2 = (LPBYTE) &ciresrv;
si.cbReserved2 = sizeof (ciresrv);
ciresrv.moreinfo = (cygheap_exec_info *) ccalloc (HEAP_1_EXEC, 1, sizeof (cygheap_exec_info)); ciresrv.moreinfo = (cygheap_exec_info *) ccalloc (HEAP_1_EXEC, 1, sizeof (cygheap_exec_info));
ciresrv.moreinfo->old_title = NULL; ciresrv.moreinfo->old_title = NULL;
@ -616,16 +614,21 @@ spawn_guts (const char * prog_arg, const char *const *argv,
if (mode == _P_DETACH || !set_console_state_for_spawn ()) if (mode == _P_DETACH || !set_console_state_for_spawn ())
flags |= DETACHED_PROCESS; flags |= DETACHED_PROCESS;
HANDLE saved_sendsig; bool reset_sendsig = false;
if (mode != _P_OVERLAY) if (mode != _P_OVERLAY)
saved_sendsig = NULL; myself->exec_sendsig = NULL;
else else
{ {
/* Reset sendsig so that any process which wants to send a signal /* Reset sendsig so that any process which wants to send a signal
to this pid will wait for the new process to become active. to this pid will wait for the new process to become active.
Save the old value in case the exec fails. */ Save the old value in case the exec fails. */
saved_sendsig = myself->sendsig; if (!myself->exec_sendsig)
myself->sendsig = INVALID_HANDLE_VALUE; {
myself->exec_sendsig = myself->sendsig;
myself->exec_dwProcessId = myself->dwProcessId;
myself->sendsig = NULL;
reset_sendsig = true;
}
/* Save a copy of a handle to the current process around the first time we /* Save a copy of a handle to the current process around the first time we
exec so that the pid will not be reused. Why did I stop cygwin from exec so that the pid will not be reused. Why did I stop cygwin from
generating its own pids again? */ generating its own pids again? */
@ -636,15 +639,13 @@ spawn_guts (const char * prog_arg, const char *const *argv,
ProtectHandle (cygheap->pid_handle); ProtectHandle (cygheap->pid_handle);
else else
system_printf ("duplicate to pid_handle failed, %E"); system_printf ("duplicate to pid_handle failed, %E");
ciresrv.parent_wr_proc_pipe = myself->wr_proc_pipe;
} }
/* Start the process in a suspended state. Needed so that any potential parent will /* Some file types (currently only sockets) need extra effort in the parent
be able to take notice of the new "execed" process. This is only really needed after CreateProcess and before copying the datastructures to the child.
to handle exec'ed windows processes since cygwin processes are smart enough that So we have to start the child in suspend state, unfortunately, to avoid
the parent doesn't have to bother but what are you gonna do? Cygwin lives in a race condition. */
a windows world. */ if (mode != _P_OVERLAY || cygheap->fdtab.need_fixup_before ())
if (mode != _P_OVERLAY || !real_path.iscygexec ())
flags |= CREATE_SUSPENDED; flags |= CREATE_SUSPENDED;
const char *runpath = null_app_name ? NULL : (const char *) real_path; const char *runpath = null_app_name ? NULL : (const char *) real_path;
@ -739,8 +740,11 @@ spawn_guts (const char * prog_arg, const char *const *argv,
__seterrno (); __seterrno ();
syscall_printf ("CreateProcess failed, %E"); syscall_printf ("CreateProcess failed, %E");
/* If this was a failed exec, restore the saved sendsig. */ /* If this was a failed exec, restore the saved sendsig. */
if (saved_sendsig) if (reset_sendsig)
myself->sendsig = saved_sendsig; {
myself->sendsig = myself->exec_sendsig;
myself->exec_sendsig = NULL;
}
cygheap_setup_for_child_cleanup (newheap, &ciresrv, 0); cygheap_setup_for_child_cleanup (newheap, &ciresrv, 0);
return -1; return -1;
} }
@ -780,41 +784,32 @@ spawn_guts (const char * prog_arg, const char *const *argv,
rc ? cygpid : (unsigned int) -1, prog_arg, one_line.buf); rc ? cygpid : (unsigned int) -1, prog_arg, one_line.buf);
/* Name the handle similarly to proc_subproc. */ /* Name the handle similarly to proc_subproc. */
ProtectHandle1 (pi.hProcess, childhProc); ProtectHandle (pi.hProcess);
int wait_for_myself = false; bool wait_for_myself = false;
DWORD exec_cygstarted;
if (mode == _P_OVERLAY) if (mode == _P_OVERLAY)
{ {
if (!real_path.iscygexec ()) myself->dwProcessId = dwExeced = pi.dwProcessId;
{
/* Store the old exec_cygstarted since this is used as a crude semaphore for
detecting when the parent has noticed the change in windows pid for this
cygwin pid. */
exec_cygstarted = myself->cygstarted;
myself->dwProcessId = dwExeced = pi.dwProcessId; /* Reparenting needs this */
myself.alert_parent (__ALERT_REPARENT);
}
CloseHandle (saved_sendsig);
strace.execing = 1; strace.execing = 1;
hExeced = pi.hProcess; myself.hProcess = hExeced = pi.hProcess;
strcpy (myself->progname, real_path); // FIXME: race? strcpy (myself->progname, real_path); // FIXME: race?
sigproc_printf ("new process name %s", myself->progname);
close_all_files (); close_all_files ();
/* If wr_proc_pipe is NULL then this process was not started by a cygwin /* If wr_proc_pipe doesn't exist then this process was not started by a cygwin
process. So, we need to wait around until the process we've just "execed" process. So, we need to wait around until the process we've just "execed"
dies. Use our own wait facility to wait for our own pid to exit (there dies. Use our own wait facility to wait for our own pid to exit (there
is some minor special case code in proc_waiter and friends to accommodate is some minor special case code in proc_waiter and friends to accommodeate
this). */ this). */
if (!myself->wr_proc_pipe) if (!myself->wr_proc_pipe)
{ {
myself.hProcess = pi.hProcess; myself.hProcess = pi.hProcess;
myself.remember (); myself.remember ();
wait_for_myself = true; wait_for_myself = true;
myself->wr_proc_pipe = INVALID_HANDLE_VALUE;
} }
} }
else else
{ {
exec_cygstarted = 0;
myself->set_has_pgid_children (); myself->set_has_pgid_children ();
ProtectHandle (pi.hThread); ProtectHandle (pi.hThread);
pinfo child (cygpid, PID_IN_USE); pinfo child (cygpid, PID_IN_USE);
@ -830,8 +825,9 @@ spawn_guts (const char * prog_arg, const char *const *argv,
child.hProcess = pi.hProcess; child.hProcess = pi.hProcess;
if (!child.remember ()) if (!child.remember ())
{ {
syscall_printf ("process table full"); /* FIXME: Child in strange state now. */
set_errno (EAGAIN); CloseHandle (pi.hProcess);
CloseHandle (pi.hThread);
res = -1; res = -1;
goto out; goto out;
} }
@ -844,27 +840,22 @@ spawn_guts (const char * prog_arg, const char *const *argv,
However, we should try to find another way to do this eventually. */ However, we should try to find another way to do this eventually. */
(void) DuplicateHandle (hMainProc, child.shared_handle (), pi.hProcess, (void) DuplicateHandle (hMainProc, child.shared_handle (), pi.hProcess,
NULL, 0, 0, DUPLICATE_SAME_ACCESS); NULL, 0, 0, DUPLICATE_SAME_ACCESS);
child->start_time = time (NULL); /* Register child's starting time. */
} }
/* Start the child running */ /* Start the child running */
if (flags & CREATE_SUSPENDED) if (flags & CREATE_SUSPENDED)
ResumeThread (pi.hThread); ResumeThread (pi.hThread);
ForceCloseHandle (pi.hThread); ForceCloseHandle (pi.hThread);
// ForceCloseHandle (pi.hProcess); // handled by proc_subproc and friends
sigproc_printf ("spawned windows pid %d", pi.dwProcessId); sigproc_printf ("spawned windows pid %d", pi.dwProcessId);
if (wait_for_myself) if (wait_for_myself)
waitpid (myself->pid, &res, 0); waitpid (myself->pid, &res, 0);
else else
{ ciresrv.sync (myself, INFINITE);
/* Loop, waiting for parent to notice pid change, if exec_cygstarted.
In theory this wait should usually be a no-op. */ ForceCloseHandle (pi.hProcess);
if (exec_cygstarted)
while (myself->cygstarted == exec_cygstarted && myself.parent_alive ())
low_priority_sleep (0);
res = 42;
}
switch (mode) switch (mode)
{ {