From 4200f2e79a389ba26eb382edba90d4ae0a262e65 Mon Sep 17 00:00:00 2001 From: Syrus Akbary Date: Fri, 23 Jul 2021 23:10:17 -0700 Subject: [PATCH 01/11] Base support for WASI in wasmer-js commit b6245ddd19077015a974e9ffd28f164fedb87801 Author: Syrus Akbary Date: Fri Jul 23 23:07:45 2021 -0700 Remove unused code commit 6bbf28c5c6d8c4603606e21af3190c52f41cbeb8 Author: Syrus Akbary Date: Fri Jul 23 22:50:50 2021 -0700 Remove set_last_accessed, set_last_modified, set_created_time from the VirtualFs commit 999d6941c93f0ea8c8c803c7b1843ec90bd178b5 Author: Syrus Akbary Date: Fri Jul 23 22:42:23 2021 -0700 Remove webc files commit 197b72a8978a2364145e20ebd6d44b5bd23082db Author: Syrus Akbary Date: Fri Jul 23 22:38:29 2021 -0700 Revert "Wip updates for python webc" This reverts commit 2d3e013e64424c0a50f32f44ad0401680d31bf9d. # Conflicts: # Cargo.lock # lib/cli/Cargo.toml # lib/cli/src/commands/run.rs # lib/cli/src/commands/run/wasi.rs # lib/vfs/Cargo.toml # lib/wasi/Cargo.toml # lib/wasi/src/state/builder.rs # lib/wasi/src/state/mod.rs commit 83b7e3b1a1708ed34694e9a44902bd6d0617f0a4 Author: Syrus Akbary Date: Fri Jul 23 22:34:36 2021 -0700 revert Remove webc commit 2de7f7f0ce518c74912509ef1fa4b7b1f00c4d11 Author: Syrus Akbary Date: Fri Jul 23 22:31:05 2021 -0700 Improved testing commit 97075c5fa69fd2ef9192a4a9737400359e0ee37f Author: Syrus Akbary Date: Fri Jul 23 22:06:08 2021 -0700 Improved bindings commit 9388790c2d31654701dd2925d30bfb35b158727c Author: Syrus Akbary Date: Fri Jul 23 18:15:43 2021 -0700 Renamed virtual-fs to vfs commit 41d91328cd83d10c0fa7242fcfd731335bcd741e Merge: c0634645a 51fdf66d5 Author: Syrus Akbary Date: Fri Jul 23 18:00:49 2021 -0700 Merge branch 'master' into js-api-wasi commit c0634645aebdf25fb545c63368114b531934970d Author: Syrus Akbary Date: Fri Jul 23 15:06:08 2021 -0700 Fixed serde dependency commit 02def893ae24f2da279ed6d3b39b4e50c18ec708 Merge: f13e4c86d d3930be60 Author: Syrus Akbary Date: Fri Jul 23 15:04:35 2021 -0700 Merge branch 'js-api' into js-api-wasi # Conflicts: # lib/wasi/Cargo.toml commit f13e4c86d48a0a527fa72270f29c9f8b97a6f820 Merge: f4ac010e1 fe04ea894 Author: Syrus Akbary Date: Fri Jul 16 00:01:19 2021 -0700 Merge branch 'js-api' into js-api-wasi commit f4ac010e1ff33cd046474a500bb5b9e4604085f6 Author: Syrus Akbary Date: Thu Jul 15 22:50:09 2021 -0700 Use latest resolver for namespace commit 505896a47c7d658cb4e39ab5256c9e960a2fedc6 Author: Syrus Akbary Date: Thu Jul 15 22:49:48 2021 -0700 Updated WASI implementation commit 30470cb81248a388ea5cf27f1838aeb264dc8956 Author: Syrus Akbary Date: Thu Jul 15 15:51:56 2021 -0700 Improved logging commit caf0c8289ad8ce2471558baab17adee4abc011f5 Author: Syrus Akbary Date: Thu Jul 15 13:55:43 2021 -0700 Improved wasmer-js debugging commit 4e2278dafe8999c262a0cea5afd23f8ae895abcb Author: Syrus Akbary Date: Thu Jul 15 08:29:35 2021 -0700 Added wasi tests commit 4f5c1fdbdae1f953498016c32d158038b6a6dc97 Author: Syrus Akbary Date: Wed Jul 14 22:22:41 2021 -0700 Fixed build commit 692111d098b73229dbe722645b3d86ff6f5e4a5e Merge: 35dade1b1 7195a9c3f Author: Syrus Akbary Date: Wed Jul 14 22:18:01 2021 -0700 Merge branch 'js-api' into js-api-wasi # Conflicts: # lib/js-api/src/trap.rs commit 35dade1b16f01ce67a23ba4fbfa25224dda1403e Author: Syrus Akbary Date: Wed Jul 14 22:12:38 2021 -0700 Fixed wasi wast commit d3a6b42f8ebd790024c7631a87a295bd6957bb80 Author: Syrus Akbary Date: Wed Jul 14 22:12:22 2021 -0700 Added extra instruction for wasmer-js commit 95b5c1ad005b17a3bacca45f906d717780f4f95a Author: Syrus Akbary Date: Wed Jul 14 22:12:12 2021 -0700 Improved API to be resilient in and out js commit e4074de27bd4adcd9ee8e9e4973c2cfd5208d523 Author: Syrus Akbary Date: Wed Jul 14 18:54:14 2021 -0700 Improved traps commit e512e06cc8c476a74eb9a8e381b0d4019cdc4365 Author: Syrus Akbary Date: Wed Jul 14 18:31:30 2021 -0700 Improved WasiFs commit cc7bda3ae33a01336e79e0a6ca48e2a72eb0ad98 Merge: 0721bbfe0 8047e3eb6 Author: Syrus Akbary Date: Wed Jul 14 15:15:05 2021 -0700 Merge branch 'js-api' into js-api-wasi # Conflicts: # lib/js-api/Cargo.toml # lib/js-api/src/cell.rs # lib/js-api/src/env.rs # lib/js-api/src/export.rs # lib/js-api/src/exports.rs # lib/js-api/src/externals/function.rs # lib/js-api/src/externals/memory.rs # lib/js-api/src/externals/table.rs # lib/js-api/src/instance.rs # lib/js-api/src/lib.rs # lib/js-api/src/module.rs commit 0721bbfe04d8d3b54ddcfa66a60a3cb501631ac6 Merge: 8354e03f1 3604debec Author: Syrus Akbary Date: Fri Jul 2 16:15:49 2021 -0700 Merge branch 'master' into js-api-wasi commit 8354e03f19b810f8fdaf0cadc3eb89bad30220ab Author: Syrus Akbary Date: Fri Jul 2 10:25:27 2021 -0700 Improved sync commit bfa6db7e7201b46fd992361699141df501e6d13c Merge: 30aa8d4bb 7553efba3 Author: Syrus Akbary Date: Fri Jul 2 10:07:23 2021 -0700 Merge branch 'features-cell' into js-api-wasi # Conflicts: # lib/api/src/ptr.rs commit 30aa8d4bb0115b3bb8275212d2f33327d32546e6 Author: Syrus Akbary Date: Thu Jul 1 17:36:47 2021 -0700 Improved VirtualFS commit a72dc93d345ca2c4967a75a0e3ef5243ebe86f33 Author: Syrus Akbary Date: Thu Jul 1 17:36:37 2021 -0700 Improved wasmer-js API commit 63c13f371f19103adb74a6f394c4c09d8fcc4d52 Author: Syrus Akbary Date: Fri Jun 25 17:32:33 2021 -0700 Updated memory_fs commit a9e7206b7437984ac367351ea75bb14c8cafaf4d Merge: 6e7285af0 be5af68ef Author: Syrus Akbary Date: Fri Jun 25 17:14:29 2021 -0700 Merge branch 'feature/webc' into js-api-wasi # Conflicts: # Cargo.lock # lib/cli/Cargo.toml # lib/virtual-fs/Cargo.toml # lib/wasi/Cargo.toml # lib/wasi/src/state/mod.rs commit 6e7285af02367a6431b302c17b708f8e0854be82 Author: Syrus Akbary Date: Fri Jun 25 17:07:39 2021 -0700 Updated virtual fs deps commit 5eab9ac6f629ddb82f5e97c5fce37998fadf262d Author: Syrus Akbary Date: Fri Jun 25 17:07:29 2021 -0700 Make wasi not serializable commit 1d242d4564e898d773601b87d135a8f5dc4a0f57 Author: Syrus Akbary Date: Fri Jun 25 17:05:30 2021 -0700 Set WASI to use Strings instead of str commit 1d7cd64232e4bdd57b64d884d4d9b38dd68e1cdb Author: Syrus Akbary Date: Fri Jun 25 17:03:23 2021 -0700 Improve Virtual FS commit 85f4bbe5ebc0e87138e74a43665616e96772ac5d Author: Syrus Akbary Date: Fri Jun 25 16:57:14 2021 -0700 wasmer-js: Added functions to the mix commit 27effe1eda37a1d810a80a489ff5c737e986f200 Author: Syrus Akbary Date: Fri Jun 25 16:01:12 2021 -0700 wasmer-js function environments working commit be5af68efe44c5084dd140f9cc6b425f61a84f8a Author: Mark McCaskey Date: Fri Jun 25 15:01:18 2021 -0700 Move webc vfs impl into wasmer src tree commit 765c89bb3954699b86a2b820fd40857811e6c466 Author: Mark McCaskey Date: Fri Jun 25 14:38:19 2021 -0700 Get python.webc working commit bedc25cbf00a91cca193bb21834117dc3344febe Author: Syrus Akbary Date: Fri Jun 25 09:17:26 2021 -0700 wasmer-js improve get_host_environment commit ee3a36d53b06be72dc00877332c4aaf0b2f57aa4 Author: Syrus Akbary Date: Thu Jun 24 19:37:34 2021 -0700 Added wasm32 API commit c136c2ac6829e4ac3d916dc5687a7c999dd6c412 Author: Syrus Akbary Date: Thu Jun 24 18:56:19 2021 -0700 Improved wasmer_js API commit f819cbbb629442f6f020985ca34b2b57bc90deca Author: Syrus Akbary Date: Thu Jun 24 18:32:29 2021 -0700 Improved wasmer_js imports commit 1d4ed08d90808922ee5e74e92f162509ba8c2efb Merge: 5451d7113 2d3e013e6 Author: Syrus Akbary Date: Thu Jun 24 17:55:25 2021 -0700 Merge branch 'feature/webc' into js-api-wasi # Conflicts: # lib/wasi/src/syscalls/mod.rs commit 2d3e013e64424c0a50f32f44ad0401680d31bf9d Author: Mark McCaskey Date: Thu Jun 24 16:54:43 2021 -0700 Wip updates for python webc commit 3a5a687964780d48e8598247009721badd50d496 Author: Mark McCaskey Date: Wed Jun 23 10:36:06 2021 -0700 Add patch to get vfs --- Cargo.lock | 61 +- Cargo.toml | 4 +- Makefile | 2 +- lib/api/src/js/ptr.rs | 19 +- lib/api/src/sys/externals/memory.rs | 5 + lib/c-api/Cargo.toml | 2 +- lib/cli/Cargo.toml | 3 +- lib/cli/src/commands/run.rs | 5 +- lib/cli/src/logging.rs | 12 +- lib/engine/src/artifact.rs | 2 +- lib/types/src/memory_view.rs | 31 +- lib/vfs/Cargo.toml | 18 + lib/vfs/src/host_fs.rs | 651 + lib/vfs/src/lib.rs | 445 + lib/vfs/src/mem_fs.rs | 892 + lib/vfs/src/vfs_fs.rs | 189 + lib/wasi-experimental-io-devices/Cargo.toml | 2 +- lib/wasi-experimental-io-devices/src/lib.rs | 4 +- lib/wasi/Cargo.toml | 38 +- lib/wasi/src/lib.rs | 65 +- lib/wasi/src/macros.rs | 2 +- lib/wasi/src/ptr.rs | 13 +- lib/wasi/src/state/builder.rs | 65 +- lib/wasi/src/state/mod.rs | 278 +- lib/wasi/src/state/types.rs | 885 +- lib/wasi/src/syscalls/mod.rs | 193 +- lib/wasi/src/syscalls/wasm32.rs | 25 + lib/wasi/tests/envvar.rs | 28 + lib/wasi/tests/envvar.wasm | Bin 0 -> 1839059 bytes lib/wasi/tests/envvar.wat | 25993 ++++++++++++++++++ lib/wasi/tests/js.rs | 136 + lib/wasi/tests/stdin-hello.wasm | Bin 0 -> 20729 bytes tests/lib/wast/src/wasi_wast.rs | 11 +- 33 files changed, 29021 insertions(+), 1058 deletions(-) create mode 100644 lib/vfs/Cargo.toml create mode 100644 lib/vfs/src/host_fs.rs create mode 100644 lib/vfs/src/lib.rs create mode 100644 lib/vfs/src/mem_fs.rs create mode 100644 lib/vfs/src/vfs_fs.rs create mode 100644 lib/wasi/src/syscalls/wasm32.rs create mode 100644 lib/wasi/tests/envvar.rs create mode 100755 lib/wasi/tests/envvar.wasm create mode 100644 lib/wasi/tests/envvar.wat create mode 100644 lib/wasi/tests/js.rs create mode 100644 lib/wasi/tests/stdin-hello.wasm diff --git a/Cargo.lock b/Cargo.lock index c104b1571b6..19f5eddf082 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1,5 +1,7 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. +version = 3 + [[package]] name = "addr2line" version = "0.15.2" @@ -849,8 +851,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753" dependencies = [ "cfg-if 1.0.0", + "js-sys", "libc", "wasi", + "wasm-bindgen", ] [[package]] @@ -1922,6 +1926,15 @@ dependencies = [ "syn", ] +[[package]] +name = "sharded-slab" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79c719719ee05df97490f80a45acfc99e5a30ce98a1e4fb67aee422745ae14e3" +dependencies = [ + "lazy_static", +] + [[package]] name = "shlex" version = "0.1.1" @@ -2100,6 +2113,15 @@ dependencies = [ "syn", ] +[[package]] +name = "thread_local" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8018d24e04c95ac8790716a5987d0fec4f8b27249ffa0f7d33f1369bdfb88cbd" +dependencies = [ + "once_cell", +] + [[package]] name = "time" version = "0.1.43" @@ -2162,6 +2184,28 @@ dependencies = [ "lazy_static", ] +[[package]] +name = "tracing-subscriber" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab69019741fca4d98be3c62d2b75254528b5432233fd8a4d2739fec20278de48" +dependencies = [ + "sharded-slab", + "thread_local", + "tracing-core", +] + +[[package]] +name = "tracing-wasm" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ae741706df70547fca8715f74a8569677666e7be3454313af70f6e158034485" +dependencies = [ + "tracing", + "tracing-subscriber", + "wasm-bindgen", +] + [[package]] name = "treeline" version = "0.1.0" @@ -2521,6 +2565,7 @@ dependencies = [ "wasmer-engine-staticlib", "wasmer-engine-universal", "wasmer-types", + "wasmer-vfs", "wasmer-vm", "wasmer-wasi", "wasmer-wasi-experimental-io-devices", @@ -2760,6 +2805,17 @@ dependencies = [ "thiserror", ] +[[package]] +name = "wasmer-vfs" +version = "2.0.0" +dependencies = [ + "libc", + "serde", + "thiserror", + "tracing", + "typetag", +] + [[package]] name = "wasmer-vm" version = "2.0.0" @@ -2784,15 +2840,18 @@ dependencies = [ name = "wasmer-wasi" version = "2.0.0" dependencies = [ - "bincode", "generational-arena", "getrandom", "libc", "serde", "thiserror", "tracing", + "tracing-wasm", "typetag", + "wasm-bindgen", + "wasm-bindgen-test", "wasmer", + "wasmer-vfs", "wasmer-wasi-types", "winapi", ] diff --git a/Cargo.toml b/Cargo.toml index 7dbac4d1496..9c2821926e1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -44,6 +44,7 @@ members = [ "lib/engine-dylib", "lib/engine-staticlib", "lib/object", + "lib/vfs", "lib/vm", "lib/wasi", "lib/wasi-types", @@ -54,6 +55,7 @@ members = [ "tests/integration/cli", "fuzz", ] +resolver = "2" [build-dependencies] test-generator = { path = "tests/lib/test-generator" } @@ -280,4 +282,4 @@ required-features = ["cranelift"] [[example]] name = "features" path = "examples/features.rs" -required-features = ["cranelift"] \ No newline at end of file +required-features = ["cranelift"] diff --git a/Makefile b/Makefile index f0d1a1fb813..ac363644057 100644 --- a/Makefile +++ b/Makefile @@ -354,7 +354,7 @@ endif all: build-wasmer build-capi build-wasmer: - cargo build --release --manifest-path lib/cli/Cargo.toml $(compiler_features) --bin wasmer + cargo build --release --manifest-path lib/cli/Cargo.toml --features "debug" $(compiler_features) --bin wasmer build-wasmer-debug: cargo build --manifest-path lib/cli/Cargo.toml $(compiler_features) --bin wasmer diff --git a/lib/api/src/js/ptr.rs b/lib/api/src/js/ptr.rs index e5c0c471b90..28f87f00c02 100644 --- a/lib/api/src/js/ptr.rs +++ b/lib/api/src/js/ptr.rs @@ -86,6 +86,13 @@ impl WasmPtr { } } +#[inline(always)] +fn align_pointer(ptr: usize, align: usize) -> usize { + // clears bits below aligment amount (assumes power of 2) to align pointer + debug_assert!(align.count_ones() == 1); + ptr & !(align - 1) +} + /// Methods for `WasmPtr`s to data that can be dereferenced, namely to types /// that implement [`ValueType`], meaning that they're valid for all possible /// bit patterns. @@ -102,7 +109,8 @@ impl WasmPtr { if total_len > memory.size().bytes().0 || mem::size_of::() == 0 { return None; } - let subarray = memory.uint8view().subarray(self.offset, total_len as u32); + let offset = align_pointer(self.offset as usize, mem::align_of::()) as u32; + let subarray = memory.uint8view().subarray(offset, total_len as u32); Some(WasmCell::new(subarray)) } } @@ -132,13 +140,14 @@ impl WasmPtr { return None; } + let offset = align_pointer(self.offset as usize, mem::align_of::()) as u32; + Some( (0..length) .map(|i| { - let subarray = memory.uint8view().subarray( - self.offset + i * item_size, - self.offset + (i + 1) * item_size, - ); + let subarray = memory + .uint8view() + .subarray(offset + i * item_size, offset + (i + 1) * item_size); WasmCell::new(subarray) }) .collect::>(), diff --git a/lib/api/src/sys/externals/memory.rs b/lib/api/src/sys/externals/memory.rs index b5b6ba5cc7e..0f880b07faa 100644 --- a/lib/api/src/sys/externals/memory.rs +++ b/lib/api/src/sys/externals/memory.rs @@ -226,6 +226,11 @@ impl Memory { unsafe { MemoryView::new(base as _, length as u32) } } + /// A uint8view + pub fn uint8view(&self) -> MemoryView { + self.view() + } + pub(crate) fn from_vm_export(store: &Store, vm_memory: VMMemory) -> Self { Self { store: store.clone(), diff --git a/lib/c-api/Cargo.toml b/lib/c-api/Cargo.toml index 5335789a708..9b9fca8ff61 100644 --- a/lib/c-api/Cargo.toml +++ b/lib/c-api/Cargo.toml @@ -32,7 +32,7 @@ wasmer-engine-universal = { version = "2.0.0", path = "../engine-universal", opt wasmer-engine-dylib = { version = "2.0.0", path = "../engine-dylib", optional = true } wasmer-engine-staticlib = { version = "2.0.0", path = "../engine-staticlib", optional = true } wasmer-middlewares = { version = "2.0.0", path = "../middlewares", optional = true } -wasmer-wasi = { version = "2.0.0", path = "../wasi", optional = true } +wasmer-wasi = { version = "2.0.0", path = "../wasi", default-features = false, features = ["host_fs"], optional = true } wasmer-types = { version = "2.0.0", path = "../types" } enumset = "1.0" cfg-if = "1.0" diff --git a/lib/cli/Cargo.toml b/lib/cli/Cargo.toml index a819372bdf1..98f248b48e7 100644 --- a/lib/cli/Cargo.toml +++ b/lib/cli/Cargo.toml @@ -35,11 +35,12 @@ wasmer-engine-universal = { version = "2.0.0", path = "../engine-universal", opt wasmer-engine-dylib = { version = "2.0.0", path = "../engine-dylib", optional = true } wasmer-engine-staticlib = { version = "2.0.0", path = "../engine-staticlib", optional = true } wasmer-vm = { version = "2.0.0", path = "../vm" } -wasmer-wasi = { version = "2.0.0", path = "../wasi", default-features = false, optional = true } +wasmer-wasi = { version = "2.0.0", path = "../wasi", default-features = false, features = ["host_fs"], optional = true } wasmer-wasi-experimental-io-devices = { version = "2.0.0", path = "../wasi-experimental-io-devices", optional = true } wasmer-wast = { version = "2.0.0", path = "../../tests/lib/wast", optional = true } wasmer-cache = { version = "2.0.0", path = "../cache", optional = true } wasmer-types = { version = "2.0.0", path = "../types" } +wasmer-vfs = { version = "2.0.0", path = "../vfs" } atty = "0.2" colored = "2.0" anyhow = "1.0" diff --git a/lib/cli/src/commands/run.rs b/lib/cli/src/commands/run.rs index c515c10f1f5..653ea4e72f6 100644 --- a/lib/cli/src/commands/run.rs +++ b/lib/cli/src/commands/run.rs @@ -64,6 +64,9 @@ pub struct Run { #[structopt(long = "debug", short = "d")] debug: bool, + #[structopt(short, long, parse(from_occurrences))] + verbose: u8, + /// Application arguments #[structopt(name = "--", multiple = true)] args: Vec, @@ -74,7 +77,7 @@ impl Run { pub fn execute(&self) -> Result<()> { #[cfg(feature = "debug")] if self.debug { - logging::set_up_logging().unwrap(); + logging::set_up_logging(self.verbose).unwrap(); } self.inner_execute().with_context(|| { format!( diff --git a/lib/cli/src/logging.rs b/lib/cli/src/logging.rs index fd2eaafc025..3a08aa2dd94 100644 --- a/lib/cli/src/logging.rs +++ b/lib/cli/src/logging.rs @@ -1,10 +1,14 @@ //! Logging functions for the debug feature. use crate::utils::wasmer_should_print_color; +use anyhow::Result; use fern::colors::{Color, ColoredLevelConfig}; use std::time; +/// The debug level +pub type DebugLevel = log::LevelFilter; + /// Subroutine to instantiate the loggers -pub fn set_up_logging() -> Result<(), String> { +pub fn set_up_logging(verbose: u8) -> Result<(), String> { let colors_line = ColoredLevelConfig::new() .error(Color::Red) .warn(Color::Yellow) @@ -12,8 +16,12 @@ pub fn set_up_logging() -> Result<(), String> { let should_color = wasmer_should_print_color(); let colors_level = colors_line.info(Color::Green); + let level = match verbose { + 1 => DebugLevel::Debug, + 2 | _ => DebugLevel::Trace, + }; let dispatch = fern::Dispatch::new() - .level(log::LevelFilter::Debug) + .level(level) .chain({ let base = if should_color { fern::Dispatch::new().format(move |out, message, record| { diff --git a/lib/engine/src/artifact.rs b/lib/engine/src/artifact.rs index 0f1058602e1..e8185d14a7f 100644 --- a/lib/engine/src/artifact.rs +++ b/lib/engine/src/artifact.rs @@ -179,7 +179,7 @@ pub trait Artifact: Send + Sync + Upcastable + MemoryUsage { } // Implementation of `Upcastable` taken from https://users.rust-lang.org/t/why-does-downcasting-not-work-for-subtraits/33286/7 . -/// Trait needed to get downcasting from `WasiFile` to work. +/// Trait needed to get downcasting of `Engine`s to work. pub trait Upcastable { fn upcast_any_ref(&'_ self) -> &'_ dyn Any; fn upcast_any_mut(&'_ mut self) -> &'_ mut dyn Any; diff --git a/lib/types/src/memory_view.rs b/lib/types/src/memory_view.rs index 172dd1ce5f8..08f4509938d 100644 --- a/lib/types/src/memory_view.rs +++ b/lib/types/src/memory_view.rs @@ -69,28 +69,29 @@ where } /// Creates a subarray view from this MemoryView. - pub fn subarray(&self, range: impl RangeBounds) -> Self { - let start: usize = match range.start_bound() { - Bound::Unbounded => 0, - Bound::Included(start) => *start, - Bound::Excluded(start) => *start + 1, - }; - let end: usize = match range.end_bound() { - Bound::Unbounded => self.length, - Bound::Included(end) => *end, - Bound::Excluded(end) => *end - 1, - }; + // pub fn subarray(&self, range: impl RangeBounds) -> Self { + // let start: usize = match range.start_bound() { + // Bound::Unbounded => 0, + // Bound::Included(start) => *start, + // Bound::Excluded(start) => *start + 1, + // }; + // let end: usize = match range.end_bound() { + // Bound::Unbounded => self.length, + // Bound::Included(end) => *end, + // Bound::Excluded(end) => *end - 1, + // }; + pub fn subarray(&self, start: u32, end: u32) -> Self { assert!( - start < self.length, + (start as usize) < self.length, "The range start is bigger than current length" ); assert!( - end < self.length, + (end as usize) < self.length, "The range end is bigger than current length" ); Self { - ptr: unsafe { self.ptr.add(start) }, - length: (end - start), + ptr: unsafe { self.ptr.add(start as usize) }, + length: (end - start) as usize, _phantom: PhantomData, } } diff --git a/lib/vfs/Cargo.toml b/lib/vfs/Cargo.toml new file mode 100644 index 00000000000..82566725720 --- /dev/null +++ b/lib/vfs/Cargo.toml @@ -0,0 +1,18 @@ +[package] +name = "wasmer-vfs" +version = "2.0.0" +description = "Wasmer Virtual FileSystem" +authors = ["Wasmer Engineering Team "] +license = "MIT" +edition = "2018" + +[dependencies] +libc = { version = "^0.2", default-features = false, optional = true } +thiserror = "1" +tracing = { version = "0.1" } +typetag = "0.1" +serde = { version = "1.0", default-features = false, features = ["derive"] } + +[features] +host_fs = ["libc"] +mem_fs = [] diff --git a/lib/vfs/src/host_fs.rs b/lib/vfs/src/host_fs.rs new file mode 100644 index 00000000000..b153f61d3c1 --- /dev/null +++ b/lib/vfs/src/host_fs.rs @@ -0,0 +1,651 @@ +use crate::*; +use serde::{de, Deserialize, Serialize}; +use std::convert::TryInto; +use std::fs; +use std::io::{Read, Seek, Write}; +use std::path::{Path, PathBuf}; +use std::time::SystemTime; + +#[derive(Debug, Clone)] +pub struct HostFileSystem; + +impl FileSystem for HostFileSystem { + fn read_dir(&self, path: &Path) -> Result { + let read_dir = std::fs::read_dir(path)?; + let data = read_dir + .map(|entry| -> Result { + let entry = entry?; + let metadata = entry.metadata()?; + Ok(DirEntry { + path: entry.path(), + metadata: Ok(fs_metadata_to_metadata(metadata)?), + }) + }) + .collect::, std::io::Error>>() + .map_err::(Into::into)?; + Ok(ReadDir::new(data)) + } + fn create_dir(&self, path: &Path) -> Result<(), FsError> { + fs::create_dir(path).map_err(Into::into) + } + fn remove_dir(&self, path: &Path) -> Result<(), FsError> { + fs::remove_dir(path).map_err(Into::into) + } + fn rename(&self, from: &Path, to: &Path) -> Result<(), FsError> { + fs::rename(from, to).map_err(Into::into) + } + + fn remove_file(&self, path: &Path) -> Result<(), FsError> { + fs::remove_file(path).map_err(Into::into) + } + fn new_open_options(&self) -> OpenOptions { + OpenOptions::new(Box::new(HostFileOpener)) + } + + fn metadata(&self, path: &Path) -> Result { + fs::metadata(path) + .and_then(fs_metadata_to_metadata) + .map_err(Into::into) + } +} + +fn fs_metadata_to_metadata(metadata: fs::Metadata) -> Result { + use std::time::UNIX_EPOCH; + let filetype = metadata.file_type(); + let (char_device, block_device, socket, fifo) = { + #[cfg(unix)] + { + use std::os::unix::fs::FileTypeExt; + ( + filetype.is_char_device(), + filetype.is_block_device(), + filetype.is_socket(), + filetype.is_fifo(), + ) + } + #[cfg(not(unix))] + { + (false, false, false) + } + }; + + Ok(Metadata { + ft: FileType { + dir: filetype.is_dir(), + file: filetype.is_file(), + symlink: filetype.is_symlink(), + char_device, + block_device, + socket, + fifo, + }, + accessed: metadata + .accessed()? + .duration_since(UNIX_EPOCH) + .unwrap() + .as_nanos() as u64, + created: metadata + .created()? + .duration_since(UNIX_EPOCH) + .unwrap() + .as_nanos() as u64, + modified: metadata + .modified()? + .duration_since(UNIX_EPOCH) + .unwrap() + .as_nanos() as u64, + len: metadata.len(), + }) +} + +#[derive(Debug, Clone)] +pub struct HostFileOpener; + +impl FileOpener for HostFileOpener { + fn open( + &mut self, + path: &Path, + conf: &OpenOptionsConfig, + ) -> Result, FsError> { + // TODO: handle create implying write, etc. + let read = conf.read(); + let write = conf.write(); + let append = conf.append(); + let mut oo = std::fs::OpenOptions::new(); + oo.read(conf.read()) + .write(conf.write()) + .create_new(conf.create_new()) + .create(conf.create()) + .append(conf.append()) + .truncate(conf.truncate()) + .open(path) + .map_err(Into::into) + .map(|file| { + Box::new(HostFile::new(file, path.to_owned(), read, write, append)) + as Box + }) + } +} + +/// A thin wrapper around `std::fs::File` +#[derive(Debug, Serialize)] +pub struct HostFile { + #[serde(skip_serializing)] + pub inner: fs::File, + pub host_path: PathBuf, + flags: u16, +} + +impl<'de> Deserialize<'de> for HostFile { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + #[derive(Deserialize)] + #[serde(field_identifier, rename_all = "snake_case")] + enum Field { + HostPath, + Flags, + } + + struct HostFileVisitor; + + impl<'de> de::Visitor<'de> for HostFileVisitor { + type Value = HostFile; + + fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result { + formatter.write_str("struct HostFile") + } + + fn visit_seq(self, mut seq: V) -> Result + where + V: de::SeqAccess<'de>, + { + let host_path = seq + .next_element()? + .ok_or_else(|| de::Error::invalid_length(0, &self))?; + let flags = seq + .next_element()? + .ok_or_else(|| de::Error::invalid_length(1, &self))?; + let inner = std::fs::OpenOptions::new() + .read(flags & HostFile::READ != 0) + .write(flags & HostFile::WRITE != 0) + .append(flags & HostFile::APPEND != 0) + .open(&host_path) + .map_err(|_| de::Error::custom("Could not open file on this system"))?; + Ok(HostFile { + inner, + host_path, + flags, + }) + } + + fn visit_map(self, mut map: V) -> Result + where + V: de::MapAccess<'de>, + { + let mut host_path = None; + let mut flags = None; + while let Some(key) = map.next_key()? { + match key { + Field::HostPath => { + if host_path.is_some() { + return Err(de::Error::duplicate_field("host_path")); + } + host_path = Some(map.next_value()?); + } + Field::Flags => { + if flags.is_some() { + return Err(de::Error::duplicate_field("flags")); + } + flags = Some(map.next_value()?); + } + } + } + let host_path = host_path.ok_or_else(|| de::Error::missing_field("host_path"))?; + let flags = flags.ok_or_else(|| de::Error::missing_field("flags"))?; + let inner = std::fs::OpenOptions::new() + .read(flags & HostFile::READ != 0) + .write(flags & HostFile::WRITE != 0) + .append(flags & HostFile::APPEND != 0) + .open(&host_path) + .map_err(|_| de::Error::custom("Could not open file on this system"))?; + Ok(HostFile { + inner, + host_path, + flags, + }) + } + } + + const FIELDS: &[&str] = &["host_path", "flags"]; + deserializer.deserialize_struct("HostFile", FIELDS, HostFileVisitor) + } +} + +impl HostFile { + const READ: u16 = 1; + const WRITE: u16 = 2; + const APPEND: u16 = 4; + + /// creates a new host file from a `std::fs::File` and a path + pub fn new(file: fs::File, host_path: PathBuf, read: bool, write: bool, append: bool) -> Self { + let mut flags = 0; + if read { + flags |= Self::READ; + } + if write { + flags |= Self::WRITE; + } + if append { + flags |= Self::APPEND; + } + Self { + inner: file, + host_path, + flags, + } + } + + pub fn metadata(&self) -> fs::Metadata { + self.inner.metadata().unwrap() + } +} + +impl Read for HostFile { + fn read(&mut self, buf: &mut [u8]) -> io::Result { + self.inner.read(buf) + } + fn read_to_end(&mut self, buf: &mut Vec) -> io::Result { + self.inner.read_to_end(buf) + } + fn read_to_string(&mut self, buf: &mut String) -> io::Result { + self.inner.read_to_string(buf) + } + fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { + self.inner.read_exact(buf) + } +} +impl Seek for HostFile { + fn seek(&mut self, pos: io::SeekFrom) -> io::Result { + self.inner.seek(pos) + } +} +impl Write for HostFile { + fn write(&mut self, buf: &[u8]) -> io::Result { + self.inner.write(buf) + } + fn flush(&mut self) -> io::Result<()> { + self.inner.flush() + } + fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { + self.inner.write_all(buf) + } + fn write_fmt(&mut self, fmt: ::std::fmt::Arguments) -> io::Result<()> { + self.inner.write_fmt(fmt) + } +} + +impl VirtualFile for HostFile { + fn last_accessed(&self) -> u64 { + self.metadata() + .accessed() + .ok() + .and_then(|ct| ct.duration_since(SystemTime::UNIX_EPOCH).ok()) + .map(|ct| ct.as_nanos() as u64) + .unwrap_or(0) + } + + fn last_modified(&self) -> u64 { + self.metadata() + .modified() + .ok() + .and_then(|ct| ct.duration_since(SystemTime::UNIX_EPOCH).ok()) + .map(|ct| ct.as_nanos() as u64) + .unwrap_or(0) + } + + fn created_time(&self) -> u64 { + self.metadata() + .created() + .ok() + .and_then(|ct| ct.duration_since(SystemTime::UNIX_EPOCH).ok()) + .map(|ct| ct.as_nanos() as u64) + .unwrap_or(0) + } + + fn size(&self) -> u64 { + self.metadata().len() + } + + fn set_len(&mut self, new_size: u64) -> Result<(), FsError> { + fs::File::set_len(&self.inner, new_size).map_err(Into::into) + } + + fn unlink(&mut self) -> Result<(), FsError> { + std::fs::remove_file(&self.host_path).map_err(Into::into) + } + fn sync_to_disk(&self) -> Result<(), FsError> { + self.inner.sync_all().map_err(Into::into) + } + + fn rename_file(&self, new_name: &std::path::Path) -> Result<(), FsError> { + std::fs::rename(&self.host_path, new_name).map_err(Into::into) + } + + fn bytes_available(&self) -> Result { + // unwrap is safe because of get_raw_fd implementation + let host_fd = self.get_raw_fd().unwrap(); + + host_file_bytes_available(host_fd) + } + + #[cfg(unix)] + fn get_raw_fd(&self) -> Option { + use std::os::unix::io::AsRawFd; + Some(self.inner.as_raw_fd()) + } + #[cfg(not(unix))] + fn get_raw_fd(&self) -> Option { + unimplemented!( + "HostFile::get_raw_fd in VirtualFile is not implemented for non-Unix-like targets yet" + ); + } +} + +#[cfg(unix)] +fn host_file_bytes_available(host_fd: i32) -> Result { + let mut bytes_found = 0 as libc::c_int; + let result = unsafe { libc::ioctl(host_fd, libc::FIONREAD, &mut bytes_found) }; + + match result { + // success + 0 => Ok(bytes_found.try_into().unwrap_or(0)), + libc::EBADF => Err(FsError::InvalidFd), + libc::EFAULT => Err(FsError::InvalidData), + libc::EINVAL => Err(FsError::InvalidInput), + _ => Err(FsError::IOError), + } +} + +#[cfg(not(unix))] +fn host_file_bytes_available(_raw_fd: i32) -> Result { + unimplemented!("host_file_bytes_available not yet implemented for non-Unix-like targets. This probably means the program tried to use wasi::poll_oneoff") +} + +/// A wrapper type around Stdout that implements `VirtualFile` and +/// `Serialize` + `Deserialize`. +#[derive(Debug, Serialize, Deserialize, Default)] +pub struct Stdout; +impl Read for Stdout { + fn read(&mut self, _buf: &mut [u8]) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stdout", + )) + } + fn read_to_end(&mut self, _buf: &mut Vec) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stdout", + )) + } + fn read_to_string(&mut self, _buf: &mut String) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stdout", + )) + } + fn read_exact(&mut self, _buf: &mut [u8]) -> io::Result<()> { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stdout", + )) + } +} +impl Seek for Stdout { + fn seek(&mut self, _pos: io::SeekFrom) -> io::Result { + Err(io::Error::new(io::ErrorKind::Other, "can not seek stdout")) + } +} +impl Write for Stdout { + fn write(&mut self, buf: &[u8]) -> io::Result { + io::stdout().write(buf) + } + fn flush(&mut self) -> io::Result<()> { + io::stdout().flush() + } + fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { + io::stdout().write_all(buf) + } + fn write_fmt(&mut self, fmt: ::std::fmt::Arguments) -> io::Result<()> { + io::stdout().write_fmt(fmt) + } +} + +impl VirtualFile for Stdout { + fn last_accessed(&self) -> u64 { + 0 + } + fn last_modified(&self) -> u64 { + 0 + } + fn created_time(&self) -> u64 { + 0 + } + fn size(&self) -> u64 { + 0 + } + fn set_len(&mut self, _new_size: u64) -> Result<(), FsError> { + debug!("Calling VirtualFile::set_len on stdout; this is probably a bug"); + Err(FsError::PermissionDenied) + } + fn unlink(&mut self) -> Result<(), FsError> { + Ok(()) + } + + fn bytes_available(&self) -> Result { + // unwrap is safe because of get_raw_fd implementation + let host_fd = self.get_raw_fd().unwrap(); + + host_file_bytes_available(host_fd) + } + + #[cfg(unix)] + fn get_raw_fd(&self) -> Option { + use std::os::unix::io::AsRawFd; + Some(io::stdout().as_raw_fd()) + } + + #[cfg(not(unix))] + fn get_raw_fd(&self) -> Option { + unimplemented!( + "Stdout::get_raw_fd in VirtualFile is not implemented for non-Unix-like targets yet" + ); + } +} + +/// A wrapper type around Stderr that implements `VirtualFile` and +/// `Serialize` + `Deserialize`. +#[derive(Debug, Serialize, Deserialize, Default)] +pub struct Stderr; +impl Read for Stderr { + fn read(&mut self, _buf: &mut [u8]) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stderr", + )) + } + fn read_to_end(&mut self, _buf: &mut Vec) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stderr", + )) + } + fn read_to_string(&mut self, _buf: &mut String) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stderr", + )) + } + fn read_exact(&mut self, _buf: &mut [u8]) -> io::Result<()> { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stderr", + )) + } +} +impl Seek for Stderr { + fn seek(&mut self, _pos: io::SeekFrom) -> io::Result { + Err(io::Error::new(io::ErrorKind::Other, "can not seek stderr")) + } +} +impl Write for Stderr { + fn write(&mut self, buf: &[u8]) -> io::Result { + io::stderr().write(buf) + } + fn flush(&mut self) -> io::Result<()> { + io::stderr().flush() + } + fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { + io::stderr().write_all(buf) + } + fn write_fmt(&mut self, fmt: ::std::fmt::Arguments) -> io::Result<()> { + io::stderr().write_fmt(fmt) + } +} + +impl VirtualFile for Stderr { + fn last_accessed(&self) -> u64 { + 0 + } + fn last_modified(&self) -> u64 { + 0 + } + fn created_time(&self) -> u64 { + 0 + } + fn size(&self) -> u64 { + 0 + } + fn set_len(&mut self, _new_size: u64) -> Result<(), FsError> { + debug!("Calling VirtualFile::set_len on stderr; this is probably a bug"); + Err(FsError::PermissionDenied) + } + fn unlink(&mut self) -> Result<(), FsError> { + Ok(()) + } + + fn bytes_available(&self) -> Result { + // unwrap is safe because of get_raw_fd implementation + let host_fd = self.get_raw_fd().unwrap(); + + host_file_bytes_available(host_fd) + } + + #[cfg(unix)] + fn get_raw_fd(&self) -> Option { + use std::os::unix::io::AsRawFd; + Some(io::stderr().as_raw_fd()) + } + + #[cfg(not(unix))] + fn get_raw_fd(&self) -> Option { + unimplemented!( + "Stderr::get_raw_fd in VirtualFile is not implemented for non-Unix-like targets yet" + ); + } +} + +/// A wrapper type around Stdin that implements `VirtualFile` and +/// `Serialize` + `Deserialize`. +#[derive(Debug, Serialize, Deserialize, Default)] +pub struct Stdin; +impl Read for Stdin { + fn read(&mut self, buf: &mut [u8]) -> io::Result { + io::stdin().read(buf) + } + fn read_to_end(&mut self, buf: &mut Vec) -> io::Result { + io::stdin().read_to_end(buf) + } + fn read_to_string(&mut self, buf: &mut String) -> io::Result { + io::stdin().read_to_string(buf) + } + fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { + io::stdin().read_exact(buf) + } +} +impl Seek for Stdin { + fn seek(&mut self, _pos: io::SeekFrom) -> io::Result { + Err(io::Error::new(io::ErrorKind::Other, "can not seek stdin")) + } +} +impl Write for Stdin { + fn write(&mut self, _buf: &[u8]) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not write to stdin", + )) + } + fn flush(&mut self) -> io::Result<()> { + Err(io::Error::new( + io::ErrorKind::Other, + "can not write to stdin", + )) + } + fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> { + Err(io::Error::new( + io::ErrorKind::Other, + "can not write to stdin", + )) + } + fn write_fmt(&mut self, _fmt: ::std::fmt::Arguments) -> io::Result<()> { + Err(io::Error::new( + io::ErrorKind::Other, + "can not write to stdin", + )) + } +} + +impl VirtualFile for Stdin { + fn last_accessed(&self) -> u64 { + 0 + } + fn last_modified(&self) -> u64 { + 0 + } + fn created_time(&self) -> u64 { + 0 + } + fn size(&self) -> u64 { + 0 + } + fn set_len(&mut self, _new_size: u64) -> Result<(), FsError> { + debug!("Calling VirtualFile::set_len on stdin; this is probably a bug"); + Err(FsError::PermissionDenied) + } + + fn unlink(&mut self) -> Result<(), FsError> { + Ok(()) + } + + fn bytes_available(&self) -> Result { + // unwrap is safe because of get_raw_fd implementation + let host_fd = self.get_raw_fd().unwrap(); + + host_file_bytes_available(host_fd) + } + + #[cfg(unix)] + fn get_raw_fd(&self) -> Option { + use std::os::unix::io::AsRawFd; + Some(io::stdin().as_raw_fd()) + } + + #[cfg(not(unix))] + fn get_raw_fd(&self) -> Option { + unimplemented!( + "Stdin::get_raw_fd in VirtualFile is not implemented for non-Unix-like targets yet" + ); + } +} diff --git a/lib/vfs/src/lib.rs b/lib/vfs/src/lib.rs new file mode 100644 index 00000000000..a13d9f8b05b --- /dev/null +++ b/lib/vfs/src/lib.rs @@ -0,0 +1,445 @@ +use std::any::Any; +use std::ffi::OsString; +use std::fmt; +use std::io::{self, Read, Seek, Write}; +use std::path::{Path, PathBuf}; +use thiserror::Error; +use tracing::debug; + +#[cfg(feature = "host_fs")] +pub mod host_fs; +//pub mod vfs_fs; +#[cfg(feature = "mem_fs")] +pub mod mem_fs; + +pub trait FileSystem: Send + Sync + 'static { + fn read_dir(&self, path: &Path) -> Result; + fn create_dir(&self, path: &Path) -> Result<(), FsError>; + fn remove_dir(&self, path: &Path) -> Result<(), FsError>; + fn rename(&self, from: &Path, to: &Path) -> Result<(), FsError>; + fn metadata(&self, path: &Path) -> Result; + /// This method gets metadata without following symlinks in the path. + /// Currently identical to `metadata` because symlinks aren't implemented + /// yet. + fn symlink_metadata(&self, path: &Path) -> Result { + self.metadata(path) + } + + fn remove_file(&self, path: &Path) -> Result<(), FsError>; + fn new_open_options(&self) -> OpenOptions; +} + +pub trait FileOpener { + fn open( + &mut self, + path: &Path, + conf: &OpenOptionsConfig, + ) -> Result, FsError>; +} + +#[derive(Debug, Clone)] +pub struct OpenOptionsConfig { + read: bool, + write: bool, + create_new: bool, + create: bool, + append: bool, + truncate: bool, +} + +impl OpenOptionsConfig { + pub const fn read(&self) -> bool { + self.read + } + + pub const fn write(&self) -> bool { + self.write + } + + pub const fn create_new(&self) -> bool { + self.create_new + } + + pub const fn create(&self) -> bool { + self.create + } + + pub const fn append(&self) -> bool { + self.append + } + + pub const fn truncate(&self) -> bool { + self.truncate + } +} + +// TODO: manually implement debug + +pub struct OpenOptions { + opener: Box, + conf: OpenOptionsConfig, +} + +impl OpenOptions { + pub fn new(opener: Box) -> Self { + Self { + opener, + conf: OpenOptionsConfig { + read: false, + write: false, + create_new: false, + create: false, + append: false, + truncate: false, + }, + } + } + + pub fn read(&mut self, read: bool) -> &mut Self { + self.conf.read = read; + self + } + + pub fn write(&mut self, write: bool) -> &mut Self { + self.conf.write = write; + self + } + + pub fn append(&mut self, append: bool) -> &mut Self { + self.conf.append = append; + self + } + + pub fn truncate(&mut self, truncate: bool) -> &mut Self { + self.conf.truncate = truncate; + self + } + + pub fn create(&mut self, create: bool) -> &mut Self { + self.conf.create = create; + self + } + + pub fn create_new(&mut self, create_new: bool) -> &mut Self { + self.conf.create_new = create_new; + self + } + + pub fn open>(&mut self, path: P) -> Result, FsError> { + self.opener.open(path.as_ref(), &self.conf) + } +} + +/// This trait relies on your file closing when it goes out of scope via `Drop` +// #[typetag::serde(tag = "type")] +pub trait VirtualFile: fmt::Debug + Send + Write + Read + Seek + 'static + Upcastable { + /// the last time the file was accessed in nanoseconds as a UNIX timestamp + fn last_accessed(&self) -> u64; + + /// the last time the file was modified in nanoseconds as a UNIX timestamp + fn last_modified(&self) -> u64; + + /// the time at which the file was created in nanoseconds as a UNIX timestamp + fn created_time(&self) -> u64; + + /// the size of the file in bytes + fn size(&self) -> u64; + + /// Change the size of the file, if the `new_size` is greater than the current size + /// the extra bytes will be allocated and zeroed + fn set_len(&mut self, new_size: u64) -> Result<(), FsError>; + + /// Request deletion of the file + fn unlink(&mut self) -> Result<(), FsError>; + + /// Store file contents and metadata to disk + /// Default implementation returns `Ok(())`. You should implement this method if you care + /// about flushing your cache to permanent storage + fn sync_to_disk(&self) -> Result<(), FsError> { + Ok(()) + } + + /// Moves the file to a new location + /// NOTE: the signature of this function will change before stabilization + // TODO: stablizie this in 0.7.0 or 0.8.0 by removing default impl + fn rename_file(&self, _new_name: &std::path::Path) -> Result<(), FsError> { + panic!("Default implementation for now as this method is unstable; this default implementation or this entire method may be removed in a future release."); + } + + /// Returns the number of bytes available. This function must not block + fn bytes_available(&self) -> Result; + + /// Used for polling. Default returns `None` because this method cannot be implemented for most types + /// Returns the underlying host fd + fn get_raw_fd(&self) -> Option { + None + } +} + +// Implementation of `Upcastable` taken from https://users.rust-lang.org/t/why-does-downcasting-not-work-for-subtraits/33286/7 . +/// Trait needed to get downcasting from `VirtualFile` to work. +pub trait Upcastable { + fn upcast_any_ref(&'_ self) -> &'_ dyn Any; + fn upcast_any_mut(&'_ mut self) -> &'_ mut dyn Any; + fn upcast_any_box(self: Box) -> Box; +} + +impl Upcastable for T { + #[inline] + fn upcast_any_ref(&'_ self) -> &'_ dyn Any { + self + } + #[inline] + fn upcast_any_mut(&'_ mut self) -> &'_ mut dyn Any { + self + } + #[inline] + fn upcast_any_box(self: Box) -> Box { + self + } +} + +impl dyn VirtualFile + 'static { + #[inline] + pub fn downcast_ref(&'_ self) -> Option<&'_ T> { + self.upcast_any_ref().downcast_ref::() + } + #[inline] + pub fn downcast_mut(&'_ mut self) -> Option<&'_ mut T> { + self.upcast_any_mut().downcast_mut::() + } +} + +/// Error type for external users +#[derive(Error, Copy, Clone, Debug, PartialEq, Eq)] +pub enum FsError { + /// The fd given as a base was not a directory so the operation was not possible + #[error("fd not a directory")] + BaseNotDirectory, + /// Expected a file but found not a file + #[error("fd not a file")] + NotAFile, + /// The fd given was not usable + #[error("invalid fd")] + InvalidFd, + /// File exists + #[error("file exists")] + AlreadyExists, + /// Something failed when doing IO. These errors can generally not be handled. + /// It may work if tried again. + #[error("io error")] + IOError, + /// The address was in use + #[error("address is in use")] + AddressInUse, + /// The address could not be found + #[error("address could not be found")] + AddressNotAvailable, + /// A pipe was closed + #[error("broken pipe (was closed)")] + BrokenPipe, + /// The connection was aborted + #[error("connection aborted")] + ConnectionAborted, + /// The connection request was refused + #[error("connection refused")] + ConnectionRefused, + /// The connection was reset + #[error("connection reset")] + ConnectionReset, + /// The operation was interrupted before it could finish + #[error("operation interrupted")] + Interrupted, + /// Invalid internal data, if the argument data is invalid, use `InvalidInput` + #[error("invalid internal data")] + InvalidData, + /// The provided data is invalid + #[error("invalid input")] + InvalidInput, + /// Could not perform the operation because there was not an open connection + #[error("connection is not open")] + NotConnected, + /// The requested file or directory could not be found + #[error("entity not found")] + EntityNotFound, + /// The requested device couldn't be accessed + #[error("can't access device")] + NoDevice, + /// Caller was not allowed to perform this operation + #[error("permission denied")] + PermissionDenied, + /// The operation did not complete within the given amount of time + #[error("time out")] + TimedOut, + /// Found EOF when EOF was not expected + #[error("unexpected eof")] + UnexpectedEof, + /// Operation would block, this error lets the caller know that they can try again + #[error("blocking operation. try again")] + WouldBlock, + /// A call to write returned 0 + #[error("write returned 0")] + WriteZero, + /// Some other unhandled error. If you see this, it's probably a bug. + #[error("unknown error found")] + UnknownError, +} + +impl From for FsError { + fn from(io_error: io::Error) -> Self { + match io_error.kind() { + io::ErrorKind::AddrInUse => FsError::AddressInUse, + io::ErrorKind::AddrNotAvailable => FsError::AddressNotAvailable, + io::ErrorKind::AlreadyExists => FsError::AlreadyExists, + io::ErrorKind::BrokenPipe => FsError::BrokenPipe, + io::ErrorKind::ConnectionAborted => FsError::ConnectionAborted, + io::ErrorKind::ConnectionRefused => FsError::ConnectionRefused, + io::ErrorKind::ConnectionReset => FsError::ConnectionReset, + io::ErrorKind::Interrupted => FsError::Interrupted, + io::ErrorKind::InvalidData => FsError::InvalidData, + io::ErrorKind::InvalidInput => FsError::InvalidInput, + io::ErrorKind::NotConnected => FsError::NotConnected, + io::ErrorKind::NotFound => FsError::EntityNotFound, + io::ErrorKind::PermissionDenied => FsError::PermissionDenied, + io::ErrorKind::TimedOut => FsError::TimedOut, + io::ErrorKind::UnexpectedEof => FsError::UnexpectedEof, + io::ErrorKind::WouldBlock => FsError::WouldBlock, + io::ErrorKind::WriteZero => FsError::WriteZero, + io::ErrorKind::Other => FsError::IOError, + // if the following triggers, a new error type was added to this non-exhaustive enum + _ => FsError::UnknownError, + } + } +} + +#[derive(Debug)] +pub struct ReadDir { + // TODO: to do this properly we need some kind of callback to the core FS abstraction + data: Vec, + index: usize, +} + +impl ReadDir { + pub fn new(data: Vec) -> Self { + Self { data, index: 0 } + } +} + +#[derive(Debug, Clone)] +pub struct DirEntry { + pub path: PathBuf, + // weird hack, to fix this we probably need an internal trait object or callbacks or something + pub metadata: Result, +} + +impl DirEntry { + pub fn path(&self) -> PathBuf { + self.path.clone() + } + + pub fn metadata(&self) -> Result { + self.metadata.clone() + } + + pub fn file_type(&self) -> Result { + let metadata = self.metadata.clone()?; + Ok(metadata.file_type()) + } + + pub fn file_name(&self) -> OsString { + self.path.as_os_str().to_owned() + } +} + +#[derive(Clone, Debug)] +// TODO: review this, proper solution would probably use a trait object internally +pub struct Metadata { + pub ft: FileType, + pub accessed: u64, + pub created: u64, + pub modified: u64, + pub len: u64, +} + +impl Metadata { + pub fn is_file(&self) -> bool { + self.ft.is_file() + } + pub fn is_dir(&self) -> bool { + self.ft.is_dir() + } + pub fn accessed(&self) -> u64 { + self.accessed + } + pub fn created(&self) -> u64 { + self.created + } + pub fn modified(&self) -> u64 { + self.modified + } + pub fn file_type(&self) -> FileType { + self.ft.clone() + } + pub fn len(&self) -> u64 { + self.len + } +} + +#[derive(Clone, Debug)] +// TODO: review this, proper solution would probably use a trait object internally +pub struct FileType { + pub dir: bool, + pub file: bool, + pub symlink: bool, + // TODO: the following 3 only exist on unix in the standard FS API. + // We should mirror that API and extend with that trait too. + pub char_device: bool, + pub block_device: bool, + pub socket: bool, + pub fifo: bool, +} + +impl FileType { + pub fn is_dir(&self) -> bool { + self.dir + } + pub fn is_file(&self) -> bool { + self.file + } + pub fn is_symlink(&self) -> bool { + self.symlink + } + pub fn is_char_device(&self) -> bool { + self.char_device + } + pub fn is_block_device(&self) -> bool { + self.block_device + } + pub fn is_socket(&self) -> bool { + self.socket + } + pub fn is_fifo(&self) -> bool { + self.fifo + } +} + +impl Iterator for ReadDir { + type Item = Result; + + fn next(&mut self) -> Option> { + if let Some(v) = self.data.get(self.index).cloned() { + self.index += 1; + return Some(Ok(v)); + } + None + } +} + +/*impl From for FsError { + fn from(vfs_error: vfs::VfsError) -> Self { + match vfs_error { + vfs::VfsError::IoError(io_error) => io_error.into(), + _ => todo!("Not yet handled vfs error type {:?}", vfs_error) + } + } +}*/ diff --git a/lib/vfs/src/mem_fs.rs b/lib/vfs/src/mem_fs.rs new file mode 100644 index 00000000000..75331e9842a --- /dev/null +++ b/lib/vfs/src/mem_fs.rs @@ -0,0 +1,892 @@ +use crate::*; +// use serde::{Deserialize, Serialize}; +use std::collections::HashMap; +use std::io::{Read, Seek, Write}; +use std::path::Path; +use std::sync::{Arc, Mutex}; + +// pub use crate::host_fs::{Stderr, Stdin, Stdout}; + +#[derive(Debug, Clone)] +enum MemKind { + File { + name: String, + inode: u64, + }, + Directory { + name: String, + contents: HashMap, + }, +} + +impl Default for MemKind { + fn default() -> Self { + MemKind::Directory { + name: "/".to_string(), + contents: Default::default(), + } + } +} + +#[derive(Clone, Default)] +pub struct MemFileSystem { + inner: Arc>, +} + +#[derive(Default)] +pub struct MemFileSystemInner { + // done for recursion purposes + fs: MemKind, + inodes: HashMap>, + next_inode: u64, +} + +impl MemFileSystemInner { + fn get_memkind_at(&self, path: &Path) -> Option<&MemKind> { + let mut components = path.components(); + if path.is_absolute() { + components.next()?; + } + + let mut memkind: &MemKind = &self.fs; + + for component in components { + match memkind { + MemKind::Directory { contents, .. } => { + memkind = contents.get(component.as_os_str().to_str().unwrap())?; + } + _ => return None, + } + } + Some(memkind) + } + fn get_memkind_at_mut(&mut self, path: &Path) -> Option<&mut MemKind> { + let mut components = path.components(); + if path.is_absolute() { + components.next()?; + } + + let mut memkind: &mut MemKind = &mut self.fs; + + for component in components { + match memkind { + MemKind::Directory { contents, .. } => { + memkind = contents.get_mut(component.as_os_str().to_str().unwrap())?; + } + _ => return None, + } + } + Some(memkind) + } +} + +impl FileSystem for MemFileSystem { + fn read_dir(&self, path: &Path) -> Result { + todo!() + } + fn create_dir(&self, path: &Path) -> Result<(), FsError> { + // TODO: handle errors + let parent = path.parent().unwrap(); + let file = path.file_name().unwrap(); + let mut inner = self.inner.lock().unwrap(); + let memkind = inner.get_memkind_at_mut(parent).unwrap(); + match memkind { + MemKind::Directory { contents, .. } => { + let name = file.to_str().unwrap().to_string(); + if contents.contains_key(&name) { + // TODO: handle error + panic!("file exists at given path"); + } + let mk = MemKind::Directory { + name: name.clone(), + contents: Default::default(), + }; + contents.insert(name.clone(), mk); + } + _ => panic!("found file, expected directory"), + } + Ok(()) + } + fn remove_dir(&self, path: &Path) -> Result<(), FsError> { + let parent = path.parent().unwrap(); + let file = path.file_name().unwrap(); + let mut inner = self.inner.lock().unwrap(); + let memkind = inner.get_memkind_at_mut(parent).unwrap(); + match memkind { + MemKind::Directory { contents, .. } => { + let name = file.to_str().unwrap().to_string(); + match contents.get(&name).unwrap() { + MemKind::Directory { contents, .. } => { + if !contents.is_empty() { + // TODO: handle error + panic!("Can't delete directory, directory is not empty"); + } + } + _ => panic!("expected directory, found file"), + } + contents.remove(&name); + } + _ => panic!("found file, expected directory"), + } + Ok(()) + } + fn rename(&self, from: &Path, to: &Path) -> Result<(), FsError> { + todo!("rename") + //fs::rename(from, to).map_err(Into::into) + } + + fn remove_file(&self, path: &Path) -> Result<(), FsError> { + let parent = path.parent().unwrap(); + let file = path.file_name().unwrap(); + let mut inner = self.inner.lock().unwrap(); + let memkind = inner.get_memkind_at_mut(parent).unwrap(); + let inode: u64 = match memkind { + MemKind::Directory { contents, .. } => { + let name = file.to_str().unwrap().to_string(); + let inode: u64 = match contents.get(&name).unwrap() { + MemKind::File { inode, .. } => *inode, + _ => panic!("expected file, found directory"), + }; + contents.remove(&name); + inode + } + _ => panic!("found file, expected directory"), + }; + inner.inodes.remove(&inode); + Ok(()) + } + fn new_open_options(&self) -> OpenOptions { + OpenOptions::new(Box::new(MemFileOpener(self.clone()))) + } + + fn metadata(&self, path: &Path) -> Result { + // let inner = self.inner.lock().unwrap(); + // let memkind = inner.get_memkind_at(path) + Ok(Metadata { + ft: FileType { + dir: false, + file: true, + symlink: false, + char_device: false, + block_device: false, + socket: false, + fifo: false, + }, + accessed: 0 as u64, + created: 0 as u64, + modified: 0 as u64, + len: 0, + }) + } +} + +#[derive(Clone)] +pub struct MemFileOpener(MemFileSystem); + +impl FileOpener for MemFileOpener { + fn open( + &mut self, + path: &Path, + conf: &OpenOptionsConfig, + ) -> Result, FsError> { + // TODO: handle create implying write, etc. + let read = conf.read(); + let write = conf.write(); + let append = conf.append(); + let virtual_file = + Box::new(MemFile::new(vec![], read, write, append)) as Box; + let mut inner = self.0.inner.lock().unwrap(); + let inode = inner.next_inode; + + let parent_path = path.parent().unwrap(); + let file_name = path.file_name().unwrap().to_str().unwrap().to_string(); + // TODO: replace with an actual missing directory error + let parent_memkind = inner + .get_memkind_at_mut(parent_path) + .ok_or(FsError::IOError)?; + match parent_memkind { + MemKind::Directory { contents, .. } => { + if contents.contains_key(&file_name) { + return Err(FsError::AlreadyExists); + } + contents.insert( + file_name.clone(), + MemKind::File { + name: file_name, + inode, + }, + ); + } + _ => { + // expected directory + // TODO: return a more proper error here + return Err(FsError::IOError); + } + } + + inner.next_inode += 1; + inner.inodes.insert(inode, virtual_file); + + Ok(Box::new(MemFileHandle { + fs: self.0.clone(), + inode, + }) as Box) + } +} + +#[derive(Debug)] +pub struct MemFile { + buffer: Vec, + cursor: usize, + flags: u16, + last_accessed: u64, + last_modified: u64, + created_time: u64, +} + +impl MemFile { + const READ: u16 = 1; + const WRITE: u16 = 2; + const APPEND: u16 = 4; + + /// creates a new host file from a `std::fs::File` and a path + pub fn new(buffer: Vec, read: bool, write: bool, append: bool) -> Self { + let mut flags = 0; + if read { + flags |= Self::READ; + } + if write { + flags |= Self::WRITE; + } + if append { + flags |= Self::APPEND; + } + Self { + buffer, + cursor: 0, + flags, + last_accessed: 0, + last_modified: 0, + created_time: 0, + } + } +} + +impl Read for MemFile { + fn read(&mut self, buf: &mut [u8]) -> io::Result { + let upper_limit = std::cmp::min(self.buffer.len() - self.cursor, buf.len()); + for i in 0..upper_limit { + buf[i] = self.buffer[self.cursor + i]; + } + self.cursor += upper_limit; + Ok(upper_limit) + } + fn read_to_end(&mut self, buf: &mut Vec) -> io::Result { + let data_to_copy = self.buffer.len() - self.cursor; + buf.reserve(data_to_copy); + for i in self.cursor..self.buffer.len() { + buf.push(self.buffer[i]); + } + Ok(data_to_copy) + } + fn read_to_string(&mut self, buf: &mut String) -> io::Result { + // TODO: error handling + let s = std::str::from_utf8(&self.buffer[self.cursor..]).unwrap(); + buf.push_str(s); + let amount_read = self.buffer.len() - self.cursor; + self.cursor = self.buffer.len(); + Ok(amount_read) + } + fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { + if buf.len() < (self.buffer.len() - self.cursor) { + return Err(std::io::Error::new( + std::io::ErrorKind::UnexpectedEof, + "Not enough bytes available", + )); + } + for i in 0..buf.len() { + buf[i] = self.buffer[self.cursor + i]; + } + self.cursor += buf.len(); + Ok(()) + } +} +impl Seek for MemFile { + fn seek(&mut self, pos: io::SeekFrom) -> io::Result { + match pos { + io::SeekFrom::Start(s) => self.cursor = s as usize, + // TODO: handle underflow / overflow properly + io::SeekFrom::End(s) => self.cursor = (self.buffer.len() as i64 + s) as usize, + io::SeekFrom::Current(s) => self.cursor = (self.cursor as i64 + s) as usize, + } + Ok(self.cursor as u64) + } +} +impl Write for MemFile { + fn write(&mut self, buf: &[u8]) -> io::Result { + self.buffer.write(buf) + } + fn flush(&mut self) -> io::Result<()> { + self.buffer.flush() + } + fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { + self.buffer.write_all(buf) + } + fn write_fmt(&mut self, fmt: ::std::fmt::Arguments) -> io::Result<()> { + self.buffer.write_fmt(fmt) + } +} + +// #[typetag::serde] +impl VirtualFile for MemFile { + fn last_accessed(&self) -> u64 { + self.last_accessed + } + + fn last_modified(&self) -> u64 { + self.last_modified + } + + fn created_time(&self) -> u64 { + self.created_time + } + + fn size(&self) -> u64 { + self.buffer.len() as u64 + } + + fn set_len(&mut self, new_size: u64) -> Result<(), FsError> { + self.buffer.resize(new_size as usize, 0); + Ok(()) + } + + fn unlink(&mut self) -> Result<(), FsError> { + self.buffer.clear(); + self.cursor = 0; + Ok(()) + } + fn sync_to_disk(&self) -> Result<(), FsError> { + Ok(()) + } + + fn rename_file(&self, _new_name: &std::path::Path) -> Result<(), FsError> { + Ok(()) + } + + fn bytes_available(&self) -> Result { + Ok(self.buffer.len() - self.cursor) + } + + fn get_raw_fd(&self) -> Option { + None + } +} + +// #[derive(Serialize, Deserialize)] +pub struct MemFileHandle { + // hack, just skip it + // #[serde(skip)] + fs: MemFileSystem, + inode: u64, +} + +impl MemFileHandle { + // not optimal,but good enough for now + fn no_file_err() -> std::io::Error { + std::io::Error::new(std::io::ErrorKind::NotFound, "File was closed") + } +} + +impl std::fmt::Debug for MemFileHandle { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("MemFileHandle") + .field("inode", &self.inode) + .finish() + } +} + +impl Read for MemFileHandle { + fn read(&mut self, buf: &mut [u8]) -> io::Result { + let mut inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get_mut(&self.inode) + .ok_or_else(Self::no_file_err)?; + + file.read(buf) + } + fn read_to_end(&mut self, buf: &mut Vec) -> io::Result { + let mut inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get_mut(&self.inode) + .ok_or_else(Self::no_file_err)?; + + file.read_to_end(buf) + } + fn read_to_string(&mut self, buf: &mut String) -> io::Result { + let mut inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get_mut(&self.inode) + .ok_or_else(Self::no_file_err)?; + + file.read_to_string(buf) + } + fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { + let mut inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get_mut(&self.inode) + .ok_or_else(Self::no_file_err)?; + + file.read_exact(buf) + } +} +impl Seek for MemFileHandle { + fn seek(&mut self, pos: io::SeekFrom) -> io::Result { + let mut inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get_mut(&self.inode) + .ok_or_else(Self::no_file_err)?; + + file.seek(pos) + } +} +impl Write for MemFileHandle { + fn write(&mut self, buf: &[u8]) -> io::Result { + let mut inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get_mut(&self.inode) + .ok_or_else(Self::no_file_err)?; + + file.write(buf) + } + fn flush(&mut self) -> io::Result<()> { + let mut inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get_mut(&self.inode) + .ok_or_else(Self::no_file_err)?; + + file.flush() + } + fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { + let mut inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get_mut(&self.inode) + .ok_or_else(Self::no_file_err)?; + + file.write_all(buf) + } + fn write_fmt(&mut self, fmt: ::std::fmt::Arguments) -> io::Result<()> { + let mut inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get_mut(&self.inode) + .ok_or_else(Self::no_file_err)?; + + file.write_fmt(fmt) + } +} + +// #[typetag::serde] +// #[typetag::serde(name = "type")] +impl VirtualFile for MemFileHandle { + fn last_accessed(&self) -> u64 { + let inner = self.fs.inner.lock().unwrap(); + inner + .inodes + .get(&self.inode) + .as_ref() + .map(|file| file.last_accessed()) + .unwrap_or_default() + } + + fn last_modified(&self) -> u64 { + let inner = self.fs.inner.lock().unwrap(); + inner + .inodes + .get(&self.inode) + .as_ref() + .map(|file| file.last_modified()) + .unwrap_or_default() + } + + fn created_time(&self) -> u64 { + let inner = self.fs.inner.lock().unwrap(); + inner + .inodes + .get(&self.inode) + .as_ref() + .map(|file| file.created_time()) + .unwrap_or_default() + } + + fn size(&self) -> u64 { + let inner = self.fs.inner.lock().unwrap(); + inner + .inodes + .get(&self.inode) + .as_ref() + .map(|file| file.size()) + .unwrap_or_default() + } + + fn set_len(&mut self, new_size: u64) -> Result<(), FsError> { + let mut inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get_mut(&self.inode) + .ok_or(FsError::InvalidFd)?; + + file.set_len(new_size) + } + + fn unlink(&mut self) -> Result<(), FsError> { + let mut inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get_mut(&self.inode) + .ok_or(FsError::InvalidFd)?; + + file.unlink() + } + fn sync_to_disk(&self) -> Result<(), FsError> { + let inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get(&self.inode) + .ok_or_else(Self::no_file_err)?; + + file.sync_to_disk() + } + + fn rename_file(&self, new_name: &std::path::Path) -> Result<(), FsError> { + let inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get(&self.inode) + .ok_or_else(Self::no_file_err)?; + + file.rename_file(new_name) + } + + fn bytes_available(&self) -> Result { + let inner = self.fs.inner.lock().unwrap(); + let file = inner + .inodes + .get(&self.inode) + .ok_or_else(Self::no_file_err)?; + + file.bytes_available() + } + + fn get_raw_fd(&self) -> Option { + let inner = self.fs.inner.lock().unwrap(); + let file = inner.inodes.get(&self.inode)?; + + file.get_raw_fd() + } +} + +// Stdin / Stdout / Stderr definitions + +/// A wrapper type around Stdout that implements `VirtualFile` +#[derive(Debug, Default)] +pub struct Stdout { + pub buf: Vec, +} + +impl Read for Stdout { + fn read(&mut self, _buf: &mut [u8]) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stdout", + )) + } + fn read_to_end(&mut self, _buf: &mut Vec) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stdout", + )) + } + fn read_to_string(&mut self, _buf: &mut String) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stdout", + )) + } + fn read_exact(&mut self, _buf: &mut [u8]) -> io::Result<()> { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stdout", + )) + } +} +impl Seek for Stdout { + fn seek(&mut self, _pos: io::SeekFrom) -> io::Result { + Err(io::Error::new(io::ErrorKind::Other, "can not seek stdout")) + } +} +impl Write for Stdout { + fn write(&mut self, buf: &[u8]) -> io::Result { + // io::stdout().write(buf) + unimplemented!(); + } + fn flush(&mut self) -> io::Result<()> { + // io::stdout().flush() + // unimplemented!(); + Ok(()) + } + fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { + // io::stdout().write_all(buf) + self.buf.extend_from_slice(&buf); + Ok(()) + } + fn write_fmt(&mut self, fmt: ::std::fmt::Arguments) -> io::Result<()> { + // io::stdout().write_fmt(fmt) + unimplemented!(); + } +} + +impl VirtualFile for Stdout { + fn last_accessed(&self) -> u64 { + 0 + } + fn last_modified(&self) -> u64 { + 0 + } + fn created_time(&self) -> u64 { + 0 + } + fn size(&self) -> u64 { + 0 + } + fn set_len(&mut self, _new_size: u64) -> Result<(), FsError> { + debug!("Calling VirtualFile::set_len on stdout; this is probably a bug"); + Err(FsError::PermissionDenied) + } + fn unlink(&mut self) -> Result<(), FsError> { + Ok(()) + } + + fn bytes_available(&self) -> Result { + // unwrap is safe because of get_raw_fd implementation + unimplemented!(); + } + + #[cfg(unix)] + fn get_raw_fd(&self) -> Option { + unimplemented!(); + } + + #[cfg(not(unix))] + fn get_raw_fd(&self) -> Option { + unimplemented!(); + } +} + +/// A wrapper type around Stderr that implements `VirtualFile` and +/// `Serialize` + `Deserialize`. +#[derive(Debug, Default)] +pub struct Stderr { + pub buf: Vec, +} +impl Read for Stderr { + fn read(&mut self, _buf: &mut [u8]) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stderr", + )) + } + fn read_to_end(&mut self, _buf: &mut Vec) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stderr", + )) + } + fn read_to_string(&mut self, _buf: &mut String) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stderr", + )) + } + fn read_exact(&mut self, _buf: &mut [u8]) -> io::Result<()> { + Err(io::Error::new( + io::ErrorKind::Other, + "can not read from stderr", + )) + } +} +impl Seek for Stderr { + fn seek(&mut self, _pos: io::SeekFrom) -> io::Result { + Err(io::Error::new(io::ErrorKind::Other, "can not seek stderr")) + } +} +impl Write for Stderr { + fn write(&mut self, buf: &[u8]) -> io::Result { + // io::stderr().write(buf) + unimplemented!(); + } + fn flush(&mut self) -> io::Result<()> { + // io::stderr().flush() + // unimplemented!(); + Ok(()) + } + fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { + self.buf.extend_from_slice(&buf); + Ok(()) + // io::stderr().write_all(buf) + // unimplemented!(); + } + fn write_fmt(&mut self, fmt: ::std::fmt::Arguments) -> io::Result<()> { + // io::stderr().write_fmt(fmt) + unimplemented!(); + } +} + +impl VirtualFile for Stderr { + fn last_accessed(&self) -> u64 { + 0 + } + fn last_modified(&self) -> u64 { + 0 + } + fn created_time(&self) -> u64 { + 0 + } + fn size(&self) -> u64 { + 0 + } + fn set_len(&mut self, _new_size: u64) -> Result<(), FsError> { + debug!("Calling VirtualFile::set_len on stderr; this is probably a bug"); + Err(FsError::PermissionDenied) + } + fn unlink(&mut self) -> Result<(), FsError> { + Ok(()) + } + + fn bytes_available(&self) -> Result { + unimplemented!(); + } + + #[cfg(unix)] + fn get_raw_fd(&self) -> Option { + unimplemented!(); + // use std::os::unix::io::AsRawFd; + // Some(io::stderr().as_raw_fd()) + } + + #[cfg(not(unix))] + fn get_raw_fd(&self) -> Option { + unimplemented!( + "Stderr::get_raw_fd in VirtualFile is not implemented for non-Unix-like targets yet" + ); + } +} + +/// A wrapper type around Stdin that implements `VirtualFile` and +/// `Serialize` + `Deserialize`. +#[derive(Debug, Default)] +pub struct Stdin { + pub buf: Vec, +} + +impl Read for Stdin { + fn read(&mut self, buf: &mut [u8]) -> io::Result { + let len = std::cmp::min(buf.len(), self.buf.len()); + for (i, val) in self.buf.drain(..len).enumerate() { + buf[i] = val; + } + Ok(len) + // unimplemented!(); + } + fn read_to_end(&mut self, buf: &mut Vec) -> io::Result { + // io::stdin().read_to_end(buf) + unimplemented!(); + } + fn read_to_string(&mut self, buf: &mut String) -> io::Result { + // io::stdin().read_to_string(buf) + unimplemented!(); + } + fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { + // io::stdin().read_exact(buf) + unimplemented!(); + } +} +impl Seek for Stdin { + fn seek(&mut self, _pos: io::SeekFrom) -> io::Result { + Err(io::Error::new(io::ErrorKind::Other, "can not seek stdin")) + } +} +impl Write for Stdin { + fn write(&mut self, _buf: &[u8]) -> io::Result { + Err(io::Error::new( + io::ErrorKind::Other, + "can not write to stdin", + )) + } + fn flush(&mut self) -> io::Result<()> { + Err(io::Error::new( + io::ErrorKind::Other, + "can not write to stdin", + )) + } + fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> { + Err(io::Error::new( + io::ErrorKind::Other, + "can not write to stdin", + )) + } + fn write_fmt(&mut self, _fmt: ::std::fmt::Arguments) -> io::Result<()> { + Err(io::Error::new( + io::ErrorKind::Other, + "can not write to stdin", + )) + } +} + +impl VirtualFile for Stdin { + fn last_accessed(&self) -> u64 { + 0 + } + fn last_modified(&self) -> u64 { + 0 + } + fn created_time(&self) -> u64 { + 0 + } + fn size(&self) -> u64 { + 0 + } + fn set_len(&mut self, _new_size: u64) -> Result<(), FsError> { + debug!("Calling VirtualFile::set_len on stdin; this is probably a bug"); + Err(FsError::PermissionDenied) + } + + fn unlink(&mut self) -> Result<(), FsError> { + Ok(()) + } + + fn bytes_available(&self) -> Result { + unimplemented!(); + } + + #[cfg(unix)] + fn get_raw_fd(&self) -> Option { + // use std::os::unix::io::AsRawFd; + // Some(io::stdin().as_raw_fd()) + unimplemented!(); + } + + #[cfg(not(unix))] + fn get_raw_fd(&self) -> Option { + unimplemented!( + "Stdin::get_raw_fd in VirtualFile is not implemented for non-Unix-like targets yet" + ); + } +} diff --git a/lib/vfs/src/vfs_fs.rs b/lib/vfs/src/vfs_fs.rs new file mode 100644 index 00000000000..4dd02d9db59 --- /dev/null +++ b/lib/vfs/src/vfs_fs.rs @@ -0,0 +1,189 @@ +use crate::*; +use serde::{Deserialize, Serialize}; +use std::io::{Read, Seek, Write}; +use std::path::Path; +use std::sync::Arc; + +pub use crate::host_fs::{Stderr, Stdin, Stdout}; + +#[derive(Clone)] +pub struct VfsFileSystem { + inner: Arc, +} + +impl FileSystem for VfsFileSystem { + fn read_dir(&self, _path: &Path) -> Result { + todo!() + } + fn create_dir(&self, path: &Path) -> Result<(), FsError> { + self.inner + .create_dir(path.to_str().unwrap()) + .map_err(Into::into) + } + fn remove_dir(&self, path: &Path) -> Result<(), FsError> { + self.inner + .remove_dir(path.to_str().unwrap()) + .map_err(Into::into) + } + fn rename(&self, from: &Path, to: &Path) -> Result<(), FsError> { + self.inner + .move_file(from.to_str().unwrap(), to.to_str().unwrap()) + .map_err(Into::into) + } + + fn remove_file(&self, path: &Path) -> Result<(), FsError> { + self.inner + .remove_file(path.to_str().unwrap()) + .map_err(Into::into) + } + fn new_open_options(&self) -> OpenOptions { + OpenOptions::new(Box::new(VfsFileOpener(self.clone()))) + } +} + + +#[derive(Clone)] +pub struct VfsFileOpener(VfsFileSystem); + +impl FileOpener for VfsFileOpener { + fn open( + &mut self, + path: &Path, + conf: &OpenOptionsConfig, + ) -> Result, FsError> { + // TODO: handle create implying write, etc. + if conf.create() || conf.create_new() { + let result = self.0.create_file(path.to_str().unwrap())?; + return Ok(Box::new(VfsOpenFile::Write(result))); + } else if conf.write() || conf.append() { + let result = self.0.append_file(path.to_str().unwrap())?; + return Ok(Box::new(VfsOpenFile::Write(result))); + } else { + let result = self.0.open_file(path.to_str().unwrap())?; + return Ok(Box::new(VfsOpenFile::SeekAndRead(result))); + } + } +} + +pub enum VfsOpenFile { + Write(Box), + SeekAndRead(Box), +} + +impl std::fmt::Debug for VfsOpenFile { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + match self { + Self::Write(_) => f.debug_struct("Write").finish(), + Self::SeekAndRead(_) => f.debug_struct("SeekAndRead").finish(), + } + } +} + +impl Read for VfsOpenFile { + fn read(&mut self, buf: &mut [u8]) -> io::Result { + match self { + Self::Write(_) => todo!(), + Self::SeekAndRead(sar) => sar.read(buf), + } + } + fn read_to_end(&mut self, buf: &mut Vec) -> io::Result { + match self { + Self::Write(_) => todo!(), + Self::SeekAndRead(sar) => sar.read_to_end(buf), + } + } + fn read_to_string(&mut self, buf: &mut String) -> io::Result { + match self { + Self::Write(_) => todo!(), + Self::SeekAndRead(sar) => sar.read_to_string(buf), + } + } + fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { + match self { + Self::Write(_) => todo!(), + Self::SeekAndRead(sar) => sar.read_exact(buf), + } + } +} +impl Seek for VfsOpenFile { + fn seek(&mut self, pos: io::SeekFrom) -> io::Result { + match self { + Self::Write(_) => todo!(), + Self::SeekAndRead(sar) => sar.seek(pos), + } + } +} +impl Write for VfsOpenFile { + fn write(&mut self, buf: &[u8]) -> io::Result { + match self { + Self::Write(w) => w.write(buf), + Self::SeekAndRead(_) => todo!(), + } + } + fn flush(&mut self) -> io::Result<()> { + match self { + Self::Write(w) => w.flush(), + Self::SeekAndRead(_) => todo!(), + } + } + fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { + match self { + Self::Write(w) => w.write_all(buf), + Self::SeekAndRead(_) => todo!(), + } + } + fn write_fmt(&mut self, fmt: ::std::fmt::Arguments) -> io::Result<()> { + match self { + Self::Write(w) => w.write_fmt(fmt), + Self::SeekAndRead(_) => todo!(), + } + } +} + +#[typetag::serde] +impl VirtualFile for VfsOpenFile { + fn last_accessed(&self) -> u64 { + // this data does not exist in vfs + 0 + } + + fn last_modified(&self) -> u64 { + // this data does not exist in vfs + 0 + } + + fn created_time(&self) -> u64 { + // this data does not exist in vfs + 0 + } + + fn size(&self) -> u64 { + todo!("vfs can do this, but it's difficult and requires the overall FS abstraction") + } + + fn set_len(&mut self, new_size: u64) -> Result<(), FsError> { + todo!("vfs can't do this!") + } + + fn unlink(&mut self) -> Result<(), FsError> { + // no-op, in vfs this isn't done here + Ok(()) + } + fn sync_to_disk(&self) -> Result<(), FsError> { + // no-op, in vfs this isn't done here + Ok(()) + } + + fn rename_file(&self, _new_name: &std::path::Path) -> Result<(), FsError> { + // no-op, in vfs this isn't done here + Ok(()) + } + + fn bytes_available(&self) -> Result { + todo!("unclear if vfs can do this") + } + + fn get_raw_fd(&self) -> Option { + None + } +} diff --git a/lib/wasi-experimental-io-devices/Cargo.toml b/lib/wasi-experimental-io-devices/Cargo.toml index bbd6c249d59..a82bd03df95 100644 --- a/lib/wasi-experimental-io-devices/Cargo.toml +++ b/lib/wasi-experimental-io-devices/Cargo.toml @@ -14,7 +14,7 @@ edition = "2018" maintenance = { status = "experimental" } [dependencies] -wasmer-wasi = { version = "2.0.0", path = "../wasi" } +wasmer-wasi = { version = "2.0.0", path = "../wasi", default-features=false } tracing = "0.1" minifb = "0.19" ref_thread_local = "0.1" diff --git a/lib/wasi-experimental-io-devices/src/lib.rs b/lib/wasi-experimental-io-devices/src/lib.rs index 8c78aff0795..18e8949291a 100644 --- a/lib/wasi-experimental-io-devices/src/lib.rs +++ b/lib/wasi-experimental-io-devices/src/lib.rs @@ -4,7 +4,7 @@ use std::convert::TryInto; use std::io::{Read, Seek, SeekFrom, Write}; use tracing::debug; use wasmer_wasi::types::*; -use wasmer_wasi::{Fd, WasiFile, WasiFs, WasiFsError, ALL_RIGHTS, VIRTUAL_ROOT_FD}; +use wasmer_wasi::{Fd, VirtualFile, WasiFs, WasiFsError, ALL_RIGHTS, VIRTUAL_ROOT_FD}; use minifb::{Key, KeyRepeat, MouseButton, Scale, Window, WindowOptions}; @@ -404,7 +404,7 @@ impl Write for FrameBuffer { } #[typetag::serde] -impl WasiFile for FrameBuffer { +impl VirtualFile for FrameBuffer { fn last_accessed(&self) -> u64 { 0 } diff --git a/lib/wasi/Cargo.toml b/lib/wasi/Cargo.toml index be2dac2c867..47a6843f569 100644 --- a/lib/wasi/Cargo.toml +++ b/lib/wasi/Cargo.toml @@ -9,23 +9,51 @@ repository = "https://github.com/wasmerio/wasmer" license = "MIT" readme = "README.md" edition = "2018" +# resolver = "2" + +[lib] +crate-type = ["cdylib", "rlib"] [dependencies] -bincode = "1" thiserror = "1" generational-arena = { version = "0.2", features = ["serde"] } -libc = { version = "^0.2", default-features = false } +# libc = { version = "^0.2", default-features = false, optional = true } tracing = { version = "0.1" } -getrandom = "0.2" +getrandom = { version = "0.2" } typetag = "0.1" serde = { version = "1.0", features = ["derive"] } wasmer-wasi-types = { path = "../wasi-types", version = "2.0.0" } -wasmer = { path = "../api", version = "2.0.0", default-features = false, features = ["sys"] } +wasmer = { path = "../api", version = "2.0.0", default-features = false } +wasmer-vfs = { path = "../vfs", version = "2.0.0", default-features = false, features = ["mem_fs"] } [target.'cfg(windows)'.dependencies] winapi = "0.3" +[target.'cfg(unix)'.dependencies] +libc = { version = "^0.2", default-features = false } + [features] +# default = ["logging", "host_fs", "wasmer"] default = ["logging"] logging = ["tracing/log"] -disable-all-logging = ["tracing/release_max_level_off", "tracing/max_level_off"] \ No newline at end of file +disable-all-logging = [ + "tracing/release_max_level_off", + "tracing/max_level_off" +] +host_fs = ["wasmer-vfs/host_fs"] +mem_fs = ["wasmer-vfs/mem_fs"] +js = [ + "getrandom/js", + "mem_fs", + "wasmer/js", +] +test-js = [ + "js", + "wasmer/js-default", + "wasmer/wat" +] + +[dev-dependencies] +wasm-bindgen = "0.2" +wasm-bindgen-test = "0.3.0" +tracing-wasm = { version = "0.2" } diff --git a/lib/wasi/src/lib.rs b/lib/wasi/src/lib.rs index 181f485b982..db01acf3e9e 100644 --- a/lib/wasi/src/lib.rs +++ b/lib/wasi/src/lib.rs @@ -22,11 +22,12 @@ mod utils; use crate::syscalls::*; pub use crate::state::{ - Fd, Pipe, Stderr, Stdin, Stdout, WasiFile, WasiFs, WasiFsError, WasiState, WasiStateBuilder, - WasiStateCreationError, ALL_RIGHTS, VIRTUAL_ROOT_FD, + Fd, Pipe, Stderr, Stdin, Stdout, WasiFs, WasiState, WasiStateBuilder, WasiStateCreationError, + ALL_RIGHTS, VIRTUAL_ROOT_FD, }; pub use crate::syscalls::types; pub use crate::utils::{get_wasi_version, get_wasi_versions, is_wasi_module, WasiVersion}; +pub use wasmer_vfs::{FsError, VirtualFile}; use thiserror::Error; use wasmer::{ @@ -242,3 +243,63 @@ fn generate_import_object_snapshot1(store: &Store, env: WasiEnv) -> ImportObject } } } + +// use wasm_bindgen::prelude::*; + +// #[wasm_bindgen] +// #[no_mangle] +// pub fn example() -> String { +// use wasmer::*; + +// let store = Store::default(); +// let module = Module::new(&store, br#" +// (module +// ;; This is the example Hello World WAT from the documentation at +// ;; https://github.com/bytecodealliance/wasmtime/blob/main/docs/WASI-tutorial.md +// ;; +// ;; It has been adapted to send CGI headers. +// (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32))) +// (memory 1) +// (export "memory" (memory 0)) + +// (data (i32.const 8) "content-type: text/html;charset=UTF-8\n\nOh hi world\n") + +// (func $main (export "_start") +// (i32.store (i32.const 0) (i32.const 8)) +// (i32.store (i32.const 4) (i32.const 51)) + +// (call $fd_write +// (i32.const 1) +// (i32.const 0) +// (i32.const 1) +// (i32.const 20) +// ) +// drop +// ) +// ) +// "#).unwrap(); + +// // Create the `WasiEnv`. +// // let stdout = Stdout::default(); +// let mut wasi_env = WasiState::new("command-name") +// .args(&["Gordon"]) +// // .stdout(Box::new(stdout)) +// .finalize() +// .unwrap(); + +// // Generate an `ImportObject`. +// let import_object = wasi_env.import_object(&module).unwrap(); + +// // Let's instantiate the module with the imports. +// let instance = Instance::new(&module, &import_object).unwrap(); + +// // Let's call the `_start` function, which is our `main` function in Rust. +// let start = instance.exports.get_function("_start").unwrap(); +// start.call(&[]).unwrap(); + +// let state = wasi_env.state(); +// let stdout = state.fs.stdout().unwrap().as_ref().unwrap(); +// let stdout = stdout.downcast_ref::().unwrap(); +// let stdout_as_str = std::str::from_utf8(&stdout.buf).unwrap().to_owned(); +// stdout_as_str +// } diff --git a/lib/wasi/src/macros.rs b/lib/wasi/src/macros.rs index 07f480ffe82..8cec82ae04b 100644 --- a/lib/wasi/src/macros.rs +++ b/lib/wasi/src/macros.rs @@ -31,6 +31,6 @@ macro_rules! wasi_try { /// corrupted. macro_rules! get_input_str { ($memory:expr, $data:expr, $len:expr) => {{ - wasi_try!($data.get_utf8_str($memory, $len), __WASI_EINVAL) + wasi_try!($data.get_utf8_string($memory, $len), __WASI_EINVAL) }}; } diff --git a/lib/wasi/src/ptr.rs b/lib/wasi/src/ptr.rs index 9be529ab619..7a472dcd451 100644 --- a/lib/wasi/src/ptr.rs +++ b/lib/wasi/src/ptr.rs @@ -82,7 +82,16 @@ impl WasmPtr { } #[inline(always)] - pub unsafe fn get_utf8_str(self, memory: &Memory, str_len: u32) -> Option<&str> { - self.0.get_utf8_str(memory, str_len) + pub unsafe fn get_utf8_str<'a>( + self, + memory: &'a Memory, + str_len: u32, + ) -> Option> { + self.0.get_utf8_str(memory, str_len).map(Into::into) + } + + #[inline(always)] + pub unsafe fn get_utf8_string(self, memory: &Memory, str_len: u32) -> Option { + self.0.get_utf8_string(memory, str_len) } } diff --git a/lib/wasi/src/state/builder.rs b/lib/wasi/src/state/builder.rs index e950decd110..bf85ef2f7b4 100644 --- a/lib/wasi/src/state/builder.rs +++ b/lib/wasi/src/state/builder.rs @@ -1,10 +1,11 @@ //! Builder system for configuring a [`WasiState`] and creating it. -use crate::state::{WasiFile, WasiFs, WasiFsError, WasiState}; +use crate::state::{WasiFs, WasiState}; use crate::syscalls::types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO}; use crate::WasiEnv; use std::path::{Path, PathBuf}; use thiserror::Error; +use wasmer_vfs::{FsError, VirtualFile}; /// Creates an empty [`WasiStateBuilder`]. /// @@ -37,15 +38,18 @@ pub struct WasiStateBuilder { args: Vec>, envs: Vec<(Vec, Vec)>, preopens: Vec, + vfs_preopens: Vec, #[allow(clippy::type_complexity)] setup_fs_fn: Option Result<(), String> + Send>>, - stdout_override: Option>, - stderr_override: Option>, - stdin_override: Option>, + stdout_override: Option>, + stderr_override: Option>, + stdin_override: Option>, + fs_override: Option>, } impl std::fmt::Debug for WasiStateBuilder { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + // TODO: update this when stable f.debug_struct("WasiStateBuilder") .field("args", &self.args) .field("envs", &self.envs) @@ -76,7 +80,7 @@ pub enum WasiStateCreationError { #[error("wasi filesystem setup error: `{0}`")] WasiFsSetupError(String), #[error(transparent)] - WasiFsError(WasiFsError), + FsError(FsError), } fn validate_mapped_dir_alias(alias: &str) -> Result<(), WasiStateCreationError> { @@ -219,6 +223,18 @@ impl WasiStateBuilder { Ok(self) } + /// TODO: document this + pub fn preopen_vfs_dirs(&mut self, po_dirs: I) -> Result<&mut Self, WasiStateCreationError> + where + I: IntoIterator, + { + for po_dir in po_dirs { + self.vfs_preopens.push(po_dir); + } + + Ok(self) + } + /// Preopen a directory with a different name exposed to the WASI. pub fn map_dir( &mut self, @@ -260,7 +276,7 @@ impl WasiStateBuilder { /// Overwrite the default WASI `stdout`, if you want to hold on to the /// original `stdout` use [`WasiFs::swap_file`] after building. - pub fn stdout(&mut self, new_file: Box) -> &mut Self { + pub fn stdout(&mut self, new_file: Box) -> &mut Self { self.stdout_override = Some(new_file); self @@ -268,7 +284,7 @@ impl WasiStateBuilder { /// Overwrite the default WASI `stderr`, if you want to hold on to the /// original `stderr` use [`WasiFs::swap_file`] after building. - pub fn stderr(&mut self, new_file: Box) -> &mut Self { + pub fn stderr(&mut self, new_file: Box) -> &mut Self { self.stderr_override = Some(new_file); self @@ -276,7 +292,7 @@ impl WasiStateBuilder { /// Overwrite the default WASI `stdin`, if you want to hold on to the /// original `stdin` use [`WasiFs::swap_file`] after building. - pub fn stdin(&mut self, new_file: Box) -> &mut Self { + pub fn stdin(&mut self, new_file: Box) -> &mut Self { self.stdin_override = Some(new_file); self @@ -293,6 +309,13 @@ impl WasiStateBuilder { self } + /// TODO: document this + pub fn set_fs(&mut self, fs: Box) -> &mut Self { + self.fs_override = Some(fs); + + self + } + /// Consumes the [`WasiStateBuilder`] and produces a [`WasiState`] /// /// Returns the error from `WasiFs::new` if there's an error @@ -359,29 +382,35 @@ impl WasiStateBuilder { } } - // self.preopens are checked in [`PreopenDirBuilder::build`] + // using `take` here is a bit of a code smell + let fs_backing = self + .fs_override + .take() + .unwrap_or_else(|| Self::default_fs_backing()); - let mut wasi_fs = WasiFs::new_with_preopen(&self.preopens) + // self.preopens are checked in [`PreopenDirBuilder::build`] + let mut wasi_fs = WasiFs::new_with_preopen(&self.preopens, &self.vfs_preopens, fs_backing) .map_err(WasiStateCreationError::WasiFsCreationError)?; // set up the file system, overriding base files and calling the setup function if let Some(stdin_override) = self.stdin_override.take() { wasi_fs .swap_file(__WASI_STDIN_FILENO, stdin_override) - .map_err(WasiStateCreationError::WasiFsError)?; + .map_err(WasiStateCreationError::FsError)?; } if let Some(stdout_override) = self.stdout_override.take() { wasi_fs .swap_file(__WASI_STDOUT_FILENO, stdout_override) - .map_err(WasiStateCreationError::WasiFsError)?; + .map_err(WasiStateCreationError::FsError)?; } if let Some(stderr_override) = self.stderr_override.take() { wasi_fs .swap_file(__WASI_STDERR_FILENO, stderr_override) - .map_err(WasiStateCreationError::WasiFsError)?; + .map_err(WasiStateCreationError::FsError)?; } if let Some(f) = &self.setup_fs_fn { f(&mut wasi_fs).map_err(WasiStateCreationError::WasiFsSetupError)?; } + Ok(WasiState { fs: wasi_fs, args: self.args.clone(), @@ -407,6 +436,16 @@ impl WasiStateBuilder { let state = self.build()?; Ok(WasiEnv::new(state)) } + + pub(crate) fn default_fs_backing() -> Box { + #[cfg(feature = "host_fs")] + return Box::new(wasmer_vfs::host_fs::HostFileSystem); + #[cfg(feature = "mem_fs")] + return Box::new(wasmer_vfs::mem_fs::MemFileSystem::default()); + + #[cfg(all(not(feature = "host_fs"), not(feature = "mem_fs")))] + panic!("No default enabled for filesystem, please enable either the `host_fs` or `mem_fs` feature in wasmer-wasi"); + } } /// Builder for preopened directories. diff --git a/lib/wasi/src/state/mod.rs b/lib/wasi/src/state/mod.rs index 4766b8006ab..e651b963db2 100644 --- a/lib/wasi/src/state/mod.rs +++ b/lib/wasi/src/state/mod.rs @@ -10,7 +10,7 @@ //! `generate_import_object` function. These are directories that the caller has given //! the WASI module permission to access. //! -//! You can implement `WasiFile` for your own types to get custom behavior and extend WASI, see the +//! You can implement `VirtualFile` for your own types to get custom behavior and extend WASI, see the //! [WASI plugin example](https://github.com/wasmerio/wasmer/blob/master/examples/plugin.rs). #![allow(clippy::cognitive_complexity, clippy::too_many_arguments)] @@ -31,10 +31,11 @@ use std::{ fs, io::Write, path::{Path, PathBuf}, - time::SystemTime, }; use tracing::debug; +use wasmer_vfs::{FileSystem, FsError, OpenOptions, VirtualFile}; + /// the fd value of the virtual root pub const VIRTUAL_ROOT_FD: __wasi_fd_t = 3; /// all the rights enabled @@ -58,7 +59,7 @@ const STDERR_DEFAULT_RIGHTS: __wasi_rights_t = STDOUT_DEFAULT_RIGHTS; pub const MAX_SYMLINKS: u32 = 128; /// A file that Wasi knows about that may or may not be open -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug)] pub struct InodeVal { pub stat: __wasi_filestat_t, pub is_preopened: bool, @@ -68,11 +69,11 @@ pub struct InodeVal { /// The core of the filesystem abstraction. Includes directories, /// files, and symlinks. -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug)] pub enum Kind { File { /// The open file, if it's open - handle: Option>, + handle: Option>, /// The path on the host system where the file is located /// This is deprecated and will be removed soon path: PathBuf, @@ -86,7 +87,7 @@ pub enum Kind { /// Parent directory parent: Option, /// The path on the host system where the directory is located - // TODO: wrap it like WasiFile + // TODO: wrap it like VirtualFile path: PathBuf, /// The entries of a directory are lazily filled. entries: HashMap, @@ -117,7 +118,7 @@ pub enum Kind { }, } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug)] pub struct Fd { pub rights: __wasi_rights_t, pub rights_inheriting: __wasi_rights_t, @@ -125,7 +126,7 @@ pub struct Fd { pub offset: u64, /// Flags that determine how the [`Fd`] can be used. /// - /// Used when reopening a [`HostFile`] during [`WasiState`] deserialization. + /// Used when reopening a [`VirtualFile`] during [`WasiState`] deserialization. pub open_flags: u16, pub inode: Inode, } @@ -150,7 +151,8 @@ impl Fd { pub const CREATE: u16 = 16; } -#[derive(Debug, Serialize, Deserialize)] +// #[derive(Debug)] +// TODO: Fix this and reenable the derives before merging /// Warning, modifying these fields directly may cause invariants to break and /// should be considered unsafe. These fields may be made private in a future release pub struct WasiFs { @@ -163,12 +165,61 @@ pub struct WasiFs { inode_counter: Cell, /// for fds still open after the file has been deleted pub orphan_fds: HashMap, + fs_backing: Box, } impl WasiFs { /// Created for the builder API. like `new` but with more information - pub(crate) fn new_with_preopen(preopens: &[PreopenedDir]) -> Result { - let (mut wasi_fs, root_inode) = Self::new_init()?; + pub(crate) fn new_with_preopen( + preopens: &[PreopenedDir], + vfs_preopens: &[String], + fs_backing: Box, + ) -> Result { + let (mut wasi_fs, root_inode) = Self::new_init(fs_backing)?; + + for preopen_name in vfs_preopens { + let kind = Kind::Dir { + parent: Some(root_inode), + path: PathBuf::from(preopen_name), + entries: Default::default(), + }; + let rights = __WASI_RIGHT_FD_ADVISE + | __WASI_RIGHT_FD_TELL + | __WASI_RIGHT_FD_SEEK + | __WASI_RIGHT_FD_READ + | __WASI_RIGHT_PATH_OPEN + | __WASI_RIGHT_FD_READDIR + | __WASI_RIGHT_PATH_READLINK + | __WASI_RIGHT_PATH_FILESTAT_GET + | __WASI_RIGHT_FD_FILESTAT_GET + | __WASI_RIGHT_PATH_LINK_SOURCE + | __WASI_RIGHT_PATH_RENAME_SOURCE + | __WASI_RIGHT_POLL_FD_READWRITE + | __WASI_RIGHT_SOCK_SHUTDOWN; + let inode = wasi_fs + .create_inode(kind, true, preopen_name.clone()) + .map_err(|e| { + format!( + "Failed to create inode for preopened dir: WASI error code: {}", + e + ) + })?; + let fd_flags = Fd::READ; + let fd = wasi_fs + .create_fd(rights, rights, 0, fd_flags, inode) + .map_err(|e| format!("Could not open fd for file {:?}: {}", preopen_name, e))?; + if let Kind::Root { entries } = &mut wasi_fs.inodes[root_inode].kind { + let existing_entry = entries.insert(preopen_name.clone(), inode); + if existing_entry.is_some() { + return Err(format!( + "Found duplicate entry for alias `{}`", + preopen_name + )); + } + assert!(existing_entry.is_none()) + } + wasi_fs.preopen_fds.push(fd); + } for PreopenedDir { path, @@ -294,7 +345,7 @@ impl WasiFs { /// Private helper function to init the filesystem, called in `new` and /// `new_with_preopen` - fn new_init() -> Result<(Self, Inode), String> { + fn new_init(fs_backing: Box) -> Result<(Self, Inode), String> { debug!("Initializing WASI filesystem"); let inodes = Arena::new(); let mut wasi_fs = Self { @@ -305,6 +356,7 @@ impl WasiFs { next_fd: Cell::new(3), inode_counter: Cell::new(1024), orphan_fds: HashMap::new(), + fs_backing, }; wasi_fs.create_stdin(); wasi_fs.create_stdout(); @@ -341,36 +393,36 @@ impl WasiFs { Ok((wasi_fs, root_inode)) } - /// Get the `WasiFile` object at stdout - pub fn stdout(&self) -> Result<&Option>, WasiFsError> { + /// Get the `VirtualFile` object at stdout + pub fn stdout(&self) -> Result<&Option>, FsError> { self.std_dev_get(__WASI_STDOUT_FILENO) } - /// Get the `WasiFile` object at stdout mutably - pub fn stdout_mut(&mut self) -> Result<&mut Option>, WasiFsError> { + /// Get the `VirtualFile` object at stdout mutably + pub fn stdout_mut(&mut self) -> Result<&mut Option>, FsError> { self.std_dev_get_mut(__WASI_STDOUT_FILENO) } - /// Get the `WasiFile` object at stderr - pub fn stderr(&self) -> Result<&Option>, WasiFsError> { + /// Get the `VirtualFile` object at stderr + pub fn stderr(&self) -> Result<&Option>, FsError> { self.std_dev_get(__WASI_STDERR_FILENO) } - /// Get the `WasiFile` object at stderr mutably - pub fn stderr_mut(&mut self) -> Result<&mut Option>, WasiFsError> { + /// Get the `VirtualFile` object at stderr mutably + pub fn stderr_mut(&mut self) -> Result<&mut Option>, FsError> { self.std_dev_get_mut(__WASI_STDERR_FILENO) } - /// Get the `WasiFile` object at stdin - pub fn stdin(&self) -> Result<&Option>, WasiFsError> { + /// Get the `VirtualFile` object at stdin + pub fn stdin(&self) -> Result<&Option>, FsError> { self.std_dev_get(__WASI_STDIN_FILENO) } - /// Get the `WasiFile` object at stdin mutably - pub fn stdin_mut(&mut self) -> Result<&mut Option>, WasiFsError> { + /// Get the `VirtualFile` object at stdin mutably + pub fn stdin_mut(&mut self) -> Result<&mut Option>, FsError> { self.std_dev_get_mut(__WASI_STDIN_FILENO) } /// Internal helper function to get a standard device handle. /// Expects one of `__WASI_STDIN_FILENO`, `__WASI_STDOUT_FILENO`, `__WASI_STDERR_FILENO`. - fn std_dev_get(&self, fd: __wasi_fd_t) -> Result<&Option>, WasiFsError> { + fn std_dev_get(&self, fd: __wasi_fd_t) -> Result<&Option>, FsError> { if let Some(fd) = self.fd_map.get(&fd) { if let Kind::File { ref handle, .. } = self.inodes[fd.inode].kind { Ok(handle) @@ -380,7 +432,7 @@ impl WasiFs { } } else { // this should only trigger if we made a mistake in this crate - Err(WasiFsError::NoDevice) + Err(FsError::NoDevice) } } /// Internal helper function to mutably get a standard device handle. @@ -388,7 +440,7 @@ impl WasiFs { fn std_dev_get_mut( &mut self, fd: __wasi_fd_t, - ) -> Result<&mut Option>, WasiFsError> { + ) -> Result<&mut Option>, FsError> { if let Some(fd) = self.fd_map.get_mut(&fd) { if let Kind::File { ref mut handle, .. } = self.inodes[fd.inode].kind { Ok(handle) @@ -398,7 +450,7 @@ impl WasiFs { } } else { // this should only trigger if we made a mistake in this crate - Err(WasiFsError::NoDevice) + Err(FsError::NoDevice) } } @@ -426,8 +478,8 @@ impl WasiFs { rights: __wasi_rights_t, rights_inheriting: __wasi_rights_t, flags: __wasi_fdflags_t, - ) -> Result<__wasi_fd_t, WasiFsError> { - let base_fd = self.get_fd(base).map_err(WasiFsError::from_wasi_err)?; + ) -> Result<__wasi_fd_t, FsError> { + let base_fd = self.get_fd(base).map_err(fs_error_from_wasi_err)?; // TODO: check permissions here? probably not, but this should be // an explicit choice, so justify it in a comment when we remove this one let mut cur_inode = base_fd.inode; @@ -440,7 +492,7 @@ impl WasiFs { Kind::Dir { ref entries, .. } | Kind::Root { ref entries } => { if let Some(_entry) = entries.get(&segment_name) { // TODO: this should be fixed - return Err(WasiFsError::AlreadyExists); + return Err(FsError::AlreadyExists); } let kind = Kind::Dir { @@ -464,7 +516,7 @@ impl WasiFs { cur_inode = inode; } - _ => return Err(WasiFsError::BaseNotDirectory), + _ => return Err(FsError::BaseNotDirectory), } } @@ -476,7 +528,7 @@ impl WasiFs { Fd::READ | Fd::WRITE, cur_inode, ) - .map_err(WasiFsError::from_wasi_err) + .map_err(fs_error_from_wasi_err) } /// Opens a user-supplied file in the directory specified with the @@ -486,14 +538,14 @@ impl WasiFs { pub fn open_file_at( &mut self, base: __wasi_fd_t, - file: Box, + file: Box, open_flags: u16, name: String, rights: __wasi_rights_t, rights_inheriting: __wasi_rights_t, flags: __wasi_fdflags_t, - ) -> Result<__wasi_fd_t, WasiFsError> { - let base_fd = self.get_fd(base).map_err(WasiFsError::from_wasi_err)?; + ) -> Result<__wasi_fd_t, FsError> { + let base_fd = self.get_fd(base).map_err(fs_error_from_wasi_err)?; // TODO: check permissions here? probably not, but this should be // an explicit choice, so justify it in a comment when we remove this one let base_inode = base_fd.inode; @@ -502,7 +554,7 @@ impl WasiFs { Kind::Dir { ref entries, .. } | Kind::Root { ref entries } => { if let Some(_entry) = entries.get(&name) { // TODO: eventually change the logic here to allow overwrites - return Err(WasiFsError::AlreadyExists); + return Err(FsError::AlreadyExists); } let kind = Kind::File { @@ -513,7 +565,7 @@ impl WasiFs { let inode = self .create_inode(kind, false, name.clone()) - .map_err(|_| WasiFsError::IOError)?; + .map_err(|_| FsError::IOError)?; // reborrow to insert match &mut self.inodes[base_inode].kind { Kind::Dir { @@ -526,9 +578,9 @@ impl WasiFs { } self.create_fd(rights, rights_inheriting, flags, open_flags, inode) - .map_err(WasiFsError::from_wasi_err) + .map_err(fs_error_from_wasi_err) } - _ => Err(WasiFsError::BaseNotDirectory), + _ => Err(FsError::BaseNotDirectory), } } @@ -539,8 +591,8 @@ impl WasiFs { pub fn swap_file( &mut self, fd: __wasi_fd_t, - file: Box, - ) -> Result>, WasiFsError> { + file: Box, + ) -> Result>, FsError> { let mut ret = Some(file); match fd { __WASI_STDIN_FILENO => { @@ -553,14 +605,14 @@ impl WasiFs { std::mem::swap(self.stderr_mut()?, &mut ret); } _ => { - let base_fd = self.get_fd(fd).map_err(WasiFsError::from_wasi_err)?; + let base_fd = self.get_fd(fd).map_err(fs_error_from_wasi_err)?; let base_inode = base_fd.inode; match &mut self.inodes[base_inode].kind { Kind::File { ref mut handle, .. } => { std::mem::swap(handle, &mut ret); } - _ => return Err(WasiFsError::NotAFile), + _ => return Err(FsError::NotAFile), } } } @@ -657,7 +709,11 @@ impl WasiFs { cd.push(component); cd }; - let metadata = file.symlink_metadata().ok().ok_or(__WASI_EINVAL)?; + let metadata = self + .fs_backing + .symlink_metadata(&file) + .ok() + .ok_or(__WASI_EINVAL)?; let file_type = metadata.file_type(); // we want to insert newly opened dirs and files, but not transient symlinks // TODO: explain why (think about this deeply when well rested) @@ -699,7 +755,7 @@ impl WasiFs { } else { #[cfg(unix)] { - use std::os::unix::fs::FileTypeExt; + //use std::os::unix::fs::FileTypeExt; let file_type: __wasi_filetype_t = if file_type.is_char_device() { __WASI_FILETYPE_CHARACTER_DEVICE @@ -1060,13 +1116,13 @@ impl WasiFs { __WASI_STDIN_FILENO => (), __WASI_STDOUT_FILENO => self .stdout_mut() - .map_err(WasiFsError::into_wasi_err)? + .map_err(fs_error_into_wasi_err)? .as_mut() .and_then(|f| f.flush().ok()) .ok_or(__WASI_EIO)?, __WASI_STDERR_FILENO => self .stderr_mut() - .map_err(WasiFsError::into_wasi_err)? + .map_err(fs_error_into_wasi_err)? .as_mut() .and_then(|f| f.flush().ok()) .ok_or(__WASI_EIO)?, @@ -1193,7 +1249,7 @@ impl WasiFs { fn create_stdout(&mut self) { self.create_std_dev_inner( - Box::new(Stdout), + Box::new(Stdout::default()), "stdout", __WASI_STDOUT_FILENO, STDOUT_DEFAULT_RIGHTS, @@ -1202,7 +1258,7 @@ impl WasiFs { } fn create_stdin(&mut self) { self.create_std_dev_inner( - Box::new(Stdin), + Box::new(Stdin::default()), "stdin", __WASI_STDIN_FILENO, STDIN_DEFAULT_RIGHTS, @@ -1211,7 +1267,7 @@ impl WasiFs { } fn create_stderr(&mut self) { self.create_std_dev_inner( - Box::new(Stderr), + Box::new(Stderr::default()), "stderr", __WASI_STDERR_FILENO, STDERR_DEFAULT_RIGHTS, @@ -1221,7 +1277,7 @@ impl WasiFs { fn create_std_dev_inner( &mut self, - handle: Box, + handle: Box, name: &'static str, raw_fd: __wasi_fd_t, rights: __wasi_rights_t, @@ -1271,9 +1327,9 @@ impl WasiFs { ..__wasi_filestat_t::default() }) } - None => path.metadata().ok()?, + None => self.fs_backing.metadata(path).ok()?, }, - Kind::Dir { path, .. } => path.metadata().ok()?, + Kind::Dir { path, .. } => self.fs_backing.metadata(path).ok()?, Kind::Symlink { base_po_dir, path_to_symlink, @@ -1283,7 +1339,7 @@ impl WasiFs { let base_po_inode_v = &self.inodes[*base_po_inode]; match &base_po_inode_v.kind { Kind::Root { .. } => { - path_to_symlink.clone().symlink_metadata().ok()? + self.fs_backing.symlink_metadata(path_to_symlink).ok()? } Kind::Dir { path, .. } => { let mut real_path = path.clone(); @@ -1294,7 +1350,7 @@ impl WasiFs { // TODO: adjust size of symlink, too // for all paths adjusted think about this real_path.push(path_to_symlink); - real_path.symlink_metadata().ok()? + self.fs_backing.symlink_metadata(&real_path).ok()? } // if this triggers, there's a bug in the symlink code _ => unreachable!("Symlink pointing to something that's not a directory as its base preopened directory"), @@ -1303,26 +1359,20 @@ impl WasiFs { _ => return None, }; Some(__wasi_filestat_t { - st_filetype: host_file_type_to_wasi_file_type(md.file_type()), + st_filetype: virtual_file_type_to_wasi_file_type(md.file_type()), st_size: md.len(), - st_atim: md - .accessed() - .ok()? - .duration_since(SystemTime::UNIX_EPOCH) - .ok()? - .as_nanos() as u64, - st_mtim: md - .modified() - .ok()? - .duration_since(SystemTime::UNIX_EPOCH) - .ok()? - .as_nanos() as u64, - st_ctim: md - .created() - .ok() - .and_then(|ct| ct.duration_since(SystemTime::UNIX_EPOCH).ok()) - .map(|ct| ct.as_nanos() as u64) - .unwrap_or(0), + st_atim: md.accessed(), /*.ok()? + .duration_since(SystemTime::UNIX_EPOCH) + .ok()? + .as_nanos() as u64*/ + st_mtim: md.modified(), /*.ok()? + .duration_since(SystemTime::UNIX_EPOCH) + .ok()? + .as_nanos() as u64*/ + st_ctim: md.created(), /*.ok() + .and_then(|ct| ct.duration_since(SystemTime::UNIX_EPOCH).ok()) + .map(|ct| ct.as_nanos() as u64) + .unwrap_or(0)*/ ..__wasi_filestat_t::default() }) } @@ -1383,6 +1433,55 @@ impl WasiFs { } } +// Implementations of direct to FS calls so that we can easily change their implementation +impl WasiState { + pub(crate) fn fs_read_dir>( + &self, + path: P, + ) -> Result { + self.fs + .fs_backing + .read_dir(path.as_ref()) + .map_err(fs_error_into_wasi_err) + } + + pub(crate) fn fs_create_dir>(&self, path: P) -> Result<(), __wasi_errno_t> { + self.fs + .fs_backing + .create_dir(path.as_ref()) + .map_err(fs_error_into_wasi_err) + } + + pub(crate) fn fs_remove_dir>(&self, path: P) -> Result<(), __wasi_errno_t> { + self.fs + .fs_backing + .remove_dir(path.as_ref()) + .map_err(fs_error_into_wasi_err) + } + + pub(crate) fn fs_rename, Q: AsRef>( + &self, + from: P, + to: Q, + ) -> Result<(), __wasi_errno_t> { + self.fs + .fs_backing + .rename(from.as_ref(), to.as_ref()) + .map_err(fs_error_into_wasi_err) + } + + pub(crate) fn fs_remove_file>(&self, path: P) -> Result<(), __wasi_errno_t> { + self.fs + .fs_backing + .remove_file(path.as_ref()) + .map_err(fs_error_into_wasi_err) + } + + pub(crate) fn fs_new_open_options(&self) -> OpenOptions { + self.fs.fs_backing.new_open_options() + } +} + /// Top level data type containing all* the state with which WASI can /// interact. /// @@ -1411,13 +1510,20 @@ impl WasiFs { /// # Ok(()) /// # } /// ``` -#[derive(Debug, Serialize, Deserialize)] +//#[derive(Debug, Serialize, Deserialize)] pub struct WasiState { pub fs: WasiFs, pub args: Vec>, pub envs: Vec>, } +impl std::fmt::Debug for WasiState { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + // TODO: reimpl Debug either here or on fs_backing to auto-derive it + f.write_str("struct WasiState") + } +} + impl WasiState { /// Create a [`WasiStateBuilder`] to construct a validated instance of /// [`WasiState`]. @@ -1428,15 +1534,19 @@ impl WasiState { /// Turn the WasiState into bytes pub fn freeze(&self) -> Option> { - bincode::serialize(self).ok() + todo!("temporarily disabled") + //bincode::serialize(self).ok() } /// Get a WasiState from bytes pub fn unfreeze(bytes: &[u8]) -> Option { - bincode::deserialize(bytes).ok() + todo!("temporarily disabled") + //bincode::deserialize(bytes).ok() } } +// TODO: remove this +#[allow(dead_code)] pub fn host_file_type_to_wasi_file_type(file_type: fs::FileType) -> __wasi_filetype_t { // TODO: handle other file types if file_type.is_dir() { @@ -1449,3 +1559,15 @@ pub fn host_file_type_to_wasi_file_type(file_type: fs::FileType) -> __wasi_filet __WASI_FILETYPE_UNKNOWN } } +pub fn virtual_file_type_to_wasi_file_type(file_type: wasmer_vfs::FileType) -> __wasi_filetype_t { + // TODO: handle other file types + if file_type.is_dir() { + __WASI_FILETYPE_DIRECTORY + } else if file_type.is_file() { + __WASI_FILETYPE_REGULAR_FILE + } else if file_type.is_symlink() { + __WASI_FILETYPE_SYMBOLIC_LINK + } else { + __WASI_FILETYPE_UNKNOWN + } +} diff --git a/lib/wasi/src/state/types.rs b/lib/wasi/src/state/types.rs index 8f6b2377893..781ebae0c07 100644 --- a/lib/wasi/src/state/types.rs +++ b/lib/wasi/src/state/types.rs @@ -1,249 +1,70 @@ /// types for use in the WASI filesystem use crate::syscalls::types::*; -use serde::{de, Deserialize, Serialize}; -use std::any::Any; +use serde::{Deserialize, Serialize}; #[cfg(unix)] use std::convert::TryInto; -use std::fmt; use std::{ collections::VecDeque, - fs, io::{self, Read, Seek, Write}, - path::PathBuf, - time::SystemTime, }; -use thiserror::Error; -use tracing::debug; -/// Error type for external users -#[derive(Error, Copy, Clone, Debug, PartialEq, Eq)] -#[allow(dead_code)] -// dead code beacuse this is for external use -pub enum WasiFsError { - /// The fd given as a base was not a directory so the operation was not possible - #[error("fd not a directory")] - BaseNotDirectory, - /// Expected a file but found not a file - #[error("fd not a file")] - NotAFile, - /// The fd given was not usable - #[error("invalid fd")] - InvalidFd, - /// File exists - #[error("file exists")] - AlreadyExists, - /// Something failed when doing IO. These errors can generally not be handled. - /// It may work if tried again. - #[error("io error")] - IOError, - /// The address was in use - #[error("address is in use")] - AddressInUse, - /// The address could not be found - #[error("address could not be found")] - AddressNotAvailable, - /// A pipe was closed - #[error("broken pipe (was closed)")] - BrokenPipe, - /// The connection was aborted - #[error("connection aborted")] - ConnectionAborted, - /// The connection request was refused - #[error("connection refused")] - ConnectionRefused, - /// The connection was reset - #[error("connection reset")] - ConnectionReset, - /// The operation was interrupted before it could finish - #[error("operation interrupted")] - Interrupted, - /// Invalid internal data, if the argument data is invalid, use `InvalidInput` - #[error("invalid internal data")] - InvalidData, - /// The provided data is invalid - #[error("invalid input")] - InvalidInput, - /// Could not perform the operation because there was not an open connection - #[error("connection is not open")] - NotConnected, - /// The requested file or directory could not be found - #[error("entity not found")] - EntityNotFound, - /// The requested device couldn't be accessed - #[error("can't access device")] - NoDevice, - /// Caller was not allowed to perform this operation - #[error("permission denied")] - PermissionDenied, - /// The operation did not complete within the given amount of time - #[error("time out")] - TimedOut, - /// Found EOF when EOF was not expected - #[error("unexpected eof")] - UnexpectedEof, - /// Operation would block, this error lets the caller know that they can try again - #[error("blocking operation. try again")] - WouldBlock, - /// A call to write returned 0 - #[error("write returned 0")] - WriteZero, - /// A WASI error without an external name. If you encounter this it means - /// that there's probably a bug on our side (maybe as simple as forgetting to wrap - /// this error, but perhaps something broke) - #[error("unknown error: {0}")] - UnknownError(__wasi_errno_t), -} - -impl WasiFsError { - pub fn from_wasi_err(err: __wasi_errno_t) -> WasiFsError { - match err { - __WASI_EBADF => WasiFsError::InvalidFd, - __WASI_EEXIST => WasiFsError::AlreadyExists, - __WASI_EIO => WasiFsError::IOError, - __WASI_EADDRINUSE => WasiFsError::AddressInUse, - __WASI_EADDRNOTAVAIL => WasiFsError::AddressNotAvailable, - __WASI_EPIPE => WasiFsError::BrokenPipe, - __WASI_ECONNABORTED => WasiFsError::ConnectionAborted, - __WASI_ECONNREFUSED => WasiFsError::ConnectionRefused, - __WASI_ECONNRESET => WasiFsError::ConnectionReset, - __WASI_EINTR => WasiFsError::Interrupted, - __WASI_EINVAL => WasiFsError::InvalidInput, - __WASI_ENOTCONN => WasiFsError::NotConnected, - __WASI_ENODEV => WasiFsError::NoDevice, - __WASI_ENOENT => WasiFsError::EntityNotFound, - __WASI_EPERM => WasiFsError::PermissionDenied, - __WASI_ETIMEDOUT => WasiFsError::TimedOut, - __WASI_EPROTO => WasiFsError::UnexpectedEof, - __WASI_EAGAIN => WasiFsError::WouldBlock, - __WASI_ENOSPC => WasiFsError::WriteZero, - _ => WasiFsError::UnknownError(err), - } - } - - pub fn into_wasi_err(self) -> __wasi_errno_t { - match self { - WasiFsError::AlreadyExists => __WASI_EEXIST, - WasiFsError::AddressInUse => __WASI_EADDRINUSE, - WasiFsError::AddressNotAvailable => __WASI_EADDRNOTAVAIL, - WasiFsError::BaseNotDirectory => __WASI_ENOTDIR, - WasiFsError::BrokenPipe => __WASI_EPIPE, - WasiFsError::ConnectionAborted => __WASI_ECONNABORTED, - WasiFsError::ConnectionRefused => __WASI_ECONNREFUSED, - WasiFsError::ConnectionReset => __WASI_ECONNRESET, - WasiFsError::Interrupted => __WASI_EINTR, - WasiFsError::InvalidData => __WASI_EIO, - WasiFsError::InvalidFd => __WASI_EBADF, - WasiFsError::InvalidInput => __WASI_EINVAL, - WasiFsError::IOError => __WASI_EIO, - WasiFsError::NoDevice => __WASI_ENODEV, - WasiFsError::NotAFile => __WASI_EINVAL, - WasiFsError::NotConnected => __WASI_ENOTCONN, - WasiFsError::EntityNotFound => __WASI_ENOENT, - WasiFsError::PermissionDenied => __WASI_EPERM, - WasiFsError::TimedOut => __WASI_ETIMEDOUT, - WasiFsError::UnexpectedEof => __WASI_EPROTO, - WasiFsError::WouldBlock => __WASI_EAGAIN, - WasiFsError::WriteZero => __WASI_ENOSPC, - WasiFsError::UnknownError(ec) => ec, - } - } -} - -/// This trait relies on your file closing when it goes out of scope via `Drop` -#[typetag::serde(tag = "type")] -pub trait WasiFile: fmt::Debug + Send + Write + Read + Seek + 'static + Upcastable { - /// the last time the file was accessed in nanoseconds as a UNIX timestamp - fn last_accessed(&self) -> __wasi_timestamp_t; - - /// the last time the file was modified in nanoseconds as a UNIX timestamp - fn last_modified(&self) -> __wasi_timestamp_t; - - /// the time at which the file was created in nanoseconds as a UNIX timestamp - fn created_time(&self) -> __wasi_timestamp_t; - - /// set the last time the file was accessed in nanoseconds as a UNIX timestamp - fn set_last_accessed(&self, _last_accessed: __wasi_timestamp_t) { - debug!("{:?} did nothing in WasiFile::set_last_accessed due to using the default implementation", self); - } - - /// set the last time the file was modified in nanoseconds as a UNIX timestamp - fn set_last_modified(&self, _last_modified: __wasi_timestamp_t) { - debug!("{:?} did nothing in WasiFile::set_last_modified due to using the default implementation", self); - } - - /// set the time at which the file was created in nanoseconds as a UNIX timestamp - fn set_created_time(&self, _created_time: __wasi_timestamp_t) { - debug!( - "{:?} did nothing in WasiFile::set_created_time to using the default implementation", - self - ); - } - - /// the size of the file in bytes - fn size(&self) -> u64; - - /// Change the size of the file, if the `new_size` is greater than the current size - /// the extra bytes will be allocated and zeroed - fn set_len(&mut self, _new_size: __wasi_filesize_t) -> Result<(), WasiFsError>; - - /// Request deletion of the file - fn unlink(&mut self) -> Result<(), WasiFsError>; - - /// Store file contents and metadata to disk - /// Default implementation returns `Ok(())`. You should implement this method if you care - /// about flushing your cache to permanent storage - fn sync_to_disk(&self) -> Result<(), WasiFsError> { - Ok(()) - } - - /// Moves the file to a new location - /// NOTE: the signature of this function will change before stabilization - // TODO: stablizie this in 0.7.0 or 0.8.0 by removing default impl - fn rename_file(&self, _new_name: &std::path::Path) -> Result<(), WasiFsError> { - panic!("Default implementation for now as this method is unstable; this default implementation or this entire method may be removed in a future release."); - } - - /// Returns the number of bytes available. This function must not block - fn bytes_available(&self) -> Result; - - /// Used for polling. Default returns `None` because this method cannot be implemented for most types - /// Returns the underlying host fd - fn get_raw_fd(&self) -> Option { - None - } -} - -// Implementation of `Upcastable` taken from https://users.rust-lang.org/t/why-does-downcasting-not-work-for-subtraits/33286/7 . -/// Trait needed to get downcasting from `WasiFile` to work. -pub trait Upcastable { - fn upcast_any_ref(&'_ self) -> &'_ dyn Any; - fn upcast_any_mut(&'_ mut self) -> &'_ mut dyn Any; - fn upcast_any_box(self: Box) -> Box; -} - -impl Upcastable for T { - #[inline] - fn upcast_any_ref(&'_ self) -> &'_ dyn Any { - self - } - #[inline] - fn upcast_any_mut(&'_ mut self) -> &'_ mut dyn Any { - self - } - #[inline] - fn upcast_any_box(self: Box) -> Box { - self - } -} - -impl dyn WasiFile + 'static { - #[inline] - pub fn downcast_ref(&'_ self) -> Option<&'_ T> { - self.upcast_any_ref().downcast_ref::() - } - #[inline] - pub fn downcast_mut(&'_ mut self) -> Option<&'_ mut T> { - self.upcast_any_mut().downcast_mut::() +#[cfg(feature = "host_fs")] +pub use wasmer_vfs::host_fs::{Stderr, Stdin, Stdout}; +#[cfg(feature = "mem_fs")] +pub use wasmer_vfs::mem_fs::{Stderr, Stdin, Stdout}; + +use wasmer_vfs::{FsError, VirtualFile}; + +pub fn fs_error_from_wasi_err(err: __wasi_errno_t) -> FsError { + match err { + __WASI_EBADF => FsError::InvalidFd, + __WASI_EEXIST => FsError::AlreadyExists, + __WASI_EIO => FsError::IOError, + __WASI_EADDRINUSE => FsError::AddressInUse, + __WASI_EADDRNOTAVAIL => FsError::AddressNotAvailable, + __WASI_EPIPE => FsError::BrokenPipe, + __WASI_ECONNABORTED => FsError::ConnectionAborted, + __WASI_ECONNREFUSED => FsError::ConnectionRefused, + __WASI_ECONNRESET => FsError::ConnectionReset, + __WASI_EINTR => FsError::Interrupted, + __WASI_EINVAL => FsError::InvalidInput, + __WASI_ENOTCONN => FsError::NotConnected, + __WASI_ENODEV => FsError::NoDevice, + __WASI_ENOENT => FsError::EntityNotFound, + __WASI_EPERM => FsError::PermissionDenied, + __WASI_ETIMEDOUT => FsError::TimedOut, + __WASI_EPROTO => FsError::UnexpectedEof, + __WASI_EAGAIN => FsError::WouldBlock, + __WASI_ENOSPC => FsError::WriteZero, + _ => FsError::UnknownError, + } +} + +pub fn fs_error_into_wasi_err(fs_error: FsError) -> __wasi_errno_t { + match fs_error { + FsError::AlreadyExists => __WASI_EEXIST, + FsError::AddressInUse => __WASI_EADDRINUSE, + FsError::AddressNotAvailable => __WASI_EADDRNOTAVAIL, + FsError::BaseNotDirectory => __WASI_ENOTDIR, + FsError::BrokenPipe => __WASI_EPIPE, + FsError::ConnectionAborted => __WASI_ECONNABORTED, + FsError::ConnectionRefused => __WASI_ECONNREFUSED, + FsError::ConnectionReset => __WASI_ECONNRESET, + FsError::Interrupted => __WASI_EINTR, + FsError::InvalidData => __WASI_EIO, + FsError::InvalidFd => __WASI_EBADF, + FsError::InvalidInput => __WASI_EINVAL, + FsError::IOError => __WASI_EIO, + FsError::NoDevice => __WASI_ENODEV, + FsError::NotAFile => __WASI_EINVAL, + FsError::NotConnected => __WASI_ENOTCONN, + FsError::EntityNotFound => __WASI_ENOENT, + FsError::PermissionDenied => __WASI_EPERM, + FsError::TimedOut => __WASI_ETIMEDOUT, + FsError::UnexpectedEof => __WASI_EPROTO, + FsError::WouldBlock => __WASI_EAGAIN, + FsError::WriteZero => __WASI_ENOSPC, + FsError::UnknownError => __WASI_EIO, } } @@ -363,12 +184,12 @@ impl PollEventBuilder { #[cfg(unix)] pub(crate) fn poll( - selfs: &[&dyn WasiFile], + selfs: &[&dyn VirtualFile], events: &[PollEventSet], seen_events: &mut [PollEventSet], -) -> Result { +) -> Result { if !(selfs.len() == events.len() && events.len() == seen_events.len()) { - return Err(WasiFsError::InvalidInput); + return Err(FsError::InvalidInput); } let mut fds = selfs .iter() @@ -384,7 +205,7 @@ pub(crate) fn poll( if result < 0 { // TODO: check errno and return value - return Err(WasiFsError::IOError); + return Err(FsError::IOError); } // convert result and write back values for (i, fd) in fds.into_iter().enumerate() { @@ -396,581 +217,15 @@ pub(crate) fn poll( #[cfg(not(unix))] pub(crate) fn poll( - _selfs: &[&dyn WasiFile], + _selfs: &[&dyn VirtualFile], _events: &[PollEventSet], _seen_events: &mut [PollEventSet], -) -> Result<(), WasiFsError> { - unimplemented!("HostFile::poll in WasiFile is not implemented for non-Unix-like targets yet"); +) -> Result<(), FsError> { + unimplemented!("VirtualFile::poll is not implemented for non-Unix-like targets yet"); } pub trait WasiPath {} -/// A thin wrapper around `std::fs::File` -#[derive(Debug, Serialize)] -pub struct HostFile { - #[serde(skip_serializing)] - pub inner: fs::File, - pub host_path: PathBuf, - flags: u16, -} - -impl<'de> Deserialize<'de> for HostFile { - fn deserialize(deserializer: D) -> Result - where - D: serde::Deserializer<'de>, - { - #[derive(Deserialize)] - #[serde(field_identifier, rename_all = "snake_case")] - enum Field { - HostPath, - Flags, - } - - struct HostFileVisitor; - - impl<'de> de::Visitor<'de> for HostFileVisitor { - type Value = HostFile; - - fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result { - formatter.write_str("struct HostFile") - } - - fn visit_seq(self, mut seq: V) -> Result - where - V: de::SeqAccess<'de>, - { - let host_path = seq - .next_element()? - .ok_or_else(|| de::Error::invalid_length(0, &self))?; - let flags = seq - .next_element()? - .ok_or_else(|| de::Error::invalid_length(1, &self))?; - let inner = std::fs::OpenOptions::new() - .read(flags & HostFile::READ != 0) - .write(flags & HostFile::WRITE != 0) - .append(flags & HostFile::APPEND != 0) - .open(&host_path) - .map_err(|_| de::Error::custom("Could not open file on this system"))?; - Ok(HostFile { - inner, - host_path, - flags, - }) - } - - fn visit_map(self, mut map: V) -> Result - where - V: de::MapAccess<'de>, - { - let mut host_path = None; - let mut flags = None; - while let Some(key) = map.next_key()? { - match key { - Field::HostPath => { - if host_path.is_some() { - return Err(de::Error::duplicate_field("host_path")); - } - host_path = Some(map.next_value()?); - } - Field::Flags => { - if flags.is_some() { - return Err(de::Error::duplicate_field("flags")); - } - flags = Some(map.next_value()?); - } - } - } - let host_path = host_path.ok_or_else(|| de::Error::missing_field("host_path"))?; - let flags = flags.ok_or_else(|| de::Error::missing_field("flags"))?; - let inner = std::fs::OpenOptions::new() - .read(flags & HostFile::READ != 0) - .write(flags & HostFile::WRITE != 0) - .append(flags & HostFile::APPEND != 0) - .open(&host_path) - .map_err(|_| de::Error::custom("Could not open file on this system"))?; - Ok(HostFile { - inner, - host_path, - flags, - }) - } - } - - const FIELDS: &[&str] = &["host_path", "flags"]; - deserializer.deserialize_struct("HostFile", FIELDS, HostFileVisitor) - } -} - -impl HostFile { - const READ: u16 = 1; - const WRITE: u16 = 2; - const APPEND: u16 = 4; - - /// creates a new host file from a `std::fs::File` and a path - pub fn new(file: fs::File, host_path: PathBuf, read: bool, write: bool, append: bool) -> Self { - let mut flags = 0; - if read { - flags |= Self::READ; - } - if write { - flags |= Self::WRITE; - } - if append { - flags |= Self::APPEND; - } - Self { - inner: file, - host_path, - flags, - } - } - - pub fn metadata(&self) -> fs::Metadata { - self.inner.metadata().unwrap() - } -} - -impl Read for HostFile { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - self.inner.read(buf) - } - fn read_to_end(&mut self, buf: &mut Vec) -> io::Result { - self.inner.read_to_end(buf) - } - fn read_to_string(&mut self, buf: &mut String) -> io::Result { - self.inner.read_to_string(buf) - } - fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { - self.inner.read_exact(buf) - } -} -impl Seek for HostFile { - fn seek(&mut self, pos: io::SeekFrom) -> io::Result { - self.inner.seek(pos) - } -} -impl Write for HostFile { - fn write(&mut self, buf: &[u8]) -> io::Result { - self.inner.write(buf) - } - fn flush(&mut self) -> io::Result<()> { - self.inner.flush() - } - fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { - self.inner.write_all(buf) - } - fn write_fmt(&mut self, fmt: ::std::fmt::Arguments) -> io::Result<()> { - self.inner.write_fmt(fmt) - } -} - -#[typetag::serde] -impl WasiFile for HostFile { - fn last_accessed(&self) -> u64 { - self.metadata() - .accessed() - .ok() - .and_then(|ct| ct.duration_since(SystemTime::UNIX_EPOCH).ok()) - .map(|ct| ct.as_nanos() as u64) - .unwrap_or(0) - } - - fn set_last_accessed(&self, _last_accessed: __wasi_timestamp_t) { - // TODO: figure out how to do this - } - - fn last_modified(&self) -> u64 { - self.metadata() - .modified() - .ok() - .and_then(|ct| ct.duration_since(SystemTime::UNIX_EPOCH).ok()) - .map(|ct| ct.as_nanos() as u64) - .unwrap_or(0) - } - - fn set_last_modified(&self, _last_modified: __wasi_timestamp_t) { - // TODO: figure out how to do this - } - - fn created_time(&self) -> u64 { - self.metadata() - .created() - .ok() - .and_then(|ct| ct.duration_since(SystemTime::UNIX_EPOCH).ok()) - .map(|ct| ct.as_nanos() as u64) - .unwrap_or(0) - } - - fn set_created_time(&self, _created_time: __wasi_timestamp_t) { - // TODO: figure out how to do this - } - - fn size(&self) -> u64 { - self.metadata().len() - } - - fn set_len(&mut self, new_size: __wasi_filesize_t) -> Result<(), WasiFsError> { - fs::File::set_len(&self.inner, new_size).map_err(Into::into) - } - - fn unlink(&mut self) -> Result<(), WasiFsError> { - std::fs::remove_file(&self.host_path).map_err(Into::into) - } - fn sync_to_disk(&self) -> Result<(), WasiFsError> { - self.inner.sync_all().map_err(Into::into) - } - - fn rename_file(&self, new_name: &std::path::Path) -> Result<(), WasiFsError> { - std::fs::rename(&self.host_path, new_name).map_err(Into::into) - } - - fn bytes_available(&self) -> Result { - // unwrap is safe because of get_raw_fd implementation - let host_fd = self.get_raw_fd().unwrap(); - - host_file_bytes_available(host_fd) - } - - #[cfg(unix)] - fn get_raw_fd(&self) -> Option { - use std::os::unix::io::AsRawFd; - Some(self.inner.as_raw_fd()) - } - #[cfg(not(unix))] - fn get_raw_fd(&self) -> Option { - unimplemented!( - "HostFile::get_raw_fd in WasiFile is not implemented for non-Unix-like targets yet" - ); - } -} - -impl From for WasiFsError { - fn from(io_error: io::Error) -> Self { - match io_error.kind() { - io::ErrorKind::AddrInUse => WasiFsError::AddressInUse, - io::ErrorKind::AddrNotAvailable => WasiFsError::AddressNotAvailable, - io::ErrorKind::AlreadyExists => WasiFsError::AlreadyExists, - io::ErrorKind::BrokenPipe => WasiFsError::BrokenPipe, - io::ErrorKind::ConnectionAborted => WasiFsError::ConnectionAborted, - io::ErrorKind::ConnectionRefused => WasiFsError::ConnectionRefused, - io::ErrorKind::ConnectionReset => WasiFsError::ConnectionReset, - io::ErrorKind::Interrupted => WasiFsError::Interrupted, - io::ErrorKind::InvalidData => WasiFsError::InvalidData, - io::ErrorKind::InvalidInput => WasiFsError::InvalidInput, - io::ErrorKind::NotConnected => WasiFsError::NotConnected, - io::ErrorKind::NotFound => WasiFsError::EntityNotFound, - io::ErrorKind::PermissionDenied => WasiFsError::PermissionDenied, - io::ErrorKind::TimedOut => WasiFsError::TimedOut, - io::ErrorKind::UnexpectedEof => WasiFsError::UnexpectedEof, - io::ErrorKind::WouldBlock => WasiFsError::WouldBlock, - io::ErrorKind::WriteZero => WasiFsError::WriteZero, - io::ErrorKind::Other => WasiFsError::IOError, - // if the following triggers, a new error type was added to this non-exhaustive enum - _ => WasiFsError::UnknownError(__WASI_EIO), - } - } -} - -#[cfg(unix)] -fn host_file_bytes_available(host_fd: i32) -> Result { - let mut bytes_found = 0 as libc::c_int; - let result = unsafe { libc::ioctl(host_fd, libc::FIONREAD, &mut bytes_found) }; - - match result { - // success - 0 => Ok(bytes_found.try_into().unwrap_or(0)), - libc::EBADF => Err(WasiFsError::InvalidFd), - libc::EFAULT => Err(WasiFsError::InvalidData), - libc::EINVAL => Err(WasiFsError::InvalidInput), - _ => Err(WasiFsError::IOError), - } -} - -#[cfg(not(unix))] -fn host_file_bytes_available(_raw_fd: i32) -> Result { - unimplemented!("host_file_bytes_available not yet implemented for non-Unix-like targets. This probably means the program tried to use wasi::poll_oneoff") -} - -/// A wrapper type around Stdout that implements `WasiFile` and -/// `Serialize` + `Deserialize`. -#[derive(Debug, Serialize, Deserialize)] -pub struct Stdout; -impl Read for Stdout { - fn read(&mut self, _buf: &mut [u8]) -> io::Result { - Err(io::Error::new( - io::ErrorKind::Other, - "can not read from stdout", - )) - } - fn read_to_end(&mut self, _buf: &mut Vec) -> io::Result { - Err(io::Error::new( - io::ErrorKind::Other, - "can not read from stdout", - )) - } - fn read_to_string(&mut self, _buf: &mut String) -> io::Result { - Err(io::Error::new( - io::ErrorKind::Other, - "can not read from stdout", - )) - } - fn read_exact(&mut self, _buf: &mut [u8]) -> io::Result<()> { - Err(io::Error::new( - io::ErrorKind::Other, - "can not read from stdout", - )) - } -} -impl Seek for Stdout { - fn seek(&mut self, _pos: io::SeekFrom) -> io::Result { - Err(io::Error::new(io::ErrorKind::Other, "can not seek stdout")) - } -} -impl Write for Stdout { - fn write(&mut self, buf: &[u8]) -> io::Result { - io::stdout().write(buf) - } - fn flush(&mut self) -> io::Result<()> { - io::stdout().flush() - } - fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { - io::stdout().write_all(buf) - } - fn write_fmt(&mut self, fmt: ::std::fmt::Arguments) -> io::Result<()> { - io::stdout().write_fmt(fmt) - } -} - -#[typetag::serde] -impl WasiFile for Stdout { - fn last_accessed(&self) -> u64 { - 0 - } - fn last_modified(&self) -> u64 { - 0 - } - fn created_time(&self) -> u64 { - 0 - } - fn size(&self) -> u64 { - 0 - } - fn set_len(&mut self, _new_size: __wasi_filesize_t) -> Result<(), WasiFsError> { - debug!("Calling WasiFile::set_len on stdout; this is probably a bug"); - Err(WasiFsError::PermissionDenied) - } - fn unlink(&mut self) -> Result<(), WasiFsError> { - Ok(()) - } - - fn bytes_available(&self) -> Result { - // unwrap is safe because of get_raw_fd implementation - let host_fd = self.get_raw_fd().unwrap(); - - host_file_bytes_available(host_fd) - } - - #[cfg(unix)] - fn get_raw_fd(&self) -> Option { - use std::os::unix::io::AsRawFd; - Some(io::stdout().as_raw_fd()) - } - - #[cfg(not(unix))] - fn get_raw_fd(&self) -> Option { - unimplemented!( - "Stdout::get_raw_fd in WasiFile is not implemented for non-Unix-like targets yet" - ); - } -} - -/// A wrapper type around Stderr that implements `WasiFile` and -/// `Serialize` + `Deserialize`. -#[derive(Debug, Serialize, Deserialize)] -pub struct Stderr; -impl Read for Stderr { - fn read(&mut self, _buf: &mut [u8]) -> io::Result { - Err(io::Error::new( - io::ErrorKind::Other, - "can not read from stderr", - )) - } - fn read_to_end(&mut self, _buf: &mut Vec) -> io::Result { - Err(io::Error::new( - io::ErrorKind::Other, - "can not read from stderr", - )) - } - fn read_to_string(&mut self, _buf: &mut String) -> io::Result { - Err(io::Error::new( - io::ErrorKind::Other, - "can not read from stderr", - )) - } - fn read_exact(&mut self, _buf: &mut [u8]) -> io::Result<()> { - Err(io::Error::new( - io::ErrorKind::Other, - "can not read from stderr", - )) - } -} -impl Seek for Stderr { - fn seek(&mut self, _pos: io::SeekFrom) -> io::Result { - Err(io::Error::new(io::ErrorKind::Other, "can not seek stderr")) - } -} -impl Write for Stderr { - fn write(&mut self, buf: &[u8]) -> io::Result { - io::stderr().write(buf) - } - fn flush(&mut self) -> io::Result<()> { - io::stderr().flush() - } - fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { - io::stderr().write_all(buf) - } - fn write_fmt(&mut self, fmt: ::std::fmt::Arguments) -> io::Result<()> { - io::stderr().write_fmt(fmt) - } -} - -#[typetag::serde] -impl WasiFile for Stderr { - fn last_accessed(&self) -> u64 { - 0 - } - fn last_modified(&self) -> u64 { - 0 - } - fn created_time(&self) -> u64 { - 0 - } - fn size(&self) -> u64 { - 0 - } - fn set_len(&mut self, _new_size: __wasi_filesize_t) -> Result<(), WasiFsError> { - debug!("Calling WasiFile::set_len on stderr; this is probably a bug"); - Err(WasiFsError::PermissionDenied) - } - fn unlink(&mut self) -> Result<(), WasiFsError> { - Ok(()) - } - - fn bytes_available(&self) -> Result { - // unwrap is safe because of get_raw_fd implementation - let host_fd = self.get_raw_fd().unwrap(); - - host_file_bytes_available(host_fd) - } - - #[cfg(unix)] - fn get_raw_fd(&self) -> Option { - use std::os::unix::io::AsRawFd; - Some(io::stderr().as_raw_fd()) - } - - #[cfg(not(unix))] - fn get_raw_fd(&self) -> Option { - unimplemented!( - "Stderr::get_raw_fd in WasiFile is not implemented for non-Unix-like targets yet" - ); - } -} - -/// A wrapper type around Stdin that implements `WasiFile` and -/// `Serialize` + `Deserialize`. -#[derive(Debug, Serialize, Deserialize)] -pub struct Stdin; -impl Read for Stdin { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - io::stdin().read(buf) - } - fn read_to_end(&mut self, buf: &mut Vec) -> io::Result { - io::stdin().read_to_end(buf) - } - fn read_to_string(&mut self, buf: &mut String) -> io::Result { - io::stdin().read_to_string(buf) - } - fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { - io::stdin().read_exact(buf) - } -} -impl Seek for Stdin { - fn seek(&mut self, _pos: io::SeekFrom) -> io::Result { - Err(io::Error::new(io::ErrorKind::Other, "can not seek stdin")) - } -} -impl Write for Stdin { - fn write(&mut self, _buf: &[u8]) -> io::Result { - Err(io::Error::new( - io::ErrorKind::Other, - "can not write to stdin", - )) - } - fn flush(&mut self) -> io::Result<()> { - Err(io::Error::new( - io::ErrorKind::Other, - "can not write to stdin", - )) - } - fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> { - Err(io::Error::new( - io::ErrorKind::Other, - "can not write to stdin", - )) - } - fn write_fmt(&mut self, _fmt: ::std::fmt::Arguments) -> io::Result<()> { - Err(io::Error::new( - io::ErrorKind::Other, - "can not write to stdin", - )) - } -} - -#[typetag::serde] -impl WasiFile for Stdin { - fn last_accessed(&self) -> u64 { - 0 - } - fn last_modified(&self) -> u64 { - 0 - } - fn created_time(&self) -> u64 { - 0 - } - fn size(&self) -> u64 { - 0 - } - fn set_len(&mut self, _new_size: __wasi_filesize_t) -> Result<(), WasiFsError> { - debug!("Calling WasiFile::set_len on stdin; this is probably a bug"); - Err(WasiFsError::PermissionDenied) - } - - fn unlink(&mut self) -> Result<(), WasiFsError> { - Ok(()) - } - - fn bytes_available(&self) -> Result { - // unwrap is safe because of get_raw_fd implementation - let host_fd = self.get_raw_fd().unwrap(); - - host_file_bytes_available(host_fd) - } - - #[cfg(unix)] - fn get_raw_fd(&self) -> Option { - use std::os::unix::io::AsRawFd; - Some(io::stdin().as_raw_fd()) - } - - #[cfg(not(unix))] - fn get_raw_fd(&self) -> Option { - unimplemented!( - "Stdin::get_raw_fd in WasiFile is not implemented for non-Unix-like targets yet" - ); - } -} - /// For piping stdio. Stores all output / input in a byte-vector. #[derive(Debug, Default, Serialize, Deserialize)] pub struct Pipe { @@ -1012,8 +267,8 @@ impl Seek for Pipe { } } -#[typetag::serde] -impl WasiFile for Pipe { +// #[typetag::serde] +impl VirtualFile for Pipe { fn last_accessed(&self) -> u64 { 0 } @@ -1026,14 +281,14 @@ impl WasiFile for Pipe { fn size(&self) -> u64 { self.buffer.len() as u64 } - fn set_len(&mut self, len: u64) -> Result<(), WasiFsError> { + fn set_len(&mut self, len: u64) -> Result<(), FsError> { self.buffer.resize(len as usize, 0); Ok(()) } - fn unlink(&mut self) -> Result<(), WasiFsError> { + fn unlink(&mut self) -> Result<(), FsError> { Ok(()) } - fn bytes_available(&self) -> Result { + fn bytes_available(&self) -> Result { Ok(self.buffer.len()) } } diff --git a/lib/wasi/src/syscalls/mod.rs b/lib/wasi/src/syscalls/mod.rs index e172ca5782e..fa36345bc21 100644 --- a/lib/wasi/src/syscalls/mod.rs +++ b/lib/wasi/src/syscalls/mod.rs @@ -11,6 +11,8 @@ pub mod types { target_os = "macos" ))] pub mod unix; +#[cfg(any(target_arch = "wasm32"))] +pub mod wasm32; #[cfg(any(target_os = "windows"))] pub mod windows; @@ -20,9 +22,9 @@ use self::types::*; use crate::{ ptr::{Array, WasmPtr}, state::{ - self, host_file_type_to_wasi_file_type, iterate_poll_events, poll, Fd, HostFile, Inode, - InodeVal, Kind, PollEvent, PollEventBuilder, WasiFile, WasiFsError, WasiState, - MAX_SYMLINKS, + self, fs_error_into_wasi_err, iterate_poll_events, poll, + virtual_file_type_to_wasi_file_type, Fd, Inode, InodeVal, Kind, PollEvent, + PollEventBuilder, WasiState, MAX_SYMLINKS, }, WasiEnv, WasiError, }; @@ -31,6 +33,7 @@ use std::convert::{Infallible, TryInto}; use std::io::{self, Read, Seek, Write}; use tracing::{debug, trace}; use wasmer::{Memory, RuntimeError, Value, WasmCell}; +use wasmer_vfs::{FsError, VirtualFile}; #[cfg(any( target_os = "freebsd", @@ -43,6 +46,9 @@ pub use unix::*; #[cfg(any(target_os = "windows"))] pub use windows::*; +#[cfg(any(target_arch = "wasm32"))] +pub use wasm32::*; + fn write_bytes_inner( mut write_loc: T, memory: &Memory, @@ -90,9 +96,10 @@ fn read_bytes( bytes_read += reader.read(&mut raw_bytes).map_err(|_| __WASI_EIO)? as u32; unsafe { memory - .view::() + .uint8view() .subarray( - iov_inner.buf as usize..=(iov_inner.buf as usize + iov_inner.buf_len as usize), + iov_inner.buf as u32, + iov_inner.buf as u32 + iov_inner.buf_len as u32, ) .copy_from(&raw_bytes); } @@ -363,7 +370,7 @@ pub fn fd_allocate( match &mut state.fs.inodes[inode].kind { Kind::File { handle, .. } => { if let Some(handle) = handle { - wasi_try!(handle.set_len(new_size).map_err(WasiFsError::into_wasi_err)); + wasi_try!(handle.set_len(new_size).map_err(fs_error_into_wasi_err)); } else { return __WASI_EBADF; } @@ -558,7 +565,7 @@ pub fn fd_filestat_set_size( match &mut state.fs.inodes[inode].kind { Kind::File { handle, .. } => { if let Some(handle) = handle { - wasi_try!(handle.set_len(st_size).map_err(WasiFsError::into_wasi_err)); + wasi_try!(handle.set_len(st_size).map_err(fs_error_into_wasi_err)); } else { return __WASI_EBADF; } @@ -615,12 +622,6 @@ pub fn fd_filestat_set_times( wasi_try!(get_current_time_in_nanos()) }; inode.stat.st_atim = time_to_set; - // TODO: set it for more than just files - if let Kind::File { handle, .. } = &mut inode.kind { - if let Some(handle) = handle { - handle.set_last_accessed(time_to_set); - } - } } if fst_flags & __WASI_FILESTAT_SET_MTIM != 0 || fst_flags & __WASI_FILESTAT_SET_MTIM_NOW != 0 { @@ -630,12 +631,6 @@ pub fn fd_filestat_set_times( wasi_try!(get_current_time_in_nanos()) }; inode.stat.st_mtim = time_to_set; - // TODO: set it for more than just files - if let Kind::File { handle, .. } = &mut inode.kind { - if let Some(handle) = handle { - handle.set_last_modified(time_to_set); - } - } } __WASI_ESUCCESS @@ -673,7 +668,7 @@ pub fn fd_pread( let bytes_read = match fd { __WASI_STDIN_FILENO => { if let Some(ref mut stdin) = - wasi_try!(state.fs.stdin_mut().map_err(WasiFsError::into_wasi_err)) + wasi_try!(state.fs.stdin_mut().map_err(fs_error_into_wasi_err)) { wasi_try!(read_bytes(stdin, memory, &iov_cells)) } else { @@ -822,7 +817,7 @@ pub fn fd_pwrite( __WASI_STDIN_FILENO => return __WASI_EINVAL, __WASI_STDOUT_FILENO => { if let Some(ref mut stdout) = - wasi_try!(state.fs.stdout_mut().map_err(WasiFsError::into_wasi_err)) + wasi_try!(state.fs.stdout_mut().map_err(fs_error_into_wasi_err)) { wasi_try!(write_bytes(stdout, memory, &iovs_arr_cell)) } else { @@ -831,7 +826,7 @@ pub fn fd_pwrite( } __WASI_STDERR_FILENO => { if let Some(ref mut stderr) = - wasi_try!(state.fs.stderr_mut().map_err(WasiFsError::into_wasi_err)) + wasi_try!(state.fs.stderr_mut().map_err(fs_error_into_wasi_err)) { wasi_try!(write_bytes(stderr, memory, &iovs_arr_cell)) } else { @@ -908,7 +903,7 @@ pub fn fd_read( let bytes_read = match fd { __WASI_STDIN_FILENO => { if let Some(ref mut stdin) = - wasi_try!(state.fs.stdin_mut().map_err(WasiFsError::into_wasi_err)) + wasi_try!(state.fs.stdin_mut().map_err(fs_error_into_wasi_err)) { wasi_try!(read_bytes(stdin, memory, &iovs_arr_cell)) } else { @@ -1000,14 +995,14 @@ pub fn fd_readdir( // we need to support multiple calls, // simple and obviously correct implementation for now: // maintain consistent order via lexacographic sorting - let fs_info = wasi_try!(wasi_try!(std::fs::read_dir(path).map_err(|_| __WASI_EIO)) + let fs_info = wasi_try!(wasi_try!(state.fs_read_dir(path)) .collect::, _>>() .map_err(|_| __WASI_EIO)); let mut entry_vec = wasi_try!(fs_info .into_iter() .map(|entry| Ok(( entry.file_name().to_string_lossy().to_string(), - host_file_type_to_wasi_file_type(entry.file_type().map_err(|_| __WASI_EIO)?), + virtual_file_type_to_wasi_file_type(entry.file_type().map_err(|_| __WASI_EIO)?), 0, // TODO: inode ))) .collect::, _>>()); @@ -1202,7 +1197,7 @@ pub fn fd_sync(env: &WasiEnv, fd: __wasi_fd_t) -> __wasi_errno_t { match &mut state.fs.inodes[inode].kind { Kind::File { handle, .. } => { if let Some(h) = handle { - wasi_try!(h.sync_to_disk().map_err(WasiFsError::into_wasi_err)); + wasi_try!(h.sync_to_disk().map_err(fs_error_into_wasi_err)); } else { return __WASI_EINVAL; } @@ -1279,7 +1274,7 @@ pub fn fd_write( __WASI_STDIN_FILENO => return __WASI_EINVAL, __WASI_STDOUT_FILENO => { if let Some(ref mut stdout) = - wasi_try!(state.fs.stdout_mut().map_err(WasiFsError::into_wasi_err)) + wasi_try!(state.fs.stdout_mut().map_err(fs_error_into_wasi_err)) { wasi_try!(write_bytes(stdout, memory, &iovs_arr_cell)) } else { @@ -1288,7 +1283,7 @@ pub fn fd_write( } __WASI_STDERR_FILENO => { if let Some(ref mut stderr) = - wasi_try!(state.fs.stderr_mut().map_err(WasiFsError::into_wasi_err)) + wasi_try!(state.fs.stderr_mut().map_err(fs_error_into_wasi_err)) { wasi_try!(write_bytes(stderr, memory, &iovs_arr_cell)) } else { @@ -1371,7 +1366,7 @@ pub fn path_create_directory( let path_string = unsafe { get_input_str!(memory, path, path_len) }; debug!("=> fd: {}, path: {}", fd, &path_string); - let path = std::path::PathBuf::from(path_string); + let path = std::path::PathBuf::from(&path_string); let path_vec = wasi_try!(path .components() .map(|comp| { @@ -1415,7 +1410,7 @@ pub fn path_create_directory( if adjusted_path.exists() && !adjusted_path.is_dir() { return __WASI_ENOTDIR; } else if !adjusted_path.exists() { - wasi_try!(std::fs::create_dir(&adjusted_path).ok(), __WASI_EIO); + wasi_try!(state.fs_create_dir(&adjusted_path)); } let kind = Kind::Dir { parent: Some(cur_dir_inode), @@ -1477,7 +1472,7 @@ pub fn path_filestat_get( let file_inode = wasi_try!(state.fs.get_inode_at_path( fd, - path_string, + &path_string, flags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0, )); let stat = if state.fs.inodes[file_inode].is_preopened { @@ -1541,7 +1536,7 @@ pub fn path_filestat_set_times( let file_inode = wasi_try!(state.fs.get_inode_at_path( fd, - path_string, + &path_string, flags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0, )); let stat = wasi_try!(state @@ -1558,12 +1553,6 @@ pub fn path_filestat_set_times( wasi_try!(get_current_time_in_nanos()) }; inode.stat.st_atim = time_to_set; - // TODO: set it for more than just files - if let Kind::File { handle, .. } = &mut inode.kind { - if let Some(handle) = handle { - handle.set_last_accessed(time_to_set); - } - } } if fst_flags & __WASI_FILESTAT_SET_MTIM != 0 || fst_flags & __WASI_FILESTAT_SET_MTIM_NOW != 0 { let time_to_set = if fst_flags & __WASI_FILESTAT_SET_MTIM != 0 { @@ -1572,12 +1561,6 @@ pub fn path_filestat_set_times( wasi_try!(get_current_time_in_nanos()) }; inode.stat.st_mtim = time_to_set; - // TODO: set it for more than just files - if let Kind::File { handle, .. } = &mut inode.kind { - if let Some(handle) = handle { - handle.set_last_modified(time_to_set); - } - } } __WASI_ESUCCESS @@ -1621,7 +1604,7 @@ pub fn path_link( let target_fd = wasi_try!(state.fs.get_fd(new_fd)); debug!( "=> source_fd: {}, source_path: {}, target_fd: {}, target_path: {}", - old_fd, old_path_str, new_fd, new_path_str + old_fd, &old_path_str, new_fd, new_path_str ); if !(has_rights(source_fd.rights, __WASI_RIGHT_PATH_LINK_SOURCE) @@ -1632,10 +1615,10 @@ pub fn path_link( let source_inode = wasi_try!(state.fs.get_inode_at_path( old_fd, - old_path_str, + &old_path_str, old_flags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0, )); - let target_path_arg = std::path::PathBuf::from(new_path_str); + let target_path_arg = std::path::PathBuf::from(&new_path_str); let (target_parent_inode, new_entry_name) = wasi_try!(state .fs @@ -1724,10 +1707,10 @@ pub fn path_open( debug!("=> fd: {}, path: {}", dirfd, &path_string); - let path_arg = std::path::PathBuf::from(path_string); + let path_arg = std::path::PathBuf::from(&path_string); let maybe_inode = state.fs.get_inode_at_path( dirfd, - path_string, + &path_string, dirflags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0, ); @@ -1736,6 +1719,7 @@ pub fn path_open( // COMMENTED OUT: WASI isn't giving appropriate rights here when opening // TODO: look into this; file a bug report if this is a bug let adjusted_rights = /*fs_rights_base &*/ working_dir_rights_inheriting; + let mut open_options = state.fs_new_open_options(); let inode = if let Ok(inode) = maybe_inode { // Happy path, we found the file we're trying to open match &mut state.fs.inodes[inode].kind { @@ -1756,7 +1740,6 @@ pub fn path_open( if o_flags & __WASI_O_EXCL != 0 && path.exists() { return __WASI_EEXIST; } - let mut open_options = std::fs::OpenOptions::new(); let write_permission = adjusted_rights & __WASI_RIGHT_FD_WRITE != 0; // append, truncate, and create all require the permission to write let (append_permission, truncate_permission, create_permission) = @@ -1786,13 +1769,9 @@ pub fn path_open( if o_flags & __WASI_O_TRUNC != 0 { open_flags |= Fd::TRUNCATE; } - *handle = Some(Box::new(HostFile::new( - wasi_try!(open_options.open(&path).map_err(|_| __WASI_EIO)), - path.to_path_buf(), - true, - adjusted_rights & __WASI_RIGHT_FD_WRITE != 0, - false, - ))); + *handle = Some(wasi_try!(open_options + .open(&path) + .map_err(fs_error_into_wasi_err))); } Kind::Buffer { .. } => unimplemented!("wasi::path_open for Buffer type files"), Kind::Dir { .. } | Kind::Root { .. } => { @@ -1839,7 +1818,6 @@ pub fn path_open( // once we got the data we need from the parent, we lookup the host file // todo: extra check that opening with write access is okay let handle = { - let mut open_options = std::fs::OpenOptions::new(); let open_options = open_options .read(true) .append(fs_flags & __WASI_FDFLAG_APPEND != 0) @@ -1849,16 +1827,12 @@ pub fn path_open( .create_new(true); open_flags |= Fd::READ | Fd::WRITE | Fd::CREATE | Fd::TRUNCATE; - Some(Box::new(HostFile::new( - wasi_try!(open_options.open(&new_file_host_path).map_err(|e| { + Some(wasi_try!(open_options.open(&new_file_host_path).map_err( + |e| { debug!("Error opening file {}", e); - __WASI_EIO - })), - new_file_host_path.clone(), - true, - true, - true, - )) as Box) + fs_error_into_wasi_err(e) + } + ))) }; let new_inode = { @@ -1937,7 +1911,7 @@ pub fn path_readlink( return __WASI_EACCES; } let path_str = unsafe { get_input_str!(memory, path, path_len) }; - let inode = wasi_try!(state.fs.get_inode_at_path(dir_fd, path_str, false)); + let inode = wasi_try!(state.fs.get_inode_at_path(dir_fd, &path_str, false)); if let Kind::Symlink { relative_path, .. } = &state.fs.inodes[inode].kind { let rel_path_str = relative_path.to_string_lossy(); @@ -1978,17 +1952,15 @@ pub fn path_remove_directory( let base_dir = wasi_try!(state.fs.fd_map.get(&fd), __WASI_EBADF); let path_str = unsafe { get_input_str!(memory, path, path_len) }; - let inode = wasi_try!(state.fs.get_inode_at_path(fd, path_str, false)); + let inode = wasi_try!(state.fs.get_inode_at_path(fd, &path_str, false)); let (parent_inode, childs_name) = wasi_try!(state .fs - .get_parent_inode_at_path(fd, std::path::Path::new(path_str), false)); + .get_parent_inode_at_path(fd, std::path::Path::new(&path_str), false)); let host_path_to_remove = match &state.fs.inodes[inode].kind { Kind::Dir { entries, path, .. } => { - if !entries.is_empty() - || wasi_try!(std::fs::read_dir(path).ok(), __WASI_EIO).count() != 0 - { + if !entries.is_empty() || wasi_try!(state.fs_read_dir(path)).count() != 0 { return __WASI_ENOTEMPTY; } path.clone() @@ -2011,7 +1983,7 @@ pub fn path_remove_directory( ), } - if std::fs::remove_dir(path_str).is_err() { + if state.fs_remove_dir(path_str).is_err() { // reinsert to prevent FS from being in bad state if let Kind::Dir { ref mut entries, .. @@ -2056,10 +2028,10 @@ pub fn path_rename( ); let (memory, mut state) = env.get_memory_and_wasi_state(0); let source_str = unsafe { get_input_str!(memory, old_path, old_path_len) }; - let source_path = std::path::Path::new(source_str); + let source_path = std::path::Path::new(&source_str); let target_str = unsafe { get_input_str!(memory, new_path, new_path_len) }; - let target_path = std::path::Path::new(target_str); - debug!("=> rename from {} to {}", source_str, target_str); + let target_path = std::path::Path::new(&target_str); + debug!("=> rename from {} to {}", &source_str, &target_str); { let source_fd = wasi_try!(state.fs.get_fd(old_fd)); @@ -2101,17 +2073,24 @@ pub fn path_rename( match &mut state.fs.inodes[source_entry].kind { Kind::File { - handle, - ref mut path, - .. + handle, ref path, .. } => { + // TODO: investigate why handle is not always there, it probably should be. + // My best guess is the fact that a handle means currently open and a path + // just means reference to host file on disk. But ideally those concepts + // could just be unified even if there's a `Box` which just + // implements the logic of "I'm not actually a file, I'll try to be as needed". let result = if let Some(h) = handle { h.rename_file(&host_adjusted_target_path) - .map_err(|e| e.into_wasi_err()) + .map_err(fs_error_into_wasi_err) } else { - let out = - std::fs::rename(&path, &host_adjusted_target_path).map_err(|_| __WASI_EIO); - *path = host_adjusted_target_path; + let path_clone = path.clone(); + let out = state.fs_rename(&path_clone, &host_adjusted_target_path); + if let Kind::File { ref mut path, .. } = &mut state.fs.inodes[source_entry].kind { + *path = host_adjusted_target_path; + } else { + unreachable!() + } out }; // if the above operation failed we have to revert the previous change and then fail @@ -2170,11 +2149,11 @@ pub fn path_symlink( } // get the depth of the parent + 1 (UNDER INVESTIGATION HMMMMMMMM THINK FISH ^ THINK FISH) - let old_path_path = std::path::Path::new(old_path_str); + let old_path_path = std::path::Path::new(&old_path_str); let (source_inode, _) = wasi_try!(state.fs.get_parent_inode_at_path(fd, old_path_path, true)); let depth = wasi_try!(state.fs.path_depth_from_fd(fd, source_inode)) - 1; - let new_path_path = std::path::Path::new(new_path_str); + let new_path_path = std::path::Path::new(&new_path_str); let (target_parent_inode, entry_name) = wasi_try!(state.fs.get_parent_inode_at_path(fd, new_path_path, true)); @@ -2191,7 +2170,7 @@ pub fn path_symlink( } } - let mut source_path = std::path::Path::new(old_path_str); + let mut source_path = std::path::Path::new(&old_path_str); let mut relative_path = std::path::PathBuf::new(); for _ in 0..depth { relative_path.push(".."); @@ -2247,11 +2226,11 @@ pub fn path_unlink_file( let path_str = unsafe { get_input_str!(memory, path, path_len) }; debug!("Requested file: {}", path_str); - let inode = wasi_try!(state.fs.get_inode_at_path(fd, path_str, false)); + let inode = wasi_try!(state.fs.get_inode_at_path(fd, &path_str, false)); let (parent_inode, childs_name) = wasi_try!(state .fs - .get_parent_inode_at_path(fd, std::path::Path::new(path_str), false)); + .get_parent_inode_at_path(fd, std::path::Path::new(&path_str), false)); let removed_inode = match &mut state.fs.inodes[parent_inode].kind { Kind::Dir { @@ -2274,12 +2253,13 @@ pub fn path_unlink_file( match &mut state.fs.inodes[removed_inode].kind { Kind::File { handle, path, .. } => { if let Some(h) = handle { - wasi_try!(h.unlink().map_err(WasiFsError::into_wasi_err)); + wasi_try!(h.unlink().map_err(fs_error_into_wasi_err)); } else { // File is closed // problem with the abstraction, we can't call unlink because there's no handle - // TODO: replace this code - wasi_try!(std::fs::remove_file(path).map_err(|_| __WASI_EIO)); + // drop mutable borrow on `path` + let path = path.clone(); + wasi_try!(state.fs_remove_file(path)); } } Kind::Dir { .. } | Kind::Root { .. } => return __WASI_EISDIR, @@ -2393,19 +2373,19 @@ pub fn poll_oneoff( }; if let Some(fd) = fd { - let wasi_file_ref: &dyn WasiFile = match fd { + let wasi_file_ref: &dyn VirtualFile = match fd { __WASI_STDERR_FILENO => wasi_try!( - wasi_try!(state.fs.stderr().map_err(WasiFsError::into_wasi_err)).as_ref(), + wasi_try!(state.fs.stderr().map_err(fs_error_into_wasi_err)).as_ref(), __WASI_EBADF ) .as_ref(), __WASI_STDIN_FILENO => wasi_try!( - wasi_try!(state.fs.stdin().map_err(WasiFsError::into_wasi_err)).as_ref(), + wasi_try!(state.fs.stdin().map_err(fs_error_into_wasi_err)).as_ref(), __WASI_EBADF ) .as_ref(), __WASI_STDOUT_FILENO => wasi_try!( - wasi_try!(state.fs.stdout().map_err(WasiFsError::into_wasi_err)).as_ref(), + wasi_try!(state.fs.stdout().map_err(fs_error_into_wasi_err)).as_ref(), __WASI_EBADF ) .as_ref(), @@ -2450,7 +2430,7 @@ pub fn poll_oneoff( in_events.as_slice(), seen_events.as_mut_slice() ) - .map_err(|e| e.into_wasi_err())); + .map_err(fs_error_into_wasi_err)); for (i, seen_event) in seen_events.into_iter().enumerate() { let mut flags = 0; @@ -2464,12 +2444,12 @@ pub fn poll_oneoff( PollEvent::PollInvalid => error = __WASI_EINVAL, PollEvent::PollIn => { bytes_available = - wasi_try!(fds[i].bytes_available().map_err(|e| e.into_wasi_err())); + wasi_try!(fds[i].bytes_available().map_err(fs_error_into_wasi_err)); error = __WASI_ESUCCESS; } PollEvent::PollOut => { bytes_available = - wasi_try!(fds[i].bytes_available().map_err(|e| e.into_wasi_err())); + wasi_try!(fds[i].bytes_available().map_err(fs_error_into_wasi_err)); error = __WASI_ESUCCESS; } } @@ -2512,10 +2492,15 @@ pub fn poll_oneoff( __WASI_ESUCCESS } +// pub fn proc_exit(env: &WasiEnv, code: __wasi_exitcode_t) -> Result<(), WasiError> { +// // panic!("Exit: {}", code); +// Err(WasiError::Exit(code)) +// // RuntimeError::raise(Box::new(WasiError::Exit(code))); +// } pub fn proc_exit(env: &WasiEnv, code: __wasi_exitcode_t) { - debug!("wasi::proc_exit, {}", code); - RuntimeError::raise(Box::new(WasiError::Exit(code))); - unreachable!(); + // panic!("Exit: {}", code); + // Err(WasiError::Exit(code)) + // RuntimeError::raise(Box::new(WasiError::Exit(code))); } pub fn proc_raise(env: &WasiEnv, sig: __wasi_signal_t) -> __wasi_errno_t { @@ -2539,8 +2524,8 @@ pub fn random_get(env: &WasiEnv, buf: u32, buf_len: u32) -> __wasi_errno_t { Ok(()) => { unsafe { memory - .view::() - .subarray(buf as usize..=(buf as usize + buf_len as usize)) + .uint8view() + .subarray(buf as u32, (buf as u32 + buf_len as u32)) .copy_from(&u8_buffer); } __WASI_ESUCCESS diff --git a/lib/wasi/src/syscalls/wasm32.rs b/lib/wasi/src/syscalls/wasm32.rs new file mode 100644 index 00000000000..4c512138a40 --- /dev/null +++ b/lib/wasi/src/syscalls/wasm32.rs @@ -0,0 +1,25 @@ +use crate::syscalls::types::*; +use std::mem; +use wasmer::WasmCell; + +pub fn platform_clock_res_get( + clock_id: __wasi_clockid_t, + resolution: WasmCell<__wasi_timestamp_t>, +) -> __wasi_errno_t { + let t_out = 1 * 1_000_000_000; + resolution.set(t_out as __wasi_timestamp_t); + + // TODO: map output of clock_getres to __wasi_errno_t + __WASI_ESUCCESS +} + +pub fn platform_clock_time_get( + clock_id: __wasi_clockid_t, + precision: __wasi_timestamp_t, + time: WasmCell<__wasi_timestamp_t>, +) -> __wasi_errno_t { + let t_out = 1 * 1_000_000_000; + time.set(t_out as __wasi_timestamp_t); + + __WASI_ESUCCESS +} diff --git a/lib/wasi/tests/envvar.rs b/lib/wasi/tests/envvar.rs new file mode 100644 index 00000000000..a76f23115b9 --- /dev/null +++ b/lib/wasi/tests/envvar.rs @@ -0,0 +1,28 @@ +// WASI: +// env: DOG=1 +// env: CAT=2 + +use std::env; + +fn get_env_var(var_name: &str) -> Result { + env::var(var_name) +} + +fn main() { + let mut env_vars = env::vars() + .map(|(key, value)| format!("{}={}", key, value)) + .collect::>(); + + env_vars.sort(); + + println!("Env vars:"); + for e in env_vars { + println!("{}", e); + } + + env::set_var("WASI_ENVVAR_TEST", "HELLO"); + + println!("DOG {:?}", get_env_var("DOG")); + println!("DOG_TYPE {:?}", get_env_var("DOG_TYPE")); + println!("SET VAR {:?}", env::var("WASI_ENVVAR_TEST")); +} diff --git a/lib/wasi/tests/envvar.wasm b/lib/wasi/tests/envvar.wasm new file mode 100755 index 0000000000000000000000000000000000000000..31a87aca698b6053d8fc11e491153280b6489465 GIT binary patch literal 1839059 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≀3Q2l7;%il0E^4AuZ`6eYqg;OhcYb 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