fmt changes

Signed-off-by: Simon Davies <[email protected]>

Author: simongdavies

src/hyperlight_guest/build.rs

@@ -104,9 +104,9 @@ fn cargo_main() {
         }
 
         if cfg!(windows) {
-            unsafe {env::set_var("AR_x86_64_unknown_none", "llvm-ar")};
+            unsafe { env::set_var("AR_x86_64_unknown_none", "llvm-ar") };
         } else {
-            unsafe {env::set_var("AR_x86_64_pc_windows_msvc", "llvm-lib")};
+            unsafe { env::set_var("AR_x86_64_pc_windows_msvc", "llvm-lib") };
         }
 
         cfg.compile("hyperlight_guest");

src/hyperlight_guest/src/entrypoint.rs

@@ -49,22 +49,24 @@ pub fn abort_with_code(code: &[u8]) -> ! {
 ///
 /// # Safety
 /// This function is unsafe because it dereferences a raw pointer.
-pub unsafe fn abort_with_code_and_message(code: &[u8], message_ptr: *const c_char) -> ! { unsafe {
-    // Step 1: Send abort code (typically 1 byte, but `code` allows flexibility)
-    outb(OutBAction::Abort as u16, code);
+pub unsafe fn abort_with_code_and_message(code: &[u8], message_ptr: *const c_char) -> ! {
+    unsafe {
+        // Step 1: Send abort code (typically 1 byte, but `code` allows flexibility)
+        outb(OutBAction::Abort as u16, code);
 
-    // Step 2: Convert the C string to bytes
-    let message_bytes = CStr::from_ptr(message_ptr).to_bytes(); // excludes null terminator
+        // Step 2: Convert the C string to bytes
+        let message_bytes = CStr::from_ptr(message_ptr).to_bytes(); // excludes null terminator
 
-    // Step 3: Send the message itself in chunks
-    outb(OutBAction::Abort as u16, message_bytes);
+        // Step 3: Send the message itself in chunks
+        outb(OutBAction::Abort as u16, message_bytes);
 
-    // Step 4: Send abort terminator to signal completion (e.g., 0xFF)
-    outb(OutBAction::Abort as u16, &[0xFF]);
+        // Step 4: Send abort terminator to signal completion (e.g., 0xFF)
+        outb(OutBAction::Abort as u16, &[0xFF]);
 
-    // This function never returns
-    unreachable!()
-}}
+        // This function never returns
+        unreachable!()
+    }
+}
 
 unsafe extern "C" {
     fn hyperlight_main();

src/hyperlight_guest/src/exceptions/gdt.rs

@@ -72,26 +72,28 @@ struct GdtPointer {
 }
 
 /// Load the GDT
-pub unsafe fn load_gdt() { unsafe {
-    let gdt_ptr = GdtPointer {
-        size: (core::mem::size_of::<[GdtEntry; 3]>() - 1) as u16,
-        base: addr_of!(GDT) as *const _ as u64,
-    };
+pub unsafe fn load_gdt() {
+    unsafe {
+        let gdt_ptr = GdtPointer {
+            size: (core::mem::size_of::<[GdtEntry; 3]>() - 1) as u16,
+            base: addr_of!(GDT) as *const _ as u64,
+        };
 
-    asm!(
-    "lgdt [{0}]",
-    "mov ax, 0x10",        // Load data segment registers
-    "mov ds, ax",
-    "mov es, ax",
-    "mov fs, ax",
-    "mov gs, ax",
-    "mov ss, ax",
-    "push 0x08",            // Push CS (kernel code segment)
-    "lea rax, [2f + rip]",  // Load the next instruction's address
-    "push rax",             // Push address onto stack
-    "retfq",                // Far return to update CS
-    "2:",                   // Label for continued execution
-    in(reg) &gdt_ptr,
-    options(nostack, preserves_flags)
-    );
-}}
+        asm!(
+        "lgdt [{0}]",
+        "mov ax, 0x10",        // Load data segment registers
+        "mov ds, ax",
+        "mov es, ax",
+        "mov fs, ax",
+        "mov gs, ax",
+        "mov ss, ax",
+        "push 0x08",            // Push CS (kernel code segment)
+        "lea rax, [2f + rip]",  // Load the next instruction's address
+        "push rax",             // Push address onto stack
+        "retfq",                // Far return to update CS
+        "2:",                   // Label for continued execution
+        in(reg) &gdt_ptr,
+        options(nostack, preserves_flags)
+        );
+    }
+}

src/hyperlight_guest/src/exceptions/idtr.rs

@@ -16,20 +16,24 @@ impl Idtr {
         self.base = base;
     }
 
-    pub unsafe fn load(&self) { unsafe {
-        core::arch::asm!("lidt [{}]", in(reg) self, options(readonly, nostack, preserves_flags));
-    }}
+    pub unsafe fn load(&self) {
+        unsafe {
+            core::arch::asm!("lidt [{}]", in(reg) self, options(readonly, nostack, preserves_flags));
+        }
+    }
 }
 
-pub(crate) unsafe fn load_idt() { unsafe {
-    init_idt();
-
-    let idt_size = 256 * size_of::<IdtEntry>();
-    let expected_base = addr_of!(IDT) as *const _ as u64;
-    
-    // Use &raw mut to get a mutable raw pointer, then dereference it
-    // this is to avoid the clippy warning "shared reference to mutable static"
-    let idtr = &mut *(&raw mut IDTR);
-    idtr.init(expected_base, idt_size as u16);
-    idtr.load();
-}}
+pub(crate) unsafe fn load_idt() {
+    unsafe {
+        init_idt();
+
+        let idt_size = 256 * size_of::<IdtEntry>();
+        let expected_base = addr_of!(IDT) as *const _ as u64;
+
+        // Use &raw mut to get a mutable raw pointer, then dereference it
+        // this is to avoid the clippy warning "shared reference to mutable static"
+        let idtr = &mut *(&raw mut IDTR);
+        idtr.init(expected_base, idt_size as u16);
+        idtr.load();
+    }
+}

src/hyperlight_guest/src/guest_function_call.rs

@@ -45,7 +45,8 @@ pub(crate) fn call_guest_function(function_call: FunctionCall) -> Result<Vec<u8>
     // Find the function definition for the function call.
     // Use &raw const to get an immutable reference to the static HashMap
     // this is to avoid the clippy warning "shared reference to mutable static"
-    if let Some(registered_function_definition) = unsafe { (*(&raw const REGISTERED_GUEST_FUNCTIONS)).get(&function_call.function_name) }
+    if let Some(registered_function_definition) =
+        unsafe { (*(&raw const REGISTERED_GUEST_FUNCTIONS)).get(&function_call.function_name) }
     {
         let function_call_parameter_types: Vec<ParameterType> = function_call
             .parameters

src/hyperlight_guest/src/host_function_call.rs

@@ -107,9 +107,11 @@ pub fn outb(port: u16, data: &[u8]) {
     }
 }
 
-pub(crate) unsafe fn out32(port: u16, val: u32) { unsafe {
-    arch::asm!("out dx, eax", in("dx") port, in("eax") val, options(preserves_flags, nomem, nostack));
-}}
+pub(crate) unsafe fn out32(port: u16, val: u32) {
+    unsafe {
+        arch::asm!("out dx, eax", in("dx") port, in("eax") val, options(preserves_flags, nomem, nostack));
+    }
+}
 
 /// Prints a message using `OutBAction::DebugPrint`. It transmits bytes of a message
 /// through several VMExists and, with such, it is slower than

src/hyperlight_guest/src/memory.rs

@@ -82,23 +82,25 @@ unsafe fn alloc_helper(size: usize, zero: bool) -> *mut c_void {
 /// # Safety
 /// The returned pointer must be freed with `memory::free` when it is no longer needed, otherwise memory will leak.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn malloc(size: usize) -> *mut c_void { unsafe {
-    alloc_helper(size, false)
-}}
+pub unsafe extern "C" fn malloc(size: usize) -> *mut c_void {
+    unsafe { alloc_helper(size, false) }
+}
 
 /// Allocates a block of memory for an array of `nmemb` elements, each of `size` bytes.
 /// The memory is initialized to 0s.
 ///
 /// # Safety
 /// The returned pointer must be freed with `memory::free` when it is no longer needed, otherwise memory will leak.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn calloc(nmemb: usize, size: usize) -> *mut c_void { unsafe {
