add rough native plugin sketch

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>

Author: rvolosatovs

Cargo.lock

@@ -174,6 +174,9 @@ members = [
   "examples/min-platform",
   "examples/min-platform/embedding",
   "examples/wasip2-plugins",
+  "examples/native-plugin",
+  "examples/native-plugin/rust-plugin",
+  "examples/native-plugin/wasm",
   "fuzz",
   "winch/codegen",
 ]

Cargo.toml

@@ -118,6 +118,25 @@ impl HostFunc {
         }
     }
 
+    pub(crate) unsafe fn new_unchecked<T, F>(func: F) -> Arc<HostFunc>
+    where
+        T: 'static,
+        F: Fn(StoreContextMut<'_, T>, ComponentFunc, &mut [MaybeUninit<ValRaw>]) -> Result<()>
+            + Send
+            + Sync
+            + 'static,
+    {
+        let entrypoint = raw_entrypoint::<T, F>;
+        Arc::new(HostFunc {
+            entrypoint,
+            // This function performs external type checks and subsequently does
+            // not need to perform up-front type checks. Instead everything is
+            // dynamically managed at runtime.
+            typecheck: Box::new(move |_expected_index, _expected_types| Ok(())),
+            func: Box::new(func),
+        })
+    }
+
     fn new_dynamic_canonical<T, F>(func: F) -> Arc<HostFunc>
     where
         F: Fn(
@@ -664,6 +683,55 @@ where
     }
 }
 
