Add VirtualFile::copy_from_owned_buffer, fixes running mounted comman…

lib/virtual-fs/src/lib.rs

@@ -5,6 +5,7 @@
 extern crate pretty_assertions;
 
 use futures::future::BoxFuture;
+use shared_buffer::OwnedBuffer;
 use std::any::Any;
 use std::ffi::OsString;
 use std::fmt;
@@ -398,6 +399,19 @@ pub trait VirtualFile:
         })
     }
 
+    /// This method will copy a file from a source to this destination where
+    /// the default is to do a straight byte copy however file system implementors
+    /// may optimize this to cheaply clone and store the OwnedBuffer directly
+    fn copy_from_owned_buffer(&mut self, src: &OwnedBuffer) -> BoxFuture<'_, std::io::Result<()>> {
+        let src = src.clone();
+        Box::pin(async move {
+            let mut bytes = src.as_slice();
+            let bytes_written = tokio::io::copy(&mut bytes, self).await?;
+            tracing::trace!(bytes_written, "Copying file into host filesystem");
+            Ok(())
+        })
+    }
+
     /// Polls the file for when there is data to be read
     fn poll_read_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>>;
 

lib/virtual-fs/src/mem_fs/file.rs

@@ -342,6 +342,38 @@ impl VirtualFile for FileHandle {
         })
     }
 
+    fn copy_from_owned_buffer(&mut self, src: &OwnedBuffer) -> BoxFuture<'_, std::io::Result<()>> {
+        let inner = self.filesystem.inner.clone();
+        let src = src.clone();
+        Box::pin(async move {
+            let mut fs = inner.write().unwrap();
+            let inode = fs.storage.get_mut(self.inode);
+            match inode {
+                Some(inode) => {
+                    let metadata = Metadata {
+                        ft: crate::FileType {
+                            file: true,
+                            ..Default::default()
+                        },
+                        accessed: 1,
+                        created: 1,
+                        modified: 1,
+                        len: src.len() as u64,
+                    };
+
+                    *inode = Node::ReadOnlyFile(ReadOnlyFileNode {
+                        inode: inode.inode(),
+                        name: inode.name().to_string_lossy().to_string().into(),
+                        file: ReadOnlyFile { buffer: src },
+                        metadata,
+                    });
+                    Ok(())
+                }
+                None => Err(std::io::ErrorKind::InvalidInput.into()),
+            }
+        })
+    }
+
     fn poll_read_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
         if !self.readable {
             return Poll::Ready(Err(io::Error::new(

lib/virtual-fs/src/mem_fs/mod.rs

@@ -54,6 +54,8 @@ struct ArcFileNode {
     metadata: Metadata,
 }
 
+// FIXME: this is broken!!! A `VirtualFile` stores its own offset,
+// so a file stored this way can only be read once!
 #[derive(Debug)]
 struct CustomFileNode {
     inode: Inode,

lib/wasix/src/lib.rs

@@ -242,7 +242,10 @@ impl SpawnError {
     /// [`NotFound`]: SpawnError::NotFound
     #[must_use]
     pub fn is_not_found(&self) -> bool {
-        matches!(self, Self::NotFound { .. } | Self::MissingEntrypoint { .. })
+        matches!(
+            self,
+            Self::NotFound { .. } | Self::MissingEntrypoint { .. } | Self::BinaryNotFound { .. }
+        )
     }
 }
 

lib/wasix/src/state/env.rs

@@ -8,7 +8,7 @@ use std::{
 
 use futures::future::BoxFuture;
 use rand::Rng;
-use virtual_fs::{FileSystem, FsError, StaticFile, VirtualFile};
+use virtual_fs::{FileSystem, FsError, VirtualFile};
 use virtual_net::DynVirtualNetworking;
 use wasmer::{
     AsStoreMut, AsStoreRef, FunctionEnvMut, Global, Imports, Instance, Memory, MemoryType,
@@ -1125,18 +1125,17 @@ impl WasiEnv {
                         }
                     }
                     WasiFsRoot::Backing(fs) => {
+                        // FIXME: we're counting on the fs being a mem_fs here. Otherwise, memory
+                        // usage will be very high.
                         let mut f = fs.new_open_options().create(true).write(true).open(path)?;
-                        if let Err(e) = f
-                            .copy_reference(Box::new(StaticFile::new(atom.clone())))
-                            .await
-                        {
+                        if let Err(e) = f.copy_from_owned_buffer(&atom).await {
                             tracing::warn!(
                                 error = &e as &dyn std::error::Error,
                                 "Unable to copy file reference",
                             );
                         }
                         let mut f = fs.new_open_options().create(true).write(true).open(path2)?;
-                        if let Err(e) = f.copy_reference(Box::new(StaticFile::new(atom))).await {
+                        if let Err(e) = f.copy_from_owned_buffer(&atom).await {
                             tracing::warn!(
                                 error = &e as &dyn std::error::Error,
                                 "Unable to copy file reference",