Apply cargo fmt

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

Author: adamperlin

src/hyperlight_common/src/fixed_buf.rs

@@ -17,7 +17,6 @@ limitations under the License.
 use core::fmt;
 use core::result::Result;
 
-
 /// FixedStringBuf is a buffer that can hold a fixed-size string of capacity N.
 /// It is meant to be used with a slice that the user has pre-allocated
 /// to avoid extra allocations during string formatting.
@@ -28,11 +27,11 @@ pub struct FixedStringBuf<const N: usize> {
 
 impl<'a, const N: usize> fmt::Write for FixedStringBuf<N> {
     fn write_str(&mut self, s: &str) -> fmt::Result {
-        // we always reserve 1 byte for the null terminator, 
+        // we always reserve 1 byte for the null terminator,
         // as the buffer must be convertible to CStr.
         let buf_end = self.buf.len() - 1;
         if self.pos + s.len() > buf_end {
-            return Err(fmt::Error)
+            return Err(fmt::Error);
         }
 
         self.buf[self.pos..self.pos + s.len()].copy_from_slice(s.as_bytes());
@@ -41,22 +40,22 @@ impl<'a, const N: usize> fmt::Write for FixedStringBuf<N> {
     }
 }
 
-impl <const N: usize> FixedStringBuf<N> {
+impl<const N: usize> FixedStringBuf<N> {
     pub fn as_str(&self) -> Result<&str, core::str::Utf8Error> {
         core::str::from_utf8(&self.buf[..self.pos])
     }
 
     pub const fn new() -> Self {
-        return FixedStringBuf{
+        return FixedStringBuf {
             buf: [0u8; N],
             pos: 0,
-        }
+        };
     }
 
     /// Null terminates the underlying buffer,
     /// and converts to a CStr which borrows the underlying buffer's slice.
     pub fn as_c_str(&mut self) -> Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> {
-        // null terminate the buffer. 
+        // null terminate the buffer.
         // we are guaranteed to have enough space since we always reserve one extra
         // byte for null in write_str, and assert buf.len() > 0 in the constructor.
         assert!(self.buf.len() > 0 && self.pos < self.buf.len());
@@ -65,12 +64,12 @@ impl <const N: usize> FixedStringBuf<N> {
     }
 }
 
-
 mod test {
     // disable unused import warnings
     #![allow(unused_imports)]
-    use core::fmt::Write;
     use core::fmt;
+    use core::fmt::Write;
+
     use super::FixedStringBuf;
 
     #[test]
@@ -90,4 +89,4 @@ mod test {
         let c_str = buf.as_c_str().unwrap();
         assert_eq!(c_str.to_bytes(), b"01234567890123456789");
     }
-}
+}

src/hyperlight_guest_bin/src/lib.rs

@@ -18,25 +18,25 @@ limitations under the License.
 // === Dependencies ===
 extern crate alloc;
 
-use core::fmt::{Write};
-
 use alloc::string::ToString;
+use core::fmt::Write;
+
 use buddy_system_allocator::LockedHeap;
 #[cfg(target_arch = "x86_64")]
 use exceptions::{gdt::load_gdt, idtr::load_idt};
 use guest_function::call::dispatch_function;
 use guest_function::register::GuestFunctionRegister;
 use guest_logger::init_logger;
+use hyperlight_common::fixed_buf::FixedStringBuf;
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 use hyperlight_common::mem::HyperlightPEB;
 #[cfg(feature = "mem_profile")]
 use hyperlight_common::outb::OutBAction;
-use hyperlight_common::fixed_buf::{FixedStringBuf};
 use hyperlight_guest::exit::{abort_with_code_and_message, halt};
 use hyperlight_guest::guest_handle::handle::GuestHandle;
 use hyperlight_guest_tracing::{trace, trace_function};
 use log::LevelFilter;
-use spin::{Once, Mutex, MutexGuard};
+use spin::{Mutex, MutexGuard, Once};
 
 // === Modules ===
 #[cfg(target_arch = "x86_64")]
@@ -151,18 +151,33 @@ fn _panic_handler(info: &core::panic::PanicInfo) -> ! {
     let mut panic_buf_guard = PANIC_BUF.lock();
     let write_res = write!(panic_buf_guard, "{}", info);
     if let Err(_) = write_res {
-        unsafe { abort_with_code_and_message(&[ErrorCode::UnknownError as u8], b"panic: message format failed\0".as_ptr() as *const i8)}
+        unsafe {
+            abort_with_code_and_message(
+                &[ErrorCode::UnknownError as u8],
+                b"panic: message format failed\0".as_ptr() as *const i8,
+            )
+        }
     }
 
     // create a CStr from the underlying array in PANIC_BUF using the as_cstr method.
     // this wraps CStr::from_bytes_until_nul which takes a borrowed byte slice
-    // and does not allocate. 
+    // and does not allocate.
     let c_string_res = panic_buf_guard.as_c_str();
     if let Err(_) = c_string_res {
-        unsafe { abort_with_code_and_message(&[ErrorCode::UnknownError as u8], b"panic: failed to convert to CStr\0".as_ptr() as *const i8)}
+        unsafe {
+            abort_with_code_and_message(
+                &[ErrorCode::UnknownError as u8],
+                b"panic: failed to convert to CStr\0".as_ptr() as *const i8,
+            )
+        }
+    }
+
+    unsafe {
+        abort_with_code_and_message(
+            &[ErrorCode::UnknownError as u8],
+            c_string_res.unwrap().as_ptr(),
+        )
     }
-    
-    unsafe { abort_with_code_and_message(&[ErrorCode::UnknownError as u8], c_string_res.unwrap().as_ptr()) }
 }
 
 // === Entrypoint ===
@@ -232,4 +247,4 @@ pub extern "C" fn entrypoint(peb_address: u64, seed: u64, ops: u64, max_log_leve
     });
 
     halt();
-}
+}

src/hyperlight_host/tests/integration_test.rs

@@ -546,10 +546,12 @@ fn guest_panic_no_alloc() {
     .unwrap();
     let mut sbox: MultiUseSandbox = uninit.evolve().unwrap();
 
-    let res = sbox.call::<i32>(
-        "ExhaustHeap", // uses the rust allocator to allocate small blocks on the heap until OOM
-        ()
-    ).unwrap_err();
+    let res = sbox
+        .call::<i32>(
+            "ExhaustHeap", // uses the rust allocator to allocate small blocks on the heap until OOM
+            (),
+        )
+        .unwrap_err();
     println!("{:?}", res);
 
     if let HyperlightError::StackOverflow() = res {
@@ -560,7 +562,6 @@ fn guest_panic_no_alloc() {
         res,
         HyperlightError::GuestAborted(code, msg) if code == ErrorCode::UnknownError as u8 && msg.contains("memory allocation of ") && msg.contains("bytes failed")
     ));
-
 }
 
 // Tests libc alloca