Initial reorg.

This is largely the same as #305, but updated for the current tree.

crates/wasi-common/src/sys/windows/fdentry_impl.rs

@@ -0,0 +1,129 @@
+use crate::fdentry::Descriptor;
+use crate::{wasi, Error, Result};
+use std::fs::File;
+use std::io;
+use std::ops::{Deref, DerefMut};
+use std::os::windows::prelude::{AsRawHandle, FromRawHandle, RawHandle};
+
+#[derive(Debug)]
+pub(crate) struct OsFile(File);
+
+impl From<File> for OsFile {
+    fn from(file: File) -> Self {
+        Self(file)
+    }
+}
+
+impl AsRawHandle for OsFile {
+    fn as_raw_handle(&self) -> RawHandle {
+        self.0.as_raw_handle()
+    }
+}
+
+impl Deref for OsFile {
+    type Target = File;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for OsFile {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl AsRawHandle for Descriptor {
+    fn as_raw_handle(&self) -> RawHandle {
+        match self {
+            Self::OsFile(file) => file.as_raw_handle(),
+            Self::Stdin => io::stdin().as_raw_handle(),
+            Self::Stdout => io::stdout().as_raw_handle(),
+            Self::Stderr => io::stderr().as_raw_handle(),
+        }
+    }
+}
+
+/// This function is unsafe because it operates on a raw file handle.
+pub(crate) unsafe fn determine_type_and_access_rights<Handle: AsRawHandle>(
+    handle: &Handle,
+) -> Result<(
+    wasi::__wasi_filetype_t,
+    wasi::__wasi_rights_t,
+    wasi::__wasi_rights_t,
+)> {
+    use winx::file::{get_file_access_mode, AccessMode};
+
+    let (file_type, mut rights_base, rights_inheriting) = determine_type_rights(handle)?;
+
+    match file_type {
+        wasi::__WASI_FILETYPE_DIRECTORY | wasi::__WASI_FILETYPE_REGULAR_FILE => {
+            let mode = get_file_access_mode(handle.as_raw_handle())?;
+            if mode.contains(AccessMode::FILE_GENERIC_READ) {
+                rights_base |= wasi::__WASI_RIGHT_FD_READ;
+            }
+            if mode.contains(AccessMode::FILE_GENERIC_WRITE) {
+                rights_base |= wasi::__WASI_RIGHT_FD_WRITE;
+            }
+        }
+        _ => {
+            // TODO: is there a way around this? On windows, it seems
+            // we cannot check access rights for anything but dirs and regular files
+        }
+    }
+
+    Ok((file_type, rights_base, rights_inheriting))
+}
+
+/// This function is unsafe because it operates on a raw file handle.
+pub(crate) unsafe fn determine_type_rights<Handle: AsRawHandle>(
+    handle: &Handle,
+) -> Result<(
+    wasi::__wasi_filetype_t,
+    wasi::__wasi_rights_t,
+    wasi::__wasi_rights_t,
+)> {
+    let (file_type, rights_base, rights_inheriting) = {
+        let file_type = winx::file::get_file_type(handle.as_raw_handle())?;
+        if file_type.is_char() {
+            // character file: LPT device or console
+            // TODO: rule out LPT device
+            (
+                wasi::__WASI_FILETYPE_CHARACTER_DEVICE,
+                wasi::RIGHTS_TTY_BASE,
+                wasi::RIGHTS_TTY_BASE,
+            )
+        } else if file_type.is_disk() {
+            // disk file: file, dir or disk device
+            let file = std::mem::ManuallyDrop::new(File::from_raw_handle(handle.as_raw_handle()));
+            let meta = file.metadata().map_err(|_| Error::EINVAL)?;
+            if meta.is_dir() {
+                (
+                    wasi::__WASI_FILETYPE_DIRECTORY,
+                    wasi::RIGHTS_DIRECTORY_BASE,
+                    wasi::RIGHTS_DIRECTORY_INHERITING,
+                )
+            } else if meta.is_file() {
+                (
+                    wasi::__WASI_FILETYPE_REGULAR_FILE,
+                    wasi::RIGHTS_REGULAR_FILE_BASE,
+                    wasi::RIGHTS_REGULAR_FILE_INHERITING,
+                )
+            } else {
+                return Err(Error::EINVAL);
+            }
+        } else if file_type.is_pipe() {
+            // pipe object: socket, named pipe or anonymous pipe
+            // TODO: what about pipes, etc?
+            (
+                wasi::__WASI_FILETYPE_SOCKET_STREAM,
+                wasi::RIGHTS_SOCKET_BASE,
+                wasi::RIGHTS_SOCKET_INHERITING,
+            )
+        } else {
+            return Err(Error::EINVAL);
+        }
+    };
+    Ok((file_type, rights_base, rights_inheriting))
+}

crates/wasi-common/src/sys/windows/host_impl.rs

@@ -0,0 +1,108 @@
+//! WASI host types specific to Windows host.
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(unused)]
+use crate::{wasi, Error, Result};
+use std::ffi::OsStr;
+use std::fs::OpenOptions;
+use std::os::windows::ffi::OsStrExt;
+use std::os::windows::fs::OpenOptionsExt;
+use winx::file::{AccessMode, Attributes, CreationDisposition, Flags};
+
+pub(crate) fn errno_from_win(error: winx::winerror::WinError) -> wasi::__wasi_errno_t {
+    // TODO: implement error mapping between Windows and WASI
+    use winx::winerror::WinError::*;
+    match error {
+        ERROR_SUCCESS => wasi::__WASI_ESUCCESS,
+        ERROR_BAD_ENVIRONMENT => wasi::__WASI_E2BIG,
+        ERROR_FILE_NOT_FOUND => wasi::__WASI_ENOENT,
+        ERROR_PATH_NOT_FOUND => wasi::__WASI_ENOENT,
+        ERROR_TOO_MANY_OPEN_FILES => wasi::__WASI_ENFILE,
+        ERROR_ACCESS_DENIED => wasi::__WASI_EACCES,
+        ERROR_SHARING_VIOLATION => wasi::__WASI_EACCES,
+        ERROR_PRIVILEGE_NOT_HELD => wasi::__WASI_ENOTCAPABLE, // TODO is this the correct mapping?
+        ERROR_INVALID_HANDLE => wasi::__WASI_EBADF,
+        ERROR_INVALID_NAME => wasi::__WASI_ENOENT,
+        ERROR_NOT_ENOUGH_MEMORY => wasi::__WASI_ENOMEM,
+        ERROR_OUTOFMEMORY => wasi::__WASI_ENOMEM,
+        ERROR_DIR_NOT_EMPTY => wasi::__WASI_ENOTEMPTY,
+        ERROR_NOT_READY => wasi::__WASI_EBUSY,
+        ERROR_BUSY => wasi::__WASI_EBUSY,
+        ERROR_NOT_SUPPORTED => wasi::__WASI_ENOTSUP,
+        ERROR_FILE_EXISTS => wasi::__WASI_EEXIST,
+        ERROR_BROKEN_PIPE => wasi::__WASI_EPIPE,
+        ERROR_BUFFER_OVERFLOW => wasi::__WASI_ENAMETOOLONG,
+        ERROR_NOT_A_REPARSE_POINT => wasi::__WASI_EINVAL,
+        ERROR_NEGATIVE_SEEK => wasi::__WASI_EINVAL,
+        ERROR_DIRECTORY => wasi::__WASI_ENOTDIR,
+        ERROR_ALREADY_EXISTS => wasi::__WASI_EEXIST,
+        _ => wasi::__WASI_ENOTSUP,
+    }
+}
+
+pub(crate) fn fdflags_from_win(mode: AccessMode) -> wasi::__wasi_fdflags_t {
+    let mut fdflags = 0;
+    // TODO verify this!
+    if mode.contains(AccessMode::FILE_APPEND_DATA) {
+        fdflags |= wasi::__WASI_FDFLAG_APPEND;
+    }
+    if mode.contains(AccessMode::SYNCHRONIZE) {
+        fdflags |= wasi::__WASI_FDFLAG_DSYNC;
+        fdflags |= wasi::__WASI_FDFLAG_RSYNC;
+        fdflags |= wasi::__WASI_FDFLAG_SYNC;
+    }
+    // The NONBLOCK equivalent is FILE_FLAG_OVERLAPPED
+    // but it seems winapi doesn't provide a mechanism
+    // for checking whether the handle supports async IO.
+    // On the contrary, I've found some dicsussion online
+    // which suggests that on Windows all handles should
+    // generally be assumed to be opened with async support
+    // and then the program should fallback should that **not**
+    // be the case at the time of the operation.
+    // TODO: this requires further investigation
+    fdflags
+}
+
+pub(crate) fn win_from_fdflags(fdflags: wasi::__wasi_fdflags_t) -> (AccessMode, Flags) {
+    let mut access_mode = AccessMode::empty();
+    let mut flags = Flags::empty();
+
+    // TODO verify this!
+    if fdflags & wasi::__WASI_FDFLAG_NONBLOCK != 0 {
+        flags.insert(Flags::FILE_FLAG_OVERLAPPED);
+    }
+    if fdflags & wasi::__WASI_FDFLAG_APPEND != 0 {
+        access_mode.insert(AccessMode::FILE_APPEND_DATA);
+    }
+    if fdflags & wasi::__WASI_FDFLAG_DSYNC != 0
+        || fdflags & wasi::__WASI_FDFLAG_RSYNC != 0
+        || fdflags & wasi::__WASI_FDFLAG_SYNC != 0
+    {
+        access_mode.insert(AccessMode::SYNCHRONIZE);
+    }
+
+    (access_mode, flags)
+}
+
+pub(crate) fn win_from_oflags(oflags: wasi::__wasi_oflags_t) -> CreationDisposition {
+    if oflags & wasi::__WASI_O_CREAT != 0 {
+        if oflags & wasi::__WASI_O_EXCL != 0 {
+            CreationDisposition::CREATE_NEW
+        } else {
+            CreationDisposition::CREATE_ALWAYS
+        }
+    } else if oflags & wasi::__WASI_O_TRUNC != 0 {
+        CreationDisposition::TRUNCATE_EXISTING
+    } else {
+        CreationDisposition::OPEN_EXISTING
+    }
+}
+
+/// Creates owned WASI path from OS string.
+///
+/// NB WASI spec requires OS string to be valid UTF-8. Otherwise,
+/// `__WASI_EILSEQ` error is returned.
+pub(crate) fn path_from_host<S: AsRef<OsStr>>(s: S) -> Result<String> {
+    let vec: Vec<u16> = s.as_ref().encode_wide().collect();
+    String::from_utf16(&vec).map_err(|_| Error::EILSEQ)
+}

crates/wasi-common/src/sys/windows/hostcalls_impl/fs.rs

@@ -0,0 +1,550 @@
+#![allow(non_camel_case_types)]
+#![allow(unused)]
+use super::fs_helpers::*;
+use crate::ctx::WasiCtx;
+use crate::fdentry::FdEntry;
+use crate::helpers::systemtime_to_timestamp;
+use crate::hostcalls_impl::{fd_filestat_set_times_impl, Dirent, FileType, PathGet};
+use crate::sys::fdentry_impl::{determine_type_rights, OsFile};
+use crate::sys::host_impl::{self, path_from_host};
+use crate::sys::hostcalls_impl::fs_helpers::PathGetExt;
+use crate::{wasi, Error, Result};
+use log::{debug, trace};
+use std::convert::TryInto;
+use std::fs::{File, Metadata, OpenOptions};
+use std::io::{self, Seek, SeekFrom};
+use std::os::windows::fs::{FileExt, OpenOptionsExt};
+use std::os::windows::prelude::{AsRawHandle, FromRawHandle};
+use std::path::{Path, PathBuf};
+use winx::file::{AccessMode, Flags};
+
+fn read_at(mut file: &File, buf: &mut [u8], offset: u64) -> io::Result<usize> {
+    // get current cursor position
+    let cur_pos = file.seek(SeekFrom::Current(0))?;
+    // perform a seek read by a specified offset
+    let nread = file.seek_read(buf, offset)?;
+    // rewind the cursor back to the original position
+    file.seek(SeekFrom::Start(cur_pos))?;
+    Ok(nread)
+}
+
+fn write_at(mut file: &File, buf: &[u8], offset: u64) -> io::Result<usize> {
+    // get current cursor position
+    let cur_pos = file.seek(SeekFrom::Current(0))?;
+    // perform a seek write by a specified offset
+    let nwritten = file.seek_write(buf, offset)?;
+    // rewind the cursor back to the original position
+    file.seek(SeekFrom::Start(cur_pos))?;
+    Ok(nwritten)
+}
+
+// TODO refactor common code with unix
+pub(crate) fn fd_pread(
+    file: &File,
+    buf: &mut [u8],
+    offset: wasi::__wasi_filesize_t,
+) -> Result<usize> {
+    read_at(file, buf, offset).map_err(Into::into)
+}
+
+// TODO refactor common code with unix
+pub(crate) fn fd_pwrite(file: &File, buf: &[u8], offset: wasi::__wasi_filesize_t) -> Result<usize> {
+    write_at(file, buf, offset).map_err(Into::into)
+}
+
+pub(crate) fn fd_fdstat_get(fd: &File) -> Result<wasi::__wasi_fdflags_t> {
+    use winx::file::AccessMode;
+    unsafe { winx::file::get_file_access_mode(fd.as_raw_handle()) }
+        .map(host_impl::fdflags_from_win)
+        .map_err(Into::into)
+}
+
+pub(crate) fn fd_fdstat_set_flags(fd: &File, fdflags: wasi::__wasi_fdflags_t) -> Result<()> {
+    unimplemented!("fd_fdstat_set_flags")
+}
+
+pub(crate) fn fd_advise(
+    _file: &File,
+    advice: wasi::__wasi_advice_t,
+    _offset: wasi::__wasi_filesize_t,
+    _len: wasi::__wasi_filesize_t,
+) -> Result<()> {
+    match advice {
+        wasi::__WASI_ADVICE_DONTNEED
+        | wasi::__WASI_ADVICE_SEQUENTIAL
+        | wasi::__WASI_ADVICE_WILLNEED
+        | wasi::__WASI_ADVICE_NOREUSE
+        | wasi::__WASI_ADVICE_RANDOM
+        | wasi::__WASI_ADVICE_NORMAL => {}
+        _ => return Err(Error::EINVAL),
+    }
+
+    Ok(())
+}
+
+pub(crate) fn path_create_directory(resolved: PathGet) -> Result<()> {
+    let path = resolved.concatenate()?;
+    std::fs::create_dir(&path).map_err(Into::into)
+}
+
+pub(crate) fn path_link(resolved_old: PathGet, resolved_new: PathGet) -> Result<()> {
+    unimplemented!("path_link")
+}
+
+pub(crate) fn path_open(
+    resolved: PathGet,
+    read: bool,
+    write: bool,
+    oflags: wasi::__wasi_oflags_t,
+    fdflags: wasi::__wasi_fdflags_t,
+) -> Result<File> {
+    use winx::file::{AccessMode, CreationDisposition, Flags};
+
+    let mut access_mode = AccessMode::READ_CONTROL;
+    if read {
+        access_mode.insert(AccessMode::FILE_GENERIC_READ);
+    }
+    if write {
+        access_mode.insert(AccessMode::FILE_GENERIC_WRITE);
+    }
+
+    let mut flags = Flags::FILE_FLAG_BACKUP_SEMANTICS;
+
+    // convert open flags
+    let mut opts = OpenOptions::new();
+    match host_impl::win_from_oflags(oflags) {
+        CreationDisposition::CREATE_ALWAYS => {
+            opts.create(true).append(true);
+        }
+        CreationDisposition::CREATE_NEW => {
+            opts.create_new(true).write(true);
+        }
+        CreationDisposition::TRUNCATE_EXISTING => {
+            opts.truncate(true);
+        }
+        _ => {}
+    }
+
+    // convert file descriptor flags
+    let (add_access_mode, add_flags) = host_impl::win_from_fdflags(fdflags);
+    access_mode.insert(add_access_mode);
+    flags.insert(add_flags);
+
+    let path = resolved.concatenate()?;
+
+    match path.symlink_metadata().map(|metadata| metadata.file_type()) {
+        Ok(file_type) => {
+            // check if we are trying to open a symlink
+            if file_type.is_symlink() {
+                return Err(Error::ELOOP);
+            }
+            // check if we are trying to open a file as a dir
+            if file_type.is_file() && oflags & wasi::__WASI_O_DIRECTORY != 0 {
+                return Err(Error::ENOTDIR);
+            }
+        }
+        Err(e) => match e.raw_os_error() {
+            Some(e) => {
+                use winx::winerror::WinError;
+                log::debug!("path_open at symlink_metadata error code={:?}", e);
+                let e = WinError::from_u32(e as u32);
+
+                if e != WinError::ERROR_FILE_NOT_FOUND {
+                    return Err(e.into());
+                }
+                // file not found, let it proceed to actually
+                // trying to open it
+            }
+            None => {
+                log::debug!("Inconvertible OS error: {}", e);
+                return Err(Error::EIO);
+            }
+        },
+    }
+
+    opts.access_mode(access_mode.bits())
+        .custom_flags(flags.bits())
+        .open(&path)
+        .map_err(Into::into)
+}
+
+fn dirent_from_path<P: AsRef<Path>>(
+    path: P,
+    name: &str,
+    cookie: wasi::__wasi_dircookie_t,
+) -> Result<Dirent> {
+    let path = path.as_ref();
+    trace!("dirent_from_path: opening {}", path.to_string_lossy());
+
+    // To open a directory on Windows, FILE_FLAG_BACKUP_SEMANTICS flag must be used
+    let file = OpenOptions::new()
+        .custom_flags(Flags::FILE_FLAG_BACKUP_SEMANTICS.bits())
+        .read(true)
+        .open(path)?;
+    let ty = file.metadata()?.file_type();
+    Ok(Dirent {
+        ftype: filetype_from_std(&ty),
+        name: name.to_owned(),
+        cookie,
+        ino: file_serial_no(&file)?,
+    })
+}
+
+// On Windows there is apparently no support for seeking the directory stream in the OS.
+// cf. https://github.com/WebAssembly/WASI/issues/61
+//
+// The implementation here may perform in O(n^2) if the host buffer is O(1)
+// and the number of directory entries is O(n).
+// TODO: Add a heuristic optimization to achieve O(n) time in the most common case
+//      where fd_readdir is resumed where it previously finished
+//
+// Correctness of this approach relies upon one assumption: that the order of entries
+// returned by `FindNextFileW` is stable, i.e. doesn't change if the directory
+// contents stay the same. This invariant is crucial to be able to implement
+// any kind of seeking whatsoever without having to read the whole directory at once
+// and then return the data from cache. (which leaks memory)
+//
+// The MSDN documentation explicitly says that the order in which the search returns the files
+// is not guaranteed, and is dependent on the file system.
+// cf. https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-findnextfilew
+//
+// This stackoverflow post suggests that `FindNextFileW` is indeed stable and that
+// the order of directory entries depends **only** on the filesystem used, but the
+// MSDN documentation is not clear about this.
+// cf. https://stackoverflow.com/questions/47380739/is-findfirstfile-and-findnextfile-order-random-even-for-dvd
+//
+// Implementation details:
+// Cookies for the directory entries start from 1. (0 is reserved by wasi::__WASI_DIRCOOKIE_START)
+// .        gets cookie = 1
+// ..       gets cookie = 2
+// other entries, in order they were returned by FindNextFileW get subsequent integers as their cookies
+pub(crate) fn fd_readdir_impl(
+    fd: &File,
+    cookie: wasi::__wasi_dircookie_t,
+) -> Result<impl Iterator<Item = Result<Dirent>>> {
+    use winx::file::get_file_path;
+
+    let cookie = cookie.try_into()?;
+    let path = get_file_path(fd)?;
+    // std::fs::ReadDir doesn't return . and .., so we need to emulate it
+    let path = Path::new(&path);
+    // The directory /.. is the same as / on Unix (at least on ext4), so emulate this behavior too
+    let parent = path.parent().unwrap_or(path);
+    let dot = dirent_from_path(path, ".", 1)?;
+    let dotdot = dirent_from_path(parent, "..", 2)?;
+
+    trace!("    | fd_readdir impl: executing std::fs::ReadDir");
+    let iter = path.read_dir()?.zip(3..).map(|(dir, no)| {
+        let dir: std::fs::DirEntry = dir?;
+
+        Ok(Dirent {
+            name: path_from_host(dir.file_name())?,
+            ftype: filetype_from_std(&dir.file_type()?),
+            ino: File::open(dir.path()).and_then(|f| file_serial_no(&f))?,
+            cookie: no,
+        })
+    });
+
+    // into_iter for arrays is broken and returns references instead of values,
+    // so we need to use vec![...] and do heap allocation
+    // See https://github.com/rust-lang/rust/issues/25725
+    let iter = vec![dot, dotdot].into_iter().map(Ok).chain(iter);
+
+    // Emulate seekdir(). This may give O(n^2) complexity if used with a
+    // small host_buf, but this is difficult to implement efficiently.
+    //
+    // See https://github.com/WebAssembly/WASI/issues/61 for more details.
+    Ok(iter.skip(cookie))
+}
+
+// This should actually be common code with Linux
+pub(crate) fn fd_readdir(
+    os_file: &mut OsFile,
+    mut host_buf: &mut [u8],
+    cookie: wasi::__wasi_dircookie_t,
+) -> Result<usize> {
+    let iter = fd_readdir_impl(os_file, cookie)?;
+    let mut used = 0;
+    for dirent in iter {
+        let dirent_raw = dirent?.to_wasi_raw()?;
+        let offset = dirent_raw.len();
+        if host_buf.len() < offset {
+            break;
+        } else {
+            host_buf[0..offset].copy_from_slice(&dirent_raw);
+            used += offset;
+            host_buf = &mut host_buf[offset..];
+        }
+    }
+
+    trace!("     | *buf_used={:?}", used);
+    Ok(used)
+}
+
+pub(crate) fn path_readlink(resolved: PathGet, buf: &mut [u8]) -> Result<usize> {
+    use winx::file::get_file_path;
+
+    let path = resolved.concatenate()?;
+    let target_path = path.read_link()?;
+
+    // since on Windows we are effectively emulating 'at' syscalls
+    // we need to strip the prefix from the absolute path
+    // as otherwise we will error out since WASI is not capable
+    // of dealing with absolute paths
+    let dir_path = get_file_path(resolved.dirfd())?;
+    let dir_path = PathBuf::from(strip_extended_prefix(dir_path));
+    let target_path = target_path
+        .strip_prefix(dir_path)
+        .map_err(|_| Error::ENOTCAPABLE)
+        .and_then(|path| path.to_str().map(String::from).ok_or(Error::EILSEQ))?;
+
+    if buf.len() > 0 {
+        let mut chars = target_path.chars();
+        let mut nread = 0usize;
+
+        for i in 0..buf.len() {
+            match chars.next() {
+                Some(ch) => {
+                    buf[i] = ch as u8;
+                    nread += 1;
+                }
+                None => break,
+            }
+        }
+
+        Ok(nread)
+    } else {
+        Ok(0)
+    }
+}
+
+fn strip_trailing_slashes_and_concatenate(resolved: &PathGet) -> Result<Option<PathBuf>> {
+    if resolved.path().ends_with('/') {
+        let suffix = resolved.path().trim_end_matches('/');
+        concatenate(resolved.dirfd(), Path::new(suffix)).map(Some)
+    } else {
+        Ok(None)
+    }
+}
+
+pub(crate) fn path_rename(resolved_old: PathGet, resolved_new: PathGet) -> Result<()> {
+    use std::fs;
+
+    let old_path = resolved_old.concatenate()?;
+    let new_path = resolved_new.concatenate()?;
+
+    // First sanity check: check we're not trying to rename dir to file or vice versa.
+    // NB on Windows, the former is actually permitted [std::fs::rename].
+    //
+    // [std::fs::rename]: https://doc.rust-lang.org/std/fs/fn.rename.html
+    if old_path.is_dir() && new_path.is_file() {
+        return Err(Error::ENOTDIR);
+    }
+    // Second sanity check: check we're not trying to rename a file into a path
+    // ending in a trailing slash.
+    if old_path.is_file() && resolved_new.path().ends_with('/') {
+        return Err(Error::ENOTDIR);
+    }
+
+    // TODO handle symlinks
+
+    fs::rename(&old_path, &new_path).or_else(|e| match e.raw_os_error() {
+        Some(e) => {
+            use winx::winerror::WinError;
+
+            log::debug!("path_rename at rename error code={:?}", e);
+            match WinError::from_u32(e as u32) {
+                WinError::ERROR_ACCESS_DENIED => {
+                    // So most likely dealing with new_path == dir.
+                    // Eliminate case old_path == file first.
+                    if old_path.is_file() {
+                        Err(Error::EISDIR)
+                    } else {
+                        // Ok, let's try removing an empty dir at new_path if it exists
+                        // and is a nonempty dir.
+                        fs::remove_dir(&new_path)
+                            .and_then(|()| fs::rename(old_path, new_path))
+                            .map_err(Into::into)
+                    }
+                }
+                WinError::ERROR_INVALID_NAME => {
+                    // If source contains trailing slashes, check if we are dealing with
+                    // a file instead of a dir, and if so, throw ENOTDIR.
+                    if let Some(path) = strip_trailing_slashes_and_concatenate(&resolved_old)? {
+                        if path.is_file() {
+                            return Err(Error::ENOTDIR);
+                        }
+                    }
+                    Err(WinError::ERROR_INVALID_NAME.into())
+                }
+                e => Err(e.into()),
+            }
+        }
+        None => {
+            log::debug!("Inconvertible OS error: {}", e);
+            Err(Error::EIO)
+        }
+    })
+}
+
+pub(crate) fn num_hardlinks(file: &File, _metadata: &Metadata) -> io::Result<u64> {
+    Ok(winx::file::get_fileinfo(file)?.nNumberOfLinks.into())
+}
+
+pub(crate) fn device_id(file: &File, _metadata: &Metadata) -> io::Result<u64> {
+    Ok(winx::file::get_fileinfo(file)?.dwVolumeSerialNumber.into())
+}
+
+pub(crate) fn file_serial_no(file: &File) -> io::Result<u64> {
+    let info = winx::file::get_fileinfo(file)?;
+    let high = info.nFileIndexHigh;
+    let low = info.nFileIndexLow;
+    let no = ((high as u64) << 32) | (low as u64);
+    Ok(no)
+}
+
+pub(crate) fn change_time(file: &File, _metadata: &Metadata) -> io::Result<i64> {
+    winx::file::change_time(file)
+}
+
+pub(crate) fn fd_filestat_get_impl(file: &std::fs::File) -> Result<wasi::__wasi_filestat_t> {
+    let metadata = file.metadata()?;
+    Ok(wasi::__wasi_filestat_t {
+        st_dev: device_id(file, &metadata)?,
+        st_ino: file_serial_no(file)?,
+        st_nlink: num_hardlinks(file, &metadata)?.try_into()?, // u64 doesn't fit into u32
+        st_size: metadata.len(),
+        st_atim: systemtime_to_timestamp(metadata.accessed()?)?,
+        st_ctim: change_time(file, &metadata)?.try_into()?, // i64 doesn't fit into u64
+        st_mtim: systemtime_to_timestamp(metadata.modified()?)?,
+        st_filetype: filetype_from_std(&metadata.file_type()).to_wasi(),
+    })
+}
+
+pub(crate) fn filetype_from_std(ftype: &std::fs::FileType) -> FileType {
+    if ftype.is_file() {
+        FileType::RegularFile
+    } else if ftype.is_dir() {
+        FileType::Directory
+    } else if ftype.is_symlink() {
+        FileType::Symlink
+    } else {
+        FileType::Unknown
+    }
+}
+
+pub(crate) fn path_filestat_get(
+    resolved: PathGet,
+    dirflags: wasi::__wasi_lookupflags_t,
+) -> Result<wasi::__wasi_filestat_t> {
+    let path = resolved.concatenate()?;
+    let file = File::open(path)?;
+    fd_filestat_get_impl(&file)
+}
+
+pub(crate) fn path_filestat_set_times(
+    resolved: PathGet,
+    dirflags: wasi::__wasi_lookupflags_t,
+    st_atim: wasi::__wasi_timestamp_t,
+    mut st_mtim: wasi::__wasi_timestamp_t,
+    fst_flags: wasi::__wasi_fstflags_t,
+) -> Result<()> {
+    use winx::file::AccessMode;
+    let path = resolved.concatenate()?;
+    let file = OpenOptions::new()
+        .access_mode(AccessMode::FILE_WRITE_ATTRIBUTES.bits())
+        .open(path)?;
+    fd_filestat_set_times_impl(&file, st_atim, st_mtim, fst_flags)
+}
+
+pub(crate) fn path_symlink(old_path: &str, resolved: PathGet) -> Result<()> {
+    use std::os::windows::fs::{symlink_dir, symlink_file};
+    use winx::winerror::WinError;
+
+    let old_path = concatenate(resolved.dirfd(), Path::new(old_path))?;
+    let new_path = resolved.concatenate()?;
+
+    // try creating a file symlink
+    symlink_file(&old_path, &new_path).or_else(|e| {
+        match e.raw_os_error() {
+            Some(e) => {
+                log::debug!("path_symlink at symlink_file error code={:?}", e);
+                match WinError::from_u32(e as u32) {
+                    WinError::ERROR_NOT_A_REPARSE_POINT => {
+                        // try creating a dir symlink instead
+                        symlink_dir(old_path, new_path).map_err(Into::into)
+                    }
+                    WinError::ERROR_ACCESS_DENIED => {
+                        // does the target exist?
+                        if new_path.exists() {
+                            Err(Error::EEXIST)
+                        } else {
+                            Err(WinError::ERROR_ACCESS_DENIED.into())
+                        }
+                    }
+                    WinError::ERROR_INVALID_NAME => {
+                        // does the target without trailing slashes exist?
+                        if let Some(path) = strip_trailing_slashes_and_concatenate(&resolved)? {
+                            if path.exists() {
+                                return Err(Error::EEXIST);
+                            }
+                        }
+                        Err(WinError::ERROR_INVALID_NAME.into())
+                    }
+                    e => Err(e.into()),
+                }
+            }
+            None => {
+                log::debug!("Inconvertible OS error: {}", e);
+                Err(Error::EIO)
+            }
+        }
+    })
+}
+
+pub(crate) fn path_unlink_file(resolved: PathGet) -> Result<()> {
+    use std::fs;
+    use winx::winerror::WinError;
+
+    let path = resolved.concatenate()?;
+    let file_type = path
+        .symlink_metadata()
+        .map(|metadata| metadata.file_type())?;
+
+    // check if we're unlinking a symlink
+    // NB this will get cleaned up a lot when [std::os::windows::fs::FileTypeExt]
+    // stabilises
+    //
+    // [std::os::windows::fs::FileTypeExt]: https://doc.rust-lang.org/std/os/windows/fs/trait.FileTypeExt.html
+    if file_type.is_symlink() {
+        fs::remove_file(&path).or_else(|e| {
+            match e.raw_os_error() {
+                Some(e) => {
+                    log::debug!("path_unlink_file at symlink_file error code={:?}", e);
+                    match WinError::from_u32(e as u32) {
+                        WinError::ERROR_ACCESS_DENIED => {
+                            // try unlinking a dir symlink instead
+                            fs::remove_dir(path).map_err(Into::into)
+                        }
+                        e => Err(e.into()),
+                    }
+                }
+                None => {
+                    log::debug!("Inconvertible OS error: {}", e);
+                    Err(Error::EIO)
+                }
+            }
+        })
+    } else if file_type.is_dir() {
+        Err(Error::EISDIR)
+    } else if file_type.is_file() {
+        fs::remove_file(path).map_err(Into::into)
+    } else {
+        Err(Error::EINVAL)
+    }
+}
+
+pub(crate) fn path_remove_directory(resolved: PathGet) -> Result<()> {
+    let path = resolved.concatenate()?;
+    std::fs::remove_dir(&path).map_err(Into::into)
+}

crates/wasi-common/src/sys/windows/hostcalls_impl/fs_helpers.rs

@@ -0,0 +1,149 @@
+#![allow(non_camel_case_types)]
+use crate::hostcalls_impl::PathGet;
+use crate::{wasi, Error, Result};
+use std::ffi::{OsStr, OsString};
+use std::fs::File;
+use std::os::windows::ffi::{OsStrExt, OsStringExt};
+use std::path::{Path, PathBuf};
+
+pub(crate) trait PathGetExt {
+    fn concatenate(&self) -> Result<PathBuf>;
+}
+
+impl PathGetExt for PathGet {
+    fn concatenate(&self) -> Result<PathBuf> {
+        concatenate(self.dirfd(), Path::new(self.path()))
+    }
+}
+
+pub(crate) fn path_open_rights(
+    rights_base: wasi::__wasi_rights_t,
+    rights_inheriting: wasi::__wasi_rights_t,
+    oflags: wasi::__wasi_oflags_t,
+    fdflags: wasi::__wasi_fdflags_t,
+) -> (wasi::__wasi_rights_t, wasi::__wasi_rights_t) {
+    // which rights are needed on the dirfd?
+    let mut needed_base = wasi::__WASI_RIGHT_PATH_OPEN;
+    let mut needed_inheriting = rights_base | rights_inheriting;
+
+    // convert open flags
+    if oflags & wasi::__WASI_O_CREAT != 0 {
+        needed_base |= wasi::__WASI_RIGHT_PATH_CREATE_FILE;
+    } else if oflags & wasi::__WASI_O_TRUNC != 0 {
+        needed_base |= wasi::__WASI_RIGHT_PATH_FILESTAT_SET_SIZE;
+    }
+
+    // convert file descriptor flags
+    if fdflags & wasi::__WASI_FDFLAG_DSYNC != 0
+        || fdflags & wasi::__WASI_FDFLAG_RSYNC != 0
+        || fdflags & wasi::__WASI_FDFLAG_SYNC != 0
+    {
+        needed_inheriting |= wasi::__WASI_RIGHT_FD_DATASYNC;
+        needed_inheriting |= wasi::__WASI_RIGHT_FD_SYNC;
+    }
+
+    (needed_base, needed_inheriting)
+}
+
+pub(crate) fn openat(dirfd: &File, path: &str) -> Result<File> {
+    use std::fs::OpenOptions;
+    use std::os::windows::fs::OpenOptionsExt;
+    use winx::file::Flags;
+    use winx::winerror::WinError;
+
+    let path = concatenate(dirfd, Path::new(path))?;
+    OpenOptions::new()
+        .read(true)
+        .custom_flags(Flags::FILE_FLAG_BACKUP_SEMANTICS.bits())
+        .open(&path)
+        .map_err(|e| match e.raw_os_error() {
+            Some(e) => {
+                log::debug!("openat error={:?}", e);
+                match WinError::from_u32(e as u32) {
+                    WinError::ERROR_INVALID_NAME => Error::ENOTDIR,
+                    e => e.into(),
+                }
+            }
+            None => {
+                log::debug!("Inconvertible OS error: {}", e);
+                Error::EIO
+            }
+        })
+}
+
+pub(crate) fn readlinkat(dirfd: &File, s_path: &str) -> Result<String> {
+    use winx::file::get_file_path;
+    use winx::winerror::WinError;
+
+    let path = concatenate(dirfd, Path::new(s_path))?;
+    match path.read_link() {
+        Ok(target_path) => {
+            // since on Windows we are effectively emulating 'at' syscalls
+            // we need to strip the prefix from the absolute path
+            // as otherwise we will error out since WASI is not capable
+            // of dealing with absolute paths
+            let dir_path = get_file_path(dirfd)?;
+            let dir_path = PathBuf::from(strip_extended_prefix(dir_path));
+            target_path
+                .strip_prefix(dir_path)
+                .map_err(|_| Error::ENOTCAPABLE)
+                .and_then(|path| path.to_str().map(String::from).ok_or(Error::EILSEQ))
+        }
+        Err(e) => match e.raw_os_error() {
+            Some(e) => {
+                log::debug!("readlinkat error={:?}", e);
+                match WinError::from_u32(e as u32) {
+                    WinError::ERROR_INVALID_NAME => {
+                        if s_path.ends_with('/') {
+                            // strip "/" and check if exists
+                            let path = concatenate(dirfd, Path::new(s_path.trim_end_matches('/')))?;
+                            if path.exists() && !path.is_dir() {
+                                Err(Error::ENOTDIR)
+                            } else {
+                                Err(Error::ENOENT)
+                            }
+                        } else {
+                            Err(Error::ENOENT)
+                        }
+                    }
+                    e => Err(e.into()),
+                }
+            }
+            None => {
+                log::debug!("Inconvertible OS error: {}", e);
+                Err(Error::EIO)
+            }
+        },
+    }
+}
+
+pub(crate) fn strip_extended_prefix<P: AsRef<OsStr>>(path: P) -> OsString {
+    let path: Vec<u16> = path.as_ref().encode_wide().collect();
+    if &[92, 92, 63, 92] == &path[0..4] {
+        OsString::from_wide(&path[4..])
+    } else {
+        OsString::from_wide(&path)
+    }
+}
+
+pub(crate) fn concatenate<P: AsRef<Path>>(dirfd: &File, path: P) -> Result<PathBuf> {
+    use winx::file::get_file_path;
+
+    // WASI is not able to deal with absolute paths
+    // so error out if absolute
+    if path.as_ref().is_absolute() {
+        return Err(Error::ENOTCAPABLE);
+    }
+
+    let dir_path = get_file_path(dirfd)?;
+    // concatenate paths
+    let mut out_path = PathBuf::from(dir_path);
+    out_path.push(path.as_ref());
+    // strip extended prefix; otherwise we will error out on any relative
+    // components with `out_path`
+    let out_path = PathBuf::from(strip_extended_prefix(out_path));
+
+    log::debug!("out_path={:?}", out_path);
+
+    Ok(out_path)
+}

crates/wasi-common/src/sys/windows/hostcalls_impl/misc.rs

@@ -0,0 +1,119 @@
+#![allow(non_camel_case_types)]
+#![allow(unused_unsafe)]
+#![allow(unused)]
+use crate::helpers::systemtime_to_timestamp;
+use crate::hostcalls_impl::{ClockEventData, FdEventData};
+use crate::memory::*;
+use crate::sys::host_impl;
+use crate::{wasi, wasi32, Error, Result};
+use cpu_time::{ProcessTime, ThreadTime};
+use lazy_static::lazy_static;
+use std::convert::TryInto;
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+
+lazy_static! {
+    static ref START_MONOTONIC: Instant = Instant::now();
+    static ref PERF_COUNTER_RES: u64 = get_perf_counter_resolution_ns();
+}
+
+// Timer resolution on Windows is really hard. We may consider exposing the resolution of the respective
+// timers as an associated function in the future.
+pub(crate) fn clock_res_get(clock_id: wasi::__wasi_clockid_t) -> Result<wasi::__wasi_timestamp_t> {
+    Ok(match clock_id {
+        // This is the best that we can do with std::time::SystemTime.
+        // Rust uses GetSystemTimeAsFileTime, which is said to have the resolution of
+        // 10ms or 55ms, [1] but MSDN doesn't confirm this in any way.
+        // Even the MSDN article on high resolution timestamps doesn't even mention the precision
+        // for this method. [3]
+        //
+        // The timer resolution can be queried using one of the functions: [2, 5]
+        // * NtQueryTimerResolution, which is undocumented and thus not exposed by the winapi crate
+        // * timeGetDevCaps, which returns the upper and lower bound for the precision, in ms.
+        // While the upper bound seems like something we could use, it's typically too high to be meaningful.
+        // For instance, the intervals return by the syscall are:
+        // * [1, 65536] on Wine
+        // * [1, 1000000] on Windows 10, which is up to (sic) 1000 seconds.
+        //
+        // It's possible to manually set the timer resolution, but this sounds like something which should
+        // only be done temporarily. [5]
+        //
+        // Alternatively, we could possibly use GetSystemTimePreciseAsFileTime in clock_time_get, but
+        // this syscall is only available starting from Windows 8.
+        // (we could possibly emulate it on earlier versions of Windows, see [4])
+        // The MSDN are not clear on the resolution of GetSystemTimePreciseAsFileTime either, but a
+        // Microsoft devblog entry [1] suggests that it kind of combines GetSystemTimeAsFileTime with
+        // QueryPeformanceCounter, which probably means that those two should have the same resolution.
+        //
+        // See also this discussion about the use of GetSystemTimePreciseAsFileTime in Python stdlib,
+        // which in particular contains some resolution benchmarks.
+        //
+        // [1] https://devblogs.microsoft.com/oldnewthing/20170921-00/?p=97057
+        // [2] http://www.windowstimestamp.com/description
+        // [3] https://docs.microsoft.com/en-us/windows/win32/sysinfo/acquiring-high-resolution-time-stamps?redirectedfrom=MSDN
+        // [4] https://www.codeproject.com/Tips/1011902/High-Resolution-Time-For-Windows
+        // [5] https://stackoverflow.com/questions/7685762/windows-7-timing-functions-how-to-use-getsystemtimeadjustment-correctly
+        // [6] https://bugs.python.org/issue19007
+        wasi::__WASI_CLOCK_REALTIME => 55_000_000,
+        // std::time::Instant uses QueryPerformanceCounter & QueryPerformanceFrequency internally
+        wasi::__WASI_CLOCK_MONOTONIC => *PERF_COUNTER_RES,
+        // The best we can do is to hardcode the value from the docs.
+        // https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getprocesstimes
+        wasi::__WASI_CLOCK_PROCESS_CPUTIME_ID => 100,
+        // The best we can do is to hardcode the value from the docs.
+        // https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getthreadtimes
+        wasi::__WASI_CLOCK_THREAD_CPUTIME_ID => 100,
+        _ => return Err(Error::EINVAL),
+    })
+}
+
+pub(crate) fn clock_time_get(clock_id: wasi::__wasi_clockid_t) -> Result<wasi::__wasi_timestamp_t> {
+    let duration = match clock_id {
+        wasi::__WASI_CLOCK_REALTIME => get_monotonic_time(),
+        wasi::__WASI_CLOCK_MONOTONIC => get_realtime_time()?,
+        wasi::__WASI_CLOCK_PROCESS_CPUTIME_ID => get_proc_cputime()?,
+        wasi::__WASI_CLOCK_THREAD_CPUTIME_ID => get_thread_cputime()?,
+        _ => return Err(Error::EINVAL),
+    };
+    duration.as_nanos().try_into().map_err(Into::into)
+}
+
+pub(crate) fn poll_oneoff(
+    timeout: Option<ClockEventData>,
+    fd_events: Vec<FdEventData>,
+    events: &mut Vec<wasi::__wasi_event_t>,
+) -> Result<Vec<wasi::__wasi_event_t>> {
+    unimplemented!("poll_oneoff")
+}
+
+fn get_monotonic_time() -> Duration {
+    // We're circumventing the fact that we can't get a Duration from an Instant
+    // The epoch of __WASI_CLOCK_MONOTONIC is undefined, so we fix a time point once
+    // and count relative to this time point.
+    //
+    // The alternative would be to copy over the implementation of std::time::Instant
+    // to our source tree and add a conversion to std::time::Duration
+    START_MONOTONIC.elapsed()
+}
+
+fn get_realtime_time() -> Result<Duration> {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map_err(|_| Error::EFAULT)
+}
+
+fn get_proc_cputime() -> Result<Duration> {
+    Ok(ProcessTime::try_now()?.as_duration())
+}
+
+fn get_thread_cputime() -> Result<Duration> {
+    Ok(ThreadTime::try_now()?.as_duration())
+}
+
+fn get_perf_counter_resolution_ns() -> u64 {
+    use winx::time::perf_counter_frequency;
+    const NANOS_PER_SEC: u64 = 1_000_000_000;
+    // This should always succeed starting from Windows XP, so it's fine to panic in case of an error.
+    let freq = perf_counter_frequency().expect("QueryPerformanceFrequency returned an error");
+    let epsilon = NANOS_PER_SEC / freq;
+    epsilon
+}

crates/wasi-common/src/sys/windows/hostcalls_impl/mod.rs

@@ -0,0 +1,8 @@
+//! Windows-specific hostcalls that implement
+//! [WASI](https://github.com/CraneStation/wasmtime-wasi/blob/wasi/docs/WASI-overview.md).
+mod fs;
+pub(crate) mod fs_helpers;
+mod misc;
+
+pub(crate) use self::fs::*;
+pub(crate) use self::misc::*;

crates/wasi-common/src/sys/windows/mod.rs

@@ -0,0 +1,32 @@
+pub(crate) mod fdentry_impl;
+pub(crate) mod host_impl;
+pub(crate) mod hostcalls_impl;
+
+use crate::Result;
+use std::fs::{File, OpenOptions};
+use std::path::Path;
+
+pub(crate) fn dev_null() -> Result<File> {
+    OpenOptions::new()
+        .read(true)
+        .write(true)
+        .open("NUL")
+        .map_err(Into::into)
+}
+
+pub fn preopen_dir<P: AsRef<Path>>(path: P) -> Result<File> {
+    use std::fs::OpenOptions;
+    use std::os::windows::fs::OpenOptionsExt;
+    use winapi::um::winbase::FILE_FLAG_BACKUP_SEMANTICS;
+
+    // To open a directory using CreateFile, specify the
+    // FILE_FLAG_BACKUP_SEMANTICS flag as part of dwFileFlags...
+    // cf. https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-createfile2
+    OpenOptions::new()
+        .create(false)
+        .write(true)
+        .read(true)
+        .attributes(FILE_FLAG_BACKUP_SEMANTICS)
+        .open(path)
+        .map_err(Into::into)
+}