dlopen support for fork and thread (#1037)

* fix dlopen in child process

* apply format

* fix symbol scope for linker

* sync up dlopen-ed libraryes across fork

* sync dlopen across thread creation

* refactor global snapshots

* remove redundent code

* clean up

* add double fork dlopen test

* refactor instance name

* add debug panic for same module name

* update skip_test_cases.txt

* update comment

* enforce debug panic on dlopen in multithread

* replace module.name().unwrap() with lind_debug_panic

Author: qianxichen233

skip_test_cases.txt

@@ -3,7 +3,11 @@ signal_tests/deterministic/signal_int_thread.c
 signal_tests/deterministic/signal_longjmp.c
 signal_tests/deterministic/signal_nodefer.c
 memory_tests/deterministic/tcache_test.c
-dylink_tests/deterministic/main.c
 dylink_tests/deterministic/lib.c
+dylink_tests/deterministic/basic.c
+dylink_tests/deterministic/dlopen_fork.c
+dylink_tests/deterministic/dlopen_thread.c
+dylink_tests/deterministic/double_fork_dlopen.c
+dylink_tests/deterministic/fork_dlopen.c
 ci/deterministic/ci_intentional_failure_tmp.c
 concurrent-request/thread_race_grate.c

src/lind-boot/src/lind_wasmtime/execute.rs

@@ -12,6 +12,7 @@ use sysdefs::constants::lind_platform_const::{INSTANCE_NUMBER, RAWPOSIX_CAGEID,
 use sysdefs::constants::{
     DEFAULT_STACKSIZE, DylinkErrorCode, GUARD_SIZE, LINDFS_ROOT, TABLE_START_INDEX,
 };
+use sysdefs::logging::lind_debug_panic;
 use threei::threei_const;
 use wasmtime::{
     AsContextMut, Engine, Export, Func, InstantiateType, Linker, Module, Precompiled, SharedMemory,
@@ -231,6 +232,7 @@ pub fn execute_with_lind(
     attach_api(
         &mut wstore,
         &mut linker,
+        dylink_metadata.got.clone(),
         &modules,
         lind_manager.clone(),
         lind_boot.clone(),
@@ -454,6 +456,7 @@ fn register_wasmtime_syscall_entry() -> bool {
 fn attach_api(
     wstore: &mut Store<HostCtx>,
     mut linker: &mut Arc<Mutex<Linker<HostCtx>>>,
+    got_table: Option<Arc<Mutex<LindGOT>>>,
     modules: &Vec<(String, String, Module)>,
     lind_manager: Arc<LindCageManager>,
     lindboot_cli: CliOptions,
@@ -464,23 +467,22 @@ fn attach_api(
     // (syscall dispatch, debug, signals, and argv/environ) to the linker.
     wstore.data_mut().lind_environ = Some(LindEnviron::new(&lindboot_cli.args, &lindboot_cli.vars));
 
-    // cloning the reference to the same linker and got
-    // later when dlopen is invoked, same linker and got instance can be used for instantiate the new library
+    // Build a dynamic loader closure that reads the current cage's linker and GOT
+    // at dlopen call time. This ensures the correct per-cage linker is used
+    // rather than a snapshot captured at cage creation.
     let dynamic_loader = {
         if dylink_metadata.dylink_enabled {
-            let cloned_linker = linker.clone();
-            let lind_got = dylink_metadata.got.as_ref().unwrap();
-            let cloned_got = lind_got.clone();
             let dynamic_loader: DynamicLoader<HostCtx> =
                 Arc::new(move |caller, cageid, library_name, mode| {
-                    load_library_module(
-                        caller,
-                        cloned_linker.clone(),
-                        cloned_got.clone(),
-                        cageid,
-                        library_name,
-                        mode,
-                    )
+                    let lind_ctx = caller.data().lind_fork_ctx.as_ref().unwrap();
+                    let linker = lind_ctx.linker.clone().unwrap();
+                    let got_table = lind_ctx.got_table.clone().unwrap();
+
+                    if lind_ctx.had_threads() {
+                        lind_debug_panic("dlopen within threads is currently not supported!");
+                    }
+
+                    load_library_module(caller, linker, got_table, cageid, library_name, mode)
                 });
             Some(dynamic_loader)
         } else {
@@ -508,6 +510,7 @@ fn attach_api(
     let _ = wstore.data_mut().lind_fork_ctx = Some(LindCtx::new(
         modules.clone(),
         linker_guard.clone(),
+        got_table,
         lind_manager.clone(),
         lindboot_cli.clone(),
         cageid,
@@ -565,6 +568,13 @@ fn load_main_module(
         .context(format!("failed to instantiate"))?;
     drop(linker);
 
+    // Register the main module so get_global_snapshot can find it by name.
+    if let Some(name) = module.name() {
+        store
+            .as_context_mut()
+            .register_named_instance(name.to_string(), cage_instanceid);
+    }
+
     // If `_initialize` is present, meaning a reactor, then invoke
     // the function.
     if let Some(func) = instance.get_func(&mut *store, "_initialize") {
@@ -711,7 +721,7 @@ fn load_main_module(
 /// which is used by dlsym symbol lookup
 fn load_library_module(
     mut main_module: &mut wasmtime::Caller<HostCtx>,
-    mut main_linker: Arc<Mutex<Linker<HostCtx>>>,
+    mut linker: Linker<HostCtx>,
     mut lind_got: Arc<Mutex<LindGOT>>,
     cageid: i32,
     library_name: &str,
@@ -758,7 +768,6 @@ fn load_library_module(
 
     // Grow the shared function table to reserve space for this library's
     // function entries, as declared in its dylink section.
-    let mut linker = main_linker.lock().unwrap();
     let mut got_guard = lind_got.lock().unwrap();
 
     // Install placeholder GOT globals for this library's imports.
@@ -773,7 +782,7 @@ fn load_library_module(
     // the library's function references can be relocated correctly.
     //
     // The GOT is used to patch symbol addresses/indices after instantiation.
-    match linker.module_with_caller(
+    let ret = match linker.module_with_caller(
         &mut main_module,
         cageid as u64,
         library_name,
@@ -789,7 +798,13 @@ fn load_library_module(
             println!("failed to process library `{}`", library_name);
             -(DylinkErrorCode::EINTERNAL as i32) // consider as internal error for now
         }
-    }
+    };
+
+    let lind_ctx = main_module.data_mut().lind_fork_ctx.as_mut().unwrap();
+    lind_ctx.attach_linker(linker);
+    lind_ctx.append_module(library_name.to_string(), lib_module);
+
+    ret
 }
 
 /// AOT-compile a `.wasm` file to a `.cwasm` artifact on disk.