feat(runtime-fuzzer): use previously waited message id as wake syscal…

…l param (#4076)
gear-tech · Jul 26, 2024 · d954e57 · d954e57
1 parent 9cdc3d0
commit d954e57
Show file tree

Hide file tree

Showing 8 changed files with 274 additions and 90 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/utils/runtime-fuzzer/src/generator/upload_program.rs b/utils/runtime-fuzzer/src/generator/upload_program.rs
@@ -150,7 +150,8 @@ fn config(
             actor_kind: actor_kind.clone(),
             range: EXISTENTIAL_DEPOSIT..=max_value,
         })
-        .with_ptr_rule(PtrParamAllowedValues::ReservationId);
+        .with_ptr_rule(PtrParamAllowedValues::ReservationId)
+        .with_ptr_rule(PtrParamAllowedValues::WaitedMessageId);
 
     if let Some(code_ids) = code_ids {
         params_config = params_config.with_ptr_rule(PtrParamAllowedValues::CodeIdsWithValue {

diff --git a/utils/wasm-gen/Cargo.toml b/utils/wasm-gen/Cargo.toml
@@ -17,6 +17,7 @@ gear-core.workspace = true
 wasmparser.workspace = true
 thiserror.workspace = true
 indexmap.workspace = true
+nonempty.workspace = true
 
 [dev-dependencies]
 rand = { workspace = true, features = ["small_rng"] }

diff --git a/utils/wasm-gen/src/config/syscalls/param.rs b/utils/wasm-gen/src/config/syscalls/param.rs
@@ -97,6 +97,7 @@ impl SyscallsParamsConfig {
                 range,
             })
             .with_ptr_rule(PtrParamAllowedValues::ReservationId)
+            .with_ptr_rule(PtrParamAllowedValues::WaitedMessageId)
     }
 
     /// Set rules for a regular syscall param.
@@ -127,6 +128,7 @@ impl SyscallsParamsConfig {
             }
             PtrParamAllowedValues::ReservationId => Ptr::Hash(HashType::ReservationId),
             PtrParamAllowedValues::CodeIdsWithValue { .. } => Ptr::HashWithValue(HashType::CodeId),
+            PtrParamAllowedValues::WaitedMessageId => Ptr::Hash(HashType::MessageId),
         };
 
         self.ptr.insert(ptr, allowed_values);
@@ -272,6 +274,8 @@ pub enum PtrParamAllowedValues {
         code_ids: NonEmpty<CodeId>,
         range: RangeInclusive<u128>,
     },
+    /// Variant of `Ptr::Hash` pointer type, where hash is waited message id.
+    WaitedMessageId,
 }
 
 /// Actor kind, which is actually a syscall destination choice.

diff --git a/utils/wasm-gen/src/generator/syscalls.rs b/utils/wasm-gen/src/generator/syscalls.rs
@@ -214,6 +214,9 @@ impl InvocableSyscall {
                 SyscallName::SendCommitWGas,
             ],
             SyscallName::ReplyDeposit => &[SyscallName::SendInput, SyscallName::ReplyDeposit],
+            // Enable `MessageId` syscall import if `Wake` syscall is enabled.
+            // This is done to provide a syscall `Wake` with a correct message id.
+            SyscallName::Wake => &[SyscallName::MessageId],
             _ => return None,
         })
     }

diff --git a/utils/wasm-gen/src/generator/syscalls/invocator.rs b/utils/wasm-gen/src/generator/syscalls/invocator.rs
@@ -354,6 +354,8 @@ impl<'a, 'b> SyscallsInvocator<'a, 'b> {
 
         match invocable {
             Loose(Wait | WaitFor | WaitUpTo) => {
+                self.store_waited_message_id(&mut instructions);
+
                 if let Some(waiting_probability) = self.config.waiting_probability() {
                     self.limit_infinite_waits(&mut instructions, waiting_probability.get());
                 }
@@ -674,6 +676,12 @@ impl<'a, 'b> SyscallsInvocator<'a, 'b> {
 
                 ret_instr
             }
+            PtrParamAllowedValues::WaitedMessageId => {
+                // Loads waited message id on previous `Wait`-like syscall.
+                // Check `SyscallsInvocator::store_waited_message_id` method for implementation details.
+                let memory_layout = MemoryLayout::from(self.memory_size_bytes());
+                vec![Instruction::I32Const(memory_layout.waited_message_id_ptr)]
+            }
         };
 
         Ok(ParamInstructions(ret))
@@ -823,6 +831,29 @@ impl<'a, 'b> SyscallsInvocator<'a, 'b> {
         }
     }
 
+    fn store_waited_message_id(&self, instructions: &mut Vec<Instruction>) {
+        let Some(gr_message_id_indexes_handle) = self
+            .syscalls_imports
+            .get(&InvocableSyscall::Loose(SyscallName::MessageId))
+            .map(|&(_, call_indexes_handle)| call_indexes_handle as u32)
+        else {
+            // We automatically enable the `message_id` syscall import if the `wait` syscall is enabled in the config.
+            // If not, then we don't need to store the message ID.
+            return;
+        };
+
+        let memory_layout = MemoryLayout::from(self.memory_size_bytes());
+        let start_offset = memory_layout.waited_message_id_ptr;
+
+        let message_id_call = vec![
+            // call `gsys::gr_message_id` storing message id at `start_offset` pointer.
+            Instruction::I32Const(start_offset),
+            Instruction::Call(gr_message_id_indexes_handle),
+        ];
+
+        instructions.splice(0..0, message_id_call);
+    }
+
     /// Patches instructions of wait-syscalls to prevent deadlocks.
     fn limit_infinite_waits(&self, instructions: &mut Vec<Instruction>, waiting_probability: u32) {
         let MemoryLayout {