Fix hyperlight-guest for Rust Edition 2024

The is mainly the result of running `cargo fix --edition` along with a couple of manula changes to fix clippy "shared reference to mutable static" warnings

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

Author: simongdavies

src/hyperlight_guest_capi/src/dispatch.rs

@@ -17,16 +17,18 @@ static mut REGISTERED_C_GUEST_FUNCTIONS: GuestFunctionRegister = GuestFunctionRe
 
 type CGuestFunc = extern "C" fn(&FfiFunctionCall) -> Box<FfiVec>;
 
-extern "C" {
+unsafe extern "C" {
     // NOTE *mut FfiVec must be a Box<FfiVec>. This will be the case as long as the guest
     // returns a FfiVec that they created using the c-api hl_flatbuffer_result_from_* functions.
     fn c_guest_dispatch_function(function_call: &FfiFunctionCall) -> *mut FfiVec;
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub fn guest_dispatch_function(function_call: FunctionCall) -> Result<Vec<u8>> {
+    // 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_func) =
-        unsafe { REGISTERED_C_GUEST_FUNCTIONS.get(&function_call.function_name) }
+        unsafe { (*(&raw const REGISTERED_C_GUEST_FUNCTIONS)).get(&function_call.function_name) }
     {
         let function_call_parameter_types: Vec<ParameterType> = function_call
             .parameters
@@ -64,7 +66,7 @@ pub fn guest_dispatch_function(function_call: FunctionCall) -> Result<Vec<u8>> {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_register_function_definition(
     function_name: *const c_char,
     func_ptr: CGuestFunc,
@@ -79,12 +81,13 @@ pub extern "C" fn hl_register_function_definition(
     let func_def =
         GuestFunctionDefinition::new(func_name, func_params, return_type, func_ptr as usize);
 
-    #[allow(static_mut_refs)]
-    unsafe { &mut REGISTERED_C_GUEST_FUNCTIONS }.register(func_def);
+    // Use &raw mut to get a mutable raw pointer, then dereference it
+    // this is to avoid the clippy warning "shared reference to mutable static"
+    unsafe { (&mut *(&raw mut REGISTERED_C_GUEST_FUNCTIONS)).register(func_def) };
 }
 
 /// The caller is responsible for freeing the memory associated with given `FfiFunctionCall`.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_call_host_function(function_call: &FfiFunctionCall) {
     let parameters = unsafe { function_call.copy_parameters() };
     let func_name = unsafe { function_call.copy_function_name() };

src/hyperlight_guest_capi/src/error.rs

@@ -3,19 +3,19 @@ use core::ffi::c_char;
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 use hyperlight_guest::guest_error::setError;
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_set_error(err: ErrorCode, message: *const c_char) {
     unsafe {
         setError(err.into(), message);
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_abort_with_code(err: i32) {
     hyperlight_guest::entrypoint::abort_with_code(&[err as u8]);
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_abort_with_code_and_message(err: i32, message: *const c_char) {
     unsafe { hyperlight_guest::entrypoint::abort_with_code_and_message(&[err as u8], message) };
 }

src/hyperlight_guest_capi/src/flatbuffer.rs

@@ -10,64 +10,64 @@ use crate::types::FfiVec;
 // is to match the names of the variants in hl_ReturnType,
 // which is used in the C macros in macro.h
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_flatbuffer_result_from_Int(value: i32) -> Box<FfiVec> {
     let vec = get_flatbuffer_result(value);
 
     Box::new(unsafe { FfiVec::from_vec(vec) })
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_flatbuffer_result_from_UInt(value: u32) -> Box<FfiVec> {
     let vec = get_flatbuffer_result(value);
 
     Box::new(unsafe { FfiVec::from_vec(vec) })
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_flatbuffer_result_from_Long(value: i64) -> Box<FfiVec> {
     let vec = get_flatbuffer_result(value);
 
     Box::new(unsafe { FfiVec::from_vec(vec) })
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_flatbuffer_result_from_ULong(value: u64) -> Box<FfiVec> {
     let vec = get_flatbuffer_result(value);
 
     Box::new(unsafe { FfiVec::from_vec(vec) })
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_flatbuffer_result_from_Float(value: f32) -> Box<FfiVec> {
     let vec = get_flatbuffer_result(value);
 
     Box::new(unsafe { FfiVec::from_vec(vec) })
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_flatbuffer_result_from_Double(value: f64) -> Box<FfiVec> {
     let vec = get_flatbuffer_result(value);
 
     Box::new(unsafe { FfiVec::from_vec(vec) })
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_flatbuffer_result_from_Void() -> Box<FfiVec> {
     let vec = get_flatbuffer_result(());
 
     Box::new(unsafe { FfiVec::from_vec(vec) })
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_flatbuffer_result_from_String(value: *const c_char) -> Box<FfiVec> {
     let str = unsafe { CStr::from_ptr(value) };
     let vec = get_flatbuffer_result(str.to_string_lossy().as_ref());
 
     Box::new(unsafe { FfiVec::from_vec(vec) })
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_flatbuffer_result_from_Bytes(data: *const u8, len: usize) -> Box<FfiVec> {
     let slice = unsafe { core::slice::from_raw_parts(data, len) };
 
@@ -78,23 +78,23 @@ pub extern "C" fn hl_flatbuffer_result_from_Bytes(data: *const u8, len: usize) -
 
 //--- Functions for getting values returned by host functions calls
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_get_host_return_value_as_Int() -> i32 {
     get_host_return_value().expect("Unable to get host return value as int")
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_get_host_return_value_as_UInt() -> u32 {
     get_host_return_value().expect("Unable to get host return value as uint")
 }
 
 // the same for long, ulong
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_get_host_return_value_as_Long() -> i64 {
     get_host_return_value().expect("Unable to get host return value as long")
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_get_host_return_value_as_ULong() -> u64 {
     get_host_return_value().expect("Unable to get host return value as ulong")
 }

src/hyperlight_guest_capi/src/logging.rs

@@ -1,6 +1,6 @@
 use core::ffi::c_char;
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn hl_log(
     level: log::Level,
     message: *const c_char,