Add support for new WASI snapshot, backwards compat too

Cargo.lock

@@ -1504,7 +1504,6 @@ dependencies = [
  "tempfile 3.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "wabt 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "wasmer-clif-backend 0.10.1",
- "wasmer-llvm-backend 0.10.1",
  "wasmer-runtime-core 0.10.1",
  "wasmer-singlepass-backend 0.10.1",
 ]

lib/wasi/Cargo.toml

@@ -21,3 +21,8 @@ wasmer-runtime-core = { path = "../runtime-core", version = "0.10.1" }
 
 [target.'cfg(windows)'.dependencies]
 winapi = "0.3"
+
+[features]
+# Enable support for the older snapshot0 WASI modules
+snapshot0 = []
+default = ["snapshot0"]

lib/wasi/src/lib.rs

@@ -37,7 +37,7 @@ use self::syscalls::*;
 use std::ffi::c_void;
 use std::path::PathBuf;
 
-pub use self::utils::is_wasi_module;
+pub use self::utils::{get_wasi_version, is_wasi_module, WasiVersion};
 
 use wasmer_runtime_core::{func, import::ImportObject, imports};
 
@@ -79,7 +79,7 @@ pub fn generate_import_object(
     imports! {
         // This generates the wasi state.
         state_gen,
-        "wasi_unstable" => {
+        "wasi_snapshot_preview1" => {
             "args_get" => func!(args_get),
             "args_sizes_get" => func!(args_sizes_get),
             "clock_res_get" => func!(clock_res_get),
@@ -128,3 +128,86 @@ pub fn generate_import_object(
         },
     }
 }
+
+#[cfg(feature = "snapshot0")]
+/// Creates a Wasi [`ImportObject`] with [`WasiState`].
+pub fn generate_import_object_snapshot0(
+    args: Vec<Vec<u8>>,
+    envs: Vec<Vec<u8>>,
+    preopened_files: Vec<PathBuf>,
+    mapped_dirs: Vec<(String, PathBuf)>,
+) -> ImportObject {
+    let state_gen = move || {
+        // TODO: look into removing all these unnecessary clones
+        fn state_destructor(data: *mut c_void) {
+            unsafe {
+                drop(Box::from_raw(data as *mut WasiState));
+            }
+        }
+        let preopened_files = preopened_files.clone();
+        let mapped_dirs = mapped_dirs.clone();
+        //let wasi_builder = create_wasi_instance();
+
+        let state = Box::new(WasiState {
+            fs: WasiFs::new(&preopened_files, &mapped_dirs).expect("Could not create WASI FS"),
+            args: args.clone(),
+            envs: envs.clone(),
+        });
+
+        (
+            Box::into_raw(state) as *mut c_void,
+            state_destructor as fn(*mut c_void),
+        )
+    };
+    imports! {
+        // This generates the wasi state.
+        state_gen,
+        "wasi_unstable" => {
+            "args_get" => func!(args_get),
+            "args_sizes_get" => func!(args_sizes_get),
+            "clock_res_get" => func!(clock_res_get),
+            "clock_time_get" => func!(clock_time_get),
+            "environ_get" => func!(environ_get),
+            "environ_sizes_get" => func!(environ_sizes_get),
+            "fd_advise" => func!(fd_advise),
+            "fd_allocate" => func!(fd_allocate),
+            "fd_close" => func!(fd_close),
+            "fd_datasync" => func!(fd_datasync),
+            "fd_fdstat_get" => func!(fd_fdstat_get),
+            "fd_fdstat_set_flags" => func!(fd_fdstat_set_flags),
+            "fd_fdstat_set_rights" => func!(fd_fdstat_set_rights),
+            "fd_filestat_get" => func!(legacy::snapshot0::fd_filestat_get),
+            "fd_filestat_set_size" => func!(fd_filestat_set_size),
+            "fd_filestat_set_times" => func!(fd_filestat_set_times),
+            "fd_pread" => func!(fd_pread),
+            "fd_prestat_get" => func!(fd_prestat_get),
+            "fd_prestat_dir_name" => func!(fd_prestat_dir_name),
+            "fd_pwrite" => func!(fd_pwrite),
+            "fd_read" => func!(fd_read),
+            "fd_readdir" => func!(fd_readdir),
+            "fd_renumber" => func!(fd_renumber),
+            "fd_seek" => func!(legacy::snapshot0::fd_seek),
+            "fd_sync" => func!(fd_sync),
+            "fd_tell" => func!(fd_tell),
+            "fd_write" => func!(fd_write),
+            "path_create_directory" => func!(path_create_directory),
+            "path_filestat_get" => func!(legacy::snapshot0::path_filestat_get),
+            "path_filestat_set_times" => func!(path_filestat_set_times),
+            "path_link" => func!(path_link),
+            "path_open" => func!(path_open),
+            "path_readlink" => func!(path_readlink),
+            "path_remove_directory" => func!(path_remove_directory),
+            "path_rename" => func!(path_rename),
+            "path_symlink" => func!(path_symlink),
+            "path_unlink_file" => func!(path_unlink_file),
+            "poll_oneoff" => func!(legacy::snapshot0::poll_oneoff),
+            "proc_exit" => func!(proc_exit),
+            "proc_raise" => func!(proc_raise),
+            "random_get" => func!(random_get),
+            "sched_yield" => func!(sched_yield),
+            "sock_recv" => func!(sock_recv),
+            "sock_send" => func!(sock_send),
+            "sock_shutdown" => func!(sock_shutdown),
+        },
+    }
+}

lib/wasi/src/syscalls/legacy/mod.rs

@@ -0,0 +1,6 @@
+//! These modules provide wrappers and implementations for older version of WASI.
+//!
+//! If you are relying on legacy WASI, please upgrade for the best experience.
+
+#[cfg(feature = "snapshot0")]
+pub mod snapshot0;

lib/wasi/src/syscalls/legacy/snapshot0.rs

@@ -0,0 +1,178 @@
+use crate::ptr::{Array, WasmPtr};
+use crate::syscalls;
+use crate::syscalls::types::{self, snapshot0};
+use wasmer_runtime_core::vm::Ctx;
+
+/// Wrapper around `syscalls::fd_filestat_get` with extra logic to handle the size
+/// difference of `wasi_filestat_t`
+///
+/// WARNING: this function involves saving, clobbering, and restoring unrelated
+/// Wasm memory.  If the memory clobbered by the current syscall is also used by
+/// that syscall, then it may break.
+pub fn fd_filestat_get(
+    ctx: &mut Ctx,
+    fd: types::__wasi_fd_t,
+    buf: WasmPtr<snapshot0::__wasi_filestat_t>,
+) -> types::__wasi_errno_t {
+    let memory = ctx.memory(0);
+
+    // transmute the WasmPtr<T1> into a WasmPtr<T2> where T2 > T1, this will read extra memory.
+    // The edge case of this causing an OOB is not handled, if the new field is OOB, then the entire
+    // memory access will fail.
+    let new_buf: WasmPtr<types::__wasi_filestat_t> = unsafe { std::mem::transmute(buf) };
+
+    // Copy the data including the extra data
+    let new_filestat_setup: types::__wasi_filestat_t =
+        wasi_try!(new_buf.deref(memory)).get().clone();
+
+    // Set up complete, make the call with the pointer that will write to the
+    // struct and some unrelated memory after the struct.
+    let result = syscalls::fd_filestat_get(ctx, fd, new_buf);
+
+    // reborrow memory
+    let memory = ctx.memory(0);
+
+    // get the values written to memory
+    let new_filestat = wasi_try!(new_buf.deref(memory)).get();
+    // translate the new struct into the old struct in host memory
+    let old_stat = snapshot0::__wasi_filestat_t {
+        st_dev: new_filestat.st_dev,
+        st_ino: new_filestat.st_ino,
+        st_filetype: new_filestat.st_filetype,
+        st_nlink: new_filestat.st_nlink as u32,
+        st_size: new_filestat.st_size,
+        st_atim: new_filestat.st_atim,
+        st_mtim: new_filestat.st_mtim,
+        st_ctim: new_filestat.st_ctim,
+    };
+
+    // write back the original values at the pointer's memory locations
+    // (including the memory unrelated to the pointer)
+    wasi_try!(new_buf.deref(memory)).set(new_filestat_setup);
+
+    // Now that this memory is back as it was, write the translated filestat
+    // into memory leaving it as it should be
+    wasi_try!(buf.deref(memory)).set(old_stat);
+
+    result
+}
+
+/// Wrapper around `syscalls::path_filestat_get` with extra logic to handle the size
+/// difference of `wasi_filestat_t`
+pub fn path_filestat_get(
+    ctx: &mut Ctx,
+    fd: types::__wasi_fd_t,
+    flags: types::__wasi_lookupflags_t,
+    path: WasmPtr<u8, Array>,
+    path_len: u32,
+    buf: WasmPtr<snapshot0::__wasi_filestat_t>,
+) -> types::__wasi_errno_t {
+    // see `fd_filestat_get` in this file for an explanation of this strange behavior
+    let memory = ctx.memory(0);
+
+    let new_buf: WasmPtr<types::__wasi_filestat_t> = unsafe { std::mem::transmute(buf) };
+    let new_filestat_setup: types::__wasi_filestat_t =
+        wasi_try!(new_buf.deref(memory)).get().clone();
+
+    let result = syscalls::path_filestat_get(ctx, fd, flags, path, path_len, new_buf);
+
+    let memory = ctx.memory(0);
+    let new_filestat = wasi_try!(new_buf.deref(memory)).get();
+    let old_stat = snapshot0::__wasi_filestat_t {
+        st_dev: new_filestat.st_dev,
+        st_ino: new_filestat.st_ino,
+        st_filetype: new_filestat.st_filetype,
+        st_nlink: new_filestat.st_nlink as u32,
+        st_size: new_filestat.st_size,
+        st_atim: new_filestat.st_atim,
+        st_mtim: new_filestat.st_mtim,
+        st_ctim: new_filestat.st_ctim,
+    };
+
+    wasi_try!(new_buf.deref(memory)).set(new_filestat_setup);
+    wasi_try!(buf.deref(memory)).set(old_stat);
+
+    result
+}
+
+/// Wrapper around `syscalls::fd_seek` with extra logic to remap the values
+/// of `__wasi_whence_t`
+pub fn fd_seek(
+    ctx: &mut Ctx,
+    fd: types::__wasi_fd_t,
+    offset: types::__wasi_filedelta_t,
+    whence: snapshot0::__wasi_whence_t,
+    newoffset: WasmPtr<types::__wasi_filesize_t>,
+) -> types::__wasi_errno_t {
+    let new_whence = match whence {
+        snapshot0::__WASI_WHENCE_CUR => types::__WASI_WHENCE_CUR,
+        snapshot0::__WASI_WHENCE_END => types::__WASI_WHENCE_END,
+        snapshot0::__WASI_WHENCE_SET => types::__WASI_WHENCE_SET,
+        // if it's invalid, let the new fd_seek handle it
+        _ => whence,
+    };
+    syscalls::fd_seek(ctx, fd, offset, new_whence, newoffset)
+}
+
+/// Wrapper around `syscalls::poll_oneoff` with extra logic to add the removed
+/// userdata field back
+pub fn poll_oneoff(
+    ctx: &mut Ctx,
+    in_: WasmPtr<snapshot0::__wasi_subscription_t, Array>,
+    out_: WasmPtr<types::__wasi_event_t, Array>,
+    nsubscriptions: u32,
+    nevents: WasmPtr<u32>,
+) -> types::__wasi_errno_t {
+    // in this case the new type is smaller than the old type, so it all fits into memory,
+    // we just need to readjust and copy it
+
+    // we start by adjusting `in_` into a format that the new code can understand
+    let memory = ctx.memory(0);
+    let mut in_origs: Vec<snapshot0::__wasi_subscription_t> = vec![];
+    for in_sub in wasi_try!(in_.deref(memory, 0, nsubscriptions)) {
+        in_origs.push(in_sub.get().clone());
+    }
+
+    // get a pointer to the smaller new type
+    let in_new_type_ptr: WasmPtr<types::__wasi_subscription_t, Array> =
+        unsafe { std::mem::transmute(in_) };
+
+    for (in_sub_new, orig) in wasi_try!(in_new_type_ptr.deref(memory, 0, nsubscriptions))
+        .iter()
+        .zip(in_origs.iter())
+    {
+        in_sub_new.set(types::__wasi_subscription_t {
+            userdata: orig.userdata,
+            type_: orig.type_,
+            u: if orig.type_ == types::__WASI_EVENTTYPE_CLOCK {
+                types::__wasi_subscription_u {
+                    clock: types::__wasi_subscription_clock_t {
+                        clock_id: unsafe { orig.u.clock.clock_id },
+                        timeout: unsafe { orig.u.clock.timeout },
+                        precision: unsafe { orig.u.clock.precision },
+                        flags: unsafe { orig.u.clock.flags },
+                    },
+                }
+            } else {
+                types::__wasi_subscription_u {
+                    fd_readwrite: unsafe { orig.u.fd_readwrite },
+                }
+            },
+        });
+    }
+
+    // make the call
+    let result = syscalls::poll_oneoff(ctx, in_new_type_ptr, out_, nsubscriptions, nevents);
+
+    // replace the old values of in, in case the calling code reuses the memory
+    let memory = ctx.memory(0);
+
+    for (in_sub, orig) in wasi_try!(in_.deref(memory, 0, nsubscriptions))
+        .iter()
+        .zip(in_origs.into_iter())
+    {
+        in_sub.set(orig);
+    }
+
+    result
+}

lib/wasi/src/syscalls/mod.rs

@@ -5,6 +5,9 @@ pub mod unix;
 #[cfg(any(target_os = "windows"))]
 pub mod windows;
 
+#[cfg(any(feature = "snapshot0"))]
+pub mod legacy;
+
 use self::types::*;
 use crate::{
     ptr::{Array, WasmPtr},

lib/wasi/src/syscalls/types.rs

@@ -416,7 +416,7 @@ pub struct __wasi_iovec_t {
 
 unsafe impl ValueType for __wasi_iovec_t {}
 
-pub type __wasi_linkcount_t = u32;
+pub type __wasi_linkcount_t = u64;
 
 pub type __wasi_lookupflags_t = u32;
 pub const __WASI_LOOKUP_SYMLINK_FOLLOW: u32 = 1 << 0;
@@ -559,7 +559,6 @@ pub const __WASI_SUBSCRIPTION_CLOCK_ABSTIME: u16 = 1 << 0;
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(C)]
 pub struct __wasi_subscription_clock_t {
-    pub userdata: __wasi_userdata_t,
     pub clock_id: __wasi_clockid_t,
     pub timeout: __wasi_timestamp_t,
     pub precision: __wasi_timestamp_t,
@@ -575,8 +574,8 @@ pub struct __wasi_subscription_fs_readwrite_t {
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub union __wasi_subscription_u {
-    clock: __wasi_subscription_clock_t,
-    fd_readwrite: __wasi_subscription_fs_readwrite_t,
+    pub clock: __wasi_subscription_clock_t,
+    pub fd_readwrite: __wasi_subscription_fs_readwrite_t,
 }
 
 #[derive(Copy, Clone)]
@@ -698,6 +697,59 @@ pub type __wasi_timestamp_t = u64;
 pub type __wasi_userdata_t = u64;
 
 pub type __wasi_whence_t = u8;
-pub const __WASI_WHENCE_CUR: u8 = 0;
-pub const __WASI_WHENCE_END: u8 = 1;
-pub const __WASI_WHENCE_SET: u8 = 2;
+pub const __WASI_WHENCE_SET: u8 = 0;
+pub const __WASI_WHENCE_CUR: u8 = 1;
+pub const __WASI_WHENCE_END: u8 = 2;
+
+pub mod snapshot0 {
+    use serde::{Deserialize, Serialize};
+    pub type __wasi_linkcount_t = u32;
+    use wasmer_runtime_core::types::ValueType;
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    #[repr(C)]
+    pub struct __wasi_subscription_clock_t {
+        pub userdata: super::__wasi_userdata_t,
+        pub clock_id: super::__wasi_clockid_t,
+        pub timeout: super::__wasi_timestamp_t,
+        pub precision: super::__wasi_timestamp_t,
+        pub flags: super::__wasi_subclockflags_t,
+    }
+
+    #[derive(Copy, Clone)]
+    #[repr(C)]
+    pub union __wasi_subscription_u {
+        pub clock: __wasi_subscription_clock_t,
+        pub fd_readwrite: super::__wasi_subscription_fs_readwrite_t,
+    }
+
+    #[derive(Copy, Clone)]
+    #[repr(C)]
+    pub struct __wasi_subscription_t {
+        pub userdata: super::__wasi_userdata_t,
+        pub type_: super::__wasi_eventtype_t,
+        pub u: __wasi_subscription_u,
+    }
+
+    unsafe impl ValueType for __wasi_subscription_t {}
+
+    pub type __wasi_whence_t = u8;
+    pub const __WASI_WHENCE_CUR: u8 = 0;
+    pub const __WASI_WHENCE_END: u8 = 1;
+    pub const __WASI_WHENCE_SET: u8 = 2;
+
+    #[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+    #[repr(C)]
+    pub struct __wasi_filestat_t {
+        pub st_dev: super::__wasi_device_t,
+        pub st_ino: super::__wasi_inode_t,
+        pub st_filetype: super::__wasi_filetype_t,
+        pub st_nlink: __wasi_linkcount_t,
+        pub st_size: super::__wasi_filesize_t,
+        pub st_atim: super::__wasi_timestamp_t,
+        pub st_mtim: super::__wasi_timestamp_t,
+        pub st_ctim: super::__wasi_timestamp_t,
+    }
+
+    unsafe impl ValueType for __wasi_filestat_t {}
+}

lib/wasi/src/utils.rs

@@ -1,18 +1,37 @@
 use wasmer_runtime_core::module::Module;
 
+#[allow(dead_code)]
 /// Check if a provided module is compiled with WASI support
 pub fn is_wasi_module(module: &Module) -> bool {
-    if module.info().imported_functions.is_empty() {
-        return false;
-    }
-    for (_, import_name) in &module.info().imported_functions {
-        let namespace = module
-            .info()
-            .namespace_table
-            .get(import_name.namespace_index);
-        if namespace != "wasi_unstable" {
-            return false;
-        }
-    }
-    true
+    get_wasi_version(module) == Some(WasiVersion::Snapshot1)
+}
+
+/// The version of WASI.  This is determined by the namespace string
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum WasiVersion {
+    /// "wasi_unstable"
+    Snapshot0,
+    /// "wasi_snapshot_preview1"
+    Snapshot1,
+}
+
+pub fn get_wasi_version(module: &Module) -> Option<WasiVersion> {
+    let mut import_iter = module
+        .info()
+        .imported_functions
+        .iter()
+        .map(|(_, import_name)| import_name.namespace_index);
+
+    // returns None if empty
+    let first = import_iter.next()?;
+    if import_iter.all(|idx| idx == first) {
+        match module.info().namespace_table.get(first) {
+            "wasi_unstable" => Some(WasiVersion::Snapshot0),
+            "wasi_snapshot_preview1" => Some(WasiVersion::Snapshot1),
+            _ => None,
+        }
+    } else {
+        // not all funcs have the same namespace: therefore it's not WASI
+        None
+    }
 }

src/bin/wasmer.rs

@@ -582,25 +582,38 @@ fn execute_wasm(options: &Run) -> Result<(), String> {
         )
         .map_err(|e| format!("{:?}", e))?;
     } else {
-        if cfg!(feature = "wasi") && wasmer_wasi::is_wasi_module(&module) {
-            let import_object = wasmer_wasi::generate_import_object(
-                if let Some(cn) = &options.command_name {
-                    [cn.clone()]
-                } else {
-                    [options.path.to_str().unwrap().to_owned()]
+        let wasi_version = wasmer_wasi::get_wasi_version(&module);
+        if cfg!(feature = "wasi") && wasi_version.is_some() {
+            let wasi_version = wasi_version.unwrap();
+            let args = if let Some(cn) = &options.command_name {
+                [cn.clone()]
+            } else {
+                [options.path.to_str().unwrap().to_owned()]
+            }
+            .iter()
+            .chain(options.args.iter())
+            .cloned()
+            .map(|arg| arg.into_bytes())
+            .collect();
+            let envs = env_vars
+                .into_iter()
+                .map(|(k, v)| format!("{}={}", k, v).into_bytes())
+                .collect();
+            let preopened_files = options.pre_opened_directories.clone();
+
+            let import_object = match wasi_version {
+                wasmer_wasi::WasiVersion::Snapshot0 => {
+                    wasmer_wasi::generate_import_object_snapshot0(
+                        args,
+                        envs,
+                        preopened_files,
+                        mapped_dirs,
+                    )
                 }
-                .iter()
-                .chain(options.args.iter())
-                .cloned()
-                .map(|arg| arg.into_bytes())
-                .collect(),
-                env_vars
-                    .into_iter()
-                    .map(|(k, v)| format!("{}={}", k, v).into_bytes())
-                    .collect(),
-                options.pre_opened_directories.clone(),
-                mapped_dirs,
-            );
+                wasmer_wasi::WasiVersion::Snapshot1 => {
+                    wasmer_wasi::generate_import_object(args, envs, preopened_files, mapped_dirs)
+                }
+            };
 
             #[allow(unused_mut)] // mut used in feature
             let mut instance = module