1. Add vec allocation after alloc::alloc failure to ensure panic in

integration test
2. Resolve clippy errors

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

Author: adamperlin

src/hyperlight_common/src/fixed_buf.rs

@@ -25,7 +25,7 @@ pub struct FixedStringBuf<const N: usize> {
     pub pos: usize,
 }
 
-impl<'a, const N: usize> fmt::Write for FixedStringBuf<N> {
+impl<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,
         // as the buffer must be convertible to CStr.
@@ -40,16 +40,22 @@ impl<'a, const N: usize> fmt::Write for FixedStringBuf<N> {
     }
 }
 
+impl<const N: usize> Default for FixedStringBuf<N> {
+    fn default() -> Self {
+        FixedStringBuf::<N>::new()
+    }
+}
+
 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 {
+        FixedStringBuf {
             buf: [0u8; N],
             pos: 0,
-        };
+        }
     }
 
     /// Null terminates the underlying buffer,
@@ -58,7 +64,7 @@ impl<const N: usize> FixedStringBuf<N> {
         // 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());
+        assert!(!self.buf.is_empty() && self.pos < self.buf.len());
         self.buf[self.pos] = 0;
         core::ffi::CStr::from_bytes_until_nul(&self.buf[..self.pos + 1])
     }
@@ -78,8 +84,8 @@ mod test {
 
         assert_eq!(buf.as_str().unwrap(), "");
 
-        write!(&mut buf, "{}", "0123456789").expect("Failed to write to FixedBuf");
-        write!(&mut buf, "{}", "0123456789").expect("Failed to write to FixedBuf");
+        write!(&mut buf, "0123456789").expect("Failed to write to FixedBuf");
+        write!(&mut buf, "0123456789").expect("Failed to write to FixedBuf");
         assert_eq!(buf.as_str().unwrap(), "01234567890123456789");
         assert_eq!(buf.pos, 20);
 

src/hyperlight_guest_bin/src/lib.rs

@@ -18,7 +18,6 @@ limitations under the License.
 // === Dependencies ===
 extern crate alloc;
 
-use alloc::string::ToString;
 use core::fmt::Write;
 
 use buddy_system_allocator::LockedHeap;
@@ -150,11 +149,11 @@ static PANIC_BUF: Mutex<FixedStringBuf<512>> = Mutex::new(FixedStringBuf::new())
 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 {
+    if write_res.is_err() {
         unsafe {
             abort_with_code_and_message(
                 &[ErrorCode::UnknownError as u8],
-                b"panic: message format failed\0".as_ptr() as *const i8,
+                c"panic: message format failed".as_ptr(),
             )
         }
     }
@@ -163,11 +162,11 @@ fn _panic_handler(info: &core::panic::PanicInfo) -> ! {
     // this wraps CStr::from_bytes_until_nul which takes a borrowed byte slice
     // and does not allocate.
     let c_string_res = panic_buf_guard.as_c_str();
-    if let Err(_) = c_string_res {
+    if c_string_res.is_err() {
         unsafe {
             abort_with_code_and_message(
                 &[ErrorCode::UnknownError as u8],
-                b"panic: failed to convert to CStr\0".as_ptr() as *const i8,
+                c"panic: failed to convert to CStr".as_ptr(),
             )
         }
     }

src/tests/rust_guests/simpleguest/src/main.rs

@@ -517,6 +517,11 @@ unsafe fn exhaust_heap(_: &FunctionCall) -> ! {
         ptr = alloc::alloc::alloc_zeroed(layout);
     }
 
+    // after alloc::alloc_zeroed failure (null return when called in loop above)
+    // allocate a Vec to ensure OOM panic
+    let vec = Vec::<i32>::with_capacity(1);
+    black_box(vec);
+
     panic!("function should have panicked before due to OOM")
 }