fuzz: use process::exit panic hook in stdin_fuzz to avoid macOS hang

On macOS, panic=abort causes the process to call abort() which sends
SIGABRT. The ReportCrash daemon then tries to generate a crash report,
leaving the process stuck in an uninterruptible wait state that cannot
be killed even with SIGKILL. This makes stdin_fuzz unusable for crash
reproduction on macOS.

Install a custom panic hook that flushes stdout (preserving log output),
prints the panic info with a full backtrace to stderr, then calls
process::exit(1) to terminate cleanly before the abort machinery runs.
The hook has zero overhead during normal execution since it is only
invoked when a panic occurs.

AI tools were used in preparing this commit.

Author: joostjager

fuzz/src/bin/base32_target.rs

@@ -57,6 +57,17 @@ fuzz_target!(|data: &[u8]| {
 fn main() {
 	use std::io::Read;
 
+	// On macOS, panic=abort causes the process to send SIGABRT which can leave it
+	// stuck in an uninterruptible state due to the ReportCrash daemon. Using
+	// process::exit in a panic hook avoids this by terminating cleanly.
+	std::panic::set_hook(Box::new(|panic_info| {
+		use std::io::Write;
+		let _ = std::io::stdout().flush();
+		eprintln!("{}\n{}", panic_info, std::backtrace::Backtrace::force_capture());
+		let _ = std::io::stderr().flush();
+		std::process::exit(1);
+	}));
+
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
 	base32_test(&data, lightning_fuzz::utils::test_logger::Stdout {});

fuzz/src/bin/bech32_parse_target.rs

@@ -57,6 +57,17 @@ fuzz_target!(|data: &[u8]| {
 fn main() {
 	use std::io::Read;
 
+	// On macOS, panic=abort causes the process to send SIGABRT which can leave it
+	// stuck in an uninterruptible state due to the ReportCrash daemon. Using
+	// process::exit in a panic hook avoids this by terminating cleanly.
+	std::panic::set_hook(Box::new(|panic_info| {
+		use std::io::Write;
+		let _ = std::io::stdout().flush();
+		eprintln!("{}\n{}", panic_info, std::backtrace::Backtrace::force_capture());
+		let _ = std::io::stderr().flush();
+		std::process::exit(1);
+	}));
+
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
 	bech32_parse_test(&data, lightning_fuzz::utils::test_logger::Stdout {});

fuzz/src/bin/bolt11_deser_target.rs

@@ -57,6 +57,17 @@ fuzz_target!(|data: &[u8]| {
 fn main() {
 	use std::io::Read;
 
+	// On macOS, panic=abort causes the process to send SIGABRT which can leave it
+	// stuck in an uninterruptible state due to the ReportCrash daemon. Using
+	// process::exit in a panic hook avoids this by terminating cleanly.
+	std::panic::set_hook(Box::new(|panic_info| {
+		use std::io::Write;
+		let _ = std::io::stdout().flush();
+		eprintln!("{}\n{}", panic_info, std::backtrace::Backtrace::force_capture());
+		let _ = std::io::stderr().flush();
+		std::process::exit(1);
+	}));
+
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
 	bolt11_deser_test(&data, lightning_fuzz::utils::test_logger::Stdout {});

fuzz/src/bin/chanmon_consistency_target.rs

@@ -57,6 +57,17 @@ fuzz_target!(|data: &[u8]| {
 fn main() {
 	use std::io::Read;
 
+	// On macOS, panic=abort causes the process to send SIGABRT which can leave it
+	// stuck in an uninterruptible state due to the ReportCrash daemon. Using
+	// process::exit in a panic hook avoids this by terminating cleanly.
+	std::panic::set_hook(Box::new(|panic_info| {
+		use std::io::Write;
+		let _ = std::io::stdout().flush();
+		eprintln!("{}\n{}", panic_info, std::backtrace::Backtrace::force_capture());
+		let _ = std::io::stderr().flush();
+		std::process::exit(1);
+	}));
+
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
 	chanmon_consistency_test(&data, lightning_fuzz::utils::test_logger::Stdout {});

fuzz/src/bin/chanmon_deser_target.rs

@@ -57,6 +57,17 @@ fuzz_target!(|data: &[u8]| {
 fn main() {
 	use std::io::Read;
 
+	// On macOS, panic=abort causes the process to send SIGABRT which can leave it
+	// stuck in an uninterruptible state due to the ReportCrash daemon. Using
+	// process::exit in a panic hook avoids this by terminating cleanly.
+	std::panic::set_hook(Box::new(|panic_info| {
+		use std::io::Write;
+		let _ = std::io::stdout().flush();
+		eprintln!("{}\n{}", panic_info, std::backtrace::Backtrace::force_capture());
+		let _ = std::io::stderr().flush();
+		std::process::exit(1);
+	}));
+
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
 	chanmon_deser_test(&data, lightning_fuzz::utils::test_logger::Stdout {});

fuzz/src/bin/feature_flags_target.rs

@@ -57,6 +57,17 @@ fuzz_target!(|data: &[u8]| {
 fn main() {
 	use std::io::Read;
 
+	// On macOS, panic=abort causes the process to send SIGABRT which can leave it
+	// stuck in an uninterruptible state due to the ReportCrash daemon. Using
+	// process::exit in a panic hook avoids this by terminating cleanly.
+	std::panic::set_hook(Box::new(|panic_info| {
+		use std::io::Write;
+		let _ = std::io::stdout().flush();
+		eprintln!("{}\n{}", panic_info, std::backtrace::Backtrace::force_capture());
+		let _ = std::io::stderr().flush();
+		std::process::exit(1);
+	}));
+
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
 	feature_flags_test(&data, lightning_fuzz::utils::test_logger::Stdout {});

fuzz/src/bin/fromstr_to_netaddress_target.rs

@@ -57,6 +57,17 @@ fuzz_target!(|data: &[u8]| {
 fn main() {
 	use std::io::Read;
 
+	// On macOS, panic=abort causes the process to send SIGABRT which can leave it
+	// stuck in an uninterruptible state due to the ReportCrash daemon. Using
+	// process::exit in a panic hook avoids this by terminating cleanly.
+	std::panic::set_hook(Box::new(|panic_info| {
+		use std::io::Write;
+		let _ = std::io::stdout().flush();
+		eprintln!("{}\n{}", panic_info, std::backtrace::Backtrace::force_capture());
+		let _ = std::io::stderr().flush();
+		std::process::exit(1);
+	}));
+
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
 	fromstr_to_netaddress_test(&data, lightning_fuzz::utils::test_logger::Stdout {});

fuzz/src/bin/fs_store_target.rs

@@ -57,6 +57,17 @@ fuzz_target!(|data: &[u8]| {
 fn main() {
 	use std::io::Read;
 
+	// On macOS, panic=abort causes the process to send SIGABRT which can leave it
+	// stuck in an uninterruptible state due to the ReportCrash daemon. Using
+	// process::exit in a panic hook avoids this by terminating cleanly.
+	std::panic::set_hook(Box::new(|panic_info| {
+		use std::io::Write;
+		let _ = std::io::stdout().flush();
+		eprintln!("{}\n{}", panic_info, std::backtrace::Backtrace::force_capture());
+		let _ = std::io::stderr().flush();
+		std::process::exit(1);
+	}));
+
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
 	fs_store_test(&data, lightning_fuzz::utils::test_logger::Stdout {});

fuzz/src/bin/full_stack_target.rs

@@ -57,6 +57,17 @@ fuzz_target!(|data: &[u8]| {
 fn main() {
 	use std::io::Read;
 
+	// On macOS, panic=abort causes the process to send SIGABRT which can leave it
+	// stuck in an uninterruptible state due to the ReportCrash daemon. Using
+	// process::exit in a panic hook avoids this by terminating cleanly.
+	std::panic::set_hook(Box::new(|panic_info| {
+		use std::io::Write;
+		let _ = std::io::stdout().flush();
+		eprintln!("{}\n{}", panic_info, std::backtrace::Backtrace::force_capture());
+		let _ = std::io::stderr().flush();
+		std::process::exit(1);
+	}));
+
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
 	full_stack_test(&data, lightning_fuzz::utils::test_logger::Stdout {});

fuzz/src/bin/indexedmap_target.rs

@@ -57,6 +57,17 @@ fuzz_target!(|data: &[u8]| {
 fn main() {
 	use std::io::Read;
 
+	// On macOS, panic=abort causes the process to send SIGABRT which can leave it
+	// stuck in an uninterruptible state due to the ReportCrash daemon. Using
+	// process::exit in a panic hook avoids this by terminating cleanly.
+	std::panic::set_hook(Box::new(|panic_info| {
+		use std::io::Write;
+		let _ = std::io::stdout().flush();
+		eprintln!("{}\n{}", panic_info, std::backtrace::Backtrace::force_capture());
+		let _ = std::io::stderr().flush();
+		std::process::exit(1);
+	}));
+
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
 	indexedmap_test(&data, lightning_fuzz::utils::test_logger::Stdout {});