Rework for wasmtime 0.29 and WASI changes

A lot has changed in upstream wasmtime / WASI, so wasmldr needs
significant reworking to keep up.

The biggest change upstream is that virtfs has been dropped from
wasi_common. So we're dropping the bundle format and virtual filesystem
view, for now, and we'll reimplement that functionality piece by piece,
using things that are a little better aligned with current directions in
WASI and WebAssembly.

With this commit, enarx-wasmldr at least compiles and passes the remaining
tests, and can successfully run some random wasm modules I had laying
around. So this seems like a good start.

Detailed changes:

* bumped deps to wasmtime 0.29 and wasmparser 0.80
* removed bundle stuff from build.rs
* removed config.rs and virtfs.rs
* removed deps on serde, tar, tempfile from Cargo.toml
* remove populate_virtfs() etc. from workload.rs
  * NOTE: this means we can't load modules on FD3 right now (that will
    be restored in a future commit)
* moved CLI parsing into cli.rs, since this might get reused elsewhere
* switched to structopt for CLI parsing, as we do elsewhere
* use anyhow for error handling (like wasmtime does)
* tweak trait bounds on workload::run() to work better with args/envs
  from structopt
* enable module-linking and multi-memory in instantiated wasmtime engine

Signed-off-by: Will Woods <[email protected]>

Author: wgwoods

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "enarx-wasmldr"
-version = "0.1.0"
-authors = ["Stefan Junker <[email protected]>", "Daiki Ueno <[email protected]>"]
+version = "0.2.0"
+authors = ["Will Woods <[email protected]>", "Stefan Junker <[email protected]>", "Daiki Ueno <[email protected]>"]
 edition = "2018"
 license = "Apache-2.0"
 homepage = "https://github.com/enarx/enarx-wasmldr"
@@ -21,25 +21,24 @@ is-it-maintained-issue-resolution = { repository = "enarx/enarx-wasmldr" }
 is-it-maintained-open-issues = { repository = "enarx/enarx-wasmldr" }
 
 [dependencies]
-wasmtime = { version = "0.22", default-features = false }
-wasmtime-wasi = { version = "0.22", default-features = false }
-wasi-common = { version = "0.22", default-features = false }
-env_logger = "0.8"
+wasmtime = { version = "0.29", default-features = false }
+wasmtime-wasi = { version = "0.29", default-features = false, features = ["sync"] }
+wasi-common = { version = "0.29", default-features = false }
+env_logger = "0.9"
 log = "0.4"
 
-wasmparser = "0.73"
-tar = "0.4"
-tempfile = "3"
-clap = "2.33"
-
-serde = { version = "1.0", features = ["derive"] }
-serde_yaml = "0.8"
-cfg-if = "1.0"
+wasmparser = "0.80"
+structopt = "0.3.22"
+anyhow = "1.0"
 
 [build-dependencies]
 wat = "1.0"
 
 [profile.release]
 incremental = false
 codegen-units = 1
+panic = "abort"
 lto = true
+opt-level = "s"
+# This only works in nightly...
+#strip = "debuginfo"

