Dash fixes and pthreads

lib/types/src/memory.rs

@@ -70,11 +70,13 @@ pub unsafe trait MemorySize: Copy {
         + TryFrom<u32>
         + TryFrom<u16>
         + TryFrom<u8>
+        + TryFrom<i32>
         + TryInto<usize>
         + TryInto<u64>
         + TryInto<u32>
         + TryInto<u16>
         + TryInto<u8>
+        + TryInto<i32>
         + TryFrom<usize>
         + Add<Self::Offset>
         + Sum<Self::Offset>

lib/wasi-types/Cargo.toml

@@ -28,6 +28,7 @@ cfg-if = "1.0.0"
 anyhow = "1.0.66"
 byteorder = "1.3"
 time = "0.2"
+tracing = "0.1"
 
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"

lib/wasi-types/schema/wasi/typenames.wit

@@ -8,6 +8,7 @@
 ///
 /// Note: This is similar to `size_t` in POSIX.
 // TODO: This is defined as `usize` in the original witx file. Should verify that this type is good as it is defined here
+// TODO: This is not good as it breaks 64bit builds - it will need to be externalized
 type size = u32
 
 /// Non-negative file size or length of a region within a file.
@@ -247,6 +248,10 @@ enum errno {
     notcapable,
     /// Cannot send after socket shutdown.
     shutdown,
+    /// Memory access violation.
+    memviolation,
+    /// An unknown error has occured
+    unknown,
 }
 
 enum bus-errno {
@@ -813,12 +818,17 @@ record option-cid {
     cid: cid
 }
 
+record option-pid {
+    tag: option-tag,
+    pid: pid
+}
+
 record option-fd {
     tag: option-tag,
     fd: fd
 }
 
-type exit-code = u32
+type exit-code = errno
 
 type event-fd-flags = u16
 
@@ -1132,6 +1142,7 @@ record option-timestamp {
 }
 
 enum signal {
+    sigunknown,
     sighup,
     sigint,
     sigquit,
@@ -1147,6 +1158,7 @@ enum signal {
     sigpipe,
     sigalrm,
     sigterm,
+    sigstkflt,
     sigchld,
     sigcont,
     sigstop,
@@ -1205,3 +1217,64 @@ enum timeout {
     connect,
     accept,
 }
+
+/// join flags.
+flags join-flags {
+    /// Non-blocking join on the process
+    non-blocking,
+    /// Return if a process is stopped
+    wake-stopped
+}
+
+/// What has happened with the proccess when we joined on it
+enum join-status-type {
+    /// Nothing has happened
+    nothing,
+    /// The process has exited by a normal exit code
+    exit-normal,
+    /// The process was terminated by a signal
+    exit-signal,
+    /// The process was stopped by a signal and can be resumed with SIGCONT
+    stopped
+}
+
+/// Represents an errno and a signal
+record errno-signal {
+    /// The exit code that was returned
+    exit-code: errno,
+    /// The signal that was returned
+    signal: signal
+}
+
+/// The contents of an `event`.
+variant join-status {
+   // TODO: wit appears to not have support for tag type
+   //(@witx tag $join_status_type)
+   nothing(u8),
+   exit-normal(errno),
+   exit-signal(errno-signal),
+   stopped(signal)
+}
+
+/// thread state flags
+flags thread-state-flags {
+    // TODO: wit doesnt appear to support repr
+    // flags (@witx repr u16)
+
+    // tsd_used
+    tsd-used,
+    // dlerror_flag
+    dlerror-flag
+}
+
+/// Represents the thread start object
+record thread-start {
+    // Address where the stack starts
+    stack: size,
+    // Address where the TLS starts
+    tls-base: size,
+    // Function that will be invoked when the thread starts
+    start-funct: size,
+    // Arguments to pass the callback function
+    start-args: size,
+}

lib/wasi-types/src/wasi/bindings_manual.rs

@@ -359,3 +359,20 @@ impl From<std::io::Error> for Errno {
         }
     }
 }
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl wasmer::FromToNativeWasmType for JoinFlags {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self.bits() as i32
+    }
+    fn from_native(n: Self::Native) -> Self {
+        Self::from_bits_truncate(n as u32)
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        // TODO: find correct implementation
+        false
+    }
+}

lib/wasi-types/src/wasi/wasix_manual.rs

@@ -1,10 +1,10 @@
 use std::mem::MaybeUninit;
 
-use wasmer::ValueType;
+use wasmer::{MemorySize, ValueType};
 
 use super::{
-    Errno, EventFdReadwrite, Eventtype, Snapshot0SubscriptionClock, SubscriptionClock,
-    SubscriptionFsReadwrite, Userdata,
+    Errno, ErrnoSignal, EventFdReadwrite, Eventtype, JoinStatusType, Signal,
+    Snapshot0SubscriptionClock, SubscriptionClock, SubscriptionFsReadwrite, Userdata,
 };
 
 /// Thread local key
@@ -175,3 +175,68 @@ unsafe impl ValueType for StackSnapshot {
     #[inline]
     fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
 }
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union JoinStatusUnion {
+    pub nothing: u8,
+    pub exit_normal: Errno,
+    pub exit_signal: ErrnoSignal,
+    pub stopped: Signal,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct JoinStatus {
+    pub tag: JoinStatusType,
+    pub u: JoinStatusUnion,
+}
+impl core::fmt::Debug for JoinStatus {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let mut binding = f.debug_struct("JoinStatus");
+        let mut f = binding.field("tag", &self.tag);
+        f = unsafe {
+            match self.tag {
+                JoinStatusType::Nothing => f.field("pid", &self.u.nothing),
+                JoinStatusType::ExitNormal => f.field("exit_normal", &self.u.exit_normal),
+                JoinStatusType::ExitSignal => f.field("exit_signal", &self.u.exit_signal),
+                JoinStatusType::Stopped => f.field("stopped", &self.u.stopped),
+            }
+        };
+        f.finish()
+    }
+}
+unsafe impl ValueType for JoinStatus {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+#[doc = " Represents the thread start object"]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ThreadStart<M: MemorySize> {
+    pub stack_start: M::Offset,
+    pub tls_base: M::Offset,
+    pub start_funct: M::Offset,
+    pub start_args: M::Offset,
+    pub reserved: [M::Offset; 10],
+    pub stack_size: M::Offset,
+    pub guard_size: M::Offset,
+}
+impl<M: MemorySize> core::fmt::Debug for ThreadStart<M> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("ThreadStart")
+            .field("stack_start", &self.stack_start)
+            .field("tls-base", &self.tls_base)
+            .field("start-funct", &self.start_funct)
+            .field("start-args", &self.start_args)
+            .field("stack_size", &self.stack_size)
+            .field("guard_size", &self.guard_size)
+            .finish()
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl<M: MemorySize> ValueType for ThreadStart<M> {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}

lib/wasi/Cargo.toml

@@ -102,7 +102,7 @@ webc_runner_rt_wcgi = ["hyper", "wcgi", "wcgi-host"]
 webc_runner_rt_emscripten = ["wasmer-emscripten"]
 
 sys = ["wasmer/sys", "wasmer-wasi-types/sys", "webc/mmap", "wasmer-vm", "time"]
-sys-default = ["wasmer/wat", "wasmer/compiler", "sys", "logging", "host-fs", "sys-poll", "sys-thread", "host-vnet", "host-threads", "host-reqwest" ]
+sys-default = ["wasmer/wat", "wasmer/compiler", "sys", "logging", "host-fs", "sys-poll", "sys-thread", "host-vnet", "host-threads", "host-reqwest", "host-termios" ]
 sys-poll = []
 sys-thread = ["tokio/rt", "tokio/time", "tokio/rt-multi-thread"]
 

lib/wasi/src/bin_factory/exec.rs

@@ -166,17 +166,17 @@ pub fn spawn_exec_module(
                     start
                         .call(&mut store, &[])
                         .map_err(WasiRuntimeError::from)
-                        .map(|_| 0)
+                        .map(|_| Errno::Success)
                 } else {
                     debug!("wasi[{}]::exec-failed: missing _start function", pid);
-                    Ok(Errno::Noexec as u32)
+                    Ok(Errno::Noexec)
                 };
                 debug!("wasi[{pid}]::main() has exited with {ret:?}");
 
                 let code = if let Err(err) = &ret {
-                    err.as_exit_code().unwrap_or(Errno::Child as u32)
+                    err.as_exit_code().unwrap_or(Errno::Child)
                 } else {
-                    0
+                    Errno::Success
                 };
                 thread.thread.set_status_finished(ret);
 

lib/wasi/src/fs/mod.rs

@@ -93,6 +93,9 @@ impl InodeGuard {
             inner: Arc::downgrade(&self.inner),
         }
     }
