referrerpolicy=no-referrer-when-downgrade

sc_executor_wasmtime/
runtime.rs

1// This file is part of Substrate.
2
3// Copyright (C) Parity Technologies (UK) Ltd.
4// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
5
6// This program is free software: you can redistribute it and/or modify
7// it under the terms of the GNU General Public License as published by
8// the Free Software Foundation, either version 3 of the License, or
9// (at your option) any later version.
10
11// This program is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// You should have received a copy of the GNU General Public License
17// along with this program. If not, see <https://www.gnu.org/licenses/>.
18
19//! Defines the compiled Wasm runtime that uses Wasmtime internally.
20
21use 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	/// This will only be set when we call into the runtime.
51	pub(crate) host_state: Option<HostState>,
52	/// This will be always set once the store is initialized.
53	pub(crate) memory: Option<Memory>,
54}
55
56impl StoreData {
57	/// Returns a mutable reference to the host state.
58	pub fn host_state_mut(&mut self) -> Option<&mut HostState> {
59		self.host_state.as_mut()
60	}
61
62	/// Returns the host memory.
63	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
86/// A handle for releasing an instance acquired by [`InstanceCounter::acquire_instance`].
87pub(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/// Keeps track on the number of parallel instances.
103///
104/// The runtime cache keeps track on the number of parallel instances. The maximum number in the
105/// cache is less than what we have configured as [`MAX_INSTANCE_COUNT`] for wasmtime. However, the
106/// cache will create on demand instances if required. This instance counter will ensure that we are
107/// blocking when we are trying to create too many instances.
108#[derive(Default)]
109pub(crate) struct InstanceCounter {
110	counter: Mutex<u32>,
111	wait_for_instance: parking_lot::Condvar,
112}
113
114impl InstanceCounter {
115	/// Acquire an instance.
116	///
117	/// Blocks if there is no free instance available.
118	///
119	/// The returned [`ReleaseInstanceHandle`] should be dropped when the instance isn't used
120	/// anymore.
121	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
133/// A `WasmModule` implementation using wasmtime to compile the runtime module to machine code
134/// and execute the compiled code.
135pub 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
156/// A `WasmInstance` implementation that reuses compiled module and spawns instances
157/// to execute the compiled code.
158pub 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
194/// Prepare a directory structure and a config file to enable wasmtime caching.
195///
196/// In case of an error the caching will not be enabled.
197fn 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			// Remember if we have already logged a warning due to an unknown profiling strategy.
228			static UNKNOWN_PROFILING_STRATEGY: AtomicBool = AtomicBool::new(false);
229			// Make sure that the warning will not be relogged regularly.
230			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		// In `wasmtime` 0.35 the default stack size limit was changed from 1MB to 512KB.
242		//
243		// This broke at least one parachain which depended on the original 1MB limit,
244		// so here we restore it to what it was originally.
245		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	// Be clear and specific about the extensions we support. If an update brings new features
253	// they should be introduced here as well.
254	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			// Pooling needs a bunch of hard limits to be set; if we go over
294			// any of these then the instantiation will fail.
295			//
296			// Current minimum values for kusama (as of 2022-04-14):
297			//   size: 32384
298			//   table_elements: 1249
299			//   memory_pages: 2070
300			.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			// This determines how many instances of the module can be
306			// instantiated in parallel from the same `Module`.
307			.total_core_instances(MAX_INSTANCE_COUNT);
308
309		config.allocation_strategy(wasmtime::InstanceAllocationStrategy::Pooling(pooling_config));
310	}
311
312	Ok(config)
313}
314
315/// Knobs for deterministic stack height limiting.
316///
317/// The WebAssembly standard defines a call/value stack but it doesn't say anything about its
318/// size except that it has to be finite. The implementations are free to choose their own notion
319/// of limit: some may count the number of calls or values, others would rely on the host machine
320/// stack and trap on reaching a guard page.
321///
322/// This obviously is a source of non-determinism during execution. This feature can be used
323/// to instrument the code so that it will count the depth of execution in some deterministic
324/// way (the machine stack limit should be so high that the deterministic limit always triggers
325/// first).
326///
327/// The deterministic stack height limiting feature allows to instrument the code so that it will
328/// count the number of items that may be on the stack. This counting will only act as an rough
329/// estimate of the actual stack limit in wasmtime. This is because wasmtime measures it's stack
330/// usage in bytes.
331///
332/// The actual number of bytes consumed by a function is not trivial to compute  without going
333/// through full compilation. Therefore, it's expected that `native_stack_max` is greatly
334/// overestimated and thus never reached in practice. The stack overflow check introduced by the
335/// instrumentation and that relies on the logical item count should be reached first.
336///
337/// See [here][stack_height] for more details of the instrumentation
338///
339/// [stack_height]: https://github.com/paritytech/wasm-instrument/blob/master/src/stack_limiter/mod.rs
340#[derive(Clone)]
341pub struct DeterministicStackLimit {
342	/// A number of logical "values" that can be pushed on the wasm stack. A trap will be triggered
343	/// if exceeded.
344	///
345	/// A logical value is a local, an argument or a value pushed on operand stack.
346	pub logical_max: u32,
347	/// The maximum number of bytes for stack used by wasmtime JITed code.
348	///
349	/// It's not specified how much bytes will be consumed by a stack frame for a given wasm
350	/// function after translation into machine code. It is also not quite trivial.
351	///
352	/// Therefore, this number should be chosen conservatively. It must be so large so that it can
353	/// fit the [`logical_max`](Self::logical_max) logical values on the stack, according to the
354	/// current instrumentation algorithm.
355	///
356	/// This value cannot be 0.
357	pub native_stack_max: u32,
358}
359
360/// The instantiation strategy to use for the WASM executor.
361///
362/// All of the CoW strategies (with `CopyOnWrite` suffix) are only supported when either:
363///   a) we're running on Linux,
364///   b) we're running on an Unix-like system and we're precompiling
365///      our module beforehand and instantiating from a file.
366///
367/// If the CoW variant of a strategy is unsupported the executor will
368/// fall back to the non-CoW equivalent.
369#[non_exhaustive]
370#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
371pub enum InstantiationStrategy {
372	/// Pool the instances to avoid initializing everything from scratch
373	/// on each instantiation. Use copy-on-write memory when possible.
374	///
375	/// This is the fastest instantiation strategy.
376	PoolingCopyOnWrite,
377
378	/// Recreate the instance from scratch on every instantiation.
379	/// Use copy-on-write memory when possible.
380	RecreateInstanceCopyOnWrite,
381
382	/// Pool the instances to avoid initializing everything from scratch
383	/// on each instantiation.
384	Pooling,
385
386	/// Recreate the instance from scratch on every instantiation. Very slow.
387	RecreateInstance,
388}
389
390enum InternalInstantiationStrategy {
391	Builtin,
392}
393
394#[derive(Clone)]
395pub struct Semantics {
396	/// The instantiation strategy to use.
397	pub instantiation_strategy: InstantiationStrategy,
398
399	/// Specifying `Some` will enable deterministic stack height. That is, all executor
400	/// invocations will reach stack overflow at the exactly same point across different wasmtime
401	/// versions and architectures.
402	///
403	/// This is achieved by a combination of running an instrumentation pass on input code and
404	/// configuring wasmtime accordingly.
405	///
406	/// Since this feature depends on instrumentation, it can be set only if runtime is
407	/// instantiated using the runtime blob, e.g. using [`create_runtime`].
408	// I.e. if [`CodeSupplyMode::Verbatim`] is used.
409	pub deterministic_stack_limit: Option<DeterministicStackLimit>,
410
411	/// Controls whether wasmtime should compile floating point in a way that doesn't allow for
412	/// non-determinism.
413	///
414	/// By default, the wasm spec allows some local non-determinism wrt. certain floating point
415	/// operations. Specifically, those operations that are not defined to operate on bits (e.g.
416	/// fneg) can produce NaN values. The exact bit pattern for those is not specified and may
417	/// depend on the particular machine that executes wasmtime generated JITed machine code. That
418	/// is a source of non-deterministic values.
419	///
420	/// The classical runtime environment for Substrate allowed it and punted this on the runtime
421	/// developers. For PVFs, we want to ensure that execution is deterministic though. Therefore,
422	/// for PVF execution this flag is meant to be turned on.
423	pub canonicalize_nans: bool,
424
425	/// Configures wasmtime to use multiple threads for compiling.
426	pub parallel_compilation: bool,
427
428	/// The heap allocation strategy to use.
429	pub heap_alloc_strategy: HeapAllocStrategy,
430
431	/// Enables WASM Multi-Value proposal
432	pub wasm_multi_value: bool,
433
434	/// Enables WASM Bulk Memory Operations proposal
435	pub wasm_bulk_memory: bool,
436
437	/// Enables WASM Reference Types proposal
438	pub wasm_reference_types: bool,
439
440	/// Enables WASM Fixed-Width SIMD proposal
441	pub wasm_simd: bool,
442}
443
444#[derive(Clone)]
445pub struct Config {
446	/// The WebAssembly standard requires all imports of an instantiated module to be resolved,
447	/// otherwise, the instantiation fails. If this option is set to `true`, then this behavior is
448	/// overridden and imports that are requested by the module and not provided by the host
449	/// functions will be resolved using stubs. These stubs will trap upon a call.
450	pub allow_missing_func_imports: bool,
451
452	/// A directory in which wasmtime can store its compiled artifacts cache.
453	pub cache_path: Option<PathBuf>,
454
455	/// Tuning of various semantics of the wasmtime executor.
456	pub semantics: Semantics,
457}
458
459enum CodeSupplyMode<'a> {
460	/// The runtime is instantiated using the given runtime blob.
461	Fresh(RuntimeBlob),
462
463	/// The runtime is instantiated using a precompiled module at the given path.
464	///
465	/// This assumes that the code is already prepared for execution and the same `Config` was
466	/// used.
467	///
468	/// We use a `Path` here instead of simply passing a byte slice to allow `wasmtime` to
469	/// map the runtime's linear memory on supported platforms in a copy-on-write fashion.
470	Precompiled(&'a Path),
471
472	/// The runtime is instantiated using a precompiled module with the given bytes.
473	///
474	/// This assumes that the code is already prepared for execution and the same `Config` was
475	/// used.
476	PrecompiledBytes(&'a [u8]),
477}
478
479/// Create a new `WasmtimeRuntime` given the code. This function performs translation from Wasm to
480/// machine code, which can be computationally heavy.
481///
482/// The `H` generic parameter is used to statically pass a set of host functions which are exposed
483/// to the runtime.
484pub fn create_runtime<H>(
485	blob: RuntimeBlob,
486	config: Config,
487) -> std::result::Result<WasmtimeRuntime, WasmError>
488where
489	H: HostFunctions,
490{
491	// SAFETY: this is safe because it doesn't use `CodeSupplyMode::Precompiled`.
492	unsafe { do_create_runtime::<H>(CodeSupplyMode::Fresh(blob), config) }
493}
494
495/// The same as [`create_runtime`] but takes a path to a precompiled artifact,
496/// which makes this function considerably faster than [`create_runtime`].
497///
498/// # Safety
499///
500/// The caller must ensure that the compiled artifact passed here was:
501///   1) produced by [`prepare_runtime_artifact`],
502///   2) written to the disk as a file,
503///   3) was not modified,
504///   4) will not be modified while any runtime using this artifact is alive, or is being
505///      instantiated.
506///
507/// Failure to adhere to these requirements might lead to crashes and arbitrary code execution.
508///
509/// It is ok though if the compiled artifact was created by code of another version or with
510/// different configuration flags. In such case the caller will receive an `Err` deterministically.
511pub 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
521/// The same as [`create_runtime`] but takes the bytes of a precompiled artifact,
522/// which makes this function considerably faster than [`create_runtime`],
523/// but slower than the more optimized [`create_runtime_from_artifact`].
524/// This is especially slow on non-Linux Unix systems. Useful in very niche cases.
525///
526/// # Safety
527///
528/// The caller must ensure that the compiled artifact passed here was:
529///   1) produced by [`prepare_runtime_artifact`],
530///   2) was not modified,
531///
532/// Failure to adhere to these requirements might lead to crashes and arbitrary code execution.
533///
534/// It is ok though if the compiled artifact was created by code of another version or with
535/// different configuration flags. In such case the caller will receive an `Err` deterministically.
536pub 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
546/// # Safety
547///
548/// This is only unsafe if called with [`CodeSupplyMode::Artifact`]. See
549/// [`create_runtime_from_artifact`] to get more details.
550unsafe 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			// SAFETY: The unsafety of `deserialize_file` is covered by this function. The
590			//         responsibilities to maintain the invariants are passed to the caller.
591			//
592			//         See [`create_runtime_from_artifact`] for more details.
593			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			// SAFETY: The unsafety of `deserialize` is covered by this function. The
600			//         responsibilities to maintain the invariants are passed to the caller.
601			//
602			//         See [`create_runtime_from_artifact_bytes`] for more details.
603			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	// We don't actually need the memory to be imported so we can just convert any memory
634	// import into an export with impunity. This simplifies our code since `wasmtime` will
635	// now automatically take care of creating the memory for us, and it is also necessary
636	// to enable `wasmtime`'s instance pooling. (Imported memories are ineligible for pooling.)
637	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
643/// Takes a [`RuntimeBlob`] and precompiles it returning the serialized result of compilation. It
644/// can then be used for calling [`create_runtime`] avoiding long compilation times.
645pub 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	// Set the host state before calling into wasm.
674	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	// Reset the host state
681	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	// Do a length check before allocating. The returned output should not be bigger than the
713	// available WASM memory. Otherwise, a malicious parachain can trigger a large allocation,
714	// potentially causing memory exhaustion.
715	//
716	// Get the size of the WASM memory in bytes.
717	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}