Support for the WASI ABI.

Cargo.toml

@@ -28,9 +28,10 @@ wasmer-runtime-core = { path = "lib/runtime-core" }
 wasmer-emscripten = { path = "lib/emscripten" }
 wasmer-llvm-backend = { path = "lib/llvm-backend", optional = true }
 wasmer-dynasm-backend = { path = "lib/dynasm-backend", optional = true }
+wasmer-wasi = { path = "lib/wasi", optional = true }
 
 [workspace]
-members = ["lib/clif-backend", "lib/dynasm-backend", "lib/runtime", "lib/runtime-core", "lib/emscripten", "lib/spectests", "lib/win-exception-handler", "lib/runtime-c-api", "lib/llvm-backend"]
+members = ["lib/clif-backend", "lib/dynasm-backend", "lib/runtime", "lib/runtime-core", "lib/emscripten", "lib/spectests", "lib/win-exception-handler", "lib/runtime-c-api", "lib/llvm-backend", "lib/wasi"]
 
 [build-dependencies]
 wabt = "0.7.2"
@@ -42,4 +43,5 @@ default = ["fast-tests"]
 # This feature will allow cargo test to run much faster
 fast-tests = []
 llvm = ["wasmer-llvm-backend"]
-dynasm = ["wasmer-dynasm-backend"]
+dynasm = ["wasmer-dynasm-backend"]
+wasi = ["wasmer-wasi"]

lib/runtime-core/src/import.rs

@@ -3,6 +3,7 @@ use hashbrown::{hash_map::Entry, HashMap};
 use std::collections::VecDeque;
 use std::{
     cell::{Ref, RefCell},
+    ffi::c_void,
     rc::Rc,
 };
 
