From 0006a2af954eba74c79885cb1fe8cdeb68f531c1 Mon Sep 17 00:00:00 2001 From: Jakub Konka Date: Mon, 11 Nov 2019 18:42:28 +0100 Subject: [PATCH] Dynamically load utimensat if exists on the host (#535) * Dynamically load utimensat if exists on the host This commit introduces a change to file time management for *nix based hosts in that it firstly tries to load `utimensat` symbol, and if it doesn't exist, then falls back to `utimes` instead. This change is borrowing very heavily from [filetime] crate, however, it introduces a couple of helpers and methods specific to WASI use case (or more generally, to a use case which requires modifying times of entities specified by a pair `(DirFD, RelativePath)` rather than the typical file time specification based only absolute path or raw file descriptor as is the case with [filetime] crate. The trick here is, that on kernels which do not have `utimensat` symbol, this implementation emulates this behaviour by a combination of `openat` and `utimes`. This commit also is meant to address #516. [filetime]: https://github.com/alexcrichton/filetime * Fix symlink NOFOLLOW flag setting * Add docs and specify UTIME_NOW/OMIT on Linux Previously, we relied on [libc] crate for `UTIME_NOW` and `UTIME_OMIT` constants on Linux. However, following the convention assumed in [filetime] crate, this is now changed to directly specified by us in our crate. [libc]: https://github.com/rust-lang/libc [filetime]: https://github.com/alexcrichton/filetime * Refactor UTIME_NOW/OMIT for BSD * Address final discussion points --- .../wasi-common/src/sys/unix/bsd/filetime.rs | 103 ++++++++++++ crates/wasi-common/src/sys/unix/bsd/mod.rs | 43 +---- crates/wasi-common/src/sys/unix/filetime.rs | 149 ++++++++++++++++++ .../src/sys/unix/hostcalls_impl/fs.rs | 55 +++---- .../src/sys/unix/hostcalls_impl/fs_helpers.rs | 15 -- .../src/sys/unix/linux/filetime.rs | 61 +++++++ crates/wasi-common/src/sys/unix/linux/mod.rs | 11 +- crates/wasi-common/src/sys/unix/mod.rs | 1 + 8 files changed, 335 insertions(+), 103 deletions(-) create mode 100644 crates/wasi-common/src/sys/unix/bsd/filetime.rs create mode 100644 crates/wasi-common/src/sys/unix/filetime.rs create mode 100644 crates/wasi-common/src/sys/unix/linux/filetime.rs diff --git a/crates/wasi-common/src/sys/unix/bsd/filetime.rs b/crates/wasi-common/src/sys/unix/bsd/filetime.rs new file mode 100644 index 0000000000..8825e97a66 --- /dev/null +++ b/crates/wasi-common/src/sys/unix/bsd/filetime.rs @@ -0,0 +1,103 @@ +//! This internal module consists of helper types and functions for dealing +//! with setting the file times specific to BSD-style *nixes. +use super::super::filetime::FileTime; +use cfg_if::cfg_if; +use std::ffi::CStr; +use std::fs::File; +use std::io; +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 +/// 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 original implementation can be found here: [filetime::unix::macos::set_times] +/// +/// [filetime::unix::macos::set_times]: https://github.com/alexcrichton/filetime/blob/master/src/unix/macos.rs#L49 +pub(crate) fn utimensat( + dirfd: &File, + path: &str, + atime: FileTime, + mtime: FileTime, + symlink_nofollow: bool, +) -> io::Result<()> { + use super::super::filetime::{to_timespec, utimesat}; + use std::ffi::CString; + use std::os::unix::prelude::*; + + // Attempt to use the `utimensat` syscall, but if it's not supported by the + // current kernel then fall back to an older syscall. + if let Some(func) = fetch_utimensat() { + let flags = if symlink_nofollow { + libc::AT_SYMLINK_NOFOLLOW + } else { + 0 + }; + + let p = CString::new(path.as_bytes())?; + let times = [to_timespec(&atime), to_timespec(&mtime)]; + let rc = unsafe { func(dirfd.as_raw_fd(), p.as_ptr(), times.as_ptr(), flags) }; + if rc == 0 { + return Ok(()); + } else { + return Err(io::Error::last_os_error()); + } + } + + utimesat(dirfd, path, atime, mtime, symlink_nofollow) +} + +/// Wraps `fetch` specifically targetting `utimensat` symbol. If the symbol exists +/// on the host, then returns an `Some(unsafe fn)`. +fn fetch_utimensat() -> Option< + unsafe extern "C" fn( + libc::c_int, + *const libc::c_char, + *const libc::timespec, + libc::c_int, + ) -> libc::c_int, +> { + static ADDR: AtomicUsize = AtomicUsize::new(0); + unsafe { + fetch(&ADDR, CStr::from_bytes_with_nul_unchecked(b"utimensat\0")) + .map(|sym| std::mem::transmute(sym)) + } +} + +/// Fetches a symbol by `name` and stores it in `cache`. +fn fetch(cache: &AtomicUsize, name: &CStr) -> Option { + match cache.load(SeqCst) { + 0 => {} + 1 => return None, + n => return Some(n), + } + let sym = unsafe { libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr() as *const _) }; + let (val, ret) = if sym.is_null() { + (1, None) + } else { + (sym as usize, Some(sym as usize)) + }; + cache.store(val, SeqCst); + return ret; +} diff --git a/crates/wasi-common/src/sys/unix/bsd/mod.rs b/crates/wasi-common/src/sys/unix/bsd/mod.rs index 4cba400a27..4fea6c835f 100644 --- a/crates/wasi-common/src/sys/unix/bsd/mod.rs +++ b/crates/wasi-common/src/sys/unix/bsd/mod.rs @@ -1,3 +1,4 @@ +pub(crate) mod filetime; pub(crate) mod hostcalls_impl; pub(crate) mod osfile; @@ -38,45 +39,3 @@ pub(crate) mod host_impl { Ok(entry) } } - -pub(crate) mod fs_helpers { - use cfg_if::cfg_if; - - pub(crate) fn utime_now() -> libc::c_long { - cfg_if! { - if #[cfg(any( - target_os = "macos", - target_os = "freebsd", - target_os = "ios", - target_os = "dragonfly" - ))] { - -1 - } else if #[cfg(target_os = "openbsd")] { - // https://github.com/openbsd/src/blob/master/sys/sys/stat.h#L187 - -2 - } else if #[cfg(target_os = "netbsd" )] { - // http://cvsweb.netbsd.org/bsdweb.cgi/src/sys/sys/stat.h?rev=1.69&content-type=text/x-cvsweb-markup&only_with_tag=MAIN - 1_073_741_823 - } - } - } - - pub(crate) fn utime_omit() -> libc::c_long { - cfg_if! { - if #[cfg(any( - target_os = "macos", - target_os = "freebsd", - target_os = "ios", - target_os = "dragonfly" - ))] { - -2 - } else if #[cfg(target_os = "openbsd")] { - // https://github.com/openbsd/src/blob/master/sys/sys/stat.h#L187 - -1 - } else if #[cfg(target_os = "netbsd")] { - // http://cvsweb.netbsd.org/bsdweb.cgi/src/sys/sys/stat.h?rev=1.69&content-type=text/x-cvsweb-markup&only_with_tag=MAIN - 1_073_741_822 - } - } - } -} diff --git a/crates/wasi-common/src/sys/unix/filetime.rs b/crates/wasi-common/src/sys/unix/filetime.rs new file mode 100644 index 0000000000..061537b3b8 --- /dev/null +++ b/crates/wasi-common/src/sys/unix/filetime.rs @@ -0,0 +1,149 @@ +//! This internal module consists of helper types and functions for dealing +//! with setting the file times (mainly in `path_filestat_set_times` syscall for now). +//! +//! The vast majority of the code contained within and in platform-specific implementations +//! (`super::linux::filetime` and `super::bsd::filetime`) is based on the [filetime] crate. +//! Kudos @alexcrichton! +//! +//! [filetime]: https://github.com/alexcrichton/filetime +use std::fs::{self, File}; +use std::io; + +cfg_if::cfg_if! { + if #[cfg(target_os = "linux")] { + pub(crate) use super::linux::filetime::*; + } else if #[cfg(any( + target_os = "macos", + target_os = "netbsd", + target_os = "freebsd", + target_os = "openbsd", + target_os = "ios", + target_os = "dragonfly" + ))] { + pub(crate) use super::bsd::filetime::*; + } +} + +/// A wrapper `enum` around `filetime::FileTime` struct, but unlike the original, this +/// type allows the possibility of specifying `FileTime::Now` as a valid enumeration which, +/// in turn, if `utimensat` is available on the host, will use a special const setting +/// `UTIME_NOW`. +#[derive(Debug, Copy, Clone)] +pub(crate) enum FileTime { + Now, + Omit, + FileTime(filetime::FileTime), +} + +/// 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() -> io::Result, +) -> io::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)) +} + +/// 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: &File, + path: &str, + atime: FileTime, + mtime: FileTime, + symlink_nofollow: bool, +) -> io::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 { File::from_raw_fd(fd) }; + let (atime, mtime) = get_times(atime, mtime, || f.metadata())?; + let times = [to_timeval(atime), to_timeval(mtime)]; + let rc = unsafe { libc::futimes(f.as_raw_fd(), times.as_ptr()) }; + return if rc == 0 { + Ok(()) + } else { + Err(io::Error::last_os_error()) + }; +} + +/// 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, + } +} + +/// Converts `FileTime` to `libc::timespec`. If `FileTime::Now` variant is specified, this +/// resolves to `UTIME_NOW` special const, `FileTime::Omit` variant resolves to `UTIME_OMIT`, and +/// `FileTime::FileTime(ft)` where `ft := filetime::FileTime` uses [filetime] crate's original +/// implementation which can be found here: [filetime::unix::to_timespec]. +/// +/// [filetime]: https://github.com/alexcrichton/filetime +/// [filetime::unix::to_timespec]: https://github.com/alexcrichton/filetime/blob/master/src/unix/mod.rs#L30 +pub(crate) fn to_timespec(ft: &FileTime) -> libc::timespec { + match ft { + FileTime::Now => libc::timespec { + tv_sec: 0, + tv_nsec: UTIME_NOW, + }, + FileTime::Omit => libc::timespec { + tv_sec: 0, + tv_nsec: UTIME_OMIT, + }, + // `filetime::FileTime`'s fields are normalised by definition. `ft.seconds()` return the number + // of whole seconds, while `ft.nanoseconds()` returns only fractional part expressed in + // nanoseconds, as underneath it uses `std::time::Duration::subsec_nanos` to populate the + // `filetime::FileTime::nanoseconds` field. It is, therefore, OK to do an `as` cast here. + FileTime::FileTime(ft) => libc::timespec { + tv_sec: ft.seconds(), + tv_nsec: ft.nanoseconds() as _, + }, + } +} diff --git a/crates/wasi-common/src/sys/unix/hostcalls_impl/fs.rs b/crates/wasi-common/src/sys/unix/hostcalls_impl/fs.rs index 34d055632f..3bdd8eefd7 100644 --- a/crates/wasi-common/src/sys/unix/hostcalls_impl/fs.rs +++ b/crates/wasi-common/src/sys/unix/hostcalls_impl/fs.rs @@ -1,6 +1,5 @@ #![allow(non_camel_case_types)] #![allow(unused_unsafe)] -use super::fs_helpers::*; use crate::helpers::systemtime_to_timestamp; use crate::hostcalls_impl::{FileType, PathGet}; use crate::sys::host_impl; @@ -281,25 +280,8 @@ pub(crate) fn path_filestat_set_times( st_mtim: wasi::__wasi_timestamp_t, fst_flags: wasi::__wasi_fstflags_t, ) -> Result<()> { - use nix::sys::stat::{utimensat, UtimensatFlags}; - use nix::sys::time::{TimeSpec, TimeValLike}; - - // FIXME this should be a part of nix - fn timespec_omit() -> TimeSpec { - let raw_ts = libc::timespec { - tv_sec: 0, - tv_nsec: utime_omit(), - }; - unsafe { std::mem::transmute(raw_ts) } - }; - - fn timespec_now() -> TimeSpec { - let raw_ts = libc::timespec { - tv_sec: 0, - tv_nsec: utime_now(), - }; - unsafe { std::mem::transmute(raw_ts) } - }; + use super::super::filetime::*; + use std::time::{Duration, UNIX_EPOCH}; let set_atim = fst_flags & wasi::__WASI_FILESTAT_SET_ATIM != 0; let set_atim_now = fst_flags & wasi::__WASI_FILESTAT_SET_ATIM_NOW != 0; @@ -310,31 +292,32 @@ pub(crate) fn path_filestat_set_times( return Err(Error::EINVAL); } - let atflags = match dirflags { - wasi::__WASI_LOOKUP_SYMLINK_FOLLOW => UtimensatFlags::FollowSymlink, - _ => UtimensatFlags::NoFollowSymlink, - }; - + let symlink_nofollow = wasi::__WASI_LOOKUP_SYMLINK_FOLLOW != dirflags; let atim = if set_atim { - let st_atim = st_atim.try_into()?; - TimeSpec::nanoseconds(st_atim) + let time = UNIX_EPOCH + Duration::from_nanos(st_atim); + FileTime::FileTime(filetime::FileTime::from_system_time(time)) } else if set_atim_now { - timespec_now() + FileTime::Now } else { - timespec_omit() + FileTime::Omit }; - let mtim = if set_mtim { - let st_mtim = st_mtim.try_into()?; - TimeSpec::nanoseconds(st_mtim) + let time = UNIX_EPOCH + Duration::from_nanos(st_mtim); + FileTime::FileTime(filetime::FileTime::from_system_time(time)) } else if set_mtim_now { - timespec_now() + FileTime::Now } else { - timespec_omit() + FileTime::Omit }; - let fd = resolved.dirfd().as_raw_fd().into(); - utimensat(fd, resolved.path(), &atim, &mtim, atflags).map_err(Into::into) + utimensat( + resolved.dirfd(), + resolved.path(), + atim, + mtim, + symlink_nofollow, + ) + .map_err(Into::into) } pub(crate) fn path_remove_directory(resolved: PathGet) -> Result<()> { diff --git a/crates/wasi-common/src/sys/unix/hostcalls_impl/fs_helpers.rs b/crates/wasi-common/src/sys/unix/hostcalls_impl/fs_helpers.rs index 5aa7f820b6..8fbfbe7f19 100644 --- a/crates/wasi-common/src/sys/unix/hostcalls_impl/fs_helpers.rs +++ b/crates/wasi-common/src/sys/unix/hostcalls_impl/fs_helpers.rs @@ -4,21 +4,6 @@ use crate::sys::host_impl; use crate::{wasi, Result}; use std::fs::File; -cfg_if::cfg_if! { - if #[cfg(target_os = "linux")] { - pub(crate) use super::super::linux::fs_helpers::*; - } else if #[cfg(any( - target_os = "macos", - target_os = "netbsd", - target_os = "freebsd", - target_os = "openbsd", - target_os = "ios", - target_os = "dragonfly" - ))] { - pub(crate) use super::super::bsd::fs_helpers::*; - } -} - pub(crate) fn path_open_rights( rights_base: wasi::__wasi_rights_t, rights_inheriting: wasi::__wasi_rights_t, diff --git a/crates/wasi-common/src/sys/unix/linux/filetime.rs b/crates/wasi-common/src/sys/unix/linux/filetime.rs new file mode 100644 index 0000000000..9fb0516b52 --- /dev/null +++ b/crates/wasi-common/src/sys/unix/linux/filetime.rs @@ -0,0 +1,61 @@ +//! 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 std::fs::File; +use std::io; +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 +/// 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 original implementation can be found here: [filetime::unix::linux::set_times] +/// +/// [filetime::unix::linux::set_times]: https://github.com/alexcrichton/filetime/blob/master/src/unix/linux.rs#L64 +pub(crate) fn utimensat( + dirfd: &File, + path: &str, + atime: FileTime, + mtime: FileTime, + symlink_nofollow: bool, +) -> io::Result<()> { + use super::super::filetime::{to_timespec, utimesat}; + use std::ffi::CString; + use std::os::unix::prelude::*; + + let flags = if symlink_nofollow { + libc::AT_SYMLINK_NOFOLLOW + } else { + 0 + }; + + // Attempt to use the `utimensat` syscall, but if it's not supported by the + // current kernel then fall back to an older syscall. + static INVALID: AtomicBool = AtomicBool::new(false); + if !INVALID.load(Relaxed) { + let p = CString::new(path.as_bytes())?; + let times = [to_timespec(&atime), to_timespec(&mtime)]; + let rc = unsafe { + libc::syscall( + libc::SYS_utimensat, + dirfd.as_raw_fd(), + p.as_ptr(), + times.as_ptr(), + flags, + ) + }; + if rc == 0 { + return Ok(()); + } + let err = io::Error::last_os_error(); + if err.raw_os_error() == Some(libc::ENOSYS) { + INVALID.store(true, Relaxed); + } else { + return Err(err); + } + } + + utimesat(dirfd, path, atime, mtime, symlink_nofollow) +} diff --git a/crates/wasi-common/src/sys/unix/linux/mod.rs b/crates/wasi-common/src/sys/unix/linux/mod.rs index e4ccc91728..0626e704cd 100644 --- a/crates/wasi-common/src/sys/unix/linux/mod.rs +++ b/crates/wasi-common/src/sys/unix/linux/mod.rs @@ -1,3 +1,4 @@ +pub(crate) mod filetime; pub(crate) mod hostcalls_impl; pub(crate) mod osfile; @@ -30,13 +31,3 @@ pub(crate) mod fdentry_impl { 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 - } -} diff --git a/crates/wasi-common/src/sys/unix/mod.rs b/crates/wasi-common/src/sys/unix/mod.rs index 91892df647..52c6e3e4eb 100644 --- a/crates/wasi-common/src/sys/unix/mod.rs +++ b/crates/wasi-common/src/sys/unix/mod.rs @@ -3,6 +3,7 @@ pub(crate) mod host_impl; pub(crate) mod hostcalls_impl; mod dir; +mod filetime; #[cfg(any( target_os = "macos",