Merge pull request #1325 from Phala-Network/fd_write

sidevm: Allow writing to stdout and stderr

Author: kvinwang

crates/sidevm/host-runtime/src/env.rs

@@ -336,6 +336,17 @@ impl Env {
     pub fn is_stifled(&self, store: &mut impl AsStoreMut) -> bool {
         self.inner.lock().unwrap().is_stifled(store)
     }
+
+    pub fn memory(&self) -> Memory {
+        self.inner
+            .lock()
+            .unwrap()
+            .memory
+            .0
+            .as_ref()
+            .expect("BUG: missing memory in env")
+            .clone()
+    }
 }
 
 impl<'a, 'b> env::OcallEnv for FnEnvMut<'a, &'b mut EnvInner> {

crates/sidevm/host-runtime/src/env/wasi_env.rs

@@ -2,8 +2,10 @@ use super::{Env as WasiEnv, Result};
 use libc::{clock_getres, clock_gettime, timespec, CLOCK_MONOTONIC, CLOCK_REALTIME};
 use sidevm_env::{OcallError, OcallFuncs};
 use thiserror::Error;
+use tracing::{error, info};
 use wasmer::{
-    namespace, AsStoreMut, Exports, Function, FunctionEnv, FunctionEnvMut, Memory32, WasmPtr,
+    namespace, AsStoreMut, Exports, Function, FunctionEnv, FunctionEnvMut, Memory32,
+    MemoryAccessError, WasmPtr,
 };
 use wasmer_wasix_types::{
     types::*,
@@ -34,6 +36,43 @@ macro_rules! wasi_try {
     }};
 }
 
+/// Like the `try!` macro or `?` syntax: returns the value if the computation
+/// succeeded or returns the error value. Results are wrapped as an `Ok(errno)`.
+macro_rules! wasi_try_ok {
+    ($expr:expr) => {{
+        let res: Result<_, Errno> = $expr;
+        match res {
+            Ok(val) => val,
+            Err(err) => {
+                return Ok(err);
+            }
+        }
+    }};
+}
+
+/// Like `wasi_try` but converts a `MemoryAccessError` to a `wasi::Errno`.
+macro_rules! wasi_try_mem_ok {
+    ($expr:expr) => {{
+        wasi_try_ok!($expr.map_err(mem_error_to_wasi))
+    }};
+}
+
+/// Like `wasi_try` but allow the inner block to use `?` syntax on a Result<_, Errno>.
+macro_rules! wasi_try_block_ok {
+    ($expr:expr) => {{
+        wasi_try_ok!(|| -> Result<_, Errno> { Ok($expr) }())
+    }};
+}
+
+fn mem_error_to_wasi(err: MemoryAccessError) -> Errno {
+    match err {
+        MemoryAccessError::HeapOutOfBounds => Errno::Memviolation,
+        MemoryAccessError::Overflow => Errno::Overflow,
+        MemoryAccessError::NonUtf8String => Errno::Inval,
+        _ => Errno::Unknown,
+    }
+}
+
 pub(crate) fn wasi_imports(store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>) -> Exports {
     namespace! {
         "args_get" => Function::new_typed_with_env(store, env, args_get),
@@ -353,14 +392,55 @@ pub fn fd_tell(
     Errno::Nosys
 }
 
+#[tracing::instrument(skip_all, fields(fd = fd))]
 pub fn fd_write(
-    _env: FunctionEnvMut<WasiEnv>,
-    _fd: wasi::Fd,
-    _iovs: WasmPtr<__wasi_ciovec_t<Memory32>>,
-    _iovs_len: u32,
-    _nwritten: WasmPtr<u32>,
-) -> Errno {
-    Errno::Success
+    ctx: FunctionEnvMut<WasiEnv>,
+    fd: wasi::Fd,
+    iovs: WasmPtr<__wasi_ciovec_t<Memory32>>,
+    iovs_len: u32,
+    nwritten: WasmPtr<u32>,
+) -> Result<Errno, WasiError> {
+    if fd != 1 && fd != 2 {
+        return Ok(Errno::Badf);
+    }
+    fd_write_stdio(ctx, fd, iovs, iovs_len, nwritten)
+}
+
+fn fd_write_stdio(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: wasi::Fd,
+    iovs: WasmPtr<__wasi_ciovec_t<Memory32>>,
+    iovs_len: u32,
+    nwritten: WasmPtr<u32>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = env.memory();
+    let memory = memory.view(&ctx);
+    let iovs_arr = wasi_try_mem_ok!(iovs.slice(&memory, iovs_len));
+    let iovs_arr = wasi_try_mem_ok!(iovs_arr.access());
+    let mut written = 0usize;
+    for iovs in iovs_arr.iter() {
+        let buf = wasi_try_block_ok! {
+            WasmPtr::<u8>::new(iovs.buf)
+                .slice(&memory, iovs.buf_len)
+                .map_err(mem_error_to_wasi)?
+                .access()
+                .map_err(mem_error_to_wasi)?
+        };
+        let bytes = buf.as_ref();
+        for line in String::from_utf8_lossy(&bytes[..bytes.len().min(1024)]).lines() {
+            if fd == 2 {
+                error!(target: "sidevm", "{}", line);
+            } else {
+                info!(target: "sidevm", "{}", line);
+            }
+        }
+        written += buf.len();
+    }
+    let nwritten_ref = nwritten.deref(&memory);
+    let written: u32 = wasi_try_ok!(written.try_into().map_err(|_| Errno::Overflow));
+    wasi_try_mem_ok!(nwritten_ref.write(written));
+    Ok(Errno::Success)
 }
 
 pub fn path_create_directory(

crates/sidevm/host/Cargo.toml

@@ -10,7 +10,7 @@ sidevm-host-runtime = { path = "../host-runtime", features = [
 ] }
 tokio = { version = "1.17.0", features = ["full"] }
 log = "0.4"
-env_logger = "0.9.0"
+tracing-subscriber = "0.3"
 anyhow = "1.0.69"
 clap = { version = "4.0.32", features = ["derive"] }
 once_cell = "1"

crates/sidevm/host/src/main.rs

@@ -17,6 +17,9 @@ pub struct Args {
     workers: usize,
     /// The WASM program to run
     program: Option<String>,
+    /// Max memory pages
+    #[arg(long, default_value_t = 256)]
+    max_memory_pages: u32,
 }
 
 fn simple_cache() -> DynCacheOps {
@@ -56,7 +59,7 @@ fn simple_cache() -> DynCacheOps {
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    env_logger::init();
+    tracing_subscriber::fmt::init();
     if std::env::var("ROCKET_PORT").is_err() {
         std::env::set_var("ROCKET_PORT", "8003");
     }

crates/sidevm/host/src/web_api.rs

@@ -63,7 +63,7 @@ impl App {
             .spawner
             .start(
                 &wasm_bytes,
-                1024,
+                inner.args.max_memory_pages,
                 vmid,
                 inner.args.gas_per_breath,
                 crate::simple_cache(),