T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[wasi-common]: add armv7 support to wasi-common (#1269)

Browse Source 
* Add armv7 support to wasi-common

This commit enables `target_pointer_width = 32` compatibility for
`wasi-common` (and by transitivity, any crate found inside, e.g., `yanix`).
I've also added a simplistic (bare minimum) check to our CI to ensure
that `wasi-common` cross-compiles to `armv7-unknown-gnueabihf` fine.
While here, I've done the same for `wasm32-unknown-emscripten`.

* Clean arch-specific impls + reuse libc consts

* Make SeekLoc::from_raw platform independent

* Collapse CI cc jobs into one
This commit is contained in:
Jakub Konka
2020-03-10 19:18:59 +01:00
committed by GitHub
parent 67bfeea16f
commit bd5e71b038
11 changed files with 76 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
.github/workflows/main.yml vendored
View File

@@ -119,19 +119,22 @@ jobs:
env: env:
RUST_BACKTRACE: 1 RUST_BACKTRACE: 1
# Install wasm32-unknown-emscripten target, and ensure `crates/wasi-common` # Check whether `crates/wasi-common` cross-compiles to the following targets:
# compiles to Emscripten. # * wasm32-unknown-emscripten
# TODO enable once rust-lang/rust#66308 is fixed # * armv7-unknown-linux-gnueabihf
# emscripten: crosscompile:
# name: Emscripten name: Cross-platform checks
# runs-on: ubuntu-latest runs-on: ubuntu-latest
# steps: steps:
# - uses: actions/checkout@v1 - uses: actions/checkout@v1
# with: with:
# submodules: true submodules: true
# - uses: ./.github/actions/install-rust - uses: ./.github/actions/install-rust
# - run: rustup target add wasm32-unknown-emscripten - run: |
# - run: cargo build --target wasm32-unknown-emscripten -p wasi-common rustup target add wasm32-unknown-emscripten
cargo check --target wasm32-unknown-emscripten -p wasi-common
rustup target add armv7-unknown-linux-gnueabihf
cargo check --target armv7-unknown-linux-gnueabihf -p wasi-common
# Perform all tests (debug mode) for `wasmtime`. This runs stable/beta/nightly # Perform all tests (debug mode) for `wasmtime`. This runs stable/beta/nightly
# channels of Rust as well as macOS/Linux/Windows. # channels of Rust as well as macOS/Linux/Windows.

8
crates/wasi-common/src/old/snapshot_0/sys/unix/emscripten/host_impl.rs
View File

@@ -1,15 +1,15 @@
use crate::old::snapshot_0::{wasi, Result}; use crate::old::snapshot_0::wasi::{self, WasiResult};
pub(crate) const O_RSYNC: yanix::file::OFlag = yanix::file::OFlag::RSYNC; 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> { pub(crate) fn stdev_from_nix(dev: libc::dev_t) -> WasiResult<wasi::__wasi_device_t> {
Ok(wasi::__wasi_device_t::from(dev)) Ok(wasi::__wasi_device_t::from(dev))
} }
pub(crate) fn stino_from_nix(ino: libc::ino_t) -> Result<wasi::__wasi_inode_t> { pub(crate) fn stino_from_nix(ino: libc::ino_t) -> WasiResult<wasi::__wasi_inode_t> {
Ok(wasi::__wasi_device_t::from(ino)) Ok(wasi::__wasi_device_t::from(ino))
} }
pub(crate) fn stnlink_from_nix(nlink: libc::nlink_t) -> Result<wasi::__wasi_linkcount_t> { pub(crate) fn stnlink_from_nix(nlink: libc::nlink_t) -> WasiResult<wasi::__wasi_linkcount_t> {
Ok(nlink) Ok(nlink)
} }

15
crates/wasi-common/yanix/src/dir.rs
View File

@@ -2,7 +2,8 @@ use crate::{
file::FileType, file::FileType,
sys::dir::{iter_impl, EntryImpl}, sys::dir::{iter_impl, EntryImpl},
}; };
use std::io::Result; use std::convert::TryInto;
use std::io::{Error, Result};
use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd}; use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd};
use std::{ffi::CStr, io, ops::Deref, ptr}; use std::{ffi::CStr, io, ops::Deref, ptr};
@@ -98,6 +99,18 @@ impl SeekLoc {
pub fn to_raw(&self) -> i64 { pub fn to_raw(&self) -> i64 {
self.0.into() self.0.into()
} }
pub unsafe fn from_raw(loc: i64) -> Result<Self> {
// The cookie (or `loc`) is an opaque value, and applications aren't supposed to do
// arithmetic on them or pick their own values or have any awareness of the numeric
// range of the values. They're just supposed to pass back in the values that we
// give them. And any value we give them will be convertable back to `long`,
// because that's the type the OS gives them to us in. So return an `EINVAL`.
let loc = loc
.try_into()
.map_err(|_| Error::from_raw_os_error(libc::EINVAL))?;
Ok(Self(loc))
}
} }
#[derive(Debug)] #[derive(Debug)]

