Update hyperlight-guest-capi to 2024 edition

Signed-off-by: Ludvig Liljenberg <[email protected]>

Author: ludfjig

src/hyperlight_guest_capi/Cargo.toml

@@ -15,6 +15,7 @@ workspace = true
 hyperlight-guest = { workspace = true, default-features = true }
 hyperlight-common = { workspace = true, default-features = false }
 log = { version = "0.4", default-features = false }
+spin = "0.9.8"
 
 [build-dependencies]
 cbindgen = "0.28.0"

src/hyperlight_guest_capi/src/dispatch.rs

@@ -12,21 +12,25 @@ use hyperlight_guest::guest_function_definition::GuestFunctionDefinition;
 use hyperlight_guest::guest_function_register::GuestFunctionRegister;
 use hyperlight_guest::host_function_call::call_host_function;
 
+use spin::Mutex;
+
 use crate::types::{FfiFunctionCall, FfiVec};
-static mut REGISTERED_C_GUEST_FUNCTIONS: GuestFunctionRegister = GuestFunctionRegister::new();
+static REGISTERED_C_GUEST_FUNCTIONS: Mutex<GuestFunctionRegister> =
+    Mutex::new(GuestFunctionRegister::new());
 
 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>> {
-    if let Some(registered_func) =
-        unsafe { REGISTERED_C_GUEST_FUNCTIONS.get(&function_call.function_name) }
+    if let Some(registered_func) = REGISTERED_C_GUEST_FUNCTIONS
+        .lock()
+        .get(&function_call.function_name)
     {
         let function_call_parameter_types: Vec<ParameterType> = function_call
             .parameters
@@ -64,8 +68,11 @@ pub fn guest_dispatch_function(function_call: FunctionCall) -> Result<Vec<u8>> {
     }
 }
 
-#[no_mangle]
-pub extern "C" fn hl_register_function_definition(
+/// # Safety
+///
+/// Dereferences the given raw pointers
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn hl_register_function_definition(
     function_name: *const c_char,
     func_ptr: CGuestFunc,
     param_no: usize,
@@ -79,12 +86,11 @@ 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);
+    REGISTERED_C_GUEST_FUNCTIONS.lock().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,25 @@ use core::ffi::c_char;
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 use hyperlight_guest::guest_error::setError;
 
-#[no_mangle]
-pub extern "C" fn hl_set_error(err: ErrorCode, message: *const c_char) {
+/// # Safety
+///
+/// Dereferences the given raw pointer.
+#[unsafe(no_mangle)]
+pub unsafe 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);
 }
 
-#[no_mangle]
-pub extern "C" fn hl_abort_with_code_and_message(err: i32, message: *const c_char) {
+/// # Safety
+///
+/// Dereferences the given raw pointer.
+#[unsafe(no_mangle)]
+pub unsafe 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, message) };
 }

src/hyperlight_guest_capi/src/flatbuffer.rs

@@ -10,65 +10,74 @@ 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]
-pub extern "C" fn hl_flatbuffer_result_from_String(value: *const c_char) -> Box<FfiVec> {
+/// # Safety
+///
+/// Dereferences the given raw pointer.
+#[unsafe(no_mangle)]
+pub unsafe 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]
-pub extern "C" fn hl_flatbuffer_result_from_Bytes(data: *const u8, len: usize) -> Box<FfiVec> {
+/// # Safety
+///
+/// Dereferences the given raw pointer.
+#[unsafe(no_mangle)]
+pub unsafe 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) };
 
     let vec = get_flatbuffer_result(slice);
@@ -78,23 +87,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,7 +1,10 @@
 use core::ffi::c_char;
 
-#[no_mangle]
-pub extern "C" fn hl_log(
+/// # Safety
+///
+/// Dereferences the given raw pointers.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn hl_log(
     level: log::Level,
     message: *const c_char,
     line: i32,