From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2201) id 408873858409; Tue, 16 Jan 2024 14:11:39 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 408873858409 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1705414299; bh=V9sYrAUNfOssu9H6UE2Nu3tYtdyz0Xv8GyTGI8JQgK0=; h=From:To:Subject:Date:From; b=gSg/MeyXJfPpIejwcjTxKMKciY5NyJ+aw+nVM4T/wqk1qGLWjM2b7AZdRFR2AFqcM fNpqmrI6wmDMmKPoYrS2K/ptbaahzjTYjNmX7vBQbyqR6tnOuFDR3qD8a5IJYtR3lH ZMYk3IQnXR5bHRO6TUvm5dWATtOgDqdyXhdY9k1w= Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable From: Jon Turney To: cygwin-cvs@sourceware.org Subject: [newlib-cygwin/main] Cygwin: Make 'ulimit -c' control writing a coredump X-Act-Checkin: newlib-cygwin X-Git-Author: Jon Turney X-Git-Refname: refs/heads/main X-Git-Oldrev: d8c0fb090ca637bba5337fb3b0a1f3ee107b21dd X-Git-Newrev: 91457377d6c9f89a08b1b70e45cbae87ef467119 Message-Id: <20240116141139.408873858409@sourceware.org> Date: Tue, 16 Jan 2024 14:11:39 +0000 (GMT) List-Id: https://sourceware.org/git/gitweb.cgi?p=3Dnewlib-cygwin.git;h=3D91457377d6c= 9f89a08b1b70e45cbae87ef467119 commit 91457377d6c9f89a08b1b70e45cbae87ef467119 Author: Jon Turney Date: Thu Jan 11 20:00:14 2024 +0000 Cygwin: Make 'ulimit -c' control writing a coredump =20 Pre-format a command to be executed on a fatal error to run 'dumper' (using an absolute path). =20 Factor out executing a pre-formatted command, so we can use that for invoking the JIT debugger in try_to_debug() (if error_start is present in the CYGWIN env var) and to invoke dumper when a fatal error occurs. =20 On a fatal error, if the core file size limit is greater than 1MB, invoke dumper to write a core dump. Otherwise, if that limit is greater than 0, write a .stackdump file, as previously. =20 Adjust and clarify the associated documentation. =20 Also: Fix so that the error_start JIT debugger is now invoked, even when ulimit -c is zero. =20 Also: Fix uses of console_printf() inside exec_prepared_command(). It's output is written via the Windows console device, so needs to use Windows-style line endings. =20 Also: consistently return non-zero from try_to_debug() if we debugged. =20 Future work: Truncate or remove the file written, if it exceeds the maximum size set by the ulimit. =20 Future work: Using the words "fatal error" could probably be improved on. This means exiting on one of the "certain signals whose default action is to cause the process to terminate and produce a core dump file". Diff: --- winsup/cygwin/environ.cc | 1 + winsup/cygwin/exceptions.cc | 104 +++++++++++++++++++++++++++---= ---- winsup/cygwin/local_includes/winsup.h | 1 + winsup/cygwin/release/3.5.0 | 4 ++ winsup/doc/cygwinenv.xml | 25 +++++--- winsup/doc/new-features.xml | 6 ++ winsup/doc/utils.xml | 43 +++++++++----- 7 files changed, 143 insertions(+), 41 deletions(-) diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc index 008854a07..dca5c5db0 100644 --- a/winsup/cygwin/environ.cc +++ b/winsup/cygwin/environ.cc @@ -832,6 +832,7 @@ environ_init (char **envp, int envc) out: findenv_func =3D (char * (*)(const char*, int*)) my_findenv; environ =3D envp; + dumper_init (); if (envp_passed_in) { p =3D getenv ("CYGWIN"); diff --git a/winsup/cygwin/exceptions.cc b/winsup/cygwin/exceptions.cc index 642afb788..36f6a476a 100644 --- a/winsup/cygwin/exceptions.cc +++ b/winsup/cygwin/exceptions.cc @@ -52,6 +52,7 @@ details. */ #define DUMPSTACK_FRAME_LIMIT 32 =20 PWCHAR debugger_command; +PWCHAR dumper_command; extern uint8_t _sigbe; extern uint8_t _sigdelayed_end; =20 @@ -132,6 +133,42 @@ error_start_init (const char *buf) wcscat (cp, L"\""); } =20 +extern "C" void +dumper_init (void) +{ + WCHAR dll_dir[PATH_MAX]; + if (!GetModuleFileNameW (cygwin_hmodule, dll_dir, PATH_MAX)) + return; + + /* Strip off last path component ("\\cygwin1.dll") */ + PWCHAR w =3D wcsrchr (dll_dir, L'\\'); + if (!w) + return; + + *w =3D L'\0'; + + /* Calculate the length of the command, allowing for an appended DWORD P= ID and + terminating null */ + int cmd_len =3D 1 + wcslen(dll_dir) + 11 + 2 + 1 + wcslen(global_prognam= e) + 1 + 10 + 1; + if (cmd_len > 32767) + { + /* If this comes to more than the 32,767 characters CreateProcess() = can + accept, we can't work, so don't set dumper_command */ + return; + } + + dumper_command =3D (PWCHAR) malloc(cmd_len * sizeof (WCHAR)); + + PWCHAR cp =3D dumper_command; + cp =3D wcpcpy (cp, L"\""); + cp =3D wcpcpy (cp, dll_dir); + cp =3D wcpcpy (cp, L"\\dumper.exe"); + cp =3D wcpcpy (cp, L"\" "); + cp =3D wcpcpy (cp, L"\""); + cp =3D wcpcpy (cp, global_progname); + wcscat (cp, L"\""); +} + void cygwin_exception::open_stackdumpfile () { @@ -454,20 +491,14 @@ cygwin_stackdump () exc.dumpstack (); } =20 -extern "C" int -try_to_debug () +static +int exec_prepared_command (PWCHAR command) { - if (!debugger_command) + if (!command) return 0; - debug_printf ("debugger_command '%W'", debugger_command); - if (being_debugged ()) - { - extern void break_here (); - break_here (); - return 0; - } + debug_printf ("executing prepared command '%W'", command); =20 - PWCHAR dbg_end =3D wcschr (debugger_command, L'\0'); + PWCHAR dbg_end =3D wcschr (command, L'\0'); __small_swprintf (dbg_end, L" %u", GetCurrentProcessId ()); =20 LONG prio =3D GetThreadPriority (GetCurrentThread ()); @@ -509,11 +540,12 @@ try_to_debug () } FreeEnvironmentStringsW (rawenv); =20 - console_printf ("*** starting debugger for pid %u, tid %u\n", + console_printf ("*** starting '%W' for pid %u, tid %u\r\n", + command, cygwin_pid (GetCurrentProcessId ()), GetCurrentThreadId ()); BOOL dbg; dbg =3D CreateProcessW (NULL, - debugger_command, + command, NULL, NULL, FALSE, @@ -527,11 +559,15 @@ try_to_debug () 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 unt= il a debugger attaches, which stops this process, after which it can decid= e if - we continue or not. */ + we continue or not. + + Note that this is still racy: if the error_start process does it's wo= rk too + fast, we don't notice that it attached and get stuck here. + */ =20 *dbg_end =3D L'\0'; if (!dbg) - system_printf ("Failed to start debugger, %E"); + system_printf ("Failed to start, %E"); else { SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_IDLE); @@ -540,13 +576,29 @@ try_to_debug () Sleep (2000); } =20 - console_printf ("*** continuing pid %u from debugger call (%d)\n", - cygwin_pid (GetCurrentProcessId ()), dbg); + console_printf ("*** continuing pid %u\r\n", + cygwin_pid (GetCurrentProcessId ())); =20 SetThreadPriority (GetCurrentThread (), prio); return dbg; } =20 +extern "C" int +try_to_debug () +{ + /* If already being debugged, break into the debugger (Note that this fu= nction + can be called from places other than an exception) */ + if (being_debugged ()) + { + extern void break_here (); + break_here (); + return 1; + } + + /* Otherwise, invoke the JIT debugger, if set */ + return exec_prepared_command (debugger_command); +} + /* myfault exception handler. */ EXCEPTION_DISPOSITION exception::myfault (EXCEPTION_RECORD *e, exception_list *frame, CONTEXT *i= n, @@ -1264,7 +1316,6 @@ signal_exit (int sig, siginfo_t *si, void *) debug_printf ("exiting due to signal %d", sig); exit_state =3D ES_SIGNAL_EXIT; =20 - if (cygheap->rlim_core > 0UL) switch (sig) { case SIGABRT: @@ -1277,9 +1328,24 @@ signal_exit (int sig, siginfo_t *si, void *) case SIGTRAP: case SIGXCPU: case SIGXFSZ: - sig |=3D 0x80; /* Flag that we've "dumped core" */ if (try_to_debug ()) break; + + if (cygheap->rlim_core =3D=3D 0Ul) + break; + + sig |=3D 0x80; /* Set flag in exit status to show that we've "dumped core= " */ + + /* If core dump size is >1MB, try to invoke dumper to write a + .core file */ + if (cygheap->rlim_core > 1024*1024) + { + if (exec_prepared_command (dumper_command)) + break; + /* If that failed, fall-through to... */ + } + + /* Otherwise write a .stackdump */ if (si->si_code !=3D SI_USER && si->si_cyg) { cygwin_exception *exc =3D (cygwin_exception *) si->si_cyg; diff --git a/winsup/cygwin/local_includes/winsup.h b/winsup/cygwin/local_in= cludes/winsup.h index bf0a0bcc3..76957618b 100644 --- a/winsup/cygwin/local_includes/winsup.h +++ b/winsup/cygwin/local_includes/winsup.h @@ -179,6 +179,7 @@ void close_all_files (bool =3D false); =20 /* debug_on_trap support. see exceptions.cc:try_to_debug() */ extern "C" void error_start_init (const char*); +extern "C" void dumper_init (void); extern "C" int try_to_debug (); =20 void ld_preload (); diff --git a/winsup/cygwin/release/3.5.0 b/winsup/cygwin/release/3.5.0 index 6209064a6..1e62316a0 100644 --- a/winsup/cygwin/release/3.5.0 +++ b/winsup/cygwin/release/3.5.0 @@ -60,3 +60,7 @@ What changed: =20 - Enable automatic sparsifying of files on SSDs, independent of the "sparse" mount mode. + +- When RLIMIT_CORE is more than 1MB, a core dump file which can be loaded = by gdb + is now written on a fatal error. Otherwise, if it's greater than zero, a= text + format .stackdump file is written, as previously. diff --git a/winsup/doc/cygwinenv.xml b/winsup/doc/cygwinenv.xml index 5e17404a7..d97f2b77d 100644 --- a/winsup/doc/cygwinenv.xml +++ b/winsup/doc/cygwinenv.xml @@ -23,18 +23,29 @@ Defaults to off. =20 -error_start:Win32filepath - if set, runs=20 -Win32filepath when cygwin encounters a fatal error, -which is useful for debugging. Win32filepath is -usually set to the path to gdb or -dumper, for example -C:\cygwin\bin\gdb.exe. -There is no default set. +error_start:Win32filepath - if set, runs +Win32filepath when cygwin encounters a fatal error, w= hich +can be useful for debugging. Defaults to not set. + + +Win32filepath is typically set to gdb or +dumper. If giving a path in +Win32filepath, note that it is a Windows-style path a= nd not +a Cygwin path. The filename of the executing program and it's Windows process id are appe= nded to the command as arguments. + + Note: This takes priority over writing core dump or .stackdump files, if + enabled by setrlimit(RLIMIT_CORE) (e.g. via + ulimit -c). + + + Note: This has no effect if a debugger is already attached when the fatal + error occurs. + =20 diff --git a/winsup/doc/new-features.xml b/winsup/doc/new-features.xml index 0abe1c41c..f8e38f5c4 100644 --- a/winsup/doc/new-features.xml +++ b/winsup/doc/new-features.xml @@ -97,6 +97,12 @@ Enable automatic sparsifying of files on SSDs, independe= nt of the "sparse" mount mode. =20 + +When RLIMIT_CORE is more than 1MB, a core dump file which can be loaded by= gdb +is now written on a fatal error. Otherwise, if it's greater than zero, a t= ext +format .stackdump file is written, as previously. + + =20 diff --git a/winsup/doc/utils.xml b/winsup/doc/utils.xml index 9210c94e2..692dae38f 100644 --- a/winsup/doc/utils.xml +++ b/winsup/doc/utils.xml @@ -721,17 +721,17 @@ explorer $XPATH & Description The dumper utility can be used to create a co= re - dump of running Windows process. This core dump can be later loaded = to - gdb and analyzed. One common way to use - dumper is to plug it into cygwin's Just-In-Time - debugging facility by adding - -error_start=3Dx:\path\to\dumper.exe - to the - CYGWIN environment variable. Please note that - x:\path\to\dumper.exe is Windows-style and not cy= gwin - path. If error_start is set this way, then dumper= will - be started whenever some program encounters a fatal error. + dump of running Windows process. This core dump can be later loaded = into + gdb and analyzed. + + + + If the core file size limit is set to unlimited (e.g. ulimi= t -c + unlimited) and an error_start executable + hasn't been configured in the CYGWIN environment + variable, Cygwin will automatically run dumper wh= en a + fatal error occurs. + =20 dumper can be also be started from the comma= nd line to create a core dump of any running process. @@ -742,14 +742,25 @@ error_start=3Dx:\path\to\dumper.exe terminated. =20 To save space in the core dump, dumper doesn= 't - write those portions of the target process's memory space that are l= oaded + write those portions of the target process's memory space that were = loaded from executable and dll files and are unchanged (e.g. program code). Instead, dumper saves paths to the files which contain that data. When a core dump is loaded into gdb, it uses these paths to load the appropriate files. That means that if you create a= core dump on one machine and try to debug it on another, you'll need to p= lace identical copies of the executable and dlls in the same directories = as on - the machine where the core dump was created. + the machine where the core dump was created. + + + + + Notes + + A Cygwin "core dump file" is an ELF file containing the mutable part= s of + the process memory and special note sections which capture the proce= ss, + thread and loaded module context needed to recreate the process imag= e in a + debugger. + =20 @@ -1497,8 +1508,10 @@ bash$ locale noexpr =20 minidumper can be used with cygwin's Just-In-Time - debugging facility in exactly the same way as dumper - (See ). + debugging facility by adding error_start=3Dminidumper to = the + CYGWIN environment variable. If CYGWIN + is set this way, then minidumper will be started wh= enever + a program encounters a fatal exception. =20