71
crates/wasi-common/yanix/src/filetime.rs
View File

@@ -10,40 +10,34 @@ use std::io::Result;
pub use super::sys::filetime::*; pub use super::sys::filetime::*;
cfg_if::cfg_if! { /// Internal trait which specialises `filetime::FileTime`'s
if #[cfg(not(target_os = "emscripten"))] { /// `seconds` and `nanoseconds` accessors for different
fn filetime_to_timespec(ft: &filetime::FileTime) -> Result<libc::timespec> { /// pointer widths (32 and 64bit currently).
Ok( pub(crate) trait FileTimeExt {
libc::timespec { fn seconds_(&self) -> Result<libc::time_t>;
tv_sec: ft.seconds(), fn nanoseconds_(&self) -> libc::c_long;
tv_nsec: i64::from(ft.nanoseconds()), }
}
) impl FileTimeExt for filetime::FileTime {
} fn seconds_(&self) -> Result<libc::time_t> {
} else { use std::convert::TryInto;
fn filetime_to_timespec(ft: &filetime::FileTime) -> Result<libc::timespec> { use std::io::Error;
use std::convert::TryInto; let sec = match self.seconds().try_into() {
use std::io::Error; Ok(sec) => sec,
// Emscripten expects both `tv_sec` and `tv_nsec` fields to be `i32`. Err(_) => {
// Here however `ft.seconds() -> i64` and `ft.nanoseconds() -> u32` so log::debug!("filetime_to_timespec failed converting seconds to required width");
// a simple `as` cast may be insufficient. So, perform a checked conversion, return Err(Error::from_raw_os_error(libc::EOVERFLOW));
// log error if any, and convert to libc::EOVERFLOW. }
let tv_sec = match ft.seconds().try_into() { };
Ok(sec) => sec, Ok(sec)
Err(_) => { }
log::debug!("filetime_to_timespec failed converting seconds to required width"); fn nanoseconds_(&self) -> libc::c_long {
return Err(Error::from_raw_os_error(libc::EOVERFLOW)); use std::convert::TryInto;
} // According to [filetime] docs, since the nanoseconds value is always less than 1 billion,
}; // any value should be convertible to `libc::c_long`, hence we can `unwrap` outright.
let tv_nsec = match ft.nanoseconds().try_into() { //
Ok(nsec) => nsec, // [filetime]: https://docs.rs/filetime/0.2.8/filetime/struct.FileTime.html#method.nanoseconds
Err(_) => { self.nanoseconds().try_into().unwrap()
log::debug!("filetime_to_timespec failed converting nanoseconds to required width");
return Err(Error::from_raw_os_error(libc::EOVERFLOW));
}
};
Ok(libc::timespec { tv_sec, tv_nsec })
}
} }
} }
@@ -69,13 +63,16 @@ pub(crate) fn to_timespec(ft: &FileTime) -> Result<libc::timespec> {
let ts = match ft { let ts = match ft {
FileTime::Now => libc::timespec { FileTime::Now => libc::timespec {
tv_sec: 0, tv_sec: 0,
tv_nsec: UTIME_NOW, tv_nsec: libc::UTIME_NOW,
}, },
FileTime::Omit => libc::timespec { FileTime::Omit => libc::timespec {
tv_sec: 0, tv_sec: 0,
tv_nsec: UTIME_OMIT, tv_nsec: libc::UTIME_OMIT,
},
FileTime::FileTime(ft) => libc::timespec {
tv_sec: ft.seconds_()?,
tv_nsec: ft.nanoseconds_(),
}, },
FileTime::FileTime(ft) => filetime_to_timespec(ft)?,
}; };
Ok(ts) Ok(ts)
} }

