These changes to hyperlight-guest were created by running cargo fix --edition

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

Author: simongdavies

src/hyperlight_guest/src/entrypoint.rs

@@ -34,7 +34,7 @@ pub fn halt() {
     unsafe { asm!("hlt", options(nostack)) }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn abort() -> ! {
     abort_with_code(&[0, 0xFF])
 }
@@ -49,7 +49,7 @@ 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) -> ! {
+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);
 
@@ -64,16 +64,16 @@ pub unsafe fn abort_with_code_and_message(code: &[u8], message_ptr: *const c_cha
 
     // This function never returns
     unreachable!()
-}
+}}
 
-extern "C" {
+unsafe extern "C" {
     fn hyperlight_main();
     fn srand(seed: u32);
 }
 
 static INIT: Once = Once::new();
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn entrypoint(peb_address: u64, seed: u64, ops: u64, max_log_level: u64) {
     if peb_address == 0 {
         panic!("PEB address is null");

src/hyperlight_guest/src/exceptions/gdt.rs

@@ -72,7 +72,7 @@ struct GdtPointer {
 }
 
 /// Load the GDT
-pub unsafe fn load_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,
@@ -94,4 +94,4 @@ pub unsafe fn load_gdt() {
     in(reg) &gdt_ptr,
     options(nostack, preserves_flags)
     );
-}
+}}

src/hyperlight_guest/src/exceptions/handlers.rs

@@ -23,7 +23,7 @@ use hyperlight_common::outb::Exception;
 use crate::entrypoint::abort_with_code_and_message;
 
 /// Exception handler
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_exception_handler(
     stack_pointer: u64,
     exception_number: u64,

src/hyperlight_guest/src/exceptions/idtr.rs

@@ -16,17 +16,17 @@ impl Idtr {
         self.base = base;
     }
 
-    pub unsafe fn load(&self) {
+    pub unsafe fn load(&self) { unsafe {
         core::arch::asm!("lidt [{}]", in(reg) self, options(readonly, nostack, preserves_flags));
-    }
+    }}
 }
 
-pub(crate) unsafe fn load_idt() {
+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;
 
     IDTR.init(expected_base, idt_size as u16);
     IDTR.load();
-}
+}}

src/hyperlight_guest/src/exceptions/interrupt_entry.rs

@@ -21,7 +21,7 @@ use core::arch::global_asm;
 
 use crate::exceptions::handlers::hl_exception_handler;
 
-extern "C" {
+unsafe extern "C" {
     // Exception handlers
     pub(crate) fn _do_excp0();
     pub(crate) fn _do_excp1();

src/hyperlight_guest/src/guest_error.rs

@@ -45,7 +45,7 @@ pub(crate) fn set_error(error_code: ErrorCode, message: &str) {
 /// # Safety
 /// TODO
 /// cbindgen:ignore
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[allow(non_camel_case_types)]
 pub unsafe extern "C" fn setError(code: u64, message: *const c_char) {
     let error_code = ErrorCode::from(code);

src/hyperlight_guest/src/guest_function_call.rs

@@ -68,7 +68,7 @@ pub(crate) fn call_guest_function(function_call: FunctionCall) -> Result<Vec<u8>
         // TODO: ideally we would define a default implementation of this with weak linkage so the guest is not required
         // to implement the function but its seems that weak linkage is an unstable feature so for now its probably better
         // to not do that.
-        extern "Rust" {
+        unsafe extern "Rust" {
             fn guest_dispatch_function(function_call: FunctionCall) -> Result<Vec<u8>>;
         }
 
@@ -78,7 +78,7 @@ pub(crate) fn call_guest_function(function_call: FunctionCall) -> Result<Vec<u8>
 
 // This function is marked as no_mangle/inline to prevent the compiler from inlining it , if its inlined the epilogue will not be called
 // and we will leak memory as the epilogue will not be called as halt() is not going to return.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[inline(never)]
 fn internal_dispatch_function() -> Result<()> {
     #[cfg(debug_assertions)]

src/hyperlight_guest/src/host_function_call.rs

@@ -107,9 +107,9 @@ pub fn outb(port: u16, data: &[u8]) {
     }
 }
 
-pub(crate) unsafe fn out32(port: u16, val: u32) {
+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

@@ -81,30 +81,30 @@ 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.
-#[no_mangle]
-pub unsafe extern "C" fn malloc(size: usize) -> *mut c_void {
+#[unsafe(no_mangle)]
+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.
-#[no_mangle]
-pub unsafe extern "C" fn calloc(nmemb: usize, size: usize) -> *mut c_void {
+#[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");
 
     alloc_helper(total_size, true)
-}
+}}
 
 /// Frees the memory block pointed to by `ptr`.
 ///
 /// # Safety
 /// `ptr` must be a pointer to a memory block previously allocated by `memory::malloc`, `memory::calloc`, or `memory::realloc`.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn free(ptr: *mut c_void) {
     if !ptr.is_null() {
         unsafe {
@@ -120,8 +120,8 @@ pub unsafe extern "C" fn free(ptr: *mut c_void) {
 ///
 /// # Safety
 /// `ptr` must be a pointer to a memory block previously allocated by `memory::malloc`, `memory::calloc`, or `memory::realloc`.
-#[no_mangle]
-pub unsafe extern "C" fn realloc(ptr: *mut c_void, size: usize) -> *mut c_void {
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn realloc(ptr: *mut c_void, size: usize) -> *mut c_void { unsafe {
     if ptr.is_null() {
         // If the pointer is null, treat as a malloc
         return malloc(size);
@@ -155,4 +155,4 @@ pub unsafe extern "C" fn realloc(ptr: *mut c_void, size: usize) -> *mut c_void {
             new_block_start.add(1) as *mut c_void
         }
     }
-}
+}}

src/hyperlight_guest/src/print.rs

@@ -31,9 +31,9 @@ static mut MESSAGE_BUFFER: Vec<u8> = Vec::new();
 ///
 /// # Safety
 /// This function is not thread safe
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[allow(static_mut_refs)]
-pub unsafe extern "C" fn _putchar(c: c_char) {
+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).
@@ -66,4 +66,4 @@ pub unsafe extern "C" fn _putchar(c: c_char) {
         // Clear the buffer after sending
         MESSAGE_BUFFER.clear();
     }
-}
+}}