Bump wasmtime to 5.0.0 (and a few other deps) (#13160)

* Bump `wasmtime` to 4.0.0 (and a few other deps)

* Use `Error::msg` instead of `anyhow!`

* Bump `wasmtime` to 5.0.0

* Update `Cargo.lock`

* Add `wasmtime` feature to `sp-wasm-interface` dependency

substrate/client/executor/wasmtime/src/imports.rs

@@ -20,7 +20,7 @@ use crate::{host::HostContext, runtime::StoreData};
 use sc_executor_common::error::WasmError;
 use sp_wasm_interface::{FunctionContext, HostFunctions};
 use std::collections::HashMap;
-use wasmtime::{ExternType, FuncType, ImportType, Linker, Module, Trap};
+use wasmtime::{ExternType, FuncType, ImportType, Linker, Module};
 
 /// Goes over all imports of a module and prepares the given linker for instantiation of the module.
 /// Returns an error if there are imports that cannot be satisfied.
@@ -67,7 +67,7 @@ where
 				log::debug!("Missing import: '{}' {:?}", name, func_ty);
 				linker
 					.func_new("env", &name, func_ty.clone(), move |_, _, _| {
-						Err(Trap::new(error.clone()))
+					    Err(anyhow::Error::msg(error.clone()))
 					})
 					.expect("adding a missing import stub can only fail when the item already exists, and it is missing here; qed");
 			}

substrate/client/executor/wasmtime/src/instance_wrapper.rs

@@ -76,27 +76,17 @@ impl EntryPoint {
 				.as_mut()
 				.expect("host state cannot be empty while a function is being called; qed");
 
-			// The logic to print out a backtrace is somewhat complicated,
-			// so let's get wasmtime to print it out for us.
-			let mut backtrace_string = trap.to_string();
-			let suffix = "\nwasm backtrace:";
-			if let Some(index) = backtrace_string.find(suffix) {
-				// Get rid of the error message and just grab the backtrace,
-				// since we're storing the error message ourselves separately.
-				backtrace_string.replace_range(0..index + suffix.len(), "");
-			}
+			let backtrace = trap.downcast_ref::<wasmtime::WasmBacktrace>().map(|backtrace| {
+				// The logic to print out a backtrace is somewhat complicated,
+				// so let's get wasmtime to print it out for us.
+				Backtrace { backtrace_string: backtrace.to_string() }
+			});
 
-			let backtrace = Backtrace { backtrace_string };
-			if let Some(error) = host_state.take_panic_message() {
-				Error::AbortedDueToPanic(MessageWithBacktrace {
-					message: error,
-					backtrace: Some(backtrace),
-				})
+			if let Some(message) = host_state.take_panic_message() {
+				Error::AbortedDueToPanic(MessageWithBacktrace { message, backtrace })
 			} else {
-				Error::AbortedDueToTrap(MessageWithBacktrace {
-					message: trap.display_reason().to_string(),
-					backtrace: Some(backtrace),
-				})
+				let message = trap.root_cause().to_string();
+				Error::AbortedDueToTrap(MessageWithBacktrace { message, backtrace })
 			}
 		})
 	}
@@ -106,7 +96,7 @@ impl EntryPoint {
 		ctx: impl AsContext,
 	) -> std::result::Result<Self, &'static str> {
 		let entrypoint = func
-			.typed::<(u32, u32), u64, _>(ctx)
+			.typed::<(u32, u32), u64>(ctx)
 			.map_err(|_| "Invalid signature for direct entry point")?;
 		Ok(Self { call_type: EntryPointType::Direct { entrypoint } })
 	}
@@ -117,7 +107,7 @@ impl EntryPoint {
 		ctx: impl AsContext,
 	) -> std::result::Result<Self, &'static str> {
 		let dispatcher = dispatcher
-			.typed::<(u32, u32, u32), u64, _>(ctx)
+			.typed::<(u32, u32, u32), u64>(ctx)
 			.map_err(|_| "Invalid signature for wrapped entry point")?;
 		Ok(Self { call_type: EntryPointType::Wrapped { func, dispatcher } })
 	}