@@ -45,16 +46,32 @@ impl IsExport for Export {
 /// ```
 pub struct ImportObject {
     map: Rc<RefCell<HashMap<String, Box<dyn LikeNamespace>>>>,
+    state_creator: Option<Rc<Fn() -> (*mut c_void, fn(*mut c_void))>>,
 }
 
 impl ImportObject {
     /// Create a new `ImportObject`.  
     pub fn new() -> Self {
         Self {
             map: Rc::new(RefCell::new(HashMap::new())),
+            state_creator: None,
         }
     }
 
+    pub fn new_with_data<F>(state_creator: F) -> Self
+    where
+        F: Fn() -> (*mut c_void, fn(*mut c_void)) + 'static,
+    {
+        Self {
+            map: Rc::new(RefCell::new(HashMap::new())),
+            state_creator: Some(Rc::new(state_creator)),
+        }
+    }
+
+    pub(crate) fn call_state_creator(&self) -> Option<(*mut c_void, fn(*mut c_void))> {
+        self.state_creator.as_ref().map(|state_gen| state_gen())
+    }
+
     /// Register anything that implements `LikeNamespace` as a namespace.
     ///
     /// # Usage:
@@ -98,6 +115,7 @@ impl ImportObject {
     pub fn clone_ref(&self) -> Self {
         Self {
             map: Rc::clone(&self.map),
+            state_creator: self.state_creator.clone(),
         }
     }
 

lib/runtime-core/src/instance.rs

@@ -63,7 +63,16 @@ impl Instance {
         // Initialize the vm::Ctx in-place after the backing
         // has been boxed.
         unsafe {
-            *inner.vmctx = vm::Ctx::new(&mut inner.backing, &mut inner.import_backing, &module)
+            *inner.vmctx = match imports.call_state_creator() {
+                Some((data, dtor)) => vm::Ctx::new_with_data(
+                    &mut inner.backing,
+                    &mut inner.import_backing,
+                    &module,
+                    data,
+                    dtor,
+                ),
+                None => vm::Ctx::new(&mut inner.backing, &mut inner.import_backing, &module),
+            };
         };
 
         let instance = Instance {

lib/runtime-core/src/macros.rs

@@ -38,6 +38,13 @@ macro_rules! func {
 ///     },
 /// };
 ///
+/// let imports_with_state = imports! {
+///     || (0 as _, |_a| {}),
+///     "env" => {
+///         "foo" => func!(foo),
+///     },
+/// };
+///
 /// fn foo(_: &mut Ctx, n: i32) -> i32 {
 ///     n
 /// }
@@ -57,6 +64,21 @@ macro_rules! imports {
             import_object.register($ns_name, ns);
         })*
 
+        import_object
+    }};
+    ($state_gen:expr, $( $ns_name:expr => $ns:tt, )* ) => {{
+        use $crate::{
+            import::{ImportObject, Namespace},
+        };
+
+        let mut import_object = ImportObject::new_with_data($state_gen);
+
+        $({
+            let ns = $crate::__imports_internal!($ns);
+
+            import_object.register($ns_name, ns);
+        })*
+
         import_object
     }};
 }

lib/runtime-core/src/vm.rs

@@ -25,7 +25,7 @@ pub struct Ctx {
     module: *const ModuleInner,
 
     pub data: *mut c_void,
-    pub data_finalizer: Option<extern "C" fn(data: *mut c_void)>,
+    pub data_finalizer: Option<fn(data: *mut c_void)>,
 }
 
 /// The internal context of the currently running WebAssembly instance.
@@ -100,7 +100,7 @@ impl Ctx {
         import_backing: &mut ImportBacking,
         module: &ModuleInner,
         data: *mut c_void,
-        data_finalizer: extern "C" fn(*mut c_void),
+        data_finalizer: fn(*mut c_void),
     ) -> Self {
         Self {
             internal: InternalCtx {
@@ -481,7 +481,7 @@ mod vm_ctx_tests {
         str: String,
     }
 
-    extern "C" fn test_data_finalizer(data: *mut c_void) {
+    fn test_data_finalizer(data: *mut c_void) {
         let test_data: &mut TestData = unsafe { &mut *(data as *mut TestData) };
         assert_eq!(test_data.x, 10);
         assert_eq!(test_data.y, true);

lib/wasi/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "wasmer-wasi"
+version = "0.1.0"
+authors = ["The Wasmer Engineering Team <engineering@wasmer.io>"]
+edition = "2018"
+
+[dependencies]
+wasmer-runtime-core = { path = "../runtime-core", version = "0.2.1" }

lib/wasi/src/lib.rs

@@ -0,0 +1,83 @@
+mod state;
+mod syscalls;
+mod utils;
+
+use self::state::WasiState;
+use self::syscalls::*;
+
+use std::ffi::c_void;
+
+pub use self::utils::is_wasi_module;
+
+use wasmer_runtime_core::{func, import::ImportObject, imports};
+
+pub fn generate_import_object(args: Vec<Vec<u8>>, envs: Vec<Vec<u8>>) -> ImportObject {
+    let state_gen = move || {
+        fn state_dtor(data: *mut c_void) {
+            unsafe {
+                drop(Box::from_raw(data as *mut WasiState));
+            }
+        }
+
+        let state = Box::new(WasiState {
+            args: &args[..],
+            envs: &envs[..],
+        });
+
+        (
+            Box::leak(state) as *mut WasiState as *mut c_void,
+            state_dtor as fn(*mut c_void),
+        )
+    };
+    imports! {
+        // This generates the wasi state.
+        state_gen,
+        "wasi_unstable" => {
+            "__wasi_args_get" => func!(__wasi_args_get),
+            "__wasi_args_sizes_get" => func!(__wasi_args_sizes_get),
+            "__wasi_clock_res_get" => func!(__wasi_clock_res_get),
+            "__wasi_clock_time_get" => func!(__wasi_clock_time_get),
+            "__wasi_environ_get" => func!(__wasi_environ_get),
+            "__wasi_environ_sizes_get" => func!(__wasi_environ_sizes_get),
+            "__wasi_fd_advise" => func!(__wasi_fd_advise),
+            "__wasi_fd_allocate" => func!(__wasi_fd_allocate),
+            "__wasi_fd_close" => func!(__wasi_fd_close),
+            "__wasi_fd_datasync" => func!(__wasi_fd_datasync),
+            "__wasi_fd_fdstat_get" => func!(__wasi_fd_fdstat_get),
+            "__wasi_fd_fdstat_set_flags" => func!(__wasi_fd_fdstat_set_flags),
+            "__wasi_fd_fdstat_set_rights" => func!(__wasi_fd_fdstat_set_rights),
+            "__wasi_fd_filestat_get" => func!(__wasi_fd_filestat_get),
+            "__wasi_fd_filestat_set_size" => func!(__wasi_fd_filestat_set_size),
+            "__wasi_fd_filestat_set_times" => func!(__wasi_fd_filestat_set_times),
+            "__wasi_fd_pread" => func!(__wasi_fd_pread),
+            "__wasi_fd_prestat_get" => func!(__wasi_fd_prestat_get),
+            "__wasi_fd_prestat_dir_name" => func!(__wasi_fd_prestat_dir_name),
+            "__wasi_fd_pwrite" => func!(__wasi_fd_pwrite),
+            "__wasi_fd_read" => func!(__wasi_fd_read),
+            "__wasi_fd_readdir" => func!(__wasi_fd_readdir),
+            "__wasi_fd_renumber" => func!(__wasi_fd_renumber),
+            "__wasi_fd_seek" => func!(__wasi_fd_seek),
+            "__wasi_fd_sync" => func!(__wasi_fd_sync),
+            "__wasi_fd_tell" => func!(__wasi_fd_tell),
+            "__wasi_fd_write" => func!(__wasi_fd_write),
+            "__wasi_path_create_directory" => func!(__wasi_path_create_directory),
+            "__wasi_path_filestat_get" => func!(__wasi_path_filestat_get),
+            "__wasi_path_filestat_set_times" => func!(__wasi_path_filestat_set_times),
+            "__wasi_path_link" => func!(__wasi_path_link),
+            "__wasi_path_open" => func!(__wasi_path_open),
+            "__wasi_path_readlink" => func!(__wasi_path_readlink),
+            "__wasi_path_remove_directory" => func!(__wasi_path_remove_directory),
+            "__wasi_path_rename" => func!(__wasi_path_rename),
+            "__wasi_path_symlink" => func!(__wasi_path_symlink),
+            "__wasi_path_unlink_file" => func!(__wasi_path_unlink_file),
+            "__wasi_poll_oneoff" => func!(__wasi_poll_oneoff),
+            "__wasi_proc_exit" => func!(__wasi_proc_exit),
+            "__wasi_proc_raise" => func!(__wasi_proc_raise),
+            "__wasi_random_get" => func!(__wasi_random_get),
+            "__wasi_sched_yield" => func!(__wasi_sched_yield),
+            "__wasi_sock_recv" => func!(__wasi_sock_recv),
+            "__wasi_sock_send" => func!(__wasi_sock_send),
+            "__wasi_sock_shutdown" => func!(__wasi_sock_shutdown),
+        },
+    }
+}

lib/wasi/src/state.rs

@@ -0,0 +1,5 @@
+pub struct WasiState<'a> {
+    // vfs: Vfs,
+    pub args: &'a [Vec<u8>],
+    pub envs: &'a [Vec<u8>],
+}