Struct Linker

pub struct Linker {
    linker_state: Arc<RwLock<LinkerState>>,
    instance_group_state: Arc<Mutex<Option<InstanceGroupState>>>,
    dl_operation_pending: Arc<AtomicBool>,
}

The linker is responsible for loading and linking dynamic modules at runtime, and managing the shared memory and indirect function table. Each linker instance represents a specific instance group. Cloning a linker instance does not create a new instance group though; the clone will refer to the same group as the original.

Fields

linker_state: Arc<RwLock<LinkerState>>

instance_group_state: Arc<Mutex<Option<InstanceGroupState>>>

dl_operation_pending: Arc<AtomicBool>

Implementations

impl Linker

pub fn new( main_module: &Module, store: &mut StoreMut<'_>, memory: Option<Memory>, func_env: &mut WasiFunctionEnv, stack_size: u64, ) -> Result<(Self, LinkedMainModule), LinkError>

Creates a new linker for the given main module. The module is expected to be a PIE executable. Imports for the module will be fulfilled, so that it can start running, and a Linker instance is returned which can then be used for the loading/linking of further side modules.

pub fn create_instance_group( &self, parent_ctx: &mut FunctionEnvMut<'_, WasiEnv>, store: &mut StoreMut<'_>, func_env: &mut WasiFunctionEnv, ) -> Result<(Self, LinkedMainModule), LinkError>

pub fn shutdown_instance_group( &self, ctx: &mut FunctionEnvMut<'_, WasiEnv>, ) -> Result<(), LinkError>

pub fn load_module( &self, module_path: impl AsRef<Path>, library_path: &[impl AsRef<Path>], ctx: &mut FunctionEnvMut<'_, WasiEnv>, ) -> Result<ModuleHandle, LinkError>

Loads a side module from the given path, linking it against the existing module tree and instantiating it. Symbols from the module can then be retrieved by calling Linker::resolve_export.

fn finalize_link_operation( &self, group_state_guard: MutexGuard<'_, Option<InstanceGroupState>>, linker_state: &mut LinkerState, store: &mut impl AsStoreMut, link_state: InProgressLinkState, ) -> Result<(), LinkError>

pub fn resolve_export( &self, ctx: &mut FunctionEnvMut<'_, WasiEnv>, module_handle: Option<ModuleHandle>, symbol: &str, ) -> Result<ResolvedExport, ResolveError>

Resolves an export from the module corresponding to the given module handle. Only functions and globals can be resolved.

If the symbol is a global, the returned value will be the absolute address of the data corresponding to that global within the shared linear memory.

If it’s a function, it’ll be placed into the indirect function table, which creates a “function pointer” that can be used from WASM code.

pub fn is_handle_valid( &self, handle: ModuleHandle, ctx: &mut FunctionEnvMut<'_, WasiEnv>, ) -> Result<bool, LinkError>

fn synchronize_link_operation( &self, op: DlOperation, linker_state_write_lock: RwLockWriteGuard<'_, LinkerState>, group_state: &mut InstanceGroupState, wasi_process: &WasiProcess, self_thread_id: WasiThreadId, )

pub(crate) fn do_pending_link_operations( &self, ctx: &mut FunctionEnvMut<'_, WasiEnv>, fast: bool, ) -> Result<(), LinkError>

fn do_pending_link_operations_internal( &self, group_state: &mut InstanceGroupState, store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>, ) -> Result<(), LinkError>

Trait Implementations

impl Clone for Linker

fn clone(&self) -> Linker

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Linker

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.