Support new spawn

.github/workflows/rust.yaml

@@ -16,3 +16,5 @@ jobs:
     - uses: actions/checkout@v3
     - name: Run Cargo Test
       run: cargo test
+    - name: Run Cargo clippy
+      run: cargo clippy --all

src/global_data.rs

@@ -0,0 +1,135 @@
+use crate::process_info::TxContext;
+use std::{
+    collections::HashMap,
+    ffi::c_void,
+    sync::{Mutex, MutexGuard},
+};
+
+lazy_static! {
+    static ref GLOBAL_DATA: Mutex<GlobalData> = Default::default();
+}
+static mut GLOBAL_DATA_PTR: *mut Mutex<GlobalData> = std::ptr::null_mut();
+
+#[derive(Default, PartialEq, Eq, Clone, Hash, Debug)]
+pub struct TxID(u64);
+impl From<u64> for TxID {
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+impl From<TxID> for u64 {
+    fn from(value: TxID) -> Self {
+        value.0
+    }
+}
+impl TxID {
+    fn next(&mut self) -> Self {
+        self.0 += 1;
+        self.clone()
+    }
+}
+
+#[derive(Default, PartialEq, Eq, Clone, Hash, Debug)]
+pub struct ProcID(u64);
+impl From<u64> for ProcID {
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+impl From<ProcID> for u64 {
+    fn from(value: ProcID) -> Self {
+        value.0
+    }
+}
+impl ProcID {
+    pub fn next(&mut self) -> Self {
+        let id = self.clone();
+        self.0 += 1;
+        id
+    }
+}
+
+pub struct GlobalData {
+    tx_ctx: HashMap<TxID, TxContext>,
+    tx_ctx_id_count: TxID,
+}
+impl Default for GlobalData {
+    fn default() -> Self {
+        TxContext::set_ctx_id(0.into());
+        Self {
+            tx_ctx: [(0.into(), TxContext::default())].into(),
+            tx_ctx_id_count: 1.into(),
+        }
+    }
+}
+
+impl GlobalData {
+    pub fn get() -> &'static Mutex<Self> {
+        if unsafe { GLOBAL_DATA_PTR.is_null() } {
+            &GLOBAL_DATA
+        } else {
+            unsafe { &mut *GLOBAL_DATA_PTR as &mut Mutex<Self> }
+        }
+    }
+    pub fn locked() -> MutexGuard<'static, Self> {
+        Self::get().lock().unwrap()
+    }
+    pub fn get_ptr() -> *const c_void {
+        if unsafe { GLOBAL_DATA_PTR.is_null() } {
+            let infos_ref: &Mutex<Self> = &GLOBAL_DATA;
+            infos_ref as *const Mutex<Self> as *const c_void
+        } else {
+            unsafe { GLOBAL_DATA_PTR as *const c_void }
+        }
+    }
+    pub fn set_ptr(ptr: *const c_void) {
+        unsafe {
+            GLOBAL_DATA_PTR = ptr as *mut Mutex<GlobalData>;
+        }
+    }
+
+    pub fn set_tx(&mut self, ctx: TxContext) -> TxID {
+        self.tx_ctx.insert(self.tx_ctx_id_count.next(), ctx);
+        self.tx_ctx_id_count.clone()
+    }
+    pub fn get_tx(&self, id: &TxID) -> &TxContext {
+        self.tx_ctx
+            .get(id)
+            .unwrap_or_else(|| panic!("unknow tx context: {:?}", id))
+    }
+    pub fn get_tx_mut(&mut self, id: &TxID) -> &mut TxContext {
+        self.tx_ctx
+            .get_mut(id)
+            .unwrap_or_else(|| panic!("unknow mut tx context: {:?}", id))
+    }
+}
+
+#[macro_export]
+macro_rules! get_tx {
+    ($txid:expr) => {
+        GlobalData::locked().get_tx(&$txid)
+    };
+}
+
+#[macro_export]
+macro_rules! get_tx_mut {
+    ($txid:expr) => {
+        GlobalData::locked().get_tx_mut(&$txid)
+    };
+}
+
+#[macro_export]
+macro_rules! get_proc {
+    ($txid: expr, $procid: expr) => {
+        GlobalData::locked().get_tx(&$txid).process(&$procid)
+    };
+}
+
+#[macro_export]
+macro_rules! get_cur_proc {
+    () => {
+        GlobalData::locked()
+            .get_tx(&TxContext::ctx_id())
+            .process(&Process::ctx_id())
+    };
+}

src/lib.rs

@@ -1,5 +1,15 @@
 pub mod constants;
 
+pub mod spawn;
+pub use spawn::*;
+
+mod global_data;
+mod process_info;
+mod utils;
+
+use global_data::GlobalData;
+use process_info::{Process, TxContext};
+
 #[macro_use]
 extern crate lazy_static;
 
@@ -20,7 +30,7 @@ use constants::{
 };
 use serde_derive::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::ffi::{CStr, CString};
+use std::ffi::CString;
 use std::os::raw::{c_char, c_int, c_void};
 
 #[derive(Clone, Serialize, Deserialize)]
