Reactor support. (#1565)

* Reactor support.

This implements the new WASI ABI described here:

https://github.com/WebAssembly/WASI/blob/master/design/application-abi.md

It adds APIs to `Instance` and `Linker` with support for running
WASI programs, and also simplifies the process of instantiating
WASI API modules.

This currently only includes Rust API support.

* Add comments and fix a typo in a comment.

* Fix a rustdoc warning.

* Tidy an unneeded `mut`.

* Factor out instance initialization with `NewInstance`.

This also separates instantiation from initialization in a manner
similar to https://github.com/bytecodealliance/lucet/pull/506.

* Update fuzzing oracles for the API changes.

* Remove `wasi_linker` and clarify that Commands/Reactors aren't connected to WASI.

* Move Command/Reactor semantics into the Linker.

* C API support.

* Fix fuzzer build.

* Update usage syntax from "::" to "=".

* Remove `NewInstance` and `start()`.

* Elaborate on Commands and Reactors and add a spec link.

* Add more comments.

* Fix wat syntax.

* Fix wat.

* Use the `Debug` formatter to format an anyhow::Error.

* Fix wat.

tests/all/cli_tests.rs

@@ -256,3 +256,97 @@ fn exit126_wasi_snapshot1() -> Result<()> {
     assert!(String::from_utf8_lossy(&output.stderr).contains("invalid exit status"));
     Ok(())
 }
+
+// Run a minimal command program.
+#[test]
+fn minimal_command() -> Result<()> {
+    let wasm = build_wasm("tests/wasm/minimal-command.wat")?;
+    let stdout = run_wasmtime(&[wasm.path().to_str().unwrap(), "--disable-cache"])?;
+    assert_eq!(stdout, "");
+    Ok(())
+}
+
+// Run a minimal reactor program.
+#[test]
+fn minimal_reactor() -> Result<()> {
+    let wasm = build_wasm("tests/wasm/minimal-reactor.wat")?;
+    let stdout = run_wasmtime(&[wasm.path().to_str().unwrap(), "--disable-cache"])?;
+    assert_eq!(stdout, "");
+    Ok(())
+}
+
+// Attempt to call invoke on a command.
+#[test]
+fn command_invoke() -> Result<()> {
+    let wasm = build_wasm("tests/wasm/minimal-command.wat")?;
+    run_wasmtime(&[
+        "run",
+        wasm.path().to_str().unwrap(),
+        "--invoke",
+        "_start",
+        "--disable-cache",
+    ])?;
+    Ok(())
+}
+
+// Attempt to call invoke on a command.
+#[test]
+fn reactor_invoke() -> Result<()> {
+    let wasm = build_wasm("tests/wasm/minimal-reactor.wat")?;
+    run_wasmtime(&[
+        "run",
+        wasm.path().to_str().unwrap(),
+        "--invoke",
+        "_initialize",
+        "--disable-cache",
+    ])?;
+    Ok(())
+}
+
+// Run the greeter test, which runs a preloaded reactor and a command.
+#[test]
+fn greeter() -> Result<()> {
+    let wasm = build_wasm("tests/wasm/greeter_command.wat")?;
+    let stdout = run_wasmtime(&[
+        "run",
+        wasm.path().to_str().unwrap(),
+        "--disable-cache",
+        "--preload",
+        "reactor=tests/wasm/greeter_reactor.wat",
+    ])?;
+    assert_eq!(
+        stdout,
+        "Hello _initialize\nHello _start\nHello greet\nHello done\n"
+    );
+    Ok(())
+}
+
+// Run the greeter test, but this time preload a command.
+#[test]
+fn greeter_preload_command() -> Result<()> {
+    let wasm = build_wasm("tests/wasm/greeter_reactor.wat")?;
+    let stdout = run_wasmtime(&[
+        "run",
+        wasm.path().to_str().unwrap(),
+        "--disable-cache",
+        "--preload",
+        "reactor=tests/wasm/hello_wasi_snapshot1.wat",
+    ])?;
+    assert_eq!(stdout, "Hello _initialize\n");
+    Ok(())
+}
+
+// Run the greeter test, which runs a preloaded reactor and a command.
+#[test]
+fn greeter_preload_callable_command() -> Result<()> {
+    let wasm = build_wasm("tests/wasm/greeter_command.wat")?;
+    let stdout = run_wasmtime(&[
+        "run",
+        wasm.path().to_str().unwrap(),
+        "--disable-cache",
+        "--preload",
+        "reactor=tests/wasm/greeter_callable_command.wat",
+    ])?;
+    assert_eq!(stdout, "Hello _start\nHello callable greet\nHello done\n");
+    Ok(())
+}

tests/wasm/greeter_callable_command.wat

@@ -0,0 +1,23 @@
+;; Like greeter_reactor, but exports "_start" instead of "_initialize".
+(module
+  (import "wasi_snapshot_preview1" "fd_write"
+    (func $__wasi_fd_write (param i32 i32 i32 i32) (result i32)))
+  (func (export "_start")
+    (call $print (i32.const 32) (i32.const 22))
+  )
+  (func (export "greet")
+    (call $print (i32.const 64) (i32.const 21))
+  )
+  (func $print (param $ptr i32) (param $len i32)
+    (i32.store (i32.const 8) (local.get $len))
+    (i32.store (i32.const 4) (local.get $ptr))
+        (drop (call $__wasi_fd_write
+          (i32.const 1)
+          (i32.const 4)
+          (i32.const 1)
+          (i32.const 0)))
+  )
+  (memory (export "memory") 1)
+  (data (i32.const 32) "Hello callable _start\0a")
+  (data (i32.const 64) "Hello callable greet\0a")
+)

tests/wasm/greeter_command.wat

@@ -0,0 +1,22 @@
+(module
+  (import "wasi_snapshot_preview1" "fd_write"
+    (func $__wasi_fd_write (param i32 i32 i32 i32) (result i32)))
+  (import "reactor" "greet" (func $greet))
+  (func (export "_start")
+    (call $print (i32.const 32) (i32.const 13))
+    (call $greet)
+    (call $print (i32.const 64) (i32.const 11))
+  )
+  (func $print (param $ptr i32) (param $len i32)
+    (i32.store (i32.const 8) (local.get $len))
+    (i32.store (i32.const 4) (local.get $ptr))
+        (drop (call $__wasi_fd_write
+          (i32.const 1)
+          (i32.const 4)
+          (i32.const 1)
+          (i32.const 0)))
+  )
+  (memory (export "memory") 1)
+  (data (i32.const 32) "Hello _start\0a")
+  (data (i32.const 64) "Hello done\0a")
+)

tests/wasm/greeter_reactor.wat

@@ -0,0 +1,22 @@
+(module
+  (import "wasi_snapshot_preview1" "fd_write"
+    (func $__wasi_fd_write (param i32 i32 i32 i32) (result i32)))
+  (func (export "_initialize")
+    (call $print (i32.const 32) (i32.const 18))
+  )
+  (func (export "greet")
+    (call $print (i32.const 64) (i32.const 12))
+  )
+  (func $print (param $ptr i32) (param $len i32)
+    (i32.store (i32.const 8) (local.get $len))
+    (i32.store (i32.const 4) (local.get $ptr))
+        (drop (call $__wasi_fd_write
+          (i32.const 1)
+          (i32.const 4)
+          (i32.const 1)
+          (i32.const 0)))
+  )
+  (memory (export "memory") 1)
+  (data (i32.const 32) "Hello _initialize\0a")
+  (data (i32.const 64) "Hello greet\0a")
+)

tests/wasm/minimal-command.wat

@@ -0,0 +1,3 @@
+(module
+    (func (export "_start"))
+)

tests/wasm/minimal-reactor.wat

@@ -0,0 +1,3 @@
+(module
+    (func (export "_initialize"))
+)