pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-28 20:17:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update wasmtime to 0.29.0 (#9552)

Browse Source 
* Start

* Move to ctx

* Make it compile for now

* More work

* Get rid off state-holder

* Use less Refcells

* 🤦

* Don't use RefCell

* Use names for parameters

* Fixes after merge

* Fixes after merge

* Review feedback

* FMT
This commit is contained in:
Bastian Köcher
2021-09-29 14:30:46 +02:00
committed by GitHub
parent e64693933f
commit 2deed49706
19 changed files with 451 additions and 430 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/Cargo.lock
Generated
+94 -113
View File
@@ -14,20 +14,11 @@ dependencies = [
[[package]]
name = "addr2line"
version = "0.14.1"
version = "0.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a55f82cfe485775d02112886f4169bde0c5894d75e79ead7eafe7e40a25e45f7"
checksum = "3e61f2b7f93d2c7d2b08263acaa4a363b3e276806c68af6134c44f523bf1aacd"
dependencies = [
"gimli 0.23.0",
]
[[package]]
name = "addr2line"
version = "0.15.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "03345e98af8f3d786b6d9f656ccfa6ac316d954e92bc4841f0bba20789d5fb5a"
dependencies = [
"gimli 0.24.0",
"gimli 0.25.0",
]
[[package]]
@@ -415,15 +406,16 @@ checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
[[package]]
name = "backtrace"
version = "0.3.56"
version = "0.3.61"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9d117600f438b1707d4e4ae15d3595657288f8235a0eb593e80ecc98ab34e1bc"
checksum = "e7a905d892734eea339e896738c14b9afce22b5318f64b951e70bf3844419b01"
dependencies = [
"addr2line 0.14.1",
"addr2line",
"cc",
"cfg-if 1.0.0",
"libc",
"miniz_oxide",
"object 0.23.0",
"object 0.26.0",
"rustc-demangle",
]
@@ -1067,11 +1059,11 @@ dependencies = [
[[package]]
name = "cranelift-bforest"
version = "0.74.0"
version = "0.76.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c8ca3560686e7c9c7ed7e0fe77469f2410ba5d7781b1acaa9adc8d8deea28e3e"
checksum = "7e6bea67967505247f54fa2c85cf4f6e0e31c4e5692c9b70e4ae58e339067333"
dependencies = [
"cranelift-entity 0.74.0",
"cranelift-entity 0.76.0",
]
[[package]]
@@ -1095,15 +1087,15 @@ dependencies = [
[[package]]
name = "cranelift-codegen"
version = "0.74.0"
version = "0.76.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf9bf1ffffb6ce3d2e5ebc83549bd2436426c99b31cc550d521364cbe35d276"
checksum = "48194035d2752bdd5bdae429e3ab88676e95f52a2b1355a5d4e809f9e39b1d74"
dependencies = [
"cranelift-bforest 0.74.0",
"cranelift-codegen-meta 0.74.0",
"cranelift-codegen-shared 0.74.0",
"cranelift-entity 0.74.0",
"gimli 0.24.0",
"cranelift-bforest 0.76.0",
"cranelift-codegen-meta 0.76.0",
"cranelift-codegen-shared 0.76.0",
"cranelift-entity 0.76.0",
"gimli 0.25.0",
"log 0.4.14",
"regalloc",
"serde",
@@ -1123,12 +1115,12 @@ dependencies = [
[[package]]
name = "cranelift-codegen-meta"
version = "0.74.0"
version = "0.76.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4cc21936a5a6d07e23849ffe83e5c1f6f50305c074f4b2970ca50c13bf55b821"
checksum = "976efb22fcab4f2cd6bd4e9913764616a54d895c1a23530128d04e03633c555f"
dependencies = [
"cranelift-codegen-shared 0.74.0",
"cranelift-entity 0.74.0",
"cranelift-codegen-shared 0.76.0",
"cranelift-entity 0.76.0",
]
[[package]]
@@ -1139,9 +1131,9 @@ checksum = "6759012d6d19c4caec95793f052613e9d4113e925e7f14154defbac0f1d4c938"
[[package]]
name = "cranelift-codegen-shared"
version = "0.74.0"
version = "0.76.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca5b6ffaa87560bebe69a5446449da18090b126037920b0c1c6d5945f72faf6b"
checksum = "9dabb5fe66e04d4652e434195b45ae65b5c8172d520247b8f66d8df42b2b45dc"
dependencies = [
"serde",
]
@@ -1157,9 +1149,9 @@ dependencies = [
[[package]]
name = "cranelift-entity"
version = "0.74.0"
version = "0.76.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7d6b4a8bef04f82e4296782646f733c641d09497df2fabf791323fefaa44c64c"
checksum = "3329733e4d4b8e91c809efcaa4faee80bf66f20164e3dd16d707346bd3494799"
dependencies = [
"serde",
]
@@ -1178,11 +1170,11 @@ dependencies = [
[[package]]
name = "cranelift-frontend"
version = "0.74.0"
version = "0.76.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c31b783b351f966fce33e3c03498cb116d16d97a8f9978164a60920bd0d3a99c"
checksum = "279afcc0d3e651b773f94837c3d581177b348c8d69e928104b2e9fccb226f921"
dependencies = [
"cranelift-codegen 0.74.0",
"cranelift-codegen 0.76.0",
"log 0.4.14",
"smallvec 1.7.0",
"target-lexicon 0.12.0",
@@ -1190,29 +1182,30 @@ dependencies = [
[[package]]
name = "cranelift-native"
version = "0.74.0"
version = "0.76.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a77c88d3dd48021ff1e37e978a00098524abd3513444ae252c08d37b310b3d2a"
checksum = "4c04d1fe6a5abb5bb0edc78baa8ef238370fb8e389cc88b6d153f7c3e9680425"
dependencies = [
"cranelift-codegen 0.74.0",
"cranelift-codegen 0.76.0",
"libc",
"target-lexicon 0.12.0",
]
[[package]]
name = "cranelift-wasm"
version = "0.74.0"
version = "0.76.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "edb6d408e2da77cdbbd65466298d44c86ae71c1785d2ab0d8657753cdb4d9d89"
checksum = "e0d260ad44f6fd2c91f7f5097191a2a9e3edcbb36df1fb787b600dad5ea148ec"
dependencies = [
"cranelift-codegen 0.74.0",
"cranelift-entity 0.74.0",
"cranelift-frontend 0.74.0",
"cranelift-codegen 0.76.0",
"cranelift-entity 0.76.0",
"cranelift-frontend 0.76.0",
"itertools 0.10.0",
"log 0.4.14",
"serde",
"smallvec 1.7.0",
"thiserror",
"wasmparser 0.78.2",
"wasmparser 0.79.0",
]
[[package]]
@@ -2469,15 +2462,9 @@ dependencies = [
[[package]]
name = "gimli"
version = "0.23.0"
version = "0.25.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6503fe142514ca4799d4c26297c4248239fe8838d827db6bd6065c6ed29a6ce"
[[package]]
name = "gimli"
version = "0.24.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e4075386626662786ddb0ec9081e7c7eeb1ba31951f447ca780ef9f5d568189"
checksum = "f0a01e0497841a3b2db4f8afa483cce65f7e96a3498bd6c541734792aeac8fe7"
dependencies = [
"fallible-iterator",
"indexmap",
@@ -4111,9 +4098,9 @@ checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
[[package]]
name = "memchr"
version = "2.3.4"
version = "2.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"
checksum = "b16bd47d9e329435e309c58469fe0791c2d0d1ba96ec0954152a5ae2b04387dc"
[[package]]
name = "memmap"
@@ -4886,9 +4873,9 @@ checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
[[package]]
name = "nom"
version = "6.2.1"
version = "6.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c5c51b9083a3c620fa67a2a635d1ce7d95b897e957d6b28ff9a5da960a103a6"
checksum = "e7413f999671bd4745a7b624bd370a569fb6bc574b23c83a3c5ed2e453f3d5e2"
dependencies = [
"bitvec 0.19.5",
"funty",
@@ -5000,18 +4987,13 @@ dependencies = [
[[package]]
name = "object"
version = "0.23.0"
version = "0.26.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a9a7ab5d64814df0fe4a4b5ead45ed6c5f181ee3ff04ba344313a6c80446c5d4"
[[package]]
name = "object"
version = "0.24.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1a5b3dd1c072ee7963717671d1ca129f1048fda25edea6b752bfc71ac8854170"
checksum = "c55827317fb4c08822499848a14237d2874d6f139828893017237e7ab93eb386"
dependencies = [
"crc32fast",
"indexmap",
"memchr",
]
[[package]]
@@ -8020,7 +8002,6 @@ dependencies = [
"sc-allocator",
"sc-executor-common",
"sc-runtime-test",
"scoped-tls",
"sp-core",
"sp-io",
"sp-runtime-interface",
@@ -11467,15 +11448,15 @@ checksum = "87cc2fe6350834b4e528ba0901e7aa405d78b89dc1fa3145359eb4de0e323fcf"
[[package]]
name = "wasmparser"
version = "0.78.2"
version = "0.79.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "52144d4c78e5cf8b055ceab8e5fa22814ce4315d6002ad32cfd914f37c12fd65"
checksum = "5b5894be15a559c85779254700e1d35f02f843b5a69152e5c82c626d9fd66c0e"
[[package]]
name = "wasmtime"
version = "0.27.0"
version = "0.29.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b310b9d20fcf59385761d1ade7a3ef06aecc380e3d3172035b919eaf7465d9f7"
checksum = "8bbb8a082a8ef50f7eeb8b82dda9709ef1e68963ea3c94e45581644dd4041835"
dependencies = [
"anyhow",
"backtrace",
@@ -11493,7 +11474,7 @@ dependencies = [
"serde",
"smallvec 1.7.0",
"target-lexicon 0.12.0",
"wasmparser 0.78.2",
"wasmparser 0.79.0",
"wasmtime-cache",
"wasmtime-environ",
"wasmtime-jit",
@@ -11504,9 +11485,9 @@ dependencies = [
[[package]]
name = "wasmtime-cache"
version = "0.27.0"
version = "0.29.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d14d500d5c3dc5f5c097158feee123d64b3097f0d836a2a27dff9c761c73c843"
checksum = "d73391579ca7f24573138ef768b73b2aed5f9d542385c64979b65d60d0912399"
dependencies = [
"anyhow",
"base64 0.13.0",
@@ -11525,78 +11506,78 @@ dependencies = [
[[package]]
name = "wasmtime-cranelift"
version = "0.27.0"
version = "0.29.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c525b39f062eada7db3c1298287b96dcb6e472b9f6b22501300b28d9fa7582f6"
checksum = "81c6f5ae9205382345c7cd7454932a906186836999a2161c385e38a15f52e1fe"
dependencies = [
"cranelift-codegen 0.74.0",
"cranelift-entity 0.74.0",
"cranelift-frontend 0.74.0",
"cranelift-codegen 0.76.0",
"cranelift-entity 0.76.0",
"cranelift-frontend 0.76.0",
"cranelift-wasm",
"target-lexicon 0.12.0",
"wasmparser 0.78.2",
"wasmparser 0.79.0",
"wasmtime-environ",
]
[[package]]
name = "wasmtime-debug"
version = "0.27.0"
version = "0.29.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c5d2a763e7a6fc734218e0e463196762a4f409c483063d81e0e85f96343b2e0a"
checksum = "c69e08f55e12f15f50b1b533bc3626723e7224254a065de6576934c86258c9e8"
dependencies = [
"anyhow",
"gimli 0.24.0",
"gimli 0.25.0",
"more-asserts",
"object 0.24.0",
"object 0.26.0",
"target-lexicon 0.12.0",
"thiserror",
"wasmparser 0.78.2",
"wasmparser 0.79.0",
"wasmtime-environ",
]
[[package]]
name = "wasmtime-environ"
version = "0.27.0"
version = "0.29.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f64d0c2d881c31b0d65c1f2695e022d71eb60b9fbdd336aacca28208b58eac90"
checksum = "005d93174040af37fb8625f891cd9827afdad314261f7ec4ee61ec497d6e9d3c"
dependencies = [
"cfg-if 1.0.0",
"cranelift-codegen 0.74.0",
"cranelift-entity 0.74.0",
"cranelift-codegen 0.76.0",
"cranelift-entity 0.76.0",
"cranelift-wasm",
"gimli 0.24.0",
"gimli 0.25.0",
"indexmap",
"log 0.4.14",
"more-asserts",
"serde",
"thiserror",
"wasmparser 0.78.2",
"wasmparser 0.79.0",
]
[[package]]
name = "wasmtime-jit"
version = "0.27.0"
version = "0.29.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4d4539ea734422b7c868107e2187d7746d8affbcaa71916d72639f53757ad707"
checksum = "d0bf1dfb213a35d8f21aefae40e597fe72778a907011ffdff7affb029a02af9a"
dependencies = [
"addr2line 0.15.1",
"addr2line",
"anyhow",
"cfg-if 1.0.0",
"cranelift-codegen 0.74.0",
"cranelift-entity 0.74.0",
"cranelift-frontend 0.74.0",
"cranelift-codegen 0.76.0",
"cranelift-entity 0.76.0",
"cranelift-frontend 0.76.0",
"cranelift-native",
"cranelift-wasm",
"gimli 0.24.0",
"gimli 0.25.0",
"log 0.4.14",
"more-asserts",
"object 0.24.0",
"object 0.26.0",
"rayon",
"region",
"serde",
"target-lexicon 0.12.0",
"thiserror",
"wasmparser 0.78.2",
"wasmparser 0.79.0",
"wasmtime-cranelift",
"wasmtime-debug",
"wasmtime-environ",
@@ -11608,13 +11589,13 @@ dependencies = [
[[package]]
name = "wasmtime-obj"
version = "0.27.0"
version = "0.29.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e1a8ff85246d091828e2225af521a6208ed28c997bb5c39eb697366dc2e2f2b"
checksum = "d231491878e710c68015228c9f9fc5955fe5c96dbf1485c15f7bed55b622c83c"
dependencies = [
"anyhow",
"more-asserts",
"object 0.24.0",
"object 0.26.0",
"target-lexicon 0.12.0",
"wasmtime-debug",
"wasmtime-environ",
@@ -11622,9 +11603,9 @@ dependencies = [
[[package]]
name = "wasmtime-profiling"
version = "0.27.0"
version = "0.29.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e24364d522dcd67c897c8fffc42e5bdfc57207bbb6d7eeade0da9d4a7d70105b"
checksum = "21486cfb5255c2069666c1f116f9e949d4e35c9a494f11112fa407879e42198d"
dependencies = [
"anyhow",
"cfg-if 1.0.0",
@@ -11638,9 +11619,9 @@ dependencies = [
[[package]]
name = "wasmtime-runtime"
version = "0.27.0"
version = "0.29.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c51e57976e8a19a18a18e002c6eb12e5769554204238e47ff155fda1809ef0f7"
checksum = "d7ddfdf32e0a20d81f48be9dacd31612bc61de5a174d1356fef806d300f507de"
dependencies = [
"anyhow",
"backtrace",
@@ -11889,18 +11870,18 @@ dependencies = [
[[package]]
name = "zstd"
version = "0.6.1+zstd.1.4.9"
version = "0.9.0+zstd.1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5de55e77f798f205d8561b8fe2ef57abfb6e0ff2abe7fd3c089e119cdb5631a3"
checksum = "07749a5dc2cb6b36661290245e350f15ec3bbb304e493db54a1d354480522ccd"
dependencies = [
"zstd-safe",
]
[[package]]
name = "zstd-safe"
version = "3.0.1+zstd.1.4.9"
version = "4.1.1+zstd.1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1387cabcd938127b30ce78c4bf00b30387dddf704e3f0881dbc4ff62b5566f8c"
checksum = "c91c90f2c593b003603e5e0493c837088df4469da25aafff8bce42ba48caf079"
dependencies = [
"libc",
"zstd-sys",
@@ -11908,9 +11889,9 @@ dependencies = [
[[package]]
name = "zstd-sys"
version = "1.4.20+zstd.1.4.9"
version = "1.6.1+zstd.1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ebd5b733d7cf2d9447e2c3e76a5589b4f5e5ae065c22a2bc0b023cbc331b6c8e"
checksum = "615120c7a2431d16cf1cf979e7fc31ba7a5b5e5707b29c8a99e5dbf8a8392a33"
dependencies = [
"cc",
"libc",
substrate/client/executor/common/src/runtime_blob/globals_snapshot.rs
+8 -5
View File
@@ -34,14 +34,14 @@ pub trait InstanceGlobals {
/// Get a handle to a global by it's export name.
///
/// The requested export is must exist in the exported list, and it should be a mutable global.
fn get_global(&self, export_name: &str) -> Self::Global;
fn get_global(&mut self, export_name: &str) -> Self::Global;
/// Get the current value of the global.
fn get_global_value(&self, global: &Self::Global) -> sp_wasm_interface::Value;
fn get_global_value(&mut self, global: &Self::Global) -> sp_wasm_interface::Value;
/// Update the current value of the global.
///
/// The global behind the handle is guaranteed to be mutable and the value to be the same type
/// as the global.
fn set_global_value(&self, global: &Self::Global, value: sp_wasm_interface::Value);
fn set_global_value(&mut self, global: &Self::Global, value: sp_wasm_interface::Value);
}
/// A set of exposed mutable globals.
@@ -79,7 +79,10 @@ impl<Global> GlobalsSnapshot<Global> {
///
/// This function panics if the instance doesn't correspond to the module from which the
/// [`ExposedMutableGlobalsSet`] was collected.
pub fn take<Instance>(mutable_globals: &ExposedMutableGlobalsSet, instance: &Instance) -> Self
pub fn take<Instance>(
mutable_globals: &ExposedMutableGlobalsSet,
instance: &mut Instance,
) -> Self
where
Instance: InstanceGlobals<Global = Global>,
{
@@ -98,7 +101,7 @@ impl<Global> GlobalsSnapshot<Global> {
/// Apply the snapshot to the given instance.
///
/// This instance must be the same that was used for creation of this snapshot.
pub fn apply<Instance>(&self, instance: &Instance)
pub fn apply<Instance>(&self, instance: &mut Instance)
where
Instance: InstanceGlobals<Global = Global>,
{
substrate/client/executor/common/src/util.rs
+1 -1
View File
@@ -233,7 +233,7 @@ pub mod wasmer {
let range = checked_range(dest_addr.into(), source.len(), destination.len())
.ok_or_else(|| Error::Other("memory write is out of bounds".into()))?;
&mut destination[range].copy_from_slice(source);
destination[range].copy_from_slice(source);
Ok(())
}
}
substrate/client/executor/common/src/wasm_runtime.rs
+3 -3
View File
@@ -78,21 +78,21 @@ pub trait WasmInstance: Send {
/// Before execution, instance is reset.
///
/// Returns the encoded result on success.
fn call(&self, method: InvokeMethod, data: &[u8]) -> Result<Vec<u8>, Error>;
fn call(&mut self, method: InvokeMethod, data: &[u8]) -> Result<Vec<u8>, Error>;
/// Call an exported method on this WASM instance.
///
/// Before execution, instance is reset.
///
/// Returns the encoded result on success.
fn call_export(&self, method: &str, data: &[u8]) -> Result<Vec<u8>, Error> {
fn call_export(&mut self, method: &str, data: &[u8]) -> Result<Vec<u8>, Error> {
self.call(method.into(), data)
}
/// Get the value from a global with the given `name`.
///
/// This method is only suitable for getting immutable globals.
fn get_global_const(&self, name: &str) -> Result<Option<Value>, Error>;
fn get_global_const(&mut self, name: &str) -> Result<Option<Value>, Error>;
/// **Testing Only**. This function returns the base address of the linear memory.
///
substrate/client/executor/src/integration_tests/linux.rs
+1 -1
View File
@@ -40,7 +40,7 @@ fn memory_consumption_compiled() {
let runtime = mk_test_runtime(WasmExecutionMethod::Compiled, 1024);
let instance = runtime.new_instance().unwrap();
let mut instance = runtime.new_instance().unwrap();
let heap_base = instance
.get_global_const("__heap_base")
.expect("`__heap_base` is valid")
substrate/client/executor/src/integration_tests/mod.rs
+4 -4
View File
@@ -467,7 +467,7 @@ test_wasm_execution!(returns_mutable_static);
fn returns_mutable_static(wasm_method: WasmExecutionMethod) {
let runtime = mk_test_runtime(wasm_method, 1024);
let instance = runtime.new_instance().unwrap();
let mut instance = runtime.new_instance().unwrap();
let res = instance.call_export("returns_mutable_static", &[0]).unwrap();
assert_eq!(33, u64::decode(&mut &res[..]).unwrap());
@@ -482,7 +482,7 @@ test_wasm_execution!(returns_mutable_static_bss);
fn returns_mutable_static_bss(wasm_method: WasmExecutionMethod) {
let runtime = mk_test_runtime(wasm_method, 1024);
let instance = runtime.new_instance().unwrap();
let mut instance = runtime.new_instance().unwrap();
let res = instance.call_export("returns_mutable_static_bss", &[0]).unwrap();
assert_eq!(1, u64::decode(&mut &res[..]).unwrap());
@@ -508,7 +508,7 @@ fn restoration_of_globals(wasm_method: WasmExecutionMethod) {
const REQUIRED_MEMORY_PAGES: u64 = 32;
let runtime = mk_test_runtime(wasm_method, REQUIRED_MEMORY_PAGES);
let instance = runtime.new_instance().unwrap();
let mut instance = runtime.new_instance().unwrap();
// On the first invocation we allocate approx. 768KB (75%) of stack and then trap.
let res = instance.call_export("allocates_huge_stack_array", &true.encode());
@@ -522,7 +522,7 @@ fn restoration_of_globals(wasm_method: WasmExecutionMethod) {
test_wasm_execution!(interpreted_only heap_is_reset_between_calls);
fn heap_is_reset_between_calls(wasm_method: WasmExecutionMethod) {
let runtime = mk_test_runtime(wasm_method, 1024);
let instance = runtime.new_instance().unwrap();
let mut instance = runtime.new_instance().unwrap();
let heap_base = instance
.get_global_const("__heap_base")
substrate/client/executor/src/native_executor.rs
+5 -5
View File
@@ -163,7 +163,7 @@ impl WasmExecutor {
where
F: FnOnce(
AssertUnwindSafe<&Arc<dyn WasmModule>>,
AssertUnwindSafe<&dyn WasmInstance>,
AssertUnwindSafe<&mut dyn WasmInstance>,
Option<&RuntimeVersion>,
AssertUnwindSafe<&mut dyn Externalities>,
) -> Result<Result<R>>,
@@ -217,7 +217,7 @@ impl WasmExecutor {
.new_instance()
.map_err(|e| format!("Failed to create instance: {:?}", e))?;
let instance = AssertUnwindSafe(instance);
let mut instance = AssertUnwindSafe(instance);
let mut ext = AssertUnwindSafe(ext);
let module = AssertUnwindSafe(module);
@@ -283,7 +283,7 @@ impl CodeExecutor for WasmExecutor {
runtime_code,
ext,
false,
|module, instance, _onchain_version, mut ext| {
|module, mut instance, _onchain_version, mut ext| {
with_externalities_safe(&mut **ext, move || {
preregister_builtin_ext(module.clone());
instance.call_export(method, data).map(NativeOrEncoded::Encoded)
@@ -438,7 +438,7 @@ impl RuntimeSpawn for RuntimeInstanceSpawn {
// pool of instances should be used.
//
// https://github.com/paritytech/substrate/issues/7354
let instance =
let mut instance =
module.new_instance().expect("Failed to create new instance from module");
instance
@@ -525,7 +525,7 @@ impl<D: NativeExecutionDispatch + 'static> CodeExecutor for NativeElseWasmExecut
runtime_code,
ext,
false,
|module, instance, onchain_version, mut ext| {
|module, mut instance, onchain_version, mut ext| {
let onchain_version =
onchain_version.ok_or_else(|| Error::ApiError("Unknown version".into()))?;
substrate/client/executor/src/wasm_runtime.rs
+6 -6
View File
@@ -76,7 +76,7 @@ impl VersionedRuntime {
where
F: FnOnce(
&Arc<dyn WasmModule>,
&dyn WasmInstance,
&mut dyn WasmInstance,
Option<&RuntimeVersion>,
&mut dyn Externalities,
) -> Result<R, Error>,
@@ -90,12 +90,12 @@ impl VersionedRuntime {
match instance {
Some((index, mut locked)) => {
let (instance, new_inst) = locked
let (mut instance, new_inst) = locked
.take()
.map(|r| Ok((r, false)))
.unwrap_or_else(|| self.module.new_instance().map(|i| (i, true)))?;
let result = f(&self.module, &*instance, self.version.as_ref(), ext);
let result = f(&self.module, &mut *instance, self.version.as_ref(), ext);
if let Err(e) = &result {
if new_inst {
log::warn!(
@@ -129,9 +129,9 @@ impl VersionedRuntime {
log::warn!(target: "wasm-runtime", "Ran out of free WASM instances");
// Allocate a new instance
let instance = self.module.new_instance()?;
let mut instance = self.module.new_instance()?;
f(&self.module, &*instance, self.version.as_ref(), ext)
f(&self.module, &mut *instance, self.version.as_ref(), ext)
},
}
}
@@ -213,7 +213,7 @@ impl RuntimeCache {
where
F: FnOnce(
&Arc<dyn WasmModule>,
&dyn WasmInstance,
&mut dyn WasmInstance,
Option<&RuntimeVersion>,
&mut dyn Externalities,
) -> Result<R, Error>,
substrate/client/executor/wasmi/src/lib.rs
+2 -2
View File
@@ -736,7 +736,7 @@ pub struct WasmiInstance {
unsafe impl Send for WasmiInstance {}
impl WasmInstance for WasmiInstance {
fn call(&self, method: InvokeMethod, data: &[u8]) -> Result<Vec<u8>, Error> {
fn call(&mut self, method: InvokeMethod, data: &[u8]) -> Result<Vec<u8>, Error> {
// We reuse a single wasm instance for multiple calls and a previous call (if any)
// altered the state. Therefore, we need to restore the instance to original state.
@@ -767,7 +767,7 @@ impl WasmInstance for WasmiInstance {
)
}
fn get_global_const(&self, name: &str) -> Result<Option<sp_wasm_interface::Value>, Error> {
fn get_global_const(&mut self, name: &str) -> Result<Option<sp_wasm_interface::Value>, Error> {
match self.instance.export_by_name(name) {
Some(global) => Ok(Some(
global
substrate/client/executor/wasmtime/Cargo.toml
+1 -5
View File
@@ -16,7 +16,6 @@ targets = ["x86_64-unknown-linux-gnu"]
libc = "0.2.90"
cfg-if = "1.0"
log = "0.4.8"
scoped-tls = "1.0"
parity-wasm = "0.42.0"
codec = { package = "parity-scale-codec", version = "2.0.0" }
sc-executor-common = { version = "0.10.0-dev", path = "../common" }
@@ -24,10 +23,7 @@ sp-wasm-interface = { version = "4.0.0-dev", path = "../../../primitives/wasm-in
sp-runtime-interface = { version = "4.0.0-dev", path = "../../../primitives/runtime-interface" }
sp-core = { version = "4.0.0-dev", path = "../../../primitives/core" }
sc-allocator = { version = "4.0.0-dev", path = "../../allocator" }
wasmtime = { version = "0.27.0", default-features = false, features = [
"cache",
"parallel-compilation",
] }
wasmtime = { version = "0.29.0", default-features = false, features = ["cache", "parallel-compilation"] }
[dev-dependencies]
sc-runtime-test = { version = "2.0.0", path = "../runtime-test" }
substrate/client/executor/wasmtime/src/host.rs
+56 -27
View File
@@ -19,7 +19,7 @@
//! This module defines `HostState` and `HostContext` structs which provide logic and state
//! required for execution of host.
use crate::instance_wrapper::InstanceWrapper;
use crate::{instance_wrapper::InstanceWrapper, runtime::StoreData};
use codec::{Decode, Encode};
use log::trace;
use sc_allocator::FreeingBumpHeapAllocator;
@@ -31,7 +31,7 @@ use sc_executor_common::{
use sp_core::sandbox as sandbox_primitives;
use sp_wasm_interface::{FunctionContext, MemoryId, Pointer, Sandbox, WordSize};
use std::{cell::RefCell, rc::Rc};
use wasmtime::{Func, Val};
use wasmtime::{Caller, Func, Val};
/// The state required to construct a HostContext context. The context only lasts for one host
/// call, whereas the state is maintained for the duration of a Wasm runtime call, which may make
@@ -64,45 +64,67 @@ impl HostState {
}
/// Materialize `HostContext` that can be used to invoke a substrate host `dyn Function`.
pub fn materialize<'a>(&'a self) -> HostContext<'a> {
HostContext(self)
pub(crate) fn materialize<'a, 'b, 'c>(
&'a self,
caller: &'b mut Caller<'c, StoreData>,
) -> HostContext<'a, 'b, 'c> {
HostContext { host_state: self, caller }
}
}
/// 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 struct HostContext<'a>(&'a HostState);
pub(crate) struct HostContext<'a, 'b, 'c> {
host_state: &'a HostState,
caller: &'b mut Caller<'c, StoreData>,
}
impl<'a> std::ops::Deref for HostContext<'a> {
impl<'a, 'b, 'c> std::ops::Deref for HostContext<'a, 'b, 'c> {
type Target = HostState;
fn deref(&self) -> &HostState {
self.0
self.host_state
}
}
impl<'a> sp_wasm_interface::FunctionContext for HostContext<'a> {
impl<'a, 'b, 'c> sp_wasm_interface::FunctionContext for HostContext<'a, 'b, 'c> {
fn read_memory_into(
&self,
address: Pointer<u8>,
dest: &mut [u8],
) -> sp_wasm_interface::Result<()> {
self.instance.read_memory_into(address, dest).map_err(|e| e.to_string())
let ctx = &self.caller;
self.host_state
.instance
.read_memory_into(ctx, address, dest)
.map_err(|e| e.to_string())
}
fn write_memory(&mut self, address: Pointer<u8>, data: &[u8]) -> sp_wasm_interface::Result<()> {
self.instance.write_memory_from(address, data).map_err(|e| e.to_string())
let ctx = &mut self.caller;
self.host_state
.instance
.write_memory_from(ctx, address, data)
.map_err(|e| e.to_string())
}
fn allocate_memory(&mut self, size: WordSize) -> sp_wasm_interface::Result<Pointer<u8>> {
self.instance
.allocate(&mut *self.allocator.borrow_mut(), size)
let ctx = &mut self.caller;
let allocator = &self.host_state.allocator;
self.host_state
.instance
.allocate(ctx, &mut *allocator.borrow_mut(), size)
.map_err(|e| e.to_string())
}
fn deallocate_memory(&mut self, ptr: Pointer<u8>) -> sp_wasm_interface::Result<()> {
self.instance
.deallocate(&mut *self.allocator.borrow_mut(), ptr)
let ctx = &mut self.caller;
let allocator = &self.host_state.allocator;
self.host_state
.instance
.deallocate(ctx, &mut *allocator.borrow_mut(), ptr)
.map_err(|e| e.to_string())
}
@@ -111,7 +133,7 @@ impl<'a> sp_wasm_interface::FunctionContext for HostContext<'a> {
}
}
impl<'a> Sandbox for HostContext<'a> {
impl<'a, 'b, 'c> Sandbox for HostContext<'a, 'b, 'c> {
fn memory_get(
&mut self,
memory_id: MemoryId,
@@ -129,7 +151,8 @@ impl<'a> Sandbox for HostContext<'a> {
Ok(buffer) => buffer,
};
if let Err(_) = self.instance.write_memory_from(buf_ptr, &buffer) {
let instance = self.instance.clone();
if let Err(_) = instance.write_memory_from(&mut self.caller, buf_ptr, &buffer) {
return Ok(sandbox_primitives::ERR_OUT_OF_BOUNDS)
}
@@ -148,7 +171,7 @@ impl<'a> Sandbox for HostContext<'a> {
let len = val_len as usize;
let buffer = match self.instance.read_memory(val_ptr, len) {
let buffer = match self.instance.read_memory(&self.caller, val_ptr, len) {
Err(_) => return Ok(sandbox_primitives::ERR_OUT_OF_BOUNDS),
Ok(buffer) => buffer,
};
@@ -241,12 +264,14 @@ impl<'a> Sandbox for HostContext<'a> {
) -> sp_wasm_interface::Result<u32> {
// Extract a dispatch thunk from the instance's table by the specified index.
let dispatch_thunk = {
let ctx = &mut self.caller;
let table_item = self
.host_state
.instance
.table()
.as_ref()
.ok_or_else(|| "Runtime doesn't have a table; sandbox is unavailable")?
.get(dispatch_thunk_id);
.get(ctx, dispatch_thunk_id);
table_item
.ok_or_else(|| "dispatch_thunk_id is out of bounds")?
@@ -295,12 +320,12 @@ impl<'a> Sandbox for HostContext<'a> {
}
}
struct SandboxContext<'a, 'b> {
host_context: &'a mut HostContext<'b>,
struct SandboxContext<'a, 'b, 'c, 'd> {
host_context: &'a mut HostContext<'b, 'c, 'd>,
dispatch_thunk: Func,
}
impl<'a, 'b> sandbox::SandboxContext for SandboxContext<'a, 'b> {
impl<'a, 'b, 'c, 'd> sandbox::SandboxContext for SandboxContext<'a, 'b, 'c, 'd> {
fn invoke(
&mut self,
invoke_args_ptr: Pointer<u8>,
@@ -308,12 +333,16 @@ impl<'a, 'b> sandbox::SandboxContext for SandboxContext<'a, 'b> {
state: u32,
func_idx: SupervisorFuncIndex,
) -> Result<i64> {
let result = self.dispatch_thunk.call(&[
Val::I32(u32::from(invoke_args_ptr) as i32),
Val::I32(invoke_args_len as i32),
Val::I32(state as i32),
Val::I32(usize::from(func_idx) as i32),
]);
let result = self.dispatch_thunk.call(
&mut self.host_context.caller,
&[
Val::I32(u32::from(invoke_args_ptr) as i32),
Val::I32(invoke_args_len as i32),
Val::I32(state as i32),
Val::I32(usize::from(func_idx) as i32),
],
);
match result {
Ok(ret_vals) => {
let ret_val = if ret_vals.len() != 1 {
substrate/client/executor/wasmtime/src/imports.rs
+31 -20
View File
@@ -16,12 +16,15 @@
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
use crate::{state_holder, util};
use crate::{
runtime::{Store, StoreData},
util,
};
use sc_executor_common::error::WasmError;
use sp_wasm_interface::{Function, ValueType};
use std::any::Any;
use wasmtime::{
Extern, ExternType, Func, FuncType, ImportType, Limits, Memory, MemoryType, Module, Store,
Caller, Extern, ExternType, Func, FuncType, ImportType, Limits, Memory, MemoryType, Module,
Trap, Val,
};
@@ -34,8 +37,8 @@ pub struct Imports {
/// Goes over all imports of a module and prepares a vector of `Extern`s that can be used for
/// instantiation of the module. Returns an error if there are imports that cannot be satisfied.
pub fn resolve_imports(
store: &Store,
pub(crate) fn resolve_imports(
store: &mut Store,
module: &Module,
host_functions: &[&'static dyn Function],
heap_pages: u32,
@@ -78,7 +81,7 @@ fn import_name<'a, 'b: 'a>(import: &'a ImportType<'b>) -> Result<&'a str, WasmEr
}
fn resolve_memory_import(
store: &Store,
store: &mut Store,
import_ty: &ImportType,
heap_pages: u32,
) -> Result<Extern, WasmError> {
@@ -117,7 +120,7 @@ fn resolve_memory_import(
}
fn resolve_func_import(
store: &Store,
store: &mut Store,
import_ty: &ImportType,
host_functions: &[&'static dyn Function],
allow_missing_func_imports: bool,
@@ -162,19 +165,27 @@ struct HostFuncHandler {
host_func: &'static dyn Function,
}
fn call_static(
fn call_static<'a>(
static_func: &'static dyn Function,
wasmtime_params: &[Val],
wasmtime_results: &mut [Val],
mut caller: Caller<'a, StoreData>,
) -> Result<(), wasmtime::Trap> {
let unwind_result = state_holder::with_context(|host_ctx| {
let mut host_ctx = host_ctx.expect(
"host functions can be called only from wasm instance;
wasm instance is always called initializing context;
therefore host_ctx cannot be None;
qed
",
);
let unwind_result = {
let host_state = caller
.data()
.host_state()
.expect(
"host functions can be called only from wasm instance;
wasm instance is always called initializing context;
therefore host_ctx cannot be None;
qed
",
)
.clone();
let mut host_ctx = host_state.materialize(&mut caller);
// `from_wasmtime_val` panics if it encounters a value that doesn't fit into the values
// available in substrate.
//
@@ -185,7 +196,7 @@ fn call_static(
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
static_func.execute(&mut host_ctx, &mut params)
}))
});
};
let execution_result = match unwind_result {
Ok(execution_result) => execution_result,
@@ -219,11 +230,11 @@ impl HostFuncHandler {
Self { host_func }
}
fn into_extern(self, store: &Store) -> Extern {
fn into_extern(self, store: &mut Store) -> Extern {
let host_func = self.host_func;
let func_ty = wasmtime_func_sig(self.host_func);
let func = Func::new(store, func_ty, move |_, params, result| {
call_static(host_func, params, result)
let func = Func::new(store, func_ty, move |caller, params, result| {
call_static(host_func, params, result, caller)
});
Extern::Func(func)
}
@@ -243,7 +254,7 @@ impl MissingHostFuncHandler {
})
}
fn into_extern(self, store: &Store, func_ty: &FuncType) -> Extern {
fn into_extern(self, store: &mut Store, func_ty: &FuncType) -> Extern {
let Self { module, name } = self;
let func = Func::new(store, func_ty.clone(), move |_, _, _| {
Err(Trap::new(format!("call to a missing function {}:{}", module, name)))
substrate/client/executor/wasmtime/src/instance_wrapper.rs
+110 -142
View File
@@ -19,20 +19,18 @@
//! Defines data and logic needed for interaction with an WebAssembly instance of a substrate
//! runtime module.
use crate::{
imports::Imports,
util::{from_wasmtime_val, into_wasmtime_val},
};
use crate::imports::Imports;
use sc_executor_common::{
error::{Error, Result},
runtime_blob,
util::checked_range,
wasm_runtime::InvokeMethod,
};
use sp_wasm_interface::{Pointer, Value, WordSize};
use std::{marker, slice};
use wasmtime::{Extern, Func, Global, Instance, Memory, Module, Store, Table, Val};
use std::marker;
use wasmtime::{
AsContext, AsContextMut, Extern, Func, Global, Instance, Memory, Module, Table, Val,
};
/// Invoked entrypoint format.
pub enum EntryPointType {
@@ -58,7 +56,12 @@ pub struct EntryPoint {
impl EntryPoint {
/// Call this entry point.
pub fn call(&self, data_ptr: Pointer<u8>, data_len: WordSize) -> Result<u64> {
pub fn call(
&self,
ctx: impl AsContextMut,
data_ptr: Pointer<u8>,
data_len: WordSize,
) -> Result<u64> {
let data_ptr = u32::from(data_ptr);
let data_len = u32::from(data_len);
@@ -68,15 +71,18 @@ impl EntryPoint {
match self.call_type {
EntryPointType::Direct { ref entrypoint } =>
entrypoint.call((data_ptr, data_len)).map_err(handle_trap),
entrypoint.call(ctx, (data_ptr, data_len)).map_err(handle_trap),
EntryPointType::Wrapped { func, ref dispatcher } =>
dispatcher.call((func, data_ptr, data_len)).map_err(handle_trap),
dispatcher.call(ctx, (func, data_ptr, data_len)).map_err(handle_trap),
}
}
pub fn direct(func: wasmtime::Func) -> std::result::Result<Self, &'static str> {
pub fn direct(
func: wasmtime::Func,
ctx: impl AsContext,
) -> std::result::Result<Self, &'static str> {
let entrypoint = func
.typed::<(u32, u32), u64>()
.typed::<(u32, u32), u64, _>(ctx)
.map_err(|_| "Invalid signature for direct entry point")?
.clone();
Ok(Self { call_type: EntryPointType::Direct { entrypoint } })
@@ -85,9 +91,10 @@ impl EntryPoint {
pub fn wrapped(
dispatcher: wasmtime::Func,
func: u32,
ctx: impl AsContext,
) -> std::result::Result<Self, &'static str> {
let dispatcher = dispatcher
.typed::<(u32, u32, u32), u64>()
.typed::<(u32, u32, u32), u64, _>(ctx)
.map_err(|_| "Invalid signature for wrapped entry point")?
.clone();
Ok(Self { call_type: EntryPointType::Wrapped { func, dispatcher } })
@@ -144,8 +151,13 @@ fn extern_func(extern_: &Extern) -> Option<&Func> {
impl InstanceWrapper {
/// Create a new instance wrapper from the given wasm module.
pub fn new(store: &Store, module: &Module, imports: &Imports, heap_pages: u32) -> Result<Self> {
let instance = Instance::new(store, module, &imports.externs)
pub fn new(
module: &Module,
imports: &Imports,
heap_pages: u32,
mut ctx: impl AsContextMut,
) -> Result<Self> {
let instance = Instance::new(&mut ctx, module, &imports.externs)
.map_err(|e| Error::from(format!("cannot instantiate: {}", e)))?;
let memory = match imports.memory_import_index {
@@ -153,51 +165,55 @@ impl InstanceWrapper {
.expect("only memory can be at the `memory_idx`; qed")
.clone(),
None => {
let memory = get_linear_memory(&instance)?;
if !memory.grow(heap_pages).is_ok() {
return Err("failed to increase the linear memory size".into())
let memory = get_linear_memory(&instance, &mut ctx)?;
if !memory.grow(&mut ctx, heap_pages).is_ok() {
return Err("failed top increase the linear memory size".into())
}
memory
},
};
Ok(Self {
table: get_table(&instance),
instance,
memory,
_not_send_nor_sync: marker::PhantomData,
})
let table = get_table(&instance, ctx);
Ok(Self { table, instance, memory, _not_send_nor_sync: marker::PhantomData })
}
/// Resolves a substrate entrypoint by the given name.
///
/// An entrypoint must have a signature `(i32, i32) -> i64`, otherwise this function will return
/// an error.
pub fn resolve_entrypoint(&self, method: InvokeMethod) -> Result<EntryPoint> {
pub fn resolve_entrypoint(
&self,
method: InvokeMethod,
mut ctx: impl AsContextMut,
) -> Result<EntryPoint> {
Ok(match method {
InvokeMethod::Export(method) => {
// Resolve the requested method and verify that it has a proper signature.
let export = self.instance.get_export(method).ok_or_else(|| {
let export = self.instance.get_export(&mut ctx, method).ok_or_else(|| {
Error::from(format!("Exported method {} is not found", method))
})?;
let func = extern_func(&export)
.ok_or_else(|| Error::from(format!("Export {} is not a function", method)))?
.clone();
EntryPoint::direct(func).map_err(|_| {
EntryPoint::direct(func, ctx).map_err(|_| {
Error::from(format!("Exported function '{}' has invalid signature.", method))
})?
},
InvokeMethod::Table(func_ref) => {
let table =
self.instance.get_table("__indirect_function_table").ok_or(Error::NoTable)?;
let val = table.get(func_ref).ok_or(Error::NoTableEntryWithIndex(func_ref))?;
let table = self
.instance
.get_table(&mut ctx, "__indirect_function_table")
.ok_or(Error::NoTable)?;
let val =
table.get(&mut ctx, func_ref).ok_or(Error::NoTableEntryWithIndex(func_ref))?;
let func = val
.funcref()
.ok_or(Error::TableElementIsNotAFunction(func_ref))?
.ok_or(Error::FunctionRefIsNull(func_ref))?
.clone();
EntryPoint::direct(func).map_err(|_| {
EntryPoint::direct(func, ctx).map_err(|_| {
Error::from(format!(
"Function @{} in exported table has invalid signature for direct call.",
func_ref,
@@ -205,10 +221,12 @@ impl InstanceWrapper {
})?
},
InvokeMethod::TableWithWrapper { dispatcher_ref, func } => {
let table =
self.instance.get_table("__indirect_function_table").ok_or(Error::NoTable)?;
let table = self
.instance
.get_table(&mut ctx, "__indirect_function_table")
.ok_or(Error::NoTable)?;
let val = table
.get(dispatcher_ref)
.get(&mut ctx, dispatcher_ref)
.ok_or(Error::NoTableEntryWithIndex(dispatcher_ref))?;
let dispatcher = val
.funcref()
@@ -216,7 +234,7 @@ impl InstanceWrapper {
.ok_or(Error::FunctionRefIsNull(dispatcher_ref))?
.clone();
EntryPoint::wrapped(dispatcher, func).map_err(|_| {
EntryPoint::wrapped(dispatcher, func, ctx).map_err(|_| {
Error::from(format!(
"Function @{} in exported table has invalid signature for wrapped call.",
dispatcher_ref,
@@ -234,17 +252,17 @@ impl InstanceWrapper {
/// Reads `__heap_base: i32` global variable and returns it.
///
/// If it doesn't exist, not a global or of not i32 type returns an error.
pub fn extract_heap_base(&self) -> Result<u32> {
pub fn extract_heap_base(&self, mut ctx: impl AsContextMut) -> Result<u32> {
let heap_base_export = self
.instance
.get_export("__heap_base")
.get_export(&mut ctx, "__heap_base")
.ok_or_else(|| Error::from("__heap_base is not found"))?;
let heap_base_global = extern_global(&heap_base_export)
.ok_or_else(|| Error::from("__heap_base is not a global"))?;
let heap_base = heap_base_global
.get()
.get(&mut ctx)
.i32()
.ok_or_else(|| Error::from("__heap_base is not a i32"))?;
@@ -252,15 +270,15 @@ impl InstanceWrapper {
}
/// Get the value from a global with the given `name`.
pub fn get_global_val(&self, name: &str) -> Result<Option<Value>> {
let global = match self.instance.get_export(name) {
pub fn get_global_val(&self, mut ctx: impl AsContextMut, name: &str) -> Result<Option<Value>> {
let global = match self.instance.get_export(&mut ctx, name) {
Some(global) => global,
None => return Ok(None),
};
let global = extern_global(&global).ok_or_else(|| format!("`{}` is not a global", name))?;
match global.get() {
match global.get(ctx) {
Val::I32(val) => Ok(Some(Value::I32(val))),
Val::I64(val) => Ok(Some(Value::I64(val))),
Val::F32(val) => Ok(Some(Value::F32(val))),
@@ -268,12 +286,17 @@ impl InstanceWrapper {
_ => Err("Unknown value type".into()),
}
}
/// Get a global with the given `name`.
pub fn get_global(&self, ctx: impl AsContextMut, name: &str) -> Option<wasmtime::Global> {
self.instance.get_global(ctx, name)
}
}
/// Extract linear memory instance from the given instance.
fn get_linear_memory(instance: &Instance) -> Result<Memory> {
fn get_linear_memory(instance: &Instance, ctx: impl AsContextMut) -> Result<Memory> {
let memory_export = instance
.get_export("memory")
.get_export(ctx, "memory")
.ok_or_else(|| Error::from("memory is not exported under `memory` name"))?;
let memory = extern_memory(&memory_export)
@@ -284,9 +307,9 @@ fn get_linear_memory(instance: &Instance) -> Result<Memory> {
}
/// Extract the table from the given instance if any.
fn get_table(instance: &Instance) -> Option<Table> {
fn get_table(instance: &Instance, ctx: impl AsContextMut) -> Option<Table> {
instance
.get_export("__indirect_function_table")
.get_export(ctx, "__indirect_function_table")
.as_ref()
.and_then(extern_table)
.cloned()
@@ -297,12 +320,17 @@ impl InstanceWrapper {
/// Read data from a slice of memory into a newly allocated buffer.
///
/// Returns an error if the read would go out of the memory bounds.
pub fn read_memory(&self, source_addr: Pointer<u8>, size: usize) -> Result<Vec<u8>> {
let range = checked_range(source_addr.into(), size, self.memory.data_size())
pub fn read_memory(
&self,
ctx: impl AsContext,
source_addr: Pointer<u8>,
size: usize,
) -> Result<Vec<u8>> {
let range = checked_range(source_addr.into(), size, self.memory.data_size(&ctx))
.ok_or_else(|| Error::Other("memory read is out of bounds".into()))?;
let mut buffer = vec![0; range.len()];
self.read_memory_into(source_addr, &mut buffer)?;
self.read_memory_into(ctx, source_addr, &mut buffer)?;
Ok(buffer)
}
@@ -310,33 +338,35 @@ impl InstanceWrapper {
/// Read data from the instance memory into a slice.
///
/// Returns an error if the read would go out of the memory bounds.
pub fn read_memory_into(&self, source_addr: Pointer<u8>, dest: &mut [u8]) -> Result<()> {
unsafe {
// This should be safe since we don't grow up memory while caching this reference and
// we give up the reference before returning from this function.
let memory = self.memory_as_slice();
pub fn read_memory_into(
&self,
ctx: impl AsContext,
address: Pointer<u8>,
dest: &mut [u8],
) -> Result<()> {
let memory = self.memory.data(ctx.as_context());
let range = checked_range(source_addr.into(), dest.len(), memory.len())
.ok_or_else(|| Error::Other("memory read is out of bounds".into()))?;
dest.copy_from_slice(&memory[range]);
Ok(())
}
let range = checked_range(address.into(), dest.len(), memory.len())
.ok_or_else(|| Error::Other("memory read is out of bounds".into()))?;
dest.copy_from_slice(&memory[range]);
Ok(())
}
/// Write data to the instance memory from a slice.
///
/// Returns an error if the write would go out of the memory bounds.
pub fn write_memory_from(&self, dest_addr: Pointer<u8>, data: &[u8]) -> Result<()> {
unsafe {
// This should be safe since we don't grow up memory while caching this reference and
// we give up the reference before returning from this function.
let memory = self.memory_as_slice_mut();
pub fn write_memory_from(
&self,
mut ctx: impl AsContextMut,
address: Pointer<u8>,
data: &[u8],
) -> Result<()> {
let memory = self.memory.data_mut(ctx.as_context_mut());
let range = checked_range(dest_addr.into(), data.len(), memory.len())
.ok_or_else(|| Error::Other("memory write is out of bounds".into()))?;
memory[range].copy_from_slice(data);
Ok(())
}
let range = checked_range(address.into(), data.len(), memory.len())
.ok_or_else(|| Error::Other("memory write is out of bounds".into()))?;
memory[range].copy_from_slice(data);
Ok(())
}
/// Allocate some memory of the given size. Returns pointer to the allocated memory region.
@@ -345,16 +375,13 @@ impl InstanceWrapper {
/// to get more details.
pub fn allocate(
&self,
mut ctx: impl AsContextMut,
allocator: &mut sc_allocator::FreeingBumpHeapAllocator,
size: WordSize,
) -> Result<Pointer<u8>> {
unsafe {
// This should be safe since we don't grow up memory while caching this reference and
// we give up the reference before returning from this function.
let memory = self.memory_as_slice_mut();
let memory = self.memory.data_mut(ctx.as_context_mut());
allocator.allocate(memory, size).map_err(Into::into)
}
allocator.allocate(memory, size).map_err(Into::into)
}
/// Deallocate the memory pointed by the given pointer.
@@ -362,64 +389,25 @@ impl InstanceWrapper {
/// Returns `Err` in case the given memory region cannot be deallocated.
pub fn deallocate(
&self,
mut ctx: impl AsContextMut,
allocator: &mut sc_allocator::FreeingBumpHeapAllocator,
ptr: Pointer<u8>,
) -> Result<()> {
unsafe {
// This should be safe since we don't grow up memory while caching this reference and
// we give up the reference before returning from this function.
let memory = self.memory_as_slice_mut();
let memory = self.memory.data_mut(ctx.as_context_mut());
allocator.deallocate(memory, ptr).map_err(Into::into)
}
}
/// Returns linear memory of the wasm instance as a slice.
///
/// # Safety
///
/// Wasmtime doesn't provide comprehensive documentation about the exact behavior of the data
/// pointer. If a dynamic style heap is used the base pointer of the heap can change. Since
/// growing, we cannot guarantee the lifetime of the returned slice reference.
unsafe fn memory_as_slice(&self) -> &[u8] {
let ptr = self.memory.data_ptr() as *const _;
let len = self.memory.data_size();
if len == 0 {
&[]
} else {
slice::from_raw_parts(ptr, len)
}
}
/// Returns linear memory of the wasm instance as a slice.
///
/// # Safety
///
/// See `[memory_as_slice]`. In addition to those requirements, since a mutable reference is
/// returned it must be ensured that only one mutable and no shared references to memory exists
/// at the same time.
unsafe fn memory_as_slice_mut(&self) -> &mut [u8] {
let ptr = self.memory.data_ptr();
let len = self.memory.data_size();
if len == 0 {
&mut []
} else {
slice::from_raw_parts_mut(ptr, len)
}
allocator.deallocate(memory, ptr).map_err(Into::into)
}
/// Returns the pointer to the first byte of the linear memory for this instance.
pub fn base_ptr(&self) -> *const u8 {
self.memory.data_ptr()
pub fn base_ptr(&self, ctx: impl AsContext) -> *const u8 {
self.memory.data_ptr(ctx)
}
/// Removes physical backing from the allocated linear memory. This leads to returning the
/// memory back to the system. While the memory is zeroed this is considered as a side-effect
/// and is not relied upon. Thus this function acts as a hint.
pub fn decommit(&self) {
if self.memory.data_size() == 0 {
pub fn decommit(&self, ctx: impl AsContext) {
if self.memory.data_size(&ctx) == 0 {
return
}
@@ -428,8 +416,8 @@ impl InstanceWrapper {
use std::sync::Once;
unsafe {
let ptr = self.memory.data_ptr();
let len = self.memory.data_size();
let ptr = self.memory.data_ptr(&ctx);
let len = self.memory.data_size(ctx);
// Linux handles MADV_DONTNEED reliably. The result is that the given area
// is unmapped and will be zeroed on the next pagefault.
@@ -447,23 +435,3 @@ impl InstanceWrapper {
}
}
}
impl runtime_blob::InstanceGlobals for InstanceWrapper {
type Global = wasmtime::Global;
fn get_global(&self, export_name: &str) -> Self::Global {
self.instance
.get_global(export_name)
.expect("get_global is guaranteed to be called with an export name of a global; qed")
}
fn get_global_value(&self, global: &Self::Global) -> Value {
from_wasmtime_val(global.get())
}
fn set_global_value(&self, global: &Self::Global, value: Value) {
global.set(into_wasmtime_val(value)).expect(
"the value is guaranteed to be of the same value; the global is guaranteed to be mutable; qed",
);
}
}
substrate/client/executor/wasmtime/src/lib.rs
-1
View File
@@ -21,7 +21,6 @@ mod host;
mod imports;
mod instance_wrapper;
mod runtime;
mod state_holder;
mod util;
#[cfg(test)]
substrate/client/executor/wasmtime/src/runtime.rs
+124 -45
View File
@@ -22,13 +22,15 @@ use crate::{
host::HostState,
imports::{resolve_imports, Imports},
instance_wrapper::{EntryPoint, InstanceWrapper},
state_holder,
util,
};
use sc_allocator::FreeingBumpHeapAllocator;
use sc_executor_common::{
error::{Result, WasmError},
runtime_blob::{DataSegmentsSnapshot, ExposedMutableGlobalsSet, GlobalsSnapshot, RuntimeBlob},
runtime_blob::{
self, DataSegmentsSnapshot, ExposedMutableGlobalsSet, GlobalsSnapshot, RuntimeBlob,
},
wasm_runtime::{InvokeMethod, WasmInstance, WasmModule},
};
use sp_runtime_interface::unpack_ptr_and_len;
@@ -38,7 +40,24 @@ use std::{
rc::Rc,
sync::Arc,
};
use wasmtime::{Engine, Store};
use wasmtime::{AsContext, AsContextMut, Engine, StoreLimits};
pub(crate) struct StoreData {
/// The limits we aply to the store. We need to store it here to return a reference to this
/// object when we have the limits enabled.
limits: StoreLimits,
/// This will only be set when we call into the runtime.
host_state: Option<Rc<HostState>>,
}
impl StoreData {
/// Returns a reference to the host state.
pub fn host_state(&self) -> Option<&Rc<HostState>> {
self.host_state.as_ref()
}
}
pub(crate) type Store = wasmtime::Store<StoreData>;
enum Strategy {
FastInstanceReuse {
@@ -46,6 +65,7 @@ enum Strategy {
globals_snapshot: GlobalsSnapshot<wasmtime::Global>,
data_segments_snapshot: Arc<DataSegmentsSnapshot>,
heap_base: u32,
store: Store,
},
RecreateInstance(InstanceCreator),
}
@@ -58,8 +78,33 @@ struct InstanceCreator {
}
impl InstanceCreator {
fn instantiate(&self) -> Result<InstanceWrapper> {
InstanceWrapper::new(&self.store, &*self.module, &*self.imports, self.heap_pages)
fn instantiate(&mut self) -> Result<InstanceWrapper> {
InstanceWrapper::new(&*self.module, &*self.imports, self.heap_pages, &mut self.store)
}
}
struct InstanceGlobals<'a, C> {
ctx: &'a mut C,
instance: &'a InstanceWrapper,
}
impl<'a, C: AsContextMut> runtime_blob::InstanceGlobals for InstanceGlobals<'a, C> {
type Global = wasmtime::Global;
fn get_global(&mut self, export_name: &str) -> Self::Global {
self.instance
.get_global(&mut self.ctx, export_name)
.expect("get_global is guaranteed to be called with an export name of a global; qed")
}
fn get_global_value(&mut self, global: &Self::Global) -> Value {
util::from_wasmtime_val(global.get(&mut self.ctx))
}
fn set_global_value(&mut self, global: &Self::Global, value: Value) {
global.set(&mut self.ctx, util::into_wasmtime_val(value)).expect(
"the value is guaranteed to be of the same value; the global is guaranteed to be mutable; qed",
);
}
}
@@ -82,19 +127,25 @@ pub struct WasmtimeRuntime {
impl WasmtimeRuntime {
/// Creates the store respecting the set limits.
fn new_store(&self) -> Store {
match self.config.max_memory_pages {
Some(max_memory_pages) => Store::new_with_limits(
&self.engine,
wasmtime::StoreLimitsBuilder::new().memory_pages(max_memory_pages).build(),
),
None => Store::new(&self.engine),
let limits = if let Some(max_memory_pages) = self.config.max_memory_pages {
wasmtime::StoreLimitsBuilder::new().memory_pages(max_memory_pages).build()
} else {
Default::default()
};
let mut store = Store::new(&self.engine, StoreData { limits, host_state: None });
if self.config.max_memory_pages.is_some() {
store.limiter(|s| &mut s.limits);
}
store
}
}
impl WasmModule for WasmtimeRuntime {
fn new_instance(&self) -> Result<Box<dyn WasmInstance>> {
let store = self.new_store();
let mut store = self.new_store();
// Scan all imports, find the matching host functions, and create stubs that adapt arguments
// and results.
@@ -103,7 +154,7 @@ impl WasmModule for WasmtimeRuntime {
// However, I am not sure if that's a good idea since it would be pushing our luck
// further by assuming that `Store` not only `Send` but also `Sync`.
let imports = resolve_imports(
&store,
&mut store,
&self.module,
&self.host_functions,
self.config.heap_pages,
@@ -112,21 +163,24 @@ impl WasmModule for WasmtimeRuntime {
let strategy = if let Some(ref snapshot_data) = self.snapshot_data {
let instance_wrapper =
InstanceWrapper::new(&store, &self.module, &imports, self.config.heap_pages)?;
let heap_base = instance_wrapper.extract_heap_base()?;
InstanceWrapper::new(&self.module, &imports, self.config.heap_pages, &mut store)?;
let heap_base = instance_wrapper.extract_heap_base(&mut store)?;
// This function panics if the instance was created from a runtime blob different from
// which the mutable globals were collected. Here, it is easy to see that there is only
// a single runtime blob and thus it's the same that was used for both creating the
// instance and collecting the mutable globals.
let globals_snapshot =
GlobalsSnapshot::take(&snapshot_data.mutable_globals, &instance_wrapper);
let globals_snapshot = GlobalsSnapshot::take(
&snapshot_data.mutable_globals,
&mut InstanceGlobals { ctx: &mut store, instance: &instance_wrapper },
);
Strategy::FastInstanceReuse {
instance_wrapper: Rc::new(instance_wrapper),
globals_snapshot,
data_segments_snapshot: snapshot_data.data_segments_snapshot.clone(),
heap_base,
store,
}
} else {
Strategy::RecreateInstance(InstanceCreator {
@@ -152,48 +206,63 @@ pub struct WasmtimeInstance {
unsafe impl Send for WasmtimeInstance {}
impl WasmInstance for WasmtimeInstance {
fn call(&self, method: InvokeMethod, data: &[u8]) -> Result<Vec<u8>> {
match &self.strategy {
fn call(&mut self, method: InvokeMethod, data: &[u8]) -> Result<Vec<u8>> {
match &mut self.strategy {
Strategy::FastInstanceReuse {
instance_wrapper,
globals_snapshot,
data_segments_snapshot,
heap_base,
ref mut store,
} => {
let entrypoint = instance_wrapper.resolve_entrypoint(method)?;
let entrypoint = instance_wrapper.resolve_entrypoint(method, &mut *store)?;
data_segments_snapshot.apply(|offset, contents| {
instance_wrapper.write_memory_from(Pointer::new(offset), contents)
instance_wrapper.write_memory_from(&mut *store, Pointer::new(offset), contents)
})?;
globals_snapshot.apply(&**instance_wrapper);
globals_snapshot
.apply(&mut InstanceGlobals { ctx: &mut *store, instance: &*instance_wrapper });
let allocator = FreeingBumpHeapAllocator::new(*heap_base);
let result =
perform_call(data, Rc::clone(&instance_wrapper), entrypoint, allocator);
let result = perform_call(
&mut *store,
data,
instance_wrapper.clone(),
entrypoint,
allocator,
);
// Signal to the OS that we are done with the linear memory and that it can be
// reclaimed.
instance_wrapper.decommit();
instance_wrapper.decommit(&store);
result
},
Strategy::RecreateInstance(instance_creator) => {
Strategy::RecreateInstance(ref mut instance_creator) => {
let instance_wrapper = instance_creator.instantiate()?;
let heap_base = instance_wrapper.extract_heap_base()?;
let entrypoint = instance_wrapper.resolve_entrypoint(method)?;
let heap_base = instance_wrapper.extract_heap_base(&mut instance_creator.store)?;
let entrypoint =
instance_wrapper.resolve_entrypoint(method, &mut instance_creator.store)?;
let allocator = FreeingBumpHeapAllocator::new(heap_base);
perform_call(data, Rc::new(instance_wrapper), entrypoint, allocator)
perform_call(
&mut instance_creator.store,
data,
Rc::new(instance_wrapper),
entrypoint,
allocator,
)
},
}
}
fn get_global_const(&self, name: &str) -> Result<Option<Value>> {
match &self.strategy {
Strategy::FastInstanceReuse { instance_wrapper, .. } =>
instance_wrapper.get_global_val(name),
Strategy::RecreateInstance(instance_creator) =>
instance_creator.instantiate()?.get_global_val(name),
fn get_global_const(&mut self, name: &str) -> Result<Option<Value>> {
match &mut self.strategy {
Strategy::FastInstanceReuse { instance_wrapper, ref mut store, .. } =>
instance_wrapper.get_global_val(&mut *store, name),
Strategy::RecreateInstance(ref mut instance_creator) => instance_creator
.instantiate()?
.get_global_val(&mut instance_creator.store, name),
}
}
@@ -204,8 +273,8 @@ impl WasmInstance for WasmtimeInstance {
// associated with it.
None
},
Strategy::FastInstanceReuse { instance_wrapper, .. } =>
Some(instance_wrapper.base_ptr()),
Strategy::FastInstanceReuse { instance_wrapper, store, .. } =>
Some(instance_wrapper.base_ptr(&store)),
}
}
}
@@ -536,40 +605,50 @@ pub fn prepare_runtime_artifact(
}
fn perform_call(
mut ctx: impl AsContextMut<Data = StoreData>,
data: &[u8],
instance_wrapper: Rc<InstanceWrapper>,
entrypoint: EntryPoint,
mut allocator: FreeingBumpHeapAllocator,
) -> Result<Vec<u8>> {
let (data_ptr, data_len) = inject_input_data(&instance_wrapper, &mut allocator, data)?;
let (data_ptr, data_len) =
inject_input_data(&mut ctx, &instance_wrapper, &mut allocator, data)?;
let host_state = HostState::new(allocator, instance_wrapper.clone());
let ret = state_holder::with_initialized_state(&host_state, || -> Result<_> {
Ok(unpack_ptr_and_len(entrypoint.call(data_ptr, data_len)?))
});
// Set the host state before calling into wasm.
ctx.as_context_mut().data_mut().host_state = Some(Rc::new(host_state));
let ret = entrypoint.call(&mut ctx, data_ptr, data_len).map(unpack_ptr_and_len);
// Reset the host state
ctx.as_context_mut().data_mut().host_state = None;
let (output_ptr, output_len) = ret?;
let output = extract_output_data(&instance_wrapper, output_ptr, output_len)?;
let output = extract_output_data(ctx, &instance_wrapper, output_ptr, output_len)?;
Ok(output)
}
fn inject_input_data(
mut ctx: impl AsContextMut,
instance: &InstanceWrapper,
allocator: &mut FreeingBumpHeapAllocator,
data: &[u8],
) -> Result<(Pointer<u8>, WordSize)> {
let data_len = data.len() as WordSize;
let data_ptr = instance.allocate(allocator, data_len)?;
instance.write_memory_from(data_ptr, data)?;
let data_ptr = instance.allocate(&mut ctx, allocator, data_len)?;
instance.write_memory_from(ctx, data_ptr, data)?;
Ok((data_ptr, data_len))
}
fn extract_output_data(
ctx: impl AsContext,
instance: &InstanceWrapper,
output_ptr: u32,
output_len: u32,
) -> Result<Vec<u8>> {
let mut output = vec![0; output_len as usize];
instance.read_memory_into(Pointer::new(output_ptr), &mut output)?;
instance.read_memory_into(ctx, Pointer::new(output_ptr), &mut output)?;
Ok(output)
}
substrate/client/executor/wasmtime/src/state_holder.rs
-45
View File
@@ -1,45 +0,0 @@
// This file is part of Substrate.
// Copyright (C) 2020-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
use crate::host::{HostContext, HostState};
scoped_tls::scoped_thread_local!(static HOST_STATE: HostState);
/// Provide `HostState` for the runtime method call and execute the given function `f`.
///
/// During the execution of the provided function `with_context` will be callable.
pub fn with_initialized_state<R, F>(s: &HostState, f: F) -> R
where
F: FnOnce() -> R,
{
HOST_STATE.set(s, f)
}
/// Create a `HostContext` from the contained `HostState` and execute the given function `f`.
///
/// This function is only callable within closure passed to `init_state`. Otherwise, the passed
/// context will be `None`.
pub fn with_context<R, F>(f: F) -> R
where
F: FnOnce(Option<HostContext>) -> R,
{
if !HOST_STATE.is_set() {
return f(None)
}
HOST_STATE.with(|state| f(Some(state.materialize())))
}
substrate/client/executor/wasmtime/src/tests.rs
+3 -3
View File
@@ -116,7 +116,7 @@ fn test_nan_canonicalization() {
builder.build()
};
let instance = runtime.new_instance().expect("failed to instantiate a runtime");
let mut instance = runtime.new_instance().expect("failed to instantiate a runtime");
/// A NaN with canonical payload bits.
const CANONICAL_NAN_BITS: u32 = 0x7fc00000;
@@ -159,7 +159,7 @@ fn test_stack_depth_reaching() {
builder.deterministic_stack(true);
builder.build()
};
let instance = runtime.new_instance().expect("failed to instantiate a runtime");
let mut instance = runtime.new_instance().expect("failed to instantiate a runtime");
let err = instance.call_export("test-many-locals", &[]).unwrap_err();
@@ -180,7 +180,7 @@ fn test_max_memory_pages() {
builder.max_memory_pages(max_memory_pages);
builder.build()
};
let instance = runtime.new_instance()?;
let mut instance = runtime.new_instance()?;
let _ = instance.call_export("main", &[])?;
Ok(())
}
substrate/primitives/maybe-compressed-blob/Cargo.toml
+1 -1
View File
@@ -11,4 +11,4 @@ documentation = "https://docs.rs/sp-maybe-compressed-blob"
readme = "README.md"
[dependencies]
zstd = { version = "0.6.0", default-features = false }
zstd = { version = "0.9.0", default-features = false }
substrate/primitives/state-machine/Cargo.toml
+1 -1
View File
@@ -35,7 +35,7 @@ tracing = { version = "0.1.22", optional = true }
hex-literal = "0.3.1"
sp-runtime = { version = "4.0.0-dev", path = "../runtime" }
pretty_assertions = "0.6.1"
rand = { version = "0.7.2" }
rand = "0.7.2"
[features]
default = ["std"]