Expliclity call crate::debug! instead of debug! to differentiate from log::debug, and alias feature with debug_assertions

Signed-off-by: Ludvig Liljenberg <[email protected]>

Author: ludfjig

src/hyperlight_host/build.rs

@@ -96,6 +96,8 @@ fn main() -> Result<()> {
         inprocess: { all(feature = "inprocess", debug_assertions) },
         // crashdump feature is aliased with debug_assertions to make it only available in debug-builds.
         crashdump: { all(feature = "crashdump", debug_assertions) },
+        // print_debug feature is aliased with debug_assertions to make it only available in debug-builds.
+        print_debug: { all(feature = "print_debug", debug_assertions) },
     }
 
     write_built_file()?;

src/hyperlight_host/src/hypervisor/hyperv_linux.rs

@@ -37,7 +37,7 @@ use crate::hypervisor::hypervisor_handler::HypervisorHandler;
 use crate::hypervisor::HyperlightExit;
 use crate::mem::memory_region::{MemoryRegion, MemoryRegionFlags};
 use crate::mem::ptr::{GuestPtr, RawPtr};
-use crate::{debug, log_then_return, new_error, Result};
+use crate::{log_then_return, new_error, Result};
 
 /// Determine whether the HyperV for Linux hypervisor API is present
 /// and functional.
