[*] clippy fix and fmt

Signed-off-by: danbugs <[email protected]>

Author: danbugs

src/hyperlight_common/src/hyperlight_peb.rs

@@ -111,8 +111,8 @@ impl HyperlightPEB {
         let guest_heap_size = self.get_guest_heap_data_size();
 
         self.set_guest_error_data_region(
-            guest_stack_size + guest_heap_size as u64, // start at the end of the host function details
-            PAGE_SIZE as u64,                          // 4KB
+            guest_stack_size + guest_heap_size, // start at the end of the host function details
+            PAGE_SIZE as u64,                   // 4KB
         );
 
         self.set_host_error_data_region(

src/hyperlight_guest/src/gdt.rs

@@ -72,6 +72,9 @@ struct GdtPointer {
 }
 
 /// Load the GDT
+///
+/// # Safety
+/// TODO
 pub unsafe fn load_gdt() {
     let gdt_ptr = GdtPointer {
         size: (core::mem::size_of::<[GdtEntry; 3]>() - 1) as u16,

src/hyperlight_guest/src/guest_function_call.rs

@@ -98,9 +98,10 @@ fn internal_dispatch_function() -> Result<()> {
         set_error(e.kind.clone(), e.message.as_str());
     })?;
 
-    Ok(output_data_section
+    output_data_section
         .push_shared_output_data(result_vec)
-        .unwrap())
+        .unwrap();
+    Ok(())
 }
 
 // This is implemented as a separate function to make sure that epilogue in the internal_dispatch_function is called before the halt()

src/hyperlight_guest/src/idtr.rs

@@ -11,11 +11,19 @@ pub struct Idtr {
 static mut IDTR: Idtr = Idtr { limit: 0, base: 0 };
 
 impl Idtr {
+    /// Initializes the IDTR with the given base address and size.
+    ///
+    /// # Safety
+    /// TODO
     pub unsafe fn init(&mut self, base: u64, size: u16) {
         self.limit = size - 1;
         self.base = base;
     }
 
+    /// Loads the IDTR with the current IDT.
+    ///
+    /// # Safety
+    /// TODO
     pub unsafe fn load(&self) {
         core::arch::asm!("lidt [{}]", in(reg) self, options(readonly, nostack, preserves_flags));
     }

src/hyperlight_guest/src/logging.rs

@@ -19,9 +19,9 @@ use alloc::vec::Vec;
 
 use hyperlight_common::flatbuffer_wrappers::guest_log_data::GuestLogData;
 use hyperlight_common::flatbuffer_wrappers::guest_log_level::LogLevel;
+use hyperlight_common::input_output::OutputDataSection;
 
 use crate::host_function_call::{outb, OutBAction};
-use hyperlight_common::input_output::OutputDataSection;
 use crate::PEB;
 
 fn write_log_data(

src/hyperlight_host/src/error.rs

@@ -41,8 +41,8 @@ use thiserror::Error;
 
 #[cfg(target_os = "windows")]
 use crate::hypervisor::wrappers::HandleWrapper;
-use crate::sandbox::sandbox_builder::MemoryRegionFlags;
 use crate::mem::ptr::RawPtr;
+use crate::sandbox::sandbox_builder::MemoryRegionFlags;
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
 pub(crate) struct HyperlightHostError {

src/hyperlight_host/src/hypervisor/gdb/mod.rs

@@ -31,7 +31,7 @@ use event_loop::event_loop_thread;
 use gdbstub::conn::ConnectionExt;
 use gdbstub::stub::GdbStub;
 use gdbstub::target::TargetError;
-use hyperlight_common::mem::PAGE_SIZE;
+use hyperlight_common::PAGE_SIZE;
 #[cfg(kvm)]
 pub(crate) use kvm_debug::KvmDebug;
 #[cfg(mshv)]
@@ -40,7 +40,7 @@ use thiserror::Error;
 use x86_64_target::HyperlightSandboxTarget;
 
 use crate::hypervisor::handlers::DbgMemAccessHandlerCaller;
-use crate::mem::layout::SandboxMemoryLayout;
+use crate::sandbox::sandbox_builder::BASE_ADDRESS;
 use crate::{new_error, HyperlightError};
 
 /// Software Breakpoint size in memory
@@ -252,14 +252,16 @@ pub(crate) trait GuestDebug {
 
             let read_len = std::cmp::min(
                 data.len(),
-                (PAGE_SIZE - (gpa & (PAGE_SIZE - 1))).try_into().unwrap(),
+                (PAGE_SIZE as u64 - (gpa & (PAGE_SIZE as u64 - 1)))
+                    .try_into()
+                    .unwrap(),
             );
             let offset = (gpa as usize)
-                .checked_sub(SandboxMemoryLayout::BASE_ADDRESS)
+                .checked_sub(BASE_ADDRESS)
                 .ok_or_else(|| {
                     log::warn!(
                         "gva=0x{:#X} causes subtract with underflow: \"gpa - BASE_ADDRESS={:#X}-{:#X}\"",
-                        gva, gpa, SandboxMemoryLayout::BASE_ADDRESS);
+                        gva, gpa, BASE_ADDRESS);
                     HyperlightError::TranslateGuestAddress(gva)
                 })?;
 
@@ -324,14 +326,16 @@ pub(crate) trait GuestDebug {
 
             let write_len = std::cmp::min(
                 data.len(),
-                (PAGE_SIZE - (gpa & (PAGE_SIZE - 1))).try_into().unwrap(),
+                (PAGE_SIZE as u64 - (gpa & (PAGE_SIZE as u64 - 1)))
+                    .try_into()
+                    .unwrap(),
             );
             let offset = (gpa as usize)
-                .checked_sub(SandboxMemoryLayout::BASE_ADDRESS)
+                .checked_sub(BASE_ADDRESS)
                 .ok_or_else(|| {
                     log::warn!(
                         "gva=0x{:#X} causes subtract with underflow: \"gpa - BASE_ADDRESS={:#X}-{:#X}\"",
-                        gva, gpa, SandboxMemoryLayout::BASE_ADDRESS);
+                        gva, gpa, BASE_ADDRESS);
                     HyperlightError::TranslateGuestAddress(gva)
                 })?;
 

src/hyperlight_host/src/hypervisor/hyperv_linux.rs

@@ -26,7 +26,7 @@ extern crate mshv_ioctls3 as mshv_ioctls;
 
 use std::fmt::{Debug, Formatter};
 
-use log::{error, LevelFilter};
+use log::LevelFilter;
 #[cfg(mshv2)]
 use mshv_bindings::hv_message;
 #[cfg(gdb)]
@@ -61,8 +61,8 @@ use super::{
 };
 use crate::hypervisor::hypervisor_handler::HypervisorHandler;
 use crate::hypervisor::HyperlightExit;
-use crate::sandbox::sandbox_builder::SandboxMemorySections;
 use crate::mem::ptr::{GuestPtr, RawPtr};
+use crate::sandbox::sandbox_builder::SandboxMemorySections;
 #[cfg(gdb)]
 use crate::HyperlightError;
 use crate::{log_then_return, new_error, Result};
@@ -480,9 +480,9 @@ impl Hypervisor for HypervLinuxDriver {
             rflags: 2, //bit 1 of rlags is required to be set
 
             // function args
-            rcx: hyperlight_peb_guest_memory_region_address.into(),
-            rdx: hyperlight_peb_guest_memory_region_size.into(),
-            r8: seed.into(),
+            rcx: hyperlight_peb_guest_memory_region_address,
+            rdx: hyperlight_peb_guest_memory_region_size,
+            r8: seed,
             r9: max_guest_log_level,
 
             ..Default::default()
@@ -788,13 +788,13 @@ impl Hypervisor for HypervLinuxDriver {
 //             crate::mem::memory_region::MemoryRegionType::Code,
 //         );
 //         super::HypervLinuxDriver::new(
-            regions.build(),
-            entrypoint_ptr,
-            rsp_ptr,
-            pml4_ptr,
-            #[cfg(gdb)]
-            None,
-        )
-        .unwrap();
+//             regions.build(),
+//             entrypoint_ptr,
+//             rsp_ptr,
+//             pml4_ptr,
+//             #[cfg(gdb)]
+//             None,
+//         )
+//         .unwrap();
 //     }
 // }

src/hyperlight_host/src/hypervisor/hypervisor_handler.rs

@@ -133,7 +133,7 @@ impl HvHandlerExecVars {
             .thread_id
             .try_lock()
             .map_err(|_| new_error!("Failed to get_thread_id"))?)
-            .ok_or_else(|| new_error!("thread_id not set"))
+        .ok_or_else(|| new_error!("thread_id not set"))
     }
 
     #[cfg(target_os = "windows")]
@@ -792,7 +792,7 @@ impl HypervisorHandler {
                         0,
                         0,
                     )
-                        .map_err(|e| new_error!("Failed to cancel guest execution {:?}", e))?;
+                    .map_err(|e| new_error!("Failed to cancel guest execution {:?}", e))?;
                 }
             }
             // if running in-process on windows, we currently have no way of cancelling the execution

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -35,8 +35,8 @@ use super::{
     CR4_OSFXSR, CR4_OSXMMEXCPT, CR4_PAE, EFER_LMA, EFER_LME, EFER_NX, EFER_SCE,
 };
 use crate::hypervisor::hypervisor_handler::HypervisorHandler;
-use crate::sandbox::sandbox_builder::{MemoryRegionFlags, SandboxMemorySections};
 use crate::mem::ptr::{GuestPtr, RawPtr};
+use crate::sandbox::sandbox_builder::{MemoryRegionFlags, SandboxMemorySections};
 #[cfg(gdb)]
 use crate::HyperlightError;
 use crate::{log_then_return, new_error, Result};
@@ -422,9 +422,9 @@ impl Hypervisor for KVMDriver {
             rsp: self.orig_rsp.absolute()?,
 
             // function args
-            rcx: hyperlight_peb_guest_memory_region_address.into(),
-            rdx: hyperlight_peb_guest_memory_region_size.into(),
-            r8: seed.into(),
+            rcx: hyperlight_peb_guest_memory_region_address,
+            rdx: hyperlight_peb_guest_memory_region_size,
+            r8: seed,
             r9: max_guest_log_level,
 
             ..Default::default()

src/hyperlight_host/src/mem/mgr.rs

@@ -35,14 +35,14 @@ use super::ptr::RawPtr;
 use super::ptr_offset::Offset;
 use super::shared_mem::{ExclusiveSharedMemory, GuestSharedMemory, HostSharedMemory, SharedMemory};
 use super::shared_mem_snapshot::SharedMemorySnapshot;
+use crate::error::HyperlightHostError;
 use crate::sandbox::sandbox_builder::{
     MemoryRegionFlags, SandboxMemorySections, BASE_ADDRESS, PDPT_OFFSET, PD_OFFSET, PT_OFFSET,
 };
 use crate::HyperlightError::{
     ExceptionDataLengthIncorrect, ExceptionMessageTooBig, JsonConversionFailure, NoMemorySnapshot,
     UTF8SliceConversionFailure,
 };
-use crate::error::HyperlightHostError;
 use crate::{log_then_return, new_error, HyperlightError, Result};
 
 /// Paging Flags

src/hyperlight_host/src/sandbox/initialized_multi_use.rs

@@ -19,10 +19,10 @@ use hyperlight_common::flatbuffer_wrappers::function_types::{
 };
 use tracing::{instrument, Span};
 
-use crate::mem::mgr::SandboxMemoryManager;
 use crate::func::call_ctx::MultiUseGuestCallContext;
 use crate::func::guest_dispatch::call_function_on_guest;
 use crate::hypervisor::hypervisor_handler::HypervisorHandler;
+use crate::mem::mgr::SandboxMemoryManager;
 use crate::mem::shared_mem::HostSharedMemory;
 use crate::sandbox_state::sandbox::{DevolvableSandbox, EvolvableSandbox, Sandbox};
 use crate::sandbox_state::transition::{MultiUseContextCallback, Noop};

src/hyperlight_host/src/sandbox/mem_access.rs

@@ -23,6 +23,8 @@ use crate::hypervisor::handlers::{DbgMemAccessHandlerCaller, DbgMemAccessHandler
 use crate::hypervisor::handlers::{
     MemAccessHandler, MemAccessHandlerFunction, MemAccessHandlerWrapper,
 };
+#[cfg(gdb)]
+use crate::mem::mgr::SandboxMemoryManager;
 
 #[instrument(skip_all, parent = Span::current(), level= "Trace")]
 pub(crate) fn mem_access_handler_wrapper() -> MemAccessHandlerWrapper {

src/hyperlight_host/src/sandbox/sandbox_builder.rs

@@ -370,9 +370,9 @@ impl SandboxBuilder {
     /// Set the sandbox run mode. Options:
     /// - SandboxRunOptions::RunInHypervisor: Run the sandbox in a hypervisor.
     /// - SandboxRunOptions::RunInProcess(false): Run the sandbox in process (i.e., without a
-    /// hypervisor), but also without using the Windows LoadLibrary to load the guest binary.
+    ///     hypervisor), but also without using the Windows LoadLibrary to load the guest binary.
     /// - SandboxRunOptions::RunInProcess(true): Run the sandbox in process (i.e., without a
-    /// hypervisor), and use the Windows LoadLibrary to load the guest binary.
+    ///     hypervisor), and use the Windows LoadLibrary to load the guest binary.
     pub fn set_sandbox_run_options(
         mut self,
         sandbox_run_options: SandboxRunOptions,
@@ -495,7 +495,7 @@ impl SandboxBuilder {
     /// - +--------------------------+ 0x0
     ///
     /// - Note 1: The guest stack size can be set manually via the `stack_size_override` parameter. If
-    /// not provided, the stack size is set to the default stack reserve size of the guest binary.
+    ///     not provided, the stack size is set to the default stack reserve size of the guest binary.
     fn set_memory_layout(mut self) -> Result<Self> {
         // Name of guard page regions
         const DEFAULT_TMP_STACK_GUARD_PAGE_NAME: &str = "tmp stack guard page";

src/hyperlight_host/src/sandbox/uninitialized_evolve.rs

@@ -65,7 +65,8 @@ where
         Duration::from_millis(u_sbox.config.get_max_initialization_time() as u64),
         Duration::from_millis(u_sbox.config.get_max_execution_time() as u64),
         Duration::from_millis(u_sbox.config.get_max_wait_for_cancellation() as u64),
-        u_sbox.max_guest_log_level,#[cfg(gdb)]
+        u_sbox.max_guest_log_level,
+        #[cfg(gdb)]
         u_sbox.debug_info,
     )?;