Implement load data as code in syscall tracer

ckb-vm-fuzzing-utils/src/lib.rs

@@ -9,8 +9,8 @@ use ckb_std::{
     syscalls::traits::{Error, IoResult, SyscallImpls},
 };
 use ckb_vm::{
-    Error as VMError, Memory, Register, SupportMachine, Syscalls,
-    memory::load_c_string_byte_by_byte,
+    Error as VMError, Memory, RISCV_PAGESIZE, Register, SupportMachine, Syscalls,
+    memory::{FLAG_EXECUTABLE, FLAG_FREEZED, load_c_string_byte_by_byte},
     registers::{A0, A1, A2, A3, A4, A5, A7},
 };
 use core::ffi::CStr;
@@ -177,13 +177,29 @@ where
                 impls.load_input_by_field(buf, offset, index, source, field)
             })?,
             SyscallCode::LoadCellDataAsCode => {
-                let addr = machine.registers()[A0].to_u64() as *mut u8;
-                let memory_size = machine.registers()[A1].to_u64() as usize;
+                let addr = machine.registers()[A0].to_u64();
+                let memory_size = machine.registers()[A1].to_u64();
                 let content_offset = machine.registers()[A2].to_u64() as usize;
                 let content_size = machine.registers()[A3].to_u64() as usize;
                 let index = machine.registers()[A4].to_u64() as usize;
                 let source = machine.registers()[A5].to_u64().try_into().expect("parse source");
-                let result = self.impls.load_cell_code(addr, memory_size, content_offset, content_size, index, source);
+
+                let mut buf = vec![0u8; memory_size as usize];
+                let result = self.impls.load_cell_code(
+                    buf.as_mut_ptr() as *mut u8,
+                    memory_size as usize,
+                    content_offset,
+                    content_size,
+                    index,
+                    source,
+                );
+                machine.memory_mut().store_bytes(addr, &buf)?;
+                let mut current_addr = addr;
+                while current_addr < addr + memory_size {
+                    let page = current_addr / RISCV_PAGESIZE as u64;
+                    machine.memory_mut().set_flag(page, FLAG_EXECUTABLE | FLAG_FREEZED)?;
+                    current_addr += RISCV_PAGESIZE as u64;
+                }
                 self.set_return(result, machine);
             }
             SyscallCode::LoadCellData => self.load_ois(machine, |buf, impls, offset, index, source| {

ckb-vm-syscall-tracer/protos/traces.proto

@@ -8,6 +8,10 @@ message IoData {
   uint64 additional_length = 2;
 }
 
+message IoDataAsCode {
+  bytes available_data = 1;
+}
+
 message Fds {
   repeated uint64 fds = 1;
 }
@@ -30,8 +34,9 @@ message Syscall {
     // 2) split them into 3 different fields.
     uint64 success_output_data = 2;
     IoData io_data = 3;
-    Terminated terminated = 4;
-    Fds fds = 5;
+    IoDataAsCode io_data_as_code = 4;
+    Terminated terminated = 5;
+    Fds fds = 6;
   }
 }
 

ckb-vm-syscall-tracer/src/lib.rs

@@ -568,6 +568,7 @@ impl<M: SupportMachine> Syscalls<M> for SyscallBasedCollectorVMSyscalls<M> {
 enum PartialSyscallContent {
     ReturnWithCode,
     IoData { data_addr: u64, input_length: u64 },
+    IoDataAsCode { data_addr: u64, input_length: u64 },
     Exec { args: Vec<Vec<u8>> },
     Spawn { args: Vec<Vec<u8>> },
     Wait,
@@ -600,7 +601,9 @@ fn build_partial_content<M: SupportMachine>(machine: &mut M) -> Result<Option<Pa
                 PartialSyscallContent::IoData { data_addr, input_length }
             }
             SyscallCode::LoadCellDataAsCode => {
-                panic!("Load cell data as code syscall is not supported!");
+                let data_addr = machine.registers()[A0].to_u64();
+                let input_length = machine.registers()[A1].to_u64();
+                PartialSyscallContent::IoDataAsCode { data_addr, input_length }
             }
             SyscallCode::VmVersion => PartialSyscallContent::ReturnWithCode,
             SyscallCode::CurrentCycles => PartialSyscallContent::ReturnWithCode,
@@ -663,6 +666,18 @@ fn apply_partial_content<M: SupportMachine>(
                 })),
             }
         }
+        PartialSyscallContent::IoDataAsCode { data_addr, input_length } => {
+            let return_code = machine.registers()[A0].to_i64();
+            if return_code != 0 {
+                return return_syscall(return_code);
+            }
+            let data = machine.memory_mut().load_bytes(*data_addr, *input_length)?;
+            traces::Syscall {
+                value: Some(traces::syscall::Value::IoDataAsCode(traces::IoDataAsCode {
+                    available_data: data.as_ref().to_vec(),
+                })),
+            }
+        }
         PartialSyscallContent::Exec { .. } => {
             let return_code = machine.registers()[A0].to_i64();
             if return_code != 0 {

protobuf-ckb-syscalls/src/lib.rs

@@ -175,14 +175,28 @@ impl SyscallImpls for ProtobufBasedSyscallImpls {
 
     fn load_cell_code(
         &self,
-        _buf_ptr: *mut u8,
-        _len: usize,
+        buf_ptr: *mut u8,
+        len: usize,
         _content_offset: usize,
         _content_size: usize,
         _index: usize,
         _source: Source,
     ) -> Result<(), Error> {
-        panic!("Load cell data as code is not suported!");
+        match self.syscall() {
+            Some(traces::syscall::Value::ReturnWithCode(code)) => {
+                if code != 0 {
+                    return Err(Error::try_from(code as u64).unwrap());
+                }
+                Ok(())
+            }
+            Some(traces::syscall::Value::IoDataAsCode(io_data_as_code)) => {
+                unsafe {
+                    std::ptr::copy_nonoverlapping(io_data_as_code.available_data.as_ptr(), buf_ptr, len);
+                }
+                Ok(())
+            }
+            _ => unreachable!(),
+        }
     }
 
     fn load_cell_data(&self, buf: &mut [u8], offset: usize, _index: usize, _source: Source) -> IoResult {