substrate/client/executor/wasmtime/src/runtime.rs

@@ -366,29 +366,27 @@ fn common_config(semantics: &Semantics) -> std::result::Result<wasmtime::Config,
 			MAX_WASM_PAGES
 		};
 
-		config.allocation_strategy(wasmtime::InstanceAllocationStrategy::Pooling {
-			strategy: wasmtime::PoolingAllocationStrategy::ReuseAffinity,
-
+		let mut pooling_config = wasmtime::PoolingAllocationConfig::default();
+		pooling_config
+			.strategy(wasmtime::PoolingAllocationStrategy::ReuseAffinity)
 			// Pooling needs a bunch of hard limits to be set; if we go over
 			// any of these then the instantiation will fail.
-			instance_limits: wasmtime::InstanceLimits {
-				// Current minimum values for kusama (as of 2022-04-14):
-				//   size: 32384
-				//   table_elements: 1249
-				//   memory_pages: 2070
-				size: 128 * 1024,
-				table_elements: 8192,
-				memory_pages,
+			//
+			// Current minimum values for kusama (as of 2022-04-14):
+			//   size: 32384
+			//   table_elements: 1249
+			//   memory_pages: 2070
+			.instance_size(128 * 1024)
+			.instance_table_elements(8192)
+			.instance_memory_pages(memory_pages)
+			// We can only have a single of those.
+			.instance_tables(1)
+			.instance_memories(1)
+			// This determines how many instances of the module can be
+			// instantiated in parallel from the same `Module`.
+			.instance_count(32);
 
-				// We can only have a single of those.
-				tables: 1,
-				memories: 1,
-
-				// This determines how many instances of the module can be
-				// instantiated in parallel from the same `Module`.
-				count: 32,
-			},
-		});
+		config.allocation_strategy(wasmtime::InstanceAllocationStrategy::Pooling(pooling_config));
 	}
 
 	Ok(config)

substrate/client/executor/wasmtime/src/tests.rs

@@ -226,8 +226,8 @@ fn deep_call_stack_wat(depth: usize) -> String {
 
 // We need two limits here since depending on whether the code is compiled in debug
 // or in release mode the maximum call depth is slightly different.
-const CALL_DEPTH_LOWER_LIMIT: usize = 65478;
-const CALL_DEPTH_UPPER_LIMIT: usize = 65514;
+const CALL_DEPTH_LOWER_LIMIT: usize = 65455;
+const CALL_DEPTH_UPPER_LIMIT: usize = 65503;
 
 test_wasm_execution!(test_consume_under_1mb_of_stack_does_not_trap);
 fn test_consume_under_1mb_of_stack_does_not_trap(instantiation_strategy: InstantiationStrategy) {
@@ -555,3 +555,34 @@ fn test_instances_without_reuse_are_not_leaked() {
 		instance.call_export("test_empty_return", &[0]).unwrap();
 	}
 }
+
+#[test]
+fn test_rustix_version_matches_with_wasmtime() {
+	let metadata = cargo_metadata::MetadataCommand::new()
+		.manifest_path("../../../Cargo.toml")
+		.exec()
+		.unwrap();
+
+	let wasmtime_rustix = metadata
+		.packages
+		.iter()
+		.find(|pkg| pkg.name == "wasmtime-runtime")
+		.unwrap()
+		.dependencies
+		.iter()
+		.find(|dep| dep.name == "rustix")
+		.unwrap();
+	let our_rustix = metadata
+		.packages
+		.iter()
+		.find(|pkg| pkg.name == "sc-executor-wasmtime")
+		.unwrap()
+		.dependencies
+		.iter()
+		.find(|dep| dep.name == "rustix")
+		.unwrap();
+
+	if wasmtime_rustix.req != our_rustix.req {
+		panic!("our version of rustix ({0}) doesn't match wasmtime's ({1}); bump the version in `sc-executor-wasmtime`'s `Cargo.toml' to '{1}' and try again", our_rustix.req, wasmtime_rustix.req);
+	}
+}