Merge branch 'master' into fix-runtime-c-api-error-length

CHANGELOG.md

@@ -7,6 +7,7 @@ Blocks of changes will separated by version increments.
 ## **[Unreleased]**
 
 - [#432](https://github.com/wasmerio/wasmer/pull/432) Fix returned value of `wasmer_last_error_message` in the runtime C API
+- [#429](https://github.com/wasmerio/wasmer/pull/429) Get wasi::path_filestat_get working for some programs; misc. minor WASI FS improvements
 - [#413](https://github.com/wasmerio/wasmer/pull/413) Update LLVM backend to use new parser codegen traits
 
 ## 0.4.1 - 2018-05-06

lib/clif-backend/src/lib.rs

@@ -1,3 +1,5 @@
+#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
+
 mod cache;
 mod func_env;
 mod libcalls;

lib/emscripten/src/lib.rs

@@ -1,3 +1,5 @@
+#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
+
 #[macro_use]
 extern crate wasmer_runtime_core;
 

lib/emscripten/src/syscalls/unix.rs

@@ -1,4 +1,6 @@
 use crate::varargs::VarArgs;
+#[cfg(target_os = "macos")]
+use libc::size_t;
 /// NOTE: TODO: These syscalls only support wasm_32 for now because they assume offsets are u32
 /// Syscall list: https://www.cs.utexas.edu/~bismith/test/syscalls/syscalls32.html
 use libc::{
@@ -53,7 +55,6 @@ use libc::{
     sendto,
     setpgid,
     setsockopt,
-    size_t,
     sockaddr,
     socket,
     socklen_t,

lib/llvm-backend/src/lib.rs

@@ -1,3 +1,4 @@
+#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
 #![cfg_attr(nightly, feature(unwind_attributes))]
 
 mod backend;

lib/llvm-backend/src/platform/unix.rs

@@ -34,7 +34,7 @@ pub unsafe fn visit_fde(addr: *mut u8, size: usize, visitor: extern "C" fn(*mut
 }
 
 #[cfg(not(target_os = "macos"))]
-pub unsafe fn visit_fde(addr: *mut u8, size: usize, visitor: extern "C" fn(*mut u8)) {
+pub unsafe fn visit_fde(addr: *mut u8, _size: usize, visitor: extern "C" fn(*mut u8)) {
     visitor(addr);
 }
 

lib/middleware-common/src/call_trace.rs

@@ -10,7 +10,7 @@ impl FunctionMiddleware for CallTrace {
     fn feed_event<'a, 'b: 'a>(
         &mut self,
         op: Event<'a, 'b>,
-        module_info: &ModuleInfo,
+        _module_info: &ModuleInfo,
         sink: &mut EventSink<'a, 'b>,
     ) -> Result<(), Self::Error> {
         match op {

lib/middleware-common/src/lib.rs

@@ -1 +1,3 @@
+#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
+
 pub mod call_trace;

lib/runtime-abi/src/lib.rs

@@ -1,3 +1,5 @@
+#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
+
 #[cfg(not(target_os = "windows"))]
 #[macro_use]
 extern crate failure;

lib/runtime-c-api/src/lib.rs

@@ -1,3 +1,5 @@
+#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
+
 extern crate wasmer_runtime;
 extern crate wasmer_runtime_core;
 

lib/runtime-core/src/codegen.rs

@@ -1,6 +1,6 @@
 use crate::{
     backend::RunnableModule,
-    backend::{sys::Memory, Backend, CacheGen, Compiler, CompilerConfig, Token},
+    backend::{Backend, CacheGen, Compiler, CompilerConfig, Token},
     cache::{Artifact, Error as CacheError},
     error::{CompileError, CompileResult},
     module::{ModuleInfo, ModuleInner},
@@ -35,7 +35,6 @@ impl fmt::Debug for InternalEvent {
             InternalEvent::Breakpoint(_) => write!(f, "Breakpoint"),
             InternalEvent::SetInternal(_) => write!(f, "SetInternal"),
             InternalEvent::GetInternal(_) => write!(f, "GetInternal"),
-            _ => panic!("unknown event"),
         }
     }
 }

lib/runtime-core/src/lib.rs

@@ -1,3 +1,4 @@
+#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
 #![cfg_attr(nightly, feature(unwind_attributes))]
 
 #[cfg(test)]

lib/runtime-core/src/typed_func.rs

@@ -247,7 +247,7 @@ impl<A: WasmExternType> WasmTypeList for (A,) {
     type CStruct = S1<A>;
     type RetArray = [u64; 1];
     fn from_ret_array(array: Self::RetArray) -> Self {
-        (WasmExternType::from_native(NativeWasmType::from_bits(
+        (WasmExternType::from_native(NativeWasmType::from_binary(
             array[0],
         )),)
     }
@@ -274,7 +274,7 @@ impl<A: WasmExternType> WasmTypeList for (A,) {
         ctx: *mut Ctx,
     ) -> Result<Rets, RuntimeError> {
         let (a,) = self;
-        let args = [a.to_native().to_bits()];
+        let args = [a.to_native().to_binary()];
         let mut rets = Rets::empty_ret_array();
         let mut trap = WasmTrapInfo::Unknown;
         let mut user_error = None;
@@ -322,7 +322,7 @@ macro_rules! impl_traits {
             fn from_ret_array(array: Self::RetArray) -> Self {
                 #[allow(non_snake_case)]
                 let [ $( $x ),* ] = array;
-                ( $( WasmExternType::from_native(NativeWasmType::from_bits($x)) ),* )
+                ( $( WasmExternType::from_native(NativeWasmType::from_binary($x)) ),* )
             }
             fn empty_ret_array() -> Self::RetArray {
                 [0; count_idents!( $( $x ),* )]
@@ -344,7 +344,7 @@ macro_rules! impl_traits {
             unsafe fn call<Rets: WasmTypeList>(self, f: NonNull<vm::Func>, wasm: Wasm, ctx: *mut Ctx) -> Result<Rets, RuntimeError> {
                 #[allow(unused_parens)]
                 let ( $( $x ),* ) = self;
-                let args = [ $( $x.to_native().to_bits() ),* ];
+                let args = [ $( $x.to_native().to_binary()),* ];
                 let mut rets = Rets::empty_ret_array();
                 let mut trap = WasmTrapInfo::Unknown;
                 let mut user_error = None;

lib/runtime-core/src/types.rs

@@ -76,44 +76,44 @@ where
     Self: Sized,
 {
     const TYPE: Type;
-    fn from_bits(bits: u64) -> Self;
+    fn from_binary(bits: u64) -> Self;
-    fn to_bits(self) -> u64;
+    fn to_binary(self) -> u64;
 }
 
 unsafe impl NativeWasmType for i32 {
     const TYPE: Type = Type::I32;
-    fn from_bits(bits: u64) -> Self {
+    fn from_binary(bits: u64) -> Self {
         bits as _
     }
-    fn to_bits(self) -> u64 {
+    fn to_binary(self) -> u64 {
         self as _
     }
 }
 unsafe impl NativeWasmType for i64 {
     const TYPE: Type = Type::I64;
-    fn from_bits(bits: u64) -> Self {
+    fn from_binary(bits: u64) -> Self {
         bits as _
     }
-    fn to_bits(self) -> u64 {
+    fn to_binary(self) -> u64 {
         self as _
     }
 }
 unsafe impl NativeWasmType for f32 {
     const TYPE: Type = Type::F32;
-    fn from_bits(bits: u64) -> Self {
+    fn from_binary(bits: u64) -> Self {
-        bits as _
+        f32::from_bits(bits as u32)
     }
-    fn to_bits(self) -> u64 {
+    fn to_binary(self) -> u64 {
-        self as _
+        self.to_bits() as _
     }
 }
 unsafe impl NativeWasmType for f64 {
     const TYPE: Type = Type::F64;
-    fn from_bits(bits: u64) -> Self {
+    fn from_binary(bits: u64) -> Self {
-        bits as _
+        f64::from_bits(bits)
     }
-    fn to_bits(self) -> u64 {
+    fn to_binary(self) -> u64 {
-        self as _
+        self.to_bits()
     }
 }
 
@@ -516,3 +516,58 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::types::NativeWasmType;
+    use crate::types::WasmExternType;
+
+    #[test]
+    fn test_native_types_round_trip() {
+        assert_eq!(
+            42i32,
+            i32::from_native(i32::from_binary((42i32).to_native().to_binary()))
+        );
+
+        assert_eq!(
+            -42i32,
+            i32::from_native(i32::from_binary((-42i32).to_native().to_binary()))
+        );
+
+        use std::i64;
+        let xi64 = i64::MAX;
+        assert_eq!(
+            xi64,
+            i64::from_native(i64::from_binary((xi64).to_native().to_binary()))
+        );
+        let yi64 = i64::MIN;
+        assert_eq!(
+            yi64,
+            i64::from_native(i64::from_binary((yi64).to_native().to_binary()))
+        );
+
+        assert_eq!(
+            16.5f32,
+            f32::from_native(f32::from_binary((16.5f32).to_native().to_binary()))
+        );
+
+        assert_eq!(
+            -16.5f32,
+            f32::from_native(f32::from_binary((-16.5f32).to_native().to_binary()))
+        );
+
+        use std::f64;
+        let xf64: f64 = f64::MAX;
+        assert_eq!(
+            xf64,
+            f64::from_native(f64::from_binary((xf64).to_native().to_binary()))
+        );
+
+        let yf64: f64 = f64::MIN;
+        assert_eq!(
+            yf64,
+            f64::from_native(f64::from_binary((yf64).to_native().to_binary()))
+        );
+    }
+
+}

lib/runtime/src/lib.rs

@@ -1,3 +1,5 @@
+#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
+
 //! Wasmer-runtime is a library that makes embedding WebAssembly
 //! in your application easy, efficient, and safe.
 //!

lib/singlepass-backend/src/codegen_x64.rs

@@ -212,10 +212,10 @@ impl RunnableModule for X64ExecutionContext {
             user_error: *mut Option<Box<dyn Any>>,
             num_params_plus_one: Option<NonNull<c_void>>,
         ) -> bool {
-            let rm: &Box<dyn RunnableModule> = &unsafe { &*(*ctx).module }.runnable_module;
+            let rm: &Box<dyn RunnableModule> = &(&*(*ctx).module).runnable_module;
-            let execution_context = unsafe {
+            let execution_context =
-                ::std::mem::transmute_copy::<&dyn RunnableModule, &X64ExecutionContext>(&&**rm)
+                ::std::mem::transmute_copy::<&dyn RunnableModule, &X64ExecutionContext>(&&**rm);
-            };
+
             let args = ::std::slice::from_raw_parts(
                 args,
                 num_params_plus_one.unwrap().as_ptr() as usize - 1,
@@ -478,7 +478,7 @@ impl ModuleCodeGenerator<X64FunctionCode, X64ExecutionContext, CodegenError>
         Ok(())
     }
 
-    unsafe fn from_cache(artifact: Artifact, _: Token) -> Result<ModuleInner, CacheError> {
+    unsafe fn from_cache(_artifact: Artifact, _: Token) -> Result<ModuleInner, CacheError> {
         Err(CacheError::Unknown(
             "the singlepass compiler API doesn't support caching yet".to_string(),
         ))
@@ -1409,7 +1409,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
         Ok(())
     }
 
-    fn begin_body(&mut self, module_info: &ModuleInfo) -> Result<(), CodegenError> {
+    fn begin_body(&mut self, _module_info: &ModuleInfo) -> Result<(), CodegenError> {
         let a = self.assembler.as_mut().unwrap();
         a.emit_push(Size::S64, Location::GPR(GPR::RBP));
         a.emit_mov(Size::S64, Location::GPR(GPR::RSP), Location::GPR(GPR::RBP));

lib/singlepass-backend/src/lib.rs

@@ -1,3 +1,4 @@
+#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
 #![feature(proc_macro_hygiene)]
 
 #[cfg(not(any(

lib/wasi/src/lib.rs

@@ -1,3 +1,5 @@
+#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
+
 #[macro_use]
 extern crate log;
 

lib/wasi/src/syscalls/mod.rs

@@ -279,7 +279,7 @@ pub fn fd_allocate(
     len: __wasi_filesize_t,
 ) -> __wasi_errno_t {
     debug!("wasi::fd_allocate");
-    unimplemented!()
+    unimplemented!("wasi::fd_allocate")
 }
 
 /// ### `fd_close()`
@@ -434,7 +434,7 @@ pub fn fd_filestat_set_size(
     st_size: __wasi_filesize_t,
 ) -> __wasi_errno_t {
     debug!("wasi::fd_filestat_set_size");
-    unimplemented!()
+    unimplemented!("wasi::fd_filestat_set_size")
 }
 
 /// ### `fd_filestat_set_times()`
@@ -474,14 +474,14 @@ pub fn fd_filestat_set_times(
         inode.stat.st_atim = st_atim;
     } else if fst_flags & __WASI_FILESTAT_SET_ATIM_NOW != 0 {
         // set to current real time
-        unimplemented!();
+        unimplemented!("Set filestat time to the current real time");
     }
 
     if fst_flags & __WASI_FILESTAT_SET_MTIM != 0 {
         inode.stat.st_mtim = st_mtim;
     } else if fst_flags & __WASI_FILESTAT_SET_MTIM_NOW != 0 {
         // set to current real time
-        unimplemented!();
+        unimplemented!("Set filestat time to the current real time");
     }
 
     __WASI_ESUCCESS
@@ -501,7 +501,7 @@ pub fn fd_pread(
     let iov_cells = wasi_try!(iovs.deref(memory, 0, iovs_len));
     let nread_cell = wasi_try!(nread.deref(memory));
 
-    unimplemented!();
+    unimplemented!("wasi::fd_pread");
 
     __WASI_ESUCCESS
 }
@@ -637,7 +637,7 @@ pub fn fd_pwrite(
                     // TODO: verify
                     return __WASI_EISDIR;
                 }
-                Kind::Symlink { .. } => unimplemented!(),
+                Kind::Symlink { .. } => unimplemented!("Symlinks in wasi::fd_pwrite"),
                 Kind::Buffer { buffer } => wasi_try!(write_bytes(
                     &mut buffer[(offset as usize)..],
                     memory,
@@ -725,7 +725,7 @@ pub fn fd_read(
                     // TODO: verify
                     return __WASI_EISDIR;
                 }
-                Kind::Symlink { .. } => unimplemented!(),
+                Kind::Symlink { .. } => unimplemented!("Symlinks in wasi::fd_read"),
                 Kind::Buffer { buffer } => {
                     wasi_try!(read_bytes(&buffer[offset..], memory, iovs_arr_cell))
                 }
@@ -771,7 +771,7 @@ pub fn fd_readdir(
     if let (Ok(buf_arr_cell), Ok(bufused_cell)) =
         (buf.deref(memory, 0, buf_len), bufused.deref(memory))
     {
-        unimplemented!()
+        unimplemented!("wasi::fd_readdir")
     } else {
         __WASI_EFAULT
     }
@@ -833,7 +833,7 @@ pub fn fd_seek(
     // TODO: handle case if fd is a dir?
     match whence {
         __WASI_WHENCE_CUR => fd_entry.offset = (fd_entry.offset as i64 + offset) as u64,
-        __WASI_WHENCE_END => unimplemented!(),
+        __WASI_WHENCE_END => unimplemented!("__WASI__WHENCE_END in wasi::fd_seek"),
         __WASI_WHENCE_SET => fd_entry.offset = offset as u64,
         _ => return __WASI_EINVAL,
     }
@@ -855,7 +855,7 @@ pub fn fd_seek(
 pub fn fd_sync(ctx: &mut Ctx, fd: __wasi_fd_t) -> __wasi_errno_t {
     debug!("wasi::fd_sync");
     // TODO: check __WASI_RIGHT_FD_SYNC
-    unimplemented!()
+    unimplemented!("wasi::fd_sync")
 }
 
 /// ### `fd_tell()`
@@ -950,7 +950,7 @@ pub fn fd_write(
                     // TODO: verify
                     return __WASI_EISDIR;
                 }
-                Kind::Symlink { .. } => unimplemented!(),
+                Kind::Symlink { .. } => unimplemented!("Symlinks in wasi::fd_write"),
                 Kind::Buffer { buffer } => {
                     wasi_try!(write_bytes(&mut buffer[offset..], memory, iovs_arr_cell))
                 }
@@ -987,8 +987,62 @@ pub fn path_create_directory(
     path_len: u32,
 ) -> __wasi_errno_t {
     debug!("wasi::path_create_directory");
-    // check __WASI_RIGHT_PATH_CREATE_DIRECTORY
+    let memory = ctx.memory(0);
-    unimplemented!()
+    let state = get_wasi_state(ctx);
+
+    let working_dir = wasi_try!(state.fs.fd_map.get(&fd).ok_or(__WASI_EBADF));
+    if !has_rights(working_dir.rights, __WASI_RIGHT_PATH_CREATE_DIRECTORY) {
+        return __WASI_EACCES;
+    }
+    let path_cells = wasi_try!(path.deref(memory, 0, path_len));
+    let path_string =
+        wasi_try!(
+            std::str::from_utf8(unsafe { &*(path_cells as *const [_] as *const [u8]) })
+                .map_err(|_| __WASI_EINVAL)
+        );
+    debug!("=> path: {}", &path_string);
+
+    let path = std::path::PathBuf::from(path_string);
+    let path_vec = wasi_try!(path
+        .components()
+        .map(|comp| {
+            comp.as_os_str()
+                .to_str()
+                .map(|inner_str| inner_str.to_string())
+                .ok_or(__WASI_EINVAL)
+        })
+        .collect::<Result<Vec<String>, __wasi_errno_t>>());
+    if path_vec.is_empty() {
+        return __WASI_EINVAL;
+    }
+
+    assert!(
+        path_vec.len() == 1,
+        "path_create_directory for paths greater than depth 1 has not been implemented because our WASI FS abstractions are a work in progress.  We apologize for the inconvenience"
+    );
+    debug!("Path vec: {:#?}", path_vec);
+
+    wasi_try!(std::fs::create_dir(&path).map_err(|_| __WASI_EIO));
+
+    let kind = Kind::Dir {
+        //parent: Some(working_dir.inode),
+        path: path.clone(),
+        entries: Default::default(),
+    };
+    let new_inode = state.fs.inodes.insert(InodeVal {
+        stat: __wasi_filestat_t::default(),
+        is_preopened: false,
+        name: path_vec[0].clone(),
+        kind,
+    });
+
+    if let Kind::Dir { entries, .. } = &mut state.fs.inodes[working_dir.inode].kind {
+        entries.insert(path_vec[0].clone(), new_inode);
+    } else {
+        return __WASI_ENOTDIR;
+    }
+
+    __WASI_ESUCCESS
 }
 
 /// ### `path_filestat_get()`
@@ -1023,32 +1077,71 @@ pub fn path_filestat_get(
         return __WASI_EACCES;
     }
 
-    let path_vec = wasi_try!(::std::str::from_utf8(unsafe {
+    let path_string = wasi_try!(::std::str::from_utf8(unsafe {
         &*(wasi_try!(path.deref(memory, 0, path_len)) as *const [_] as *const [u8])
     })
-    .map_err(|_| __WASI_EINVAL))
+    .map_err(|_| __WASI_EINVAL));
-    .split('/')
+    debug!("=> path: {}", &path_string);
-    .map(|str| str.to_string())
+    let path = std::path::PathBuf::from(path_string);
+    let path_vec = path
+        .components()
+        .map(|comp| comp.as_os_str().to_string_lossy().to_string())
         .collect::<Vec<String>>();
     let buf_cell = wasi_try!(buf.deref(memory));
 
+    if path_vec.is_empty() {
+        return __WASI_EINVAL;
+    }
+    let mut cumulative_path = std::path::PathBuf::new();
+
+    debug!("=> Path vec: {:?}:", &path_vec);
     // find the inode by traversing the path
     let mut inode = root_dir.inode;
-    'outer: for segment in path_vec {
+    'outer: for segment in &path_vec[..(path_vec.len() - 1)] {
         // loop to traverse symlinks
         // TODO: proper cycle detection
         let mut sym_count = 0;
         loop {
             match &state.fs.inodes[inode].kind {
                 Kind::Dir { entries, .. } => {
-                    if let Some(entry) = entries.get(&segment) {
+                    cumulative_path.push(&segment);
+                    if let Some(entry) = entries.get(segment) {
+                        debug!("Entry {:?} found", &segment);
                         inode = entry.clone();
-                        continue 'outer;
                     } else {
-                        return __WASI_ENOENT;
+                        // lazily load
+                        debug!("Lazily loading entry {:?}", &segment);
+                        let path_metadata =
+                            wasi_try!(cumulative_path.metadata().map_err(|_| __WASI_ENOENT));
+                        if !path_metadata.is_dir() {
+                            // TODO: should this just return invalid arg?
+                            return __WASI_ENOTDIR;
                         }
+                        let kind = Kind::Dir {
+                            path: std::path::PathBuf::from(&segment),
+                            entries: Default::default(),
+                        };
+                        let inode_val = InodeVal::from_file_metadata(
+                            &path_metadata,
+                            segment.clone(),
+                            false,
+                            kind,
+                        );
+                        let new_inode = state.fs.inodes.insert(inode_val);
+                        let inode_idx = state.fs.inode_counter.get();
+                        state.fs.inode_counter.replace(inode_idx + 1);
+                        if let Kind::Dir { entries, .. } = &mut state.fs.inodes[inode].kind {
+                            // check that we're not displacing any entries
+                            assert!(entries.insert(segment.clone(), new_inode).is_none());
+                            state.fs.inodes[new_inode].stat.st_ino = state.fs.inode_counter.get();
+                            inode = new_inode;
+                        }
+                        debug!("Directory {:#?} lazily loaded", &cumulative_path);
+                    }
+                    continue 'outer;
                 }
                 Kind::Symlink { forwarded } => {
+                    // TODO: updated cumulative path
                     sym_count += 1;
                     inode = forwarded.clone();
                     if sym_count > MAX_SYMLINKS {
@@ -1062,7 +1155,62 @@ pub fn path_filestat_get(
         }
     }
 
-    let stat = state.fs.inodes[inode].stat;
+    let final_inode = match &state.fs.inodes[inode].kind {
+        Kind::Dir { path, entries, .. } => {
+            // TODO: fail earlier if size 0
+            let last_segment = path_vec.last().unwrap();
+            cumulative_path.push(last_segment);
+
+            if entries.contains_key(last_segment) {
+                entries[last_segment]
+            } else {
+                // lazily load it if we can
+                if !cumulative_path.exists() {
+                    return __WASI_ENOENT;
+                }
+                let final_path_metadata =
+                    wasi_try!(cumulative_path.metadata().map_err(|_| __WASI_EIO));
+                let new_inode = if final_path_metadata.is_dir() {
+                    debug!("Opening host directory {:#?}", &cumulative_path);
+                    state.fs.inodes.insert(InodeVal {
+                        stat: __wasi_filestat_t::default(),
+                        is_preopened: false, // is this correct?
+                        name: last_segment.clone(),
+                        kind: Kind::Dir {
+                            path: std::path::PathBuf::from(&last_segment),
+                            entries: Default::default(),
+                        },
+                    })
+                } else {
+                    debug!("Opening host file {:#?}", &cumulative_path);
+                    let real_open_file = wasi_try!(std::fs::OpenOptions::new()
+                        .read(true)
+                        .write(true)
+                        .open(&cumulative_path)
+                        .map_err(|_| __WASI_ENOENT));
+
+                    state.fs.inodes.insert(InodeVal {
+                        stat: __wasi_filestat_t::default(),
+                        is_preopened: false, // is this correct?
+                        name: last_segment.clone(),
+                        kind: Kind::File {
+                            handle: WasiFile::HostFile(real_open_file),
+                        },
+                    })
+                };
+                // reborrow to insert entry
+                if let Kind::Dir { entries, .. } = &mut state.fs.inodes[inode].kind {
+                    entries.insert(last_segment.clone(), new_inode);
+                }
+                new_inode
+            }
+        }
+        _ => {
+            return __WASI_ENOTDIR;
+        }
+    };
+
+    let stat = state.fs.inodes[final_inode].stat;
 
     buf_cell.set(stat);
 
@@ -1097,7 +1245,7 @@ pub fn path_filestat_set_times(
     fst_flags: __wasi_fstflags_t,
 ) -> __wasi_errno_t {
     debug!("wasi::path_filestat_set_times");
-    unimplemented!()
+    unimplemented!("wasi::path_filestat_set_times")
 }
 
 /// ### `path_link()`
@@ -1128,7 +1276,7 @@ pub fn path_link(
     new_path_len: u32,
 ) -> __wasi_errno_t {
     debug!("wasi::path_link");
-    unimplemented!()
+    unimplemented!("wasi::path_link")
 }
 
 /// ### `path_open()`
@@ -1221,6 +1369,7 @@ pub fn path_open(
             match &state.fs.inodes[cur_dir_inode].kind {
                 Kind::Dir { entries, .. } => {
                     if let Some(child) = entries.get(path_segment) {
+                        cumulative_path.push(path_segment);
                         let inode_val = *child;
                         cur_dir_inode = inode_val;
                     } else {
@@ -1376,7 +1525,7 @@ pub fn path_readlink(
     bufused: WasmPtr<u32>,
 ) -> __wasi_errno_t {
     debug!("wasi::path_readlink");
-    unimplemented!()
+    unimplemented!("wasi::path_readlink")
 }
 pub fn path_remove_directory(
     ctx: &mut Ctx,
@@ -1385,7 +1534,7 @@ pub fn path_remove_directory(
     path_len: u32,
 ) -> __wasi_errno_t {
     debug!("wasi::path_remove_directory");
-    unimplemented!()
+    unimplemented!("wasi::path_remove_directory")
 }
 pub fn path_rename(
     ctx: &mut Ctx,
@@ -1397,7 +1546,7 @@ pub fn path_rename(
     new_path_len: u32,
 ) -> __wasi_errno_t {
     debug!("wasi::path_rename");
-    unimplemented!()
+    unimplemented!("wasi::path_rename")
 }
 pub fn path_symlink(
     ctx: &mut Ctx,
@@ -1408,7 +1557,7 @@ pub fn path_symlink(
     new_path_len: u32,
 ) -> __wasi_errno_t {
     debug!("wasi::path_symlink");
-    unimplemented!()
+    unimplemented!("wasi::path_symlink")
 }
 pub fn path_unlink_file(
     ctx: &mut Ctx,
@@ -1417,7 +1566,7 @@ pub fn path_unlink_file(
     path_len: u32,
 ) -> __wasi_errno_t {
     debug!("wasi::path_unlink_file");
-    unimplemented!()
+    unimplemented!("wasi::path_unlink_file")
 }
 pub fn poll_oneoff(
     ctx: &mut Ctx,
@@ -1427,7 +1576,7 @@ pub fn poll_oneoff(
     nevents: WasmPtr<u32>,
 ) -> __wasi_errno_t {
     debug!("wasi::poll_oneoff");
-    unimplemented!()
+    unimplemented!("wasi::poll_oneoff")
 }
 pub fn proc_exit(ctx: &mut Ctx, code: __wasi_exitcode_t) -> Result<Infallible, ExitCode> {
     debug!("wasi::proc_exit, {}", code);
@@ -1435,7 +1584,7 @@ pub fn proc_exit(ctx: &mut Ctx, code: __wasi_exitcode_t) -> Result<Infallible, E
 }
 pub fn proc_raise(ctx: &mut Ctx, sig: __wasi_signal_t) -> __wasi_errno_t {
     debug!("wasi::proc_raise");
-    unimplemented!()
+    unimplemented!("wasi::proc_raise")
 }
 
 /// ### `random_get()`
@@ -1478,7 +1627,7 @@ pub fn sock_recv(
     ro_flags: WasmPtr<__wasi_roflags_t>,
 ) -> __wasi_errno_t {
     debug!("wasi::sock_recv");
-    unimplemented!()
+    unimplemented!("wasi::sock_recv")
 }
 pub fn sock_send(
     ctx: &mut Ctx,
@@ -1489,9 +1638,9 @@ pub fn sock_send(
     so_datalen: WasmPtr<u32>,
 ) -> __wasi_errno_t {
     debug!("wasi::sock_send");
-    unimplemented!()
+    unimplemented!("wasi::sock_send")
 }
 pub fn sock_shutdown(ctx: &mut Ctx, sock: __wasi_fd_t, how: __wasi_sdflags_t) -> __wasi_errno_t {
     debug!("wasi::sock_shutdown");
-    unimplemented!()
+    unimplemented!("wasi::sock_shutdown")
 }

lib/win-exception-handler/src/exception_handling.rs

@@ -1,4 +1,3 @@
-use std::ffi::c_void;
 use std::ptr::NonNull;
 use wasmer_runtime_core::vm::{Ctx, Func};
 

lib/win-exception-handler/src/lib.rs

@@ -1,3 +1,5 @@
+#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
+
 #[cfg(windows)]
 mod exception_handling;
 

src/bin/wasmer.rs

@@ -1,3 +1,5 @@
+#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
+
 extern crate structopt;
 
 use std::env;

src/lib.rs

@@ -1,3 +1,5 @@
+#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
+
 #[macro_use]
 extern crate wasmer_runtime_core;
 // extern crate wasmer_emscripten;