Initial reorg.

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

crates/wasi-common/src/sys/unix/linux/hostcalls_impl.rs

@@ -0,0 +1,165 @@
+use super::super::dir::{Dir, Entry, SeekLoc};
+use super::osfile::OsFile;
+use crate::hostcalls_impl::{Dirent, PathGet};
+use crate::sys::host_impl;
+use crate::sys::unix::str_to_cstring;
+use crate::{wasi, Error, Result};
+use log::trace;
+use std::convert::TryInto;
+use std::fs::File;
+use std::os::unix::prelude::AsRawFd;
+
+pub(crate) fn path_unlink_file(resolved: PathGet) -> Result<()> {
+    use nix::errno;
+    use nix::libc::unlinkat;
+
+    let path_cstr = str_to_cstring(resolved.path())?;
+
+    // nix doesn't expose unlinkat() yet
+    let res = unsafe { unlinkat(resolved.dirfd().as_raw_fd(), path_cstr.as_ptr(), 0) };
+    if res == 0 {
+        Ok(())
+    } else {
+        Err(host_impl::errno_from_nix(errno::Errno::last()))
+    }
+}
+
+pub(crate) fn path_symlink(old_path: &str, resolved: PathGet) -> Result<()> {
+    use nix::{errno::Errno, libc::symlinkat};
+
+    let old_path_cstr = str_to_cstring(old_path)?;
+    let new_path_cstr = str_to_cstring(resolved.path())?;
+
+    log::debug!("path_symlink old_path = {:?}", old_path);
+    log::debug!("path_symlink resolved = {:?}", resolved);
+
+    let res = unsafe {
+        symlinkat(
+            old_path_cstr.as_ptr(),
+            resolved.dirfd().as_raw_fd(),
+            new_path_cstr.as_ptr(),
+        )
+    };
+    if res != 0 {
+        Err(host_impl::errno_from_nix(Errno::last()))
+    } else {
+        Ok(())
+    }
+}
+
+pub(crate) fn path_rename(resolved_old: PathGet, resolved_new: PathGet) -> Result<()> {
+    use nix::libc::renameat;
+    let old_path_cstr = str_to_cstring(resolved_old.path())?;
+    let new_path_cstr = str_to_cstring(resolved_new.path())?;
+
+    let res = unsafe {
+        renameat(
+            resolved_old.dirfd().as_raw_fd(),
+            old_path_cstr.as_ptr(),
+            resolved_new.dirfd().as_raw_fd(),
+            new_path_cstr.as_ptr(),
+        )
+    };
+    if res != 0 {
+        Err(host_impl::errno_from_nix(nix::errno::Errno::last()))
+    } else {
+        Ok(())
+    }
+}
+
+pub(crate) fn fd_readdir_impl(
+    fd: &File,
+    cookie: wasi::__wasi_dircookie_t,
+) -> Result<impl Iterator<Item = Result<Dirent>>> {
+    // We need to duplicate the fd, because `opendir(3)`:
+    //     After a successful call to fdopendir(), fd is used internally by the implementation,
+    //     and should not otherwise be used by the application.
+    // `opendir(3p)` also says that it's undefined behavior to
+    // modify the state of the fd in a different way than by accessing DIR*.
+    //
+    // Still, rewinddir will be needed because the two file descriptors
+    // share progress. But we can safely execute closedir now.
+    let fd = fd.try_clone()?;
+    let mut dir = Dir::from(fd)?;
+
+    // Seek if needed. Unless cookie is wasi::__WASI_DIRCOOKIE_START,
+    // new items may not be returned to the caller.
+    //
+    // According to `opendir(3p)`:
+    //     If a file is removed from or added to the directory after the most recent call
+    //     to opendir() or rewinddir(), whether a subsequent call to readdir() returns an entry
+    //     for that file is unspecified.
+    if cookie == wasi::__WASI_DIRCOOKIE_START {
+        trace!("     | fd_readdir: doing rewinddir");
+        dir.rewind();
+    } else {
+        trace!("     | fd_readdir: doing seekdir to {}", cookie);
+        let loc = unsafe { SeekLoc::from_raw(cookie as i64) };
+        dir.seek(loc);
+    }
+
+    Ok(dir.into_iter().map(|entry| {
+        let entry: Entry = entry?;
+        Ok(Dirent {
+            name: entry // TODO can we reuse path_from_host for CStr?
+                .file_name()
+                .to_str()?
+                .to_owned(),
+            ino: entry.ino(),
+            ftype: entry.file_type().into(),
+            cookie: entry.seek_loc().to_raw().try_into()?,
+        })
+    }))
+}
+
+// This should actually be common code with Windows,
+// but there's BSD stuff remaining
+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 fd_advise(
+    file: &File,
+    advice: wasi::__wasi_advice_t,
+    offset: wasi::__wasi_filesize_t,
+    len: wasi::__wasi_filesize_t,
+) -> Result<()> {
+    {
+        use nix::fcntl::{posix_fadvise, PosixFadviseAdvice};
+
+        let offset = offset.try_into()?;
+        let len = len.try_into()?;
+        let host_advice = match advice {
+            wasi::__WASI_ADVICE_DONTNEED => PosixFadviseAdvice::POSIX_FADV_DONTNEED,
+            wasi::__WASI_ADVICE_SEQUENTIAL => PosixFadviseAdvice::POSIX_FADV_SEQUENTIAL,
+            wasi::__WASI_ADVICE_WILLNEED => PosixFadviseAdvice::POSIX_FADV_WILLNEED,
+            wasi::__WASI_ADVICE_NOREUSE => PosixFadviseAdvice::POSIX_FADV_NOREUSE,
+            wasi::__WASI_ADVICE_RANDOM => PosixFadviseAdvice::POSIX_FADV_RANDOM,
+            wasi::__WASI_ADVICE_NORMAL => PosixFadviseAdvice::POSIX_FADV_NORMAL,
+            _ => return Err(Error::EINVAL),
+        };
+
+        posix_fadvise(file.as_raw_fd(), offset, len, host_advice)?;
+    }
+
+    Ok(())
+}

