Fix Wasmtime latest runtime compatibility

Map Wasmtime 45 direct errors into Hyperlight guest errors and avoid latest-only component post_return deprecation while preserving LTS behavior.

Run clippy with the latest and LTS Wasmtime feature sets separately so mutually exclusive features are not enabled together.

Signed-off-by: James Sturtevant <jsturtevant@gmail.com>

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: jsturtevant

Justfile

@@ -6,6 +6,8 @@ latest-release:= if os() == "windows" {"$(git tag -l --sort=v:refname | select -
 wit-world := if os() == "windows" { "$env:WIT_WORLD=\"" + justfile_directory() + "\\src\\tests\\rust_guests\\component_sample\\wit\\component-world.wasm" + "\";" } else { "WIT_WORLD=" + justfile_directory() + "/src/tests/rust_guests/component_sample/wit/component-world.wasm" }
 wit-world-c := if os() == "windows" { "$env:WIT_WORLD=\"" + justfile_directory() + "\\src\\tests\\c_guests\\wasmsamples\\components\\runcomponent-world.wasm" + "\";" } else { "WIT_WORLD=" + justfile_directory() + "/src/tests/c_guests/wasmsamples/components/runcomponent-world.wasm" }
 wit-world-name-greeter := if os() == "windows" { "$env:WIT_WORLD_NAME=\"greeter-world\";" } else { "WIT_WORLD_NAME=greeter-world" }
+workspace-features-latest := "hyperlight-wasm/function_call_metrics,hyperlight-wasm/print_debug,hyperlight-wasm/crashdump,hyperlight-wasm/gdb,hyperlight-wasm/kvm,hyperlight-wasm/mshv3,hyperlight-wasm/pulley,hyperlight-wasm/trace_guest,hyperlight-wasm/wasmtime_latest,hyperlight-wasm-aot/gdb"
+workspace-features-lts := "hyperlight-wasm/function_call_metrics,hyperlight-wasm/print_debug,hyperlight-wasm/crashdump,hyperlight-wasm/gdb,hyperlight-wasm/kvm,hyperlight-wasm/mshv3,hyperlight-wasm/trace_guest,hyperlight-wasm/wasmtime_lts,hyperlight-wasm-aot/gdb"
 
 set windows-shell := ["pwsh.exe", "-NoLogo", "-Command"]
 
@@ -91,12 +93,13 @@ fmt:
     cd src/hyperlight_wasm_macro && cargo +nightly fmt -v --all
 
 clippy target=default-target: (check target)
-    cargo clippy --profile={{ if target == "debug" {"dev"} else { target } }} --all-targets --all-features -- -D warnings
+    cargo clippy --workspace --exclude hyperlight-wasm-runtime --exclude hyperlight-wasm-macro --profile={{ if target == "debug" {"dev"} else { target } }} --all-targets --no-default-features --features {{ workspace-features-latest }} -- -D warnings
+    cargo clippy --workspace --exclude hyperlight-wasm-runtime --exclude hyperlight-wasm-macro --profile={{ if target == "debug" {"dev"} else { target } }} --all-targets --no-default-features --features {{ workspace-features-lts }} -- -D warnings
     cd src/tests/rust_guests/rust_wasm_samples &&  cargo clippy --profile={{ if target == "debug" {"dev"} else { target } }} --all-targets --all-features -- -D warnings
     cd src/tests/rust_guests/component_sample &&  cargo clippy --profile={{ if target == "debug" {"dev"} else { target } }} --all-targets --all-features -- -D warnings
     cd src/tests/rust_guests/greeter_sample &&  cargo clippy --profile={{ if target == "debug" {"dev"} else { target } }} --all-targets --all-features -- -D warnings
     # hyperlight_wasm_runtime has mutually exclusive wasmtime features, so we run clippy for each separately with all other features
-    cd src/hyperlight_wasm_runtime && cargo hyperlight clippy --profile={{ if target == "debug" {"dev"} else { target } }} --all-targets --features wasmtime_latest,gdb,trace_guest,pulley -- -D warnings
+    cd src/hyperlight_wasm_runtime && cargo hyperlight clippy --profile={{ if target == "debug" {"dev"} else { target } }} --all-targets --no-default-features --features wasmtime_latest,gdb,trace_guest,pulley -- -D warnings
     cd src/hyperlight_wasm_runtime && cargo hyperlight clippy --profile={{ if target == "debug" {"dev"} else { target } }} --all-targets --no-default-features --features wasmtime_lts,gdb,trace_guest -- -D warnings
     cd src/hyperlight_wasm_macro && cargo clippy --profile={{ if target == "debug" {"dev"} else { target } }} --all-targets --all-features -- -D warnings
 

src/hyperlight_wasm_macro/src/wasmguest.rs

@@ -214,17 +214,28 @@ fn emit_wasm_function_call(
     let rwt = match result {
         None => {
             quote! {
-                let func = instance.get_typed_func::<(#(#pwts,)*), ()>(&mut *store, func_idx)?;
-                func.call(&mut *store, (#(#pus,)*))?;
-                func.post_return(&mut *store)?;
+                let func = instance
+                    .get_typed_func::<(#(#pwts,)*), ()>(&mut *store, func_idx)
+                    .map_err(crate::map_wasmtime_error)?;
+                func.call(&mut *store, (#(#pus,)*))
+                    .map_err(crate::map_wasmtime_error)?;
+                #[cfg(feature = "wasmtime_lts")]
+                func.post_return(&mut *store)
+                    .map_err(crate::map_wasmtime_error)?;
             }
         }
         _ => {
             let r = rtypes::emit_func_result(s, result);
             quote! {
-                let func = instance.get_typed_func::<(#(#pwts,)*), ((#r,))>(&mut *store, func_idx)?;
-                let #ret = func.call(&mut *store, (#(#pus,)*))?.0;
-                func.post_return(&mut *store)?;
+                let func = instance
+                    .get_typed_func::<(#(#pwts,)*), ((#r,))>(&mut *store, func_idx)
+                    .map_err(crate::map_wasmtime_error)?;
+                let #ret = func.call(&mut *store, (#(#pus,)*))
+                    .map_err(crate::map_wasmtime_error)?
+                    .0;
+                #[cfg(feature = "wasmtime_lts")]
+                func.post_return(&mut *store)
+                    .map_err(crate::map_wasmtime_error)?;
             }
         }
     };

src/hyperlight_wasm_runtime/build.rs

@@ -44,9 +44,7 @@ fn main() {
         // Multiple wasmtime versions present; pick based on feature
         wasmtime_packages
             .iter()
-            .find(|p| {
-                (use_lts && p.version.major <= 36) || (!use_lts && p.version.major > 36)
-            })
+            .find(|p| (use_lts && p.version.major <= 36) || (!use_lts && p.version.major > 36))
             .unwrap_or_else(|| panic!("wasmtime dependency not found for lts={}", use_lts))
             .version
             .clone()

src/hyperlight_wasm_runtime/src/component.rs

@@ -34,7 +34,7 @@ use tracing::instrument;
 use wasmtime::component::{Component, Instance, Linker};
 use wasmtime::{Config, Engine, Store};
 
-use crate::platform;
+use crate::{map_wasmtime_error, platform};
 
 static CUR_ENGINE: Mutex<Option<Engine>> = Mutex::new(None);
 static CUR_LINKER: Mutex<Option<Linker<()>>> = Mutex::new(None);
@@ -55,7 +55,8 @@ fn load_component_common(engine: &Engine, component: Component) -> Result<()> {
     let instance = (*CUR_LINKER.lock())
         .as_ref()
         .unwrap()
-        .instantiate(&mut store, &component)?;
+        .instantiate(&mut store, &component)
+        .map_err(map_wasmtime_error)?;
     *CUR_STORE.lock() = Some(store);
     *CUR_INSTANCE.lock() = Some(instance);
     Ok(())
@@ -72,7 +73,8 @@ fn load_wasm_module(function_call: FunctionCall) -> Result<Vec<u8>> {
         &function_call.parameters.as_ref().unwrap()[1],
         &*CUR_ENGINE.lock(),
     ) {
-        let component = unsafe { Component::deserialize(engine, wasm_bytes)? };
+        let component =
+            unsafe { Component::deserialize(engine, wasm_bytes).map_err(map_wasmtime_error)? };
         load_component_common(engine, component)?;
         Ok(get_flatbuffer_result::<i32>(0))
     } else {
@@ -90,8 +92,10 @@ fn load_wasm_module_phys(function_call: FunctionCall) -> Result<Vec<u8>> {
         &function_call.parameters.as_ref().unwrap()[1],
         &*CUR_ENGINE.lock(),
     ) {
-        let component =
-            unsafe { Component::deserialize_raw(engine, platform::map_buffer(*phys, *len))? };
+        let component = unsafe {
+            Component::deserialize_raw(engine, platform::map_buffer(*phys, *len))
+                .map_err(map_wasmtime_error)?
+        };
         load_component_common(engine, component)?;
         Ok(get_flatbuffer_result::<()>(()))
     } else {

src/hyperlight_wasm_runtime/src/lib.rs

@@ -19,6 +19,11 @@ limitations under the License.
 
 extern crate alloc;
 
+use alloc::string::ToString;
+
+use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
+use hyperlight_guest::error::HyperlightGuestError;
+
 // Re-export wasmtime based on expected version
 #[cfg(all(feature = "wasmtime_latest", feature = "wasmtime_lts"))]
 compile_error!(
@@ -33,6 +38,10 @@ extern crate wasmtime;
 #[cfg(feature = "wasmtime_lts")]
 extern crate wasmtime_lts as wasmtime;
 
+pub(crate) fn map_wasmtime_error(error: wasmtime::Error) -> HyperlightGuestError {
+    HyperlightGuestError::new(ErrorCode::GuestError, error.to_string())
+}
+
 mod platform;
 
 #[cfg(not(component))]

src/hyperlight_wasm_runtime/src/marshal.rs

@@ -60,6 +60,8 @@ use spin::Mutex;
 use tracing::instrument;
 use wasmtime::{AsContextMut, Extern, Val};
 
+use crate::map_wasmtime_error;
+
 // Global tracking for return value allocations that need to be freed on next VM entry
 static RETURN_VALUE_ALLOCATIONS: Mutex<Vec<i32>> = Mutex::new(Vec::new());
 
@@ -95,8 +97,10 @@ fn malloc<C: AsContextMut>(
             "malloc function not exported".to_string(),
         ))?;
     let addr = malloc
-        .typed::<i32, i32>(&mut *ctx)?
-        .call(&mut *ctx, len as i32)?;
+        .typed::<i32, i32>(&mut *ctx)
+        .map_err(map_wasmtime_error)?
+        .call(&mut *ctx, len as i32)
+        .map_err(map_wasmtime_error)?;
     Ok(addr)
 }
 
@@ -112,7 +116,10 @@ fn free<C: AsContextMut>(
             ErrorCode::GuestError,
             "free function not exported".to_string(),
         ))?;
-    free.typed::<i32, ()>(&mut *ctx)?.call(&mut *ctx, addr)?;
+    free.typed::<i32, ()>(&mut *ctx)
+        .map_err(map_wasmtime_error)?
+        .call(&mut *ctx, addr)
+        .map_err(map_wasmtime_error)?;
     Ok(())
 }
 

src/hyperlight_wasm_runtime/src/module.rs

@@ -33,7 +33,7 @@ use spin::Mutex;
 use tracing::instrument;
 use wasmtime::{Config, Engine, Linker, Module, Store, Val};
 
-use crate::{hostfuncs, marshal, platform, wasip1};
+use crate::{hostfuncs, map_wasmtime_error, marshal, platform, wasip1};
 
 // Set by transition to WasmSandbox (by init_wasm_runtime)
 static CUR_ENGINE: Mutex<Option<Engine>> = Mutex::new(None);
@@ -86,7 +86,8 @@ pub fn guest_dispatch_function(function_call: FunctionCall) -> Result<Vec<u8>> {
     let is_void = ReturnType::Void == function_call.expected_return_type;
     let n_results = if is_void { 0 } else { 1 };
     let mut results = vec![Val::I32(0); n_results];
-    func.call(&mut *store, &w_params, &mut results)?;
+    func.call(&mut *store, &w_params, &mut results)
+        .map_err(map_wasmtime_error)?;
     marshal::val_to_hl_result(
         &mut *store,
         |ctx, name| instance.get_export(ctx, name),
@@ -119,7 +120,7 @@ fn init_wasm_runtime(function_call: FunctionCall) -> Result<Vec<u8>> {
             "Failed to set wasmtime target: pulley64".to_string(),
         )
     })?;
-    let engine = Engine::new(&config)?;
+    let engine = Engine::new(&config).map_err(map_wasmtime_error)?;
     let mut linker = Linker::new(&engine);
     wasip1::register_handlers(&mut linker)?;
 
@@ -157,15 +158,17 @@ fn init_wasm_runtime(function_call: FunctionCall) -> Result<Vec<u8>> {
 
     for hostfunc in hostfuncs.iter() {
         let captured = hostfunc.clone();
-        linker.func_new(
-            "env",
-            &hostfunc.function_name,
-            hostfuncs::hostfunc_type(hostfunc, &engine)?,
-            move |c, ps, rs| {
-                hostfuncs::call(&captured, c, ps, rs)
-                    .map_err(|e| wasmtime::Error::msg(format!("{:?}", e)))
-            },
-        )?;
+        linker
+            .func_new(
+                "env",
+                &hostfunc.function_name,
+                hostfuncs::hostfunc_type(hostfunc, &engine)?,
+                move |c, ps, rs| {
+                    hostfuncs::call(&captured, c, ps, rs)
+                        .map_err(|e| wasmtime::Error::msg(format!("{:?}", e)))
+                },
+            )
+            .map_err(map_wasmtime_error)?;
     }
 
     *CUR_ENGINE.lock() = Some(engine);
@@ -190,9 +193,12 @@ fn load_wasm_module(function_call: FunctionCall) -> Result<Vec<u8>> {
             "impossible: wasm runtime has no valid linker".to_string(),
         ))?;
 
-        let module = unsafe { Module::deserialize(engine, wasm_bytes)? };
+        let module =
+            unsafe { Module::deserialize(engine, wasm_bytes).map_err(map_wasmtime_error)? };
         let mut store = Store::new(engine, ());
-        let instance = linker.instantiate(&mut store, &module)?;
+        let instance = linker
+            .instantiate(&mut store, &module)
+            .map_err(map_wasmtime_error)?;
 
         *CUR_MODULE.lock() = Some(module);
         *CUR_STORE.lock() = Some(store);
@@ -219,9 +225,14 @@ fn load_wasm_module_phys(function_call: FunctionCall) -> Result<Vec<u8>> {
             "impossible: wasm runtime has no valid linker".to_string(),
         ))?;
 
-        let module = unsafe { Module::deserialize_raw(engine, platform::map_buffer(*phys, *len))? };
+        let module = unsafe {
+            Module::deserialize_raw(engine, platform::map_buffer(*phys, *len))
+                .map_err(map_wasmtime_error)?
+        };
         let mut store = Store::new(engine, ());
-        let instance = linker.instantiate(&mut store, &module)?;
+        let instance = linker
+            .instantiate(&mut store, &module)
+            .map_err(map_wasmtime_error)?;
 
         *CUR_MODULE.lock() = Some(module);
         *CUR_STORE.lock() = Some(store);

src/hyperlight_wasm_runtime/src/platform.rs

@@ -65,7 +65,10 @@ pub(crate) fn register_page_fault_handler() {
     // See AMD64 Architecture Programmer's Manual, Volume 2
     //    §8.2 Vectors, p. 245
     //      Table 8-1: Interrupt Vector Source and Cause
-    arch::HANDLERS[14].store(page_fault_handler as usize as u64, Ordering::Release);
+    arch::HANDLERS[14].store(
+        page_fault_handler as *const () as usize as u64,
+        Ordering::Release,
+    );
 }
 
 // Wasmtime Embedding Interface
@@ -161,7 +164,10 @@ pub extern "C" fn wasmtime_init_traps(handler: wasmtime_trap_handler_t) -> i32 {
     // See AMD64 Architecture Programmer's Manual, Volume 2
     //    §8.2 Vectors, p. 245
     //      Table 8-1: Interrupt Vector Source and Cause
-    arch::HANDLERS[6].store(wasmtime_trap_handler as usize as u64, Ordering::Release);
+    arch::HANDLERS[6].store(
+        wasmtime_trap_handler as *const () as usize as u64,
+        Ordering::Release,
+    );
     // TODO: Add handlers for any other traps that wasmtime needs,
     //       probably including at least some floating-point
     //       exceptions