Cargo.toml

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use std::path::Path;
-use std::process::Command;
 
 fn main() {
     let in_dir = Path::new("fixtures");
@@ -10,47 +9,18 @@ fn main() {
     let out_dir = Path::new(&out_dir).join("fixtures");
     std::fs::create_dir_all(&out_dir).expect("Can't create output directory");
 
-    for entry in in_dir.read_dir().unwrap() {
-        if let Ok(entry) = entry {
-            let wat = entry.path();
-            match wat.extension() {
-                Some(ext) if ext == "wat" => {
-                    let wasm = out_dir
-                        .join(wat.file_name().unwrap())
-                        .with_extension("wasm");
-                    let binary = wat::parse_file(&wat).expect("Can't parse wat file");
-                    std::fs::write(&wasm, &binary).expect("Can't write wasm file");
-                    // If the "enarx" command is installed, create a
-                    // bundled Wasm file for testing.
-                    let status = Command::new("enarx")
-                        .arg("wasm")
-                        .arg("bundle")
-                        .arg("fixtures/bundle")
-                        .arg(&wasm)
-                        .arg(&wasm.with_extension("bundled.wasm"))
-                        .status();
-
-                    if let Ok(status) = status {
-                        if !status.success() {
-                            println!(
-                                "cargo:warning=Error bundling resources for {:?}: {}",
-                                &wasm.file_name().unwrap(),
-                                status.code().unwrap()
-                            );
-                        } else {
-                            println!("cargo:rustc-cfg=bundle_tests");
-                        }
-                    } else {
-                        println!(
-                            "cargo:warning=Not bundling resources for {:?}",
-                            &wasm.file_name().unwrap()
-                        );
-                    }
-
-                    println!("cargo:rerun-if-changed={}", &wat.display());
-                }
-                _ => {}
+    for entry in in_dir.read_dir().unwrap().flatten() {
+        let wat = entry.path();
+        match wat.extension() {
+            Some(ext) if ext == "wat" => {
+                let wasm = out_dir
+                    .join(wat.file_name().unwrap())
+                    .with_extension("wasm");
+                let binary = wat::parse_file(&wat).expect("Can't parse wat file");
+                std::fs::write(&wasm, &binary).expect("Can't write wasm file");
+                println!("cargo:rerun-if-changed={}", &wat.display());
             }
+            _ => {}
         }
     }
 }

build.rs

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#![allow(missing_docs, unused_variables)] // This is a work-in-progress, so...
+
+use structopt::{clap::AppSettings, StructOpt};
+
+use anyhow::{bail, Result};
+use std::path::PathBuf;
+
+// The main StructOpt for running `wasmldr` directly
+#[derive(StructOpt, Debug)]
+#[structopt(setting=AppSettings::TrailingVarArg)]
+pub struct RunOptions {
+    /// Pass an environment variable to the program
+    #[structopt(
+        short = "e",
+        long = "env",
+        number_of_values = 1,
+        value_name = "NAME=VAL",
+        parse(try_from_str=parse_env_var),
+    )]
+    pub envs: Vec<(String, String)>,
+
+    /// Name of the function to invoke
+    #[structopt(long, value_name = "FUNCTION")]
+    invoke: Option<String>,
+
+    // TODO: --inherit-env
+    // TODO: --stdin, --stdout, --stderr
+    /// Path of the WebAssembly module to run
+    #[structopt(index = 1, required = true, value_name = "MODULE", parse(from_os_str))]
+    pub module: PathBuf,
+
+    // NOTE: this has to come last for TrailingVarArg
+    /// Arguments to pass to the WebAssembly module
+    #[structopt(value_name = "ARGS")]
+    pub args: Vec<String>,
+}
+
+fn parse_env_var(s: &str) -> Result<(String, String)> {
+    let parts: Vec<&str> = s.splitn(2, '=').collect();
+    if parts.len() != 2 {
+        bail!("must be of the form `NAME=VAL`");
+    }
+    Ok((parts[0].to_owned(), parts[1].to_owned()))
+}

src/cli.rs

@@ -28,52 +28,41 @@
 #![deny(missing_docs)]
 #![deny(clippy::all)]
 
-mod bundle;
-mod config;
-mod virtfs;
+mod cli;
 mod workload;
 
-use cfg_if::cfg_if;
-use log::info;
+use log::{debug, info};
+use structopt::StructOpt;
 
 use std::fs::File;
 use std::io::Read;
-#[cfg(unix)]
-use std::os::unix::io::FromRawFd;
-
-#[cfg(unix)]
-const FD: std::os::unix::io::RawFd = 3;
 
 fn main() {
-    let _ = env_logger::try_init_from_env(env_logger::Env::default());
+    // Initialize the logger, taking settings from the default env vars
+    env_logger::Builder::from_default_env().init();
+
+    info!("version {} starting up", env!("CARGO_PKG_VERSION"));
 
-    // Skip the program name by default, but also skip the enarx-keepldr image
-    // name if it happens to precede the regular command line arguments.
-    let nskip = 1 + std::env::args()
-        .take(1)
-        .filter(|s| s.ends_with("enarx-keepldr"))
-        .count();
-    let mut args = std::env::args().skip(nskip);
-    let vars = std::env::vars();
+    debug!("parsing argv");
+    let opts = cli::RunOptions::from_args();
+    info!("opts: {:#?}", opts);
 
-    let mut reader = if let Some(path) = args.next() {
-        File::open(&path).expect("Unable to open file")
-    } else {
-        cfg_if! {
-            if #[cfg(unix)] {
-                unsafe { File::from_raw_fd(FD) }
-            } else {
-                unreachable!();
-            }
-        }
-    };
+    info!("reading {:?}", opts.module);
+    // TODO: don't just panic here...
+    let mut reader = File::open(&opts.module).expect("Unable to open file");
 
     let mut bytes = Vec::new();
     reader
         .read_to_end(&mut bytes)
         .expect("Failed to load workload");
 
-    let result = workload::run(&bytes, args, vars).expect("Failed to run workload");
+    // FUTURE: measure opts.envs, opts.args, opts.wasm_features
+    // FUTURE: fork() the workload off into a separate memory space
 
+    info!("running workload");
+    // TODO: pass opts.wasm_features
+    let result = workload::run(bytes, opts.args, opts.envs).expect("Failed to run workload");
     info!("got result: {:#?}", result);
+    // TODO: exit with the resulting code, if the result is a return code
+    // FUTURE: produce attestation report here
 }