在Rust中使用全局Wasmtime Linker对象实现Wasm模块动态链接的技术问题

嘿，我刚好在Wasmtime上折腾过类似的动态链接需求，踩过不少坑，给你分享下亲测可行的实现思路和代码示例！

核心思路 #

要实现host_dlopen()和host_dlsym()这两个宿主函数，关键是要打破Wasmtime默认“每个实例一个Linker”的限制，维护一个全局共享的Linker实例，用来统一管理所有已加载的Wasm模块及其导出函数。同时还要用线程安全的容器存储已加载的模块，避免重复加载。

第一步：定义全局共享状态 #

我们需要两个全局容器：一个用来存共享的Linker，另一个存已加载的Wasm模块。因为要跨实例、跨线程访问，所以用Arc<Mutex<>>来保证线程安全：

use std::collections::HashMap;
use std::sync::{Arc, Mutex, Lazy};
use wasmtime::{Caller, Engine, Func, Linker, Module, Store, WasmError};

// 全局存储已加载的Wasm模块
static MODULE_STORAGE: Lazy<Arc<Mutex<HashMap<String, Module>>>> = Lazy::new(|| {
    Arc::new(Mutex::new(HashMap::new()))
});

第二步：实现host_dlopen()函数 #

这个函数的作用是加载指定路径的Wasm模块，并把它的所有导出注册到全局Linker中。注意要先检查模块是否已经加载过，避免重复注册：

fn host_dlopen(
    mut caller: Caller<'_, Arc<Mutex<Linker<()>>>>,
    module_path: String,
) -> Result<u32, WasmError> {
    // 锁定全局Linker和模块存储
    let mut shared_linker = caller.data().lock().unwrap();
    let mut modules = MODULE_STORAGE.lock().unwrap();

    // 检查模块是否已加载，避免重复操作
    if modules.contains_key(&module_path) {
        return Ok(0); // 用0表示加载成功，你也可以自定义返回码
    }

    // 从文件加载Wasm模块
    let engine = shared_linker.engine();
    let module_bytes = std::fs::read(&module_path)?;
    let module = Module::new(engine, module_bytes)?;

    // 将模块导出注册到全局Linker
    shared_linker.module(&mut caller, "", &module)?;
    // 可选：允许同名导出覆盖，适合模块间有同名函数的场景
    shared_linker.allow_shadowing(true);

    // 把模块存入全局存储
    modules.insert(module_path, module);
    Ok(0)
}

第三步：实现host_dlsym()函数 #

这个函数负责根据函数名从全局Linker中查找对应的导出函数。因为Wasm不能直接接收Func类型，我们可以返回一个整数ID，再维护一个全局函数映射表来实现间接调用：

// 额外定义全局函数存储，用来映射ID和Func
static FUNC_STORAGE: Lazy<Arc<Mutex<HashMap<u32, Func>>>> = Lazy::new(|| {
    Arc::new(Mutex::new(HashMap::new()))
});
static mut NEXT_FUNC_ID: u32 = 0;

fn host_dlsym(
    caller: Caller<'_, Arc<Mutex<Linker<()>>>>,
    func_name: String,
) -> Result<u32, WasmError> {
    let shared_linker = caller.data().lock().unwrap();
    let mut funcs = FUNC_STORAGE.lock().unwrap();

    // 查找函数
    match shared_linker.get(&caller, &func_name) {
        Ok(func) => {
            // 生成唯一ID并存入映射表
            let func_id = unsafe {
                NEXT_FUNC_ID += 1;
                NEXT_FUNC_ID
            };
            funcs.insert(func_id, func);
            Ok(func_id)
        }
        Err(_) => Err(WasmError::msg(format!("Function {} not found", func_name))),
    }
}

// 辅助函数：让Wasm通过ID调用动态加载的函数
fn host_call_func(
    caller: Caller<'_, Arc<Mutex<Linker<()>>>>,
    func_id: u32,
    args: Vec<u64>,
) -> Result<Vec<u64>, WasmError> {
    let mut funcs = FUNC_STORAGE.lock().unwrap();
    match funcs.get(&func_id) {
        Some(func) => {
            // 根据函数签名处理参数和返回值，示例做简化处理
            let mut results = vec![0; func.ty(&caller).results().len()];
            func.call(&caller, &args, &mut results)?;
            Ok(results)
        }
        None => Err(WasmError::msg(format!("Function ID {} not found", func_id))),
    }
}

第四步：初始化环境并运行主模块 #

最后，我们需要把宿主函数注册到全局Linker，然后创建存储和实例，让主Wasm模块可以调用这些宿主函数：

fn main() -> Result<(), WasmError> {
    // 初始化Wasmtime引擎
    let engine = Engine::default();
    let mut linker = Linker::new(&engine);

    // 把Linker包装成线程安全的共享对象
    let shared_linker = Arc::new(Mutex::new(linker));

    // 注册宿主函数到Linker
    let mut linker_ref = shared_linker.lock().unwrap();
    linker_ref.func_wrap("env", "host_dlopen", host_dlopen)?;
    linker_ref.func_wrap("env", "host_dlsym", host_dlsym)?;
    linker_ref.func_wrap("env", "host_call_func", host_call_func)?;

    // 加载并实例化主Wasm模块
    let main_module = Module::new(&engine, std::fs::read("main.wasm")?)?;
    let mut store = Store::new(&engine, shared_linker.clone());
    let instance = linker_ref.instantiate(&mut store, &main_module)?;

    // 运行主模块的入口函数
    if let Some(start_func) = instance.get_func(&mut store, "_start") {
        start_func.call(&mut store, &[], &mut [])?;
    }

    Ok(())
}

关键注意事项 #

• 线程安全：所有全局状态都用Arc<Mutex<>>包裹，确保多实例或多线程访问时不会出问题，但要注意锁的粒度，避免死锁。
• 命名冲突：如果多个模块有同名导出，开启allow_shadowing(true)会让后加载的模块覆盖之前的，建议给每个模块的导出加上独特前缀，或者用Linker的命名空间功能。
• 签名匹配：Wasm调用宿主函数或动态加载的函数时，参数和返回值的类型必须严格匹配，否则会触发运行时错误，调试时可以用Wasmtime的Func::ty()方法检查签名。

内容来源于stack exchange