Virtual fs refactor

lib/c-api/src/wasm_c_api/wasi/mod.rs

@@ -19,7 +19,7 @@ use std::sync::Arc;
 #[cfg(feature = "webc_runner")]
 use wasmer_api::{AsStoreMut, Imports, Module};
 use wasmer_wasix::{
-    default_fs_backing, get_wasi_version,
+    get_wasi_version,
     runtime::task_manager::{tokio::TokioTaskManager, InlineWaker},
     virtual_fs::AsyncReadExt,
     virtual_fs::VirtualFile,
@@ -55,7 +55,7 @@ pub unsafe extern "C" fn wasi_config_new(
         inherit_stdout: true,
         inherit_stderr: true,
         inherit_stdin: true,
-        builder: WasiEnv::builder(prog_name).fs(default_fs_backing()),
+        builder: WasiEnv::builder(prog_name),
         runtime: Some(runtime),
     }))
 }

lib/cli/src/commands/run/mod.rs

@@ -228,12 +228,13 @@ impl Run {
     ) -> Result<(), Error> {
         let mut runner = wasmer_wasix::runners::wcgi::WcgiRunner::new();
 
+        let root_fs = self.wasi.get_fs()?;
         runner
             .config()
             .args(self.args.clone())
             .addr(self.wcgi.addr)
             .envs(self.wasi.env_vars.clone())
-            .map_directories(self.wasi.mapped_dirs.clone())
+            .with_fs(root_fs)
             .callbacks(Callbacks::new(self.wcgi.addr))
             .inject_packages(uses);
         *runner.config().capabilities() = self.wasi.capabilities();
@@ -298,8 +299,8 @@ impl Run {
             .with_args(&self.args)
             .with_injected_packages(packages)
             .with_envs(self.wasi.env_vars.clone())
+            .with_fs(self.wasi.get_fs()?)
             .with_mapped_host_commands(self.wasi.build_mapped_commands()?)
-            .with_mapped_directories(self.wasi.build_mapped_directories()?)
             .with_forward_host_env(self.wasi.forward_host_env)
             .with_capabilities(self.wasi.capabilities());
 
@@ -316,7 +317,7 @@ impl Run {
     ) -> Result<(), Error> {
         let program_name = wasm_path.display().to_string();
 
-        let runner = self.build_wasi_runner(&runtime)?;
+        let mut runner = self.build_wasi_runner(&runtime)?;
         runner.run_wasm(
             runtime,
             &program_name,

lib/cli/src/commands/run/wasi.rs

@@ -10,13 +10,14 @@ use bytes::Bytes;
 use clap::Parser;
 use tokio::runtime::Handle;
 use url::Url;
-use virtual_fs::{DeviceFile, FileSystem, PassthruFileSystem, RootFileSystemBuilder};
+use virtual_fs::host_fs::FileSystem as HostFileSystem;
+use virtual_fs::{DeviceFile, FileSystem, RootFileSystemBuilder};
 use wasmer::{Engine, Function, Instance, Memory32, Memory64, Module, RuntimeError, Store, Value};
 use wasmer_registry::wasmer_env::WasmerEnv;
 use wasmer_wasix::{
     bin_factory::BinaryPackage,
     capabilities::Capabilities,
-    default_fs_backing, get_wasi_versions,
+    get_wasi_versions,
     http::HttpClient,
     os::{tty_sys::SysTty, TtyBridge},
     rewind_ext,
@@ -125,7 +126,7 @@ pub struct RunProperties {
 
 #[allow(dead_code)]
 impl Wasi {
-    const MAPPED_CURRENT_DIR_DEFAULT_PATH: &'static str = "/mnt/host";
+    const MAPPED_CURRENT_DIR_DEFAULT_PATH: &'static str = "/home";
 
     pub fn map_dir(&mut self, alias: &str, target_on_disk: PathBuf) {
         self.mapped_dirs.push(MappedDirectory {
@@ -193,115 +194,13 @@ impl Wasi {
             .map_commands(map_commands);
 
         let mut builder = {
-            // If we preopen anything from the host then shallow copy it over
-            let root_fs = RootFileSystemBuilder::new()
-                .with_tty(Box::new(DeviceFile::new(__WASI_STDIN_FILENO)))
-                .build();
-
-            let mut mapped_dirs = Vec::new();
-
-            // Process the --dirs flag and merge it with --mapdir.
-            let mut have_current_dir = false;
-            for dir in &self.pre_opened_directories {
-                let mapping = if dir == Path::new(".") {
-                    if have_current_dir {
-                        bail!("Cannot pre-open the current directory twice: --dir=. must only be specified once");
-                    }
-                    have_current_dir = true;
-
-                    let current_dir =
-                        std::env::current_dir().context("could not determine current directory")?;
-
-                    MappedDirectory {
-                        host: current_dir,
-                        guest: Self::MAPPED_CURRENT_DIR_DEFAULT_PATH.to_string(),
-                    }
-                } else {
-                    let resolved = dir.canonicalize().with_context(|| {
-                        format!(
-                            "could not canonicalize path for argument '--dir {}'",
-                            dir.display()
-                        )
-                    })?;
-
-                    if &resolved != dir {
-                        bail!(
-                            "Invalid argument '--dir {}': path must either be absolute, or '.'",
-                            dir.display(),
-                        );
-                    }
-
-                    let guest = resolved
-                        .to_str()
-                        .with_context(|| {
-                            format!(
-                                "invalid argument '--dir {}': path must be valid utf-8",
-                                dir.display(),
-                            )
-                        })?
-                        .to_string();
-
-                    MappedDirectory {
-                        host: resolved,
-                        guest,
-                    }
-                };
-
-                mapped_dirs.push(mapping);
-            }
-
-            for MappedDirectory { host, guest } in &self.mapped_dirs {
-                let resolved_host = host.canonicalize().with_context(|| {
-                    format!(
-                        "could not canonicalize path for argument '--mapdir {}:{}'",
-                        host.display(),
-                        guest,
-                    )
-                })?;
-
-                let mapping = if guest == "." {
-                    if have_current_dir {
-                        bail!("Cannot pre-open the current directory twice: '--mapdir=?:.' / '--dir=.' must only be specified once");
-                    }
-                    have_current_dir = true;
-
-                    MappedDirectory {
-                        host: resolved_host,
-                        guest: Self::MAPPED_CURRENT_DIR_DEFAULT_PATH.to_string(),
-                    }
-                } else {
-                    MappedDirectory {
-                        host: resolved_host,
-                        guest: guest.clone(),
-                    }
-                };
-                mapped_dirs.push(mapping);
-            }
-
-            if !mapped_dirs.is_empty() {
-                let fs_backing: Arc<dyn FileSystem + Send + Sync> =
-                    Arc::new(PassthruFileSystem::new(default_fs_backing()));
-                for MappedDirectory { host, guest } in self.mapped_dirs.clone() {
-                    let host = if !host.is_absolute() {
-                        Path::new("/").join(host)
-                    } else {
-                        host
-                    };
-                    root_fs.mount(guest.into(), &fs_backing, host)?;
-                }
-            }
-
+            let root_fs = self.get_fs()?;
             // Open the root of the new filesystem
             let b = builder
                 .sandbox_fs(root_fs)
                 .preopen_dir(Path::new("/"))
                 .unwrap();
-
-            if have_current_dir {
-                b.map_dir(".", Self::MAPPED_CURRENT_DIR_DEFAULT_PATH)?
-            } else {
-                b.map_dir(".", "/")?
-            }
+            b
         };
 
         *builder.capabilities_mut() = self.capabilities();
@@ -317,85 +216,74 @@ impl Wasi {
         Ok(builder)
     }
 
-    pub fn build_mapped_directories(&self) -> Result<Vec<MappedDirectory>, anyhow::Error> {
-        let mut mapped_dirs = Vec::new();
-
-        // Process the --dirs flag and merge it with --mapdir.
-        let mut have_current_dir = false;
-        for dir in &self.pre_opened_directories {
-            let mapping = if dir == Path::new(".") {
-                if have_current_dir {
-                    bail!("Cannot pre-open the current directory twice: --dir=. must only be specified once");
-                }
-                have_current_dir = true;
-
-                let current_dir =
-                    std::env::current_dir().context("could not determine current directory")?;
-
-                MappedDirectory {
-                    host: current_dir,
-                    guest: Self::MAPPED_CURRENT_DIR_DEFAULT_PATH.to_string(),
-                }
-            } else {
-                let resolved = dir.canonicalize().with_context(|| {
-                    format!(
-                        "could not canonicalize path for argument '--dir {}'",
-                        dir.display()
-                    )
-                })?;
-
-                if &resolved != dir {
-                    bail!(
-                        "Invalid argument '--dir {}': path must either be absolute, or '.'",
-                        dir.display(),
-                    );
-                }
-
-                let guest = resolved
-                    .to_str()
-                    .with_context(|| {
-                        format!(
-                            "invalid argument '--dir {}': path must be valid utf-8",
-                            dir.display(),
+    pub fn get_fs(&self) -> Result<virtual_fs::TmpFileSystem> {
+        // If we preopen anything from the host then shallow copy it over
+        let root_fs = RootFileSystemBuilder::new()
+            .with_tty(Box::new(DeviceFile::new(__WASI_STDIN_FILENO)))
+            .build();
+        let mut mapped_dirs = self.build_mapped_directories()?;
+        if !mapped_dirs.is_empty() {
+            for MappedDirectory { host, guest } in mapped_dirs {
+                let native_fs = HostFileSystem::new(host.canonicalize()?)?;
+                let fs: Arc<dyn virtual_fs::FileSystem + Send + Sync + 'static> =
+                    Arc::new(native_fs);
+                root_fs
+                    .mount(guest.clone().into(), &fs, PathBuf::new())
+                    .map_err(|_e| {
+                        anyhow!(
+                            "There has been a collision. \nA folder might be already mounted in {} or it's parent.",
+                            guest
                         )
-                    })?
-                    .to_string();
+                        .context(format!(
+                            "Could not mount {} in {}",
+                            host.display(),
+                            guest
+                        ))
+                    })?;
+            }
+        }
+        Ok(root_fs)
+    }
 
-                MappedDirectory {
-                    host: resolved,
-                    guest,
-                }
-            };
+    fn build_mapped_directories(&self) -> Result<Vec<MappedDirectory>> {
+        let mut mapped_dirs = Vec::new();
 
-            mapped_dirs.push(mapping);
+        // Process the --dirs flag and merge it with --mapdir flag.
+        for dir in &self.pre_opened_directories {
+            if !dir.is_relative() {
+                bail!(
+                    "Invalid argument '--dir {}': path must be relative",
+                    dir.display(),
+                );
+            }
+            let guest = PathBuf::from(Self::MAPPED_CURRENT_DIR_DEFAULT_PATH)
+                .join(dir)
+                .display()
+                .to_string();
+            let host = dir.canonicalize().with_context(|| {
+                format!(
+                    "could not canonicalize path for argument '--dir {}'",
+                    dir.display()
+                )
+            })?;
+            mapped_dirs.push(MappedDirectory { host, guest });
         }
 
+        // Process the --mapdir flag.
         for MappedDirectory { host, guest } in &self.mapped_dirs {
-            let resolved_host = host.canonicalize().with_context(|| {
+            let host = host.canonicalize().with_context(|| {
                 format!(
                     "could not canonicalize path for argument '--mapdir {}:{}'",
                     host.display(),
                     guest,
                 )
             })?;
+            let guest = PathBuf::from(Self::MAPPED_CURRENT_DIR_DEFAULT_PATH)
+                .join(guest)
+                .display()
+                .to_string();
 
-            let mapping = if guest == "." {
-                if have_current_dir {
-                    bail!("Cannot pre-open the current directory twice: '--mapdir=?:.' / '--dir=.' must only be specified once");
-                }
-                have_current_dir = true;
-
-                MappedDirectory {
-                    host: resolved_host,
-                    guest: Self::MAPPED_CURRENT_DIR_DEFAULT_PATH.to_string(),
-                }
-            } else {
-                MappedDirectory {
-                    host: resolved_host,
-                    guest: guest.clone(),
-                }
-            };
-            mapped_dirs.push(mapping);
+            mapped_dirs.push(MappedDirectory { host, guest });
         }
 
         Ok(mapped_dirs)

lib/virtual-fs/Cargo.toml

@@ -42,7 +42,8 @@ tokio = { version = "1", features = ["io-util", "rt"], default_features = false
 
 [features]
 default = ["host-fs", "webc-fs", "static-fs"]
-host-fs = ["libc", "fs_extra", "filetime", "tokio/fs", "tokio/io-std", "tokio/rt"]
+host-fs = ["libc", "fs_extra", "filetime", "tokio/fs", "tokio/io-std", "tokio/rt", "native-fs"]
+native-fs = ["libc", "fs_extra", "filetime", "tokio/fs", "tokio/io-std", "tokio/rt"]
 webc-fs = ["webc", "anyhow"]
 static-fs = ["webc", "anyhow"]
 enable-serde = ["typetag"]