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

Cygwin: Remove waitloop argument from try_to_debug() 

Currently, when using CYGWIN's error_start facility, the faulting
process isn't stopped while the error_start process is started when the
fault is caused by an exception. (it even seems possible in theory that
the faulting process could have exited before the error_start process
attaches).

This leads to e.g. the core dump written by CYGWIN='error_start=dumper'
in response to an exception being non-deterministic.

Remove the waitloop argument from try_to_debug(), only used in the
exception case, so the faulting process busy-waits until the error_start
process attaches.

Code archaeology to determine why the code is this way didn't really
turn up any answers, but this seems a low-risk change, as this only
changes the behaviour when:

 - a debugger isn't already attached
 - an error_start is specified in CYGWIN env var
 - an exception has occurred which will be translated to a signal

If error_start invokes something which doesn't attach using
DebugActiveProcess(), we will spin indefinitely, but that will also
currently occur for any of the existing other uses of try_to_debug(),
which default to waitloop=TRUE.
This commit is contained in:
Jon Turney 2020-08-27 16:12:47 +01:00
parent 0416f68de1
commit a30cd7a5b9
No known key found for this signature in database
GPG Key ID: C7C86F0370285C81
2 changed files with 9 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
winsup/cygwin/exceptions.cc
View File

@ -461,10 +461,8 @@ cygwin_stackdump ()
exc.dumpstack (); exc.dumpstack ();
} }
#define TIME_TO_WAIT_FOR_DEBUGGER 10000
extern "C" int extern "C" int
try_to_debug (bool waitloop) try_to_debug ()
{ {
if (!debugger_command) if (!debugger_command)
return 0; return 0;
@ -532,13 +530,17 @@ try_to_debug (bool waitloop)
&si, &si,
&pi); &pi);
/* We want to stop here and wait until the error_start process attaches. But
we can't wait here for the error_start process to exit, as if it's a
debugger, it might want to continue this thread. So we busy wait until a
debugger attaches, which stops this process, after which it can decide if
we continue or not. */
*dbg_end = L'\0'; *dbg_end = L'\0';
if (!dbg) if (!dbg)
system_printf ("Failed to start debugger, %E"); system_printf ("Failed to start debugger, %E");
else else
{ {
if (!waitloop)
return dbg;
SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_IDLE); SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_IDLE);
while (!being_debugged ()) while (!being_debugged ())
Sleep (1); Sleep (1);
@ -812,7 +814,7 @@ exception::handle (EXCEPTION_RECORD *e, exception_list *frame, CONTEXT *in,
if (exit_state >= ES_SIGNAL_EXIT if (exit_state >= ES_SIGNAL_EXIT
&& (NTSTATUS) e->ExceptionCode != STATUS_CONTROL_C_EXIT) && (NTSTATUS) e->ExceptionCode != STATUS_CONTROL_C_EXIT)
api_fatal ("Exception during process exit"); api_fatal ("Exception during process exit");
else if (!try_to_debug (0)) else if (!try_to_debug ())
rtl_unwind (frame, e); rtl_unwind (frame, e);
else else
{ {

2
winsup/cygwin/winsup.h
View File

@ -190,7 +190,7 @@ void close_all_files (bool = false);
/* debug_on_trap support. see exceptions.cc:try_to_debug() */ /* debug_on_trap support. see exceptions.cc:try_to_debug() */
extern "C" void error_start_init (const char*); extern "C" void error_start_init (const char*);
extern "C" int try_to_debug (bool waitloop = 1); extern "C" int try_to_debug ();
void ld_preload (); void ld_preload ();
void fixup_hooks_after_fork (); void fixup_hooks_after_fork ();