@@ -287,7 +287,7 @@ impl Hypervisor for HypervLinuxDriver {
         let result = match &self.vcpu_fd.run(hv_message) {
             Ok(m) => match m.header.message_type {
                 HALT_MESSAGE => {
-                    debug!("mshv - Halt Details : {:#?}", &self);
+                    crate::debug!("mshv - Halt Details : {:#?}", &self);
                     HyperlightExit::Halt()
                 }
                 IO_PORT_INTERCEPT_MESSAGE => {
@@ -296,7 +296,7 @@ impl Hypervisor for HypervLinuxDriver {
                     let rip = io_message.header.rip;
                     let rax = io_message.rax;
                     let instruction_length = io_message.header.instruction_length() as u64;
-                    debug!("mshv IO Details : \nPort : {}\n{:#?}", port_number, &self);
+                    crate::debug!("mshv IO Details : \nPort : {}\n{:#?}", port_number, &self);
                     HyperlightExit::IoOut(
                         port_number,
                         rax.to_le_bytes().to_vec(),
@@ -307,19 +307,21 @@ impl Hypervisor for HypervLinuxDriver {
                 UNMAPPED_GPA_MESSAGE => {
                     let mimo_message = m.to_memory_info()?;
                     let addr = mimo_message.guest_physical_address;
-                    debug!(
+                    crate::debug!(
                         "mshv MMIO unmapped GPA -Details: Address: {} \n {:#?}",
-                        addr, &self
+                        addr,
+                        &self
                     );
                     HyperlightExit::Mmio(addr)
                 }
                 INVALID_GPA_ACCESS_MESSAGE => {
                     let mimo_message = m.to_memory_info()?;
                     let gpa = mimo_message.guest_physical_address;
                     let access_info = MemoryRegionFlags::try_from(mimo_message)?;
-                    debug!(
+                    crate::debug!(
                         "mshv MMIO invalid GPA access -Details: Address: {} \n {:#?}",
-                        gpa, &self
+                        gpa,
+                        &self
                     );
                     match self.get_memory_access_violation(
                         gpa as usize,
@@ -331,7 +333,7 @@ impl Hypervisor for HypervLinuxDriver {
                     }
                 }
                 other => {
-                    debug!("mshv Other Exit: Exit: {:#?} \n {:#?}", other, &self);
+                    crate::debug!("mshv Other Exit: Exit: {:#?} \n {:#?}", other, &self);
                     log_then_return!("unknown Hyper-V run message type {:?}", other);
                 }
             },
@@ -340,7 +342,7 @@ impl Hypervisor for HypervLinuxDriver {
                 libc::EINTR => HyperlightExit::Cancelled(),
                 libc::EAGAIN => HyperlightExit::Retry(),
                 _ => {
-                    debug!("mshv Error - Details: Error: {} \n {:#?}", e, &self);
+                    crate::debug!("mshv Error - Details: Error: {} \n {:#?}", e, &self);
                     log_then_return!("Error running VCPU {:?}", e);
                 }
             },

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -31,7 +31,7 @@ use super::{
 use crate::hypervisor::hypervisor_handler::HypervisorHandler;
 use crate::mem::memory_region::{MemoryRegion, MemoryRegionFlags};
 use crate::mem::ptr::{GuestPtr, RawPtr};
-use crate::{debug, log_then_return, new_error, Result};
+use crate::{log_then_return, new_error, Result};
 
 /// Return `true` if the KVM API is available, version 12, and has UserMemory capability, or `false` otherwise
 #[instrument(skip_all, parent = Span::current(), level = "Trace")]
@@ -271,17 +271,17 @@ impl Hypervisor for KVMDriver {
         let exit_reason = self.vcpu_fd.run();
         let result = match exit_reason {
             Ok(VcpuExit::Hlt) => {
-                debug!("KVM - Halt Details : {:#?}", &self);
+                crate::debug!("KVM - Halt Details : {:#?}", &self);
                 HyperlightExit::Halt()
             }
             Ok(VcpuExit::IoOut(port, data)) => {
-                // because vcpufd.run() mutably borrows self we cannot pass self to debug! macro here
-                debug!("KVM IO Details : \nPort : {}\nData : {:?}", port, data);
+                // because vcpufd.run() mutably borrows self we cannot pass self to crate::debug! macro here
+                crate::debug!("KVM IO Details : \nPort : {}\nData : {:?}", port, data);
                 // KVM does not need to set RIP or instruction length so these are set to 0
                 HyperlightExit::IoOut(port, data.to_vec(), 0, 0)
             }
             Ok(VcpuExit::MmioRead(addr, _)) => {
-                debug!("KVM MMIO Read -Details: Address: {} \n {:#?}", addr, &self);
+                crate::debug!("KVM MMIO Read -Details: Address: {} \n {:#?}", addr, &self);
 
                 match self.get_memory_access_violation(
                     addr as usize,
@@ -293,7 +293,7 @@ impl Hypervisor for KVMDriver {
                 }
             }
             Ok(VcpuExit::MmioWrite(addr, _)) => {
-                debug!("KVM MMIO Write -Details: Address: {} \n {:#?}", addr, &self);
+                crate::debug!("KVM MMIO Write -Details: Address: {} \n {:#?}", addr, &self);
 
                 match self.get_memory_access_violation(
                     addr as usize,
@@ -309,12 +309,12 @@ impl Hypervisor for KVMDriver {
                 libc::EINTR => HyperlightExit::Cancelled(),
                 libc::EAGAIN => HyperlightExit::Retry(),
                 _ => {
-                    debug!("KVM Error -Details: Address: {} \n {:#?}", e, &self);
+                    crate::debug!("KVM Error -Details: Address: {} \n {:#?}", e, &self);
                     log_then_return!("Error running VCPU {:?}", e);
                 }
             },
             Ok(other) => {
-                debug!("KVM Other Exit {:?}", other);
+                crate::debug!("KVM Other Exit {:?}", other);
                 HyperlightExit::Unknown(format!("Unexpected KVM Exit {:?}", other))
             }
         };

src/hyperlight_host/src/lib.rs

@@ -143,19 +143,14 @@ macro_rules! log_then_return {
     };
 }
 
+// same as log::debug!, but will additionally print to stdout if the print_debug feature is enabled
 #[macro_export]
 macro_rules! debug {
-
     ($($arg:tt)+) =>
     {
-        // If the print_debug feature is enabled, print the debug message to the console
-        #[cfg(all(feature = "print_debug", debug_assertions))]
-        {
-            (println!($($arg)+))
-        }
-
-        // Then log/trace the debug message
-        (log::debug!($($arg)+))
+        #[cfg(print_debug)]
+        println!($($arg)+);
+        log::debug!($($arg)+);
     }
 }
 

src/hyperlight_host/src/mem/pe/pe_info.rs

@@ -23,7 +23,7 @@ use goblin::pe::PE;
 use tracing::{instrument, Span};
 
 use crate::mem::pe::base_relocations;
-use crate::{debug, log_then_return, Result};
+use crate::{log_then_return, Result};
 
 const IMAGE_REL_BASED_DIR64: u8 = 10;
 const IMAGE_REL_BASED_ABSOLUTE: u8 = 0;
@@ -106,9 +106,11 @@ impl PEInfo {
             let name = section.name().unwrap_or("Unknown");
             let virtual_size = section.virtual_size;
             let raw_size = section.size_of_raw_data;
-            debug!(
+            crate::debug!(
                 "Section: {}, Virtual Size: {}, On-Disk Size: {}",
-                name, virtual_size, raw_size
+                name,
+                virtual_size,
+                raw_size
             );
 
             if virtual_size > raw_size {
@@ -122,16 +124,16 @@ impl PEInfo {
 
                     data_section_raw_pointer = section.pointer_to_raw_data;
                     data_section_additional_bytes = virtual_size - raw_size;
-                    debug!(
+                    crate::debug!(
                         "Resizing the data section - Additional bytes required: {}",
                         data_section_additional_bytes
                     );
-                    debug!(
+                    crate::debug!(
                         "Resizing the data section - Existing PE File Size: {} New PE File Size: {}",
                         pe_bytes.len(),
                         pe_bytes.len() + data_section_additional_bytes as usize,
                     );
-                    debug!(
+                    crate::debug!(
                         "Resizing the data section - Data Section Raw Pointer: {}",
                         data_section_raw_pointer
                     );
@@ -140,19 +142,19 @@ impl PEInfo {
                     end_of_data_index =
                         (section.pointer_to_raw_data + section.size_of_raw_data) as usize;
 
-                    debug!("End of data index: {}", end_of_data_index);
+                    crate::debug!("End of data index: {}", end_of_data_index);
 
                     // the remainder of the data is the rest of the file after the .data section if any
 
                     let next_section = pe.sections.get(i + 1);
 
                     if let Some(next_section) = next_section {
-                        debug!(
+                        crate::debug!(
                             "Start of section after data index: {}",
                             next_section.pointer_to_raw_data
                         );
                     } else {
-                        debug!("No more sections after the .data section");
+                        crate::debug!("No more sections after the .data section");
                     }
                 } else {
                     log_then_return!(

src/hyperlight_host/src/sandbox/uninitialized.rs

@@ -35,7 +35,7 @@ use crate::sandbox::SandboxConfiguration;
 use crate::sandbox_state::sandbox::EvolvableSandbox;
 use crate::sandbox_state::transition::Noop;
 use crate::{
-    debug, log_build_details, log_then_return, new_error, MultiUseSandbox, Result, SingleUseSandbox,
+    log_build_details, log_then_return, new_error, MultiUseSandbox, Result, SingleUseSandbox,
 };
 
 /// A preliminary `Sandbox`, not yet ready to execute guest code.
@@ -258,7 +258,7 @@ impl UninitializedSandbox {
             }
         }
 
-        debug!("Sandbox created:  {:#?}", sandbox);
+        crate::debug!("Sandbox created:  {:#?}", sandbox);
 
         Ok(sandbox)
     }