-    let total_size = nmemb
-        .checked_mul(size)
-        .expect("nmemb * size should not overflow in calloc");
+pub unsafe extern "C" fn calloc(nmemb: usize, size: usize) -> *mut c_void {
+    unsafe {
+        let total_size = nmemb
+            .checked_mul(size)
+            .expect("nmemb * size should not overflow in calloc");
 
-    alloc_helper(total_size, true)
-}}
+        alloc_helper(total_size, true)
+    }
+}
 
 /// Frees the memory block pointed to by `ptr`.
 ///
@@ -124,39 +126,37 @@ pub unsafe extern "C" fn free(ptr: *mut c_void) {
 pub unsafe extern "C" fn realloc(ptr: *mut c_void, size: usize) -> *mut c_void {
     if ptr.is_null() {
         // If the pointer is null, treat as a malloc
-        return unsafe {malloc(size)};
+        return unsafe { malloc(size) };
     }
 
     if size == 0 {
         // If the size is 0, treat as a free and return null
-         unsafe {
-             free(ptr);
+        unsafe {
+            free(ptr);
         }
         return ptr::null_mut();
     }
 
-    
-        let total_new_size = size
-            .checked_add(size_of::<Layout>())
-            .expect("data and layout size should not overflow in realloc");
+    let total_new_size = size
+        .checked_add(size_of::<Layout>())
+        .expect("data and layout size should not overflow in realloc");
 
-        let block_start = unsafe { (ptr as *const Layout).sub(1) };
-        let old_layout = unsafe { block_start.read() };
-        let new_layout = Layout::from_size_align(total_new_size, MAX_ALIGN).unwrap();
+    let block_start = unsafe { (ptr as *const Layout).sub(1) };
+    let old_layout = unsafe { block_start.read() };
+    let new_layout = Layout::from_size_align(total_new_size, MAX_ALIGN).unwrap();
 
-        let new_block_start =
-            unsafe {alloc::alloc::realloc(block_start as *mut u8, old_layout, total_new_size)}
-                as *mut Layout;
+    let new_block_start =
+        unsafe { alloc::alloc::realloc(block_start as *mut u8, old_layout, total_new_size) }
+            as *mut Layout;
 
-        if new_block_start.is_null() {
-            // Realloc failed
-            abort_with_code(&[ErrorCode::MallocFailed as u8]);
-        } else {
-            // Update the stored Layout, then return ptr to memory right after the Layout.
-            unsafe {
-                new_block_start.write(new_layout);
-                new_block_start.add(1) as *mut c_void
-            }
+    if new_block_start.is_null() {
+        // Realloc failed
+        abort_with_code(&[ErrorCode::MallocFailed as u8]);
+    } else {
+        // Update the stored Layout, then return ptr to memory right after the Layout.
+        unsafe {
+            new_block_start.write(new_layout);
+            new_block_start.add(1) as *mut c_void
         }
-    
+    }
 }

src/hyperlight_guest/src/print.rs

@@ -33,37 +33,39 @@ static mut MESSAGE_BUFFER: Vec<u8> = Vec::new();
 /// This function is not thread safe
 #[unsafe(no_mangle)]
 #[allow(static_mut_refs)]
-pub unsafe extern "C" fn _putchar(c: c_char) { unsafe {
-    let char = c as u8;
+pub unsafe extern "C" fn _putchar(c: c_char) {
+    unsafe {
+        let char = c as u8;
 
-    // Extend buffer capacity if it's empty (like `with_capacity` in lazy_static).
-    // TODO: replace above Vec::new() with Vec::with_capacity once it's stable in const contexts.
-    if MESSAGE_BUFFER.capacity() == 0 {
-        MESSAGE_BUFFER.reserve(BUFFER_SIZE);
-    }
+        // Extend buffer capacity if it's empty (like `with_capacity` in lazy_static).
+        // TODO: replace above Vec::new() with Vec::with_capacity once it's stable in const contexts.
+        if MESSAGE_BUFFER.capacity() == 0 {
+            MESSAGE_BUFFER.reserve(BUFFER_SIZE);
+        }
 
-    MESSAGE_BUFFER.push(char);
+        MESSAGE_BUFFER.push(char);
 
-    if MESSAGE_BUFFER.len() == BUFFER_SIZE || char == b'\0' {
-        let str = if char == b'\0' {
-            CStr::from_bytes_until_nul(&MESSAGE_BUFFER)
-                .expect("No null byte in buffer")
-                .to_string_lossy()
-                .into_owned()
-        } else {
-            String::from_utf8(mem::take(&mut MESSAGE_BUFFER))
-                .expect("Failed to convert buffer to string")
-        };
+        if MESSAGE_BUFFER.len() == BUFFER_SIZE || char == b'\0' {
+            let str = if char == b'\0' {
+                CStr::from_bytes_until_nul(&MESSAGE_BUFFER)
+                    .expect("No null byte in buffer")
+                    .to_string_lossy()
+                    .into_owned()
+            } else {
+                String::from_utf8(mem::take(&mut MESSAGE_BUFFER))
+                    .expect("Failed to convert buffer to string")
+            };
 
-        // HostPrint returns an i32, but we don't care about the return value
-        let _ = call_host_function::<i32>(
-            "HostPrint",
-            Some(Vec::from(&[ParameterValue::String(str)])),
-            ReturnType::Int,
-        )
-        .expect("Failed to call HostPrint");
+            // HostPrint returns an i32, but we don't care about the return value
+            let _ = call_host_function::<i32>(
+                "HostPrint",
+                Some(Vec::from(&[ParameterValue::String(str)])),
+                ReturnType::Int,
+            )
+            .expect("Failed to call HostPrint");
 
-        // Clear the buffer after sending
-        MESSAGE_BUFFER.clear();
+            // Clear the buffer after sending
+            MESSAGE_BUFFER.clear();
+        }
     }
-}}
+}

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -45,23 +45,26 @@ 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")]
 pub(crate) fn is_hypervisor_present() -> bool {
-    match Kvm::new() { Ok(kvm) => {
-        let api_version = kvm.get_api_version();
-        match api_version {
-            version if version == 12 && kvm.check_extension(UserMemory) => true,
-            12 => {
-                log::info!("KVM does not have KVM_CAP_USER_MEMORY capability");
-                false
-            }
-            version => {
-                log::info!("KVM GET_API_VERSION returned {}, expected 12", version);
-                false
+    match Kvm::new() {
+        Ok(kvm) => {
+            let api_version = kvm.get_api_version();
+            match api_version {
+                version if version == 12 && kvm.check_extension(UserMemory) => true,
+                12 => {
+                    log::info!("KVM does not have KVM_CAP_USER_MEMORY capability");
+                    false
+                }
+                version => {
+                    log::info!("KVM GET_API_VERSION returned {}, expected 12", version);
+                    false
+                }
             }
         }
-    } _ => {
-        log::info!("KVM is not available on this system");
-        false
-    }}
+        _ => {
+            log::info!("KVM is not available on this system");
+            false
+        }
+    }
 }
 
 #[cfg(gdb)]

src/hyperlight_host/src/mem/layout.rs

@@ -462,8 +462,7 @@ impl SandboxMemoryLayout {
 
         // Get the number of pages needed for the PTs
 
-        let num_pages: usize = total_mapped_memory_size.div_ceil(AMOUNT_OF_MEMORY_PER_PT)
-            + 3; // PML4, PDPT, PD
+        let num_pages: usize = total_mapped_memory_size.div_ceil(AMOUNT_OF_MEMORY_PER_PT) + 3; // PML4, PDPT, PD
 
         num_pages * PAGE_SIZE_USIZE
     }