+unsafe fn call_raw<T, F>(
+    mut store: StoreContextMut<'_, T>,
+    instance: Instance,
+    ty: TypeFuncIndex,
+    options_idx: OptionsIndex,
+    storage: &mut [MaybeUninit<ValRaw>],
+    closure: F,
+) -> Result<()>
+where
+    F: Fn(StoreContextMut<'_, T>, ComponentFunc, &mut [MaybeUninit<ValRaw>]) -> Result<()>
+        + Send
+        + Sync
+        + 'static,
+{
+    let options = Options::new_index(store.0, instance, options_idx);
+    let vminstance = instance.id().get(store.0);
+    let opts = &vminstance.component().env_component().options[options_idx];
+    let caller_instance = opts.instance;
+    let mut flags = vminstance.instance_flags(caller_instance);
+
+    // Perform a dynamic check that this instance can indeed be left. Exiting
+    // the component is disallowed, for example, when the `realloc` function
+    // calls a canonical import.
+    if unsafe { !flags.may_leave() } {
+        return Err(anyhow!(crate::Trap::CannotLeaveComponent));
+    }
+
+    let types = instance.id().get(store.0).component().types().clone();
+
+    let lift = &mut LiftContext::new(store.0.store_opaque_mut(), &options, instance);
+    lift.enter_call();
+    let ty = ComponentFunc::from(ty, &lift.instance_type());
+
+    // TODO: Handle resources and async
+
+    closure(store.as_context_mut(), ty, storage)?;
+
+    unsafe {
+        flags.set_may_leave(false);
+    }
+    let mut lower = LowerContext::new(store, &options, &types, instance);
+    unsafe {
+        flags.set_may_leave(true);
+    }
+    lower.exit_call()?;
+
+    return Ok(());
+}
+
 pub(crate) fn validate_inbounds<T: ComponentType>(memory: &[u8], ptr: &ValRaw) -> Result<usize> {
     // FIXME(#4311): needs memory64 support
     let ptr = usize::try_from(ptr.get_u32())?;
@@ -916,6 +984,36 @@ pub(crate) fn validate_inbounds_dynamic(
     Ok(ptr)
 }
 
+extern "C" fn raw_entrypoint<T, F>(
+    cx: NonNull<VMOpaqueContext>,
+    data: NonNull<u8>,
+    ty: u32,
+    options: u32,
+    storage: NonNull<MaybeUninit<ValRaw>>,
+    storage_len: usize,
+) -> bool
+where
+    F: Fn(StoreContextMut<'_, T>, ComponentFunc, &mut [MaybeUninit<ValRaw>]) -> Result<()>
+        + Send
+        + Sync
+        + 'static,
+    T: 'static,
+{
+    let data = SendSyncPtr::new(NonNull::new(data.as_ptr() as *mut F).unwrap());
+    unsafe {
+        call_host_and_handle_result(cx, |store, instance| {
+            call_raw::<T, _>(
+                store,
+                instance,
+                TypeFuncIndex::from_u32(ty),
+                OptionsIndex::from_u32(options),
+                NonNull::slice_from_raw_parts(storage, storage_len).as_mut(),
+                &*data.as_ptr(),
+            )
+        })
+    }
+}
+
 extern "C" fn dynamic_entrypoint<T, F>(
     cx: NonNull<VMOpaqueContext>,
     data: NonNull<u8>,

crates/wasmtime/src/runtime/component/func/host.rs

@@ -1,3 +1,4 @@
+use crate::ValRaw;
 #[cfg(feature = "component-model-async")]
 use crate::component::concurrent::Accessor;
 use crate::component::func::HostFunc;
@@ -12,6 +13,7 @@ use crate::prelude::*;
 use crate::{AsContextMut, Engine, Module, StoreContextMut};
 use alloc::sync::Arc;
 use core::marker;
+use core::mem::MaybeUninit;
 #[cfg(feature = "async")]
 use core::{future::Future, pin::Pin};
 use wasmtime_environ::PrimaryMap;
@@ -674,6 +676,37 @@ impl<T: 'static> LinkerInstance<'_, T> {
         Ok(())
     }
 
+    /// Creates a [`Func::new_unchecked`]-style function named in this linker.
+    ///
+    /// For more information see [`Linker::func_wrap`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the given function type is not associated with the same engine
+    /// as this linker.
+    ///
+    /// # Safety
+    ///
+    /// See [`Func::new_unchecked`] for more safety information.
+    pub unsafe fn func_new_unchecked(
+        &mut self,
+        name: &str,
+        func: impl Fn(
+            StoreContextMut<'_, T>,
+            types::ComponentFunc,
+            &mut [MaybeUninit<ValRaw>],
+        ) -> Result<()>
+        + Send
+        + Sync
+        + 'static,
+    ) -> Result<()> {
+        self.insert(
+            name,
+            Definition::Func(unsafe { HostFunc::new_unchecked(func) }),
+        )?;
+        Ok(())
+    }
+
     /// Define a new host-provided async function using dynamic types.
     ///
     /// As [`Self::func_wrap_async`] is a dual of [`Self::func_wrap`], this

crates/wasmtime/src/runtime/component/linker.rs

@@ -59,6 +59,7 @@ create_rust_wasm(wasi wasm32-wasip1)
 create_rust_wasm(wasi wasm32-wasip2)
 create_rust_wasm(component wasm32-unknown-unknown)
 create_rust_wasm(resource-component wasm32-wasip2)
+create_rust_wasm(native-plugin wasm32-wasip2)
 
 # C/C++ examples/tests
 create_target(anyref anyref.c)

examples/CMakeLists.txt

@@ -0,0 +1,17 @@
+[package]
+name = "native-plugin"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+publish = false
+
+[dependencies]
+anyhow = { workspace = true }
+clap = { workspace = true, features = ["derive"] }
+libloading = "0.8"
+wasmtime = { workspace = true, features = ["std", "cranelift"] }
+wasmtime-wasi = { workspace = true }
+
+[lints]
+workspace = true

examples/native-plugin/Cargo.toml

@@ -0,0 +1,13 @@
+package docs:greet;
+
+interface greet {
+    greet: func(name: string) -> string;
+}
+
+world imports {
+    import greet;
+}
+
+world handler {
+    export greet;
+}

examples/native-plugin/greet.wit

@@ -0,0 +1,15 @@
+[package]
+name = "rust-plugin"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+publish = false
+
+[dependencies]
+wit-bindgen = { workspace = true, features = ["default"] }
+
+[lib]
+path = "plugin.rs"
+name = "rust_plugin"
+crate-type = ["cdylib"]

examples/native-plugin/rust-plugin/Cargo.toml

@@ -0,0 +1,20 @@
+mod bindings {
+    use crate::Handler;
+
+    wit_bindgen::generate!({
+        path: "..",
+        world: "handler",
+        generate_all,
+    });
+    export!(Handler);
+}
+
+use bindings::exports::docs::greet::greet::Guest;
+
+struct Handler;
+
+impl Guest for Handler {
+    fn greet(name: String) -> String {
+        format!("hello, {name}!")
+    }
+}