Allow suppressing panics.

This makes it possible to incrementally adopt tracing-mutex
in a library shared by many binaries in the same project without
having to fix all potential deadlocks in all binaries at once. The
binaries that don't yet have proper lock hygeine can opt-out of
real enforcement until their deadlocks are addressed.

Author: anp

src/lib.rs

@@ -116,6 +116,9 @@ mod reporting;
 pub mod stdsync;
 pub mod util;
 
+#[cfg(feature = "experimental")]
+pub use reporting::{set_panic_action, PanicAction};
+
 thread_local! {
     /// Stack to track which locks are held
     ///
@@ -188,7 +191,7 @@ impl MutexId {
         });
 
         if let Some(cycle) = opt_cycle {
-            panic!("{}", Dep::panic_message(&cycle))
+            reporting::report_cycle(&cycle);
         }
 
         HELD_LOCKS.with(|locks| locks.borrow_mut().push(self.value()));

src/reporting.rs

@@ -6,6 +6,8 @@ use std::backtrace::Backtrace;
 use std::borrow::Cow;
 use std::fmt::Write;
 use std::sync::Arc;
+use std::sync::atomic::AtomicU8;
+use std::sync::atomic::Ordering;
 
 #[cfg(feature = "backtraces")]
 pub type Dep = MutexDep<Arc<Backtrace>>;
@@ -15,12 +17,44 @@ pub type Dep = MutexDep<()>;
 // Base message to be reported when cycle is detected
 const BASE_MESSAGE: &str = "Found cycle in mutex dependency graph:";
 
+/// Action to take when a cycle is detected.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum PanicAction {
+    /// Panic when a cycle is detected.
+    Panic = 0,
+    /// Log the cycle to stderr but do not panic.
+    #[cfg(feature = "experimental")]
+    Log = 1,
+}
+
+static PANIC_ACTION: AtomicU8 = AtomicU8::new(0);
+
+/// Set the action to take when a cycle is detected.
+///
+/// This is useful for incrementally adopting tracing-mutex to a large codebase compiled with
+/// `panic=abort`, as it allows you to continue running your program even when a cycle is detected.
+#[cfg(feature = "experimental")]
+pub fn set_panic_action(action: PanicAction) {
+    PANIC_ACTION.store(action as u8, Ordering::Relaxed);
+}
+
+pub(crate) fn report_cycle(cycle: &[Dep]) {
+    let message = Dep::message(cycle);
+    let action = PANIC_ACTION.load(Ordering::Relaxed);
+    if action == PanicAction::Panic as u8 {
+        panic!("{message}");
+    } else {
+        eprintln!("{message}");
+    }
+}
+
 pub trait Reportable: Clone {
     /// Capture the current state
     fn capture() -> Self;
 
     /// Format a trace of state for human readable consumption.
-    fn panic_message(trace: &[Self]) -> Cow<'static, str>;
+    fn message(trace: &[Self]) -> Cow<'static, str>;
 }
 
 #[derive(Clone)]
@@ -35,7 +69,7 @@ impl Reportable for MutexDep<()> {
         Self(())
     }
 
-    fn panic_message(_trace: &[Self]) -> Cow<'static, str> {
+    fn message(_trace: &[Self]) -> Cow<'static, str> {
         Cow::Borrowed(BASE_MESSAGE)
     }
 }
@@ -52,7 +86,7 @@ impl Reportable for MutexDep<Arc<Backtrace>> {
         Self(Arc::new(Backtrace::capture()))
     }
 
-    fn panic_message(trace: &[Self]) -> Cow<'static, str> {
+    fn message(trace: &[Self]) -> Cow<'static, str> {
         let mut message = format!("{BASE_MESSAGE}\n");
 
         for entry in trace {