[wasm] Basic WASI support.

Enabling WASI when building an instance sets up the default WASI
imports, and can optionally capture stdout/stderr. I'd like to set up
something similar for stdin, but Wasmer doesn't support that yet.

I also improved error handling in WasmRuntime by adding Wasmer's last
error to the thrown exceptions where appropriate.

Bug: #37882
Change-Id: I2d8546e878bcb43c7093490eac085aa62d318e96
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/167904
Reviewed-by: Ryan Macnak <[email protected]>
Commit-Queue: Liam Appelbe <[email protected]>

Author: liamappelbe

pkg/wasm/lib/src/module.dart

@@ -114,6 +114,7 @@ class WasmInstanceBuilder {
   late List<WasmImportDescriptor> _importDescs;
   Map<String, int> _importIndex;
   late Pointer<Pointer<WasmerExtern>> _imports;
+  Pointer<WasmerWasiEnv> _wasiEnv = nullptr;
 
   WasmInstanceBuilder(this._module) : _importIndex = {} {
     _importDescs = WasmRuntime().importDescriptors(_module._module);
@@ -174,14 +175,29 @@ class WasmInstanceBuilder {
     return this;
   }
 
+  /// Enable WASI and add the default WASI imports.
+  WasmInstanceBuilder enableWasi(
+      {bool captureStdout = false, bool captureStderr = false}) {
+    if (_wasiEnv != nullptr) {
+      throw Exception("WASI is already enabled.");
+    }
+    var runtime = WasmRuntime();
+    var config = runtime.newWasiConfig();
+    if (captureStdout) runtime.captureWasiStdout(config);
+    if (captureStderr) runtime.captureWasiStderr(config);
+    _wasiEnv = runtime.newWasiEnv(config);
+    runtime.getWasiImports(_module._store, _module._module, _wasiEnv, _imports);
+    return this;
+  }
+
   /// Build the module instance.
   WasmInstance build() {
     for (var i = 0; i < _importDescs.length; ++i) {
       if (_imports[i] == nullptr) {
         throw Exception("Missing import: ${_importDescs[i]}");
       }
     }
-    return WasmInstance(_module, _imports);
+    return WasmInstance(_module, _imports, _wasiEnv);
   }
 }
 
@@ -190,9 +206,13 @@ class WasmInstance {
   WasmModule _module;
   Pointer<WasmerInstance> _instance;
   Pointer<WasmerMemory>? _exportedMemory;
+  Pointer<WasmerWasiEnv> _wasiEnv;
+  Stream<List<int>>? _stdout;
+  Stream<List<int>>? _stderr;
   Map<String, WasmFunction> _functions = {};
 
-  WasmInstance(this._module, Pointer<Pointer<WasmerExtern>> imports)
+  WasmInstance(
+      this._module, Pointer<Pointer<WasmerExtern>> imports, this._wasiEnv)
       : _instance = WasmRuntime()
             .instantiate(_module._store, _module._module, imports) {
     var runtime = WasmRuntime();
@@ -210,7 +230,11 @@ class WasmInstance {
             name, f, runtime.getArgTypes(ft), runtime.getReturnType(ft));
       } else if (kind == WasmerExternKindMemory) {
         // WASM currently allows only one memory per module.
-        _exportedMemory = runtime.externToMemory(e);
+        var mem = runtime.externToMemory(e);
+        _exportedMemory = mem;
+        if (_wasiEnv != nullptr) {
+          runtime.wasiEnvSetMemory(_wasiEnv as Pointer<WasmerWasiEnv>, mem);
+        }
       }
     }
   }
@@ -228,6 +252,24 @@ class WasmInstance {
     }
     return WasmMemory._fromExport(_exportedMemory as Pointer<WasmerMemory>);
   }
+
+  /// Returns a stream that reads from stdout. To use this, you must enable WASI
+  /// when instantiating the module, and set captureStdout to true.
+  Stream<List<int>> get stdout {
+    if (_wasiEnv == nullptr) {
+      throw Exception("Can't capture stdout without WASI enabled.");
+    }
+    return _stdout ??= WasmRuntime().getWasiStdoutStream(_wasiEnv);
+  }
+
+  /// Returns a stream that reads from stderr. To use this, you must enable WASI
+  /// when instantiating the module, and set captureStderr to true.
+  Stream<List<int>> get stderr {
+    if (_wasiEnv == nullptr) {
+      throw Exception("Can't capture stderr without WASI enabled.");
+    }
+    return _stderr ??= WasmRuntime().getWasiStderrStream(_wasiEnv);
+  }
 }
 
 /// WasmMemory contains the memory of a WasmInstance.

pkg/wasm/lib/src/runtime.dart

@@ -6,6 +6,7 @@
 // To regenerate the file, use the following command
 // "generate_ffi_boilerplate.py".
 
+import 'dart:async';
 import 'dart:convert';
 import 'dart:ffi';
 import 'dart:io';
