refactor: add and impl file trait

src/wasi/wasi_snapshot_preview1/file.rs

@@ -1,69 +1,86 @@
 use anyhow::Result;
-use std::fs;
-use std::io::{Cursor, Read, Seek, Write};
-use std::os::fd::FromRawFd;
-use std::sync::{Arc, Mutex};
+use std::io::{Read, Seek, Write};
 
-pub trait ReadWrite: Read + Write + Seek {}
+pub trait ReadWrite: Read + Write + Seek + Send + Sync + 'static {}
 
-impl<IO: Read + Write + Send + Seek> ReadWrite for IO {}
+impl<IO: Read + Write + Seek + Send + Sync + 'static> ReadWrite for IO {}
 
-pub struct File(Box<dyn ReadWrite>);
-
-impl File {
-    pub fn from_buffer(buffer: Vec<u8>) -> Self {
-        File(Box::new(Cursor::new(buffer)))
-    }
-
-    pub fn from_raw_fd(fd: u32) -> Self {
-        let file = unsafe { fs::File::from_raw_fd(fd as i32) };
-        File(Box::new(file))
-    }
-
-    pub fn write(&mut self, data: &[u8]) -> Result<usize> {
-        let written = self.0.write(data)?;
-        Ok(written)
-    }
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum FdFlags {
+    Append = 0b1,
+    Dsync = 0b10,
+    Nonblock = 0b1000,
+    Rsync = 0b10000,
+    Sync = 0b100000,
+}
 
-    pub fn read(&mut self, data: &mut [u8]) -> Result<usize> {
-        Ok(self.0.read(data)?)
-    }
+#[derive(Debug, Clone)]
+pub enum FileCaps {
+    DataSync = 0b1,
+    Read = 0b10,
+    Seek = 0b100,
+    FdstatSetFlags = 0b1000,
+    Sync = 0b10000,
+    Tell = 0b100000,
+    Write = 0b1000000,
+    Advise = 0b10000000,
+    Allocate = 0b100000000,
+    FilestatGet = 0b1000000000,
+    FilestatSetSize = 0b10000000000,
+    FilestatSetTimes = 0b100000000000,
+    PollReadwrite = 0b1000000000000,
+}
 
-    pub fn seek(&mut self, pos: u64) -> Result<u64> {
-        Ok(self.0.seek(std::io::SeekFrom::Start(pos))?)
-    }
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum FileType {
+    Unknown = 0,
+    BlockDevice = 1,
+    CharacterDevice = 2,
+    Directory = 3,
+    RegularFile = 4,
+    SocketDgram = 5,
+    SocketStream = 6,
+    SymbolicLink = 7,
+    Pipe = 8,
+}
 
-    pub fn read_string(&mut self) -> Result<String> {
-        let mut buf = String::new();
-        self.0.read_to_string(&mut buf)?;
-        Ok(buf)
-    }
+pub trait File: Send + Sync {
+    fn write(&mut self, data: &[u8]) -> Result<usize>;
+    fn read(&mut self, data: &mut [u8]) -> Result<usize>;
+    fn seek(&mut self, pos: u64) -> Result<u64>;
+    fn filetype(&self) -> Result<FileType>;
+    fn fdflags(&self) -> Result<FdFlags>;
+    fn read_string(&mut self) -> Result<String>;
 }
 
-pub struct FileTable(Vec<Arc<Mutex<File>>>);
+#[derive(Debug, Clone)]
+pub struct FdStat {
+    pub filetype: FileType,
+    pub caps: FileCaps,
+    pub flags: FdFlags,
+}
 
-impl Default for FileTable {
-    fn default() -> Self {
-        Self(vec![
-            Arc::new(Mutex::new(File::from_raw_fd(0))), // stdin
-            Arc::new(Mutex::new(File::from_raw_fd(1))), // stdout
-            Arc::new(Mutex::new(File::from_raw_fd(2))), // stderr
-        ])
-    }
+pub struct FileEntry {
+    caps: FileCaps,
+    file: Box<dyn File>,
 }
 
-impl FileTable {
-    pub fn with_io(files: Vec<Arc<Mutex<File>>>) -> Self {
-        let mut file_table = FileTable(vec![]);
-        for file in files {
-            file_table.add(file);
-        }
-        file_table
+impl FileEntry {
+    pub fn new(file: Box<dyn File>, caps: FileCaps) -> Self {
+        Self { caps, file }
     }
-    pub fn get(&self, idx: usize) -> Option<&Arc<Mutex<File>>> {
-        self.0.get(idx)
+
+    pub fn get_fdstat(&self) -> Result<FdStat> {
+        Ok(FdStat {
+            filetype: self.file.filetype()?,
+            caps: self.caps.clone(),
+            flags: self.file.fdflags()?,
+        })
     }
-    pub fn add(&mut self, file: Arc<Mutex<File>>) {
-        self.0.push(file);
+
+    pub fn capbable(&mut self, _cap: FileCaps) -> Result<&mut Box<dyn File>> {
+        // TODO: check capabilites
+        let file = &mut self.file;
+        Ok(file)
     }
 }

src/wasi/wasi_snapshot_preview1/file_table.rs

@@ -0,0 +1,43 @@
+use super::{
+    file::{FileCaps, FileEntry},
+    wasi_file::WasiFile,
+};
+use std::sync::{Arc, Mutex};
+
+pub struct FileTable(Vec<Arc<Mutex<FileEntry>>>);
+
+impl Default for FileTable {
+    fn default() -> Self {
+        Self(vec![
+            // stdin
+            Arc::new(Mutex::new(FileEntry::new(
+                Box::new(WasiFile::from_raw_fd(0)),
+                FileCaps::Sync,
+            ))),
+            // stdout
+            Arc::new(Mutex::new(FileEntry::new(
+                Box::new(WasiFile::from_raw_fd(1)),
+                FileCaps::Sync,
+            ))),
+            // stderr
+            Arc::new(Mutex::new(FileEntry::new(
+                Box::new(WasiFile::from_raw_fd(2)),
+                FileCaps::Sync,
+            ))),
+        ])
+    }
+}
+
+impl FileTable {
+    pub fn with_io(files: Vec<Arc<Mutex<FileEntry>>>) -> Self {
+        FileTable(files)
+    }
+
+    pub fn get(&self, idx: usize) -> Option<&Arc<Mutex<FileEntry>>> {
+        self.0.get(idx)
+    }
+
+    pub fn add(&mut self, file: Arc<Mutex<FileEntry>>) {
+        self.0.push(file);
+    }
+}

src/wasi/wasi_snapshot_preview1/mod.rs

@@ -1,5 +1,8 @@
 pub mod file;
+pub mod file_table;
 pub mod preview1;
 pub mod types;
+pub mod virtual_file;
+pub mod wasi_file;
 
 pub use preview1::*;

src/wasi/wasi_snapshot_preview1/preview1.rs

@@ -1,7 +1,7 @@
-use super::file::{File, FileTable};
+use super::{file::FileEntry, file_table::FileTable};
 use crate::{
-    binary::instruction::MemoryArg, memory_load, memory_write, module::ExternalFuncInst, Importer,
-    Store, Value,
+    binary::instruction::MemoryArg, memory_load, memory_write, module::ExternalFuncInst,
+    wasi::file::FileCaps, Importer, Store, Value,
 };
 use anyhow::{Context as _, Result};
 use rand::prelude::*;
@@ -34,14 +34,15 @@ impl Importer for WasiSnapshotPreview1 {
             "args_get" => self.args_get(store, args),
             "args_sizes_get" => self.args_sizes_get(store, args),
             "random_get" => self.random_get(store, args),
+            "fd_fdstat_get" => self.fd_fdstat_get(store, args),
             _ => todo!(),
         }?;
         Ok(Some(value))
     }
 }
 
 impl WasiSnapshotPreview1 {
-    pub fn with_io(files: Vec<Arc<Mutex<File>>>) -> Self {
+    pub fn with_io(files: Vec<Arc<Mutex<FileEntry>>>) -> Self {
         let file_table = FileTable::with_io(files);
         Self { file_table }
     }
@@ -120,7 +121,10 @@ impl WasiSnapshotPreview1 {
             .file_table
             .get(fd)
             .with_context(|| format!("cannot get file with fd: {}", fd))?;
+
         let file = Arc::clone(file);
+        let mut file = file.lock().expect("cannot lock file");
+        let file = file.capbable(FileCaps::Read)?;
 
         let mut nread = 0;
         for _ in 0..iovs_len {
@@ -133,10 +137,7 @@ impl WasiSnapshotPreview1 {
             let offset = offset as usize;
             let end = offset + len as usize;
 
-            nread += file
-                .lock()
-                .expect("cannot get file lock")
-                .read(&mut memory.data[offset..end])?;
+            nread += file.read(&mut memory.data[offset..end])?;
         }
 
         memory_write!(memory, 0, 4, nread_offset, nread);
@@ -162,6 +163,10 @@ impl WasiSnapshotPreview1 {
             .get(fd)
             .with_context(|| format!("cannot get file with fd: {}", fd))?;
         let file = Arc::clone(file);
+
+        let mut file = file.lock().expect("cannot lock file");
+        let file = file.capbable(FileCaps::Write)?;
+
         let mut written = 0;
 
         for _ in 0..iovs_len {
@@ -175,7 +180,7 @@ impl WasiSnapshotPreview1 {
             let end = offset + len as usize;
             let buf = &memory.data[offset..end];
 
-            written += file.lock().expect("cannot get file lock").write(buf)?;
+            written += file.write(buf)?;
         }
 
         memory_write!(memory, 0, 4, rp, written);
@@ -252,12 +257,43 @@ impl WasiSnapshotPreview1 {
 
         Ok(0.into())
     }
+
+    fn fd_fdstat_get(&self, store: Rc<RefCell<Store>>, args: Vec<Value>) -> Result<Value> {
+        let args: Vec<i32> = args.into_iter().map(Into::into).collect();
+        let (fd, offset) = (args[0] as usize, args[1] as usize);
+
+        let store = store.borrow();
+        let memory = store.memory.get(0).with_context(|| "not found memory")?;
+        let mut memory = memory.borrow_mut();
+
+        let file = self
+            .file_table
+            .get(fd)
+            .with_context(|| format!("cannot get file with fd: {}", fd))?;
+        let file = file.lock().expect("cannot lock file");
+        let stat = file.get_fdstat()?;
+
+        // ref: https://deno.land/[email protected]/wasi/snapshot_preview1.ts?source=#L673
+        memory.write_bytes(offset, get_memory(&stat.filetype))?;
+        memory.write_bytes(offset + 2, get_memory(&stat.flags))?;
+
+        Ok(0.into())
+    }
+}
+
+fn get_memory<T>(input: &T) -> &[u8] {
+    unsafe { std::slice::from_raw_parts(input as *const _ as *const u8, std::mem::size_of::<T>()) }
 }
 
 #[cfg(test)]
 mod tests {
+    use std::sync::Mutex;
+
     use super::*;
-    use crate::Runtime;
+    use crate::{
+        wasi::{file::FileEntry, wasi_snapshot_preview1::virtual_file::VirtualFile},
+        Runtime,
+    };
     use pretty_assertions::assert_eq;
 
     #[test]
@@ -290,10 +326,16 @@ mod tests {
             "#;
         let wasm = wat::parse_str(code)?;
 
-        let stdin = Arc::new(Mutex::new(File::from_buffer(vec![])));
-        let stdout = Arc::new(Mutex::new(File::from_buffer(vec![])));
+        let stdin = Arc::new(Mutex::new(FileEntry::new(
+            Box::<VirtualFile>::default(),
+            FileCaps::Sync,
+        )));
+        let stdout = Arc::new(Mutex::new(FileEntry::new(
+            Box::<VirtualFile>::default(),
+            FileCaps::Sync,
+        )));
 
-        let wasi = WasiSnapshotPreview1::with_io(vec![stdin, Arc::clone(&stdout)]);
+        let wasi = WasiSnapshotPreview1::with_io(vec![stdin, stdout.clone()]);
         let mut runtime = Runtime::from_bytes(wasm.as_slice(), Some(Box::new(wasi)))?;
 
         let result: i32 = runtime
@@ -303,6 +345,7 @@ mod tests {
         assert_eq!(result, 0);
 
         let mut stdout = stdout.lock().expect("cannot lock stdout");
+        let stdout = stdout.capbable(FileCaps::Seek)?;
         stdout.seek(0)?; // NOTE: need to reset cursor for reading
         assert_eq!(stdout.read_string()?, "Hello, World!\n");
         Ok(())
@@ -312,15 +355,22 @@ mod tests {
     fn test_args_get() -> Result<()> {
         let wasm = wat::parse_file("examples/args_get.wasm")?;
 
-        let stdin = Arc::new(Mutex::new(File::from_buffer(vec![])));
-        let stdout = Arc::new(Mutex::new(File::from_buffer(vec![])));
+        let stdin = Arc::new(Mutex::new(FileEntry::new(
+            Box::<VirtualFile>::default(),
+            FileCaps::Sync,
+        )));
+        let stdout = Arc::new(Mutex::new(FileEntry::new(
+            Box::<VirtualFile>::default(),
+            FileCaps::Sync,
+        )));
 
-        let wasi = WasiSnapshotPreview1::with_io(vec![stdin, Arc::clone(&stdout)]);
+        let wasi = WasiSnapshotPreview1::with_io(vec![stdin, stdout.clone()]);
         let mut runtime = Runtime::from_bytes(wasm.as_slice(), Some(Box::new(wasi)))?;
 
         runtime.call("_start".into(), vec![])?;
 
         let mut stdout = stdout.lock().expect("cannot lock stdout");
+        let stdout = stdout.capbable(FileCaps::Read)?;
         stdout.seek(0)?;
         let result: Vec<String> = serde_json::from_str(&stdout.read_string()?)?;
         let arg = std::env::args().take(1).next().unwrap();
@@ -332,17 +382,23 @@ mod tests {
     fn test_fd_read() -> Result<()> {
         let wasm = wat::parse_file("examples/fd_read.wasm")?;
 
-        let stdin = Arc::new(Mutex::new(File::from_buffer(
-            "hello world".as_bytes().to_vec(),
+        let stdin = Arc::new(Mutex::new(FileEntry::new(
+            Box::new(VirtualFile::new(b"hello world")),
+            FileCaps::Sync,
+        )));
+
+        let stdout = Arc::new(Mutex::new(FileEntry::new(
+            Box::<VirtualFile>::default(),
+            FileCaps::Sync,
         )));
-        let stdout = Arc::new(Mutex::new(File::from_buffer(vec![])));
 
-        let wasi = WasiSnapshotPreview1::with_io(vec![Arc::clone(&stdin), Arc::clone(&stdout)]);
+        let wasi = WasiSnapshotPreview1::with_io(vec![stdin.clone(), stdout.clone()]);
         let mut runtime = Runtime::from_bytes(wasm.as_slice(), Some(Box::new(wasi)))?;
 
         runtime.call("_start".into(), vec![])?;
 
         let mut stdout = stdout.lock().expect("cannot lock stdout");
+        let stdout = stdout.capbable(FileCaps::Read)?;
         stdout.seek(0)?;
         assert_eq!(stdout.read_string()?, "input: got: hello world\n");
         Ok(())