hyperlight-capi

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

Author: ludfjig

Cargo.lock

@@ -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/Cargo.toml

@@ -11,22 +11,25 @@ use hyperlight_guest::error::{HyperlightGuestError, Result};
 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,7 +67,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 +82,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/dispatch.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);
 }
 
-#[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, message) };
 }

src/hyperlight_guest_capi/src/error.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/flatbuffer.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,