fix(musl): add pthread workaround

Co-authored-by: Panagiotis "Ivory" Vasilopoulos <git@n0toose.net>
Co-authored-by: Ellen Emilia Anna Zscheile <fogti+devel@ytrizja.de>

Author: 2 people

src/linux/gdb/mod.rs

@@ -24,7 +24,7 @@ use self::breakpoints::SwBreakpoints;
 use crate::{
 	HypervisorError, HypervisorResult,
 	arch::x86_64::{registers::debug::HwBreakpoints, virt_to_phys},
-	linux::{KickSignal, x86_64::kvm_cpu::KvmVm},
+	linux::{KickSignal, PthreadWrapper, x86_64::kvm_cpu::KvmVm},
 	vcpu::{VcpuStopReason, VirtualCPU},
 	vm::UhyveVm,
 };
@@ -218,15 +218,15 @@ impl run_blocking::BlockingEventLoop for UhyveGdbEventLoop {
 		static SPAWN_THREAD: Once = Once::new();
 
 		SPAWN_THREAD.call_once(|| {
-			let parent_thread = pthread_self();
+			let parent_thread = PthreadWrapper(pthread_self());
 			let mut conn_clone = conn.try_clone().unwrap();
 			thread::spawn(move || {
 				loop {
 					// Block on TCP stream without consuming any data.
 					Read::read(&mut conn_clone, &mut []).unwrap();
 
 					// Kick VCPU out of KVM_RUN
-					KickSignal::pthread_kill(parent_thread).unwrap();
+					KickSignal::pthread_kill(parent_thread.0).unwrap();
 
 					// Wait for all inputs to be processed and for VCPU to be running again
 					thread::sleep(Duration::from_millis(20));

src/linux/mod.rs

@@ -34,6 +34,23 @@ static KVM: LazyLock<Kvm> = LazyLock::new(|| Kvm::new().unwrap());
 /// It is used to stop a vCPU from another thread.
 pub(crate) struct KickSignal;
 
+/// A way of sending pthread IDs reliably across threads.
+///
+/// # Platform-specific behavior
+///
+/// This is particularly necessary for musl, as `Pthread` is equal to `*mut c_void` there,
+/// which can't be passed to thread as easily
+///
+/// # Safety
+///
+/// This can be safely sent across threads because pthread IDs are just opaque identifiers
+/// and thread-safety is ensured by the pthread library.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct PthreadWrapper(pub Pthread);
+
+unsafe impl Send for PthreadWrapper {}
+unsafe impl Sync for PthreadWrapper {}
+
 // TODO: nix::signal::Signal doesn't support real-time signals yet.
 // Start using the Signal type once this no longer is the case.
 //

src/vm.rs

@@ -394,7 +394,11 @@ impl<VirtBackend: VirtualizationBackend> UhyveVm<VirtBackend> {
 
 		trace!("Killing all threads");
 		for thread in &threads {
-			KickSignal::pthread_kill(thread.as_pthread_t()).unwrap();
+			// The following `as _` is necessary because on some platforms, the type (aliases)
+			// - std::os::unix::thread::RawPthread, and
+			// - libc::pthread_t
+			// can differ, and currently do so on x86_64-linux-musl.
+			KickSignal::pthread_kill(thread.as_pthread_t() as _).unwrap();
 		}
 
 		let cpu_results = threads