timeout: don't dump core when re-raising the child's signal

src/uu/timeout/src/platform/unix.rs

@@ -3,7 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) sigstr setpgid sigchld sigwait getpid TTIN TTOU
+// spell-checker:ignore (ToDO) sigstr setpgid sigchld sigwait getpid TTIN TTOU rlimit setrlimit Dumpable
 
 use std::io;
 use std::os::unix::process::CommandExt;
@@ -136,9 +136,31 @@
     // The easiest way to preserve the latter seems to be to kill
     // ourselves with whatever signal our child exited with, which is
     // what the following is intended to accomplish.
-    if let Some(sig) = signal_from_raw(signal) {
+    //
+    // If the child dumped core, re-raising a signal like SIGSEGV would make
+    // us dump core too and get blamed for the crash, so only do it once
+    // core dumps are off.
+    if let Some(sig) = signal_from_raw(signal)
+        && disable_core_dumps()
+    {
         let _ = unblock_signal(sig);
         let _ = kill_process(getpid(), sig);
     }
     signal
 }
+
+/// Make sure this process won't dump core, returning whether that worked.
+fn disable_core_dumps() -> bool {
+    use rustix::process::{Resource, Rlimit, setrlimit};
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    if rustix::process::set_dumpable_behavior(rustix::process::DumpableBehavior::NotDumpable)
+        .is_ok()
+    {
+        return true;
+    }
+    let limit = Rlimit {
+        current: Some(0),
+        maximum: Some(0),
+    };
+    setrlimit(Resource::Core, limit).is_ok()
+}

tests/by-util/test_timeout.rs

@@ -169,6 +169,25 @@ fn test_kill_signal_reports_signal_exit_code() {
         .no_output();
 }
 
+/// When the child dumps core, timeout re-raises its signal without dumping
+/// core itself.
+// Linux only: on macOS the child would write a real core file into /cores.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_child_core_dump_not_repeated() {
+    use std::os::unix::process::ExitStatusExt;
+    let ts = TestScenario::new(util_name!());
+    let script = r#"ulimit -c unlimited 2>/dev/null; exec "$0" timeout 5 sh -c 'kill -SEGV $$'"#;
+    let status = std::process::Command::new("sh")
+        .args(["-c", script])
+        .arg(&ts.bin_path)
+        .current_dir(ts.fixtures.as_string())
+        .status()
+        .unwrap();
+    assert_eq!(status.signal(), Some(libc::SIGSEGV));
+    assert!(!status.core_dumped());
+}
+
 #[test]
 fn test_preserve_status_even_when_send_signal() {
     let (ts, bin) = scenario_with_bin();