chore: stub/exclude macOS portions, fix errors

- Use macOS-specific KickSignal
- Fix some XhyveCpu implementations
- Stub out/exclude unused gdb portions
- Use explicit allow(dead_code) to show warnings/what's missing
- Add placeholder AllBreakpoints for macOS
- Add placeholder DebugExitInfo (may need to be replaced)

Author: n0toose

src/gdb/mod.rs

@@ -18,10 +18,12 @@ use gdbstub::{
 };
 use nix::sys::pthread::{Pthread, pthread_self};
 
+#[cfg_attr(target_os = "macos", allow(unused_imports))]
+use crate::HypervisorResult;
+#[cfg_attr(target_os = "macos", allow(unused_imports))]
+use crate::os::Breakpoints;
 use crate::{
-	HypervisorResult,
 	gdb::resume::{ResumeMarker, ResumeMode},
-	os::Breakpoints,
 	vcpu::{VcpuStopReason, VirtualCPU},
 	vm::{
 		KernelInfo, VirtualizationBackend, VmPeripherals, internal::VirtualizationBackendInternal,
@@ -45,11 +47,13 @@ pub(crate) struct PthreadWrapper(pub Pthread);
 unsafe impl Send for PthreadWrapper {}
 unsafe impl Sync for PthreadWrapper {}
 
+#[cfg_attr(target_os = "macos", allow(unused))]
 pub(crate) struct VcpuWrapperShared<VCpu> {
 	pub(crate) vcpu: RwLock<VCpu>,
 	pub(crate) resume: ResumeMarker,
 }
 
+#[cfg_attr(target_os = "macos", allow(unused))]
 pub(crate) struct VcpuWrapper<VCpu> {
 	pub(crate) shared: Arc<VcpuWrapperShared<VCpu>>,
 
@@ -60,7 +64,9 @@ pub(crate) struct VcpuWrapper<VCpu> {
 	pub(crate) planned_resume_mode: Option<ResumeMode>,
 }
 
+#[cfg_attr(target_os = "macos", allow(unused))]
 pub(crate) struct GdbVcpuManager<Vm: VirtualizationBackend> {
+	#[cfg(not(target_os = "macos"))]
 	pub(crate) breakpoints: Arc<RwLock<Breakpoints>>,
 
 	pub(crate) peripherals: Arc<VmPeripherals>,
@@ -85,6 +91,7 @@ fn derive_tid(pthread: libc::pthread_t) -> NonZero<u32> {
 }
 
 impl<Vm: VirtualizationBackend> crate::vm::UhyveVm<Vm> {
+	#[cfg_attr(target_os = "macos", allow(dead_code))]
 	pub(crate) fn spawn_cpu_manager_for_gdb(
 		self,
 		cpu_affinity: Option<Vec<CoreId>>,
@@ -97,6 +104,7 @@ impl<Vm: VirtualizationBackend> crate::vm::UhyveVm<Vm> {
 		let (stops_s, stops_r) = async_channel::unbounded();
 		let peripherals = Arc::clone(&self.peripherals);
 		let kernel_info = Arc::clone(&self.kernel_info);
+		#[cfg(not(target_os = "macos"))]
 		let breakpoints = Arc::new(RwLock::new(Breakpoints::default()));
 		let cpu_affinity: Option<Arc<[_]>> = cpu_affinity.map(Arc::from);
 
@@ -107,6 +115,7 @@ impl<Vm: VirtualizationBackend> crate::vm::UhyveVm<Vm> {
 				let vcpu_id = vcpu.get_vcpu_id();
 				let vcpu = RwLock::new(vcpu);
 				let stops_s = stops_s.clone();
+				#[cfg(not(target_os = "macos"))]
 				let breakpoints = Arc::clone(&breakpoints);
 				let shared = Arc::new(VcpuWrapperShared {
 					resume: ResumeMarker {
@@ -154,6 +163,7 @@ impl<Vm: VirtualizationBackend> crate::vm::UhyveVm<Vm> {
 
 							listener.wait();
 						}
+						#[cfg(not(target_os = "macos"))]
 						shared
 							.apply_current_guest_debug(&(*breakpoints).read().unwrap())
 							.expect("GDB target error");
@@ -164,6 +174,9 @@ impl<Vm: VirtualizationBackend> crate::vm::UhyveVm<Vm> {
 							.r#continue()
 							.expect("GDB target error")
 						{
+							#[cfg(target_os = "macos")]
+							VcpuStopReason::Debug(_debug) => todo!(),
+							#[cfg(not(target_os = "macos"))]
 							VcpuStopReason::Debug(debug) => crate::os::debug_info_to_stop_reason(
 								debug,
 								tid.try_into().unwrap(),
@@ -207,6 +220,7 @@ impl<Vm: VirtualizationBackend> crate::vm::UhyveVm<Vm> {
 		trace!("tid2vcpu = {tid_to_vcpu:?}");
 
 		GdbVcpuManager {
+			#[cfg(not(target_os = "macos"))]
 			breakpoints,
 			peripherals,
 			kernel_info,
@@ -222,6 +236,7 @@ impl<Vm: VirtualizationBackend> crate::vm::UhyveVm<Vm> {
 
 impl<Vm: VirtualizationBackend> GdbVcpuManager<Vm> {
 	/// Resolves a [`Tid`] from GDB to the associated [`VcpuWrapper`].
+	#[cfg_attr(target_os = "macos", allow(dead_code))]
 	pub(crate) fn get_vcpu_wrapper(
 		&self,
 		tid: Tid,
@@ -244,6 +259,7 @@ impl<Vm: VirtualizationBackend> GdbVcpuManager<Vm> {
 	}
 
 	/// Resolves a [`Tid`] from GDB to the lock around the associated [`KvmCpu`].
+	#[cfg_attr(target_os = "macos", allow(dead_code))]
 	pub(crate) fn get_vm_cpu(
 		&self,
 		tid: Tid,
@@ -257,6 +273,7 @@ impl<VCpu: VirtualCPU> VcpuWrapperShared<VCpu> {
 	/// `ResumeMode`, and `breakpoints`.
 	///
 	/// This handles e.g. single-stepping of the vCPU.
+	#[cfg(not(target_os = "macos"))]
 	pub fn apply_current_guest_debug(&self, breakpoints: &Breakpoints) -> HypervisorResult<()> {
 		// SAFETY: we trust the value of `self.resume.mode`.
 		let mode: ResumeMode =

src/gdb/resume.rs

@@ -8,7 +8,6 @@ use gdbstub::{
 
 use crate::{
 	gdb::{GdbVcpuManager, VcpuWrapper, VcpuWrapperShared},
-	os::KickSignal,
 	vm::VirtualizationBackend,
 };
 
@@ -31,6 +30,7 @@ pub enum ResumeMode {
 impl<Vm: VirtualizationBackend> GdbVcpuManager<Vm> {
 	/// Signal to the vCPU manager that the `gdbstub` finished initializing,
 	/// i.e. exited the `Idle` state and entered the `Running` state.
+	#[cfg_attr(target_os = "macos", allow(dead_code))]
 	pub fn set_finished_initializing(&mut self) {
 		if core::mem::replace(&mut self.is_initializing, false) {
 			for i in &mut self.vcpus {
@@ -44,10 +44,11 @@ impl<Vcpu> VcpuWrapper<Vcpu> {
 	/// Kick the vCPU
 	pub fn kick(&self) {
 		trace!("vcpu: kick! {}", self.tid);
-		KickSignal::pthread_kill(self.pthread.0).unwrap();
+		crate::os::KickSignal::pthread_kill(self.pthread.0).unwrap();
 	}
 
 	/// Resume the vCPU in free-wheeling / non-stepped mode
+	#[cfg_attr(target_os = "macos", allow(dead_code))]
 	fn r#continue(&mut self) {
 		// TODO: refactor to get rid of mutability
 		let old_planned = self.planned_resume_mode.take();

src/lib.rs

@@ -74,7 +74,6 @@ pub enum HypervisorError {
 
 impl HypervisorError {
 	/// Report an (target independent) invalid value error e.g. during debug interactions
-	#[cfg_attr(target_os = "macos", expect(unused))]
 	fn backend_invalid_value() -> Self {
 		Self::BackendError({
 			#[cfg(target_os = "linux")]

src/macos/aarch64/vcpu.rs

@@ -331,7 +331,15 @@ impl VirtualCPU for XhyveCpu {
 	}
 
 	fn get_vcpu_id(&self) -> usize {
-		self.id
+		self.id.try_into().unwrap()
+	}
+
+	fn apply_current_guest_debug(
+		&mut self,
+		_breakpoints: &crate::os::Breakpoints,
+		_resume_mode: crate::gdb::resume::ResumeMode,
+	) -> HypervisorResult<()> {
+		todo!()
 	}
 }
 

src/macos/gdb/breakpoints.rs

@@ -0,0 +1,3 @@
+/// TODO: Implement breakpoinst for macOS.
+#[derive(Clone, Debug, Default)]
+pub struct AllBreakpoints;

src/macos/gdb/mod.rs

@@ -0,0 +1 @@
+pub(crate) mod breakpoints;

src/macos/mod.rs

@@ -1,16 +1,21 @@
 #[cfg(target_arch = "aarch64")]
 pub mod aarch64;
 
+pub(crate) mod gdb;
+
 use core_affinity::CoreId;
 use nix::sys::{
 	pthread::{Pthread, pthread_kill},
 	signal::{SIGUSR1, SigHandler, Signal, signal},
 };
 
-#[cfg(target_arch = "aarch64")]
 pub use crate::macos::aarch64::vcpu::{XhyveCpu, XhyveVm};
 use crate::vm::{UhyveVm, VmResult};
 
+/// TODO: Use proper structure and methods for this
+pub(crate) type DebugExitInfo = xhypervisor::ffi::hv_vcpu_exit_exception_t;
+pub(crate) type Breakpoints = gdb::breakpoints::AllBreakpoints;
+
 /// The signal for kicking vCPUs out of KVM_RUN.
 ///
 /// It is used to stop a vCPU from another thread.
@@ -38,8 +43,6 @@ impl KickSignal {
 	}
 }
 
-pub(crate) type DebugExitInfo = ();
-
 impl UhyveVm<XhyveVm> {
 	/// Runs the VM.
 	///

src/vcpu.rs

@@ -7,10 +7,6 @@ use crate::{HypervisorResult, os::DebugExitInfo};
 use crate::{gdb::resume::ResumeMode, stats::CpuStats};
 
 /// Reasons for vCPU exits.
-#[cfg_attr(
-	target_os = "macos",
-	expect(dead_code, reason = "Not all variants used in macOS.")
-)]
 pub enum VcpuStopReason {
 	/// The vCPU stopped for debugging.
 	Debug(DebugExitInfo),