@@ -58,6 +59,15 @@ class WasmRuntime {
 
   DynamicLibrary _lib;
   late Pointer<WasmerEngine> _engine;
+  late WasmerWasiConfigInheritStderrFn _wasi_config_inherit_stderr;
+  late WasmerWasiConfigInheritStdoutFn _wasi_config_inherit_stdout;
+  late WasmerWasiConfigNewFn _wasi_config_new;
+  late WasmerWasiEnvDeleteFn _wasi_env_delete;
+  late WasmerWasiEnvNewFn _wasi_env_new;
+  late WasmerWasiEnvReadStderrFn _wasi_env_read_stderr;
+  late WasmerWasiEnvReadStdoutFn _wasi_env_read_stdout;
+  late WasmerWasiEnvSetMemoryFn _wasi_env_set_memory;
+  late WasmerWasiGetImportsFn _wasi_get_imports;
   late WasmerByteVecDeleteFn _byte_vec_delete;
   late WasmerByteVecNewFn _byte_vec_new;
   late WasmerByteVecNewEmptyFn _byte_vec_new_empty;
@@ -120,11 +130,11 @@ class WasmRuntime {
   late WasmerValtypeVecNewFn _valtype_vec_new;
   late WasmerValtypeVecNewEmptyFn _valtype_vec_new_empty;
   late WasmerValtypeVecNewUninitializedFn _valtype_vec_new_uninitialized;
+  late WasmerWasmerLastErrorLengthFn _wasmer_last_error_length;
+  late WasmerWasmerLastErrorMessageFn _wasmer_last_error_message;
 
   factory WasmRuntime() {
-    WasmRuntime inst = _inst ?? WasmRuntime._init();
-    _inst = inst;
-    return inst;
+    return _inst ??= WasmRuntime._init();
   }
 
   static String _getLibName() {
@@ -165,6 +175,29 @@ class WasmRuntime {
 
   WasmRuntime._init()
       : _lib = DynamicLibrary.open(path.join(_getLibDir(), _getLibName())) {
+    _wasi_config_inherit_stderr = _lib.lookupFunction<
+        NativeWasmerWasiConfigInheritStderrFn,
+        WasmerWasiConfigInheritStderrFn>('wasi_config_inherit_stderr');
+    _wasi_config_inherit_stdout = _lib.lookupFunction<
+        NativeWasmerWasiConfigInheritStdoutFn,
+        WasmerWasiConfigInheritStdoutFn>('wasi_config_inherit_stdout');
+    _wasi_config_new =
+        _lib.lookupFunction<NativeWasmerWasiConfigNewFn, WasmerWasiConfigNewFn>(
+            'wasi_config_new');
+    _wasi_env_delete =
+        _lib.lookupFunction<NativeWasmerWasiEnvDeleteFn, WasmerWasiEnvDeleteFn>(
+            'wasi_env_delete');
+    _wasi_env_new =
+        _lib.lookupFunction<NativeWasmerWasiEnvNewFn, WasmerWasiEnvNewFn>(
+            'wasi_env_new');
+    _wasi_env_read_stderr = _lib.lookupFunction<NativeWasmerWasiEnvReadStderrFn,
+        WasmerWasiEnvReadStderrFn>('wasi_env_read_stderr');
+    _wasi_env_read_stdout = _lib.lookupFunction<NativeWasmerWasiEnvReadStdoutFn,
+        WasmerWasiEnvReadStdoutFn>('wasi_env_read_stdout');
+    _wasi_env_set_memory = _lib.lookupFunction<NativeWasmerWasiEnvSetMemoryFn,
+        WasmerWasiEnvSetMemoryFn>('wasi_env_set_memory');
+    _wasi_get_imports = _lib.lookupFunction<NativeWasmerWasiGetImportsFn,
+        WasmerWasiGetImportsFn>('wasi_get_imports');
     _byte_vec_delete =
         _lib.lookupFunction<NativeWasmerByteVecDeleteFn, WasmerByteVecDeleteFn>(
             'wasm_byte_vec_delete');
@@ -329,6 +362,12 @@ class WasmRuntime {
             NativeWasmerValtypeVecNewUninitializedFn,
             WasmerValtypeVecNewUninitializedFn>(
         'wasm_valtype_vec_new_uninitialized');
+    _wasmer_last_error_length = _lib.lookupFunction<
+        NativeWasmerWasmerLastErrorLengthFn,
+        WasmerWasmerLastErrorLengthFn>('wasmer_last_error_length');
+    _wasmer_last_error_message = _lib.lookupFunction<
+        NativeWasmerWasmerLastErrorMessageFn,
+        WasmerWasmerLastErrorMessageFn>('wasmer_last_error_message');
 
     _engine = _engine_new();
   }
@@ -351,11 +390,7 @@ class WasmRuntime {
     free(dataPtr);
     free(dataVec);
 
-    if (modulePtr == nullptr) {
-      throw Exception("Wasm module compile failed");
-    }
-
-    return modulePtr;
+    return _checkNotEqual(modulePtr, nullptr, "Wasm module compile failed.");
   }
 
   List<WasmExportDescriptor> exportDescriptors(Pointer<WasmerModule> module) {
@@ -399,12 +434,8 @@ class WasmRuntime {
 
   Pointer<WasmerInstance> instantiate(Pointer<WasmerStore> store,
       Pointer<WasmerModule> module, Pointer<Pointer<WasmerExtern>> imports) {
-    var instancePtr = _instance_new(store, module, imports, nullptr);
-    if (instancePtr == nullptr) {
-      throw Exception("Wasm module instantiation failed");
-    }
-
-    return instancePtr;
+    return _checkNotEqual(_instance_new(store, module, imports, nullptr),
+        nullptr, "Wasm module instantiation failed.");
   }
 
   Pointer<WasmerExternVec> exports(Pointer<WasmerInstance> instancePtr) {
@@ -464,19 +495,13 @@ class WasmRuntime {
     limPtr.ref.max = maxPages ?? wasm_limits_max_default;
     var memType = _memorytype_new(limPtr);
     free(limPtr);
-    Pointer<WasmerMemory> memPtr = _memory_new(store, memType);
-
-    if (memPtr == nullptr) {
-      throw Exception("Failed to create memory");
-    }
-    return memPtr;
+    return _checkNotEqual(
+        _memory_new(store, memType), nullptr, "Failed to create memory.");
   }
 
   void growMemory(Pointer<WasmerMemory> memory, int deltaPages) {
-    var result = _memory_grow(memory, deltaPages);
-    if (result == 0) {
-      throw Exception("Failed to grow memory");
-    }
+    _checkNotEqual(
+        _memory_grow(memory, deltaPages), 0, "Failed to grow memory.");
   }
 
   int memoryLength(Pointer<WasmerMemory> memory) {
@@ -497,9 +522,89 @@ class WasmRuntime {
         store, funcType, func.cast(), env.cast(), finalizer.cast());
   }
 
+  Pointer<WasmerWasiConfig> newWasiConfig() {
+    var name = allocate<Uint8>();
+    name[0] = 0;
+    var config = _wasi_config_new(name);
+    free(name);
+    return _checkNotEqual(config, nullptr, "Failed to create WASI config.");
+  }
+
+  void captureWasiStdout(Pointer<WasmerWasiConfig> config) {
+    _wasi_config_inherit_stdout(config);
+  }
+
+  void captureWasiStderr(Pointer<WasmerWasiConfig> config) {
+    _wasi_config_inherit_stderr(config);
+  }
+
+  Pointer<WasmerWasiEnv> newWasiEnv(Pointer<WasmerWasiConfig> config) {
+    return _checkNotEqual(
+        _wasi_env_new(config), nullptr, "Failed to create WASI environment.");
+  }
+
+  void wasiEnvSetMemory(
+      Pointer<WasmerWasiEnv> env, Pointer<WasmerMemory> memory) {
+    _wasi_env_set_memory(env, memory);
+  }
+
+  void getWasiImports(Pointer<WasmerStore> store, Pointer<WasmerModule> mod,
+      Pointer<WasmerWasiEnv> env, Pointer<Pointer<WasmerExtern>> imports) {
+    _checkNotEqual(_wasi_get_imports(store, mod, env, imports), 0,
+        "Failed to fill WASI imports.");
+  }
+
+  Stream<List<int>> getWasiStdoutStream(Pointer<WasmerWasiEnv> env) {
+    return Stream.fromIterable(_WasiStreamIterable(env, _wasi_env_read_stdout));
+  }
+
+  Stream<List<int>> getWasiStderrStream(Pointer<WasmerWasiEnv> env) {
+    return Stream.fromIterable(_WasiStreamIterable(env, _wasi_env_read_stderr));
+  }
+
+  String _getLastError() {
+    var length = _wasmer_last_error_length();
+    var buf = allocate<Uint8>(count: length);
+    _wasmer_last_error_message(buf, length);
+    String message = utf8.decode(buf.asTypedList(length));
+    free(buf);
+    return message;
+  }
+
+  T _checkNotEqual<T>(T x, T y, String errorMessage) {
+    if (x == y) {
+      throw Exception("$errorMessage\n${_getLastError()}");
+    }
+    return x;
+  }
+
   static String getSignatureString(
       String name, List<int> argTypes, int returnType) {
     return "${wasmerValKindName(returnType)} $name" +
         "(${argTypes.map(wasmerValKindName).join(", ")})";
   }
 }
+
+class _WasiStreamIterator implements Iterator<List<int>> {
+  static final int _bufferLength = 1024;
+  Pointer<WasmerWasiEnv> _env;
+  Function _reader;
+  Pointer<Uint8> _buf = allocate<Uint8>(count: _bufferLength);
+  int _length = 0;
+  _WasiStreamIterator(this._env, this._reader) {}
+
+  bool moveNext() {
+    _length = _reader(_env, _buf, _bufferLength);
+    return true;
+  }
+
+  List<int> get current => _buf.asTypedList(_length);
+}
+
+class _WasiStreamIterable extends Iterable<List<int>> {
+  Pointer<WasmerWasiEnv> _env;
+  Function _reader;
+  _WasiStreamIterable(this._env, this._reader) {}
+  @override
+  Iterator<List<int>> get iterator => _WasiStreamIterator(_env, _reader);
+}