@@ -56,7 +66,7 @@ lazy_static! {
 }
 
 fn assert_vm_version() {
-    if SETUP.vm_version != 1 {
+    if SETUP.vm_version != 1 && SETUP.vm_version != 2 {
         panic!(
             "Currently running setup vm_version({}) not support this syscall",
             SETUP.vm_version
@@ -94,45 +104,40 @@ pub extern "C" fn ckb_exec_cell(
 ) -> c_int {
     assert_vm_version();
 
-    let mut filename = None;
-    for ht in [hash_type, 0xFF] {
-        let code_hash = unsafe { std::slice::from_raw_parts(code_hash, 32) };
-        let mut buffer = vec![];
-        buffer.extend_from_slice(code_hash);
-        buffer.push(ht);
-        buffer.extend_from_slice(&offset.to_be_bytes()[..]);
-        buffer.extend_from_slice(&length.to_be_bytes()[..]);
-        let key = format!("0x{}", faster_hex::hex_string(&buffer));
-        filename = SETUP.native_binaries.get(&key);
-        if filename.is_some() {
-            break;
-        }
-    }
-    let filename = filename.expect("cannot locate native binary for ckb_exec syscall!");
+    let sim_path =
+        utils::get_simulator_path(utils::to_array(code_hash, 32), hash_type, offset, length);
+    let sim_path = sim_path.expect("cannot locate native binary for ckb_exec syscall!");
 
     match SETUP.run_type.as_ref().unwrap_or(&RunningType::Executable) {
         RunningType::Executable => {
-            let filename_cstring = CString::new(filename.as_bytes().to_vec()).unwrap();
+            let filename_cstring = CString::new(sim_path.as_bytes().to_vec()).unwrap();
             unsafe {
                 let args = argv as *const *const i8;
                 libc::execvp(filename_cstring.as_ptr(), args)
             }
         }
         RunningType::DynamicLib => {
-            use core::ffi::c_int;
-            type CkbMainFunc<'a> = libloading::Symbol<
-                'a,
-                unsafe extern "C" fn(argc: c_int, argv: *const *const i8) -> i8,
-            >;
+            use utils::CkbNativeSimulator;
 
-            unsafe {
-                let lib = libloading::Library::new(filename).expect("Load library");
-                let func: CkbMainFunc = lib
-                    .get(b"__ckb_std_main")
-                    .expect("load function : __ckb_std_main");
-                let args = argv as *const *const i8;
-                std::process::exit(func(argc, args).into())
-            }
+            let tx_ctx_id = GlobalData::locked().set_tx(process_info::TxContext::default());
+            TxContext::set_ctx_id(tx_ctx_id.clone());
+
+            let sim = CkbNativeSimulator::new_by_hash(code_hash, hash_type, offset, length);
+            let args = utils::to_vec_args(argc, argv as *const *const i8);
+
+            let t = std::thread::spawn(move || {
+                let proc_id = get_tx_mut!(&tx_ctx_id).new_process(None, &[]);
+
+                Process::set_ctx_id(proc_id.clone());
+                TxContext::set_ctx_id(tx_ctx_id.clone());
+
+                sim.update_script_info(tx_ctx_id.clone(), proc_id.clone());
+
+                sim.ckb_std_main(args)
+                // get_cur_proc!().notify();
+            });
+
+            t.join().expect("exec dylib") as c_int
         }
     }
 }
@@ -165,7 +170,7 @@ pub extern "C" fn ckb_load_script(ptr: *mut c_void, len: *mut u64, offset: u64)
 
 #[no_mangle]
 pub extern "C" fn ckb_debug(s: *const c_char) {
-    let message = unsafe { CStr::from_ptr(s) }.to_str().expect("UTF8 error!");
+    let message = utils::to_c_str(s).to_str().expect("UTF8 error!");
     println!("Debug message: {}", message);
 }
 
@@ -378,6 +383,29 @@ extern "C" {
     ) -> c_int;
 }
 
+// TO fix clippy error: clippy::not_unsafe_ptr_arg_deref
+fn rs_simulator_internal_dlopen2(
+    native_library_path: *const u8,
+    code: *const u8,
+    length: u64,
+    aligned_addr: *mut u8,
+    aligned_size: u64,
+    handle: *mut *mut c_void,
+    consumed_size: *mut u64,
+) -> c_int {
+    unsafe {
+        simulator_internal_dlopen2(
+            native_library_path,
+            code,
+            length,
+            aligned_addr,
+            aligned_size,
+            handle,
+            consumed_size,
+        )
+    }
+}
+
 #[no_mangle]
 pub extern "C" fn ckb_dlopen2(
     dep_cell_hash: *const u8,
@@ -387,7 +415,7 @@ pub extern "C" fn ckb_dlopen2(
     handle: *mut *mut c_void,
     consumed_size: *mut u64,
 ) -> c_int {
-    let dep_cell_hash = unsafe { std::slice::from_raw_parts(dep_cell_hash, 32) };
+    let dep_cell_hash = utils::to_array(dep_cell_hash, 32);
     let mut buffer = vec![];
     buffer.extend_from_slice(dep_cell_hash);
     buffer.push(hash_type);
@@ -414,17 +442,22 @@ pub extern "C" fn ckb_dlopen2(
         })
         .expect("cannot locate cell dep");
     let cell_data = cell_dep.data.as_ref();
-    unsafe {
-        simulator_internal_dlopen2(
-            filename.as_str().as_ptr(),
-            cell_data.as_ptr(),
-            cell_data.len() as u64,
-            aligned_addr,
-            aligned_size,
-            handle,
-            consumed_size,
-        )
-    }
+    rs_simulator_internal_dlopen2(
+        filename.as_str().as_ptr(),
+        cell_data.as_ptr(),
+        cell_data.len() as u64,
+        aligned_addr,
+        aligned_size,
+        handle,
+        consumed_size,
+    )
+}
+
+#[no_mangle]
+pub extern "C" fn set_script_info(ptr: *const std::ffi::c_void, tx_ctx_id: u64, proc_ctx_id: u64) {
+    GlobalData::set_ptr(ptr);
+    TxContext::set_ctx_id(tx_ctx_id.into());
+    Process::set_ctx_id(proc_ctx_id.into());
 }
 
 fn fetch_cell(index: u64, source: u64) -> Result<(CellOutput, Bytes), c_int> {