crates/wasi-common/src/sys/unix/linux/mod.rs

@@ -0,0 +1,42 @@
+pub(crate) mod hostcalls_impl;
+pub(crate) mod osfile;
+
+pub(crate) mod fdentry_impl {
+    use crate::{sys::host_impl, Result};
+    use std::os::unix::prelude::AsRawFd;
+
+    pub(crate) unsafe fn isatty(fd: &impl AsRawFd) -> Result<bool> {
+        use nix::errno::Errno;
+
+        let res = libc::isatty(fd.as_raw_fd());
+        if res == 1 {
+            // isatty() returns 1 if fd is an open file descriptor referring to a terminal...
+            Ok(true)
+        } else {
+            // ... otherwise 0 is returned, and errno is set to indicate the error.
+            match Errno::last() {
+                // While POSIX specifies ENOTTY if the passed
+                // fd is *not* a tty, on Linux, some implementations
+                // may return EINVAL instead.
+                //
+                // https://linux.die.net/man/3/isatty
+                Errno::ENOTTY | Errno::EINVAL => Ok(false),
+                x => Err(host_impl::errno_from_nix(x)),
+            }
+        }
+    }
+}
+
+pub(crate) mod host_impl {
+    pub(crate) const O_RSYNC: nix::fcntl::OFlag = nix::fcntl::OFlag::O_RSYNC;
+}
+
+pub(crate) mod fs_helpers {
+    pub(crate) fn utime_now() -> libc::c_long {
+        libc::UTIME_NOW
+    }
+
+    pub(crate) fn utime_omit() -> libc::c_long {
+        libc::UTIME_OMIT
+    }
+}

crates/wasi-common/src/sys/unix/linux/osfile.rs

@@ -0,0 +1,32 @@
+use std::fs;
+use std::ops::{Deref, DerefMut};
+use std::os::unix::prelude::{AsRawFd, RawFd};
+
+#[derive(Debug)]
+pub(crate) struct OsFile(fs::File);
+
+impl From<fs::File> for OsFile {
+    fn from(file: fs::File) -> Self {
+        Self(file)
+    }
+}
+
+impl AsRawFd for OsFile {
+    fn as_raw_fd(&self) -> RawFd {
+        self.0.as_raw_fd()
+    }
+}
+
+impl Deref for OsFile {
+    type Target = fs::File;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for OsFile {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}