7
crates/wasi-common/yanix/src/sys/bsd/dir.rs
View File

@@ -57,10 +57,3 @@ impl EntryExt for Entry {
Ok(self.0.loc) Ok(self.0.loc)
} }
} }
impl SeekLoc {
pub unsafe fn from_raw(loc: i64) -> Result<Self> {
let loc = loc.into();
Ok(Self(loc))
}
}

23
crates/wasi-common/yanix/src/sys/bsd/filetime.rs
View File

@@ -2,34 +2,11 @@
//! with setting the file times specific to BSD-style *nixes. //! with setting the file times specific to BSD-style *nixes.
use crate::filetime::FileTime; use crate::filetime::FileTime;
use crate::from_success_code; use crate::from_success_code;
use cfg_if::cfg_if;
use std::ffi::CStr; use std::ffi::CStr;
use std::fs::File; use std::fs::File;
use std::io::Result; use std::io::Result;
use std::sync::atomic::{AtomicUsize, Ordering::SeqCst}; use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
cfg_if! {
if #[cfg(any(
target_os = "macos",
target_os = "freebsd",
target_os = "ios",
target_os = "dragonfly"
))] {
pub(crate) const UTIME_NOW: i64 = -1;
pub(crate) const UTIME_OMIT: i64 = -2;
} else if #[cfg(target_os = "openbsd")] {
// These are swapped compared to macos, freebsd, ios, and dragonfly.
// https://github.com/openbsd/src/blob/master/sys/sys/stat.h#L187
pub(crate) const UTIME_NOW: i64 = -2;
pub(crate) const UTIME_OMIT: i64 = -1;
} else if #[cfg(target_os = "netbsd" )] {
// These are the same as for Linux.
// http://cvsweb.netbsd.org/bsdweb.cgi/src/sys/sys/stat.h?rev=1.69&content-type=text/x-cvsweb-markup&only_with_tag=MAIN
pub(crate) const UTIME_NOW: i64 = 1_073_741_823;
pub(crate) const UTIME_OMIT: i64 = 1_073_741_822;
}
}
/// Wrapper for `utimensat` syscall, however, with an added twist such that `utimensat` symbol /// Wrapper for `utimensat` syscall, however, with an added twist such that `utimensat` symbol
/// is firstly resolved (i.e., we check whether it exists on the host), and only used if that is /// is firstly resolved (i.e., we check whether it exists on the host), and only used if that is
/// the case. Otherwise, the syscall resorts to a less accurate `utimesat` emulated syscall. /// the case. Otherwise, the syscall resorts to a less accurate `utimesat` emulated syscall.

3
crates/wasi-common/yanix/src/sys/emscripten/filetime.rs
View File

