gsc-executor-wasmtime 0.35.0

Defines a `WasmRuntime` that uses the Wasmtime JIT to execute.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

// Copyright (C) Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0

//! This module defines `HostContext`, which provides logic required for host execution.

use std::cell::Cell;
pub use wasmtime::Caller;

use sp_wasm_interface::{FunctionContext, Pointer, WordSize};

use crate::{store_data::StoreData, util};

thread_local! {
    static CURRENT_CALLER: Cell<*mut ()> = const { Cell::new(std::ptr::null_mut()) };
}

struct CurrentCallerGuard<'a> {
    cell: &'a Cell<*mut ()>,
    previous: *mut (),
}

impl Drop for CurrentCallerGuard<'_> {
    fn drop(&mut self) {
        self.cell.set(self.previous);
    }
}

/// A `HostContext` implements `FunctionContext` for making host calls from a Wasmtime
/// runtime. The `HostContext` exists only for the lifetime of the call and borrows state from
/// a longer-living `HostState`.
pub(crate) struct HostContext<'a> {
    pub(crate) caller: Caller<'a, StoreData>,
}

pub(crate) fn with_host_context<R>(
    host_context: &mut HostContext<'_>,
    callback: impl FnOnce(&mut dyn FunctionContext) -> R,
) -> R {
    CURRENT_CALLER.with(|cell| {
        let _guard = CurrentCallerGuard {
            cell,
            previous: cell.replace(&mut host_context.caller as *mut _ as *mut ()),
        };
        callback(host_context)
    })
}

/// Runs `callback` with the active Wasmtime caller for the current host call.
///
/// This is the Gear-local replacement for the caller accessor that used to live in the custom
/// Polkadot SDK fork. It is intentionally scoped to the Wasmtime executor.
pub fn with_caller_mut<R>(
    _context: &mut dyn FunctionContext,
    callback: impl FnOnce(&mut Caller<'_, StoreData>) -> R,
) -> R {
    CURRENT_CALLER.with(|cell| {
        let ptr = cell.get();
        assert!(
            !ptr.is_null(),
            "Wasmtime caller is only available during a host call"
        );
        let caller = unsafe { &mut *(ptr as *mut Caller<'_, StoreData>) };
        callback(caller)
    })
}

impl<'a> FunctionContext for HostContext<'a> {
    fn read_memory_into(
        &self,
        address: Pointer<u8>,
        dest: &mut [u8],
    ) -> sp_wasm_interface::Result<()> {
        util::read_memory_into(&self.caller, address, dest).map_err(|e| e.to_string())
    }

    fn write_memory(&mut self, address: Pointer<u8>, data: &[u8]) -> sp_wasm_interface::Result<()> {
        util::write_memory_from(&mut self.caller, address, data).map_err(|e| e.to_string())
    }

    fn allocate_memory(&mut self, size: WordSize) -> sp_wasm_interface::Result<Pointer<u8>> {
        util::allocate_memory(&mut self.caller, size).map_err(|e| e.to_string())
    }

    fn deallocate_memory(&mut self, ptr: Pointer<u8>) -> sp_wasm_interface::Result<()> {
        util::deallocate_memory(&mut self.caller, ptr).map_err(|e| e.to_string())
    }

    fn register_panic_error_message(&mut self, message: &str) {
        self.caller
            .data_mut()
            .host_state_mut()
            .expect("host state is not empty when calling a function in wasm; qed")
            .panic_message = Some(message.to_owned());
    }
}