de919382b3
* Make Handle a trait required for any WASI-compatible handle
OK, so this PR is a bit of an experiment that came about somewhat itself
when I was looking at refactoring use of `Rc<RefCell<Descriptor>>` inside
`Entry` struct. I've noticed that since we've placed `VirtualFile` on the
same level as `OsHandle` and `Stdin` etc., we've ended up necessiitating
checks for different combinations such as "is a real OS resource being mixed
up with a virtual resource?", and if that was the case, we'd panic since
this was clearly not allowed (e.g., symlinking, or worse renaming).
Therefore, it seemed natural for virtual file to be on the same level
as _any_ OS handle (regardless of whether it's an actual file, socket,
or stdio handle). In other words, we should ideally envision the following
hierarchy:
```
\-- OsHandle \-- OsFile
-- Stdio
\-- Virtual
```
This way, we can deal with the mix up at a level above which cleans up
our logic significantly.
On the other hand, when looking through the `virtfs`, the trait approach
to some type that's a valid `Handle` grew on me, and I think this
is the way to go. And this is what this PR is proposing, a trait
`Handle` which features enough functionality to make both virtual and
OS ops to work. Now, inside `Entry` we can safely store something like
`Rc<dyn Handle>` where `Handle` can downcast to either `VirtualFile` or
`VirtualDir`, or `OsHandle` if its an actual OS resource. Note that
I've left `Handle` as one massive trait, but I reckon we could split
it up into several smaller traits, each dealing with some bit of WASI
functionality. I'm hoping this would perhaps make it easier to figure
out polyfilling between snapshots and the new upcoming ephemeral
snapshot since a lot of boilerplate functionality is now done as part
of the `Handle` trait implementation.
Next, I've redone the original `OsHandle` to be an `OsFile` which
now stores a raw descriptor/handle (`RawFd`/`RawHandle`) inside a
`Cell` so that we can handle interior mutability in an easy (read,
non-panicky) way. In order not to lose the perks of derefercing to
`std::fs::File`, I've added a convenience trait `AsFile` which
will take `OsFile` by reference (or the stdio handles) and create
a non-owned `ManuallyDrop<File>` resource which can be passed around
and acted upon the way we'd normally do on `&File`. This change of
course implies that we now have to worry about properly closing all
OS resources stored as part of `OsFile`, thus this type now implements
`Drop` trait which essentially speaking moves the raw descriptor/handle
into a `File` and drops it.
Finally, I've redone setting time info on relative paths on *nix using
the same approach as advocated in the virtual fs. Namely, we do an
`openat` followed by `filestat_set_times` on the obtained descriptor.
This effectively removes the need for custom `filetime` module in
`yanix`. However, this does probably incur additional cost of at least
one additional syscall, and I haven't checked whether this approach
performs as expected on platforms such as NixOS which as far as I remember
had some weirdness todo with linking `utimensat` symbols, etc. Still,
this change is worth considering given that the implementation of
`path_filestat_set_times` cleans up a lot, albeit with some additional
cost.
* Fix tests on Windows
* Address comments plus minor consistency cleanup
* Address comments
* Fix formatting
45 lines
1.3 KiB
Rust
45 lines
1.3 KiB
Rust
use crate::wasi::{types, Errno, Result};
|
|
use filetime::{set_file_handle_times, FileTime};
|
|
use std::fs::File;
|
|
use std::time::{Duration, SystemTime, UNIX_EPOCH};
|
|
|
|
pub(crate) use super::sys_impl::fd::*;
|
|
|
|
pub(crate) fn filestat_set_times(
|
|
file: &File,
|
|
st_atim: types::Timestamp,
|
|
st_mtim: types::Timestamp,
|
|
fst_flags: types::Fstflags,
|
|
) -> Result<()> {
|
|
let set_atim = fst_flags.contains(&types::Fstflags::ATIM);
|
|
let set_atim_now = fst_flags.contains(&types::Fstflags::ATIM_NOW);
|
|
let set_mtim = fst_flags.contains(&types::Fstflags::MTIM);
|
|
let set_mtim_now = fst_flags.contains(&types::Fstflags::MTIM_NOW);
|
|
|
|
if (set_atim && set_atim_now) || (set_mtim && set_mtim_now) {
|
|
return Err(Errno::Inval);
|
|
}
|
|
let atim = if set_atim {
|
|
let time = UNIX_EPOCH + Duration::from_nanos(st_atim);
|
|
Some(FileTime::from_system_time(time))
|
|
} else if set_atim_now {
|
|
let time = SystemTime::now();
|
|
Some(FileTime::from_system_time(time))
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let mtim = if set_mtim {
|
|
let time = UNIX_EPOCH + Duration::from_nanos(st_mtim);
|
|
Some(FileTime::from_system_time(time))
|
|
} else if set_mtim_now {
|
|
let time = SystemTime::now();
|
|
Some(FileTime::from_system_time(time))
|
|
} else {
|
|
None
|
|
};
|
|
|
|
set_file_handle_times(file, atim, mtim)?;
|
|
Ok(())
|
|
}
|