Abort for GC thread panic (#221)

The code is mainly from `mmrk-ruby`. We hijack the Rust panic hook to
make sure that if the GC threads panic, the process will be aborted. The
current behavior is that when a GC thread panics, the process hangs and
wait for that GC thread to finish its work.

This should be ported to `master`.

Author: qinsoon

mmtk/src/api.rs

@@ -95,6 +95,9 @@ pub extern "C" fn mmtk_gc_init(
     // Make sure we initialize MMTk here
     lazy_static::initialize(&SINGLETON);
 
+    // Hijack the panic hook to make sure that if we crash in the GC threads, the process aborts.
+    crate::set_panic_hook();
+
     // Assert to make sure our fastpath allocation is correct.
     {
         // If the assertion failed, check the allocation fastpath in Julia

mmtk/src/collection.rs

@@ -16,6 +16,27 @@ use crate::{BLOCK_FOR_GC, STW_COND, WORLD_HAS_STOPPED};
 static GC_START: AtomicU64 = AtomicU64::new(0);
 static CURRENT_GC_MAY_MOVE: AtomicBool = AtomicBool::new(true);
 
+use std::collections::HashSet;
+use std::sync::RwLock;
+use std::thread::ThreadId;
+
+lazy_static! {
+    static ref GC_THREADS: RwLock<HashSet<ThreadId>> = RwLock::new(HashSet::new());
+}
+
+pub(crate) fn register_gc_thread() {
+    let id = std::thread::current().id();
+    GC_THREADS.write().unwrap().insert(id);
+}
+pub(crate) fn unregister_gc_thread() {
+    let id = std::thread::current().id();
+    GC_THREADS.write().unwrap().remove(&id);
+}
+pub(crate) fn is_gc_thread() -> bool {
+    let id = std::thread::current().id();
+    GC_THREADS.read().unwrap().contains(&id)
+}
+
 pub struct VMCollection {}
 
 impl Collection<JuliaVM> for VMCollection {
@@ -99,6 +120,11 @@ impl Collection<JuliaVM> for VMCollection {
             .spawn(move || {
                 use mmtk::util::opaque_pointer::*;
                 use mmtk::util::Address;
+
+                // Remember this GC thread
+                register_gc_thread();
+
+                // Start the worker loop
                 let worker_tls = VMWorkerThread(VMThread(OpaquePointer::from_address(unsafe {
                     Address::from_usize(thread_id::get())
                 })));
@@ -107,6 +133,9 @@ impl Collection<JuliaVM> for VMCollection {
                         mmtk::memory_manager::start_worker(&SINGLETON, worker_tls, w)
                     }
                 }
+
+                // The GC thread quits somehow. Unresgister this GC thread
+                unregister_gc_thread();
             });
     }
 

mmtk/src/lib.rs

@@ -143,3 +143,37 @@ macro_rules! early_return_for_current_gc {
         }
     };
 }
+
+pub(crate) fn set_panic_hook() {
+    let old_hook = std::panic::take_hook();
+
+    std::panic::set_hook(Box::new(move |panic_info| {
+        if crate::collection::is_gc_thread() {
+            eprintln!("ERROR: An MMTk GC thread panicked.  This is a bug.");
+            eprintln!("{panic_info}");
+
+            let bt = std::backtrace::Backtrace::capture();
+            match bt.status() {
+                std::backtrace::BacktraceStatus::Unsupported => {
+                    eprintln!("Backtrace is unsupported.")
+                }
+                std::backtrace::BacktraceStatus::Disabled => {
+                    eprintln!("Backtrace is disabled.");
+                    eprintln!(
+                        "run with `RUST_BACKTRACE=1` environment variable to display a backtrace"
+                    );
+                }
+                std::backtrace::BacktraceStatus::Captured => {
+                    eprintln!("{bt}");
+                }
+                s => {
+                    eprintln!("Unknown backtrace status: {s:?}");
+                }
+            }
+
+            std::process::abort();
+        } else {
+            old_hook(panic_info);
+        }
+    }));
+}