RFC-145 (former RFC-4) implementation

polkadot/node/core/pvf/common/src/executor_interface.rs

@@ -208,6 +208,7 @@ type HostFunctions = (
 	sp_io::allocator::HostFunctions,
 	sp_io::logging::HostFunctions,
 	sp_io::trie::HostFunctions,
+	sp_io::input::HostFunctions,
 );
 
 /// The validation externalities that will panic on any storage related access. (PVFs should not
@@ -299,6 +300,14 @@ impl sp_externalities::Externalities for ValidationExternalities {
 		panic!("storage_commit_transaction: unsupported feature for parachain validation")
 	}
 
+	fn store_last_cursor(&mut self, _cursor: &[u8]) {
+		panic!("store_last_cursor: unsupported feature for parachain validation")
+	}
+
+	fn take_last_cursor(&mut self) -> Option<Vec<u8>> {
+		panic!("take_last_cursor: unsupported feature for parachain validation")
+	}
+
 	fn wipe(&mut self) {
 		panic!("wipe: unsupported feature for parachain validation")
 	}

prdoc/pr_8641.prdoc

@@ -0,0 +1,20 @@
+title: RFC-145 (former RFC-4) host functions implementation
+doc:
+- audience: Runtime Dev
+  description: |-
+    This implements the host functions introduced by [RFC-145](https://github.com/polkadot-fellows/RFCs/pull/145).
+crates:
+- name: sp-io
+  bump: major
+- name: sp-runtime-interface
+  bump: major
+- name: sp-externalities
+  bump: major
+- name: polkadot-node-core-pvf-common
+  bump: major
+- name: sc-executor-polkavm
+  bump: major
+- name: sc-executor-wasmtime
+  bump: major
+- name: sp-wasm-interface
+  bump: major

substrate/client/executor/polkavm/src/lib.rs

@@ -171,6 +171,14 @@ impl<'r, 'a> FunctionContext for Context<'r, 'a> {
 	fn register_panic_error_message(&mut self, _message: &str) {
 		unimplemented!("'register_panic_error_message' is never used when running under PolkaVM");
 	}
+
+	fn fill_input_data(
+		&mut self,
+		_ptr: Pointer<u8>,
+		_size: WordSize,
+	) -> sp_wasm_interface::Result<()> {
+		todo!("Implement 'fill_input_data' for PolkaVM");
+	}
 }
 
 fn call_host_function(caller: &mut Caller<()>, function: &dyn Function) -> Result<(), String> {

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

@@ -35,14 +35,19 @@ pub struct HostState {
 	/// This is stored as an `Option` as we need to temporarily set this to `None` when we are
 	/// allocating/deallocating memory. The problem being that we can only mutable access `caller`
 	/// once.
-	allocator: Option<FreeingBumpHeapAllocator>,
+	pub(crate) allocator: Option<FreeingBumpHeapAllocator>,
 	panic_message: Option<String>,
+	pub(crate) input_data: Option<Vec<u8>>,
 }
 
 impl HostState {
 	/// Constructs a new `HostState`.
-	pub fn new(allocator: FreeingBumpHeapAllocator) -> Self {
-		HostState { allocator: Some(allocator), panic_message: None }
+	pub fn new(allocator: FreeingBumpHeapAllocator, input_data: impl AsRef<[u8]>) -> Self {
+		HostState {
+			allocator: Some(allocator),
+			panic_message: None,
+			input_data: Some(input_data.as_ref().to_vec()),
+		}
 	}
 
 	/// Takes the error message out of the host state, leaving a `None` in its place.
@@ -125,4 +130,19 @@ impl<'a> sp_wasm_interface::FunctionContext for HostContext<'a> {
 	fn register_panic_error_message(&mut self, message: &str) {
 		self.host_state_mut().panic_message = Some(message.to_owned());
 	}
+
+	fn fill_input_data(
+		&mut self,
+		ptr: Pointer<u8>,
+		size: WordSize,
+	) -> sp_wasm_interface::Result<()> {
+		let input_data = self
+			.host_state_mut()
+			.input_data
+			.take()
+			.expect("input data is not empty when calling a function in wasm; qed");
+		assert_eq!(input_data.len(), size as usize, "input data length mismatch");
+		self.write_memory(ptr, &input_data[..])?;
+		Ok(())
+	}
 }

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

@@ -27,21 +27,41 @@ use sp_wasm_interface::{Pointer, WordSize};
 use wasmtime::{AsContext, AsContextMut, Engine, Instance, InstancePre, Memory};
 
 /// Wasm blob entry point.
-pub struct EntryPoint(wasmtime::TypedFunc<(u32, u32), u64>);
+pub enum EntryPoint {
+	V1(wasmtime::TypedFunc<(u32, u32), u64>),
+	V2(wasmtime::TypedFunc<(u32,), u64>),
+}
 
 impl EntryPoint {
 	/// Call this entry point.
-	pub(crate) fn call(
-		&self,
-		store: &mut Store,
-		data_ptr: Pointer<u8>,
-		data_len: WordSize,
-	) -> Result<u64> {
-		let data_ptr = u32::from(data_ptr);
-		let data_len = u32::from(data_len);
-
-		self.0.call(&mut *store, (data_ptr, data_len)).map_err(|trap| {
-			let host_state = store
+	pub(crate) fn call(&self, instance: &mut InstanceWrapper) -> Result<u64> {
+		let result =
+			match self {
+				Self::V1(func) => {
+					// SAFETY: Entry point signature has been checked statically and represents a
+					// V1 entry point. The V1 code is known to use the host-side allocator.
+					let (data_ptr, data_len) = unsafe { instance.inject_input_data()? };
+					let data_ptr = u32::from(data_ptr);
+					let data_len = u32::from(data_len);
+					func.call(instance.store_mut(), (data_ptr, data_len))
+				},
+				Self::V2(func) => {
+					let host_state =
+						instance.store().data().host_state.as_ref().expect(
+							"host state cannot be empty while a function is being called; qed",
+						);
+					let data_len = host_state
+						.input_data
+						.as_ref()
+						.expect("input data cannot be empty while a function is being called; qed")
+						.len() as u32;
+					func.call(instance.store_mut(), (data_len,))
+				},
+			};
+
+		result.map_err(|trap| {
+			let host_state = instance
+				.store_mut()
 				.data_mut()
 				.host_state
 				.as_mut()
@@ -66,10 +86,18 @@ impl EntryPoint {
 		func: wasmtime::Func,
 		ctx: impl AsContext,
 	) -> std::result::Result<Self, &'static str> {
-		let entrypoint = func
-			.typed::<(u32, u32), u64>(ctx)
-			.map_err(|_| "Invalid signature for direct entry point")?;
-		Ok(Self(entrypoint))
+		let ty = func.ty(ctx.as_context());
+		if ty.params().len() == 1 {
+			let entrypoint = func
+				.typed::<(u32,), u64>(ctx)
+				.map_err(|_| "Invalid signature for direct V2 entry point")?;
+			Ok(Self::V2(entrypoint))
+		} else {
+			let entrypoint = func
+				.typed::<(u32, u32), u64>(ctx)
+				.map_err(|_| "Invalid signature for direct V1 entry point")?;
+			Ok(Self::V1(entrypoint))
+		}
 	}
 }
 
@@ -181,6 +209,52 @@ impl InstanceWrapper {
 
 		Ok(heap_base as u32)
 	}
+
+	/// Injects the input data into the guest's memory.
+	///
+	/// Should only be used for code using the host-side allocator. Otherwise will corrupt
+	/// guest's memory
+	pub(crate) unsafe fn inject_input_data(&mut self) -> Result<(Pointer<u8>, WordSize)> {
+		let store = self.store_mut();
+		let mut allocator = store
+			.data_mut()
+			.host_state
+			.as_mut()
+			.expect("host state cannot be empty while a function is being called; qed")
+			.allocator
+			.take()
+			.expect("allocator cannot be empty while a function is being called; qed");
+
+		let result = {
+			let mut ctx = store.as_context_mut();
+			let host_data = ctx.data_mut();
+			let memory = host_data.memory();
+			let data = host_data
+				.host_state
+				.as_mut()
+				.expect("host state cannot be empty while a function is being called; qed")
+				.input_data
+				.take()
+				.expect("input data cannot be empty while a function is being called; qed");
+
+			let data_len = data.len() as WordSize;
+			match allocator.allocate(&mut MemoryWrapper(&memory, &mut ctx), data_len) {
+				Ok(data_ptr) => crate::util::write_memory_from(&mut ctx, data_ptr, &data[..])
+					.map(|_| (data_ptr, data_len))
+					.map_err(Into::into),
+				Err(e) => Err(e.into()),
+			}
+		};
+
+		store
+			.data_mut()
+			.host_state
+			.as_mut()
+			.expect("host state cannot be empty while a function is being called; qed")
+			.allocator = Some(allocator);
+
+		result
+	}
 }
 
 /// Extract linear memory instance from the given instance.

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

@@ -20,7 +20,7 @@
 
 use crate::{
 	host::HostState,
-	instance_wrapper::{EntryPoint, InstanceWrapper, MemoryWrapper},
+	instance_wrapper::{EntryPoint, InstanceWrapper},
 	util::{self, replace_strategy_if_broken},
 };
 
@@ -33,7 +33,7 @@ use sc_executor_common::{
 	wasm_runtime::{HeapAllocStrategy, WasmInstance, WasmModule},
 };
 use sp_runtime_interface::unpack_ptr_and_len;
-use sp_wasm_interface::{HostFunctions, Pointer, WordSize};
+use sp_wasm_interface::{HostFunctions, Pointer};
 use std::{
 	path::{Path, PathBuf},
 	sync::{
@@ -664,19 +664,15 @@ fn perform_call(
 	data: &[u8],
 	instance_wrapper: &mut InstanceWrapper,
 	entrypoint: EntryPoint,
-	mut allocator: FreeingBumpHeapAllocator,
+	allocator: FreeingBumpHeapAllocator,
 	allocation_stats: &mut Option<AllocationStats>,
 ) -> Result<Vec<u8>> {
-	let (data_ptr, data_len) = inject_input_data(instance_wrapper, &mut allocator, data)?;
-
-	let host_state = HostState::new(allocator);
+	let host_state = HostState::new(allocator, data);
 
 	// Set the host state before calling into wasm.
 	instance_wrapper.store_mut().data_mut().host_state = Some(host_state);
 
-	let ret = entrypoint
-		.call(instance_wrapper.store_mut(), data_ptr, data_len)
-		.map(unpack_ptr_and_len);
+	let ret = entrypoint.call(instance_wrapper).map(unpack_ptr_and_len);
 
 	// Reset the host state
 	let host_state = instance_wrapper.store_mut().data_mut().host_state.take().expect(
@@ -690,19 +686,6 @@ fn perform_call(
 	Ok(output)
 }
 
-fn inject_input_data(
-	instance: &mut InstanceWrapper,
-	allocator: &mut FreeingBumpHeapAllocator,
-	data: &[u8],
-) -> Result<(Pointer<u8>, WordSize)> {
-	let mut ctx = instance.store_mut();
-	let memory = ctx.data().memory();
-	let data_len = data.len() as WordSize;
-	let data_ptr = allocator.allocate(&mut MemoryWrapper(&memory, &mut ctx), data_len)?;
-	util::write_memory_from(instance.store_mut(), data_ptr, data)?;
-	Ok((data_ptr, data_len))
-}
-
 fn extract_output_data(
 	instance: &InstanceWrapper,
 	output_ptr: u32,

substrate/primitives/externalities/src/lib.rs

@@ -52,7 +52,7 @@ pub enum Error {
 }
 
 /// Results concerning an operation to remove many keys.
-#[derive(codec::Encode, codec::Decode)]
+#[derive(codec::Encode, codec::Decode, Default)]
 #[must_use]
 pub struct MultiRemovalResults {
 	/// A continuation cursor which, if `Some` must be provided to the subsequent removal call.
@@ -248,6 +248,16 @@ pub trait Externalities: ExtensionStore {
 		unimplemented!("storage_renew_transaction_index");
 	}
 
+	/// Store the last cursor of a storage operation.
+	fn store_last_cursor(&mut self, _cursor: &[u8]) {
+		unimplemented!("store_last_cursor");
+	}
+
+	/// Take the last cursor of a storage operation.
+	fn take_last_cursor(&mut self) -> Option<Vec<u8>> {
+		unimplemented!("take_last_cursor");
+	}
+
 	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 	/// Benchmarking related functionality and shouldn't be used anywhere else!
 	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!