kill based tests

danielsn · danielsn · commit 3fa42280a7ec · 2025-02-14T14:12:27.000-05:00
diff --git a/bin_tests/src/bin/crashtracker_bin_test.rs b/bin_tests/src/bin/crashtracker_bin_test.rs
@@ -13,7 +13,10 @@ fn main() -> anyhow::Result<()> {
 mod unix {
     use anyhow::Context;
     use bin_tests::modes::behavior::get_behavior;
-    use nix::sys::signal::{raise, Signal};
+    use nix::{
+        sys::signal::{kill, raise, Signal},
+        unistd::Pid,
+    };
     use std::env;
     use std::path::Path;
 
@@ -100,14 +103,18 @@ mod unix {
 
         crashtracker::begin_op(crashtracker::OpTypes::ProfilerCollectingSample)?;
         match crash_typ.as_str() {
+            "kill_sigabrt" => kill(Pid::this(), Signal::SIGABRT)?,
+            "kill_sigill" => kill(Pid::this(), Signal::SIGILL)?,
+            "kill_sigbus" => kill(Pid::this(), Signal::SIGBUS)?,
+            "kill_sigsegv" => kill(Pid::this(), Signal::SIGSEGV)?,
             "null_deref" => {
                 let x = unsafe { deref_ptr(std::ptr::null_mut::<u8>()) };
                 println!("{x}");
             }
-            "sigabrt" => raise(Signal::SIGABRT)?,
-            "sigill" => raise(Signal::SIGILL)?,
-            "sigbus" => raise(Signal::SIGBUS)?,
-            "sigsegv" => raise(Signal::SIGSEGV)?,
+            "raise_sigabrt" => raise(Signal::SIGABRT)?,
+            "raise_sigill" => raise(Signal::SIGILL)?,
+            "raise_sigbus" => raise(Signal::SIGBUS)?,
+            "raise_sigsegv" => raise(Signal::SIGSEGV)?,
             _ => anyhow::bail!("Unexpected crash_typ: {crash_typ}"),
         }
         crashtracker::end_op(crashtracker::OpTypes::ProfilerCollectingSample)?;
diff --git a/bin_tests/tests/crashtracker_bin_test.rs b/bin_tests/tests/crashtracker_bin_test.rs
@@ -69,30 +69,58 @@ fn test_crash_tracking_bin_fork() {
 
 #[test]
 #[cfg_attr(miri, ignore)]
-fn test_crash_tracking_bin_abort() {
+fn test_crash_tracking_bin_kill_sigabrt() {
     // For now, do the base test (donothing).  For future we should probably also test chaining.
-    test_crash_tracking_bin(BuildProfile::Release, "donothing", "sigabrt");
+    test_crash_tracking_bin(BuildProfile::Release, "donothing", "kill_sigabrt");
 }
 
 #[test]
 #[cfg_attr(miri, ignore)]
-fn test_crash_tracking_bin_sigill() {
+fn test_crash_tracking_bin_kill_sigill() {
     // For now, do the base test (donothing).  For future we should probably also test chaining.
-    test_crash_tracking_bin(BuildProfile::Release, "donothing", "sigill");
+    test_crash_tracking_bin(BuildProfile::Release, "donothing", "kill_sigill");
 }
 
 #[test]
 #[cfg_attr(miri, ignore)]
-fn test_crash_tracking_bin_sigbus() {
+fn test_crash_tracking_bin_kill_sigbus() {
     // For now, do the base test (donothing).  For future we should probably also test chaining.
-    test_crash_tracking_bin(BuildProfile::Release, "donothing", "sigbus");
+    test_crash_tracking_bin(BuildProfile::Release, "donothing", "kill_sigbus");
 }
 
 #[test]
 #[cfg_attr(miri, ignore)]
-fn test_crash_tracking_bin_sigsegv() {
+fn test_crash_tracking_bin_kill_sigsegv() {
     // For now, do the base test (donothing).  For future we should probably also test chaining.
-    test_crash_tracking_bin(BuildProfile::Release, "donothing", "sigsegv");
+    test_crash_tracking_bin(BuildProfile::Release, "donothing", "kill_sigsegv");
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn test_crash_tracking_bin_raise_sigabrt() {
+    // For now, do the base test (donothing).  For future we should probably also test chaining.
+    test_crash_tracking_bin(BuildProfile::Release, "donothing", "raise_sigabrt");
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn test_crash_tracking_bin_raise_sigill() {
+    // For now, do the base test (donothing).  For future we should probably also test chaining.
+    test_crash_tracking_bin(BuildProfile::Release, "donothing", "raise_sigill");
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn test_crash_tracking_bin_raise_sigbus() {
+    // For now, do the base test (donothing).  For future we should probably also test chaining.
+    test_crash_tracking_bin(BuildProfile::Release, "donothing", "raise_sigbus");
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn test_crash_tracking_bin_raise_sigsegv() {
+    // For now, do the base test (donothing).  For future we should probably also test chaining.
+    test_crash_tracking_bin(BuildProfile::Release, "donothing", "raise_sigsegv");
 }
 
 fn test_crash_tracking_bin(
@@ -122,8 +150,12 @@ fn test_crash_tracking_bin(
     // Not sure why sigill behaves differently??
     // TODO: figure that out.
     match crash_typ {
-        "null_deref" | "sigabrt" | "sigill" => assert!(!exit_status.success()),
-        "sigbus" | "sigsegv" => (),
+        "kill_sigabrt" | "kill_sigill" | "null_deref" | "raise_sigabrt" | "raise_sigill" => {
+            assert!(!exit_status.success())
+        }
+        "kill_sigbus" | "kill_sigsegv" | "raise_sigbus" | "raise_sigsegv" => {
+            assert!(exit_status.success())
+        }
         _ => unreachable!("{crash_typ} shouldn't happen"),
     }
 
@@ -186,22 +218,6 @@ fn test_crash_tracking_bin(
 
 fn assert_siginfo_message(sig_info: &Value, crash_typ: &str) {
     match crash_typ {
-        "sigabrt" => {
-            assert_eq!(sig_info["si_signo"], libc::SIGABRT);
-            assert_eq!(sig_info["si_signo_human_readable"], "SIGABRT");
-        }
-        "sigsegv" => {
-            assert_eq!(sig_info["si_signo"], libc::SIGSEGV);
-            assert_eq!(sig_info["si_signo_human_readable"], "SIGSEGV");
-        }
-        "sigbus" => {
-            assert_eq!(sig_info["si_signo"], libc::SIGBUS);
-            assert_eq!(sig_info["si_signo_human_readable"], "SIGBUS");
-        }
-        "sigill" => {
-            assert_eq!(sig_info["si_signo"], libc::SIGILL);
-            assert_eq!(sig_info["si_signo_human_readable"], "SIGILL");
-        }
         "null_deref" =>
         // On every platform other than OSX ARM, the si_code is 1: SEGV_MAPERR
         // On OSX ARM, its 2: SEGV_ACCERR
@@ -219,6 +235,72 @@ fn assert_siginfo_message(sig_info: &Value, crash_typ: &str) {
             assert_eq!(sig_info["si_signo"], libc::SIGSEGV);
             assert_eq!(sig_info["si_signo_human_readable"], "SIGSEGV");
         }
+
+        "kill_sigabrt" => {
+            assert_eq!(sig_info["si_signo"], libc::SIGABRT);
+            assert_eq!(sig_info["si_signo_human_readable"], "SIGABRT");
+            // https://vorner.github.io/2021/01/03/dark-side-of-posix-apis.html
+            // OSX signal handling is the worst.
+            assert!(
+                sig_info["si_code_human_readable"] == "UNKNOWN"
+                    || sig_info["si_code_human_readable"] == "SI_USER",
+                "{sig_info:?}"
+            );
+        }
+        "kill_sigsegv" => {
+            assert_eq!(sig_info["si_signo"], libc::SIGSEGV);
+            assert_eq!(sig_info["si_signo_human_readable"], "SIGSEGV");
+            // https://vorner.github.io/2021/01/03/dark-side-of-posix-apis.html
+            // OSX signal handling is the worst.
+            assert!(
+                matches!(
+                    sig_info["si_code_human_readable"].as_str().unwrap(),
+                    "UNKNOWN" | "SI_USER" | "SEGV_ACCERR"
+                ),
+                "{sig_info:?}"
+            );
+        }
+        "kill_sigbus" => {
+            assert_eq!(sig_info["si_signo"], libc::SIGBUS);
+            assert_eq!(sig_info["si_signo_human_readable"], "SIGBUS");
+            // https://vorner.github.io/2021/01/03/dark-side-of-posix-apis.html
+            // OSX signal handling is the worst.
+            assert!(
+                matches!(
+                    sig_info["si_code_human_readable"].as_str().unwrap(),
+                    "UNKNOWN" | "SI_USER" | "BUS_ADRALN"
+                ),
+                "{sig_info:?}"
+            );
+
+        }
+        "kill_sigill" => {
+            assert_eq!(sig_info["si_signo"], libc::SIGILL);
+            assert_eq!(sig_info["si_signo_human_readable"], "SIGILL");
+            // https://vorner.github.io/2021/01/03/dark-side-of-posix-apis.html
+            // OSX signal handling is the worst.
+            assert!(
+                sig_info["si_code_human_readable"] == "UNKNOWN"
+                    || sig_info["si_code_human_readable"] == "SI_USER",
+                "{sig_info:?}"
+            );
+        }
+        "raise_sigabrt" => {
+            assert_eq!(sig_info["si_signo"], libc::SIGABRT);
+            assert_eq!(sig_info["si_signo_human_readable"], "SIGABRT");
+        }
+        "raise_sigsegv" => {
+            assert_eq!(sig_info["si_signo"], libc::SIGSEGV);
+            assert_eq!(sig_info["si_signo_human_readable"], "SIGSEGV");
+        }
+        "raise_sigbus" => {
+            assert_eq!(sig_info["si_signo"], libc::SIGBUS);
+            assert_eq!(sig_info["si_signo_human_readable"], "SIGBUS");
+        }
+        "raise_sigill" => {
+            assert_eq!(sig_info["si_signo"], libc::SIGILL);
+            assert_eq!(sig_info["si_signo_human_readable"], "SIGILL");
+        }
         _ => panic!("unexpected crash_typ {crash_typ}"),
     }
 }
@@ -260,12 +342,32 @@ fn assert_telemetry_message(crash_telemetry: &[u8], crash_typ: &str) {
         ]);
 
     match crash_typ {
-        "sigabrt" => {
+        "null_deref" => {
+            assert!(base_expected_tags.is_subset(&tags), "{tags:?}");
+            assert!(tags.contains("si_addr:0x0000000000000000"), "{tags:?}");
+            assert!(
+                tags.contains("si_code_human_readable:SEGV_ACCERR")
+                    || tags.contains("si_code_human_readable:SEGV_MAPERR"),
+                "{tags:?}"
+            );
+            assert!(tags.contains("si_signo_human_readable:SIGSEGV"), "{tags:?}");
+            assert!(tags.contains("si_signo:11"), "{tags:?}");
+            assert!(
+                tags.contains("si_code:1") || tags.contains("si_code:2"),
+                "{tags:?}"
+            );
+        }
+        "kill_sigabrt" => {
             assert!(base_expected_tags.is_subset(&tags), "{tags:?}");
             assert!(tags.contains("si_signo_human_readable:SIGABRT"), "{tags:?}");
             assert!(tags.contains("si_signo:6"), "{tags:?}");
         }
-        "sigbus" => {
+        "kill_sigill" => {
+            assert!(base_expected_tags.is_subset(&tags), "{tags:?}");
+            assert!(tags.contains("si_signo_human_readable:SIGILL"), "{tags:?}");
+            assert!(tags.contains("si_signo:4"), "{tags:?}");
+        }
+        "kill_sigbus" => {
             assert!(base_expected_tags.is_subset(&tags), "{tags:?}");
             assert!(tags.contains("si_signo_human_readable:SIGBUS"), "{tags:?}");
             // SIGBUS can be 7 or 10, depending on the os.
@@ -274,30 +376,34 @@ fn assert_telemetry_message(crash_telemetry: &[u8], crash_typ: &str) {
                 "{tags:?}"
             );
         }
-        "sigill" => {
-            assert!(base_expected_tags.is_subset(&tags), "{tags:?}");
-            assert!(tags.contains("si_signo_human_readable:SIGILL"), "{tags:?}");
-            assert!(tags.contains("si_signo:4"), "{tags:?}");
-        }
-        "sigsegv" => {
+        "kill_sigsegv" => {
             assert!(base_expected_tags.is_subset(&tags), "{tags:?}");
             assert!(tags.contains("si_signo_human_readable:SIGSEGV"), "{tags:?}");
             assert!(tags.contains("si_signo:11"), "{tags:?}");
         }
-        "null_deref" => {
+        "raise_sigabrt" => {
             assert!(base_expected_tags.is_subset(&tags), "{tags:?}");
-            assert!(tags.contains("si_addr:0x0000000000000000"), "{tags:?}");
+            assert!(tags.contains("si_signo_human_readable:SIGABRT"), "{tags:?}");
+            assert!(tags.contains("si_signo:6"), "{tags:?}");
+        }
+        "raise_sigill" => {
+            assert!(base_expected_tags.is_subset(&tags), "{tags:?}");
+            assert!(tags.contains("si_signo_human_readable:SIGILL"), "{tags:?}");
+            assert!(tags.contains("si_signo:4"), "{tags:?}");
+        }
+        "raise_sigbus" => {
+            assert!(base_expected_tags.is_subset(&tags), "{tags:?}");
+            assert!(tags.contains("si_signo_human_readable:SIGBUS"), "{tags:?}");
+            // SIGBUS can be 7 or 10, depending on the os.
             assert!(
-                tags.contains("si_code_human_readable:SEGV_ACCERR")
-                    || tags.contains("si_code_human_readable:SEGV_MAPERR"),
+                tags.contains(format!("si_signo:{}", libc::SIGBUS).as_str()),
                 "{tags:?}"
             );
+        }
+        "raise_sigsegv" => {
+            assert!(base_expected_tags.is_subset(&tags), "{tags:?}");
             assert!(tags.contains("si_signo_human_readable:SIGSEGV"), "{tags:?}");
             assert!(tags.contains("si_signo:11"), "{tags:?}");
-            assert!(
-                tags.contains("si_code:1") || tags.contains("si_code:2"),
-                "{tags:?}"
-            );
         }
         _ => panic!("{crash_typ}"),
     }
diff --git a/crashtracker/src/crash_info/emit_sicodes.c b/crashtracker/src/crash_info/emit_sicodes.c
@@ -10,6 +10,8 @@
 //! export constants for si_code types.
 //! As a workaround, link some C code which DOES have access to the types on the current platform
 //! and use it to do the translation.
+//! Also, OSX doesn't always set the value at all, which sucks
+//! https://vorner.github.io/2021/01/03/dark-side-of-posix-apis.html
 
 // MUST REMAIN IN SYNC WITH THE ENUM IN SIG_INFO.RS
 enum SiCodes {
@@ -47,6 +49,8 @@ enum SiCodes {
 /// @param si_code
 /// @return The enum value of the si_code, given signum. UNKNOWN if unable to translate.
 int translate_si_code_impl(int signum, int si_code) {
+  // TODO, handle ptrace events
+
   switch (si_code) {
   case SI_USER:
     return SI_CODE_SI_USER;
