1use crate::{
22 host::HostState,
23 instance_wrapper::{EntryPoint, InstanceWrapper, MemoryWrapper},
24 util::{self, replace_strategy_if_broken},
25};
26
27use parking_lot::Mutex;
28use sc_allocator::{AllocationStats, FreeingBumpHeapAllocator};
29use sc_executor_common::{
30 error::{Error, Result, WasmError},
31 runtime_blob::RuntimeBlob,
32 util::checked_range,
33 wasm_runtime::{HeapAllocStrategy, WasmInstance, WasmModule},
34};
35use sp_runtime_interface::unpack_ptr_and_len;
36use sp_wasm_interface::{HostFunctions, Pointer, WordSize};
37use std::{
38 path::{Path, PathBuf},
39 sync::{
40 atomic::{AtomicBool, Ordering},
41 Arc,
42 },
43};
44use wasmtime::{AsContext, Cache, CacheConfig, Engine, Memory};
45
46const MAX_INSTANCE_COUNT: u32 = 64;
47
48#[derive(Default)]
49pub(crate) struct StoreData {
50 pub(crate) host_state: Option<HostState>,
52 pub(crate) memory: Option<Memory>,
54}
55
56impl StoreData {
57 pub fn host_state_mut(&mut self) -> Option<&mut HostState> {
59 self.host_state.as_mut()
60 }
61
62 pub fn memory(&self) -> Memory {
64 self.memory.expect("memory is always set; qed")
65 }
66}
67
68pub(crate) type Store = wasmtime::Store<StoreData>;
69
70enum Strategy {
71 RecreateInstance(InstanceCreator),
72}
73
74struct InstanceCreator {
75 engine: Engine,
76 instance_pre: Arc<wasmtime::InstancePre<StoreData>>,
77 instance_counter: Arc<InstanceCounter>,
78}
79
80impl InstanceCreator {
81 fn instantiate(&mut self) -> Result<InstanceWrapper> {
82 InstanceWrapper::new(&self.engine, &self.instance_pre, self.instance_counter.clone())
83 }
84}
85
86pub(crate) struct ReleaseInstanceHandle {
88 counter: Arc<InstanceCounter>,
89}
90
91impl Drop for ReleaseInstanceHandle {
92 fn drop(&mut self) {
93 {
94 let mut counter = self.counter.counter.lock();
95 *counter = counter.saturating_sub(1);
96 }
97
98 self.counter.wait_for_instance.notify_one();
99 }
100}
101
102#[derive(Default)]
109pub(crate) struct InstanceCounter {
110 counter: Mutex<u32>,
111 wait_for_instance: parking_lot::Condvar,
112}
113
114impl InstanceCounter {
115 pub fn acquire_instance(self: Arc<Self>) -> ReleaseInstanceHandle {
122 let mut counter = self.counter.lock();
123
124 while *counter >= MAX_INSTANCE_COUNT {
125 self.wait_for_instance.wait(&mut counter);
126 }
127 *counter += 1;
128
129 ReleaseInstanceHandle { counter: self.clone() }
130 }
131}
132
133pub struct WasmtimeRuntime {
136 engine: Engine,
137 instance_pre: Arc<wasmtime::InstancePre<StoreData>>,
138 instantiation_strategy: InternalInstantiationStrategy,
139 instance_counter: Arc<InstanceCounter>,
140}
141
142impl WasmModule for WasmtimeRuntime {
143 fn new_instance(&self) -> Result<Box<dyn WasmInstance>> {
144 let strategy = match self.instantiation_strategy {
145 InternalInstantiationStrategy::Builtin => Strategy::RecreateInstance(InstanceCreator {
146 engine: self.engine.clone(),
147 instance_pre: self.instance_pre.clone(),
148 instance_counter: self.instance_counter.clone(),
149 }),
150 };
151
152 Ok(Box::new(WasmtimeInstance { strategy }))
153 }
154}
155
156pub struct WasmtimeInstance {
159 strategy: Strategy,
160}
161
162impl WasmtimeInstance {
163 fn call_impl(
164 &mut self,
165 method: &str,
166 data: &[u8],
167 allocation_stats: &mut Option<AllocationStats>,
168 ) -> Result<Vec<u8>> {
169 match &mut self.strategy {
170 Strategy::RecreateInstance(ref mut instance_creator) => {
171 let mut instance_wrapper = instance_creator.instantiate()?;
172 let heap_base = instance_wrapper.extract_heap_base()?;
173 let entrypoint = instance_wrapper.resolve_entrypoint(method)?;
174 let allocator = FreeingBumpHeapAllocator::new(heap_base);
175
176 perform_call(data, &mut instance_wrapper, entrypoint, allocator, allocation_stats)
177 },
178 }
179 }
180}
181
182impl WasmInstance for WasmtimeInstance {
183 fn call_with_allocation_stats(
184 &mut self,
185 method: &str,
186 data: &[u8],
187 ) -> (Result<Vec<u8>>, Option<AllocationStats>) {
188 let mut allocation_stats = None;
189 let result = self.call_impl(method, data, &mut allocation_stats);
190 (result, allocation_stats)
191 }
192}
193
194fn setup_wasmtime_caching(
198 cache_path: &Path,
199 config: &mut wasmtime::Config,
200) -> std::result::Result<(), String> {
201 use std::fs;
202
203 let wasmtime_cache_root = cache_path.join("wasmtime");
204 fs::create_dir_all(&wasmtime_cache_root)
205 .map_err(|err| format!("cannot create the dirs to cache: {}", err))?;
206
207 let mut cache_config = CacheConfig::new();
208 cache_config.with_directory(cache_path);
209
210 let cache =
211 Cache::new(cache_config).map_err(|err| format!("failed to initiate Cache: {err:?}"))?;
212
213 config.cache(Some(cache));
214
215 Ok(())
216}
217
218fn common_config(semantics: &Semantics) -> std::result::Result<wasmtime::Config, WasmError> {
219 let mut config = wasmtime::Config::new();
220 config.cranelift_opt_level(wasmtime::OptLevel::SpeedAndSize);
221 config.cranelift_nan_canonicalization(semantics.canonicalize_nans);
222
223 let profiler = match std::env::var_os("WASMTIME_PROFILING_STRATEGY") {
224 Some(os_string) if os_string == "jitdump" => wasmtime::ProfilingStrategy::JitDump,
225 None => wasmtime::ProfilingStrategy::None,
226 Some(_) => {
227 static UNKNOWN_PROFILING_STRATEGY: AtomicBool = AtomicBool::new(false);
229 if !UNKNOWN_PROFILING_STRATEGY.swap(true, Ordering::Relaxed) {
231 log::warn!("WASMTIME_PROFILING_STRATEGY is set to unknown value, ignored.");
232 }
233 wasmtime::ProfilingStrategy::None
234 },
235 };
236 config.profiler(profiler);
237
238 let native_stack_max = match semantics.deterministic_stack_limit {
239 Some(DeterministicStackLimit { native_stack_max, .. }) => native_stack_max,
240
241 None => 1024 * 1024,
246 };
247
248 config.max_wasm_stack(native_stack_max as usize);
249
250 config.parallel_compilation(semantics.parallel_compilation);
251
252 config.wasm_reference_types(semantics.wasm_reference_types);
255 config.wasm_simd(semantics.wasm_simd);
256 config.wasm_relaxed_simd(semantics.wasm_simd);
257 config.wasm_bulk_memory(semantics.wasm_bulk_memory);
258 config.wasm_multi_value(semantics.wasm_multi_value);
259 config.wasm_multi_memory(false);
260 config.wasm_threads(false);
261 config.wasm_memory64(false);
262 config.wasm_tail_call(false);
263 config.wasm_extended_const(false);
264
265 let (use_pooling, use_cow) = match semantics.instantiation_strategy {
266 InstantiationStrategy::PoolingCopyOnWrite => (true, true),
267 InstantiationStrategy::Pooling => (true, false),
268 InstantiationStrategy::RecreateInstanceCopyOnWrite => (false, true),
269 InstantiationStrategy::RecreateInstance => (false, false),
270 };
271
272 const WASM_PAGE_SIZE: u64 = 65536;
273
274 config.memory_init_cow(use_cow);
275 config.memory_guaranteed_dense_image_size(match semantics.heap_alloc_strategy {
276 HeapAllocStrategy::Dynamic { maximum_pages } =>
277 maximum_pages.map(|p| p as u64 * WASM_PAGE_SIZE).unwrap_or(u64::MAX),
278 HeapAllocStrategy::Static { .. } => u64::MAX,
279 });
280
281 if use_pooling {
282 const MAX_WASM_PAGES: u64 = 0x10000;
283
284 let memory_pages = match semantics.heap_alloc_strategy {
285 HeapAllocStrategy::Dynamic { maximum_pages } =>
286 maximum_pages.map(|p| p as u64).unwrap_or(MAX_WASM_PAGES),
287 HeapAllocStrategy::Static { .. } => MAX_WASM_PAGES,
288 };
289
290 let mut pooling_config = wasmtime::PoolingAllocationConfig::default();
291 pooling_config
292 .max_unused_warm_slots(4)
293 .max_core_instance_size(512 * 1024)
301 .table_elements(8192)
302 .max_memory_size(memory_pages as usize * WASM_PAGE_SIZE as usize)
303 .total_tables(MAX_INSTANCE_COUNT)
304 .total_memories(MAX_INSTANCE_COUNT)
305 .total_core_instances(MAX_INSTANCE_COUNT);
308
309 config.allocation_strategy(wasmtime::InstanceAllocationStrategy::Pooling(pooling_config));
310 }
311
312 Ok(config)
313}
314
315#[derive(Clone)]
341pub struct DeterministicStackLimit {
342 pub logical_max: u32,
347 pub native_stack_max: u32,
358}
359
360#[non_exhaustive]
370#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
371pub enum InstantiationStrategy {
372 PoolingCopyOnWrite,
377
378 RecreateInstanceCopyOnWrite,
381
382 Pooling,
385
386 RecreateInstance,
388}
389
390enum InternalInstantiationStrategy {
391 Builtin,
392}
393
394#[derive(Clone)]
395pub struct Semantics {
396 pub instantiation_strategy: InstantiationStrategy,
398
399 pub deterministic_stack_limit: Option<DeterministicStackLimit>,
410
411 pub canonicalize_nans: bool,
424
425 pub parallel_compilation: bool,
427
428 pub heap_alloc_strategy: HeapAllocStrategy,
430
431 pub wasm_multi_value: bool,
433
434 pub wasm_bulk_memory: bool,
436
437 pub wasm_reference_types: bool,
439
440 pub wasm_simd: bool,
442}
443
444#[derive(Clone)]
445pub struct Config {
446 pub allow_missing_func_imports: bool,
451
452 pub cache_path: Option<PathBuf>,
454
455 pub semantics: Semantics,
457}
458
459enum CodeSupplyMode<'a> {
460 Fresh(RuntimeBlob),
462
463 Precompiled(&'a Path),
471
472 PrecompiledBytes(&'a [u8]),
477}
478
479pub fn create_runtime<H>(
485 blob: RuntimeBlob,
486 config: Config,
487) -> std::result::Result<WasmtimeRuntime, WasmError>
488where
489 H: HostFunctions,
490{
491 unsafe { do_create_runtime::<H>(CodeSupplyMode::Fresh(blob), config) }
493}
494
495pub unsafe fn create_runtime_from_artifact<H>(
512 compiled_artifact_path: &Path,
513 config: Config,
514) -> std::result::Result<WasmtimeRuntime, WasmError>
515where
516 H: HostFunctions,
517{
518 do_create_runtime::<H>(CodeSupplyMode::Precompiled(compiled_artifact_path), config)
519}
520
521pub unsafe fn create_runtime_from_artifact_bytes<H>(
537 compiled_artifact_bytes: &[u8],
538 config: Config,
539) -> std::result::Result<WasmtimeRuntime, WasmError>
540where
541 H: HostFunctions,
542{
543 do_create_runtime::<H>(CodeSupplyMode::PrecompiledBytes(compiled_artifact_bytes), config)
544}
545
546unsafe fn do_create_runtime<H>(
551 code_supply_mode: CodeSupplyMode<'_>,
552 mut config: Config,
553) -> std::result::Result<WasmtimeRuntime, WasmError>
554where
555 H: HostFunctions,
556{
557 replace_strategy_if_broken(&mut config.semantics.instantiation_strategy);
558
559 let mut wasmtime_config = common_config(&config.semantics)?;
560 if let Some(ref cache_path) = config.cache_path {
561 if let Err(reason) = setup_wasmtime_caching(cache_path, &mut wasmtime_config) {
562 log::warn!(
563 "failed to setup wasmtime cache. Performance may degrade significantly: {}.",
564 reason,
565 );
566 }
567 }
568
569 let engine = Engine::new(&wasmtime_config)
570 .map_err(|e| WasmError::Other(format!("cannot create the wasmtime engine: {:#}", e)))?;
571
572 let (module, instantiation_strategy) = match code_supply_mode {
573 CodeSupplyMode::Fresh(blob) => {
574 let blob = prepare_blob_for_compilation(blob, &config.semantics)?;
575 let serialized_blob = blob.clone().serialize();
576
577 let module = wasmtime::Module::new(&engine, &serialized_blob)
578 .map_err(|e| WasmError::Other(format!("cannot create module: {:#}", e)))?;
579
580 match config.semantics.instantiation_strategy {
581 InstantiationStrategy::Pooling |
582 InstantiationStrategy::PoolingCopyOnWrite |
583 InstantiationStrategy::RecreateInstance |
584 InstantiationStrategy::RecreateInstanceCopyOnWrite =>
585 (module, InternalInstantiationStrategy::Builtin),
586 }
587 },
588 CodeSupplyMode::Precompiled(compiled_artifact_path) => {
589 let module = wasmtime::Module::deserialize_file(&engine, compiled_artifact_path)
594 .map_err(|e| WasmError::Other(format!("cannot deserialize module: {:#}", e)))?;
595
596 (module, InternalInstantiationStrategy::Builtin)
597 },
598 CodeSupplyMode::PrecompiledBytes(compiled_artifact_bytes) => {
599 let module = wasmtime::Module::deserialize(&engine, compiled_artifact_bytes)
604 .map_err(|e| WasmError::Other(format!("cannot deserialize module: {:#}", e)))?;
605
606 (module, InternalInstantiationStrategy::Builtin)
607 },
608 };
609
610 let mut linker = wasmtime::Linker::new(&engine);
611 crate::imports::prepare_imports::<H>(&mut linker, &module, config.allow_missing_func_imports)?;
612
613 let instance_pre = linker
614 .instantiate_pre(&module)
615 .map_err(|e| WasmError::Other(format!("cannot preinstantiate module: {:#}", e)))?;
616
617 Ok(WasmtimeRuntime {
618 engine,
619 instance_pre: Arc::new(instance_pre),
620 instantiation_strategy,
621 instance_counter: Default::default(),
622 })
623}
624
625fn prepare_blob_for_compilation(
626 mut blob: RuntimeBlob,
627 semantics: &Semantics,
628) -> std::result::Result<RuntimeBlob, WasmError> {
629 if let Some(DeterministicStackLimit { logical_max, .. }) = semantics.deterministic_stack_limit {
630 blob = blob.inject_stack_depth_metering(logical_max)?;
631 }
632
633 blob.convert_memory_import_into_export()?;
638 blob.setup_memory_according_to_heap_alloc_strategy(semantics.heap_alloc_strategy)?;
639
640 Ok(blob)
641}
642
643pub fn prepare_runtime_artifact(
646 blob: RuntimeBlob,
647 semantics: &Semantics,
648) -> std::result::Result<Vec<u8>, WasmError> {
649 let mut semantics = semantics.clone();
650 replace_strategy_if_broken(&mut semantics.instantiation_strategy);
651
652 let blob = prepare_blob_for_compilation(blob, &semantics)?;
653
654 let engine = Engine::new(&common_config(&semantics)?)
655 .map_err(|e| WasmError::Other(format!("cannot create the engine: {:#}", e)))?;
656
657 engine
658 .precompile_module(&blob.serialize())
659 .map_err(|e| WasmError::Other(format!("cannot precompile module: {:#}", e)))
660}
661
662fn perform_call(
663 data: &[u8],
664 instance_wrapper: &mut InstanceWrapper,
665 entrypoint: EntryPoint,
666 mut allocator: FreeingBumpHeapAllocator,
667 allocation_stats: &mut Option<AllocationStats>,
668) -> Result<Vec<u8>> {
669 let (data_ptr, data_len) = inject_input_data(instance_wrapper, &mut allocator, data)?;
670
671 let host_state = HostState::new(allocator);
672
673 instance_wrapper.store_mut().data_mut().host_state = Some(host_state);
675
676 let ret = entrypoint
677 .call(instance_wrapper.store_mut(), data_ptr, data_len)
678 .map(unpack_ptr_and_len);
679
680 let host_state = instance_wrapper.store_mut().data_mut().host_state.take().expect(
682 "the host state is always set before calling into WASM so it can't be None here; qed",
683 );
684 *allocation_stats = Some(host_state.allocation_stats());
685
686 let (output_ptr, output_len) = ret?;
687 let output = extract_output_data(instance_wrapper, output_ptr, output_len)?;
688
689 Ok(output)
690}
691
692fn inject_input_data(
693 instance: &mut InstanceWrapper,
694 allocator: &mut FreeingBumpHeapAllocator,
695 data: &[u8],
696) -> Result<(Pointer<u8>, WordSize)> {
697 let mut ctx = instance.store_mut();
698 let memory = ctx.data().memory();
699 let data_len = data.len() as WordSize;
700 let data_ptr = allocator.allocate(&mut MemoryWrapper(&memory, &mut ctx), data_len)?;
701 util::write_memory_from(instance.store_mut(), data_ptr, data)?;
702 Ok((data_ptr, data_len))
703}
704
705fn extract_output_data(
706 instance: &InstanceWrapper,
707 output_ptr: u32,
708 output_len: u32,
709) -> Result<Vec<u8>> {
710 let ctx = instance.store();
711
712 let memory_size = ctx.as_context().data().memory().data_size(ctx);
718 if checked_range(output_ptr as usize, output_len as usize, memory_size).is_none() {
719 Err(Error::OutputExceedsBounds)?
720 }
721 let mut output = vec![0; output_len as usize];
722
723 util::read_memory_into(ctx, Pointer::new(output_ptr), &mut output)?;
724 Ok(output)
725}