Compile wasi-common to Emscripten (#688)

* Compile wasi-common to Emscripten

This commit enables cross-compiling of `wasi-common` to Emscripten. To achieve
this, this commit does quite a bit reshuffling in the existing codebase. Namely,
* rename `linux` modules in `wasi-common` and `yanix` to `linux_like` -- this is
  needed so that we can separate out logic specific to Linux and Emscripten out
* tweak `dir` module in `yanix` to support Emscripten -- in particular, the main
  change involves `SeekLoc::from_raw` which has to be now host-specific, and is now
  fallible
* tweak `filetime` so that in Emscripten we never check for existence of `utimensat`
  at runtime since we are guaranteed for it to exist by design
* since `utimes` and `futimes` are not present in Emscripten, move them into a separate
  module, `utimesat`, and tag it cfg-non-emscripten only
* finally, `to_timespec` is now fallible since on Emscripten we have to cast number of
  seconds, `FileTime::seconds` from `i64` to `libc::c_long` which resolves to `i32`
  unlike on other nixes

* Fix macos build

* Verify wasi-common compiles to Emscripten

This commit adds `emscripten` job to Github Actions which installs
`wasm32-unknown-emscripten` target, and builds `wasi-common` crate.

* Use #[path] to cherry-pick mods for Emscripten

This commit effectively reverses the reorg introduced in 145f4a5
in that it ditches `linux_like` mod for separate mods `linux` and
`emscripten` which are now on the same crate level, and instead,
pulls in common bits from `linux` using the `#[path = ..]` proc
macro.

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

@@ -1,6 +1,6 @@
 //! This internal module consists of helper types and functions for dealing
 //! with setting the file times specific to Linux.
-use super::super::filetime::FileTime;
+use crate::{sys::unix::filetime::FileTime, Result};
 use std::fs::File;
 use std::io;
 use std::sync::atomic::{AtomicBool, Ordering::Relaxed};
@@ -20,8 +20,8 @@ pub(crate) fn utimensat(
     atime: FileTime,
     mtime: FileTime,
     symlink_nofollow: bool,
-) -> io::Result<()> {
-    use super::super::filetime::{to_timespec, utimesat};
+) -> Result<()> {
+    use crate::sys::unix::filetime::to_timespec;
     use std::ffi::CString;
     use std::os::unix::prelude::*;
 
@@ -53,9 +53,9 @@ pub(crate) fn utimensat(
         if err.raw_os_error() == Some(libc::ENOSYS) {
             INVALID.store(true, Relaxed);
         } else {
-            return Err(err);
+            return Err(err.into());
         }
     }
 
-    utimesat(dirfd, path, atime, mtime, symlink_nofollow)
+    super::utimesat::utimesat(dirfd, path, atime, mtime, symlink_nofollow)
 }

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

@@ -0,0 +1,11 @@
+use crate::{wasi, Result};
+
+pub(crate) const O_RSYNC: yanix::file::OFlag = yanix::file::OFlag::RSYNC;
+
+pub(crate) fn stdev_from_nix(dev: libc::dev_t) -> Result<wasi::__wasi_device_t> {
+    Ok(wasi::__wasi_device_t::from(dev))
+}
+
+pub(crate) fn stino_from_nix(ino: libc::ino_t) -> Result<wasi::__wasi_inode_t> {
+    Ok(wasi::__wasi_device_t::from(ino))
+}

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

@@ -1,17 +1,5 @@
 pub(crate) mod filetime;
+pub(crate) mod host_impl;
 pub(crate) mod hostcalls_impl;
 pub(crate) mod oshandle;
-
-pub(crate) mod host_impl {
-    use crate::{wasi, Result};
-
-    pub(crate) const O_RSYNC: yanix::file::OFlag = yanix::file::OFlag::RSYNC;
-
-    pub(crate) fn stdev_from_nix(dev: libc::dev_t) -> Result<wasi::__wasi_device_t> {
-        Ok(wasi::__wasi_device_t::from(dev))
-    }
-
-    pub(crate) fn stino_from_nix(ino: libc::ino_t) -> Result<wasi::__wasi_inode_t> {
-        Ok(wasi::__wasi_device_t::from(ino))
-    }
-}
+pub(crate) mod utimesat;

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

@@ -0,0 +1,88 @@
+use crate::sys::unix::filetime::FileTime;
+use crate::Result;
+use std::{fs, io};
+
+/// Combines `openat` with `utimes` to emulate `utimensat` on platforms where it is
+/// not available. The logic for setting file times is based on [filetime::unix::set_file_handles_times].
+///
+/// [filetime::unix::set_file_handles_times]: https://github.com/alexcrichton/filetime/blob/master/src/unix/utimes.rs#L24
+pub(crate) fn utimesat(
+    dirfd: &fs::File,
+    path: &str,
+    atime: FileTime,
+    mtime: FileTime,
+    symlink_nofollow: bool,
+) -> Result<()> {
+    use std::ffi::CString;
+    use std::os::unix::prelude::*;
+    // emulate *at syscall by reading the path from a combination of
+    // (fd, path)
+    let p = CString::new(path.as_bytes())?;
+    let mut flags = libc::O_RDWR;
+    if symlink_nofollow {
+        flags |= libc::O_NOFOLLOW;
+    }
+    let fd = unsafe { libc::openat(dirfd.as_raw_fd(), p.as_ptr(), flags) };
+    let f = unsafe { fs::File::from_raw_fd(fd) };
+    let (atime, mtime) = get_times(atime, mtime, || f.metadata().map_err(Into::into))?;
+    let times = [to_timeval(atime), to_timeval(mtime)];
+    let rc = unsafe { libc::futimes(f.as_raw_fd(), times.as_ptr()) };
+    if rc == 0 {
+        Ok(())
+    } else {
+        Err(io::Error::last_os_error().into())
+    }
+}
+
+/// Converts `filetime::FileTime` to `libc::timeval`. This function was taken directly from
+/// [filetime] crate.
+///
+/// [filetime]: https://github.com/alexcrichton/filetime/blob/master/src/unix/utimes.rs#L93
+fn to_timeval(ft: filetime::FileTime) -> libc::timeval {
+    libc::timeval {
+        tv_sec: ft.seconds(),
+        tv_usec: (ft.nanoseconds() / 1000) as libc::suseconds_t,
+    }
+}
+
+/// For a provided pair of access and modified `FileTime`s, converts the input to
+/// `filetime::FileTime` used later in `utimensat` function. For variants `FileTime::Now`
+/// and `FileTime::Omit`, this function will make two syscalls: either accessing current
+/// system time, or accessing the file's metadata.
+///
+/// The original implementation can be found here: [filetime::unix::get_times].
+///
+/// [filetime::unix::get_times]: https://github.com/alexcrichton/filetime/blob/master/src/unix/utimes.rs#L42
+fn get_times(
+    atime: FileTime,
+    mtime: FileTime,
+    current: impl Fn() -> Result<fs::Metadata>,
+) -> Result<(filetime::FileTime, filetime::FileTime)> {
+    use std::time::SystemTime;
+
+    let atime = match atime {
+        FileTime::Now => {
+            let time = SystemTime::now();
+            filetime::FileTime::from_system_time(time)
+        }
+        FileTime::Omit => {
+            let meta = current()?;
+            filetime::FileTime::from_last_access_time(&meta)
+        }
+        FileTime::FileTime(ft) => ft,
+    };
+
+    let mtime = match mtime {
+        FileTime::Now => {
+            let time = SystemTime::now();
+            filetime::FileTime::from_system_time(time)
+        }
+        FileTime::Omit => {
+            let meta = current()?;
+            filetime::FileTime::from_last_modification_time(&meta)
+        }
+        FileTime::FileTime(ft) => ft,
+    };
+
+    Ok((atime, mtime))
+}