+    pub fn ref_cnt(&self) -> usize {
+        Arc::strong_count(&self.inner)
+    }
 }
 impl std::ops::Deref for InodeGuard {
     type Target = InodeVal;
@@ -1740,7 +1743,8 @@ impl WasiFs {
         match pfd {
             Ok(fd_ref) => {
                 let inode = fd_ref.inode.ino().as_u64();
-                trace!(%fd, %inode, "closing file descriptor");
+                let ref_cnt = fd_ref.inode.ref_cnt();
+                trace!(%fd, %inode, %ref_cnt, "closing file descriptor");
             }
             Err(err) => {
                 trace!(%fd, "closing file descriptor failed - {}", err);

lib/wasi/src/lib.rs

@@ -821,10 +821,10 @@ fn generate_import_object_wasix64_v1(
 
 fn mem_error_to_wasi(err: MemoryAccessError) -> Errno {
     match err {
-        MemoryAccessError::HeapOutOfBounds => Errno::Fault,
+        MemoryAccessError::HeapOutOfBounds => Errno::Memviolation,
         MemoryAccessError::Overflow => Errno::Overflow,
         MemoryAccessError::NonUtf8String => Errno::Inval,
-        _ => Errno::Inval,
+        _ => Errno::Unknown,
     }
 }
 

lib/wasi/src/os/command/builtins/cmd_wasmer.rs

@@ -85,14 +85,14 @@ impl CmdWasmer {
                     )
                     .await;
                 });
-                let handle = OwnedTaskStatus::new_finished_with_code(Errno::Noent as u32).handle();
+                let handle = OwnedTaskStatus::new_finished_with_code(Errno::Noent).handle();
                 Ok(handle)
             }
         } else {
             parent_ctx.data().tasks().block_on(async move {
                 let _ = stderr_write(parent_ctx, HELP_RUN.as_bytes()).await;
             });
-            let handle = OwnedTaskStatus::new_finished_with_code(0).handle();
+            let handle = OwnedTaskStatus::new_finished_with_code(Errno::Success).handle();
             Ok(handle)
         }
     }
@@ -135,7 +135,7 @@ impl VirtualCommand for CmdWasmer {
                 parent_ctx.data().tasks().block_on(async move {
                     let _ = stderr_write(parent_ctx, HELP.as_bytes()).await;
                 });
-                let handle = OwnedTaskStatus::new_finished_with_code(0).handle();
+                let handle = OwnedTaskStatus::new_finished_with_code(Errno::Success).handle();
                 Ok(handle)
             }
             Some(what) => {

lib/wasi/src/os/command/mod.rs

@@ -101,7 +101,7 @@ impl Commands {
                 format!("wasm command unknown - {}\r\n", path).as_bytes(),
             );
 
-            let res = OwnedTaskStatus::new(TaskStatus::Finished(Ok(Errno::Noent as u32)));
+            let res = OwnedTaskStatus::new(TaskStatus::Finished(Ok(Errno::Noent)));
             Ok(res.handle())
         }
     }