@@ -5,9 +5,6 @@ use crate::from_success_code;
use std::fs::File; use std::fs::File;
use std::io::Result; use std::io::Result;
pub(crate) const UTIME_NOW: i32 = 1_073_741_823;
pub(crate) const UTIME_OMIT: i32 = 1_073_741_822;
/// Wrapper for `utimensat` syscall. In Emscripten, there is no point in dynamically resolving /// Wrapper for `utimensat` syscall. In Emscripten, there is no point in dynamically resolving
/// if `utimensat` is available as it always was and will be. /// if `utimensat` is available as it always was and will be.
pub fn utimensat( pub fn utimensat(

18
crates/wasi-common/yanix/src/sys/emscripten/mod.rs
View File

@@ -5,21 +5,3 @@ pub(crate) mod fadvise;
#[path = "../linux/file.rs"] #[path = "../linux/file.rs"]
pub(crate) mod file; pub(crate) mod file;
pub(crate) mod filetime; pub(crate) mod filetime;
use crate::dir::SeekLoc;
use std::convert::TryInto;
use std::io::{Error, Result};
impl SeekLoc {
pub unsafe fn from_raw(loc: i64) -> Result<Self> {
// The cookie (or `loc`) is an opaque value, and applications aren't supposed to do
// arithmetic on them or pick their own values or have any awareness of the numeric
// range of the values. They're just supposed to pass back in the values that we
// give them. And any value we give them will be convertable back to `long`,
// because that's the type the OS gives them to us in. So return an `EINVAL`.
let loc = loc
.try_into()
.map_err(|_| Error::from_raw_os_error(libc::EINVAL))?;
Ok(Self(loc))
}
}

3
crates/wasi-common/yanix/src/sys/linux/filetime.rs
View File

@@ -6,9 +6,6 @@ use std::fs::File;
use std::io::Result; use std::io::Result;
use std::sync::atomic::{AtomicBool, Ordering::Relaxed}; use std::sync::atomic::{AtomicBool, Ordering::Relaxed};
pub(crate) const UTIME_NOW: i64 = 1_073_741_823;
pub(crate) const UTIME_OMIT: i64 = 1_073_741_822;
/// Wrapper for `utimensat` syscall, however, with an added twist such that `utimensat` symbol /// Wrapper for `utimensat` syscall, however, with an added twist such that `utimensat` symbol
/// is firstly resolved (i.e., we check whether it exists on the host), and only used if that is /// is firstly resolved (i.e., we check whether it exists on the host), and only used if that is
/// the case. Otherwise, the syscall resorts to a less accurate `utimesat` emulated syscall. /// the case. Otherwise, the syscall resorts to a less accurate `utimesat` emulated syscall.

10
crates/wasi-common/yanix/src/sys/linux/mod.rs
View File

@@ -3,13 +3,3 @@ pub(crate) mod fadvise;
pub(crate) mod file; pub(crate) mod file;
pub(crate) mod filetime; pub(crate) mod filetime;
pub(crate) mod utimesat; pub(crate) mod utimesat;
use crate::dir::SeekLoc;
use std::io::Result;
impl SeekLoc {
pub unsafe fn from_raw(loc: i64) -> Result<Self> {
let loc = loc.into();
Ok(Self(loc))
}
}

18
crates/wasi-common/yanix/src/sys/linux/utimesat.rs
View File

@@ -1,4 +1,5 @@
use crate::filetime::FileTime; use crate::filetime::FileTime;
use crate::filetime::FileTimeExt;
use crate::from_success_code; use crate::from_success_code;
use std::fs; use std::fs;
use std::io::Result; use std::io::Result;
@@ -26,19 +27,16 @@ pub fn utimesat(
let fd = unsafe { libc::openat(dirfd.as_raw_fd(), p.as_ptr(), flags) }; let fd = unsafe { libc::openat(dirfd.as_raw_fd(), p.as_ptr(), flags) };
let f = unsafe { fs::File::from_raw_fd(fd) }; let f = unsafe { fs::File::from_raw_fd(fd) };
let (atime, mtime) = get_times(atime, mtime, || f.metadata().map_err(Into::into))?; let (atime, mtime) = get_times(atime, mtime, || f.metadata().map_err(Into::into))?;
let times = [to_timeval(atime), to_timeval(mtime)]; let times = [to_timeval(atime)?, to_timeval(mtime)?];
from_success_code(unsafe { libc::futimes(f.as_raw_fd(), times.as_ptr()) }) from_success_code(unsafe { libc::futimes(f.as_raw_fd(), times.as_ptr()) })
} }
/// Converts `filetime::FileTime` to `libc::timeval`. This function was taken directly from /// Converts `filetime::FileTime` to `libc::timeval`.
/// [filetime] crate. fn to_timeval(ft: filetime::FileTime) -> Result<libc::timeval> {
/// Ok(libc::timeval {
/// [filetime]: https://github.com/alexcrichton/filetime/blob/master/src/unix/utimes.rs#L93 tv_sec: ft.seconds_()?,
fn to_timeval(ft: filetime::FileTime) -> libc::timeval { tv_usec: (ft.nanoseconds_() / 1000) as libc::suseconds_t,
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 /// For a provided pair of access and modified `FileTime`s, converts the input to